DarioS
1469 lines
48 KiB
C++
1469 lines
48 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2020-2020
|
|
//----------------------------------------------------------------------------
|
|
// File : SurfBezier.cpp Data : 11.08.20 Versione : 2.2h2
|
|
// Contenuto : Implementazione della classe Superfici Bezier.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 22.03.20 DS Creazione modulo.
|
|
// 11.08.20 DS Trasformata in MultiPatch.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "SurfBezier.h"
|
|
#include "GeoObjFactory.h"
|
|
#include "NgeWriter.h"
|
|
#include "NgeReader.h"
|
|
#include "Bernstein.h"
|
|
#include "CurveBezier.h"
|
|
#include "CurveComposite.h"
|
|
#include "/EgtDev/Include/EGkSfrCreate.h"
|
|
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
|
|
#include "/EgtDev/Include/EGkStringUtils3d.h"
|
|
#include "/EgtDev/Include/EGkUiUnits.h"
|
|
#include "/EgtDev/Include/EgtNumUtils.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
GEOOBJ_REGISTER( SRF_BEZIER, NGE_S_BEZ, SurfBezier) ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
SurfBezier::SurfBezier(void)
|
|
: m_pSTM( nullptr), m_nStatus( TO_VERIFY), m_nDegU(), m_nDegV(), m_nSpanU(), m_nSpanV(), m_bRat( false),
|
|
m_bTrimmed( false), m_pTrimReg( nullptr)
|
|
{
|
|
m_nTempProp[0] = 0 ;
|
|
m_nTempProp[1] = 0 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
SurfBezier::~SurfBezier( void)
|
|
{
|
|
ResetTrimRegion() ;
|
|
m_OGrMgr.Reset() ;
|
|
ResetAuxSurf() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Init( int nDegU, int nDegV, int nSpanU, int nSpanV, bool bIsRational)
|
|
{
|
|
// verifico validità grado
|
|
if ( nDegU < 1 || nDegU > MAXDEG || nDegV < 1 || nDegV > MAXDEG || nSpanU < 1 || nSpanV < 1)
|
|
return false ;
|
|
|
|
// imposto gradi e flag di razionale
|
|
m_nDegU = nDegU ;
|
|
m_nDegV = nDegV ;
|
|
m_nSpanU = nSpanU ;
|
|
m_nSpanV = nSpanV ;
|
|
m_bRat = bIsRational ;
|
|
m_bTrimmed = false ;
|
|
ResetTrimRegion() ;
|
|
|
|
// dimensiono i vettori dei punti e dei pesi
|
|
m_vPtCtrl.assign( GetDim(), ORIG) ;
|
|
if ( bIsRational)
|
|
m_vWeCtrl.assign( GetDim(), 1) ;
|
|
else
|
|
m_vWeCtrl.clear() ;
|
|
m_nStatus = TO_VERIFY ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return Validate() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::SetControlPoint( int nInd, const Point3d& ptCtrl)
|
|
{
|
|
// verifico validità indice
|
|
if ( m_nStatus != OK || m_bRat || nInd < 0 || nInd >= GetDim())
|
|
return false ;
|
|
|
|
// assegno il valore
|
|
m_vPtCtrl[nInd] = ptCtrl ;
|
|
|
|
// se razionale, metto il peso a 1
|
|
if ( m_bRat)
|
|
m_vWeCtrl[nInd] = 1 ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::SetControlPoint( int nInd, const Point3d& ptCtrl, double dW)
|
|
{
|
|
// verifico validità, razionalità e indice
|
|
if ( m_nStatus != OK || ! m_bRat || nInd < 0 || nInd >= GetDim())
|
|
return false ;
|
|
|
|
// verifico che il peso non sia nullo o negativo
|
|
if ( dW < EPS_SMALL)
|
|
return false ;
|
|
|
|
// assegno il valore e il peso
|
|
m_vPtCtrl[nInd] = ptCtrl ;
|
|
m_vWeCtrl[nInd] = dW ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::SetTrimRegion( const ISurfFlatRegion& sfrTrimReg)
|
|
{
|
|
// verifico la regione passata
|
|
if ( &sfrTrimReg == nullptr || ! sfrTrimReg.IsValid())
|
|
return false ;
|
|
// limito la regione allo spazio parametrico della superficie
|
|
PtrOwner< ISurfFlatRegion> pSfrTrim( GetSurfFlatRegionRectangle( SBZ_TREG_COEFF * m_nSpanU, SBZ_TREG_COEFF * m_nSpanV)) ;
|
|
if ( IsNull( pSfrTrim) || ! pSfrTrim->Intersect( sfrTrimReg) || ! pSfrTrim->IsValid())
|
|
return false ;
|
|
// assegno la regione di trim
|
|
m_bTrimmed = true ;
|
|
delete m_pTrimReg ;
|
|
m_pTrimReg = GetBasicSurfFlatRegion( Release( pSfrTrim)) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetInfo( int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) const
|
|
{
|
|
// verifico validità superficie
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// restituisco gradi e flag di razionale
|
|
nDegU = m_nDegU ;
|
|
nDegV = m_nDegV ;
|
|
nSpanU = m_nSpanU ;
|
|
nSpanV = m_nSpanV ;
|
|
bIsRat = m_bRat ;
|
|
bTrimmed = m_bTrimmed ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const Point3d&
|
|
SurfBezier::GetControlPoint( int nInd, bool* pbOk) const
|
|
{
|
|
// verifico validità e indice
|
|
if ( m_nStatus != OK || nInd < 0 || nInd >= GetDim()) {
|
|
if ( pbOk != NULL)
|
|
*pbOk = false ;
|
|
return ORIG ;
|
|
}
|
|
// ritorno i dati
|
|
if ( pbOk != NULL)
|
|
*pbOk = true ;
|
|
return m_vPtCtrl[nInd] ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
double
|
|
SurfBezier::GetControlWeight( int nInd, bool* pbOk) const
|
|
{
|
|
// verifico validità, razionalità e indice
|
|
if ( m_nStatus != OK || ! m_bRat || nInd < 0 || nInd >= GetDim()) {
|
|
if ( pbOk != NULL)
|
|
*pbOk = false ;
|
|
return 0 ;
|
|
}
|
|
// ritorno i dati
|
|
if ( pbOk != NULL)
|
|
*pbOk = true ;
|
|
return m_vWeCtrl[nInd] ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::IsAPoint( void) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// ciclo sui punti
|
|
for ( int i = 1 ; i < GetDim() ; ++ i) {
|
|
if ( ! AreSamePointApprox( m_vPtCtrl[0], m_vPtCtrl[i]))
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetArea( double& dArea) const
|
|
{
|
|
// controllo parametro di ritorno
|
|
if ( &dArea == nullptr)
|
|
return false ;
|
|
// inizio con area nulla
|
|
dArea = 0 ;
|
|
// calcolo l'area
|
|
if ( ! GetAuxSurf())
|
|
return false ;
|
|
return m_pSTM->GetArea( dArea) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetCentroid( Point3d& ptCen) const
|
|
{
|
|
// controllo parametro di ritorno
|
|
if ( &ptCen == nullptr)
|
|
return false ;
|
|
// inizio con centro nell'origine
|
|
ptCen = ORIG ;
|
|
// calcolo il baricentro
|
|
if ( ! GetAuxSurf())
|
|
return false ;
|
|
return m_pSTM->GetCentroid( ptCen) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs,
|
|
Point3d& ptPos,
|
|
Vector3d* pvtDerU, Vector3d* pvtDerV, Vector3d* pvtDerUU, Vector3d* pvtDerVV, Vector3d* pvtDerUV) const
|
|
{
|
|
// la curva deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// i parametri U e V devono essere compresi tra 0 e il corrispondente numero di Span
|
|
dU = Clamp( dU, 0., double( m_nSpanU)) ;
|
|
dV = Clamp( dV, 0., double( m_nSpanV)) ;
|
|
|
|
// determino gli intervalli di span e riduco i parametri in essi
|
|
int nBsU = min( int( dU), m_nSpanU - 1) ;
|
|
double dLocU = dU - nBsU ;
|
|
if ( abs( dLocU) < 5 * EPS_PARAM && nBsU > 0 && nUs == ISurfBezier::FROM_MINUS) {
|
|
-- nBsU ;
|
|
dLocU = 1 ;
|
|
}
|
|
else if ( abs( dLocU) > 1 - 5 * EPS_PARAM && nBsU < m_nSpanU - 1 && nUs == ISurfBezier::FROM_PLUS) {
|
|
++ nBsU ;
|
|
dLocU = 0 ;
|
|
}
|
|
int nOffsU = nBsU * m_nDegU ;
|
|
int nBsV = min( int( dV), m_nSpanV - 1) ;
|
|
double dLocV = dV - nBsV ;
|
|
if ( abs( dLocV) < 5 * EPS_PARAM && nBsV > 0 && nVs == ISurfBezier::FROM_MINUS) {
|
|
-- nBsV ;
|
|
dLocV = 1 ;
|
|
}
|
|
else if ( abs( dLocV) > 1 - 5 * EPS_PARAM && nBsV < m_nSpanV - 1 && nVs == ISurfBezier::FROM_PLUS) {
|
|
++ nBsV ;
|
|
dLocV = 0 ;
|
|
}
|
|
int nOffsV = nBsV * m_nDegV ;
|
|
|
|
// se forma polinomiale (o integrale)
|
|
if ( ! m_bRat) {
|
|
|
|
// calcolo dei polinomi di Bernstein per U di grado opportuno
|
|
DBLVECTOR vBernU( m_nDegU + 1) ;
|
|
GetAllBernstein( dLocU, m_nDegU - 2, vBernU) ;
|
|
|
|
//// se richiesto, calcolo della derivata seconda
|
|
// if ( pvtDer2 != nullptr && pvtDer1 != nullptr) {
|
|
// *pvtDer2 = V_NULL ;
|
|
// for ( int i = 0 ; i <= m_nDeg - 2 ; ++ i) {
|
|
// *pvtDer2 += vBern[i] * ( m_vPtCtrl[i+2] + m_vPtCtrl[i] - 2 * m_vPtCtrl[i+1]) ;
|
|
// }
|
|
// *pvtDer2 *= m_nDeg * ( m_nDeg - 1) ;
|
|
// }
|
|
|
|
// aumento il grado
|
|
IncreaseAllBernsteinOneDegree( dLocU, m_nDegU - 1, vBernU) ;
|
|
|
|
// se richiesto, calcolo dei vettori intermedi per la derivata prima rispetto ad U
|
|
VCT3DVECTOR vtTemp1( m_nDegV + 1, V_NULL) ;
|
|
if ( pvtDerU != nullptr) {
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
for ( int i = 0 ; i <= m_nDegU - 1 ; ++ i)
|
|
vtTemp1[j] += vBernU[i] * ( m_vPtCtrl[GetInd( nOffsU + i + 1, nOffsV + j)] - m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)]) ;
|
|
vtTemp1[j] *= m_nDegU ;
|
|
}
|
|
}
|
|
|
|
// aumento il grado
|
|
IncreaseAllBernsteinOneDegree( dLocU, m_nDegU, vBernU) ;
|
|
|
|
// calcolo dei punti intermedi
|
|
PNTVECTOR ptTemp( m_nDegV + 1, ORIG) ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i)
|
|
ptTemp[j] += vBernU[i] * m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)] ;
|
|
}
|
|
|
|
// calcolo dei polinomi di Bernstein per V di grado opportuno
|
|
DBLVECTOR vBernV( m_nDegV + 1) ;
|
|
GetAllBernstein( dLocV, m_nDegV - 1, vBernV) ;
|
|
|
|
// se richiesto, calcolo della derivata prima rispetto a V
|
|
if ( pvtDerV != nullptr) {
|
|
*pvtDerV = V_NULL ;
|
|
for ( int j = 0 ; j <= m_nDegV - 1 ; ++ j)
|
|
*pvtDerV += vBernV[j] * ( ptTemp[j+1] - ptTemp[j]) ;
|
|
*pvtDerV *= m_nDegV ;
|
|
}
|
|
|
|
// aumento il grado
|
|
IncreaseAllBernsteinOneDegree( dLocV, m_nDegV, vBernV) ;
|
|
|
|
// calcolo del punto
|
|
ptPos = ORIG ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j)
|
|
ptPos += vBernV[j] * ptTemp[j] ;
|
|
|
|
// se richiesto, calcolo della derivata prima rispetto a U
|
|
if ( pvtDerU != nullptr) {
|
|
*pvtDerU = V_NULL ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j)
|
|
*pvtDerU += vBernV[j] * vtTemp1[j] ;
|
|
}
|
|
}
|
|
|
|
// altrimenti forma razionale
|
|
else {
|
|
|
|
// porto i punti in forma omogenea moltiplicandoli per i pesi
|
|
PNTVECTOR vPtWCtrl( GetLocDim()) ;
|
|
DBLVECTOR vWeCtrl( GetLocDim()) ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i) {
|
|
vPtWCtrl[GetLocInd( i, j)] = m_vWeCtrl[GetInd( nOffsU + i, nOffsV + j)] * m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)] ;
|
|
vWeCtrl[GetLocInd( i, j)] = m_vWeCtrl[GetInd( nOffsU + i, nOffsV + j)] ;
|
|
}
|
|
}
|
|
|
|
// calcolo dei polinomi di Bernstein di grado opportuno
|
|
DBLVECTOR vBernU( m_nDegU + 1) ;
|
|
GetAllBernstein( dLocU, m_nDegU - 2, vBernU) ;
|
|
|
|
//// se richiesto, calcolo della derivata seconda
|
|
// double dW2 = 0 ;
|
|
// if ( pvtDer2 != nullptr && pvtDer1 != nullptr) {
|
|
// *pvtDer2 = V_NULL ;
|
|
// for ( int i = 0 ; i <= m_nDeg - 2 ; ++ i) {
|
|
// *pvtDer2 += vBern[i] * ( vPtWCtrl[i+2] + vPtWCtrl[i] - 2 * vPtWCtrl[i+1]) ;
|
|
// dW2 += vBern[i] * ( m_vWeCtrl[i+2] + m_vWeCtrl[i] - 2 * m_vWeCtrl[i+1]) ;
|
|
// }
|
|
// *pvtDer2 *= m_nDeg * ( m_nDeg - 1) ;
|
|
// dW2 *= m_nDeg * ( m_nDeg - 1) ;
|
|
// }
|
|
|
|
// aumento il grado
|
|
IncreaseAllBernsteinOneDegree( dLocU, m_nDegU - 1, vBernU) ;
|
|
|
|
// se richiesto, calcolo dei vettori intermedi per la derivata prima rispetto ad U
|
|
VCT3DVECTOR vtTemp1( m_nDegV + 1, V_NULL) ;
|
|
DBLVECTOR dTemp1( m_nDegV + 1, 0) ;
|
|
if ( pvtDerU != nullptr) {
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
for ( int i = 0 ; i <= m_nDegU - 1 ; ++ i) {
|
|
vtTemp1[j] += vBernU[i] * ( vPtWCtrl[GetLocInd( i + 1, j)] - vPtWCtrl[GetLocInd( i, j)]) ;
|
|
dTemp1[j] += vBernU[i] * ( vWeCtrl[GetLocInd( i + 1, j)] - vWeCtrl[GetLocInd( i, j)]) ;
|
|
}
|
|
vtTemp1[j] *= m_nDegU ;
|
|
dTemp1[j] *= m_nDegU ;
|
|
}
|
|
}
|
|
|
|
// aumento il grado
|
|
IncreaseAllBernsteinOneDegree( dLocU, m_nDegU, vBernU) ;
|
|
|
|
// calcolo dei punti e pesi intermedi
|
|
PNTVECTOR ptTempW( m_nDegV + 1, ORIG) ;
|
|
DBLVECTOR dTempW( m_nDegV + 1, 0) ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i) {
|
|
ptTempW[j] += vBernU[i] * vPtWCtrl[GetLocInd( i, j)] ;
|
|
dTempW[j] += vBernU[i] * vWeCtrl[GetLocInd( i, j)] ;
|
|
}
|
|
}
|
|
|
|
// calcolo dei polinomi di Bernstein per V di grado opportuno
|
|
DBLVECTOR vBernV( m_nDegV + 1) ;
|
|
GetAllBernstein( dLocV, m_nDegV - 1, vBernV) ;
|
|
|
|
// se richiesto, calcolo della derivata prima rispetto a V
|
|
double dW1v = 0 ;
|
|
if ( pvtDerV != nullptr) {
|
|
*pvtDerV = V_NULL ;
|
|
for ( int j = 0 ; j <= m_nDegV - 1 ; ++ j) {
|
|
*pvtDerV += vBernV[j] * ( ptTempW[j+1] - ptTempW[j]) ;
|
|
dW1v += vBernV[j] * ( dTempW[j+1] - dTempW[j]) ;
|
|
}
|
|
*pvtDerV *= m_nDegV ;
|
|
dW1v *= m_nDegV ;
|
|
}
|
|
|
|
// aumento il grado
|
|
IncreaseAllBernsteinOneDegree( dLocV, m_nDegV, vBernV) ;
|
|
|
|
// calcolo del punto
|
|
double dW = 0 ;
|
|
ptPos = ORIG ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
ptPos += vBernV[j] * ptTempW[j] ;
|
|
dW += vBernV[j] * dTempW[j] ;
|
|
}
|
|
|
|
// ritrasformo da forma omogenea a forma standard
|
|
double dInvW = 1 / ( ( dW > EPS_ZERO) ? dW : EPS_ZERO) ;
|
|
ptPos *= dInvW ;
|
|
|
|
// se richiesto, calcolo della derivata prima rispetto a U
|
|
if ( pvtDerU != nullptr) {
|
|
*pvtDerU = V_NULL ;
|
|
double dW1u = 0 ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
*pvtDerU += vBernV[j] * vtTemp1[j] ;
|
|
dW1u += vBernV[j] * dTemp1[j] ;
|
|
}
|
|
Vector3d vtPos( ptPos.x, ptPos.y, ptPos.z) ;
|
|
*pvtDerU = ( *pvtDerU - dW1u * vtPos) * dInvW ;
|
|
}
|
|
|
|
// se richiesto, completo il calcolo della derivata prima rispetto a V
|
|
if ( pvtDerV != nullptr) {
|
|
Vector3d vtPos( ptPos.x, ptPos.y, ptPos.z) ;
|
|
*pvtDerV = ( *pvtDerV - dW1v * vtPos) * dInvW ;
|
|
}
|
|
|
|
//if ( pvtDer1 != nullptr) {
|
|
// Vector3d vtPos( ptPos.x, ptPos.y, ptPos.z) ;
|
|
// *pvtDer1 = ( *pvtDer1 - dW1 * vtPos) * dInvW ;
|
|
// if ( pvtDer2 != nullptr)
|
|
// *pvtDer2 = ( *pvtDer2 - 2 * dW1 * *pvtDer1 - dW2 * vtPos) * dInvW ;
|
|
//}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetPointNrmD1D2( double dU, double dV, Side nUs, Side nVs,
|
|
Point3d& ptPos, Vector3d& vtN,
|
|
Vector3d* pvtDerU, Vector3d* pvtDerV, Vector3d* pvtDerUU, Vector3d* pvtDerVV, Vector3d* pvtDerUV) const
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// i parametri U e V devono essere compresi tra 0 e il corrispondente numero di Span
|
|
dU = Clamp( dU, 0., double( m_nSpanU)) ;
|
|
dV = Clamp( dV, 0., double( m_nSpanV)) ;
|
|
|
|
// eseguo calcolo del punto con le derivate prime
|
|
Vector3d vtDerU ;
|
|
if ( pvtDerU == nullptr)
|
|
pvtDerU = &vtDerU ;
|
|
Vector3d vtDerV ;
|
|
if ( pvtDerV == nullptr)
|
|
pvtDerV = &vtDerV ;
|
|
GetPointD1D2( dU, dV, nUs, nVs, ptPos, pvtDerU, pvtDerV) ;
|
|
|
|
// calcolo la normale e la verifico
|
|
vtN = *pvtDerU ^ *pvtDerV ;
|
|
if ( vtN.Normalize())
|
|
return true ;
|
|
|
|
// se solo una delle due derivate è piccola, mi sposto lungo il relativo parametro e uso le tangenti
|
|
if ( pvtDerU->Len() < EPS_SMALL && pvtDerV->Len() > 10 * EPS_SMALL) {
|
|
double dCoeff = ( dU - 1000 * EPS_PARAM < 0. ? 1 : -1) ;
|
|
double dUm = dU + 1000 * EPS_PARAM * dCoeff ;
|
|
Point3d ptTmp ;
|
|
Vector3d vtTmpU, vtTmpV ;
|
|
GetPointD1D2( dUm, dV, nUs, nVs, ptTmp, &vtTmpU, &vtTmpV) ;
|
|
vtN = ( *pvtDerV ^ vtTmpV) * dCoeff ;
|
|
if ( vtN.Normalize())
|
|
return true ;
|
|
}
|
|
if ( pvtDerU->Len() > 10 * EPS_SMALL && pvtDerV->Len() < EPS_SMALL) {
|
|
double dCoeff = ( dV - 1000 * EPS_PARAM < 0. ? 1 : -1) ;
|
|
double dVm = dV + 1000 * EPS_PARAM * dCoeff ;
|
|
Point3d ptTmp ;
|
|
Vector3d vtTmpU, vtTmpV ;
|
|
GetPointD1D2( dU, dVm, nUs, nVs, ptTmp, &vtTmpU, &vtTmpV) ;
|
|
vtN = ( vtTmpU ^ *pvtDerU) * dCoeff ;
|
|
if ( vtN.Normalize())
|
|
return true ;
|
|
}
|
|
|
|
// ricalcolo con una piccola variazione di entrambi i parametri
|
|
double dUm ;
|
|
if ( dU - 100 * EPS_PARAM < 0.)
|
|
dUm = dU + 100 * EPS_PARAM ;
|
|
else
|
|
dUm = dU - 100 * EPS_PARAM ;
|
|
double dVm ;
|
|
if ( dV - 100 * EPS_PARAM < 0.)
|
|
dVm = dV + 100 * EPS_PARAM ;
|
|
else
|
|
dVm = dV - 100 * EPS_PARAM ;
|
|
Point3d ptTmp ;
|
|
GetPointD1D2( dUm, dVm, nUs, nVs, ptTmp, pvtDerU, pvtDerV) ;
|
|
vtN = *pvtDerU ^ *pvtDerV ;
|
|
return vtN.Normalize() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
SurfBezier*
|
|
SurfBezier::Clone( void) const
|
|
{
|
|
// alloco oggetto
|
|
SurfBezier* pSbz = new( nothrow) SurfBezier ;
|
|
if ( pSbz != nullptr) {
|
|
if ( ! pSbz->CopyFrom( *this)) {
|
|
delete pSbz ;
|
|
return nullptr ;
|
|
}
|
|
}
|
|
|
|
return pSbz ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::CopyFrom( const IGeoObj* pGObjSrc)
|
|
{
|
|
const SurfBezier* pSbz = GetBasicSurfBezier( pGObjSrc) ;
|
|
if ( pSbz == nullptr)
|
|
return false ;
|
|
return CopyFrom( *pSbz) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::CopyFrom( const SurfBezier& sbSrc)
|
|
{
|
|
if ( &sbSrc == this)
|
|
return true ;
|
|
if ( ! Init( sbSrc.m_nDegU, sbSrc.m_nDegV, sbSrc.m_nSpanU, sbSrc.m_nSpanV, sbSrc.m_bRat))
|
|
return false ;
|
|
m_nStatus = sbSrc.m_nStatus ;
|
|
m_vPtCtrl = sbSrc.m_vPtCtrl ;
|
|
if ( sbSrc.m_bRat)
|
|
m_vWeCtrl = sbSrc.m_vWeCtrl ;
|
|
m_nTempProp[0] = sbSrc.m_nTempProp[0] ;
|
|
m_nTempProp[1] = sbSrc.m_nTempProp[1] ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GeoObjType
|
|
SurfBezier::GetType( void) const
|
|
{
|
|
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( SurfBezier)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const string&
|
|
SurfBezier::GetTitle( void) const
|
|
{
|
|
static const string sTitle = "SurfBezier" ;
|
|
return sTitle ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Dump( string& sOut, bool bMM, const char* szNewLine) const
|
|
{
|
|
// verifico validità superficie
|
|
if ( m_nStatus != OK)
|
|
sOut += string( "Status=Invalid") + szNewLine ;
|
|
// area
|
|
double dArea ;
|
|
GetArea( dArea) ;
|
|
sOut += "Area=" + ToString( GetAreaInUiUnits( dArea, bMM),1) + szNewLine ;
|
|
// parametri : flag razionale
|
|
sOut += ( m_bRat ? "Rat" : "Int") ;
|
|
// flag trimmata
|
|
sOut += ( m_bTrimmed ? " Trim " : " Full") ;
|
|
// gradi in U e V
|
|
sOut += " DegU=" + ToString( m_nDegU) + " DegV=" + ToString( m_nDegV) ;
|
|
// pezze in U e V
|
|
sOut += " SpanU=" + ToString( m_nSpanU) + " SpanV=" + ToString( m_nSpanV) + szNewLine ;
|
|
// ciclo sui punti di controllo ( con pesi se razionale)
|
|
for ( int i = 0 ; i < GetDim() ; ++ i) {
|
|
sOut += "PC(" + ToString( GetInUiUnits( m_vPtCtrl[i], bMM), 3) ;
|
|
if ( m_bRat)
|
|
sOut += "," + ToString( m_vWeCtrl[i], 3) ;
|
|
sOut += string( ")") + szNewLine ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
SurfBezier::GetNgeId( void) const
|
|
{
|
|
return GEOOBJ_GETNGEID( SurfBezier) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Save( NgeWriter& ngeOut) const
|
|
{
|
|
// flag razionale
|
|
if ( ! ngeOut.WriteBool( m_bRat, ";"))
|
|
return false ;
|
|
// flag trimmata
|
|
if ( ! ngeOut.WriteBool( m_bTrimmed, ";"))
|
|
return false ;
|
|
// gradi
|
|
if ( ! ngeOut.WriteInt( m_nDegU, ",") ||
|
|
! ngeOut.WriteInt( m_nDegV, ";", false))
|
|
return false ;
|
|
// pezze
|
|
if ( ! ngeOut.WriteInt( m_nSpanU, ",") ||
|
|
! ngeOut.WriteInt( m_nSpanV, ";", true))
|
|
return false ;
|
|
// ciclo sui punti di controllo ( con pesi se razionale)
|
|
for ( int i = 0 ; i < GetDim() ; ++ i) {
|
|
if ( ! m_bRat) {
|
|
if ( ! ngeOut.WritePoint( m_vPtCtrl[i], ";", true))
|
|
return false ;
|
|
}
|
|
else {
|
|
if ( ! ngeOut.WritePointW( m_vPtCtrl[i], m_vWeCtrl[i], ";", true))
|
|
return false ;
|
|
}
|
|
}
|
|
// se trimmata, scrittura della regione
|
|
if ( m_bTrimmed) {
|
|
// recupero il gestore di lettura/scrittura della regione
|
|
const IGeoObjRW* pSFrRW = dynamic_cast<const IGeoObjRW*>( m_pTrimReg) ;
|
|
if ( pSFrRW == nullptr)
|
|
return false ;
|
|
// salvataggio della regione
|
|
if ( ! pSFrRW->Save( ngeOut))
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Load( NgeReader& ngeIn)
|
|
{
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
// leggo la prossima linea ( 3 parametri)
|
|
// recupero il flag razionale
|
|
bool bIsRat ;
|
|
if ( ! ngeIn.ReadBool( bIsRat, ";"))
|
|
return false ;
|
|
// recupero il flag trimmata
|
|
bool bTrimmed ;
|
|
if ( ! ngeIn.ReadBool( bTrimmed, ";"))
|
|
return false ;
|
|
// recupero i gradi
|
|
int nDegU, nDegV ;
|
|
if ( ! ngeIn.ReadInt( nDegU, ",") ||
|
|
! ngeIn.ReadInt( nDegV, ";"))
|
|
return false ;
|
|
// recupero le pezze
|
|
int nSpanU, nSpanV ;
|
|
if ( ! ngeIn.ReadInt( nSpanU, ",") ||
|
|
! ngeIn.ReadInt( nSpanV, ";", true))
|
|
return false ;
|
|
// inizializzo la superficie di Bezier
|
|
if ( ! Init( nDegU, nDegV, nSpanU, nSpanV, bIsRat))
|
|
return false ;
|
|
// se integrale
|
|
if ( ! bIsRat) {
|
|
// recupero e setto punti di controllo
|
|
Point3d ptP ;
|
|
for ( int i = 0 ; i < GetDim() ; ++ i) {
|
|
// leggo la prossima linea ( un punto)
|
|
if ( ! ngeIn.ReadPoint( ptP, ";", true))
|
|
return false ;
|
|
// lo assegno
|
|
if ( ! SetControlPoint( i, ptP))
|
|
return false ;
|
|
}
|
|
}
|
|
// altrimenti razionale
|
|
else {
|
|
// recupero e setto punti di controllo
|
|
Point3d ptP ;
|
|
double dW ;
|
|
for ( int i = 0 ; i < GetDim() ; ++ i) {
|
|
// leggo la prossima linea ( un punto con peso)
|
|
if ( ! ngeIn.ReadPointW( ptP, dW, ";", true))
|
|
return false ;
|
|
// lo assegno
|
|
if ( ! SetControlPoint( i, ptP, dW))
|
|
return false ;
|
|
}
|
|
}
|
|
// se trimmata, lettura della regione
|
|
if ( m_bTrimmed) {
|
|
// creo l'oggetto
|
|
ResetTrimRegion() ;
|
|
m_pTrimReg = CreateBasicSurfFlatRegion() ;
|
|
if ( m_pTrimReg == nullptr)
|
|
return false ;
|
|
// ne leggo i dati
|
|
IGeoObjRW* pGObjRW = dynamic_cast<IGeoObjRW*>( m_pTrimReg) ;
|
|
if ( pGObjRW == nullptr || pGObjRW->Load( ngeIn))
|
|
return false ;
|
|
}
|
|
|
|
// eseguo validazione
|
|
return Validate() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Validate( void)
|
|
{
|
|
if ( m_nStatus == TO_VERIFY)
|
|
m_nStatus = ( ( m_nDegU * m_nDegV > 0 && m_vPtCtrl.size() > 0) ? OK : ERR) ;
|
|
|
|
return ( m_nStatus == OK) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
|
|
{
|
|
// basta approssimato
|
|
if ( ( nFlag & BBF_EXACT) == 0) {
|
|
for ( int i = 0 ; i < GetDim() ; ++ i) {
|
|
Point3d ptTemp = m_vPtCtrl[i] ;
|
|
b3Loc.Add( ptTemp) ;
|
|
}
|
|
return true ;
|
|
}
|
|
// deve essere preciso
|
|
else {
|
|
// verifico esistenza trimesh associata
|
|
if ( ! GetAuxSurf())
|
|
return false ;
|
|
// calcolo il box della trimesh
|
|
return m_pSTM->GetLocalBBox( b3Loc, nFlag) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
|
|
{
|
|
// basta approssimato
|
|
if ( ( nFlag & BBF_EXACT) == 0) {
|
|
for ( int i = 0 ; i < GetDim() ; ++ i) {
|
|
Point3d ptTemp = m_vPtCtrl[i] ;
|
|
ptTemp.ToGlob( frRef) ;
|
|
b3Ref.Add( ptTemp) ;
|
|
}
|
|
return true ;
|
|
}
|
|
// deve essere preciso
|
|
else {
|
|
// verifico esistenza trimesh associata
|
|
if ( ! GetAuxSurf())
|
|
return false ;
|
|
// calcolo il box della trimesh
|
|
return m_pSTM->GetBBox( frRef, b3Ref, nFlag) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Translate( const Vector3d& vtMove)
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// traslo i punti di controllo
|
|
for ( auto& ptP : m_vPtCtrl)
|
|
ptP.Translate( vtMove) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità dell'asse di rotazione
|
|
if ( vtAx.IsSmall())
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// ruoto i punti di controllo
|
|
for ( auto& ptP : m_vPtCtrl)
|
|
ptP.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico non sia nulla
|
|
if ( abs( dCoeffX) < EPS_ZERO && abs( dCoeffY) < EPS_ZERO && abs( dCoeffZ) < EPS_ZERO)
|
|
return false ;
|
|
|
|
// calcolo bbox allineato con riferimento di scalatura e senza tener conto dello spessore
|
|
// lo scalo per verificare se tutto si riduce a un punto o una linea (solo se diretta come assi ref)
|
|
BBox3d b3Ref ;
|
|
if ( ! GetBBox( frRef, b3Ref))
|
|
return false ;
|
|
Vector3d vtDelta = b3Ref.GetMax() - b3Ref.GetMin() ;
|
|
bool bZeroX = ( abs( vtDelta.x * dCoeffX) < EPS_SMALL) ;
|
|
bool bZeroY = ( abs( vtDelta.y * dCoeffY) < EPS_SMALL) ;
|
|
bool bZeroZ = ( abs( vtDelta.z * dCoeffZ) < EPS_SMALL) ;
|
|
if ( ( bZeroX && bZeroY) || ( bZeroX && bZeroZ) || ( bZeroY && bZeroZ))
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// scalo i punti di controllo
|
|
for ( auto& ptP : m_vPtCtrl)
|
|
ptP.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità del piano di specchiatura
|
|
if ( vtNorm.IsSmall())
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// specchio i punti di controllo
|
|
for ( auto& ptP : m_vPtCtrl)
|
|
ptP.Mirror( ptOn, vtNorm) ;
|
|
|
|
// eseguo invert per mantenere l'orientazione
|
|
return Invert() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff)
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità dei parametri
|
|
if ( vtNorm.IsSmall() || vtDir.IsSmall())
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// eseguo scorrimento dei punti di controllo
|
|
for ( auto& ptP : m_vPtCtrl)
|
|
ptP.Shear( ptOn, vtNorm, vtDir, dCoeff) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::ToGlob( const Frame3d& frRef)
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
|
|
// se frame identità, non devo fare alcunché
|
|
if ( IsGlobFrame( frRef))
|
|
return true ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// trasformo i punti di controllo
|
|
for ( auto& ptP : m_vPtCtrl)
|
|
ptP.ToGlob( frRef) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::ToLoc( const Frame3d& frRef)
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
|
|
// se frame identità, non devo fare alcunché
|
|
if ( IsGlobFrame( frRef))
|
|
return true ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// trasformo i punti di controllo
|
|
for ( auto& ptP : m_vPtCtrl)
|
|
ptP.ToLoc( frRef) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità dei frame
|
|
if ( frOri.GetType() == Frame3d::ERR || frDest.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
|
|
// se i due riferimenti coincidono, non devo fare alcunché
|
|
if ( AreSameFrame( frOri, frDest))
|
|
return true ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// trasformo i punti di controllo
|
|
for ( auto& ptP : m_vPtCtrl)
|
|
ptP.LocToLoc( frOri, frDest) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::Invert( void)
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetAuxSurf() ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// inverto
|
|
PNTVECTOR vPtCtrl = m_vPtCtrl ;
|
|
int l = 0 ;
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i) {
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
int k = i + ( m_nDegU + 1) * j ;
|
|
m_vPtCtrl[l] = vPtCtrl[k] ;
|
|
++ l ;
|
|
}
|
|
}
|
|
if ( m_bRat) {
|
|
DBLVECTOR vWeCtrl = m_vWeCtrl ;
|
|
int lr = 0 ;
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i) {
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
int k = i + ( m_nDegU + 1) * j ;
|
|
m_vWeCtrl[lr] = vWeCtrl[k] ;
|
|
++ lr ;
|
|
}
|
|
}
|
|
}
|
|
swap( m_nDegU, m_nDegV) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
SurfBezier::GetSteps( int nDeg, int nSpan, double dLen, int nQuality) const
|
|
{
|
|
const double dCoeff[] = { 0, 1, 2, 2.4, 2.8, 3, 3, 3, 3, 3, 3, 3} ;
|
|
nDeg = Clamp( nDeg, 0, MAXDEG) ;
|
|
nSpan = max( nSpan, 1) ;
|
|
nQuality = Clamp( nQuality, 1, 10) ;
|
|
double dMult = sqrt( max( dLen / nSpan, 10.)) ;
|
|
return ( nSpan * int( dMult * dCoeff[nDeg] * 2 / nQuality)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
CurveComposite*
|
|
SurfBezier::GetCurveOnU( double dV) const
|
|
{
|
|
// controlli
|
|
if ( dV < - EPS_PARAM || dV > m_nSpanV + EPS_PARAM)
|
|
return nullptr ;
|
|
dV = Clamp( dV, 0., double( m_nSpanV)) ;
|
|
|
|
// determino l'intervallo di span in V e riduco i parametri in essi
|
|
int nBsV = min( int( dV), m_nSpanV - 1) ;
|
|
double dLocV = dV - nBsV ;
|
|
int nOffsV = nBsV * m_nDegV ;
|
|
|
|
// se forma polinomiale (o integrale)
|
|
if ( ! m_bRat) {
|
|
// preparazione della curva composita
|
|
PtrOwner<CurveComposite> pCrvCo( CreateBasicCurveComposite()) ;
|
|
// ciclo sugli intervalli
|
|
for ( int k = 0 ; k < m_nSpanU ; ++ k) {
|
|
// preparazione della curva di Bezier
|
|
PtrOwner<CurveBezier> pCbz( CreateBasicCurveBezier()) ;
|
|
if ( IsNull( pCbz) || ! pCbz->Init( m_nDegU, false))
|
|
return nullptr ;
|
|
// calcolo dei polinomi di Bernstein per V di grado opportuno
|
|
DBLVECTOR vBernV( m_nDegV + 1) ;
|
|
GetAllBernstein( dLocV, m_nDegV, vBernV) ;
|
|
// calcolo offset in U
|
|
int nOffsU = k * m_nDegU ;
|
|
// calcolo dei punti di controllo della curva
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i) {
|
|
Point3d ptP = ORIG ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j)
|
|
ptP += vBernV[j] * m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)] ;
|
|
pCbz->SetControlPoint( i, ptP) ;
|
|
}
|
|
// inserisco la curva della pezza in quella complessiva
|
|
if ( ! IsNull( pCbz))
|
|
pCrvCo->AddCurve( Release( pCbz)) ;
|
|
}
|
|
return Release( pCrvCo) ;
|
|
}
|
|
// altrimenti forma razionale
|
|
else {
|
|
// preparazione della curva composita
|
|
PtrOwner<CurveComposite> pCrvCo( CreateBasicCurveComposite()) ;
|
|
// ciclo sugli intervalli
|
|
for ( int k = 0 ; k < m_nSpanU ; ++ k) {
|
|
// preparazione della curva di Bezier
|
|
PtrOwner<CurveBezier> pCbz( CreateBasicCurveBezier()) ;
|
|
if ( IsNull( pCbz) || ! pCbz->Init( m_nDegU, true))
|
|
return nullptr ;
|
|
// calcolo dei polinomi di Bernstein per V di grado opportuno
|
|
DBLVECTOR vBernV( m_nDegV + 1) ;
|
|
GetAllBernstein( dLocV, m_nDegV, vBernV) ;
|
|
// calcolo offset in U
|
|
int nOffsU = k * m_nDegU ;
|
|
// porto i punti in forma omogenea moltiplicandoli per i pesi
|
|
PNTVECTOR vPtWCtrl( GetLocDim()) ;
|
|
DBLVECTOR vWeCtrl( GetLocDim()) ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i) {
|
|
vPtWCtrl[GetLocInd( i, j)] = m_vWeCtrl[GetInd( nOffsU + i, nOffsV + j)] * m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)] ;
|
|
vWeCtrl[GetLocInd( i, j)] = m_vWeCtrl[GetInd( nOffsU + i, nOffsV + j)] ;
|
|
}
|
|
}
|
|
// calcolo dei punti di controllo della curva
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i) {
|
|
Point3d ptP = ORIG ;
|
|
double dW = 0 ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
ptP += vBernV[j] * vPtWCtrl[GetLocInd( i, j)] ;
|
|
dW += vBernV[j] * vWeCtrl[GetLocInd( i, j)] ;
|
|
}
|
|
double dInvW = 1 / ( ( dW > EPS_ZERO) ? dW : EPS_ZERO) ;
|
|
pCbz->SetControlPoint( i, ptP * dInvW, dW) ;
|
|
}
|
|
// inserisco la curva della pezza in quella complessiva
|
|
if ( ! IsNull( pCbz))
|
|
pCrvCo->AddCurve( Release( pCbz)) ;
|
|
}
|
|
return Release( pCrvCo) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
CurveComposite*
|
|
SurfBezier::GetCurveOnV( double dU) const
|
|
{
|
|
// controlli
|
|
if ( dU < - EPS_PARAM || dU > m_nSpanU + EPS_PARAM)
|
|
return nullptr ;
|
|
dU = Clamp( dU, 0., double( m_nSpanU)) ;
|
|
|
|
// determino l'intervallo di span in U e riduco i parametri in essi
|
|
int nBsU = min( int( dU), m_nSpanU - 1) ;
|
|
double dLocU = dU - nBsU ;
|
|
int nOffsU = nBsU * m_nDegU ;
|
|
|
|
// se forma polinomiale (o integrale)
|
|
if ( ! m_bRat) {
|
|
// preparazione della curva composita
|
|
PtrOwner<CurveComposite> pCrvCo( CreateBasicCurveComposite()) ;
|
|
// ciclo sugli intervalli
|
|
for ( int k = 0 ; k < m_nSpanV ; ++ k) {
|
|
// preparazione della curva di Bezier
|
|
PtrOwner<CurveBezier> pCbz( CreateBasicCurveBezier()) ;
|
|
if ( IsNull( pCbz) || ! pCbz->Init( m_nDegV, false))
|
|
return nullptr ;
|
|
// calcolo dei polinomi di Bernstein per U di grado opportuno
|
|
DBLVECTOR vBernU( m_nDegU + 1) ;
|
|
GetAllBernstein( dLocU, m_nDegU, vBernU) ;
|
|
// calcolo offset in V
|
|
int nOffsV = k * m_nDegV ;
|
|
// calcolo dei punti di controllo della curva
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
Point3d ptP = ORIG ;
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i)
|
|
ptP += vBernU[i] * m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)] ;
|
|
pCbz->SetControlPoint( j, ptP) ;
|
|
}
|
|
// inserisco la curva della pezza in quella complessiva
|
|
if ( ! IsNull( pCbz))
|
|
pCrvCo->AddCurve( Release( pCbz)) ;
|
|
}
|
|
return Release( pCrvCo) ;
|
|
}
|
|
// altrimenti forma razionale
|
|
else {
|
|
// preparazione della curva composita
|
|
PtrOwner<CurveComposite> pCrvCo( CreateBasicCurveComposite()) ;
|
|
// ciclo sugli intervalli
|
|
for ( int k = 0 ; k < m_nSpanV ; ++ k) {
|
|
// preparazione della curva di Bezier
|
|
PtrOwner<CurveBezier> pCbz( CreateBasicCurveBezier()) ;
|
|
if ( IsNull( pCbz) || ! pCbz->Init( m_nDegV, true))
|
|
return nullptr ;
|
|
// calcolo dei polinomi di Bernstein per U di grado opportuno
|
|
DBLVECTOR vBernU( m_nDegU + 1) ;
|
|
GetAllBernstein( dLocU, m_nDegU, vBernU) ;
|
|
// calcolo offset in V
|
|
int nOffsV = k * m_nDegV ;
|
|
// porto i punti in forma omogenea moltiplicandoli per i pesi
|
|
PNTVECTOR vPtWCtrl( GetLocDim()) ;
|
|
DBLVECTOR vWeCtrl( GetLocDim()) ;
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i) {
|
|
vPtWCtrl[GetLocInd( i, j)] = m_vWeCtrl[GetInd( nOffsU + i, nOffsV + j)] * m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)] ;
|
|
vWeCtrl[GetLocInd( i, j)] = m_vWeCtrl[GetInd( nOffsU + i, nOffsV + j)] ;
|
|
}
|
|
}
|
|
// calcolo dei punti di controllo della curva
|
|
for ( int j = 0 ; j <= m_nDegV ; ++ j) {
|
|
Point3d ptP = ORIG ;
|
|
double dW = 0 ;
|
|
for ( int i = 0 ; i <= m_nDegU ; ++ i) {
|
|
ptP += vBernU[i] * vPtWCtrl[GetLocInd( i, j)] ;
|
|
dW += vBernU[i] * vWeCtrl[GetLocInd( i, j)] ;
|
|
}
|
|
double dInvW = 1 / ( ( dW > EPS_ZERO) ? dW : EPS_ZERO) ;
|
|
pCbz->SetControlPoint( j, ptP * dInvW, dW) ;
|
|
}
|
|
// inserisco la curva della pezza in quella complessiva
|
|
if ( ! IsNull( pCbz))
|
|
pCrvCo->AddCurve( Release( pCbz)) ;
|
|
}
|
|
return Release( pCrvCo) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
CurveComposite*
|
|
SurfBezier::GetLoop( int nLoop) const
|
|
{
|
|
// Se superficie completa, basta concatenare le 4 isoparametriche di bordo
|
|
if ( ! m_bTrimmed) {
|
|
// Esiste solo il loop esterno
|
|
if ( nLoop != 0)
|
|
return nullptr ;
|
|
// Loop
|
|
PtrOwner<CurveComposite> pLoop( CreateBasicCurveComposite()) ;
|
|
// prima curva isoparametrica in U con V=0
|
|
PtrOwner<CurveComposite> pCrvCoU0( GetCurveOnU( 0)) ;
|
|
if ( ! IsNull( pCrvCoU0) && ! pCrvCoU0->IsAPoint())
|
|
pLoop->AddCurve( Release( pCrvCoU0)) ;
|
|
// seconda curva isoparametrica in V con U=m_nSpanU
|
|
PtrOwner<CurveComposite> pCrvCoV1( GetCurveOnV( m_nSpanU)) ;
|
|
if ( ! IsNull( pCrvCoV1) && ! pCrvCoV1->IsAPoint())
|
|
pLoop->AddCurve( Release( pCrvCoV1)) ;
|
|
// terza curva isoparametrica in U con V=m_nSpanV invertita
|
|
PtrOwner<CurveComposite> pCrvCoU1( GetCurveOnU( m_nSpanV)) ;
|
|
if ( ! IsNull( pCrvCoU1) && ! pCrvCoU1->IsAPoint()) {
|
|
pCrvCoU1->Invert() ;
|
|
pLoop->AddCurve( Release( pCrvCoU1)) ;
|
|
}
|
|
// quarta curva isoparametrica in V con U=0 invertita
|
|
PtrOwner<CurveComposite> pCrvCoV0( GetCurveOnV( 0)) ;
|
|
if ( ! IsNull( pCrvCoV0) && ! pCrvCoV0->IsAPoint()) {
|
|
pCrvCoV0->Invert() ;
|
|
pLoop->AddCurve( Release( pCrvCoV0)) ;
|
|
}
|
|
// se loop chiuso lo restituisco, altrimenti errore
|
|
return ( pLoop->IsClosed() ? Release( pLoop) : nullptr) ;
|
|
}
|
|
// altrimenti trimmata, per ora non gestita
|
|
else
|
|
return nullptr ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetCurveOnU( double dV, int nStep, PolyLine& plCrvU) const
|
|
{
|
|
// controlli
|
|
plCrvU.Clear() ;
|
|
if ( dV < - EPS_PARAM || dV > m_nSpanV + EPS_PARAM)
|
|
return false ;
|
|
dV = Clamp( dV, 0., double( m_nSpanV)) ;
|
|
// recupero la curva
|
|
PtrOwner<CurveComposite> pCrvCo( GetCurveOnU( dV)) ;
|
|
if ( IsNull( pCrvCo))
|
|
return false ;
|
|
// ciclo sulle curve componenti (tutte curve di Bezier)
|
|
int i = 0 ;
|
|
const ICurve* pSCrv = pCrvCo->GetFirstCurve() ;
|
|
while ( pSCrv != nullptr) {
|
|
const CurveBezier* pCbz = GetBasicCurveBezier( pSCrv) ;
|
|
if ( pCbz == NULL)
|
|
return false ;
|
|
int nCurrSpanStep = nStep / m_nSpanU ;
|
|
if ( nCurrSpanStep <= 0) {
|
|
double dLenU = 0 ;
|
|
pCbz->GetApproxLength( dLenU) ;
|
|
nCurrSpanStep = GetSteps( m_nDegU, 1, dLenU, 2) ;
|
|
}
|
|
PolyLine plCurr ;
|
|
if ( ! pCbz->ApproxWithLines( nCurrSpanStep, plCurr))
|
|
return false ;
|
|
plCrvU.Join( plCurr, i) ;
|
|
++ i ;
|
|
pSCrv = pCrvCo->GetNextCurve() ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetCurveOnV( double dU, int nStep, PolyLine& plCrvV) const
|
|
{
|
|
// controlli
|
|
plCrvV.Clear() ;
|
|
if ( dU < - EPS_PARAM || dU > m_nSpanU + EPS_PARAM)
|
|
return false ;
|
|
dU = Clamp( dU, 0., double( m_nSpanU)) ;
|
|
// recupero la curva
|
|
PtrOwner<CurveComposite> pCrvCo( GetCurveOnV( dU)) ;
|
|
if ( IsNull( pCrvCo))
|
|
return false ;
|
|
// ciclo sulle curve componenti (tutte curve di Bezier)
|
|
int i = 0 ;
|
|
const ICurve* pSCrv = pCrvCo->GetFirstCurve() ;
|
|
while ( pSCrv != nullptr) {
|
|
const CurveBezier* pCbz = GetBasicCurveBezier( pSCrv) ;
|
|
if ( pCbz == NULL)
|
|
return false ;
|
|
int nCurrSpanStep = nStep / m_nSpanU ;
|
|
if ( nCurrSpanStep <= 0) {
|
|
double dLenV = 0 ;
|
|
pCbz->GetApproxLength( dLenV) ;
|
|
nCurrSpanStep = GetSteps( m_nDegV, 1, dLenV, 2) ;
|
|
}
|
|
PolyLine plCurr ;
|
|
if ( ! pCbz->ApproxWithLines( nCurrSpanStep, plCurr))
|
|
return false ;
|
|
plCrvV.Join( plCurr, i) ;
|
|
++ i ;
|
|
pSCrv = pCrvCo->GetNextCurve() ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetControlCurveOnU( int nIndV, PolyLine& plCtrlU) const
|
|
{
|
|
plCtrlU.Clear() ;
|
|
if ( nIndV < 0 || nIndV > m_nDegV * m_nSpanV)
|
|
return false ;
|
|
for ( int i = 0 ; i <= m_nDegU * m_nSpanU ; ++ i)
|
|
plCtrlU.AddUPoint( double( i) / m_nDegU, m_vPtCtrl[GetInd( i, nIndV)]) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
SurfBezier::GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const
|
|
{
|
|
plCtrlV.Clear() ;
|
|
if ( nIndU < 0 || nIndU > m_nDegU * m_nSpanU)
|
|
return false ;
|
|
for ( int j = 0 ; j <= m_nDegV * m_nSpanV ; ++ j)
|
|
plCtrlV.AddUPoint( double( j) / m_nDegV, m_vPtCtrl[GetInd( nIndU, j)]) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
double
|
|
SurfBezier::GetCurveOnUApproxLen( double dV) const
|
|
{
|
|
PtrOwner<CurveComposite> pCrvCo( GetCurveOnU( dV)) ;
|
|
double dLen ;
|
|
if ( IsNull( pCrvCo) || ! pCrvCo->GetApproxLength( dLen))
|
|
return 0 ;
|
|
return dLen ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
double
|
|
SurfBezier::GetCurveOnVApproxLen( double dU) const
|
|
{
|
|
PtrOwner<CurveComposite> pCrvCo( GetCurveOnV( dU)) ;
|
|
double dLen ;
|
|
if ( IsNull( pCrvCo) || ! pCrvCo->GetApproxLength( dLen))
|
|
return 0 ;
|
|
return dLen ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const SurfTriMesh*
|
|
SurfBezier::GetAuxSurf( void) const
|
|
{
|
|
// la superficie deve essere validata
|
|
if ( m_nStatus != OK) {
|
|
ResetAuxSurf() ;
|
|
return nullptr ;
|
|
}
|
|
// se già calcolata, la restituisco
|
|
if ( m_pSTM != nullptr)
|
|
return m_pSTM ;
|
|
// costruttore della superficie
|
|
StmFromTriangleSoup stmSoup ;
|
|
if ( ! stmSoup.Start())
|
|
return nullptr ;
|
|
// definisco il numero degli step in U e in V
|
|
double dMaxLenU = 0 ;
|
|
for ( int j = 0 ; j <= m_nDegV * m_nSpanV ; ++ j)
|
|
dMaxLenU = max( dMaxLenU, GetCurveOnUApproxLen( double( j) / m_nDegV)) ;
|
|
int nStepU = GetSteps( m_nDegU, m_nSpanU, dMaxLenU, 2) ;
|
|
double dMaxLenV = 0 ;
|
|
for ( int i = 0 ; i <= m_nDegU * m_nSpanU ; ++ i)
|
|
dMaxLenV = max( dMaxLenV, GetCurveOnVApproxLen( double( i) / m_nDegU)) ;
|
|
int nStepV = GetSteps( m_nDegV, m_nSpanV, dMaxLenV, 2) ;
|
|
// prima curva isoparametrica (potrebbe essere un solo punto)
|
|
PolyLine PL1 ;
|
|
GetCurveOnU( 0, nStepU, PL1) ;
|
|
bool bSingle1 = ( PL1.GetPointNbr() == 1) ;
|
|
// ciclo sulle isoparametriche
|
|
for ( int i = 1 ; i <= nStepV ; ++ i) {
|
|
// seconda curva isoparametrica (con tanti punti quanti la prima, oppure uno solo)
|
|
double dV = double( i) * m_nSpanV / nStepV ;
|
|
PolyLine PL2 ;
|
|
GetCurveOnU( dV, nStepU, PL2) ;
|
|
bool bSingle2 = ( PL2.GetPointNbr() == 1) ;
|
|
// inserisco i triangoli della striscia nel costruttore della TriMesh
|
|
Point3d ptP1c, ptP2c ;
|
|
Point3d ptP1n, ptP2n ;
|
|
bool bNext = PL1.GetFirstPoint( ptP1c) && PL2.GetFirstPoint( ptP2c) ;
|
|
if ( bNext) {
|
|
if ( bSingle1 && bSingle2)
|
|
bNext = false ;
|
|
if ( bSingle1)
|
|
ptP1n = ptP1c ;
|
|
else
|
|
bNext = bNext && PL1.GetNextPoint( ptP1n) ;
|
|
if ( bSingle2)
|
|
ptP2n = ptP2c ;
|
|
else
|
|
bNext = bNext && PL2.GetNextPoint( ptP2n) ;
|
|
}
|
|
while ( bNext) {
|
|
// eventuale primo triangolo (con base sui correnti e vertice su P2 successivo)
|
|
if ( ! AreSamePointApprox( ptP1c, ptP2c))
|
|
stmSoup.AddTriangle( ptP2c, ptP1c, ptP2n) ;
|
|
// eventuale secondo triangolo (con vertice su P1 corrente e base sui successivi)
|
|
if ( ! AreSamePointApprox( ptP1n, ptP2n))
|
|
stmSoup.AddTriangle( ptP1c, ptP1n, ptP2n) ;
|
|
// passo alla successiva coppia
|
|
ptP1c = ptP1n ;
|
|
ptP2c = ptP2n ;
|
|
bNext = ( bSingle1 || PL1.GetNextPoint( ptP1n)) && ( bSingle2 || PL2.GetNextPoint( ptP2n)) ;
|
|
}
|
|
// salvo isoparametrica PL2 in PL1
|
|
PL1.GetUPointList().swap( PL2.GetUPointList()) ;
|
|
bSingle1 = bSingle2 ;
|
|
}
|
|
// la completo
|
|
if ( ! stmSoup.End())
|
|
return nullptr ;
|
|
// la salvo
|
|
m_pSTM = GetBasicSurfTriMesh( stmSoup.GetSurf()) ;
|
|
return m_pSTM ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
SurfBezier::ResetAuxSurf( void) const
|
|
{
|
|
if ( m_pSTM != nullptr)
|
|
delete( m_pSTM) ;
|
|
m_pSTM = nullptr ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
SurfBezier::ResetTrimRegion( void)
|
|
{
|
|
if ( m_pTrimReg != nullptr)
|
|
delete( m_pTrimReg) ;
|
|
m_pTrimReg = nullptr ;
|
|
}
|