Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
49ff6e79a832a4d1112f3c5ab98b9b20387fef89
EgtGeomKernel/SurfAux.cpp
T
Daniele Bariletti 49ff6e79a8 EgtGeomKernel : 
- correzione nella gestione della conversione delle curve/superfici NURBS.
2024-04-29 17:20:30 +02:00

678 lines
26 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// 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
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
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 ;
}
Reference in New Issue View Git Blame Copy Permalink