diff --git a/CurveAux.cpp b/CurveAux.cpp
index 7a7d0e2..5e8051b 100644
--- a/CurveAux.cpp
+++ b/CurveAux.cpp
@@ -523,51 +523,61 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
 
   // se periodica
    if ( cnData.bPeriodic) {
-      CNurbsData cnData_clamped ;
      // va trasformata in non-periodica (clamped)
-     // bisogna aumentare la molteplicità del primo e ultimo nodo fino ad arrivare al grado della nurbs
-     // e poi scartare nodi e punti fuori dalla regione clamped ( tra u_p e u_(m-p) ?)
+     // bisogna aumentare la molteplicità dei nodi u_p e u_(m-p) fino ad arrivare al grado della nurbs
+     // e poi scartare nodi e punti fuori dalla regione clamped ( al di fuori della regione u_p -> u_(m-p))
 
-      // comincio ad aumentare la molteplictià della fine della curva
+      // comincio ad aumentare la molteplictià del nodo u_m-p
       int nCP = int( cnData.vCP.size()) ;
       int nU = nCP + cnData.nDeg - 1 ;
+      int nDeg = cnData.nDeg ;
       PNTVECTOR vBC ;
-      vBC.resize( cnData.nDeg + 1) ;
+      vBC.resize( nDeg + 1) ;
       DBLVECTOR vBW ;
-      vBW.resize( cnData.nDeg + 1) ;
-      if ( ! cnData.bRat) {
-         for ( int i = 0 ; i <= cnData.nDeg ; ++ i)
-            vBC[ cnData.nDeg - i] = cnData.vCP[nCP - 1 - i] ;
-      }
-      else {
-         for ( int i = 0 ; i <= cnData.nDeg ; ++ i) {
-            vBC[cnData.nDeg - i] = cnData.vCP[nCP - i] * cnData.vW[nCP - i] ;
-            vBW[cnData.nDeg - i] = cnData.vW[nCP - i] ;
-         }
-      }
+      vBW.resize( nDeg + 1) ;
 
-
-      double alpha ;
-      int b = nU - 1 ;
-      int a = b - 1 ;
+      // trovo il nodo di cui aumentare la molteplicità e ne calcolo la molteplicità
+      int b = nU - nDeg - 1 ;
       int i = b ;
       while ( abs( cnData.vU[b] - cnData.vU[b - 1]) < EPS_ZERO)
          -- b ;
-      int mult = min( i - b + 1, cnData.nDeg) ; // mi aspetto che sia 1, ma comunque sarà < cnData.nDeg
-      int r = cnData.nDeg - mult ;
-      //// indice che si riferisce al vettore vCP
-      int c = nU - cnData.nDeg + 1 ;
-      // aggiusto a mano il vettore dei nodi ( aumento la molteplicità del primo valore fino a cnData.nDeg)
-      double dKnot = cnData.vU[ nU - 1] ;
-      cnData.vU.resize( nU + r) ;
-      for ( int t = 0 ; t < r ; ++t) {
-         cnData.vU[nU + t] = dKnot ;
+      int mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < cnData.nDeg
+      // recupero i punti da modificare
+      if ( ! cnData.bRat) {
+         for ( int i = 0 ; i <= nDeg - mult ; ++ i)
+            vBC[i] = cnData.vCP[b - nDeg + i] ;
+      }
+      else {
+         for ( int i = 0 ; i <= nDeg - mult ; ++ i) {
+            vBC[i] = cnData.vCP[b - nDeg + i] * cnData.vW[b - nDeg + i] ;
+            vBW[i] = cnData.vW[b - nDeg + i] ;
+         }
       }
 
-      if ( mult < cnData.nDeg) {
+      // salvo i punti inalterati
+      int r = nDeg - mult ;  // numero di volte che dovrò inserire il nodo
+      cnData.vCP.resize( nCP + r) ;
+      for ( int p = b - mult ; p <  nCP ; ++p) {
+         cnData.vCP[r + p] = cnData.vCP[p] ;
+      }
+      if ( cnData.bRat ) {
+         cnData.vW.resize( nCP + r) ;
+         for ( int p = b - mult ; p <=  nCP ; ++p) {
+            cnData.vW[r + p] = cnData.vW[p] ;
+         }
+      }
+
+      //DEBUG
+      PNTVECTOR vtPT = cnData.vCP ;
+      //DEBUG
+
+      // procedo all'inserimento
+      int L = 0 ;
+      double alpha ;
+      if ( mult < nDeg) {
          // inserisco il nodo r volte
          for ( int j = 1 ; j <= r ; ++ j) {
-            int L = b - cnData.nDeg + j ;
+            L = b - nDeg + j ;
             for ( int i = 0; i <= r - j ; ++i) {
                alpha = (cnData.vU[b] - cnData.vU[L+i])/ ( cnData.vU[i+b+1] - cnData.vU[L+i]) ;
                vBC[i] = alpha * vBC[i+1] + ( 1 - alpha) * vBC[i] ;
@@ -576,34 +586,157 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
                }
             }
             cnData.vCP[L] = vBC[0] ;
-            //cnData.vCP[c+r-j-mult] = vBC[r-j] ;
+            cnData.vCP[b+r-j-mult] = vBC[r-j] ;
             if ( cnData.bRat ) {
                cnData.vW[L] = vBW[0] ;
-               //cnData.vW[c+r-j-mult] = vBW[r-j] ;
+               cnData.vW[b+r-j-mult] = vBW[r-j] ;
             }
          }
       }
+
+      //DEBUG
+      PNTVECTOR vtPT_A = cnData.vCP ;
+      //DEBUG
+
       // aggiungo i punti ottenuti alla curva.
-      cnData.vCP.resize( nCP + cnData.nDeg - mult) ;
-      for ( int p = 0 ; p <  cnData.nDeg - mult ; ++p) {
-         cnData.vCP[ nCP + cnData.nDeg - mult - 1 - p] = vBC[cnData.nDeg - p] ;
+      for ( int p = L + 1 ; p <  b - mult ; ++p) {
+         cnData.vCP[ b - nDeg + 1 + p] = vBC[p] ;
       }
       if ( cnData.bRat ) {
-         cnData.vW.resize( nCP + cnData.nDeg - mult) ;
-         for ( int p = 0 ; p <=  cnData.nDeg ; ++p) {
-            cnData.vW[ nCP + cnData.nDeg - mult - 1 - p] = vBW[cnData.nDeg - p] ;
+         for ( int p = L + 1 ; p <=  b - mult ; ++p) {
+            cnData.vW[ b - nDeg + 1 + p] = vBW[p] ;
          }
       }
 
-      // aumento la molteplicità del primo punto
+      //DEBUG
+      PNTVECTOR vtPT_B = cnData.vCP ;
+      //DEBUG
 
-      // aggiusto a mano il vettore dei nodi ( aumento la molteplicità del primo valore fino a cnData.nDeg)
-      /// DA ADATTARE PER IL PRIMO
-      cnData.vU.resize( nU + cnData.nDeg - mult) ;
-      dKnot = cnData.vU[ nU] ;
-      for ( int t = nU - 1 ; t < cnData.nDeg - mult - 1 ; ++t) {
-         cnData.vU[t] = dKnot ;
+      // allungo il vettore dei nodi e sposto gli ultimi nodi
+      cnData.vU.resize(nU + r) ;
+      for ( int p = nU - 1 ; p > b ; --p)
+         cnData.vU[p+r] = cnData.vU[p] ;
+      // aggiungo i nodi nuovi
+      for ( int p = 0 ; p < r ; ++p)
+         cnData.vU[b+1+p] = cnData.vU[b] ;
+      nU = nU + r ;
+      nCP = nCP + r ;
+
+      //DEBUG
+      PNTVECTOR vtPT0 = cnData.vCP ;
+      //DEBUG
+
+      // aumento la molteplicità del punto u_p
+      b = nDeg ;
+      i = b ;
+      while ( abs( cnData.vU[b] - cnData.vU[b - 1]) < EPS_ZERO)
+         -- b ;
+      mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < cnData.nDeg
+      // recupero i punti da modificare
+      if ( ! cnData.bRat) {
+         for ( int i = 0 ; i <= nDeg - mult  ; ++ i)
+            vBC[i] = cnData.vCP[i] ;
       }
+      else {
+         for ( int i = 0 ; i <= nDeg - mult ; ++ i) {
+            vBC[i] = cnData.vCP[i] * cnData.vW[i] ;
+            vBW[i] = cnData.vW[i] ;
+         }
+      }
+
+      r = nDeg - mult ;
+      // salvo i punti inalterati
+      cnData.vCP.resize( nCP + r) ;
+      for ( int p = b - mult ; p <  nCP ; ++p) {
+         cnData.vCP[ r + p] = cnData.vCP[p] ;
+      }
+      if ( cnData.bRat ) {
+         cnData.vW.resize( nCP + r) ;
+         for ( int p = b - mult ; p <=  nCP ; ++p) {
+            cnData.vW[ r + p] = cnData.vW[p] ;
+         }
+      }
+
+      //DEBUG
+      PNTVECTOR vtPT1 = cnData.vCP ;
+      //DEBUG
+
+      // procedo all'inserimento
+      L = 0 ;
+      if ( mult < nDeg) {
+         // inserisco il nodo r volte
+         for ( int j = 1 ; j <= r ; ++ j) {
+            L = b - nDeg + j ;
+            for ( int i = 0; i <= r - j ; ++i) {
+               alpha = (cnData.vU[b] - cnData.vU[L+i])/ ( cnData.vU[i+b+1] - cnData.vU[L+i]) ;
+               vBC[i] = alpha * vBC[i+1] + ( 1 - alpha) * vBC[i] ;
+               if ( cnData.bRat) {
+                  vBW[i] = alpha * vBW[i+1] + ( 1 - alpha) * vBW[i] ;
+               }
+            }
+            cnData.vCP[L] = vBC[0] ;
+            cnData.vCP[b+r-j-mult] = vBC[r-j] ;
+            if ( cnData.bRat ) {
+               cnData.vW[L] = vBW[0] ;
+               cnData.vW[b+r-j-mult] = vBW[r-j] ;
+            }
+         }
+      }
+
+      //DEBUG
+      PNTVECTOR vtPT2 = cnData.vCP ;
+      //DEBUG
+
+      // aggiungo i punti ottenuti alla curva.
+      for ( int p = L + 1 ; p <  b - mult ; ++p) {
+         cnData.vCP[ b - nDeg + 1 + p] = vBC[p] ;
+      }
+      if ( cnData.bRat ) {
+         for ( int p = L + 1 ; p <=  b - mult ; ++p) {
+            cnData.vW[ b - nDeg + 1 + p] = vBW[p] ;
+         }
+      }
+
+      //DEBUG
+      PNTVECTOR vtPT3 = cnData.vCP ;
+      //DEBUG
+
+      // allungo il vettore dei nodi e sposto gli ultimi nodi
+      cnData.vU.resize(nU + r) ;
+      for ( int p = nU - 1 ; p > b ; --p)
+         cnData.vU[p+r] = cnData.vU[p] ;
+      // aggiungo i nodi nuovi
+      for ( int p = 0 ; p < r ; ++p)
+         cnData.vU[b+1+p] = cnData.vU[b] ;
+      nU = nU + r ;
+      nCP = nCP + r ;
+
+      //DEBUG
+      PNTVECTOR vtPT4 = cnData.vCP ;
+      //DEBUG
+
+
+      // rendo la curva chiusa e non periodica eliminando i primi e gli ultimi nDeg punti e nodi
+      cnData.bPeriodic = false ;
+      nCP = nCP - 2 * nDeg;
+      nU = nU - 2 * nDeg ;
+      PNTVECTOR vCP_clamped ;
+      vCP_clamped.resize( nCP) ;
+      DBLVECTOR vU_clamped ;
+      vU_clamped.resize( nU) ;
+      for ( int i = 0 ; i < nCP ; ++i) {
+         vCP_clamped[i] = cnData.vCP[i + nDeg] ;
+      }
+      cnData.vCP = vCP_clamped ;
+      for ( int i = 0 ; i < nU ; ++i) {
+         vU_clamped[i] = cnData.vU[i + nDeg] ;
+      }
+      cnData.vU = vU_clamped ;
+
+      //DEBUG
+      PNTVECTOR vtPT5 = cnData.vCP ;
+      //DEBUG
+
    }
 
    return true ;