Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtGeomKernel :

Browse Source 
- implementazione delle nurbs periodiche; da sistemare.
This commit is contained in:
Daniele Bariletti
2023-10-04 16:39:20 +02:00
parent 38146c6294
commit bf2a3f0e22
1 changed files with 179 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CurveAux.cpp
+179 -46
View File
@@ -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 ;