diff --git a/Pocketing.cpp b/Pocketing.cpp
index 8a1ffc0..20b9991 100644
--- a/Pocketing.cpp
+++ b/Pocketing.cpp
@@ -8875,10 +8875,25 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
    pCrvOpen_clone->GetParamAtLength( dRad, dUS) ;
    pCrvOpen_clone->GetParamAtLength( dLen - dRad, dUE) ;
    pCrvOpen_clone->TrimStartEndAtParam( dUS, dUE) ;
+   int black = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvOpen_clone->Clone()) ;               //
+   m_pGeomDB->SetMaterial( black, BLACK) ;
    // 4) Creo regione squadrata da questa curva
    PtrOwner<ISurfFlatRegion> pSfrInc( GetSurfFlatRegionFromFatCurve( Release( pCrvOpen_clone), dRad, true, false)) ;
-   if ( IsNull( pSfrInc)  ||  ! pSfrInc->IsValid())
-      return false ;
+   if ( IsNull( pSfrInc)  ||  ! pSfrInc->IsValid()) {
+      //return false ;
+      Point3d ptS ; pCrvOpen->GetEndPoint( ptS) ;
+      PtrOwner<ICurveComposite> pCrv_CompoHelp( CreateCurveComposite()) ;
+      pCrv_CompoHelp->AddCurve( pCrvOpen->Clone()) ;
+      pCrv_CompoHelp->AddLine( ptS) ;
+      PtrOwner<ICurveComposite> pCrvOpenOffs_Clone( CloneCurveComposite( pCrvOpenOffs)) ;
+      pCrvOpenOffs_Clone->Invert() ;
+      pCrv_CompoHelp->AddCurve( Release( pCrvOpenOffs_Clone)) ;
+      pCrv_CompoHelp->Close() ;
+      pSfrInc.Set( CreateSurfFlatRegion()) ;
+      pSfrInc->AddExtLoop( Release( pCrv_CompoHelp)) ;
+      if ( IsNull( pSfrInc)  ||  !pSfrInc->IsValid())
+         return false ;
+   }
    //int black = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrInc->Clone()) ;               //
    //m_pGeomDB->SetMaterial( black, BLACK) ;                                                      //
 
@@ -8978,8 +8993,8 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
 
    PtrOwner<ISurfFlatRegion> pSrfInc_toDraw( CloneSurfFlatRegion( pSfrInc)) ;
    pSrfInc_toDraw->Translate( vtTrasl) ;
-   //int brown1 = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfInc_toDraw->Clone()) ;        //
-   //m_pGeomDB->SetMaterial( brown1, BROWN) ;
+   int brown1 = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfInc_toDraw->Clone()) ;        //
+   m_pGeomDB->SetMaterial( brown1, BROWN) ;
 
 
   // recupero il Grezzo e sottraggo tutto ciò che sta nella regione
@@ -8991,8 +9006,8 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
 
    PtrOwner<ISurfFlatRegion> pSrfInc_toDraw1( CloneSurfFlatRegion( pSfrInc)) ;
    pSrfInc_toDraw1->Translate( vtTrasl) ;
-   //int brown = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfInc_toDraw1->Clone()) ;        //
-   //m_pGeomDB->SetMaterial( brown, YELLOW) ;
+   int brown = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfInc_toDraw1->Clone()) ;        //
+   m_pGeomDB->SetMaterial( brown, YELLOW) ;
 
   // RECUPERO DELLA CURVA DI BORDO ESTERNA DA AGGIUNGERE ALLA SVUOTATURA
    PtrOwner<ICurveComposite> pCrvNewBorder( GetCurveComposite( pSfrInc->GetLoop( 0, 0))) ;
@@ -10257,11 +10272,24 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
    if ( ! plProj.IsValid())
       return false ;
 
+  // Offsetto la regione della quantità richiesta
+   PtrOwner<ISurfFlatRegion> pSrf_Pock_Clone(CloneSurfFlatRegion( pSfrPock)) ;
+   if ( ! pSrf_Pock_Clone->Offset( m_dMaxLenRawProj, ICurve::OFF_CHAMFER))
+      return false ;
+   CICURVEPVECTOR vCrv ;
+   for ( int c = 0 ; c < pSrf_Pock_Clone->GetChunkCount() ; ++ c)
+      for ( int l = 0 ; l < pSrf_Pock_Clone->GetLoopCount( c) ; ++ l)
+         vCrv.emplace_back( pSrf_Pock_Clone->GetLoop( c, l)) ;
+
+   PtrOwner<ISurfTriMesh> pSrf_ForCuttingRaw( GetSurfTriMeshByRegionExtrusion( vCrv, vtNorm * 1000)) ;
+
   // creo la Trimesh del grezzo e la taglio con il piano
    PtrOwner<ISurfTriMesh> pSrfRaw_clone( CloneSurfTriMesh( pStmRaw)) ;
    if ( IsNull( pSrfRaw_clone))
       return false ;
-   if ( ! pSrfRaw_clone->Cut( plProj, true))
+   //if ( ! pSrfRaw_clone->Cut( plProj, true))
+   //   return false ;
+   if ( ! pSrfRaw_clone->CutWithOtherSurf( *pSrf_ForCuttingRaw, true, true))
       return false ;
    if ( ! pSrfRaw_clone->IsValid()  ||  pSrfRaw_clone->GetTriangleCount() == 0) {
       pSfrRawBoxProj->Clear() ;
@@ -10297,11 +10325,11 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
 
   // creo una Regione piana a partire da tutte le curve ( superificie che restituisco)
    PtrOwner<ISurfFlatRegion> pSfrProj( CreateSurfFlatRegion()) ;
-   if( IsNull( pSfrProj))
+   if ( IsNull( pSfrProj))
       return false ;
 
-   //int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStr_real->Clone()) ;
-   //m_pGeomDB->SetMaterial( g, GREEN) ;
+   int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStr_real->Clone()) ;
+   m_pGeomDB->SetMaterial( g, GREEN) ;
 
   // Proietto ora le curve, delle facce della superificie ottenuta, sul piano della svuotatura
    for ( int f = 0 ; f < pStr_real->GetFacetCount() ; ++ f) {
@@ -10324,15 +10352,66 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
          Plane3d plCheck ;
          if ( ! pCrvProjFacef->IsClosed()  ||  ! pCrvProjFacef->GetArea( plCheck, dArea)  ||  dArea <= EPS_SMALL)
             continue ;
+
+        // aggiungo questa curva solo se :
+         bool bNeedProj = false ;
+        // 1) cerco se ho dei tratti sulla curva di proiezione che fanno overlap con il bordo della superificie da svuoatare
+         for ( int cc_ = 0 ; cc_ < pSfr->GetChunkCount()  &&  !bNeedProj ; ++ cc_) {
+           // recupero il bordo esterno
+            PtrOwner<ICurveComposite> pCrvEB_Ccc_( GetCurveComposite( pSfr->GetLoop( cc_, 0))) ;
+           // converto la curva di proiezione in composita
+            PtrOwner<ICurveComposite> pCrvCompoProj_( CreateCurveComposite()) ;
+            pCrvCompoProj_->AddCurve( pCrvProjFacef->Clone()) ;
+           // 1a) controllo se una delle sue curva aperte overlappa la proizione attuale
+            for ( int uu_ = 0 ; uu_ < pCrvEB_Ccc_->GetCurveCount()  && !bNeedProj ; ++ uu_) {
+               int nTmpProp_uu_ = 0 ;
+               if ( pCrvEB_Ccc_->GetCurveTempProp( uu_, nTmpProp_uu_, 0)  &&  nTmpProp_uu_ == 1) {
+                 int nStat_uu_ = 0 ;
+                 const ICurve* pCrv_c = pCrvEB_Ccc_->GetCurve( uu_) ;
+                 if ( CheckSimpleOverlap( pCrv_c, pCrvCompoProj_, nStat_uu_, 50 * EPS_SMALL)  &&  nStat_uu_ == 1)
+                    bNeedProj = true ;
+               }
+            }
+           // 1b) controllo se una delle curve della proiezione attuale fa overlap con una curva aperta della superificie originale
+            for ( int uu_ = 0 ; uu_ < pCrvCompoProj_->GetCurveCount()  && !bNeedProj ; ++ uu_) {
+               for ( int uu__ = 0 ; uu__ < pCrvEB_Ccc_->GetCurveCount()  && !bNeedProj ; ++ uu__) {
+                  int nTmpProp_uu__ = 0 ;
+                  if ( pCrvEB_Ccc_->GetCurveTempProp( uu__, nTmpProp_uu__, 0)  &&  nTmpProp_uu__ == 1) {
+                     int nStat_uu__ = 0 ;
+                     const ICurve* pCrv_c = pCrvCompoProj_->GetCurve( uu_) ;
+                     PtrOwner<ICurveComposite> pCrvCompo__( CreateCurveComposite()) ;
+                     const ICurve* pCrv_Ccc_uu__clone = pCrvEB_Ccc_->GetCurve( uu__) ;
+                     pCrvCompo__->AddCurve( pCrv_Ccc_uu__clone->Clone()) ;
+                     if ( CheckSimpleOverlap( pCrv_c, pCrvCompo__, nStat_uu__, 50 * EPS_SMALL)  &&  nStat_uu__ == 1)
+                        bNeedProj = true ;
+                  }
+               }
+            }
+         }
+         if ( ! bNeedProj)
+            continue ;
+
+         // 2) ha almeno una sottocurva sovrapposta ad un lato aperto della superfcicie originale
+         CRVCVECTOR ccClass ;
+         if ( pSfrPock->GetCurveClassification( *pCrvProjFacef, EPS_SMALL, ccClass)) {
+            for ( int j = 0 ; j < ( int)ccClass.size()  && bNeedProj ; ++ j) {
+               if ( ccClass[j].nClass == CRVC_IN)
+                  bNeedProj = false ;
+            }
+         }
+         if ( ! bNeedProj)
+            continue ;
+
+
          if ( l == 0)
             pSfr_ff->AddExtLoop( pCrvProjFacef->Clone()) ;
          else
             pSfr_ff->AddIntLoop( pCrvProjFacef->Clone()) ;
 
-         if ( IsNull( pSfr_ff)  ||  ! pSfr_ff->IsValid()) {
+         //if ( IsNull( pSfr_ff)  ||  ! pSfr_ff->IsValid()) {
             int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvProjFacef->Clone()) ;
             m_pGeomDB->SetMaterial( r, RED) ;
-         }
+         //}
 
       }
       if ( IsNull( pSfr_ff)  ||  ! pSfr_ff->IsValid())
@@ -10348,7 +10427,7 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
   // Recupero la regione e controllo la validità
    //pSfrProj.Set( pSrf_Help.GetSurf()) ;
    if ( IsNull( pSfrProj)  ||  ! pSfrProj->IsValid())
-      return false ;
+      return true ;
 
   // controllo che le normali siano coerenti
    Vector3d vtN_check = pSfrProj->GetNormVersor() ;
@@ -10421,10 +10500,13 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
    if ( IsNull( pSrfOnPlPlus)  ||  ! GetProjStmBoxOnSfr( pSrf_clone, pStmRaw, pSrfOnPlPlus))
       return false ;
    if ( IsNull( pSrfOnPlPlus)  ||  ! pSrfOnPlPlus->IsValid()  ||  pSrfOnPlPlus->GetChunkCount() == 0) {
-      pSrf->Clear() ;  // se non ho grezzo sopra alla superificie, allora non devo svuotare nulla ( non dovrebbe capitare)
+      //pSrf->Clear() ;  // se non ho grezzo sopra alla superificie, allora non devo svuotare nulla ( non dovrebbe capitare)
       return true ;
    }
 
+   int r = m_pGeomDB->AddGeoObj(GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ;
+   m_pGeomDB->SetMaterial( r, RED) ;
+
   // Creo la superificie finale da restituire ( come unione di tutti i nuovi chunks)
    SurfFlatRegionByContours pSrfAfterProj ;
 
@@ -10445,6 +10527,9 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
    if ( ! pStmExtrusionProj_Chunkcc->IsValid()  ||  pStmExtrusionProj_Chunkcc->GetTriangleCount() == 0)
       return true ;
 
+   int o = m_pGeomDB->AddGeoObj(GDB_ID_NULL, GDB_ID_ROOT, pStmExtrusionProj_Chunkcc->Clone()) ;
+   m_pGeomDB->SetMaterial( o, ORANGE) ;
+
   // Modifico la curva esterna, estendola presso i lati aperti
    for ( int c = 0 ; c < pSrf_clone->GetChunkCount() ; ++ c) {
      // Controllo se per questo chunk serve proiettare
@@ -10479,8 +10564,8 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
          pSrf_byOE->AddExtLoop( pCrvExtPock_Chunk_c->Clone()) ;
         // Tengo solo le parti nuove all'interno della proizione originaria
 
-         //int PU = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_byOE->Clone()) ;
-         //m_pGeomDB->SetMaterial( PU, PURPLE) ;
+         int PU = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_byOE->Clone()) ;
+         m_pGeomDB->SetMaterial( PU, PURPLE) ;
          //int AC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ;
          //m_pGeomDB->SetMaterial( AC, AQUA) ;