diff --git a/Pocketing.cpp b/Pocketing.cpp
index c8c25b4..965d277 100644
--- a/Pocketing.cpp
+++ b/Pocketing.cpp
@@ -9372,12 +9372,14 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, ICRVCOMPOPO
             return false ;
          if ( pSrf->GetChunkCount() == 0  ||  ! pSrf->IsValid())
             return true ;
-         int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf->Clone()) ;
-         m_pGeomDB->SetMaterial( b, BROWN) ;
+         //int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf->Clone()) ;
+         //m_pGeomDB->SetMaterial( b, BROWN) ;
       }
      // 2) PROIEZIONE CON GREZZO
       if ( m_bProjectRaw) {
-         if ( ! ProjectRaw( pSrf, vtTrasl, pStmRaw))
+        // recupero la Trimesh di partenza
+
+         if ( ! ProjectRaw( pSrf, vtTrasl, pStmRaw, nProp0))
             return false ;
          if ( pSrf->GetChunkCount() == 0  ||  ! pSrf->IsValid())
             return true ;
@@ -9631,9 +9633,6 @@ Pocketing::IntersSurfWithRaw( ISurfFlatRegion* pSfrPock, const ISurfTriMesh* pSt
       //m_pGeomDB->SetMaterial( L, LIME) ;
 
       SrfChunkDef.AddCurve( Release( pCrv_proj)) ; // aggiungo le curve proiettate
-
-
-
    }
 
    PtrOwner<ISurfFlatRegion> pSrfByCurves( SrfChunkDef.GetSurf()) ;
@@ -10280,31 +10279,60 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
       return false ;
 
   // recupero il box globale del grezzo
-   BBox3d b3Raw ; 
-   if( ! pStmRaw->GetBBox( GLOB_FRM, b3Raw)  ||  b3Raw.IsEmpty())
-      return false ;
+   //BBox3d b3Raw ; 
+   //if ( ! pStmRaw->GetBBox( GLOB_FRM, b3Raw)  ||  b3Raw.IsEmpty())
+   //   return false ;
 
   // creo la trimesh del box globale del grezzo e la taglio con il piano
-   PtrOwner<ISurfTriMesh> pStmRawBox( GetSurfTriMeshBox( b3Raw.GetDimX(), b3Raw.GetDimY(), b3Raw.GetDimZ())) ;
-   if ( IsNull( pStmRawBox)  ||  ! pStmRawBox->IsValid())
+   PtrOwner<ISurfTriMesh> pSrfRaw_clone( CloneSurfTriMesh( pStmRaw)) ;
+   if ( IsNull( pSrfRaw_clone))
       return false ;
-   pStmRawBox->Translate( b3Raw.GetMin() - ORIG) ; // è creata con ptMin nell'origine ( alla funzione passo le dimensioni)
-   if ( ! pStmRawBox->Cut( plProj, true))
+   //PtrOwner<ISurfTriMesh> pStmRawClone( GetSurfTriMeshBox( b3Raw.GetDimX(), b3Raw.GetDimY(), b3Raw.GetDimZ())) ;
+   //if ( IsNull( pStmRawBox)  ||  ! pStmRawBox->IsValid())
+   //   return false ;
+   //pStmRawBox->Translate( b3Raw.GetMin() - ORIG) ; // è creata con ptMin nell'origine ( alla funzione passo le dimensioni)
+   if ( ! pSrfRaw_clone->Cut( plProj, true))
       return false ;
-   if ( ! pStmRawBox->IsValid()  ||  pStmRawBox->GetTriangleCount() == 0) {
+   if ( ! pSrfRaw_clone->IsValid()  ||  pSrfRaw_clone->GetTriangleCount() == 0) {
       pSfrRawBoxProj->Clear() ;
       return true ;
    }
 
+  // recupero solo la parte di TriMesh contente la superificie da svuotare
+   PtrOwner<ISurfTriMesh> pStr_real( CreateSurfTriMesh()) ;
+   for ( int p = 0 ; p < pSrfRaw_clone->GetPartCount() ; ++ p) {
+      PtrOwner<ISurfTriMesh> pStm_raw_part( pSrfRaw_clone->ClonePart( p)) ;
+      POLYLINEVECTOR vPl ;
+      pStm_raw_part->GetLoops( vPl) ;
+      for ( int l = 0 ; l < ( int)vPl.size() ; ++ l) {
+         PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
+         pCompo->FromPolyLine( vPl[l]) ;
+         PtrOwner<ISurfFlatRegion> pSfr_H( CreateSurfFlatRegion()) ;
+         pSfr_H->AddExtLoop( Release( pCompo)) ;
+         if ( ! AreSameVectorApprox( pSfr_H->GetNormVersor(), pSfrPock->GetNormVersor()))
+            pSfr_H->Invert() ;
+         for ( int c = 0 ; c < pSfrPock->GetChunkCount() ; ++ c) {
+            if ( pSfr_H->GetChunkSimpleClassification( 0, *pSfrPock, c) != CCREGC_OUT) {
+               if ( pStr_real->GetTriangleCount() != 0)
+                  pStr_real->Add( *Release( pStm_raw_part)) ;
+               else
+                  pStr_real.Set( Release( pStm_raw_part)) ;
+               l = ( int)vPl.size() ;
+               break ;
+            }
+         }
+      }
+   }
+
   // creo una Regione piana a partire da tutte le curve
    PtrOwner<ISurfFlatRegion> pSfrProj( CreateSurfFlatRegion()) ;
    if( IsNull( pSfrProj))
       return false ;
 
   // proietto ora le curve, delle facce della superificie ottenuta, sul piano della svuotatura
-   for ( int f = 0 ; f < pStmRawBox->GetFacetCount() ; ++ f) {
+   for ( int f = 0 ; f < pStr_real->GetFacetCount() ; ++ f) {
       POLYLINEVECTOR vPL ;
-      pStmRawBox->GetFacetLoops( f, vPL) ;
+      pStr_real->GetFacetLoops( f, vPL) ;
       PtrOwner<ICurveComposite> pCrvBorder( CreateCurveComposite()) ; 
       if ( IsNull( pCrvBorder)  ||  ! pCrvBorder->FromPolyLine( vPL[0])) // le facce del box sono semplici
          return false ;
@@ -10332,7 +10360,7 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
 //----------------------------------------------------------------------------
 bool 
 Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
-                       const ISurfTriMesh* pStmRaw)
+                       const ISurfTriMesh* pStmRaw, int nId)
 {
   // controllo dei paramtri
    if ( pSrf == nullptr  ||  ! pSrf->IsValid()  ||  pSrf->GetChunkCount() == 0  ||  
@@ -10390,8 +10418,8 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
    pSrf->ToLoc( frLoc) ;
    pSrfOnPlPlus->ToLoc( frLoc) ;
 
-   //int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ;
-   //m_pGeomDB->SetMaterial( G, GREEN) ;
+   int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ;
+   m_pGeomDB->SetMaterial( G, GREEN) ;
 
   // creo la superificie finale da restituire
    SurfFlatRegionByContours pSrfAfterProj ;
@@ -10417,10 +10445,10 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
      // derivando da una trimesh, semplifico le curve ( specialmente per circonferenze)
       pCrvExtProj->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ;
       pCrvExtSfr->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ;
-      //int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtProj->Clone()) ;
-      //m_pGeomDB->SetMaterial( b, BLACK) ;
-      //int l = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtSfr->Clone()) ;
-      //m_pGeomDB->SetMaterial( l, LIME) ;
+      int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtProj->Clone()) ;
+      m_pGeomDB->SetMaterial( b, BLACK) ;
+      int l = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtSfr->Clone()) ;
+      m_pGeomDB->SetMaterial( l, LIME) ;
 
      // parametri
       Vector3d vtS ; Vector3d vtE ;
@@ -10444,6 +10472,7 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
             pCrvExtSfr->ChangeStartPoint( u) ;
          }
       }
+
      // se la curva ha tutti lati aperti, allora la imposto uguale alla proiezione del grezzo ed esco
       if ( ! bCEFound) { 
          pCrvExtSfr->Clear() ;
@@ -10455,172 +10484,220 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
             pCrvExtSfr->SetCurveTempProp( i, 1) ;
          pCrvExtSfr->SetExtrusion( vtExtr) ;
          pCrvExtSfr->SetThickness( dthick) ;
-         PtrOwner<ISurfFlatRegion> pSrf_h( CreateSurfFlatRegion()) ;
-         for ( int cc = 0 ; cc < pSrf->GetChunkCount() ; ++ cc) {
-            if ( cc != c)
-               pSrf_h->Add( *pSrf->CloneChunk( cc)) ;
-            else
-               pSrf_h->AddExtLoop( Release( pCrvExtSfr)) ;
-         }
-         pSrf->Clear() ;
-         pSrf->CopyFrom( pSrf_h) ;
-         pSrf->Translate( - vtTrasl) ;
-         return true ;
+         pCrvExtSfr->ToLoc( frLoc) ;
+         pSrfAfterProj.AddCurve( Release( pCrvExtSfr)) ;
+         //PtrOwner<ISurfFlatRegion> pSrf_h( CreateSurfFlatRegion()) ;
+         //for ( int cc = 0 ; cc < pSrf->GetChunkCount() ; ++ cc) {
+         //   if ( cc != c)
+         //      pSrf_h->Add( *pSrf->CloneChunk( cc)) ;
+         //   else
+         //      pSrf_h->AddExtLoop( Release( pCrvExtSfr)) ;
+         //}
+        // la proiezione con il grezzo potrebbe essere troppo grande
+         //pSrf->Clear() ;
+         //pSrfF->CopyFrom( pSrf_h) ;
+         //pSrf->Translate( - vtTrasl) ;
+         //return true ;
       }
+      else {
 
-      //int O = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtProj->Clone()) ;
-      //m_pGeomDB->SetMaterial( O, ORANGE) ;
 
-      //int R = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtSfr->Clone()) ;
-      //m_pGeomDB->SetMaterial( R, RED) ;
+         //int O = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtProj->Clone()) ;
+         //m_pGeomDB->SetMaterial( O, ORANGE) ;
 
-     // paramtri dU iniziali e finali del tratto di curva compreso tra le due rette
-      double dUS = EPS_SMALL ;
-      double dUE = EPS_SMALL ;
+         //int R = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtSfr->Clone()) ;
+         //m_pGeomDB->SetMaterial( R, RED) ;
 
-     // scorro tutte le curve del contorno, cercando di raccordare linearmente i tratti aperti
-     // con il bordo della proiezione ( in modo da estendere la superficie da svuotare
-      bool bIsLastOpen = false ;
-      for ( int c = 0 ; c < pCrvExtSfr->GetCurveCount()  ||  bIsLastOpen ; ++c) {
-        // recupero la curva c-esima
-         PtrOwner<ICurve> pCrv( pCrvExtSfr->GetCurve( bIsLastOpen ? 0 : c)->Clone()) ;
-         if ( IsNull( pCrv))
-            return false ;
-        // controllo se fa overlap con il bordo della proiezione e/o con il bordo di un isola aperta
-         int nStat1 = 0 ;
-         if ( ! CheckSimpleOverlap( pCrv, pCrvExtProj, nStat1, 5 * EPS_SMALL))
-            return false ;
-        // se lato aperto e non sulla curva esterna di proiezione...
-         if ( pCrv->GetTempProp() == 1  &&  nStat1 == 0) {
+        // paramtri dU iniziali e finali del tratto di curva compreso tra le due rette
+         double dUS = EPS_SMALL ;
+         double dUE = EPS_SMALL ;
 
-            ++ nCont ;
-            if ( nCont == 1) { // ... e primo lato aperto trovato
+        // scorro tutte le curve del contorno, cercando di raccordare linearmente i tratti aperti
+        // con il bordo della proiezione ( in modo da estendere la superficie da svuotare
+         bool bIsLastOpen = false ;
+         for ( int c = 0 ; c < pCrvExtSfr->GetCurveCount()  ||  bIsLastOpen ; ++c) {
+           // recupero la curva c-esima
+            PtrOwner<ICurve> pCrv( pCrvExtSfr->GetCurve( bIsLastOpen ? 0 : c)->Clone()) ;
+            if ( IsNull( pCrv))
+               return false ;
+           // controllo se fa overlap con il bordo della proiezione e/o con il bordo di un isola aperta
+            int nStat1 = 0 ;
+            if ( ! CheckSimpleOverlap( pCrv, pCrvExtProj, nStat1, 5 * EPS_SMALL))
+               return false ;
+           // se lato aperto e non sulla curva esterna di proiezione...
+            if ( pCrv->GetTempProp() == 1  &&  nStat1 == 0) {
+
+               ++ nCont ;
+               if ( nCont == 1) { // ... e primo lato aperto trovato
             
-              // creo la retta iniziale di raccordo
-               pCrvLS->Set( ptS, ptS + vtS * 10000) ;
-               //int CC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvLS->Clone()) ;
-               //m_pGeomDB->SetMaterial( CC, AQUA) ;
+                 // creo la retta iniziale di raccordo
+                  pCrvLS->Set( ptS, ptS + vtS * 10000) ;
+                  int CC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvLS->Clone()) ;
+                  m_pGeomDB->SetMaterial( CC, AQUA) ;
 
-              // imposto il parametro inziale sulla curva
-               pCrvExtSfr->GetParamAtPoint( ptS, dUS) ;
+                 // imposto il parametro inziale sulla curva
+                  pCrvExtSfr->GetParamAtPoint( ptS, dUS) ;
 
-              // la spezzo alla prima intersezione con il grezzo
-               CRVCVECTOR ccClass ;
-               if ( pSrfOnPlPlus->GetCurveClassification( *pCrvLS, EPS_SMALL, ccClass)  &&  
-                  ( ccClass[0].nClass == CRVC_IN  ||  ccClass[0].nClass == CRVC_ON_P  ||  ccClass[0].nClass == CRVC_ON_M)) {
-                  pCrvLS.Set( GetCurveLine( pCrvLS->CopyParamRange( 0, ccClass[0].dParE))) ;
-                  pCrvLS->SetTempProp( ccClass[0].nClass == CRVC_IN ? 0 : 1) ;
+                 // la spezzo alla prima intersezione con il grezzo
+                  CRVCVECTOR ccClass ;
+                  if ( pSrfOnPlPlus->GetCurveClassification( *pCrvLS, EPS_SMALL, ccClass)  &&  
+                     ( ccClass[0].nClass == CRVC_IN  ||  ccClass[0].nClass == CRVC_ON_P  ||  ccClass[0].nClass == CRVC_ON_M)) {
+                     pCrvLS.Set( GetCurveLine( pCrvLS->CopyParamRange( 0, ccClass[0].dParE))) ;
+                     pCrvLS->SetTempProp( ccClass[0].nClass == CRVC_IN ? 0 : 1) ;
+                  }
+                  else if (( int) ccClass.size() == 0) // retta iniziale degenere ad un punto
+                     nStat = 1 ;
+                  else { // esco ...
+                     pSrf->ToGlob( frLoc) ;
+                     pSrf->Translate( -vtTrasl) ;
+                     return true ;
+                  }
+
+                 // nel caso in cui la retta tocca la curva della svuotatura n volte...
+                  IntersCurveCurve intCCOpt( *pCrvLS, *pCrvExtSfr) ;
+                  if ( intCCOpt.GetCurveClassification( 0, EPS_SMALL, ccClass)  &&  ( int)ccClass.size() > 1) {
+                    // salto questa proiezione, proviene da isole aperte
+                     pSrf->ToGlob( frLoc) ;
+                     pSrf->Translate( -vtTrasl) ;
+                     return true ; 
+                  }
+
+                 // se ultima curva ...
+                  if ( c == pCrvExtSfr->GetCurveCount() - 1)
+                      bIsLastOpen = true ;
                }
-               else if (( int) ccClass.size() == 0) // retta iniziale degenere ad un punto
-                  nStat = 1 ;
-               else { // esco ...
-                  pSrf->ToGlob( frLoc) ;
-                  pSrf->Translate( -vtTrasl) ;
-                  return true ;
-               }
-
-              // nel caso in cui la retta tocca la curva della svuotatura n volte...
-               IntersCurveCurve intCCOpt( *pCrvLS, *pCrvExtSfr) ;
-               if ( intCCOpt.GetCurveClassification( 0, EPS_SMALL, ccClass)  &&  ( int)ccClass.size() > 1) {
-                 // salto questa proiezione, proviene da isole aperte
-                  pSrf->ToGlob( frLoc) ;
-                  pSrf->Translate( -vtTrasl) ;
-                  return true ; 
-               }
-
-              // se ultima curva ...
-               if ( c == pCrvExtSfr->GetCurveCount() - 1)
-                   bIsLastOpen = true ;
             }
-         }
-         else {
-           // se è un chiuso dopo n lati aperti non sulla proiezione...
-            if ( nCont > 0) {
+            else {
+              // se è un chiuso dopo n lati aperti non sulla proiezione...
+               if ( nCont > 0) {
             
-               pCrv->GetStartDir( vtE) ; vtE = -vtE ;
-               pCrv->GetStartPoint( ptE) ;
+                  pCrv->GetStartDir( vtE) ; vtE = -vtE ;
+                  pCrv->GetStartPoint( ptE) ;
 
-             // setto la retta finale di raccordo
-               pCrvLE->Set( ptE, ptE + vtE * 10000) ;
-               //int BB = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvLE->Clone()) ;
-               //m_pGeomDB->SetMaterial( BB, BLUE) ;
+                // setto la retta finale di raccordo
+                  pCrvLE->Set( ptE, ptE + vtE * 10000) ;
+                  int BB = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvLE->Clone()) ;
+                  m_pGeomDB->SetMaterial( BB, BLUE) ;
 
-              // imposto il parametro finale sulla curva
-               pCrvExtSfr->GetParamAtPoint( ptE, dUE) ;
+                 // imposto il parametro finale sulla curva
+                  pCrvExtSfr->GetParamAtPoint( ptE, dUE) ;
 
-              // controllo se il tratto di curva esterno alla superificie da svuotare
-               PtrOwner<ICurveComposite> pCrvToCheck( GetCurveComposite( pCrvExtSfr->CopyParamRange( dUS, dUE))) ;
-               if ( ! IsNull( pCrvToCheck)  &&  pCrvToCheck->IsValid()) {
-                  CRVCVECTOR ccClass_c ;
-                  if ( pSrf->GetCurveClassification( *pCrvToCheck, EPS_SMALL, ccClass_c)) {
-                     bool bIsPartOut = false ;
-                     for ( int _c = 0 ; _c < ( int)ccClass_c.size() && ! bIsPartOut ; ++ _c) {
-                        if ( ccClass_c[_c].nClass == CRVC_OUT)
-                           bIsPartOut = true ;
-                     }
-                    // se la curva trovata non è esterna alla superificie ( caso in cui il grezzo sia interno alla
-                    // curva di svuotatura, allora non allargo la sua proiezione al suo box)
-                     if ( ! bIsPartOut) {
-                        nCont = 0 ;
-                        continue ;
+                 // controllo se il tratto di curva esterno alla superificie da svuotare
+                  PtrOwner<ICurveComposite> pCrvToCheck( GetCurveComposite( pCrvExtSfr->CopyParamRange( dUS, dUE))) ;
+                  if ( ! IsNull( pCrvToCheck)  &&  pCrvToCheck->IsValid()) {
+                     CRVCVECTOR ccClass_c ;
+                     if ( pSrf->GetCurveClassification( *pCrvToCheck, EPS_SMALL, ccClass_c)) {
+                        bool bIsPartOut = false ;
+                        for ( int _c = 0 ; _c < ( int)ccClass_c.size() && ! bIsPartOut ; ++ _c) {
+                           if ( ccClass_c[_c].nClass == CRVC_OUT)
+                              bIsPartOut = true ;
+                        }
+                       // se la curva trovata non è esterna alla superificie ( caso in cui il grezzo sia interno alla
+                       // curva di svuotatura, allora non allargo la sua proiezione al suo box)
+                        if ( ! bIsPartOut) {
+                           nCont = 0 ;
+                           continue ;
+                        }
                      }
                   }
-               }
 
-              // la spezzo alla prima intersezione con il grezzo
-               CRVCVECTOR ccClass ;
-               if ( pSrfOnPlPlus->GetCurveClassification( *pCrvLE, EPS_SMALL, ccClass)  &&
-                  ( ccClass[0].nClass == CRVC_IN  ||  ccClass[0].nClass == CRVC_ON_P  ||  ccClass[0].nClass == CRVC_ON_M)) {
-                  pCrvLE.Set( GetCurveLine( pCrvLE->CopyParamRange( 0, ccClass[0].dParE))) ; 
-                  pCrvLE->SetTempProp( ccClass[0].nClass == CRVC_IN ? 0 : 1) ;
-               }
-               else if (( int) ccClass.size() == 0) // retta finale degenere ad un punto
-                  nStat = nStat == 1 ? 3 : 2 ;
-               else { // esco...
-                  pSrf->ToGlob( frLoc) ;
-                  pSrf->Translate( -vtTrasl) ;
-                  return true ;  // migliorare
-               }
+                 // la spezzo alla prima intersezione con il grezzo
+                  CRVCVECTOR ccClass ;
+                  if ( pSrfOnPlPlus->GetCurveClassification( *pCrvLE, EPS_SMALL, ccClass)  &&
+                     ( ccClass[0].nClass == CRVC_IN  ||  ccClass[0].nClass == CRVC_ON_P  ||  ccClass[0].nClass == CRVC_ON_M)) {
+                     pCrvLE.Set( GetCurveLine( pCrvLE->CopyParamRange( 0, ccClass[0].dParE))) ; 
+                     pCrvLE->SetTempProp( ccClass[0].nClass == CRVC_IN ? 0 : 1) ;
+                  }
+                  else if (( int) ccClass.size() == 0) // retta finale degenere ad un punto
+                     nStat = nStat == 1 ? 3 : 2 ;
+                  else { // esco...
+                     pSrf->ToGlob( frLoc) ;
+                     pSrf->Translate( -vtTrasl) ;
+                     return true ;  // migliorare
+                  }
 
-              // nel caso in cui la retta tocca la curva della svuotatura n volte...
-               IntersCurveCurve intCCOpt( *pCrvLE, *pCrvExtSfr) ;
-               if ( intCCOpt.GetCurveClassification( 0, EPS_SMALL, ccClass)  &&  ( int)ccClass.size() > 1) {
-                 // salto questa proiezione, proviene da isole aperte
-                  pSrf->ToGlob( frLoc) ;
-                  pSrf->Translate( -vtTrasl) ;
-                  return true ;
-               }
+                 // nel caso in cui la retta tocca la curva della svuotatura n volte...
+                  IntersCurveCurve intCCOpt( *pCrvLE, *pCrvExtSfr) ;
+                  if ( intCCOpt.GetCurveClassification( 0, EPS_SMALL, ccClass)  &&  ( int)ccClass.size() > 1) {
+                    // salto questa proiezione, proviene da isole aperte
+                     pSrf->ToGlob( frLoc) ;
+                     pSrf->Translate( -vtTrasl) ;
+                     return true ;
+                  }
 
-               int nCrv = pCrvExtSfr->GetCurveCount() ; // memorizzo il numero di curve attuali
-               PNTVECTOR vPtTan{ ptS, ptE} ;
-               if ( ! AjustCurveForProjRawOnFace( pCrvLS, pCrvLE, pCrvExtProj, pCrvExtSfr, nStat, vPtTan, pSrfOnPlPlus))
-                  return false ;
-               c += pCrvExtSfr->GetCurveCount() - nCrv - 1 ; // aumento numero delle curve
-               nStat = 0 ; // ritorno al caso base per nStat
+                  int nCrv = pCrvExtSfr->GetCurveCount() ; // memorizzo il numero di curve attuali
+                  PNTVECTOR vPtTan{ ptS, ptE} ;
+                  if ( ! AjustCurveForProjRawOnFace( pCrvLS, pCrvLE, pCrvExtProj, pCrvExtSfr, nStat, vPtTan, pSrfOnPlPlus))
+                     return false ;
+                  c += pCrvExtSfr->GetCurveCount() - nCrv - 1 ; // aumento numero delle curve
+                  nStat = 0 ; // ritorno al caso base per nStat
         
+               }
+               nCont = 0 ;
+               pCrv->GetEndDir( vtS) ;
+               pCrv->GetEndPoint( ptS) ;
+               if ( bIsLastOpen)
+                  bIsLastOpen = false ;
             }
-            nCont = 0 ;
-            pCrv->GetEndDir( vtS) ;
-            pCrv->GetEndPoint( ptS) ;
-            if ( bIsLastOpen)
-               bIsLastOpen = false ;
          }
-      }
 
-     // aggiungo la nuova curva esterna ricavata e le isole
-      pCrvExtSfr->SetExtrusion( vtExtr) ;
-      pCrvExtSfr->SetThickness( dthick) ;
-      pSrfAfterProj.AddCurve( Release( pCrvExtSfr)) ;
-      for ( int i = 0 ; i < ( int)vCrvIsl.size() ; ++ i) {
-         vCrvIsl[i]->SetExtrusion( vtExtr) ;
-         vCrvIsl[i]->SetThickness( dthick) ;
-         pSrfAfterProj.AddCurve( Release( vCrvIsl[i])) ;
+        // aggiungo la nuova curva esterna ricavata e le isole
+         pCrvExtSfr->SetExtrusion( vtExtr) ;
+         pCrvExtSfr->SetThickness( dthick) ;
+         pSrfAfterProj.AddCurve( Release( pCrvExtSfr)) ;
+         for ( int i = 0 ; i < ( int)vCrvIsl.size() ; ++ i) {
+            vCrvIsl[i]->SetExtrusion( vtExtr) ;
+            vCrvIsl[i]->SetThickness( dthick) ;
+            pSrfAfterProj.AddCurve( Release( vCrvIsl[i])) ;
+         }
       }
    }
 
+  // Superificie finale
+   PtrOwner<ISurfFlatRegion> pSrfF( CreateSurfFlatRegion()) ;
+   pSrfF.Set( pSrfAfterProj.GetSurf()) ;
+
   // ritorno la nuova superificie
    pSrf->Clear() ;
-   PtrOwner<ISurfFlatRegion> pSrfF( pSrfAfterProj.GetSurf()) ;
+
+  // se la superificie da svuotare viene da una Trimesh, taglio quest'ultima con la Trimesh Originale
+   if ( m_pGeomDB->GetGeoType( nId) == SRF_TRIMESH) {
+
+      ICRVCOMPOPOVECTOR vCrvAll ;
+      for ( int c = 0 ; c < ( int)pSrfF->GetChunkCount() ; ++ c)
+         vCrvAll.emplace_back( GetCurveComposite( pSrfF->GetLoop( c, 0))) ;
+      for ( int c = 0 ; c < ( int)pSrfF->GetChunkCount() ; ++ c) 
+         for ( int l = 1 ; l < ( int)pSrfF->GetLoopCount( c) ; ++ l)
+            vCrvAll.emplace_back( GetCurveComposite( pSrfF->GetLoop( c, l))) ;
+
+      PtrOwner<ISurfTriMesh> pStm_orig( CloneSurfTriMesh( m_pGeomDB->GetGeoObj( nId))) ;
+      Frame3d frLoc1 ; m_pGeomDB->GetGlobFrame( nId, frLoc1) ;
+      pStm_orig->LocToLoc( frLoc1, frLoc) ;
+      PtrOwner<ISurfTriMesh> pSrfF_tm( CloneSurfTriMesh( pSrfF->GetAuxSurf())) ;
+
+      SurfFlatRegionByContours pSrf_HH ;
+
+      if ( pSrfF_tm->CutWithOtherSurf( *pStm_orig, false, true)) {
+        // estraggo tutti i loops
+         POLYLINEVECTOR vPl ;
+         pSrfF_tm->GetLoops( vPl) ;
+         for ( int ll = 0 ; ll < ( int)vPl.size() ; ++ ll) {
+            PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
+            pCrvCompo->FromPolyLine( vPl[ll]) ;
+            for ( int u = 0 ; u < pCrvCompo->GetCurveCount() ; ++ u) {
+               for ( int j = 0 ; j < ( int)vCrvAll.size() ; ++ j) {
+                  int nStat = -1 ;
+                  pCrvCompo->SetCurveTempProp( u, 0, 0) ;
+                  if ( SetTmpPropByOverlap( pCrvCompo, u, vCrvAll[j], nStat)  &&  nStat == 1)
+                     break ;
+               }
+            }
+            pSrf_HH.AddCurve( Release( pCrvCompo)) ;
+         }
+         pSrfF.Set( pSrf_HH.GetSurf()) ;
+      }
+   }
+
    pSrf->CopyFrom( pSrfF) ;
    pSrf->ToGlob( frLoc) ;
 
diff --git a/Pocketing.h b/Pocketing.h
index bffa2ab..64c28a5 100644
--- a/Pocketing.h
+++ b/Pocketing.h
@@ -98,7 +98,7 @@ class Pocketing : public Machining
       bool IntersSurfWithRaw( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm, const Vector3d& vtTrasl,
                               bool& bIsChanged, double dAreaToll = 500 * EPS_SMALL, bool bInVsOut = true,
                               bool bRemoveSmallRawParts = false) ;
-      bool ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrals, const ISurfTriMesh* pSrfProjRaw) ;
+      bool ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrals, const ISurfTriMesh* pSrfProjRaw, int nId) ;
       bool AdjustAngleForProjectedFace( const ISurfFlatRegion* pSrfFaceT, ICurveComposite* pCrvEdgeBorder, double dAngle) ;
       bool SetOpenOrCloseEdge( ISurfFlatRegion* pSrfTP, const ISurfFlatRegion* pSrfO) ;
       bool GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw, ISurfFlatRegion* pSfrRawBoxProj) ;