//----------------------------------------------------------------------------
//  EgalTech 2023-2023
//----------------------------------------------------------------------------
// File : SurfAux.cpp      Data : 09.08.23          Versione :
// Contenuto : Implementazione di alcune funzioni di utilit? per le Superfici.
//
//
//
// Modifiche : 09.08.23 DB Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "CurveAux.h"
#include "GeoConst.h"
#include "CurveLine.h"
#include "CurveArc.h"
#include "CurveBezier.h"
#include "CurveComposite.h"
#include "SurfBezier.h"
#include "/EgtDev/Include/EGkSurf.h"
#include "/EgtDev/Include/EGkSurfAux.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//----------------------------------------------------------------------------
bool
NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
{
   // per rendere una superficie non periodica devo recuperare i punti di controllo, suddivisi in isoparametriche lungo una direzione
   // e applicare la trasformazione ad ogni isoparametrica, sostituendola poi a quella originale. ( si mantiene il numero di punti)
   if ( snData.bPeriodicU  ||  ! snData.bClampedU) {
      bool bIsRational = snData.bRat ;
      // vettore dei nodi
      DBLVECTOR vU ;
      int nKnot = (int) snData.vU.size() ;
      for ( int k = 0 ; k < nKnot ; ++k ) {
         double dKnot = snData.vU[k] ;
         vU.push_back( dKnot) ;
      }
      for( int j = 0 ; j < snData.nCPV ; ++j) {
         CNurbsData nuCurve ;
         nuCurve.bPeriodic = true ;
         nuCurve.nDeg = snData.nDegU ;
         nuCurve.vU = vU ;
         // vettore dei punti di controllo
         PNTVECTOR vPtCtrl ;
         // vettore dei pesi
         DBLVECTOR vWeCtrl ;
         for ( int i = 0 ; i < snData.nCPU ; ++i ) {
            if ( bIsRational) {
               vPtCtrl.push_back( snData.mCP[i][j] / snData.mW[i][j]) ;
               vWeCtrl.push_back( snData.mW[i][j]) ;
            }
            else
               vPtCtrl.push_back( snData.mCP[i][j]) ;
         }
         nuCurve.vCP = vPtCtrl ;
         nuCurve.vW = vWeCtrl ;
         // i punti dell' oggetto nuCurve devono essere in forma non omogenea
         if ( NurbsCurveCanonicalize( nuCurve)) {  // se NurbsCurveCanonicalize ha restituito false (la curva potrebbe esserre un punto di polo) allora non modifico i punti e il vettore dei nodi della superficie
            for ( int i = 0 ; i < snData.nCPU ; ++i) {
               snData.mCP[i][j] = nuCurve.vCP[i] ;
            }
            snData.vU = nuCurve.vU ;
         }
      }
      snData.bPeriodicU = false ;
   }
   if ( snData.bPeriodicV  ||  ! snData.bClampedV) {
      bool bIsRational = snData.bRat ;
      // vettore dei nodi
      DBLVECTOR vV ;
      int nKnot = (int) snData.vV.size() ;
      for ( int k = 0 ; k < nKnot ; ++k ) {
         double dKnot = snData.vV[k] ;
         vV.push_back( dKnot) ;
      }
      for( int i = 0 ; i < snData.nCPU ; ++i) {
         CNurbsData nuCurve ;
         nuCurve.bPeriodic = true ;
         nuCurve.nDeg = snData.nDegV ;
         nuCurve.vU = vV ;
         // vettore dei punti di controllo
         PNTVECTOR vPtCtrl ;
         // vettore dei pesi
         DBLVECTOR vWeCtrl ;
         for ( int j = 0 ; j < snData.nCPV ; ++j ) {
            if ( bIsRational) {
               vPtCtrl.push_back( snData.mCP[i][j] / snData.mW[i][j]) ;
               vWeCtrl.push_back( snData.mW[i][j]) ;
            }
            else
               vPtCtrl.push_back( snData.mCP[i][j]) ;
         }
         nuCurve.vCP = vPtCtrl ;
         nuCurve.vW = vWeCtrl ;
         // i punti dell' oggetto nuCurve devono essere in forma non omogenea
         if ( NurbsCurveCanonicalize( nuCurve)) { // se NurbsCurveCanonicalize ha restituito false (la curva potrebbe esserre un punto di polo) allora non modifico i punti e il vettore dei nodi della superficie
            for ( int j = 0 ; j < snData.nCPV ; ++j ) {
               snData.mCP[i][j] = nuCurve.vCP[j] ;
            }
            snData.vV = nuCurve.vU ;
         }
      }
      snData.bPeriodicV = false ;
   }
   return true;
}

//----------------------------------------------------------------------------
ISurf*
NurbsToBezierSurface(const SNurbsSurfData& snData)
{
  // la superficie Nurbs deve essere in forma canonica
   if ( snData.bPeriodicU || snData.bPeriodicV || snData.bExtraKnotes )
      return nullptr ;
  // controllo sul numero dei nodi
   int nU = snData.nCPU + snData.nDegU - 1 ;
   int nV = snData.nCPV + snData.nDegV - 1 ;
  // controllo nodi e punti di controllo
   if ( nU != int(snData.vU.size()) || nV != int(snData.vV.size())) {
      return nullptr ;
   }

  // verifico le condizioni agli estremi sui nodi (i primi nDeg nodi e gli ultimi nDeg nodi devono essere uguali tra loro)
   bool bOk = true ;
  // direzione U
   for ( int i = 1 ; i < snData.nDegU ; ++ i) {
      if ( abs( snData.vU[i] - snData.vU[0]) >= EPS_ZERO)
         bOk = false ;
   }
   for ( int i = 1 ; i < snData.nDegU ; ++ i) {
      if ( abs( snData.vU[nU - 1 - i] - snData.vU[nU - 1]) >= EPS_ZERO)
         bOk = false ;
   }
  // direzione V
   for ( int i = 1 ; i < snData.nDegV ; ++ i) {
      if ( abs( snData.vV[i] - snData.vV[0]) >= EPS_ZERO)
         bOk = false ;
   }
   for ( int i = 1 ; i < snData.nDegV ; ++ i) {
      if ( abs( snData.vV[nV - 1 - i] - snData.vV[nV - 1]) >= EPS_ZERO)
         bOk = false ;
   }
   if ( ! bOk)
      return nullptr ;

  // algoritmo 5.7 del libro "The NURBS book"
  // creazione delle strips nella direzione U ( trasformo le curve iso con U costante in bezier)
   int a = snData.nDegU - 1 ;
   int b = snData.nDegU ;
   int nb = 0 ;  // numero di strisce in U ( lunghezza con U costante)
   vector<Point3d> vCPV( snData.nCPV) ;
   vector< vector<Point3d>> mBC (snData.nDegU + 1,vCPV ) ;
   vector< vector<Point3d>> mBC_next (snData.nDegU - 1, vCPV) ;
   vector< vector<Point3d>> mPC_strip(snData.nDegU + 1, vCPV) ; // matrice che verrà ingrandita e conterrà la superficie metà bezier e metà NURBS
   DBLVECTOR vV_W( snData.nCPV) ;
   vector<DBLVECTOR> mW( snData.nDegU + 1, vV_W) ;
   vector<DBLVECTOR> mW_next( snData.nDegU - 1, vV_W) ;
   vector<DBLVECTOR> mW_strip( snData.nDegU + 1, vV_W) ;
   DBLVECTOR vAlpha ;
   vAlpha.resize( snData.nDegU - 1) ;
   if ( ! snData.bRat ) {
      for ( int i = 0 ; i <= snData.nDegU ; ++i) {
         for ( int row = 0 ; row < snData.nCPV ; ++row ) {
            mBC[i][row] = snData.mCP[i][row] ;
         }
      }
   }
   else {
      for ( int i = 0 ; i <= snData.nDegU ; ++i) {
         for (int row = 0 ; row < snData.nCPV ; ++ row) {
            mW[i][row] = snData.mW[i][row] ;
            mBC[i][row] = snData.mCP[i][row] * snData.mW[i][row] ;
         }
      }
   }

   bool bRef = false ;
   while ( snData.nDegU != 1 ? b < nU - 1 : b < nU) { // qui correggo un probabile errore, mettendo nU anziché nCPV, come indicato nell'algoritmo
      int i = b ;
      while ( b < nU - 1  &&  abs( snData.vU[b+1] - snData.vU[b]) < EPS_ZERO)
         ++ b ;
      int mult = b - i + 1 ;
      if ( mult < snData.nDegU) {
         bRef = true ;
         // calcolo numeratore e alpha
         double numer = snData.vU[b] - snData.vU[a] ;
         for ( int j = snData.nDegU ; j > mult ; -- j)
            vAlpha[j-mult-1] = numer / ( snData.vU[a+j] - snData.vU[a]) ;
         int r = snData.nDegU - mult ;
         for ( int j = 1 ; j <= snData.nDegU - mult ; ++j) {
            int save = r - j ;
            int s = mult + j ;
            if ( ! snData.bRat ) {
               for ( int k = snData.nDegU ; k >= s ; --k) {
                  for ( int row = 0 ; row < snData.nCPV ; ++row) {
                     mBC[k][row] = vAlpha[k-s] * mBC[k][row] + ( 1 -  vAlpha[k-s]) * mBC[k-1][row] ;
                  }
               }
            }
            else {
               for ( int k = snData.nDegU ; k >= s ; --k) {
                  for ( int row = 0 ; row < snData.nCPV ; ++row) {
                     mBC[k][row] = vAlpha[k-s] * mBC[k][row] + ( 1 -  vAlpha[k-s]) * mBC[k-1][row] ;
                     mW[k][row] = vAlpha[k-s] * mW[k][row] + ( 1 - vAlpha[k-s]) * mW[k-1][row] ;
                  }
               }
            }

            if ( b < nU - 1 ) {
               for ( int row = 0 ; row < snData.nCPV ; ++row) {
                  mBC_next[save][row] =  mBC[snData.nDegU][row] ;
               }
               if ( snData.bRat )
                  for ( int row = 0 ; row < snData.nCPV ; ++row) { 
                     mW_next[save][row] = mW[snData.nDegU][row] ;
                  }
            }
         }
      }
      mPC_strip.resize( snData.nDegU * ( nb  + 1) + 1, vCPV) ;
      mW_strip.resize( snData.nDegU * ( nb  + 1) + 1, vV_W) ;
      if ( ! snData.bRat)
         for ( int i = 0 ; i <= snData.nDegU ; ++i) {
            for ( int row = 0 ; row < snData.nCPV ; ++row) {
               mPC_strip[i+ nb * snData.nDegU][row] = mBC[i][row] ;
            }
         }
      else {
         for ( int i = 0 ; i <= snData.nDegU ; ++i) {
            for ( int row = 0 ; row < snData.nCPV ; ++row) {
               mPC_strip[i+ nb * snData.nDegU][row] = mBC[i][row]/mW[i][row] ;
               mW_strip[i+ nb * snData.nDegU][row] = mW[i][row] ;
            }
         }
      }
     // ho finito di definire la patch di Bezier attuale e passo alla successiva
      ++ nb ;

     // aggiorno mBC con i valori della prossima pezza di Bezier // corrisponde a nb = nb + 1 
      if ( ! snData.bRat){
         for (int i = 0 ; i < snData.nDegU - 1 ; ++ i) {
            for ( int row = 0 ; row < snData.nCPV ; ++row) {
               mBC[i][row] = mBC_next[i][row] ;
            }
         }
      }
      else {
         for (int i = 0 ; i < snData.nDegU - 1 ; ++ i) {
            for ( int row = 0 ; row < snData.nCPV ; ++row) {
               mBC[i][row] = mBC_next[i][row] ;
               mW[i][row] = mW_next[i][row] ;
            }
         }
      }

      if ( b < nU - 1 ) {
         if ( ! snData.bRat ) {
            for ( int i = snData.nDegU - mult ; i <= snData.nDegU ; ++ i) {
               for (int row = 0 ; row < snData.nCPV ; ++ row ) {
                  mBC[i][row] = snData.mCP[b - snData.nDegU + i + 1][row] ;
               }
            }
         }
         else {
            for ( int i = snData.nDegU - mult ; i <= snData.nDegU ; ++ i) {
               for (int row = 0 ; row < snData.nCPV ; ++ row ) {
                  mBC[i][row] = snData.mCP[b - snData.nDegU + i + 1][row] * snData.mW[b - snData.nDegU + i + 1][row] ;
                  mW[i][row] = snData.mW[b - snData.nDegU + i + 1][row] ;
               }
            }
         }
         a = b ;
         ++b ;
      }
      else if ( snData.nDegU == 1  &&  b < nU) {
         a = b ;
         ++b ;
      }
   }

  // se non ho raffinato allora tutti i nodi avevano gi? molteplicit? massima. Converto direttamente in Bezier la dir U
   int nCPU_ref ; // numero dei punti di controllo in U dopo il raffinamento
   if ( ! bRef ) {
      nCPU_ref = snData.nCPU ;
      mPC_strip.resize( snData.nCPU, vCPV) ;
      mW_strip.resize( snData.nCPU, vV_W) ;
      if ( ! snData.bRat) {
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row < snData.nCPV ; ++ row) {
               mPC_strip[i][row] = snData.mCP[i][row] ;
            }
         }
      }
      else {
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row < snData.nCPV ; ++ row) {
               mPC_strip[i][row] = snData.mCP[i][row] ;
               mW_strip[i][row] = snData.mW[i][row] ;
            }
         }
      }
   }
   else
      nCPU_ref = snData.nDegU * nb + 1 ; // numero dei punti di controllo in U dopo il raffinamento

  // ora ho ottenuto le strisce nDegU x nCPV
  // devo ripetere la procedura, sulla dir V, per ottenere le patch nDegU x nDegV
   a = snData.nDegV - 1 ;
   b = snData.nDegV ;
   int nc = 0 ;  // numero di strisce in V ( lunghezza con V costante)
   vector<Point3d> vDegV(snData.nDegV + 1) ;
   vector<Point3d> vDegV_1(snData.nDegV - 1) ;
   vector< vector<Point3d>> m_BC1( nCPU_ref, vDegV) ;
   vector< vector<Point3d>> m_BC1_next( nCPU_ref, vDegV_1) ;
   DBLVECTOR vV1_W(snData.nDegV + 1) ;
   DBLVECTOR vV2_W(snData.nDegV - 1) ;
   vector<DBLVECTOR> mW1( nCPU_ref, vV1_W) ;
   vector<DBLVECTOR> mW1_next( nCPU_ref, vV2_W) ;
   DBLVECTOR vAlpha1( snData.nDegV - 1) ;
   vector<vector<Point3d>> mPC_tot( nCPU_ref, vDegV) ;
   vector<DBLVECTOR> mW_tot( nCPU_ref, vV1_W) ;
   if ( ! snData.bRat ) {
      for ( int i = 0 ; i < nCPU_ref ; ++i) {
         for ( int row = 0 ; row <= snData.nDegV ; ++row ) {
            m_BC1[i][row] = mPC_strip[i][row] ;
         }
      }
   }
   else {
      for ( int i = 0 ; i < nCPU_ref ; ++i) {
         for (int row = 0 ; row <= snData.nDegV ; ++ row) {
            mW1[i][row] = mW_strip[i][row] ;
            m_BC1[i][row] = mPC_strip[i][row] * mW_strip[i][row] ;
         }
      }
   }

   bRef = false ;
   while ( snData.nDegV != 1 ? b < nV - 1 : b < nV) { // qui correggo un probabile errore, mettendo nU anziché nCPV, come indicato nell'algoritmo
      int i = b ;
      while ( b < nV - 1  &&  abs( snData.vV[b+1] - snData.vV[b]) < EPS_ZERO)
         ++ b ;
      int mult = b - i + 1 ;
      if ( mult < snData.nDegV ) {
         bRef = true ;
        // calcolo numeratore e alpha
         double numer = snData.vV[b] - snData.vV[a] ;
         for ( int j = snData.nDegV ; j > mult ; -- j)
            vAlpha1[j-mult-1] = numer / ( snData.vV[a+j] - snData.vV[a]) ;
         int r = snData.nDegV - mult ;
         for ( int j = 1 ; j <= snData.nDegV - mult ; ++j) {
            int save = r - j ;
            int s = mult + j ;
            if ( ! snData.bRat) {
               for ( int k = 0 ; k < nCPU_ref ; ++k) {
                  for ( int row = snData.nDegV ; row >= s ; --row) {
                     m_BC1[k][row] = vAlpha1[row-s] * m_BC1[k][row] + ( 1 -  vAlpha1[row-s]) * m_BC1[k][row-1] ;
                  }
               }
            }
            else {
               for ( int k = 0 ; k < nCPU_ref ; ++k) {
                  for ( int row = snData.nDegV ; row >= s ; --row) {
                     m_BC1[k][row] = vAlpha1[row-s] * m_BC1[k][row] + ( 1 -  vAlpha1[row-s]) * m_BC1[k][row-1] ;
                     mW1[k][row] = vAlpha1[row-s] * mW1[k][row] + ( 1 -  vAlpha1[row-s]) * mW1[k][row-1] ;
                  }
               }
            }

            if ( b < nV - 1 ) {
               if ( !snData.bRat ){
                  for ( int i = 0 ; i < nCPU_ref ; ++i) {
                     m_BC1_next[i][save] =  m_BC1[i][snData.nDegV] ;
                  }
               }
               else {
                  for ( int i = 0 ; i < nCPU_ref ; ++i) {
                     m_BC1_next[i][save] =  m_BC1[i][snData.nDegV] ;
                     mW1_next[i][save] = mW1[i][snData.nDegV] ;
                  }
               }
            }
         }
      }
      int nRef = snData.nDegV * ( nc + 1) + 1 ;
      for ( int k = 0 ; k < nCPU_ref; ++k) {
         mPC_tot[k].resize( nRef) ;
         mW_tot[k].resize( nRef) ;
      }
      if ( ! snData.bRat)
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row <= snData.nDegV ; ++row) {
               mPC_tot[i][row + nc * snData.nDegV] = m_BC1[i][row] ;
            }
         }
      else {
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row <= snData.nDegV ; ++row) {
               mPC_tot[i][row + nc * snData.nDegV] = m_BC1[i][row] / mW1[i][row] ;
               mW_tot[i][row + nc * snData.nDegV] = mW1[i][row] ;
            }
         }
      }
     // ho finito di definire la patch di Bezier attuale e passo alla successiva
      ++ nc ;

     // aggiorno mBC con i valori della prossima pezza di Bezier // corrisponde a nc = nc + 1 
      if ( ! snData.bRat){
         for (int i = 0 ; i < nCPU_ref ; ++ i) {
            for ( int row = 0 ; row < snData.nDegV - 1 ; ++row) {
               m_BC1[i][row] = m_BC1_next[i][row] ;
            }
         }
      }
      else {
         for (int i = 0 ; i < nCPU_ref ; ++ i) {
            for ( int row = 0 ; row < snData.nDegV - 1 ; ++row) {
               m_BC1[i][row] = m_BC1_next[i][row] ;
               mW1[i][row] = mW1_next[i][row] ;
            }
         }
      }

      if ( b < nV - 1) {
         if ( ! snData.bRat) {
            for (int i = 0 ; i < nCPU_ref ; ++ i ) {
               for ( int row = snData.nDegV - mult ; row <= snData.nDegV ; ++ row) {
                  m_BC1[i][row] = mPC_strip[i][b - snData.nDegV + row + 1] ;
               }
            }
         }
         else {
            for (int i = 0 ; i < nCPU_ref ; ++ i ) {
               for ( int row = snData.nDegV - mult ; row <= snData.nDegV ; ++ row) {
                  m_BC1[i][row] = mPC_strip[i][b - snData.nDegV + row + 1] * mW_strip[i][b - snData.nDegV + row + 1] ;
                  mW1[i][row] = mW_strip[i][b - snData.nDegV + row + 1] ;
               }
            }
         }
         a = b ;
         ++b ;
      }
      else if ( snData.nDegV == 1  &&  b < nV) {
         a = b ;
         ++b ;
      }
   }
  // se non ho raffinato allora aggiungo direttamente alle matrici della superficie totale
   int nCPV_ref ; // numero dei punti di controllo in V dopo il raffinamento
   if ( ! bRef) {
      nCPV_ref = snData.nCPV ;
      for ( int k = 0 ; k < nCPU_ref ; ++k){
         mPC_tot[k].resize( snData.nCPV) ;
         mW_tot[k].resize( snData.nCPV) ;
      }
      if ( ! snData.bRat) {
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row < nCPV_ref ; ++ row) {
               mPC_tot[i][row] = mPC_strip[i][row] ;
            }
         }
      }
      else {
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row < nCPV_ref ; ++ row) {
               mPC_tot[i][row] = mPC_strip[i][row] ;
               mW_tot[i][row] = mW_strip[i][row] ;
            }
         }
      }
   }
   else
      nCPV_ref = snData.nDegV * nc + 1 ;

  // finalmente setto la superficie di bezier totale divisa in nb patch in U e nc patch in V
   PtrOwner<SurfBezier> pSrfBz( CreateBasicSurfBezier()) ;
   if ( IsNull( pSrfBz))
      return nullptr ;
   pSrfBz->Init(snData.nDegU, snData.nDegV, nb, nc, snData.bRat) ;
   if ( !snData.bRat ) {
      for ( int i = 0 ; i < nCPU_ref; ++ i) {
         for (int j = 0 ; j < nCPV_ref; ++j) {
            pSrfBz->SetControlPoint( i + nCPU_ref * j, mPC_tot[i][j]) ;
         }
      }
   }
   else {
      for ( int i = 0 ; i < nCPU_ref; ++ i) {
         for (int j = 0 ; j < nCPV_ref; ++j) {
            pSrfBz->SetControlPoint( i + nCPU_ref * j, mPC_tot[i][j] /*/ mW_tot[i][j]*/, mW_tot[i][j]) ;
         }
      }
   }
   return Release( pSrfBz) ;
}

//----------------------------------------------------------------------------
bool
MakeUniform( ISurfFlatRegion*& pSfr, bool& bRescaled, const DBLVECTOR& vU0, const DBLVECTOR& vV0,
             int nDegU, int nDegV, double dScaleU, double dScaleV, bool bRetry) 
{
  // la superficie in input arriva già scalata
   bool bRescaledU = false ;
   bool bRescaledV = false ;
   int nSpanU = 1, nSpanV = 1 ;
   PtrOwner<ISurfFlatRegion> pRescaledSfr( CreateSurfFlatRegion()) ;
   for ( int nDir = 0 ; nDir <= 1 ; ++ nDir) {
     // vettore dei nodi
      DBLVECTOR vU ;
      int nExtraKnots = 0 ;
     // controllo in U
      if ( nDir == 0) {
         if ( nDegU > 1) {
            nExtraKnots = nDegU - 1 ;
         }
         for ( int i = nExtraKnots ; i < int( vU0.size()) - nExtraKnots ; ++i ) {
            double dKnot = vU0[i] * SBZ_TREG_COEFF ;
            // lo aggiungo solo se è diverso dal precedente
            if ( i == nExtraKnots  ||  dKnot > vU.back() + EPS_SMALL  ||  dKnot < vU.back() - EPS_SMALL)
               vU.push_back( dKnot) ;
         }
         nSpanU = (int)vU.size() - 1 ;
      }
     // controllo in V
      else if ( nDir == 1 ) {
         if ( nDegV > 1) {
            nExtraKnots = nDegV - 1 ;
         }
         for ( int i = nExtraKnots ; i < int( vV0.size()) - nExtraKnots ; ++i ) {
            double dKnot = vV0[i] * SBZ_TREG_COEFF ;
            // lo aggiungo solo se è diverso dal precedente
            if ( i == nExtraKnots  ||  dKnot > vU.back() + EPS_SMALL  ||  dKnot < vU.back() - EPS_SMALL)
               vU.push_back( dKnot) ;
         }
         nSpanV = (int)vU.size() - 1 ;
      }

     // controllo se il vettore dei nodi è uniforme
      int a = 0, b = 1 ;
      double d0 = abs( vU[b] - vU[a]), d1 = d0 ;
      // il vettore è uniforme quando la distanza tra nodi consecutivi è sempre zero o un valore costante
      while ( b < (int)vU.size()  &&  ( ( d1 < d0 + EPS_SMALL  &&  d1 > d0 - EPS_SMALL)  ||  d1 < EPS_SMALL)) {
         a = b ;
         ++b ;
         if ( b < (int)vU.size())
            d1 = abs( vU[b] - vU[a]) ;
      }
      if ( b != (int)vU.size()) {
         nDir == 0 ? bRescaledU = true : bRescaledV = true ;
         pRescaledSfr.Set( CreateSurfFlatRegion()) ;
         if ( IsNull( pRescaledSfr))
            return false ;
         for ( int p = 0 ; p < (int)vU.size() - 1 ; ++p) {
            PtrOwner<ISurfFlatRegion> pSfr_copy( pSfr->Clone()) ;
            if ( IsNull( pSfr_copy))
               return false ;
            double dLenStrip = abs( vU[p+1] - vU[p]) ;
            if ( dLenStrip < EPS_SMALL)
               continue ;
            // creo la maschera per tagliare la superficie originale e ottenere una striscia
            PtrOwner<ISurfFlatRegion> pSfrTrim( CreateSurfFlatRegion()) ;

            // ricavo la maschera del trim, con cui poi farò l'intersezione con la sfr iniziale
            Vector3d vtTrim ;
            if ( nDir == 0) {
               pSfrTrim.Set( GetSurfFlatRegionRectangle( dLenStrip, dScaleV + 2)) ;
               vtTrim.Set( abs(vU[p] - vU.front()), - 1, 0) ;
            }
            else{
               pSfrTrim.Set( GetSurfFlatRegionRectangle( dScaleU + 2, dLenStrip)) ;
               vtTrim.Set( - 1, abs(vU[p] - vU.front()), 0) ;
            }
            pSfrTrim->Translate( vtTrim) ;

            if ( ! pSfr_copy->Intersect( *pSfrTrim))
               return false ;

            // aggiungo la nuova striscia solo se è valida
            if ( pSfr_copy->IsValid() ) {
               if ( nDir == 0)
                  pSfr_copy->Scale( GLOB_FRM, SBZ_TREG_COEFF / dLenStrip, 1, 1) ;
               else
                  pSfr_copy->Scale( GLOB_FRM, 1, SBZ_TREG_COEFF / dLenStrip, 1) ;

               // prima di riunire la striscia al resto devo traslarla sul bordo destro della superificie che sto ricostruendo

               Point3d pt ;
               nDir == 0 ? pt.Set( abs(vU[p] - vU.front()), 0, 0) : pt.Set( 0,abs(vU[p] - vU.front()), 0) ;
               if ( nDir == 0)
                  pt.Scale( GLOB_FRM, SBZ_TREG_COEFF / dLenStrip, 1, 1) ;
               else
                  pt.Scale( GLOB_FRM, 1, SBZ_TREG_COEFF / dLenStrip, 1) ;

               Vector3d vtJoin ;
               if ( nDir == 0)
                  vtJoin.Set( p * SBZ_TREG_COEFF - pt.x, 0, 0) ;
               else
                  vtJoin.Set( 0, p  * SBZ_TREG_COEFF - pt.y, 0) ;
               pSfr_copy->Translate( vtJoin) ;
               // se sto ritentando MakeUniform, allora faccio anche OFFSET e controOFFSET
               if ( bRetry)
                  pSfr_copy->Offset( 10 * EPS_SMALL, ICurve::OFF_CHAMFER) ; // OFFSET
               if ( pRescaledSfr->IsValid()) {
                  if ( ! pRescaledSfr->Add( *pSfr_copy))
                     return false ;
               }
               else
                  pRescaledSfr.Set( pSfr_copy) ;
            }
         }
         if ( nDir == 0) {
            dScaleU = ((int)vU.size() - 1) * SBZ_TREG_COEFF ;
            if ( pRescaledSfr->IsValid()) {
               if ( bRetry)
                  pRescaledSfr->Offset( -10 * EPS_SMALL, ICurve::OFF_CHAMFER) ;  //contro OFFSET
               delete pSfr ;
               pSfr = Release( pRescaledSfr) ;
            }
         }
         else
            dScaleV = ((int)vU.size() - 1) * SBZ_TREG_COEFF ;
      }
   }

   if ( ! IsNull( pRescaledSfr)  &&  pRescaledSfr->IsValid()) {
      if ( bRetry)
         pRescaledSfr->Offset( -10 * EPS_SMALL, ICurve::OFF_CHAMFER) ;  // contro OFFSET
      delete pSfr ;
      pSfr = Release( pRescaledSfr) ;
   }

   if ( ! bRescaledU  &&  ! bRescaledV)
      pSfr->Scale( GLOB_FRM, nSpanU / dScaleU * SBZ_TREG_COEFF, nSpanV / dScaleV * SBZ_TREG_COEFF, 1) ;
   else if ( bRescaledU  &&  ! bRescaledV)
      pSfr->Scale( GLOB_FRM, 1, nSpanV / dScaleV * SBZ_TREG_COEFF, 1) ;
   else if ( ! bRescaledU  &&  bRescaledV)
      pSfr->Scale( GLOB_FRM, nSpanU / dScaleU * SBZ_TREG_COEFF, 1, 1) ;

   bRescaled = ( bRescaledU || bRescaledV) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
OnWhichEdge( double u0, double u1, double v0, double v1, const Point3d& ptToAssign, int& nEdge)
{
   Point3d ptTR( u1, v1) ;
   Point3d ptTl( u0, v1) ;
   Point3d ptBL( u0, v0) ;
   Point3d ptBr( u1, v0) ;

   double dEps = 0.1 ;
   if ( AreSamePointEpsilon( ptToAssign, ptTR, dEps))
      nEdge = 7 ;
   else if ( AreSamePointEpsilon( ptToAssign, ptTl, dEps))
      nEdge = 4 ;
   else if ( AreSamePointEpsilon( ptToAssign, ptBL, dEps))
      nEdge = 5 ;
   else if ( AreSamePointEpsilon( ptToAssign, ptBr, dEps))
      nEdge = 6 ;
   else if ( ptToAssign.x > ptBL.x - dEps  &&  ptToAssign.x < ptTR.x + dEps  &&  abs( ptToAssign.y - ptTR.y) < dEps)
      nEdge = 0 ;
   else if ( ptToAssign.y > ptBL.y - dEps  &&  ptToAssign.y < ptTR.y + dEps  &&  abs( ptToAssign.x - ptBL.x) < dEps)
      nEdge = 1 ;
   else if ( ptToAssign.x > ptBL.x - dEps  &&  ptToAssign.x < ptTR.x + dEps  &&  abs( ptToAssign.y - ptBL.y) < dEps)
      nEdge = 2 ;
   else if ( ptToAssign.y > ptBL.y - dEps  &&  ptToAssign.y < ptTR.y + dEps  &&  abs( ptToAssign.x - ptTR.x) < dEps)
      nEdge = 3 ;
   else
      return false ;
   return true ;
}