diff --git a/RotationMinimizeFrame.cpp b/RotationMinimizeFrame.cpp
index 8a31952..76d0689 100644
--- a/RotationMinimizeFrame.cpp
+++ b/RotationMinimizeFrame.cpp
@@ -112,12 +112,14 @@ RotationMinimizeFrame::GetFrames( FRAME3DVECTOR& vRMFrams)
    if ( ! m_pCrv->GetLength( dLen))
       return false ;
 
-  // ricavo il numero degli step
-   int nStep = ceil( dLen / m_dStep) ;
-
   // in prima posizione viene inserito il frame iniziale
    m_vRMFrames.push_back( m_Frame0) ;
 
+  // ricavo il numero degli step
+   int nStep = ceil( dLen / m_dStep) ;
+   if ( nStep == 0) // se non ho step allora serve sono il frame iniziale
+      return true ;
+
   // variabili di utilizzo
    double dLenCurr = 0 ;                  // lunghezza della curva allo step i-esimo
    double dLenNext ;                      // lunghezza della curva allo step (i+1)-esimo
@@ -128,51 +130,54 @@ RotationMinimizeFrame::GetFrames( FRAME3DVECTOR& vRMFrams)
       return false ;
    Point3d ptNext ;                       // punto sulla curva allo step (i+1)-esimo
 
-  // definizione dei versori r,s,t
+  // definizione dei versori "r","s","t"
    Vector3d vt_r = m_Frame0.VersX() ;
    Vector3d vt_s = m_Frame0.VersY() ;
    Vector3d vt_t = m_Frame0.VersZ() ;
 
+  // ricavo la lunghezza dello step di campionamento reale
+   double dStep_real = dLen / nStep ;
+
   // ciclo sugli step in cui la curva è suddivisa
    for ( int i = 0 ; i < nStep ; ++ i) {
-     // ricavo la lunghezza della curva nello step successivo
-      dLenNext = min( dLen - EPS_SMALL, ( i + 1) * dLen / nStep) ;
-     // parametro successivo sulla curva
+     // ricavo la lunghezza della curva relativo allo step (i+1)-esimo
+      dLenNext = min( dLen - EPS_SMALL, ( i + 1) * dStep_real) ;
+     // parametro (i+1)-esimo sulla curva
       if ( ! m_pCrv->GetParamAtLength( dLenNext, dUNext))
          return false ;
-     // punto successivo sulla curva e suo vettore tangente
+     // punto (i+1)-esimo sulla curva e suo vettore tangente
       Vector3d vt_t_next ;
       if ( ! m_pCrv->GetPointD1D2( dUNext, ICurve::FROM_MINUS, ptNext, &vt_t_next)  ||
-           ! vt_t_next.IsValid()  /*||  ! vt_t_next.Normalize()*/)
+           ! vt_t_next.IsValid())
          return false ;
-     // controllo per caso degenere 
-      if ( AreSamePointEpsilon( ptCurr, ptNext, EPS_ZERO)  ||           // non esiste R1
-           abs(( ptNext - ptCurr) * ( vt_t_next + vt_t)) < EPS_ZERO)    // non esiste R2
+     // controllo per casi degeneri
+      if ( AreSamePointEpsilon( ptCurr, ptNext, EPS_ZERO)  ||           // non esiste il piano R1
+           abs(( ptNext - ptCurr) * ( vt_t_next + vt_t)) < EPS_ZERO)    // non esiste il piano R2
          return false ;
      // ricavo il vettore di riflessione rispetto al piano R1
-      Vector3d v1 = ptNext - ptCurr ;
-      if ( ! v1.IsValid())
+      Vector3d vR1_norm = ptNext - ptCurr ;
+      if ( ! vR1_norm.IsValid())
          return false ;
      // parametro di riflessione per R1
-      double c1 = v1 * v1 ;
-     // riflessione rispetto al piano R1
-      Vector3d vt_r_L = vt_r - ( 2 / c1) * ( v1 * vt_r) * v1 ;
-      Vector3d vt_t_L = vt_t - ( 2 / c1) * ( v1 * vt_t) * v1 ;
+      double dPar1 = vR1_norm * vR1_norm ;
+     // riflessione rispetto al piano R1 ( sistema sinistrorso L )
+      Vector3d vt_r_L = vt_r - ( 2 / dPar1) * ( vR1_norm * vt_r) * vR1_norm ;
+      Vector3d vt_t_L = vt_t - ( 2 / dPar1) * ( vR1_norm * vt_t) * vR1_norm ;
      // ricavo il vettore di riflessione rispetto al piano R1
-      Vector3d v2 = vt_t_next - vt_t_L ;
-      if ( ! v2.IsValid())
+      Vector3d vR2_norm = vt_t_next - vt_t_L ;
+      if ( ! vR2_norm.IsValid())
          return false ;
      // parametro di riflessione per R2
-      double c2 = v2 * v2 ;
-     // versore r del nuovo frame
-      Vector3d vt_r_next = vt_r_L - ( 2 / c2) * ( v2 * vt_r_L) * v2 ;
-     // versore t del nuovo frame
+      double dPar2 = vR2_norm * vR2_norm ;
+     // versore r del nuovo frame (i+1)-esimo
+      Vector3d vt_r_next = vt_r_L - ( 2 / dPar2) * ( vR2_norm * vt_r_L) * vR2_norm ;
+     // versore t del nuovo frame (i+1)-esimo
       Vector3d vt_s_next = vt_t_next ^ vt_r_next ;
-     // creazione del nuovo frame
+     // creazione del nuovo frame (i+1)-esimo
       Frame3d RMFrame_next ;
       RMFrame_next.Set( ptNext, vt_r_next, vt_s_next, vt_t_next) ;
-      if ( ! RMFrame_next.IsValid()) {
-        // sistemo...
+      if ( ! RMFrame_next.IsValid()) { // il frame potrebbe non essere nelle tolleranze...
+        // ... sistemo ricavando il versore "s" mediante "t" ed "r" ...
          RMFrame_next.Set( ptNext, vt_t_next, vt_r_next) ;
          if ( ! RMFrame_next.IsValid())
             return false ;
@@ -185,10 +190,8 @@ RotationMinimizeFrame::GetFrames( FRAME3DVECTOR& vRMFrams)
       ptCurr = ptNext ;
    }
 
-  // restituisco il vettore di Frame
-   vRMFrams.resize( int( m_vRMFrames.size())) ;
-
   // oriento i frames ottenuti in modo da avere il versore X tangente alla curva
+   vRMFrams.resize( int( m_vRMFrames.size())) ;
    for ( int i = 0 ; i < int( m_vRMFrames.size()) ; ++ i) {
       vRMFrams[i].Set( m_vRMFrames[i].Orig(), m_vRMFrames[i].VersY(), m_vRMFrames[i].VersZ()) ;
       if ( ! vRMFrams[i].IsValid())