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

EgtGeomKernel 1.5e6 :

Browse Source 
- aggiunto PointGrid3d (griglia hash per ricerca spaziale veloce di punti)
- aggiunti Compacting e Sewing a SurfTriMesh
- razionalizzazioni a GdbExecutor.
This commit is contained in:
Dario Sassi
2014-05-18 09:28:31 +00:00
parent 7bcd0813f9
commit ea3099ae74
11 changed files with 731 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SurfTriMesh.cpp
+256 -54
View File
@@ -19,7 +19,9 @@
#include "NgeReader.h"
#include "DistPointLine.h"
#include "Triangulate.h"
#include "GeoConst.h"
#include "\EgtDev\Include\EGkStringUtils3d.h"
#include "\EgtDev\Include\EGkPointGrid3d.h"
#include "\EgtDev\Include\EGkPolyLine.h"
#include <new>
@@ -30,8 +32,9 @@ GEOOBJ_REGISTER( SRF_TRIMESH, NGE_S_TRM, SurfTriMesh) ;
//----------------------------------------------------------------------------
SurfTriMesh::SurfTriMesh( void)
: m_nStatus( TO_VERIFY), m_bClosed( false)
: m_nStatus( TO_VERIFY), m_dLinTol( STM_STD_LIN_TOL), m_dSmoothAng( STM_STD_SMOOTH_ANG), m_bClosed( false)
{
m_dCosSmAng = cos( m_dSmoothAng * DEGTORAD) ;
}
//----------------------------------------------------------------------------
@@ -169,6 +172,34 @@ SurfTriMesh::SetTriangle( int nInd, const StmTria& tT)
return true ;
}
//----------------------------------------------------------------------------
int
SurfTriMesh::GetVertexNum( void) const
{
// calcolo il numero dei vertici cancellati
int nErased = 0 ;
for ( int nId = 0 ; nId < GetVertexSize() ; ++ nId) {
if ( m_vVert[nId].nIdTria == SVT_DEL)
++ nErased ;
}
return ( GetVertexSize() - nErased) ;
}
//----------------------------------------------------------------------------
int
SurfTriMesh::GetTriangleNum( void) const
{
// calcolo il numero dei triangoli cancellati
int nErased = 0 ;
for ( int nId = 0 ; nId < GetTriangleSize() ; ++ nId) {
if ( m_vTria[nId].nIdVert[0] == SVT_DEL)
++ nErased ;
}
return ( GetTriangleSize() - nErased) ;
}
//----------------------------------------------------------------------------
int
SurfTriMesh::GetFirstVertex( Point3d& ptP) const
@@ -183,9 +214,9 @@ SurfTriMesh::GetNextVertex( int nId, Point3d& ptP) const
// cerco il primo successivo valido
do {
nId ++ ;
} while ( nId < GetVertexNum() && m_vVert[nId].nIdTria == SVT_DEL) ;
} while ( nId < GetVertexSize() && m_vVert[nId].nIdTria == SVT_DEL) ;
// se oltrepassata fine
if ( nId >= GetVertexNum())
if ( nId >= GetVertexSize())
return SVT_NULL ;
// recupero i dati
ptP = m_vVert[nId].ptP ;
@@ -207,9 +238,9 @@ SurfTriMesh::GetNextTriangle( int nId, Triangle3d& Tria) const
// cerco il primo successivo valido
do {
nId ++ ;
} while ( nId < GetTriangleNum() && m_vTria[nId].nIdVert[0] == SVT_DEL) ;
} while ( nId < GetTriangleSize() && m_vTria[nId].nIdVert[0] == SVT_DEL) ;
// se oltrepassata fine
if ( nId >= GetTriangleNum())
if ( nId >= GetTriangleSize())
return SVT_NULL ;
// recupero i dati
Tria.Set( m_vVert[m_vTria[nId].nIdVert[0]].ptP,
@@ -225,7 +256,7 @@ bool
SurfTriMesh::GetTriangleSmoothNormals( int nId, TriNormals3d& TNrms) const
{
// verifico esistenza del triangolo
if ( nId >= GetTriangleNum() || m_vTria[nId].nIdVert[0] == SVT_DEL)
if ( nId >= GetTriangleSize() || m_vTria[nId].nIdVert[0] == SVT_DEL)
return false ;
// recupero le normali di ciascun vertice
@@ -261,13 +292,12 @@ SurfTriMesh::GetTriangleSmoothNormal( int nT, int nV, Vector3d& vtN) const
// medio le normali, finché non incontro degli spigoli
vtN = m_vTria[nT].vtN ;
const double COS_DEV_LIM = cos( 22.5 * DEGTORAD) ;
// parto dal triangolo e vado in direzione positiva
int nLim = nPos ;
for ( int i = NextIndAroundVertex( nPos, nTria, bCirc) ;
i != nPos && i < int( vT.size()) ;
i = NextIndAroundVertex( i, nTria, bCirc)) {
if ( m_vTria[vT[nPos]].vtN * m_vTria[vT[i]].vtN >= COS_DEV_LIM)
if ( m_vTria[vT[nPos]].vtN * m_vTria[vT[i]].vtN >= m_dCosSmAng)
vtN += m_vTria[vT[i]].vtN ;
else
break ;
@@ -277,26 +307,11 @@ SurfTriMesh::GetTriangleSmoothNormal( int nT, int nV, Vector3d& vtN) const
for ( int i = PrevIndAroundVertex( nPos, nTria, bCirc) ;
i != nLim && i >= 0 ;
i = PrevIndAroundVertex( i, nTria, bCirc)) {
if ( m_vTria[vT[nPos]].vtN * m_vTria[vT[i]].vtN >= COS_DEV_LIM)
if ( m_vTria[vT[nPos]].vtN * m_vTria[vT[i]].vtN >= m_dCosSmAng)
vtN += m_vTria[vT[i]].vtN ;
else
break ;
}
//// parto dal triangolo e vado in direzione positiva
//for ( int i = nPos + 1 ; i < int( vT.size()) ; ++ i) {
// if ( m_vTria[vT[nPos]].vtN * m_vTria[vT[i]].vtN >= COS_DEV_LIM)
// vtN += m_vTria[vT[i]].vtN ;
// else
// break ;
//}
//// parto dal triangolo e vado in direzione negativa
//for ( int i = nPos - 1 ; i >= 0 ; -- i) {
// if ( m_vTria[vT[nPos]].vtN * m_vTria[vT[i]].vtN >= COS_DEV_LIM)
// vtN += m_vTria[vT[i]].vtN ;
// else
// break ;
//}
vtN.Normalize() ;
return true ;
@@ -334,11 +349,14 @@ SurfTriMesh::Copy( const SurfTriMesh& stmSrc)
{
if ( &stmSrc == this)
return true ;
if ( ! Init( stmSrc.GetVertexNum(), stmSrc.GetTriangleNum()))
if ( ! Init( stmSrc.GetVertexSize(), stmSrc.GetTriangleSize()))
return false ;
m_vVert = stmSrc.m_vVert ;
m_vTria = stmSrc.m_vTria ;
m_bClosed = stmSrc.m_bClosed ;
m_dLinTol = stmSrc.m_dLinTol ;
m_dSmoothAng = stmSrc.m_dSmoothAng ;
m_dCosSmAng = stmSrc.m_dCosSmAng ;
m_nStatus = stmSrc.m_nStatus ;
return true ;
}
@@ -363,11 +381,13 @@ bool
SurfTriMesh::Dump( string& sOut, const char* szNewLine) const
{
// se superficie aperta o chiusa
sOut += ( m_bClosed ? "Closed" : "Open") ;
sOut += ( m_bClosed ? "Closed" : "Open") + string( szNewLine) ;
// numero di vertici
sOut += " VertNbr=" + ToString( GetVertexNum()) ;
sOut += "Vert : Nbr=" + ToString( GetVertexNum()) +
" Size=" + ToString( GetVertexSize()) + szNewLine ;
// numero di triangoli
sOut += " TriaNbr=" + ToString( GetTriangleNum()) ;
sOut += "Tria : Nbr=" + ToString( GetTriangleNum()) +
" Size=" + ToString( GetTriangleSize()) + szNewLine ;
return true ;
}
@@ -383,12 +403,16 @@ SurfTriMesh::GetNgeId( void) const
bool
SurfTriMesh::Save( NgeWriter& ngeOut) const
{
// tolleranza lineare di costruzione
ngeOut.WriteDouble( m_dLinTol, ";") ;
// angolo limite per mediare le normali
ngeOut.WriteDouble( m_dSmoothAng, ";", true) ;
// flag aperta/chiusa
ngeOut.WriteBool( m_bClosed, ";") ;
// numero di vertici
ngeOut.WriteInt( GetVertexNum(), ";") ;
ngeOut.WriteInt( GetVertexSize(), ";") ;
// numero di triangoli
ngeOut.WriteInt( GetTriangleNum(), ";", true) ;
ngeOut.WriteInt( GetTriangleSize(), ";", true) ;
// ciclo sui vertici
for ( int i = 0 ; i < int( m_vVert.size()) ; ++ i) {
ngeOut.WriteInt( i, ";") ;
@@ -419,6 +443,15 @@ SurfTriMesh::Load( NgeReader& ngeIn)
{
// imposto ricalcolo della grafica
m_OGrMgr.Reset() ;
// leggo la prossima linea ( 2 parametri : dLinTol e dSmoothAng)
// tolleranza lineare di costruzione
double dLinTol ;
if ( ! ngeIn.ReadDouble( dLinTol, ";"))
return false ;
// angolo limite per mediare le normali
double dSmoothAng ;
if ( ! ngeIn.ReadDouble( dSmoothAng, ";", true))
return false ;
// leggo la prossima linea ( 3 parametri : flag chiuso num vertici e num tria)
// recupero il flag
bool bClosed ;
@@ -432,10 +465,13 @@ SurfTriMesh::Load( NgeReader& ngeIn)
int nNumTria ;
if ( ! ngeIn.ReadInt( nNumTria, ";", true))
return false ;
// inizializzo la superficie TriMesh
// preparo la superficie
if ( ! Init( nNumVert, nNumTria))
return false ;
m_bClosed = bClosed ;
m_dLinTol = dLinTol ;
m_dSmoothAng = dSmoothAng ;
m_dCosSmAng = cos( dSmoothAng * DEGTORAD) ;
// lettura dei vertici
int nInd ;
StmVert vV ;
@@ -480,12 +516,12 @@ SurfTriMesh::Validate( void)
// Verifico che i vertici riferiti dai triangoli esistano
m_nStatus = OK ;
for ( int i = 0 ; i < GetTriangleNum() && m_nStatus == OK ; ++ i) {
for ( int i = 0 ; i < GetTriangleSize() && m_nStatus == OK ; ++ i) {
// se triangolo non cancellato
if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
for ( int j = 0 ; j < 3 && m_nStatus == OK ; ++ j) {
if ( m_vTria[i].nIdVert[j] < 0 ||
m_vTria[i].nIdVert[j] >= GetVertexNum() ||
m_vTria[i].nIdVert[j] >= GetVertexSize() ||
m_vVert[ m_vTria[i].nIdVert[j]].nIdTria == SVT_DEL)
m_nStatus = ERR ;
}
@@ -496,11 +532,11 @@ SurfTriMesh::Validate( void)
}
// Verifico che i triangoli riferiti dai vertici esistano
for ( int i = 0 ; i < GetVertexNum() && m_nStatus == OK ; ++ i) {
for ( int i = 0 ; i < GetVertexSize() && m_nStatus == OK ; ++ i) {
// se vertice non cancellato e con riferimento assegnato
if ( m_vVert[i].nIdTria != SVT_DEL && m_vVert[i].nIdTria != SVT_NULL) {
if ( m_vVert[i].nIdTria < SVT_DEL ||
m_vVert[i].nIdTria >= GetTriangleNum() ||
m_vVert[i].nIdTria >= GetTriangleSize() ||
m_vTria[ m_vVert[i].nIdTria].nIdVert[0] == SVT_DEL)
m_nStatus = ERR ;
}
@@ -604,7 +640,7 @@ bool
SurfTriMesh::AdjustAdjacencies( void)
{
// sistemo i puntatori dai vertici ai triangoli
for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
// se triangolo non cancellato
if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
for ( int j = 0 ; j < 3 ; ++ j) {
@@ -618,7 +654,7 @@ SurfTriMesh::AdjustAdjacencies( void)
bool bModif ;
do {
bModif = false ;
for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
// se triangolo non cancellato
if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
for ( int j = 0 ; j < 3 ; ++ j) {
@@ -686,7 +722,7 @@ SurfTriMesh::AdjustOrientations( int nLev, bool& bSomeWrong)
// inizializzo parametro di ritorno
bSomeWrong = false ;
// ciclo sui triangoli
for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
// flags
int nNull = 0 ;
int nWrong = 0 ;
@@ -727,7 +763,7 @@ SurfTriMesh::TestClosure( void)
{
// ciclo sui triangoli
bool bClosed = true ;
for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
if ( m_vTria[i].nIdAdjac[0] == SVT_NULL ||
m_vTria[i].nIdAdjac[1] == SVT_NULL ||
m_vTria[i].nIdAdjac[2] == SVT_NULL)
@@ -812,6 +848,10 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
if ( PL.GetPointNbr() < 2)
return false ;
// imposto ricalcolo
m_nStatus = ERR ;
m_OGrMgr.Reset() ;
// verifico se la polilinea è chiusa
bool bClosed = PL.IsClosed() ;
@@ -856,6 +896,7 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
}
// sistemo la topologia
m_nStatus = TO_VERIFY ;
return AdjustTopology() ;
}
@@ -866,6 +907,11 @@ 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 ;
// imposto ricalcolo
m_nStatus = ERR ;
m_OGrMgr.Reset() ;
// flag di curve chiuse
bool bClosed = PL1.IsClosed() && PL2.IsClosed() ;
// recupero i parametri delle due polilinee
@@ -1022,6 +1068,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2)
}
// sistemo la topologia
m_nStatus = TO_VERIFY ;
return AdjustTopology() ;
}
@@ -1150,6 +1197,10 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
return false ;
}
// imposto ricalcolo
m_nStatus = ERR ;
m_OGrMgr.Reset() ;
// verifico se la polilinea è chiusa
bool bClosed = PL.IsClosed() ;
@@ -1287,6 +1338,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
}
// sistemo la topologia
m_nStatus = TO_VERIFY ;
return AdjustTopology() ;
}
@@ -1375,6 +1427,156 @@ SurfTriMesh::AddBiTriangle( const int nIdVert[4])
return true ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::DoCompacting( void)
{
// imposto ricalcolo
m_nStatus = ERR ;
m_OGrMgr.Reset() ;
// definisco un Grid per i vertici della superficie
PointGrid3d VertGrid ;
int nBuckets = GetVertexSize() ;
VertGrid.Init( nBuckets) ;
// inserisco i vertici della trimesh (evitando ripetizioni coi precedenti),
// salvando in un vettore di reindirizzo i nuovi Id
INTVECTOR vVId ;
vVId.reserve( GetVertexSize()) ;
for ( int nId = 0 ; nId < GetVertexSize() ; ++ nId) {
// salto i vertici cancellati (ma ne occupo il posto nel vettore di reindirizzo)
if ( m_vVert[nId].nIdTria == SVT_DEL) {
vVId.push_back( SVT_DEL) ;
continue ;
}
// recupero la posizione geometrica del vertice
Point3d ptP = m_vVert[nId].ptP ;
// se non c'è già un vertice con la stessa posizione lo inserisco nel grid
int nAliasId ;
if ( ! VertGrid.Find( ptP, 2 * EPS_SMALL, nAliasId)) {
VertGrid.InsertPoint( ptP, nId) ;
// salvo l'Id nel vettore di reindirizzo
vVId.push_back( nId) ;
}
// c'e un vertice coincidente
else {
// salvo l'Id alias nel vettore di reindirizzo
vVId.push_back( nAliasId) ;
// marco il vertice come cancellato
m_vVert[nId].nIdTria = SVT_DEL ;
}
}
int nVIdSize = int( vVId.size()) ;
// sistemo gli indici dei vertici nei triangoli
for ( int nId = 0 ; nId < GetTriangleSize() ; ++ nId) {
// recupero gli indici dei vertici del triangolo
int vOId[3] ;
vOId[0] = m_vTria[nId].nIdVert[0] ;
vOId[1] = m_vTria[nId].nIdVert[1] ;
vOId[2] = m_vTria[nId].nIdVert[2] ;
// salto i triangoli cancellati
if ( vOId[0] == SVT_DEL)
continue ;
// verifico la validità degli indici
if ( vOId[0] < 0 || vOId[0] >= nVIdSize ||
vOId[1] < 0 || vOId[1] >= nVIdSize ||
vOId[2] < 0 || vOId[2] >= nVIdSize)
return false ;
// aggiorno il triangolo
m_vTria[nId].nIdVert[0] = vVId[vOId[0]] ;
m_vTria[nId].nIdVert[1] = vVId[vOId[1]] ;
m_vTria[nId].nIdVert[2] = vVId[vOId[2]] ;
}
// ricalcolo le adiacenze
m_nStatus = TO_VERIFY ;
return AdjustTopology() ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::DoSewing( const ISurfTriMesh& stmOther, const Frame3d& frOther)
{
// recupero l'altra superficie
const SurfTriMesh* pOther = dynamic_cast<const SurfTriMesh*>( &stmOther) ;
if ( pOther == nullptr)
return false ;
// imposto ricalcolo
m_nStatus = ERR ;
m_OGrMgr.Reset() ;
// definisco un Grid per i vertici delle due superfici
PointGrid3d VertGrid ;
int nBuckets = GetVertexSize() + pOther->GetVertexSize() ;
VertGrid.Init( nBuckets) ;
// inserisco i vertici della trimesh corrente (li considero tutti diversi tra loro)
for ( int nId = 0 ; nId < GetVertexSize() ; ++ nId) {
// salto i vertici cancellati
if ( m_vVert[nId].nIdTria == SVT_DEL)
continue ;
// inserisco il vertice nella griglia
VertGrid.InsertPoint( m_vVert[nId].ptP, nId) ;
}
// inserisco i vertici dell'altra trimesh (evitando ripetizioni coi precedenti),
// salvando in un vettore di reindirizzo i nuovi Id
INTVECTOR vVId ;
vVId.reserve( pOther->GetVertexSize()) ;
for ( int nOId = 0 ; nOId < pOther->GetVertexSize() ; ++ nOId) {
// salto i vertici cancellati (ma ne occupo il posto nel vettore di reindirizzo)
if ( pOther->m_vVert[nOId].nIdTria == SVT_DEL) {
vVId.push_back( SVT_DEL) ;
continue ;
}
// recupero la posizione geometrica del vertice
Point3d ptOP = pOther->m_vVert[nOId].ptP ;
// la porto nel riferimento della prima superficie
ptOP.ToGlob( frOther) ;
// se non c'è già un vertice con la stessa posizione lo inserisco
int nNewId ;
if ( ! VertGrid.Find( ptOP, 2 * EPS_SMALL, nNewId)) {
if ( ( nNewId = AddVertex( ptOP)) == SVT_NULL)
return false ;
VertGrid.InsertPoint( ptOP, nNewId) ;
}
// salvo il nuovo Id nel vettore di reindirizzo
vVId.push_back( nNewId) ;
}
int nVIdSize = int( vVId.size()) ;
// inserisco i triangoli dell'altra trimesh
for ( int nOtId = 0 ; nOtId < pOther->GetTriangleSize() ; ++ nOtId) {
// recupero gli indici dei vertici del triangolo
int vOId[3] ;
vOId[0] = pOther->m_vTria[nOtId].nIdVert[0] ;
vOId[1] = pOther->m_vTria[nOtId].nIdVert[1] ;
vOId[2] = pOther->m_vTria[nOtId].nIdVert[2] ;
// salto i triangoli cancellati
if ( vOId[0] == SVT_DEL)
continue ;
// verifico la validità degli indici
if ( vOId[0] < 0 || vOId[0] >= nVIdSize ||
vOId[1] < 0 || vOId[1] >= nVIdSize ||
vOId[2] < 0 || vOId[2] >= nVIdSize)
return false ;
int vId[3] ;
vId[0] = vVId[vOId[0]] ;
vId[1] = vVId[vOId[1]] ;
vId[2] = vVId[vOId[2]] ;
// inserisco il triangolo
if ( AddTriangle( vId) == SVT_NULL)
return false ;
}
// ricalcolo le adiacenze
m_nStatus = TO_VERIFY ;
return AdjustTopology() ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::GetLocalBBox( BBox3d& b3Loc) const
@@ -1384,7 +1586,7 @@ SurfTriMesh::GetLocalBBox( BBox3d& b3Loc) const
return false ;
// assegno il box in locale
b3Loc.Reset() ;
for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
for ( int i = 0 ; i < GetVertexSize() ; ++ i) {
if ( m_vVert[i].nIdTria != SVT_DEL)
b3Loc.Add( m_vVert[i].ptP) ;
}
@@ -1403,7 +1605,7 @@ SurfTriMesh::GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const
return false ;
// assegno il box nel riferimento
b3Ref.Reset() ;
for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
for ( int i = 0 ; i < GetVertexSize() ; ++ i) {
if ( m_vVert[i].nIdTria != SVT_DEL) {
Point3d ptTemp = m_vVert[i].ptP ;
ptTemp.ToGlob( frRef) ;
@@ -1426,7 +1628,7 @@ SurfTriMesh::Translate( const Vector3d& vtMove)
m_OGrMgr.Reset() ;
// traslo i vertici
for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
for ( int i = 0 ; i < GetVertexSize() ; ++ i) {
if ( m_vVert[i].nIdTria != SVT_DEL)
m_vVert[i].ptP.Translate( vtMove) ;
}
@@ -1450,13 +1652,13 @@ SurfTriMesh::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng,
m_OGrMgr.Reset() ;
// ruoto i vertici
for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
for ( int i = 0 ; i < GetVertexSize() ; ++ i) {
if ( m_vVert[i].nIdTria != SVT_DEL)
m_vVert[i].ptP.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
}
// ruoto le normali delle facce
for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
if ( m_vTria[i].nIdVert[0] != SVT_DEL)
m_vTria[i].vtN.Rotate( vtAx, dCosAng, dSinAng) ;
}
@@ -1485,13 +1687,13 @@ SurfTriMesh::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double
m_OGrMgr.Reset() ;
// scalo i vertici
for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
for ( int i = 0 ; i < GetVertexSize() ; ++ i) {
if ( m_vVert[i].nIdTria != SVT_DEL)
m_vVert[i].ptP.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;
}
// aggiorno le facce
for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
// se c'è mirror, devo invertire la faccia
if ( bMirror && ! InvertTriangle( i))
@@ -1530,13 +1732,13 @@ SurfTriMesh::CalcTriangleNormal( int nT)
return false ;
// controllo validità vertici riferiti dal triangolo
if ( m_vTria[nT].nIdVert[0] < 0 ||
m_vTria[nT].nIdVert[0] >= GetVertexNum() ||
m_vTria[nT].nIdVert[0] >= GetVertexSize() ||
m_vVert[m_vTria[nT].nIdVert[0]].nIdTria == SVT_DEL ||
m_vTria[nT].nIdVert[1] < 0 ||
m_vTria[nT].nIdVert[1] >= GetVertexNum() ||
m_vTria[nT].nIdVert[1] >= GetVertexSize() ||
m_vVert[m_vTria[nT].nIdVert[1]].nIdTria == SVT_DEL ||
m_vTria[nT].nIdVert[2] < 0 ||
m_vTria[nT].nIdVert[2] >= GetVertexNum() ||
m_vTria[nT].nIdVert[2] >= GetVertexSize() ||
m_vVert[m_vTria[nT].nIdVert[2]].nIdTria == SVT_DEL)
return false ;
// calcolo vettori come due lati consecutivi del triangolo
@@ -1566,11 +1768,11 @@ SurfTriMesh::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
m_OGrMgr.Reset() ;
// specchio i vertici
for ( int i = 0 ; i < GetVertexNum() ; ++ i)
for ( int i = 0 ; i < GetVertexSize() ; ++ i)
m_vVert[i].ptP.Mirror( ptOn, vtNorm) ;
// inverto le facce
for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
// inverto la faccia
if ( ! InvertTriangle( i))
@@ -1597,7 +1799,7 @@ SurfTriMesh::ToGlob( const Frame3d& frRef)
return false ;
// trasformo i vertici
for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
for ( int i = 0 ; i < GetVertexSize() ; ++ i) {
if ( m_vVert[i].nIdTria != SVT_DEL)
m_vVert[i].ptP.ToGlob( frRef) ;
}
@@ -1621,7 +1823,7 @@ SurfTriMesh::ToLoc( const Frame3d& frRef)
return false ;
// trasformo i vertici
for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
for ( int i = 0 ; i < GetVertexSize() ; ++ i) {
if ( m_vVert[i].nIdTria != SVT_DEL)
m_vVert[i].ptP.ToLoc( frRef) ;
}
@@ -1641,7 +1843,7 @@ SurfTriMesh::Invert( void)
return false ;
// inverto i triangoli
for ( int i = 0 ; i < GetTriangleNum() ; ++ i)
for ( int i = 0 ; i < GetTriangleSize() ; ++ i)
InvertTriangle( i) ;
// imposto ricalcolo della grafica