diff --git a/SurfBezier.cpp b/SurfBezier.cpp
index 4ae0115..c1b6810 100644
--- a/SurfBezier.cpp
+++ b/SurfBezier.cpp
@@ -41,6 +41,7 @@
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkIntervals.h"
+#include "/EgtDev/Include/EGkSurfAux.h"
 #define EIGEN_NO_IO
 #include "/EgtDev/Extern/Eigen/Dense"
 
@@ -50,7 +51,8 @@
 #define SAVERULEDGUIDEDISO 0
 #define SAVEMATCHCURVES 0
 #define SAVEFAILEDTREE 0
-#if SAVEFAILEDTRIANGULATION  || SAVEREBUILTISO || SAVERULEDISO || SAVERULEDGUIDEDISO  ||  SAVEMATCHCURVES  || SAVEFAILEDTREE
+#define SAVELIMITSURF 0
+#if SAVEFAILEDTRIANGULATION  || SAVEREBUILTISO || SAVERULEDISO || SAVERULEDGUIDEDISO  ||  SAVEMATCHCURVES  || SAVEFAILEDTREE  || SAVELIMITSURF
    #include "/EgtDev/Include/EGkGeoObjSave.h"
 #endif
 
@@ -6566,3 +6568,130 @@ SurfBezier::SwapParameters( void)
 
    return true ;
 }
+
+//----------------------------------------------------------------------------
+bool
+SurfBezier::LimitSurfToTrimmedRegion( void)
+{
+   if ( ! m_bTrimmed  ||  m_pTrimReg == nullptr)
+      return true ;
+
+   double dParamArea = m_nSpanU * m_nSpanV * SBZ_TREG_COEFF * SBZ_TREG_COEFF ;
+   double dTrimmedArea = 0 ; m_pTrimReg->GetArea( dTrimmedArea) ;
+
+   // se la parte trimmata è molto inferiore alla superficie originale limito la superficie alla parte trimmata
+   if ( dTrimmedArea / dParamArea < 0.01  ||  true) {
+      BBox3d bboxTrim ; m_pTrimReg->GetLocalBBox( bboxTrim) ;
+      // estraggo tutte le isocurve in U e le limito a poco più del box della regione trimmata
+      double dMinU = bboxTrim.GetMin().x - 10 ; dMinU = Clamp( dMinU, 0., double(m_nSpanU * SBZ_TREG_COEFF)) ;
+      double dMaxU = bboxTrim.GetMax().x + 10 ; dMaxU = Clamp( dMaxU, 0., double(m_nSpanU * SBZ_TREG_COEFF)) ;
+      double dMinV = bboxTrim.GetMin().y - 10 ; dMinV = Clamp( dMinV, 0., double(m_nSpanV * SBZ_TREG_COEFF)) ;
+      double dMaxV = bboxTrim.GetMax().y + 10 ; dMaxV = Clamp( dMaxV, 0., double(m_nSpanV * SBZ_TREG_COEFF)) ;
+      int nV = m_nSpanV * m_nDegV + 1 ;
+      int nU = m_nSpanU * m_nDegU + 1 ;
+      vector<CurveComposite> vIsoU ; vIsoU.reserve( nV) ;
+      for ( int i = 0 ; i < nV ; ++i) {
+         vIsoU.emplace_back() ;
+         bool bOk = false ;
+         for ( int k = 0 ; k < m_nSpanU ; ++k) {
+            CurveBezier cbIsoU ;
+            cbIsoU.Init( m_nDegU, m_bRat) ;
+            for ( int j = 0 ; j <= m_nDegU ; ++j) {
+               if ( ! m_bRat)
+                  cbIsoU.SetControlPoint( j, GetControlPoint( k * m_nDegU + j, i, &bOk)) ;
+               else {
+                  double dW = GetControlWeight( j, i, &bOk) ;
+                  cbIsoU.SetControlPoint( j, GetControlPoint( k * m_nDegU + j, i, &bOk), dW) ;
+               }
+            }
+            vIsoU.back().AddCurve( cbIsoU) ;
+         }
+         vIsoU.back().TrimStartEndAtParam( dMinU / SBZ_TREG_COEFF, dMaxU / SBZ_TREG_COEFF) ;
+      }
+      // a partire dalle curve limitate in U recupero le curve in V e le limito
+      int nSpanU = vIsoU.back().GetCurveCount() ;
+      nU = nSpanU * m_nDegU + 1 ;
+      vector<CurveComposite> vIsoV ; vIsoV.reserve( nU) ;
+      for ( int i = 0 ; i < nU ; ++i) {
+         int nSubU = i / m_nDegU ;
+         int nPoint = i % m_nDegU ;
+         if ( nSubU == nSpanU) {
+            --nSubU ;
+            nPoint = m_nDegU ;
+         }
+         vIsoV.emplace_back() ;
+         for ( int k = 0 ; k < m_nSpanV ; ++k) {
+            CurveBezier cbIsoV ;
+            cbIsoV.Init( m_nDegV, m_bRat) ;
+            for ( int j = 0 ; j <= m_nDegV ; ++j) {
+               const CurveComposite& ccIsoU = vIsoU[k * m_nDegV + j] ;
+               const ICurveBezier* cbSubCurveU = GetCurveBezier( ccIsoU.GetCurve( nSubU)) ;
+               if ( ! m_bRat)
+                  cbIsoV.SetControlPoint( j, cbSubCurveU->GetControlPoint( nPoint)) ;
+               else {
+                  double dW = cbSubCurveU->GetControlWeight( nPoint) ;
+                  cbIsoV.SetControlPoint( j, cbSubCurveU->GetControlPoint( nPoint), dW) ;
+               }
+            }
+            vIsoV.back().AddCurve( cbIsoV) ;
+         }
+         vIsoV.back().TrimStartEndAtParam( dMinV / SBZ_TREG_COEFF, dMaxV / SBZ_TREG_COEFF) ;
+      }
+      int nSpanV = vIsoV.back().GetCurveCount() ;
+      // ricostruisco la superficie a partire dalle nuove curve
+      // salvo la regione di trim
+      ISurfFlatRegion* pSaveTrim = m_pTrimReg ;
+      m_pTrimReg = nullptr ;
+      Init( m_nDegU, m_nDegV, nSpanU, nSpanV, m_bRat) ;
+      // scorro le isocurve in V
+      for ( int i = 0 ; i < nU ; ++i) {
+         CurveComposite ccIsoV = vIsoV[i] ;
+         for ( int k = 0 ; k < nSpanV ; ++k) {
+            const ICurveBezier* cbSubCurveV = GetCurveBezier( ccIsoV.GetCurve( k)) ;
+            for ( int j = k == 0 ? 0 : 1 ; j <= m_nDegV ; ++j) {
+               if ( ! m_bRat)
+                  SetControlPoint(  i, k * m_nDegV + j, cbSubCurveV->GetControlPoint( j)) ;
+               else {
+                  double dW = cbSubCurveV->GetControlWeight( j) ;
+                  SetControlPoint(  i, k * m_nDegV + j, cbSubCurveV->GetControlPoint( j), dW) ;
+               }
+            }
+         }
+      }
+#if SAVELIMITSURF
+   vector<IGeoObj*> vGeo ; 
+   vGeo.push_back( pSaveTrim->Clone()) ;
+#endif
+
+      // riscalo la superficie di trim
+      double dDimX = dMaxU - dMinU ;
+      double dDimY = dMaxV - dMinV ;
+      Vector3d vtMove( dMinU, dMinV) ;
+      pSaveTrim->Translate( -vtMove) ;
+      bool bRescaled = false ;
+      DBLVECTOR vU, vV ;
+      vU.push_back( 0) ;
+      int nFirst = int( ceil( dMinU / SBZ_TREG_COEFF)) ;
+      nFirst = nFirst == 0 ? 1 : nFirst ;
+      for ( int i = 0 ; i < nSpanU - 1 ; ++i)
+         vU.push_back( nFirst + i - dMinU/ SBZ_TREG_COEFF) ;
+      vU.push_back( (dMaxU - dMinU) / SBZ_TREG_COEFF) ;
+      vV.push_back( 0) ;
+      nFirst = int( ceil( dMinV / SBZ_TREG_COEFF)) ;
+      nFirst = nFirst == 0 ? 1 : nFirst ;
+      for ( int i = 0 ; i < nSpanV - 1 ; ++i)
+         vV.push_back( nFirst + i - dMinV/ SBZ_TREG_COEFF) ;
+      vV.push_back( (dMaxV - dMinV)/ SBZ_TREG_COEFF) ;
+      MakeUniform( pSaveTrim, bRescaled, vU, vV, m_nDegU, m_nDegV, dDimX, dDimY, false) ;
+      //m_pTrimReg->Scale( GLOB_FRM, nSpanU * SBZ_TREG_COEFF / dDimX, nSpanV * SBZ_TREG_COEFF / dDimY, 1) ;
+      m_pTrimReg = GetBasicSurfFlatRegion( pSaveTrim) ;
+      m_bTrimmed = true ;
+#if SAVELIMITSURF
+   vGeo.push_back( m_pTrimReg->Clone()) ;
+   SaveGeoObj( vGeo, "D:\\Temp\\bezier\\edit surf\\trim_reg_before_after.nge") ;
+   vGeo.clear() ;
+#endif
+   }
+
+   return true ;
+}
\ No newline at end of file
diff --git a/SurfBezier.h b/SurfBezier.h
index 88a7883..1338978 100644
--- a/SurfBezier.h
+++ b/SurfBezier.h
@@ -153,6 +153,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const BIPNTVECTOR& vCrv) ;
       bool RemoveCollapsedSpans( void) override ;
       bool SwapParameters( void) ;
+      bool LimitSurfToTrimmedRegion( void) override ;
 
    public :                      // IGeoObjRW
       int  GetNgeId( void) const override ;