EgtGeomKernel 1.5e2 :
- creazione STM per rototraslazione e da due curve.
This commit is contained in:
Dario Sassi
+373
-127
@@ -749,7 +749,7 @@ SurfTriMesh::AdjustTopology( void)
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
SurfTriMesh::CreateByTriangulation( const PolyLine& PL)
|
||||
SurfTriMesh::CreateByFlatContour( const PolyLine& PL)
|
||||
{
|
||||
// eseguo la triangolazione
|
||||
PNTVECTOR vPnt ;
|
||||
@@ -788,10 +788,14 @@ SurfTriMesh::CreateByTriangulation( const PolyLine& PL)
|
||||
bool
|
||||
SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
|
||||
{
|
||||
// verifico che il vettore di estrusione sia non nullo
|
||||
// il vettore di estrusione deve essere non nullo
|
||||
if ( vtExtr.IsSmall())
|
||||
return false ;
|
||||
|
||||
// la polilinea deve avere almeno 2 punti
|
||||
if ( PL.GetPointNbr() < 2)
|
||||
return false ;
|
||||
|
||||
// verifico se la polilinea è chiusa
|
||||
bool bClosed = PL.IsClosed() ;
|
||||
|
||||
@@ -801,44 +805,201 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
|
||||
return false ;
|
||||
|
||||
// inserisco il primo vertice della polilinea e il suo estruso
|
||||
int nP = 0 ;
|
||||
int nV = -1 ;
|
||||
Point3d ptP ;
|
||||
if ( ! PL.GetFirstPoint( ptP))
|
||||
return false ;
|
||||
++ nP ;
|
||||
if ( AddVertex( ptP) == SVT_NULL || AddVertex( ptP + vtExtr) == SVT_NULL)
|
||||
return false ;
|
||||
nV += 2 ;
|
||||
// ciclo sui punti della polilinea (per inserire vertice e suo estruso + 2 triangoli per ogni punto)
|
||||
int nIdV[4] ;
|
||||
while ( PL.GetNextPoint( ptP, bClosed)) {
|
||||
// aggiungo due nuovi vertici
|
||||
if ( AddVertex( ptP) == SVT_NULL || AddVertex( ptP + vtExtr) == SVT_NULL)
|
||||
return false ;
|
||||
nV += 2 ;
|
||||
// aggiungo i due triangoli relativi
|
||||
nIdV[0] = nV - 2 ;
|
||||
nIdV[1] = nV - 3 ;
|
||||
nIdV[2] = nV - 1 ;
|
||||
nIdV[3] = nV ;
|
||||
if ( ! AddBiTriangle( nIdV))
|
||||
return false ;
|
||||
}
|
||||
// se curva chiusa, aggiungo gli ultimi due triangoli
|
||||
if ( bClosed) {
|
||||
// non devo aggiungere i vertici, perchè coincidono con quelli iniziali
|
||||
// aggiungo i due triangoli relativi
|
||||
nIdV[0] = nV ;
|
||||
nIdV[1] = nV - 1 ;
|
||||
nIdV[2] = 0 ;
|
||||
nIdV[3] = 1 ;
|
||||
if ( ! AddBiTriangle( nIdV))
|
||||
return false ;
|
||||
}
|
||||
|
||||
// sistemo la topologia
|
||||
return AdjustTopology() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2)
|
||||
{
|
||||
// verifico validità polilinee (devono avere almeno 2 punti e non coincidere se non agli estremi aperti)
|
||||
if ( ! VerifyPolylinesForTwoCurves( PL1, PL2))
|
||||
return false ;
|
||||
// flag di curve chiuse
|
||||
bool bClosed = PL1.IsClosed() && PL2.IsClosed() ;
|
||||
// recupero i parametri delle due polilinee
|
||||
double dU1F ; PL1.GetFirstU( dU1F) ;
|
||||
double dU1L ; PL1.GetLastU( dU1L) ;
|
||||
double dDeltaU1 = dU1L - dU1F ;
|
||||
if ( dDeltaU1 < EPS_SMALL)
|
||||
return false ;
|
||||
double dU2F ; PL2.GetFirstU( dU2F) ;
|
||||
double dU2L ; PL2.GetLastU( dU2L) ;
|
||||
double dDeltaU2 = dU2L - dU2F ;
|
||||
if ( dDeltaU2 < EPS_SMALL)
|
||||
return false ;
|
||||
|
||||
// costruisco la mesh
|
||||
int nPointNbr = PL1.GetPointNbr() + PL2.GetPointNbr() ;
|
||||
if ( ! Init( nPointNbr, nPointNbr))
|
||||
return false ;
|
||||
|
||||
// recupero i punti iniziali su curva 1
|
||||
int nV1p ; double dU1p ; double dA1p ; Point3d ptP1p ;
|
||||
int nV1s ; double dU1s ; double dA1s ; Point3d ptP1s ;
|
||||
bool bNext1 = PL1.GetFirstUPoint( &dU1p, &ptP1p) && PL1.GetNextUPoint( &dU1s, &ptP1s, bClosed) ;
|
||||
if ( ! bNext1)
|
||||
return false ;
|
||||
dA1p = 0 ;
|
||||
dA1s = ( dU1s - dU1F) / dDeltaU1 ;
|
||||
if ( ( nV1p = AddVertex( ptP1p)) == SVT_NULL)
|
||||
return false ;
|
||||
// recupero i punti iniziali su curva 2
|
||||
int nV2p ; double dU2p ; double dA2p ; Point3d ptP2p ;
|
||||
int nV2s ; double dU2s ; double dA2s ; Point3d ptP2s ;
|
||||
bool bNext2 = PL2.GetFirstUPoint( &dU2p, &ptP2p) && PL2.GetNextUPoint( &dU2s, &ptP2s, bClosed) ;
|
||||
if ( ! bNext2)
|
||||
return false ;
|
||||
dA2p = 0 ;
|
||||
dA2s = ( dU2s - dU2F) / dDeltaU2 ;
|
||||
int nIdV[3] ;
|
||||
while ( PL.GetNextPoint( ptP)) {
|
||||
// incremento numero punto
|
||||
++ nP ;
|
||||
// se polilinea aperta o non è l'ultimo punto
|
||||
if ( ! bClosed || nP < nPointNbr) {
|
||||
// aggiungo due nuovi vertici
|
||||
if ( AddVertex( ptP) == SVT_NULL || AddVertex( ptP + vtExtr) == SVT_NULL)
|
||||
// se i punti iniziali non coincidono, inserisco il vertice iniziale di 2
|
||||
if ( ! AreSamePointNear( ptP1p, ptP2p)) {
|
||||
if ( ( nV2p = AddVertex( ptP2p)) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// altrimenti, inserisco un triangolo e mi sposto in avanti su entrambe le curve
|
||||
else {
|
||||
// inserisco il vertice A1s
|
||||
if ( ( nV1s = AddVertex( ptP1s)) == SVT_NULL)
|
||||
return false ;
|
||||
// inserisco il vertice A2s
|
||||
if ( ( nV2s = AddVertex( ptP2s)) == SVT_NULL)
|
||||
return false ;
|
||||
// inserisco il triangolo A1p -> A1s -> A2s
|
||||
nIdV[0] = nV1p ;
|
||||
nIdV[1] = nV1s ;
|
||||
nIdV[2] = nV2s ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
// passo al punto successivo su 1
|
||||
nV1p = nV1s ; dA1p = dA1s ; dU1p = dU1s ; ptP1p = ptP1s ;
|
||||
bNext1 = PL1.GetNextUPoint( &dU1s, &ptP1s, bClosed) ;
|
||||
if ( bNext1)
|
||||
dA1s = ( dU1s - dU1F) / dDeltaU1 ;
|
||||
// passo al punto successivo su 2
|
||||
nV2p = nV2s ; dA2p = dA2s ; dU2p = dU2s ; ptP2p = ptP2s ;
|
||||
bNext2 = PL2.GetNextUPoint( &dU2s, &ptP2s, bClosed) ;
|
||||
if ( bNext2)
|
||||
dA2s = ( dU2s - dU2F) / dDeltaU2 ;
|
||||
}
|
||||
// ciclo sui punti
|
||||
while ( bNext1 || bNext2) {
|
||||
// se la diagonale più corta è dA2p -> dA1s
|
||||
if ( ( dA1s - dA2p) <= ( dA2s - dA1p) + EPS_PARAM) {
|
||||
// inserisco il vertice A1s
|
||||
if ( ( nV1s = AddVertex( ptP1s)) == SVT_NULL)
|
||||
return false ;
|
||||
nV += 2 ;
|
||||
// aggiungo triangolo in basso a sinistra
|
||||
nIdV[0] = nV - 3 ; nIdV[1] = nV - 1 ; nIdV[2] = nV - 2 ;
|
||||
// inserisco il triangolo A2p -> A1p -> A1s
|
||||
nIdV[0] = nV2p ;
|
||||
nIdV[1] = nV1p ;
|
||||
nIdV[2] = nV1s ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
// aggiungo triangolo in alto a destra
|
||||
nIdV[0] = nV - 2 ; nIdV[1] = nV - 1 ; nIdV[2] = nV ;
|
||||
// se i punti correnti coincidono passo al successivo anche su 2
|
||||
if ( AreSamePointNear( ptP1s, ptP2s)) {
|
||||
nV2p = nV2s ; dA2p = dA2s ; dU2p = dU2s ; ptP2p = ptP2s ;
|
||||
bNext2 = PL2.GetNextUPoint( &dU2s, &ptP2s, bClosed) ;
|
||||
if ( bNext2)
|
||||
dA2s = ( dU2s - dU2F) / dDeltaU2 ;
|
||||
}
|
||||
// passo al punto successivo su 1
|
||||
nV1p = nV1s ; dA1p = dA1s ; dU1p = dU1s ; ptP1p = ptP1s ;
|
||||
bNext1 = PL1.GetNextUPoint( &dU1s, &ptP1s, bClosed) ;
|
||||
if ( bNext1)
|
||||
dA1s = ( dU1s - dU1F) / dDeltaU1 ;
|
||||
}
|
||||
// altrimenti è dA1p -> dA2s
|
||||
else {
|
||||
// inserisco il vertice A2s
|
||||
if ( ( nV2s = AddVertex( ptP2s)) == SVT_NULL)
|
||||
return false ;
|
||||
// inserisco il triangolo A2p -> A1p -> A2s
|
||||
nIdV[0] = nV2p ;
|
||||
nIdV[1] = nV1p ;
|
||||
nIdV[2] = nV2s ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
// se i punti correnti coincidono passo al successivo anche su 1
|
||||
if ( AreSamePointNear( ptP1s, ptP2s)) {
|
||||
nV1p = nV1s ; dA1p = dA1s ; dU1p = dU1s ; ptP1p = ptP1s ;
|
||||
bNext1 = PL1.GetNextUPoint( &dU1s, &ptP1s, bClosed) ;
|
||||
if ( bNext1)
|
||||
dA1s = ( dU1s - dU1F) / dDeltaU1 ;
|
||||
}
|
||||
// passo al punto successivo su 2
|
||||
nV2p = nV2s ; dA2p = dA2s ; dU2p = dU2s ; ptP2p = ptP2s ;
|
||||
bNext2 = PL2.GetNextUPoint( &dU2s, &ptP2s, bClosed) ;
|
||||
if ( bNext2)
|
||||
dA2s = ( dU2s - dU2F) / dDeltaU2 ;
|
||||
}
|
||||
}
|
||||
// se curve chiuse, aggiungo gli ultimi due triangoli
|
||||
if ( bClosed) {
|
||||
dA1s = 1 ;
|
||||
dA2s = 1 ;
|
||||
// se la diagonale più corta è dA2p -> dA1s = 0
|
||||
if ( ( dA1s - dA2p) <= ( dA2s - dA1p) + EPS_PARAM) {
|
||||
// inserisco il triangolo A2p -> A1p -> A1s = 0
|
||||
nIdV[0] = nV2p ;
|
||||
nIdV[1] = nV1p ;
|
||||
nIdV[2] = 0 ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
// inserisco il triangolo A2p -> A1s = 0 -> A2s = 1
|
||||
nIdV[0] = nV2p ;
|
||||
nIdV[1] = 0 ;
|
||||
nIdV[2] = 1 ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// altrimenti ultimo punto di polilinea chiusa
|
||||
// altrimenti è dA1p -> dA2s = 1
|
||||
else {
|
||||
// non devo aggiungere i vertici, perchè coincidono con quelli iniziali
|
||||
// aggiungo triangolo in basso a sinistra
|
||||
nIdV[0] = nV - 1 ; nIdV[1] = 0 ; nIdV[2] = nV ;
|
||||
// inserisco il triangolo A2p -> A1p -> A2s = 1
|
||||
nIdV[0] = nV2p ;
|
||||
nIdV[1] = nV1p ;
|
||||
nIdV[2] = 1 ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
// aggiungo triangolo in alto a destra
|
||||
nIdV[0] = nV ; nIdV[1] = 0 ; nIdV[2] = 1 ;
|
||||
// inserisco il triangolo A1p -> A1s = 0 -> A2s = 1
|
||||
nIdV[0] = nV1p ;
|
||||
nIdV[1] = 0 ;
|
||||
nIdV[2] = 1 ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
@@ -848,21 +1009,107 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
|
||||
return AdjustTopology() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
SurfTriMesh::VerifyPolylinesForTwoCurves( const PolyLine& PL1, const PolyLine& PL2) const
|
||||
{
|
||||
// recupero se chiusa
|
||||
bool bClosed = PL1.IsClosed() && PL2.IsClosed() ;
|
||||
// se chiuse, devono avere almeno 3 punti
|
||||
if ( bClosed) {
|
||||
if ( PL1.GetPointNbr() < 3 || PL2.GetPointNbr() < 3)
|
||||
return false ;
|
||||
}
|
||||
// se aperte, almeno 2
|
||||
else {
|
||||
if ( PL1.GetPointNbr() < 2 || PL2.GetPointNbr() < 2)
|
||||
return false ;
|
||||
}
|
||||
|
||||
// verifico che non ci siano punti interni in comune a pari parametro
|
||||
// recupero i parametri delle due polilinee
|
||||
double dU1F ; PL1.GetFirstU( dU1F) ;
|
||||
double dU1L ; PL1.GetLastU( dU1L) ;
|
||||
double dDeltaU1 = dU1L - dU1F ;
|
||||
if ( dDeltaU1 < EPS_SMALL)
|
||||
return false ;
|
||||
double dU2F ; PL2.GetFirstU( dU2F) ;
|
||||
double dU2L ; PL2.GetLastU( dU2L) ;
|
||||
double dDeltaU2 = dU2L - dU2F ;
|
||||
if ( dDeltaU2 < EPS_SMALL)
|
||||
return false ;
|
||||
// ciclo sui punti
|
||||
double dA1p ; double dU1p ; Point3d ptP1p ;
|
||||
double dA1s ; double dU1s ; Point3d ptP1s ;
|
||||
bool bNext1 = PL1.GetFirstUPoint( &dU1p, &ptP1p) && PL1.GetNextUPoint( &dU1s, &ptP1s) ;
|
||||
if ( ! bNext1)
|
||||
return false ;
|
||||
dA1p = 0 ;
|
||||
dA1s = ( dU1s - dU1F) / dDeltaU1 ;
|
||||
double dA2p ; double dU2s ; Point3d ptP2s ;
|
||||
double dA2s ; double dU2p ; Point3d ptP2p ;
|
||||
bool bNext2 = PL2.GetFirstUPoint( &dU2p, &ptP2p) && PL2.GetNextUPoint( &dU2s, &ptP2s) ;
|
||||
if ( ! bNext2)
|
||||
return false ;
|
||||
dA2p = 0 ;
|
||||
dA2s = ( dU2s - dU2F) / dDeltaU2 ;
|
||||
// se chiuse, verifico la coincidenza dell'inizio delle due curve
|
||||
if ( bClosed && AreSamePointNear( ptP1p, ptP2p))
|
||||
return false ;
|
||||
// verifiche sui punti successivi (non sugli ultimi)
|
||||
while ( bNext1 || bNext2) {
|
||||
// se la diagonale più corta è dA2p -> dA1s
|
||||
if ( ( dA1s - dA2p) <= ( dA2s - dA1p) + EPS_PARAM) {
|
||||
// verifico se coincidono
|
||||
if ( AreSamePointNear( ptP2p, ptP1s))
|
||||
return false ;
|
||||
// passo al punto successivo su 1
|
||||
dA1p = dA1s ; dU1p = dU1s ; ptP1p = ptP1s ;
|
||||
bNext1 = PL1.GetNextUPoint( &dU1s, &ptP1s, true) ;
|
||||
if ( bNext1)
|
||||
dA1s = ( dU1s - dU1F) / dDeltaU1 ;
|
||||
}
|
||||
// altrimenti è dA1p -> dA2s = 1
|
||||
else {
|
||||
// verifico se coincidono
|
||||
if ( AreSamePointNear( ptP1p, ptP2s))
|
||||
return false ;
|
||||
// passo al punto successivo su 2
|
||||
dA2p = dA2s ; dU2p = dU2s ; ptP2p = ptP2s ;
|
||||
bNext2 = PL2.GetNextUPoint( &dU2s, &ptP2s, true) ;
|
||||
if ( bNext2)
|
||||
dA2s = ( dU2s - dU2F) / dDeltaU2 ;
|
||||
}
|
||||
}
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
SurfTriMesh::CreateByRevolution( const PolyLine& PL, const Point3d& ptAx, const Vector3d& vtAx,
|
||||
double dAngRot, double dStepRot)
|
||||
{
|
||||
return CreateByScrewing( PL, ptAx, vtAx, dAngRot, dStepRot, 0) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Vector3d& vtAx,
|
||||
double dAngRot, double dStepRot, double dMove)
|
||||
{
|
||||
// verifico che l'asse di rotazione sia non nullo
|
||||
if ( vtAx.IsSmall())
|
||||
return false ;
|
||||
// verifico che l'angolo di rotazione sia significativo e non superi un giro
|
||||
// verifico se solo rivoluzione
|
||||
bool bOnlyRev = ( fabs( dMove) < EPS_SMALL) ;
|
||||
// verifico che l'angolo di rotazione sia significativo e, se solo rivoluzione, non superi un giro
|
||||
if ( fabs( dAngRot) < EPS_ANG_SMALL)
|
||||
return false ;
|
||||
if ( fabs( dAngRot) > ANG_FULL)
|
||||
if ( bOnlyRev && fabs( dAngRot) > ANG_FULL)
|
||||
dAngRot = _copysign( ANG_FULL, dAngRot) ;
|
||||
// verifico se rotazione completa
|
||||
bool bFullRev = ( fabs( fabs( dAngRot) - ANG_FULL) < EPS_ANG_SMALL) ;
|
||||
bool bFullRev = bOnlyRev && ( fabs( fabs( dAngRot) - ANG_FULL) < EPS_ANG_SMALL) ;
|
||||
// aggiusto il valore dell'angolo di step
|
||||
const double MIN_STEP_ROT = 1 ;
|
||||
const double MAX_STEP_ROT = 90 ;
|
||||
@@ -875,7 +1122,9 @@ SurfTriMesh::CreateByRevolution( const PolyLine& PL, const Point3d& ptAx, const
|
||||
// calcolo il numero di step
|
||||
int nStep = int( dAngRot / dStepRot) ;
|
||||
nStep = max( nStep, 1) ;
|
||||
dStepRot = dAngRot / nStep ;
|
||||
double dCosStepRot = cos( dAngRot / nStep * DEGTORAD) ;
|
||||
double dSinStepRot = sin( dAngRot / nStep * DEGTORAD) ;
|
||||
Vector3d vtStepMove = ( dMove / nStep) * vtAx ;
|
||||
if ( bFullRev)
|
||||
-- nStep ;
|
||||
|
||||
@@ -894,24 +1143,24 @@ SurfTriMesh::CreateByRevolution( const PolyLine& PL, const Point3d& ptAx, const
|
||||
return false ;
|
||||
|
||||
// inserisco il primo punto della polilinea e i suoi ruotati
|
||||
int nP = 0 ;
|
||||
int nV = -1 ;
|
||||
Point3d ptP ;
|
||||
// recupero il punto
|
||||
if ( ! PL.GetFirstPoint( ptP))
|
||||
return false ;
|
||||
++ nP ;
|
||||
// inserisco il primo vertice
|
||||
if ( AddVertex( ptP) == SVT_NULL)
|
||||
return false ;
|
||||
++ nV ;
|
||||
// verifico se il punto giace sull'asse
|
||||
bool bPrevOnAx = DistPointLine( ptP, ptAx, vtAx, 1, false).IsSmall() ;
|
||||
// verifico se il punto giace sull'asse e vi sta fisso
|
||||
bool bPrevOnAx = bOnlyRev && DistPointLine( ptP, ptAx, vtAx, 1, false).IsSmall() ;
|
||||
int nVPrevOnAx = nV ;
|
||||
// se non è sull'asse, inserisco le copie ruotate
|
||||
// se non è fisso sull'asse, inserisco le copie ruotate
|
||||
if ( ! bPrevOnAx) {
|
||||
for ( int i = 1 ; i <= nStep ; ++i) {
|
||||
ptP.Rotate( ptAx, vtAx, dStepRot * DEGTORAD) ;
|
||||
ptP.Rotate( ptAx, vtAx, dCosStepRot, dSinStepRot) ;
|
||||
if ( ! bOnlyRev)
|
||||
ptP.Translate( vtStepMove) ;
|
||||
if ( AddVertex( ptP) == SVT_NULL)
|
||||
return false ;
|
||||
++ nV ;
|
||||
@@ -919,108 +1168,105 @@ SurfTriMesh::CreateByRevolution( const PolyLine& PL, const Point3d& ptAx, const
|
||||
}
|
||||
// ciclo sui punti della polilinea (per inserire vertice e suoi ruotati + 2 triangoli per ogni punto)
|
||||
int nIdV[4] ;
|
||||
while ( PL.GetNextPoint( ptP)) {
|
||||
// incremento numero punto
|
||||
++ nP ;
|
||||
// se polilinea aperta o non è l'ultimo punto
|
||||
if ( ! bClosed || nP < nPointNbr) {
|
||||
// aggiungo il primo vertice
|
||||
if ( AddVertex( ptP) == SVT_NULL)
|
||||
return false ;
|
||||
++ nV ;
|
||||
// verifico se il punto giace sull'asse
|
||||
bool bOnAx = DistPointLine( ptP, ptAx, vtAx, 1, false).IsSmall() ;
|
||||
// ciclo sugli step
|
||||
for ( int i = 1 ; i <= nStep ; ++i) {
|
||||
// se non è sull'asse, inserisco le copie ruotate
|
||||
if ( ! bOnAx) {
|
||||
ptP.Rotate( ptAx, vtAx, dStepRot * DEGTORAD) ;
|
||||
if ( AddVertex( ptP) == SVT_NULL)
|
||||
return false ;
|
||||
++ nV ;
|
||||
}
|
||||
// per i controlli già fatti non è possibile avere contemp. prec e corr su asse
|
||||
// se il precedente è sull'asse, aggiungo un solo triangolo
|
||||
if ( bPrevOnAx) {
|
||||
nIdV[0] = nVPrevOnAx ;
|
||||
nIdV[1] = nV ;
|
||||
nIdV[2] = nV - 1 ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// se il corrente è sull'asse, aggiungo un solo triangolo
|
||||
else if ( bOnAx) {
|
||||
nIdV[0] = nV - ( nStep + 2) + i ;
|
||||
nIdV[1] = nIdV[0] + 1 ;
|
||||
nIdV[2] = nV ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// altrimenti aggiungo due triangoli
|
||||
else {
|
||||
nIdV[0] = nV - ( nStep + 2) ;
|
||||
nIdV[1] = nIdV[0] + 1 ;
|
||||
nIdV[2] = nV ;
|
||||
nIdV[3] = nV - 1 ;
|
||||
if ( ! AddBiTriangle( nIdV))
|
||||
return false ;
|
||||
}
|
||||
while ( PL.GetNextPoint( ptP, bClosed)) {
|
||||
// aggiungo il primo vertice
|
||||
if ( AddVertex( ptP) == SVT_NULL)
|
||||
return false ;
|
||||
++ nV ;
|
||||
// verifico se il punto giace sull'asse e vi sta fisso
|
||||
bool bOnAx = bOnlyRev && DistPointLine( ptP, ptAx, vtAx, 1, false).IsSmall() ;
|
||||
// ciclo sugli step
|
||||
for ( int i = 1 ; i <= nStep ; ++i) {
|
||||
// se non è fisso sull'asse, inserisco le copie ruotate
|
||||
if ( ! bOnAx) {
|
||||
ptP.Rotate( ptAx, vtAx, dCosStepRot, dSinStepRot) ;
|
||||
if ( ! bOnlyRev)
|
||||
ptP.Translate( vtStepMove) ;
|
||||
if ( AddVertex( ptP) == SVT_NULL)
|
||||
return false ;
|
||||
++ nV ;
|
||||
}
|
||||
// se rivoluzione completa, aggiungo i due triangoli di chiusura
|
||||
if ( bFullRev) {
|
||||
// per i controlli già fatti non è possibile avere contemp. prec e corr su asse
|
||||
// se il precedente è sull'asse, aggiungo un solo triangolo
|
||||
if ( bPrevOnAx) {
|
||||
nIdV[0] = nVPrevOnAx ;
|
||||
nIdV[1] = nV - nStep ;
|
||||
nIdV[2] = nV ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// se il corrente è sull'asse, aggiungo un solo triangolo
|
||||
else if ( bOnAx) {
|
||||
nIdV[0] = nV - 1 ;
|
||||
nIdV[1] = nV - ( nStep + 1) ;
|
||||
nIdV[2] = nV ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// altrimenti aggiungo due triangoli
|
||||
else {
|
||||
nIdV[0] = nV - ( nStep + 1) ;
|
||||
nIdV[1] = nV - ( 2 * nStep + 1) ;
|
||||
nIdV[2] = nV - nStep ;
|
||||
nIdV[3] = nV ;
|
||||
if ( ! AddBiTriangle( nIdV))
|
||||
return false ;
|
||||
}
|
||||
// per i controlli già fatti non è possibile avere contemp. prec e corr su asse
|
||||
// se il precedente è sull'asse, aggiungo un solo triangolo
|
||||
if ( bPrevOnAx) {
|
||||
nIdV[0] = nVPrevOnAx ;
|
||||
nIdV[1] = nV ;
|
||||
nIdV[2] = nV - 1 ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// se il corrente è sull'asse, aggiungo un solo triangolo
|
||||
else if ( bOnAx) {
|
||||
nIdV[0] = nV - ( nStep + 2) + i ;
|
||||
nIdV[1] = nIdV[0] + 1 ;
|
||||
nIdV[2] = nV ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// altrimenti aggiungo due triangoli
|
||||
else {
|
||||
nIdV[0] = nV - ( nStep + 2) ;
|
||||
nIdV[1] = nIdV[0] + 1 ;
|
||||
nIdV[2] = nV ;
|
||||
nIdV[3] = nV - 1 ;
|
||||
if ( ! AddBiTriangle( nIdV))
|
||||
return false ;
|
||||
}
|
||||
bPrevOnAx = false ;
|
||||
}
|
||||
// altrimenti ultimo punto di polilinea chiusa
|
||||
else {
|
||||
for ( int i = 1 ; i <= nStep ; ++i) {
|
||||
// non devo aggiungere i vertici, perchè coincidono con quelli iniziali
|
||||
// aggiungo triangolo in basso a sinistra
|
||||
nIdV[0] = nV - nStep + i - 1 ; nIdV[1] = nV - nStep + i ; nIdV[2] = i ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
// aggiungo triangolo in alto a destra
|
||||
nIdV[0] = nV - nStep + i - 1 ; nIdV[1] = i ; nIdV[2] = i - 1 ;
|
||||
// se rivoluzione completa, aggiungo i due triangoli di chiusura
|
||||
if ( bFullRev) {
|
||||
// per i controlli già fatti non è possibile avere contemp. prec e corr su asse
|
||||
// se il precedente è sull'asse, aggiungo un solo triangolo
|
||||
if ( bPrevOnAx) {
|
||||
nIdV[0] = nVPrevOnAx ;
|
||||
nIdV[1] = nV - nStep ;
|
||||
nIdV[2] = nV ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// se rivoluzione completa, aggiungo i due triangoli di chiusura
|
||||
if ( bFullRev) {
|
||||
// aggiungo triangolo in basso a sinistra
|
||||
nIdV[0] = nV ; nIdV[1] = nV - nStep ; nIdV[2] = 0 ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
// aggiungo triangolo in alto a destra
|
||||
nIdV[0] = nV ; nIdV[1] = 0 ; nIdV[2] = nStep ;
|
||||
// se il corrente è sull'asse, aggiungo un solo triangolo
|
||||
else if ( bOnAx) {
|
||||
nIdV[0] = nV - 1 ;
|
||||
nIdV[1] = nV - ( nStep + 1) ;
|
||||
nIdV[2] = nV ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// altrimenti aggiungo due triangoli
|
||||
else {
|
||||
nIdV[0] = nV - ( nStep + 1) ;
|
||||
nIdV[1] = nV - ( 2 * nStep + 1) ;
|
||||
nIdV[2] = nV - nStep ;
|
||||
nIdV[3] = nV ;
|
||||
if ( ! AddBiTriangle( nIdV))
|
||||
return false ;
|
||||
}
|
||||
}
|
||||
bPrevOnAx = false ;
|
||||
}
|
||||
// altrimenti ultimo punto di polilinea chiusa
|
||||
if ( bClosed) {
|
||||
for ( int i = 1 ; i <= nStep ; ++i) {
|
||||
// non devo aggiungere i vertici, perchè coincidono con quelli iniziali
|
||||
// aggiungo triangolo in basso a sinistra
|
||||
nIdV[0] = nV - nStep + i - 1 ; nIdV[1] = nV - nStep + i ; nIdV[2] = i ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
// aggiungo triangolo in alto a destra
|
||||
nIdV[0] = nV - nStep + i - 1 ; nIdV[1] = i ; nIdV[2] = i - 1 ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
// se rivoluzione completa, aggiungo i due triangoli di chiusura
|
||||
if ( bFullRev) {
|
||||
// aggiungo triangolo in basso a sinistra
|
||||
nIdV[0] = nV ; nIdV[1] = nV - nStep ; nIdV[2] = 0 ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
// aggiungo triangolo in alto a destra
|
||||
nIdV[0] = nV ; nIdV[1] = 0 ; nIdV[2] = nStep ;
|
||||
if ( AddTriangle( nIdV) == SVT_NULL)
|
||||
return false ;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1078,9 +1324,9 @@ SurfTriMesh::AddBiTriangle( const int nIdVert[4])
|
||||
// | |
|
||||
// 1 -> 2
|
||||
int nIdV[3] ;
|
||||
// se la diagonale 0->2 è più corta della 1->3
|
||||
// se la diagonale 0->2 è uguale o più corta della 1->3
|
||||
if ( SqDist( m_vVert[nIdVert[0]].ptP, m_vVert[nIdVert[2]].ptP) <=
|
||||
SqDist( m_vVert[nIdVert[1]].ptP, m_vVert[nIdVert[3]].ptP)) {
|
||||
SqDist( m_vVert[nIdVert[1]].ptP, m_vVert[nIdVert[3]].ptP) + EPS_SMALL) {
|
||||
// triangolo 0->1->2
|
||||
nIdV[0] = nIdVert[0] ;
|
||||
nIdV[1] = nIdVert[1] ;
|
||||
|
||||
Reference in New Issue
Block a user