//----------------------------------------------------------------------------
//  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 "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkSurf.h"
#include "/EgtDev/Include/EGkSurfAux.h"
#include "/EgtDev/Include/EGkSurfBezier.h"

using namespace std ;

//----------------------------------------------------------------------------
ISurf*
NurbsToBezierSurface(const CNurbsSurfData& cnData)
{
   //INTVECTOR vInt_sub( 10) ;
   //INTMATRIX vInt( 10, vInt_sub) ;
   //for ( int i = 0 ; i < 10 ; ++i ) {
   //   for ( int j = 0 ; j < 10 ; ++j ) {
   //      vInt[i][j] = i + 10 * j ;
   //   }
   //}
   //vInt_sub.resize( 20) ;
   //vInt[0].resize( 20) ;





   // la superficie Nurbs deve essere in forma canonica
   if ( cnData.bPeriodicU || cnData.bPeriodicV || cnData.bExtraKnotes )
      return nullptr ;
   // controllo sul numero dei nodi
   int nU = cnData.nCPU + cnData.nDegU - 1 ;
   int nV = cnData.nCPV + cnData.nDegV - 1 ;
   // controllo nodi e punti di controllo
   //if ( nU != int( cnData.vU.size())  ||  nV != int( cnData.vV.size())  ||  cnData.nCPU * cnData.nCPV != int( cnData.vCP.size()))
   if ( nU != int(cnData.vU.size()) || nV != int(cnData.vV.size())) {
      return nullptr ;
   }
      
   //// numero degli intervalli
   //int nInt = nU - 2 * cnData.nDeg + 1 ;
   // 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 < cnData.nDegU ; ++ i) {
      if ( abs( cnData.vU[i] - cnData.vU[0]) >= EPS_ZERO)
         bOk = false ;
   }
   for ( int i = 1 ; i < cnData.nDegU ; ++ i) {
      if ( abs( cnData.vU[nU - 1 - i] - cnData.vU[nU - 1]) >= EPS_ZERO)
         bOk = false ;
   }
   // direzione V
   for ( int i = 1 ; i < cnData.nDegV ; ++ i) {
      if ( abs( cnData.vV[i] - cnData.vV[0]) >= EPS_ZERO)
         bOk = false ;
   }
   for ( int i = 1 ; i < cnData.nDegV ; ++ i) {
      if ( abs( cnData.vV[nV - 1 - i] - cnData.vV[nV - 1]) >= EPS_ZERO)
         bOk = false ;
   }
   if ( ! bOk)
      return nullptr ;

   //// se 1 solo intervallo, la Nurbs è già una curva di Bezier
   //if ( nInt == 1) {
   //   // creo la curva di Bezier
   //   PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
   //   if ( IsNull( pCrvBez))
   //      return nullptr ;
   //   // la inizializzo
   //   if ( ! pCrvBez->Init( cnData.nDeg, cnData.bRat))
   //      return nullptr ;
   //   for ( int i = 0 ; i <= cnData.nDeg ; ++ i) {
   //      if ( ! cnData.bRat) {
   //         if ( ! pCrvBez->SetControlPoint( i, cnData.vCP[i]))
   //            return nullptr ;
   //      }
   //      else {
   //         if ( ! pCrvBez->SetControlPoint( i, cnData.vCP[i], cnData.vW[i]))
   //            return nullptr ;
   //      }
   //   }
   //   // se non è una curva ma un punto, la invalido
   //   if ( pCrvBez->IsAPoint())
   //      pCrvBez->Init( cnData.nDeg, cnData.bRat) ;
   //   // restituisco la curva
   //   return Release( pCrvBez) ;
   //}


   // 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 = cnData.nDegU - 1 ;
   int b = cnData.nDegU ;
   int nb = 0 ;  // numero di strisce in U ( lunghezza con U costante)
   //PNTVECTOR vBC ;
   //vBC.resize( cnData.nCPV * cnData.nDegU) ;
   //for (int row = 0 ; row < cnData.nCPV ; ++row ) {
   //   for ( int i = 0 ; i <= cnData.nDegU ; ++i ) {
   //      vBC[nDegU*row + i] = ( cnData.vCP[nCPU*row + i]) ;
   //   }
   //}
   vector<Point3d> vCPV( cnData.nCPV) ;
   vector< vector<Point3d>> mBC (cnData.nDegU + 1,vCPV ) ;
   vector< vector<Point3d>> mBC_next (cnData.nDegU - 1, vCPV) ;
   vector< vector<Point3d>> mPC_strip(cnData.nDegU + 1, vCPV) ; // matrice che verrà ingrandita e conterrà la superficie metà bezier e metà NURBS
   DBLVECTOR vV_W( cnData.nCPV) ;
   vector<DBLVECTOR> mW( cnData.nDegU + 1, vV_W) ;
   vector<DBLVECTOR> mW_next( cnData.nDegU - 1, vV_W) ;
   vector<DBLVECTOR> mW_strip( cnData.nDegU + 1, vV_W) ;
   DBLVECTOR vAlpha ;
   vAlpha.resize( cnData.nDegU - 1) ;
   if ( ! cnData.bRat ) {
      for ( int i = 0 ; i <= cnData.nDegU ; ++i ) {
         for ( int row = 0 ; row < cnData.nCPV ; ++row ) {
            mBC[i][row] = cnData.mCP[i][row] ;
         }
      }
   }
   else {
      for ( int i = 0 ; i <= cnData.nDegU ; ++i ) {
         for (int row = 0 ; row < cnData.nCPV ; ++ row) {
            mW[i][row] = cnData.mW[i][row] ;
            mBC[i][row] = cnData.mCP[i][row] * cnData.mW[i][row] ;
         }
      }
   }
   
   bool bRef = false ;
   while ( b < nU - 1) { // qui correggo un probabile errore, mettendo nU anziché nCPV, come indicato nell'algoritmo
      int i = b ;
      while ( b < nU - 1  &&  abs( cnData.vU[b+1] - cnData.vU[b]) < EPS_ZERO)
         ++ b ;
      int mult = b - i + 1 ;
      if ( mult < cnData.nDegU ) {
         bRef = true ;
         // calcolo numeratore e alpha
         double numer = cnData.vU[b] - cnData.vU[a] ;
         for ( int j = cnData.nDegU ; j > mult ; -- j)
            vAlpha[j-mult-1] = numer / ( cnData.vU[a+j] - cnData.vU[a]) ;
         int r = cnData.nDegU - mult ;
         for ( int j = 1 ; j <= cnData.nDegU - mult ; ++j ) {
            int save = r - j ;
            int s = mult + j ;
            //for ( int row = 0 ; row < cnData.nCPV ; ++row) {
            //   for ( int k = cnData.nDegU ; k >= s ; --k ) {
            //      vBC[nCPU*row + k] = vAlpha[k-s]*vBC[nCPU*row + k] + ( 1 -  vAlfa[k-s]) * vBC[nCPU*row + k - 1]
            //   }
            //}
            if ( ! cnData.bRat ) {
               for ( int k = cnData.nDegU ; k >= s ; --k ) {
                  for ( int row = 0 ; row < cnData.nCPV ; ++row) {
                     mBC[k][row] = vAlpha[k-s] * mBC[k][row] + ( 1 -  vAlpha[k-s]) * mBC[k-1][row] ;
                  }
               }
            }
            else {
               for ( int k = cnData.nDegU ; k >= s ; --k ) {
                  for ( int row = 0 ; row < cnData.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 < cnData.nCPV ; ++row) {
                  mBC_next[save][row] =  mBC[cnData.nDegU][row] ;
               }
               if ( cnData.bRat )
                  for ( int row = 0 ; row < cnData.nCPV ; ++row) { 
                     mW_next[save][row] = mW[cnData.nDegU][row] ;
                  }
            }
         }
         mPC_strip.resize( cnData.nDegU * ( nb  + 1) + 1 , vCPV) ;
         mW_strip.resize( cnData.nDegU * ( nb  + 1) + 1, vV_W) ;
         if ( ! cnData.bRat)
            for ( int i = 0 ; i <= cnData.nDegU ; ++i) {
               for ( int row = 0 ; row < cnData.nCPV ; ++row ) {
                  mPC_strip[i+ nb * cnData.nDegU][row] = mBC[i][row] ;
               }
            }
         else {
            for ( int i = 0 ; i <= cnData.nDegU ; ++i) {
               for ( int row = 0 ; row < cnData.nCPV ; ++row ) {
                  mPC_strip[i+ nb * cnData.nDegU][row] = mBC[i][row]/mW[i][row] ;
                  mW_strip[i+ nb * cnData.nDegU][row] = mW[i][row] ;
               }
            }
         }
      }
      ++ nb ;
      // ho finito di definire la patch di Bezier attuale e passo alla successiva
         
      // aggiorno mBC con i valori della prossima pezza di Bezier // corrisponde a nb = nb + 1 
      if ( ! cnData.bRat){
         for (int i = 0 ; i < cnData.nDegU - 1 ; ++ i) {
            for ( int row = 0 ; row < cnData.nCPV ; ++row) {
               mBC[i][row] = mBC_next[i][row] ;
            }
         }
      }
      else {
         for (int i = 0 ; i < cnData.nDegU - 1 ; ++ i) {
            for ( int row = 0 ; row < cnData.nCPV ; ++row) {
               mBC[i][row] = mBC_next[i][row] ;
               mW[i][row] = mW_next[i][row] ;
            }
         }
      }

      if ( b < nU - 1 ) {
         for ( int i = cnData.nDegU - mult ; i <= cnData.nDegU ; ++ i) {
            for (int row = 0 ; row < cnData.nCPV ; ++ row ) {
               mBC[i][row] = cnData.mCP[b - cnData.nDegU + i + 1][row] ;
            }
         }
         if ( cnData.bRat ) {
            for ( int i = cnData.nDegU - mult ; i <= cnData.nDegU ; ++ i) {
               for (int row = 0 ; row < cnData.nCPV ; ++ row ) {
                  mW[i][row] = cnData.mW[b - cnData.nDegU + i + 1][row] ;
               }
            }
         }
         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 = cnData.nCPU ;
      mPC_strip.resize( cnData.nCPU, vCPV) ;
      mW_strip.resize( cnData.nCPU, vV_W) ;
      if ( ! cnData.bRat) {
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row < cnData.nCPV ; ++ row) {
               mPC_strip[i][row] = cnData.mCP[i][row] ;
            }
         }
      }
      else {
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row < cnData.nCPV ; ++ row) {
               mPC_strip[i][row] = cnData.mCP[i][row] ;
               mW_strip[i][row] = cnData.mW[i][row] ;
            }
         }
      }
      // devo vedere quante patch ci stanno prendendo i punti che ci sono
      nb = (cnData.nCPU - 1) / cnData.nDegU ;
   }
   else
      nCPU_ref = cnData.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 = cnData.nDegV - 1 ;
   b = cnData.nDegV ;
   int nc = 0 ;  // numero di strisce in V ( lunghezza con V costante)
   vector<Point3d> vDegV(cnData.nDegV + 1) ;
   vector<Point3d> vDegV_1(cnData.nDegV - 1) ;
   vector< vector<Point3d>> m_BC1( nCPU_ref, vDegV) ;
   vector< vector<Point3d>> m_BC1_next( nCPU_ref, vDegV_1) ;
   DBLVECTOR vV1_W(cnData.nDegV + 1) ;
   DBLVECTOR vV2_W(cnData.nDegV - 1) ;
   vector<DBLVECTOR> mW1( nCPU_ref, vV1_W) ;
   vector<DBLVECTOR> mW1_next( nCPU_ref, vV2_W) ;
   DBLVECTOR vAlpha1( cnData.nDegV - 1) ;
   vector<vector<Point3d>> mPC_tot( nCPU_ref, vDegV) ;
   vector<DBLVECTOR> mW_tot( nCPU_ref, vV1_W) ;
   if ( ! cnData.bRat ) {
      for ( int i = 0 ; i < nCPU_ref ; ++i ) {
         for ( int row = 0 ; row <= cnData.nDegV ; ++row ) {
            m_BC1[i][row] = mPC_strip[i][row] ;
         }
      }
   }
   else {
      for ( int i = 0 ; i < nCPU_ref ; ++i ) {
         for (int row = 0 ; row <= cnData.nDegV ; ++ row) {
            mW1[i][row] = mW_strip[i][row] ;
            m_BC1[i][row] = mPC_strip[i][row] * mW_strip[i][row] ;
         }
      }
   }

   bRef = false ;
   while ( b < nV - 1) { // qui correggo un probabile errore, mettendo nU anziché nCPV, come indicato nell'algoritmo
      int i = b ;
      while ( b < nV - 1  &&  abs( cnData.vV[b+1] - cnData.vV[b]) < EPS_ZERO)
         ++ b ;
      int mult = b - i + 1 ;
      if ( mult < cnData.nDegV ) {
         bRef = true ;
         // calcolo numeratore e alpha
         double numer = cnData.vV[b] - cnData.vV[a] ;
         for ( int j = cnData.nDegV ; j > mult ; -- j)
            vAlpha1[j-mult-1] = numer / ( cnData.vV[a+j] - cnData.vV[a]) ;
         int r = cnData.nDegV - mult ;
         for ( int j = 1 ; j <= cnData.nDegV - mult ; ++j ) {
            int save = r - j ;
            int s = mult + j ;
            //for ( int row = 0 ; row < cnData.nCPV ; ++row) {
            //   for ( int k = cnData.nDegU ; k >= s ; --k ) {
            //      vBC[nCPU*row + k] = vAlpha1[k-s]*vBC[nCPU*row + k] + ( 1 -  vAlpha1[k-s]) * vBC[nCPU*row + k - 1]
            //   }
            //}
            if ( ! cnData.bRat) {
               for ( int k = 0 ; k < nCPU_ref ; ++k) {
                  for ( int row = cnData.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 = cnData.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 ( !cnData.bRat ){
                  for ( int i = 0 ; i < nCPU_ref ; ++i) {
                     m_BC1_next[i][save] =  m_BC1[i][cnData.nDegV] ;
                  }
               }
               else {
                  for ( int i = 0 ; i < nCPU_ref ; ++i) {
                     m_BC1_next[i][save] =  m_BC1[i][cnData.nDegV] ;
                     mW1_next[save] = mW1[cnData.nDegV] ;
                  }
               }
            }
         }
      }
      int nRef = cnData.nDegV * ( nc + 1) + 1 ;
      for ( int k = 0 ; k < nCPU_ref; ++k){
         mPC_tot[k].resize( nRef) ;
         mW_tot[k].resize( nRef) ;
      }
      if ( ! cnData.bRat)
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row <= cnData.nDegV ; ++row ) {
               mPC_tot[i][row + nc * cnData.nDegV] = m_BC1[i][row] ;
            }
         }
      else {
         for ( int i = 0 ; i < nCPU_ref ; ++i) {
            for ( int row = 0 ; row <= cnData.nDegV ; ++row ) {
               mPC_tot[i][row + nc * cnData.nDegV] = m_BC1[i][row]/mW1[i][row] ;
               mW_tot[i][row + nc * cnData.nDegV] = mW1[i][row] ;
            }
         }
      }
      ++ nc ;
      // ho finito di definire la patch di Bezier attuale e passo alla successiva

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

      if ( b < nV - 1) {
         for (int i = 0 ; i < nCPU_ref ; ++ i ) {
            for ( int row = cnData.nDegV - mult ; row <= cnData.nDegV ; ++ row) {
               m_BC1[i][row] = cnData.mCP[i][b - cnData.nDegV + row + 1] ;
            }
         }
         if ( cnData.bRat ) {
            for (int i = 0 ; i < nCPU_ref ; ++ i ) {
               for ( int row = cnData.nDegV - mult ; row <= cnData.nDegV ; ++ row) {
                  mW1[i][row] = cnData.mW[i][b - cnData.nDegV + row + 1] ;
               }
            }
         }
         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 = cnData.nCPV ;
      for ( int k = 0 ; k < nCPU_ref ; ++k){
         mPC_tot[k].resize( cnData.nCPV) ;
         mW_tot[k].resize( cnData.nCPV) ;
      }
      if ( ! cnData.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] ;
            }
         }
      }
      // devo vedere quante patch ci stanno prendendo i punti che ci sono
      nc = (cnData.nCPV - 1) / cnData.nDegV ;
   }
   else
      nCPV_ref = cnData.nDegV * nc + 1 ;

   // finalmente setto la superficie di bezier totale divisa in nb patch in U e nc patch in V
   PtrOwner<ISurfBezier> pSrfBz( CreateSurfBezier()) ;
   if ( IsNull( pSrfBz))
      return nullptr ;
   pSrfBz->Init(cnData.nDegU, cnData.nDegV, nb, nc, cnData.bRat) ;
   if ( !cnData.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) ;
}

//// algoritmo per le curve, da usare come reference///////////////////////////////////////////////////////////////////////////////
//
//
//   // vettore dei punti di controllo della curva di Bezier
//   PNTVECTOR vBC ;
//   vBC.resize( cnData.nDeg + 1) ;
//   DBLVECTOR vBW ;
//   vBW.resize( cnData.nDeg + 1) ;
//   if ( ! cnData.bRat) {
//      for ( int i = 0 ; i <= cnData.nDeg ; ++ i)
//         vBC[i] = cnData.vCP[i] ;
//   }
//   else {
//      for ( int i = 0 ; i <= cnData.nDeg ; ++ i) {
//         vBC[i] = cnData.vCP[i] * cnData.vW[i] ;
//         vBW[i] = cnData.vW[i] ;
//      }
//   }
//   // primi coefficienti della successiva
//   PNTVECTOR vNextBC ;
//   vNextBC.resize( cnData.nDeg - 1) ;
//   DBLVECTOR vNextBW ;
//   vNextBW.resize( cnData.nDeg - 1) ;
//   // ...
//   DBLVECTOR vAlfa ;
//   vAlfa.resize( cnData.nDeg - 1) ;
//   int a = cnData.nDeg - 1 ;
//   int b = cnData.nDeg ;
//   bool bPrevRejected = false ;
//   // ciclo
//   while ( b < nU - 1) {
//      int i = b ;
//      while ( b < nU - 1  &&  abs( cnData.vU[b+1] - cnData.vU[b]) < EPS_ZERO)
//         ++ b ;
//      int mult = min( b - i + 1, cnData.nDeg) ;
//      if ( mult < cnData.nDeg) {
//         // numeratore di alfa
//         double numer = cnData.vU[b] - cnData.vU[a] ;
//         // calcola e salva gli alfa
//         for ( int j = cnData.nDeg ; j > mult ; -- j)
//            vAlfa[j-mult-1] = numer / ( cnData.vU[a+j] - cnData.vU[a]) ;
//         // inserisco il nodo r volte
//         int r = cnData.nDeg - mult ;
//         for ( int j = 1 ; j <= r ; ++ j) {
//            int save = r - j ;
//            int s = mult + j ;
//            for ( int k = cnData.nDeg ; k >= s ; -- k)
//               vBC[k] = vAlfa[k-s] * vBC[k] + ( 1 - vAlfa[k-s]) * vBC[k-1] ;
//            if ( cnData.bRat) {
//               for ( int k = cnData.nDeg ; k >= s ; -- k)
//                  vBW[k] = vAlfa[k-s] * vBW[k] + ( 1 - vAlfa[k-s]) * vBW[k-1] ;
//            }
//            if ( b < nU - 1) {
//               vNextBC[save] = vBC[cnData.nDeg] ;
//               if ( cnData.bRat)
//                  vNextBW[save] = vBW[cnData.nDeg] ;
//            }
//         }
//      }
//
//      // costruisco la curva di Bezier e la inserisco nella curva composita
//      PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
//      if ( IsNull( pCrvBez))
//         return nullptr ;
//      // se precedente saltata
//      if ( bPrevRejected) {
//         // prendo l'ultimo punto della curva composita per garantire la continuità
//         Point3d ptEnd ;
//         if ( pCrvCompo->GetEndPoint( ptEnd))
//            vBC[0] = ptEnd ;
//      }
//      // la inizializzo
//      if ( ! pCrvBez->Init( cnData.nDeg, cnData.bRat))
//         return nullptr ;
//      if ( ! cnData.bRat) {
//         for ( int i = 0 ; i <= cnData.nDeg ; ++ i) {
//            if ( ! pCrvBez->SetControlPoint( i, vBC[i]))
//               return nullptr ;
//         }
//      }
//      else {
//         for ( int i = 0 ; i <= cnData.nDeg ; ++ i) {
//            if ( ! pCrvBez->SetControlPoint( i, vBC[i] / vBW[i], vBW[i]))
//               return nullptr ;
//         }
//      }
//      // se è una vera curva, la aggiungo alla curva composita
//      if ( ! pCrvBez->IsAPoint()) {
//         if ( ! pCrvCompo->AddCurve( Release( pCrvBez)))
//            return nullptr ;
//         bPrevRejected = false ;
//      }
//      // altrimenti è un punto, la cancello
//      else {
//         pCrvBez.Reset() ;
//         bPrevRejected = true ;
//      }
//
//      // inizializzazioni per la prossima curva di Bezier
//      if ( b < nU - 1) {
//         if ( ! cnData.bRat) {
//            for ( int i = 0 ; i < cnData.nDeg - 1 ; ++ i)
//               vBC[i] = vNextBC[i] ;
//            for ( int i = cnData.nDeg - mult ; i <= cnData.nDeg ; ++ i)
//               vBC[i] = cnData.vCP[b-cnData.nDeg+i+1] ;
//         }
//         else {
//            for ( int i = 0 ; i < cnData.nDeg - 1 ; ++ i) {
//               vBC[i] = vNextBC[i] ;
//               vBW[i] = vNextBW[i] ;
//            }
//            for ( int i = cnData.nDeg - mult ; i <= cnData.nDeg ; ++ i) {
//               vBC[i] = cnData.vCP[b-cnData.nDeg+i+1] * cnData.vW[b-cnData.nDeg+i+1] ;
//               vBW[i] = cnData.vW[b-cnData.nDeg+i+1] ;
//            }
//         }
//         a = b ;
//         ++ b ;
//      }
//   }
//
//   // restituisco la curva composita
//   return Release( pCrvCompo) ;
//}