diff --git a/SurfBezier.cpp b/SurfBezier.cpp
index 29a47b1..c9fea9a 100644
--- a/SurfBezier.cpp
+++ b/SurfBezier.cpp
@@ -5988,7 +5988,9 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c
       double dFloor0 = floor( dNewStart0) ;
       double dCeil1 = ceil( dNewStart1) ;
       double dFloor1 = floor( dNewStart1) ;
+      vPnt0.pop_back() ;
       rotate( vPnt0.begin(), vPnt0.begin() + int( dCeil0), vPnt0.end()) ;
+      vPnt1.pop_back() ;
       rotate( vPnt1.begin(), vPnt1.begin() + int( dCeil1), vPnt1.end()) ;
       if ( abs( dNewStart0 - round( dNewStart0)) > EPS_SMALL) {
          Point3d ptNewStart ; CrvU0.GetStartPoint( ptNewStart) ;
@@ -6125,7 +6127,7 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c
                return false ;
             }
             // se ho una corrispondenza tra punti ( e non sono alla fine del tratto) allora non aggiungo split
-            if ( abs( vdParamPos0[c0] - vdParamPos1[c1]) < EPS_PARAM  &&  vdParamPos0[c0] < 1) {
+            if ( abs( vdParamPos0[c0] - vdParamPos1[c1]) < EPS_SMALL  &&  vdParamPos0[c0] < 1) {
                ++c0 ;
                ++c1 ;
                ++nLastParam0 ;
@@ -6140,6 +6142,7 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c
                   nSplit1 = vdSplit1.size() ;
                }
                else if ( dPar = round( dPar) ;  dPar > nLastParam1){
+                  ++ c1 ;
                   ++ nLastParam1 ;
                }
                ++nLastParam0 ;
@@ -6154,6 +6157,7 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c
                   nSplit0 = vdSplit0.size() ;
                }
                else if ( dPar = round( dPar) ;  dPar > nLastParam0){
+                  ++ c0 ;
                   ++ nLastParam0 ;
                }
                ++nLastParam1 ;
diff --git a/Trimming.cpp b/Trimming.cpp
index 0d9df4c..48d7b46 100644
--- a/Trimming.cpp
+++ b/Trimming.cpp
@@ -3920,8 +3920,50 @@ GetTrimmingSyncInterpolation( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
       return false ;
 
   // Recupero i due tratti di curva
-   PtrOwner<CurveComposite> pCompoGuide1( ConvertCurveToBasicComposite( pCrvEdge1->CopyParamRange( dUA, dUC))) ;
-   PtrOwner<CurveComposite> pCompoGuide2( ConvertCurveToBasicComposite( pCrvEdge2->CopyParamRange( dUB, dUD))) ;
+   PtrOwner<CurveComposite> pCompoGuide1( nullptr) ;
+   PtrOwner<CurveComposite> pCompoGuide2( nullptr) ;
+  // se entrambe chiuse
+   if ( pCrvEdge1->IsClosed()  &&  pCrvEdge2->IsClosed()) {
+     // Recupero la porzione di curva di Edge1 di lunghezza minima tra il parametro A e C
+      PtrOwner<CurveComposite> pCompoAC( ConvertCurveToBasicComposite( pCrvEdge1->CopyParamRange( dUA, dUC))) ;
+      PtrOwner<CurveComposite> pCompoCA( ConvertCurveToBasicComposite( pCrvEdge1->CopyParamRange( dUC, dUA))) ;
+      if ( IsNull( pCompoAC)  ||  IsNull( pCompoCA)  ||  ! pCompoAC->IsValid()  ||  ! pCompoCA->IsValid())
+         return false ;
+      double dLenAC ; pCompoAC->GetLength( dLenAC) ;
+      double dLenCA ; pCompoCA->GetLength( dLenCA) ;
+      if ( dLenAC < dLenCA)
+         pCompoGuide1.Set( Release( pCompoAC)) ;
+      else
+         pCompoGuide1.Set( Release( pCompoCA)) ;
+     // Recupero la porzione di curva di Edge2 di lunghezza minima tra il parametro B e D
+      PtrOwner<CurveComposite> pCompoBD( ConvertCurveToBasicComposite( pCrvEdge2->CopyParamRange( dUB, dUD))) ;
+      PtrOwner<CurveComposite> pCompoDB( ConvertCurveToBasicComposite( pCrvEdge2->CopyParamRange( dUD, dUB))) ;
+      if ( IsNull( pCompoBD)  ||  IsNull( pCompoBD)  ||  ! pCompoBD->IsValid()  ||  ! pCompoDB->IsValid())
+         return false ;
+      double dLenBD ; pCompoBD->GetLength( dLenBD) ;
+      double dLenDB ; pCompoDB->GetLength( dLenDB) ;
+      if ( dLenBD < dLenDB)
+         pCompoGuide2.Set( Release( pCompoBD)) ;
+      else
+         pCompoGuide2.Set( Release( pCompoDB)) ;
+   }
+  // se entrambe aperte
+   else if ( ! pCrvEdge1->IsClosed()  &&  ! pCrvEdge2->IsClosed()) {
+      pCompoGuide1.Set( ConvertCurveToBasicComposite( pCrvEdge1->Clone())) ;
+      if ( IsNull( pCompoGuide1)  ||  ! pCompoGuide1->IsValid())
+         return false ;
+      if ( dUA < dUC)
+         pCompoGuide1->TrimStartEndAtParam( dUA, dUC) ;
+      else
+         pCompoGuide1->TrimStartEndAtParam( dUC, dUA) ;
+      pCompoGuide2.Set( ConvertCurveToBasicComposite( pCrvEdge2->Clone())) ;
+      if ( IsNull( pCompoGuide2)  ||  ! pCompoGuide2->IsValid())
+         return false ;
+      if ( dUB < dUD)
+         pCompoGuide2->TrimStartEndAtParam( dUB, dUD) ;
+      else
+         pCompoGuide2->TrimStartEndAtParam( dUD, dUB) ;
+   }
    if ( IsNull( pCompoGuide1)  ||  IsNull( pCompoGuide2)  ||
         ! pCompoGuide1->IsValid()  ||  ! pCompoGuide2->IsValid())
       return false ;
@@ -3935,10 +3977,11 @@ GetTrimmingSyncInterpolation( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
       swap( pCompoGuide1, pCompoGuide2) ;
       swap( dLen1, dLen2) ;
    }
-   if ( pCompoGuide2->IsPointOn( ptS1))
-      swap( ptS1, ptE1) ;
-   if ( pCompoGuide2->IsPointOn( ptS2))
-      swap( ptS2, ptE2) ;
+  // Aggiorno gli estremi delle curve
+   pCompoGuide1->GetStartPoint( ptS1) ;
+   pCompoGuide2->GetStartPoint( ptE1) ;
+   pCompoGuide1->GetEndPoint( ptS2) ;
+   pCompoGuide2->GetEndPoint( ptE2) ;
 
    #if DEBUG_SYNC_INTERPOLATION
       VT.clear() ; VC.clear() ;