//----------------------------------------------------------------------------
//  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/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkSurf.h"
#include "/EgtDev/Include/EGkSurfAux.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
         NurbsCurveCanonicalize( nuCurve) ;
         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
         NurbsCurveCanonicalize( nuCurve) ;
         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())  ||  snData.nCPU * snData.nCPV != int( snData.vCP.size()))
   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] ;
            }
         }
      }
      ++ 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 ( ! 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] ;
            }
         }
      }
      ++ 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 ( ! 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) ;
}