diff --git a/SbzFromCurves.cpp b/SbzFromCurves.cpp
index da24792..f6a40a4 100644
--- a/SbzFromCurves.cpp
+++ b/SbzFromCurves.cpp
@@ -735,7 +735,8 @@ GetSurfBezierRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, dou
 
 //-------------------------------------------------------------------------------
 ISurfBezier*
-GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const ICURVEPOVECTOR& vCrv, double dLinTol)
+GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const ICURVEPOVECTOR& vCrv, const ICURVEPOVECTOR& vNewCrv,
+                          const INTVECTOR& vShown, const INTINTVECTOR& vNewOrEdited, double dLinTol)
 {
    // verifica parametri
    if ( pCurve1 == nullptr  ||  pCurve2 == nullptr)
@@ -762,7 +763,7 @@ GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const IC
 
    // creo e setto la superficie trimesh
    PtrOwner<SurfBezier> pSbz( CreateBasicSurfBezier()) ;
-   if ( IsNull( pSbz)  ||  ! pSbz->CreateByIsoParamSet( pCC1, pCC2, vCrv))
+   if ( IsNull( pSbz)  ||  ! pSbz->CreateByIsoParamSet( pCC1, pCC2, vCrv, vNewCrv, vShown, vNewOrEdited))
       return nullptr ;
 
    // restituisco la superficie
diff --git a/SurfBezier.cpp b/SurfBezier.cpp
index 1a6aa76..e652741 100644
--- a/SurfBezier.cpp
+++ b/SurfBezier.cpp
@@ -44,8 +44,9 @@
 #define EIGEN_NO_IO
 #include "/EgtDev/Extern/Eigen/Dense"
 
-//#define SAVEFAILEDTRIANGULATION
-#ifdef SAVEFAILEDTRIANGULATION
+#define SAVEFAILEDTRIANGULATION 0
+#define SAVEISO 1
+#if SAVEFAILEDTRIANGULATION  || SAVEISO
    #include "/EgtDev/Include/EGkGeoObjSave.h"
 #endif
 
@@ -1068,6 +1069,15 @@ SurfBezier::Load( NgeReader& ngeIn)
       m_bTrimmed = true ;
    }
 
+#if SAVEISO
+   ICURVEPOVECTOR vCrv ;
+   GetAllPatchesIsocurves( false, vCrv) ;
+   vector<IGeoObj*> vGeo ;
+   for( int i = 0 ; i < ssize(vCrv) ; ++i) 
+      vGeo.push_back( vCrv[i]->Clone()) ;
+   SaveGeoObj( vGeo, "D:\\Temp\\bezier\\ruled\\rebuild\\isoCrv.nge") ;
+#endif
+
   // eseguo validazione
    return Validate() ;
 }
@@ -1849,7 +1859,7 @@ SurfBezier::GetAuxSurfRefined( void) const
    return m_pSTMRefined ;
 }
 
-#ifdef SAVEFAILEDTRIANGULATION
+#if SAVEFAILEDTRIANGULATION
 static int nErr = 0 ;
 #endif
 
@@ -1900,7 +1910,7 @@ SurfBezier::GetApproxSurf( double dTol, double dSideMin, bool bUpdateEdges) cons
    
    if ( vvPL.empty()) {
       LOG_DBG_ERR( GetEGkLogger(), "ERROR : Bezier Surface couldn't be triangulated")
-#ifdef SAVEFAILEDTRIANGULATION
+#if SAVEFAILEDTRIANGULATION
       SaveGeoObj( Clone(),"D:\\Temp\\bezier\\not_triangulated\\" + ToString( nErr) + ".nge") ;
       ++nErr ;
 #endif
@@ -5629,11 +5639,11 @@ SurfBezier::GetAllPatchesIsocurves( bool bUOrV, ICURVEPOVECTOR& vCrv) const
 {
    // restituisce tutte le isocurve di separazione tra patch in un parametro o nell'altro
    if ( bUOrV) {
-      for ( int v = 0 ; v < m_nSpanV ; ++v)
+      for ( int v = 0 ; v <= m_nSpanV ; ++v)
          vCrv.emplace_back( GetCurveOnU( v)) ;
    }
    else {
-      for ( int u = 0 ; u < m_nSpanU ; ++u)
+      for ( int u = 0 ; u <= m_nSpanU ; ++u)
          vCrv.emplace_back( GetCurveOnV( u)) ;
    }
    return true ;
@@ -5643,7 +5653,10 @@ struct IsoParam {
    int nCrv ;
    double dParam0 ;
    double dParam1 ;
-   IsoParam( int _nCrv, double _dParam0, double _dParam1): nCrv(_nCrv), dParam0( _dParam0), dParam1( _dParam1){ } ;
+   bool bNew ;
+   bool bShown ;
+   IsoParam( int _nCrv, double _dParam0, double _dParam1, bool _bNew = false, bool _bShown = false) :
+      nCrv(_nCrv), dParam0( _dParam0), dParam1( _dParam1), bNew( _bNew), bShown( _bShown){ } ;
    bool operator < ( IsoParam& b)
    {
       return ( abs(dParam0 - b.dParam0) > EPS_SMALL ? dParam0 < b.dParam0 : dParam1 < b.dParam1) ;
@@ -5654,8 +5667,13 @@ typedef vector<IsoParam> ISOPARVECT ;
 
 //----------------------------------------------------------------------------
 bool
-SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const ICURVEPOVECTOR& vCrv)
+SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const ICURVEPOVECTOR& vCrv, const ICURVEPOVECTOR& vNewCrv, const INTVECTOR& vShown , const INTINTVECTOR& vNewOrEdited)
 {
+   // vCrv è il vettore delle isocurve (nel parametro V) di una surf ( creata come rigata) che si vuole modificare ( già ordinato)
+   // vNewCrv è il vettore delle isocurve mostrate durante l'editing, che comprende le curve editate e le curve nuove
+   // vShown indica gli indici delle curve in vCrv che sono mostrate in vCrv
+   // vNewOrEdited indica la coppia di indici (nId1, nId2) (in vCrv, in vNewCrv) per le curve editate e una coppia (-1, nId) per le curve aggiunte
+
    // converto in bezier la curva iniziale
    CurveComposite CrvU0 ; CrvU0.AddCurve( CurveToBezierCurve(pCurve0)) ;
    if ( ! CrvU0.IsValid())
@@ -5691,20 +5709,122 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c
    double dLastParam0 = 0, dLastParam1 = 0 ;
    double dLenPrev0 = 0 ,dLenPrev1 = 0 ;
 
-   // mi assicuro che le isocurve siano in ordine
+   // costruisco il vettore delle nuove curve isoparamtriche per la nuova superficie
    ISOPARVECT vIso ;
+   int nNewCounter = 0 ;
+   int nShowCounter = 0 ;
+   // inserisco solo le isocurve che non sono state modificate
    for ( int i = 0 ; i < ssize( vCrv) ; ++i) {
-      Point3d ptU0 ; vCrv[i]->GetStartPoint( ptU0) ;
-      Point3d ptU1 ; vCrv[i]->GetEndPoint( ptU1) ;
-      double dParam0 ; CrvU0.GetParamAtPoint( ptU0, dParam0) ;
-      double dParam1 ; CrvU1.GetParamAtPoint( ptU1, dParam1) ;
-      vIso.emplace_back( i, dParam0, dParam1) ;
+      if( i != vNewOrEdited[nNewCounter].first) {
+         Point3d ptU0 ; vCrv[i]->GetStartPoint( ptU0) ;
+         Point3d ptU1 ; vCrv[i]->GetEndPoint( ptU1) ;
+         double dParam0 ; CrvU0.GetParamAtPoint( ptU0, dParam0) ;
+         double dParam1 ; CrvU1.GetParamAtPoint( ptU1, dParam1) ;
+         if( i != vShown[nShowCounter])
+            vIso.emplace_back( i, dParam0, dParam1) ;
+         else {
+            vIso.emplace_back( i, dParam0, dParam1, false, true) ;
+            ++ nShowCounter ;
+         }
+      }
+      else {
+         ++ nNewCounter ;
+         while( nNewCounter < ssize( vNewOrEdited) - 1  &&  vNewOrEdited[nNewCounter].first == -1)
+            ++ nNewCounter ;
+         if( i == vShown[nShowCounter])
+            ++nShowCounter ;
+      }
+   }
+
+   // vNewCrv contiene tutto il nuovo set di curve
+   for( INTINT ii : vNewOrEdited) {
+         Point3d ptU0 ; vNewCrv[ii.second]->GetStartPoint( ptU0) ;
+         Point3d ptU1 ; vNewCrv[ii.second]->GetEndPoint( ptU1) ;
+         double dParam0 ; CrvU0.GetParamAtPoint( ptU0, dParam0) ;
+         double dParam1 ; CrvU1.GetParamAtPoint( ptU1, dParam1) ;
+         vIso.emplace_back( ii.second, dParam0, dParam1, true) ;
    }
    sort( vIso.begin(), vIso.end()) ;
 
+   // scorro vIso per eliminare le isocurve non più necessarie
+   int c = 0 ;
+   dLastParam0 = vIso[c].dParam0 ;
+   dLastParam1 = vIso[c].dParam1 ;
+   ++c ;
+   while( c < ssize( vIso)) {
+      if ( vIso[c].dParam1 >= dLastParam1 && ! vIso[c].bNew)
+         ;  // non devo fare nulla
+      else {
+         dLastParam0 = vIso[c].dParam0 ;
+         dLastParam1 = vIso[c].dParam1 ;
+         // cancello tutte le curve avanti e indietro finché incontro una show che non viene intersecata
+         int c_temp = c + 1 ;
+         while( ! (vIso[c_temp].bShown && vIso[c_temp].dParam0 >= dLastParam0  && vIso[c_temp].dParam1 >= dLastParam1)) {
+            if( vIso[c_temp].bNew)
+               ++c_temp ;
+            else
+               vIso.erase(vIso.begin() + c_temp) ;
+         }
+         c_temp = c - 1 ;
+         while( ! (vIso[c_temp].bShown && vIso[c_temp].dParam0 <= dLastParam0  && vIso[c_temp].dParam1 <= dLastParam1)) {
+            if( vIso[c_temp].bNew)
+               --c_temp ;
+            else {
+               vIso.erase(vIso.begin() + c_temp) ;
+               --c_temp ;
+               --c ;
+            }
+         }
+      }
+      dLastParam0 = vIso[c].dParam0 ;
+      dLastParam1 = vIso[c].dParam1 ;
+      ++c ;
+   }
+
+   /////////////////////QUESTI CONTROLLI LI DOVREI FARE IO SE NON AVESSI INFORMAZIONI SU QUALI CURVE SONO QUELLE NUOVE( o MODIFICATE) (da finire nel caso)
+   //// controllo anche se le curve sono ordinate anche nel parametro sulla seconda curva ( se sono state modificate delle curve)
+   //// elimino eventuali curve intersecate da curve modificate
+   //double dLastParam0 = 0 ;
+   //double dLastParam1 = 0 ;
+   //int nCountOrig = 0 ;
+   //int nCountOrigTemp = 0 ;
+   //int nErased = 0 ;
+   //for( int i = 0 ; i < ssize( vNewCrv); ++i) {
+   //   bool bFoundPos = false ;
+   //   bool bNew = false ;
+   //   nCountOrigTemp = nCountOrig ;
+   //   while( ! bFoundPos) {
+   //      bool bSameCrv = false ;
+   //      bool bEdited = false ;
+   //      Point3d ptStartOrig ; vCrv[nCountOrig]->GetStartPoint( ptStartOrig) ;
+   //      Point3d ptStartNew ; vNewCrv[i]->GetStartPoint( ptStartNew) ;
+   //      bool bSameStart = false ;
+   //      bool bSameEnd = false ;
+   //      if( AreSamePointExact( ptStartOrig, ptStartNew))
+   //         bSameStart = true ;
+   //      Point3d ptEndOrig ; vCrv[nCountOrig]->GetEndPoint( ptEndOrig) ;
+   //      Point3d ptEndNew ; vNewCrv[i]->GetEndPoint( ptEndNew) ;
+   //      if( AreSamePointExact( ptEndOrig, ptEndNew))
+   //         bSameEnd = true ;
+   //      bSameCrv = bSameStart && bSameEnd ;
+   //      bEdited = bSameStart ^ bSameEnd ;
+   //      if( bEdited  ||  bNew) {
+   //         // cancello eventuali curve intersecate da questa modificata
+   //      }
+   //      bFoundPos = bSameCrv || bEdited  ||  bNew ;
+
+   //   }
+
+
+   //}
+
+
+   dLastParam0 = 0 ;
+   dLastParam1 = 0 ;
    for ( int i = 0 ; i < ssize( vIso) ; ++i) {
-      Point3d ptU0 ; vCrv[vIso[i].nCrv]->GetStartPoint( ptU0) ;
-      Point3d ptU1 ; vCrv[vIso[i].nCrv]->GetEndPoint( ptU1) ;
+      ICurve* pCrv = vIso[i].bNew ? vNewCrv[vIso[i].nCrv] :  vCrv[vIso[i].nCrv] ;
+      Point3d ptU0 ; pCrv->GetStartPoint( ptU0) ;
+      Point3d ptU1 ; pCrv->GetEndPoint( ptU1) ;
       double& dParam0 = vIso[i].dParam0 ;
       double& dParam1 = vIso[i].dParam1 ;
       // se sono vicino ad un'intero allora considero il parametro intero ( uno split già esistente)
diff --git a/SurfBezier.h b/SurfBezier.h
index 2e7b89b..2182d95 100644
--- a/SurfBezier.h
+++ b/SurfBezier.h
@@ -150,7 +150,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3) override ;
       PNTVECTOR GetAllControlPoints( void) const ;
       bool GetAllPatchesIsocurves( bool bUorV, ICURVEPOVECTOR& vCrv) const ;
-      bool CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const ICURVEPOVECTOR& vCrv) ;
+      bool CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const ICURVEPOVECTOR& vCrv, const ICURVEPOVECTOR& vNewCrv, const INTVECTOR& vShown ,const INTINTVECTOR& vNewOrEdited) ;
       bool RemoveCollapsedSpans() override ;
       bool SwapParameters() ;
 
diff --git a/Trimming.cpp b/Trimming.cpp
index bf42b82..4d7c22c 100644
--- a/Trimming.cpp
+++ b/Trimming.cpp
@@ -3373,7 +3373,10 @@ GetTrimmingRuledBezier( const CISURFPVECTOR& vSurf, const ICurve* pCrvEdge1,
          }
       #endif
      // Definisco la superficie
-      pSurfBz.Set( GetSurfBezierRuledGuided( pCompoEdge1, pCompoEdge2, vCrv, dMyLinTol)) ;
+      ICURVEPOVECTOR vNewCrv ;
+      INTVECTOR vShown ;
+      INTINTVECTOR vNewOrEdited ;
+      pSurfBz.Set( GetSurfBezierRuledGuided( pCompoEdge1, pCompoEdge2, vCrv, vNewCrv, vShown, vNewOrEdited, dMyLinTol)) ;
       if ( IsNull( pSurfBz)  ||  ! pSurfBz->IsValid()) {
          LOG_ERROR( GetEGkLogger(), "Error in Trimming : Ruled Bezier with Sync Points invalid") ;
          return nullptr ;