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

EgtGeomKernel 2.1b3 :

Browse Source 
- razionalizzazione interfaccia Zmap e SurfTm.
This commit is contained in:
Dario Sassi
2019-02-13 08:33:18 +00:00
parent 88fd76934d
commit 86cd1346ec
8 changed files with 254 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtGeomKernel.rc
BIN
View File
Binary file not shown.
SurfTriMesh.cpp
+46
View File
@@ -489,6 +489,52 @@ SurfTriMesh::GetNextTriangle( int nId, Triangle3d& Tria) const
return nId ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::GetTriangle( int nId, Triangle3dEx& Tria) const
{
// verifico esistenza del triangolo
if ( nId < 0 || nId >= GetTriangleSize() || m_vTria[nId].nIdVert[0] == SVT_DEL)
return false ;
// recupero i dati
Tria.Set( m_vVert[m_vTria[nId].nIdVert[0]].ptP,
m_vVert[m_vTria[nId].nIdVert[1]].ptP,
m_vVert[m_vTria[nId].nIdVert[2]].ptP,
m_vTria[nId].vtN) ;
GetTriangleBoundaryEdges( nId, const_cast<TriFlags3d&>( Tria.GetTriFlags())) ;
GetTriangleSmoothNormals( nId, const_cast<TriNormals3d&>( Tria.GetTriNormals())) ;
return true ;
}
//----------------------------------------------------------------------------
int
SurfTriMesh::GetFirstTriangle( Triangle3dEx& Tria) const
{
return GetNextTriangle( SVT_NULL, Tria) ;
}
//----------------------------------------------------------------------------
int
SurfTriMesh::GetNextTriangle( int nId, Triangle3dEx& Tria) const
{
// cerco il primo successivo valido
do {
nId ++ ;
} while ( nId < GetTriangleSize() && m_vTria[nId].nIdVert[0] == SVT_DEL) ;
// se oltrepassata fine
if ( nId >= GetTriangleSize())
return SVT_NULL ;
// recupero i dati
Tria.Set( m_vVert[m_vTria[nId].nIdVert[0]].ptP,
m_vVert[m_vTria[nId].nIdVert[1]].ptP,
m_vVert[m_vTria[nId].nIdVert[2]].ptP,
m_vTria[nId].vtN) ;
GetTriangleBoundaryEdges( nId, const_cast<TriFlags3d&>( Tria.GetTriFlags())) ;
GetTriangleSmoothNormals( nId, const_cast<TriNormals3d&>( Tria.GetTriNormals())) ;
// ritorno indice triangolo corrente
return nId ;
}
//----------------------------------------------------------------------------
int
SurfTriMesh::GetAllTriaAroundVertex( int nV, INTVECTOR& vT, bool& bCirc) const
SurfTriMesh.h
+5 -2
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
// EgalTech 2014-2019
//----------------------------------------------------------------------------
// File : SurfTriMesh.h Data : 26.03.14 Versione : 1.5c9
// File : SurfTriMesh.h Data : 12.02.19 Versione : 2.1b2
// Contenuto : Dichiarazione della classe Superficie TriMesh.
//
//
@@ -161,6 +161,9 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
bool GetTriangle( int nId, Triangle3d& Tria) const override ;
int GetFirstTriangle( Triangle3d& Tria) const override ;
int GetNextTriangle( int nId, Triangle3d& Tria) const override ;
bool GetTriangle( int nId, Triangle3dEx& Tria) const override ;
int GetFirstTriangle( Triangle3dEx& Tria) const override ;
int GetNextTriangle( int nId, Triangle3dEx& Tria) const override ;
int GetAllTriaAroundVertex( int nV, INTVECTOR& vT, bool& bCirc) const override ;
bool GetVertexSmoothNormal( int nV, int nT, Vector3d& vtN) const override ;
bool GetTriangleBoundaryEdges( int nId, TriFlags3d& TFlags) const override ;
VolZmap.cpp
+2 -2
View File
@@ -142,7 +142,7 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc)
m_BlockUpdatingCounter = vzmSrc.m_BlockUpdatingCounter ;
m_InterBlockVox = vzmSrc.m_InterBlockVox ;
m_InterBlockOriginalSharpTria = vzmSrc.m_InterBlockOriginalSharpTria ;
m_InterBlockToBeFlippedSharpTria = vzmSrc.m_InterBlockToBeFlippedSharpTria ;
m_InterBlockSharpTria = vzmSrc.m_InterBlockSharpTria ;
m_BlockSharpTria = vzmSrc.m_BlockSharpTria ;
m_BlockSmoothTria = vzmSrc.m_BlockSmoothTria ;
m_BlockBigTria = vzmSrc.m_BlockBigTria ;
@@ -393,7 +393,7 @@ VolZmap::Load( NgeReader& ngeIn)
// per triangoli di feature di frontiera tra blocchi
m_InterBlockVox.resize( m_nNumBlock) ;
m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ;
m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ;
m_InterBlockSharpTria.resize( m_nNumBlock) ;
m_BlockSharpTria.resize( m_nNumBlock) ;
m_BlockSmoothTria.resize( m_nNumBlock) ;
m_BlockBigTria.resize( m_nNumBlock) ;
VolZmap.h
+5 -5
View File
@@ -75,12 +75,12 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) override ;
bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) override ;
bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex) override ;
bool GetAllTriangles( TRIA3DEXLIST& lstTria) const override ;
int GetBlockCount( void) const override ;
int GetBlockUpdatingCounter( int nBlock) const override ;
bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const override ;
bool GetVolume( double& dVol) const override ;
int GetPartCount( void) const override ;
bool GetPartVolume( int nPart, double& dVol) const override ;
bool GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DEXLISTVECTOR& vLstTria) const override ;
bool GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const override ;
bool SetTolerances( double dLinTol, double dAngTolDeg = 90) override ;
bool SetStdTool( const std::string& sToolName, double dH, double dR, double dCornR, int nFlag) override ;
@@ -189,8 +189,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Point3d& ptQ,
const Vector3d& vtZ, const Vector3d& vtNorm, int nBlock) const ;
bool ProcessCell( int nGrid, int nCellI, int nCellJ, const Plane3d& plPlane, std::vector<CurveLine>& vLine) const ;
bool UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const ;
bool UpdateSingleMapGraphics( INTVECTOR& nModifiedBlocks) const ;
bool UpdateSingleMapGraphics( void) const ;
bool UpdateTripleMapGraphics( void) const ;
bool ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const ;
bool RegulateFeaturesChain( std::vector<VoxelContainer>& vVecVox) const ;
bool CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVox) const ;
@@ -396,7 +396,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
mutable std::vector<VoxelContainer> m_InterBlockVox ;
mutable SharpTriaMatrix m_InterBlockOriginalSharpTria ;
mutable SharpTriaMatrix m_InterBlockToBeFlippedSharpTria ;
mutable SharpTriaMatrix m_InterBlockSharpTria ;
mutable SharpTriaMatrix m_BlockSharpTria ;
mutable SmoothTriaMatrix m_BlockSmoothTria ;
mutable std::vector<TRIA3DEXVECTOR> m_BlockBigTria ;
VolZmapCalculus.cpp
+13 -35
View File
@@ -409,9 +409,11 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn
return true ;
}
// Se la grafica non è aggiornata la ricalcolo
INTVECTOR nModifiedBlocks ;
UpdateTripleMapGraphics( nModifiedBlocks) ;
// Lancio eventuale aggiornamento pendente della grafica
if ( m_nMapNum == 1)
UpdateSingleMapGraphics() ;
else
UpdateTripleMapGraphics() ;
// Determino il voxel di partenza
int nVoxI, nVoxJ, nVoxK ;
@@ -420,7 +422,7 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn
return false ;
}
// Incrementi degli indici per sguire la retta
// Incrementi degli indici per seguire la retta
int nDeltaI = ( vtD.x > 0 ? 1 : ( vtD.x < 0 ? - 1 : 0)) ;
int nDeltaJ = ( vtD.y > 0 ? 1 : ( vtD.y < 0 ? - 1 : 0)) ;
int nDeltaK = ( vtD.z > 0 ? 1 : ( vtD.z < 0 ? - 1 : 0)) ;
@@ -493,13 +495,13 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn
int nCurBlockN ;
GetBlockNFromIJK( nCurBlockIJK, nCurBlockN) ;
// Triangoli sharp fra blocchi
for ( int nBlVx = 0 ; nBlVx < int( m_InterBlockToBeFlippedSharpTria[nCurBlockN].size()) ; ++ nBlVx) {
if ( m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] &&
m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] &&
m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) {
for ( int nBlCm = 0 ; nBlCm < int( m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].vCompoTria.size()) ; ++ nBlCm) {
for ( int nBlTr = 0 ; nBlTr < int( m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm].size()) ; ++ nBlTr) {
Triangle3d CurrTria = m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm][nBlTr] ;
for ( int nBlVx = 0 ; nBlVx < int( m_InterBlockSharpTria[nCurBlockN].size()) ; ++ nBlVx) {
if ( m_InterBlockSharpTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] &&
m_InterBlockSharpTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] &&
m_InterBlockSharpTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) {
for ( int nBlCm = 0 ; nBlCm < int( m_InterBlockSharpTria[nCurBlockN][nBlVx].vCompoTria.size()) ; ++ nBlCm) {
for ( int nBlTr = 0 ; nBlTr < int( m_InterBlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm].size()) ; ++ nBlTr) {
Triangle3d CurrTria = m_InterBlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm][nBlTr] ;
Point3d ptLineTria1, ptLineTria2 ;
// Studio dell'intersezione della retta con il triangolo corrente
int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ;
@@ -611,30 +613,6 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn
}
}
}
// Ciclo sui triangoli dei voxel
//for ( auto it = lstTria.begin() ; it != lstTria.end() ; ++it ) {
// // Triangolo corrente e suoi punti di intersezione con la retta
// const Triangle3d& CurrTria = *it ;
// Point3d ptLineTria1, ptLineTria2 ;
// // Studio dell'intersezione della retta con il triangolo corrente
// int nIntType = IntersLineTria( ptP, vtD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ;
// // Se non ci sono intersezioni passo al prossimo triangolo
// if ( nIntType == ILTT_NO)
// continue ;
// // se altrimenti c'è una sola intersezione
// else if ( nIntType == ILTT_VERT ||
// nIntType == ILTT_EDGE ||
// nIntType == ILTT_IN) {
// vInt.emplace_back( ( ptLineTria1 - ptP) * vtD, vtD * CurrTria.GetN()) ;
// }
// // altrimenti ci sono due intersezioni
// else {
// double dP1 = ( ptLineTria1 - ptP) * vtD ;
// double dP2 = ( ptLineTria2 - ptP) * vtD ;
// double dD = vtD * CurrTria.GetN() ;
// vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ;
// }
//}
// Ordino le intersezioni in base al parametro distanza con segno da ptP
sort( vInt.begin(), vInt.end(),
VolZmapCreation.cpp
+3 -3
View File
@@ -146,7 +146,7 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
// Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel
m_InterBlockVox.resize( m_nNumBlock) ;
m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ;
m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ;
m_InterBlockSharpTria.resize( m_nNumBlock) ;
m_BlockSharpTria.resize( m_nNumBlock) ;
m_BlockSmoothTria.resize( m_nNumBlock) ;
m_BlockBigTria.resize( m_nNumBlock) ;
@@ -457,7 +457,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
// Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel
m_InterBlockVox.resize( m_nNumBlock) ;
m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ;
m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ;
m_InterBlockSharpTria.resize( m_nNumBlock) ;
m_BlockSharpTria.resize( m_nNumBlock) ;
m_BlockSmoothTria.resize( m_nNumBlock) ;
m_BlockBigTria.resize( m_nNumBlock) ;
@@ -660,7 +660,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
// Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel
m_InterBlockVox.resize( m_nNumBlock) ;
m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ;
m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ;
m_InterBlockSharpTria.resize( m_nNumBlock) ;
m_BlockSharpTria.resize( m_nNumBlock) ;
m_BlockSmoothTria.resize( m_nNumBlock) ;
m_BlockBigTria.resize( m_nNumBlock) ;
VolZmapGraphics.cpp
+180 -225
View File
@@ -461,130 +461,141 @@ VolZmap::GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) con
}
}
//----------------------------------------------------------------------------
bool
VolZmap::GetAllTriangles( TRIA3DEXLIST& lstTria) const
{
INTVECTOR nModifiedBlocks ;
TRIA3DEXLISTVECTOR vLstTria ;
if ( ! GetTriangles( true, nModifiedBlocks, vLstTria))
return false ;
lstTria.clear() ;
for ( int i = 0 ; i < int( vLstTria.size()) ; ++ i) {
lstTria.splice( lstTria.end(), vLstTria[i]) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DEXLISTVECTOR& vLstTria) const
VolZmap::GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const
{
// Caso di singola mappa
// Dexel (singola mappa)
if ( m_nMapNum == 1) {
nModifiedBlocks.resize( m_nNumBlock) ;
vLstTria.reserve( m_nNumBlock) ;
UpdateSingleMapGraphics( nModifiedBlocks) ;
// Se richiesti tutti, dichiaro tutti modificati
if ( bAllBlocks) {
for ( int i = 0 ; i < m_nNumBlock ; ++ i)
nModifiedBlocks[i] = i ;
}
for ( int t = 0 ; t < m_nNumBlock ; ++ t) {
if ( nModifiedBlocks[t] >= 0) {
vLstTria.emplace_back() ;
for ( int tDx = 0 ; tDx < int( m_SingleMapTria[t].size()) ; ++ tDx)
vLstTria.back().emplace_back( m_SingleMapTria[t][tDx]) ;
}
}
// se il blocco non esiste, errore
if ( nBlock < 0 || nBlock > m_nNumBlock - 1)
return false ;
// lancio eventuale aggiornamento pendente della grafica
UpdateSingleMapGraphics() ;
// copio i triangoli
vTria = m_SingleMapTria[nBlock] ;
return true ;
}
// Caso con tre mappe
// Tridexel (tre mappe)
else {
UpdateTripleMapGraphics( nModifiedBlocks) ;
// Se richiesti tutti, dichiaro tutti modificati
if ( bAllBlocks) {
for ( int i = 0 ; i < m_nNumBlock + 1 ; ++ i)
nModifiedBlocks[i] = i ;
}
// Alloco lo spazio
vLstTria.reserve( m_nNumBlock + 1) ;
// Calcolo i triangoli sui blocchi
for ( int t = 0 ; t < m_nNumBlock ; ++ t) {
// Se il blocco è stato aggiornato
if ( nModifiedBlocks[t] >= 0) {
vLstTria.emplace_back() ;
// Copio i triangoli nella lista
for ( int nVx = 0 ; nVx < int( m_BlockSmoothTria[t].size()) ; ++ nVx) {
for ( int nTr = 0 ; nTr < int( m_BlockSmoothTria[t][nVx].vTria.size()) ; ++ nTr) {
vLstTria.back().emplace_back( m_BlockSmoothTria[t][nVx].vTria[nTr]) ;
// se il blocco non esiste, errore
if ( nBlock < 0 || nBlock > ( m_nNumBlock + 1) - 1)
return false ;
// lancio eventuale aggiornamento pendente della grafica
UpdateTripleMapGraphics() ;
// copio i triangoli del blocco
if ( nBlock != m_nNumBlock) {
vTria.clear() ;
vTria.reserve( 10000) ;
// triangoli smooth
for ( int nVx = 0 ; nVx < int( m_BlockSmoothTria[nBlock].size()) ; ++ nVx) {
for ( int nTr = 0 ; nTr < int( m_BlockSmoothTria[nBlock][nVx].vTria.size()) ; ++ nTr)
vTria.emplace_back( m_BlockSmoothTria[nBlock][nVx].vTria[nTr]) ;
}
// triangoli grandi piatti
for ( int tBl = 0 ; tBl < int( m_BlockBigTria[nBlock].size()) ; ++ tBl) {
vTria.emplace_back( m_BlockBigTria[nBlock][tBl]) ;
}
// triangoli di feature nel blocco (ciclo sui voxel del blocco)
for ( int t1 = 0 ; t1 < int( m_BlockSharpTria[nBlock].size()) ; ++ t1) {
// ciclo sulle componenti connesse del voxel
for ( int t2 = 0 ; t2 < int( m_BlockSharpTria[nBlock][t1].vCompoTria.size()) ; ++ t2) {
// ciclo sui triangoli delle componenti connesse
for ( int t3 = 0 ; t3 < int( m_BlockSharpTria[nBlock][t1].vCompoTria[t2].size()) ; ++ t3) {
// aggiungo triangolo alla lista
vTria.emplace_back( m_BlockSharpTria[nBlock][t1].vCompoTria[t2][t3]) ;
}
}
}
}
// Inserisco i triangoli grandi piatti
for ( int t = 0 ; t < m_nNumBlock ; ++ t) {
if ( nModifiedBlocks[t] >= 0) {
for ( int tBl = 0 ; tBl < int( m_BlockBigTria[t].size()) ; ++ tBl) {
vLstTria[nModifiedBlocks[t]].emplace_back( m_BlockBigTria[t][tBl]) ;
}
}
}
// Inserisco in lista i triangoli di feature derivanti dai blocchi
for ( int t = 0 ; t < m_nNumBlock ; ++ t) {
if ( nModifiedBlocks[t] >= 0) {
// ciclo sui voxel del blocco
for ( int t1 = 0 ; t1 < int( m_BlockSharpTria[t].size()) ; ++ t1) {
// ciclo sulle componenti connesse del voxel
for ( int t2 = 0 ; t2 < int( m_BlockSharpTria[t][t1].vCompoTria.size()) ; ++ t2) {
// ciclo sui triangoli delle componenti connesse
for ( int t3 = 0 ; t3 < int( m_BlockSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) {
// aggiungo triangolo alla lista
vLstTria[nModifiedBlocks[t]].emplace_back( m_BlockSharpTria[t][t1].vCompoTria[t2][t3]) ;
}
}
}
}
}
// Inserisco in lista i triangoli di frontiera tra feature di blocchi diversi
if ( nModifiedBlocks[m_nNumBlock] >= 0) {
vLstTria.resize( vLstTria.size() + 1) ;
int nPos = int( vLstTria.size()) - 1 ;
for ( int t = 0 ; t < int( m_InterBlockToBeFlippedSharpTria.size()) ; ++ t) {
for ( int t1 = 0 ; t1 < int( m_InterBlockToBeFlippedSharpTria[t].size()) ; ++ t1) {
for ( int t2 = 0 ; t2 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria.size()) ; ++ t2) {
for ( int t3 = 0 ; t3 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) {
if ( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) {
// blocco speciale aggiunto per i triangoli feature a cavallo dei blocchi
else {
vTria.clear() ;
vTria.reserve( 1000) ;
for ( int t = 0 ; t < int( m_InterBlockSharpTria.size()) ; ++ t) {
for ( int t1 = 0 ; t1 < int( m_InterBlockSharpTria[t].size()) ; ++ t1) {
for ( int t2 = 0 ; t2 < int( m_InterBlockSharpTria[t][t1].vCompoTria.size()) ; ++ t2) {
for ( int t3 = 0 ; t3 < int( m_InterBlockSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) {
if ( m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) {
// aggiungo triangolo alla lista
vLstTria[nPos].emplace_back( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3]) ;
vTria.emplace_back( m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3]) ;
}
}
}
}
}
}
return true ;
}
return true ;
}
//----------------------------------------------------------------------------
int
VolZmap::GetBlockCount( void) const
{
return m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1) ;
return ( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1)) ;
}
//----------------------------------------------------------------------------
int
VolZmap::GetBlockUpdatingCounter( int nBlock) const
{
// se il blocco non esiste, errore
if ( nBlock < 0 || nBlock >= int( m_BlockUpdatingCounter.size()))
return -1 ;
// Lancio eventuale aggiornamento pendente della grafica
if ( m_nMapNum == 1)
UpdateSingleMapGraphics() ;
else
UpdateTripleMapGraphics() ;
// restituisco il suo indice di aggiornamento
return m_BlockUpdatingCounter[nBlock] ;
}
//----------------------------------------------------------------------------
bool
VolZmap::UpdateSingleMapGraphics( void) const
{
const int MAX_DIM_CHUNK = 128 ;
// Ciclo sui blocchi
for ( int t = 0 ; t < m_nNumBlock ; ++ t) {
// Se il blocco deve essere aggiornato, eseguo
if ( m_BlockToUpdate[t]) {
m_SingleMapTria[t].clear() ;
// Calcolo posizione del blocco nella griglia
int nIBlock = int( t) % int( m_nFracLin[0]) ;
int nJBlock = int( t) / int( m_nFracLin[0]) ;
// Calcolo limiti per l'indice i
int nStartI = nIBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ;
int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ?
int( m_nNx[0]) : ( nIBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ;
// Calcolo limiti per l'indice j
int nStartJ = nJBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ;
int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ?
int( m_nNy[0]) : ( nJBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ;
// Ciclo su i e j
for ( int i = nStartI ; i < nEndI ; i += MAX_DIM_CHUNK) {
int nDimChunkX = min( MAX_DIM_CHUNK, nEndI - i) ;
for ( int j = nStartJ ; j < nEndJ ; j += MAX_DIM_CHUNK) {
int nDimChunkY = min( MAX_DIM_CHUNK, nEndJ - j) ;
GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, t) ;
}
}
m_BlockToUpdate[t] = false ;
++ m_BlockUpdatingCounter[t] ;
}
}
return true ;
}
//----------------------------------------------------------------------------
@@ -780,10 +791,13 @@ VolZmap::AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Poin
//----------------------------------------------------------------------------
bool
VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const
VolZmap::UpdateTripleMapGraphics( void) const
{
nModifiedBlocks.resize( m_nNumBlock + 1, -1) ;
// se non ci sono blocchi da aggiornare, esco
if ( find( begin( m_BlockToUpdate), end( m_BlockToUpdate), true) == end( m_BlockToUpdate))
return true ;
// contenitori temporanei
vector<VoxelContainer> vVoxContainerVec ;
vVoxContainerVec.resize( m_nNumBlock) ;
SharpTriaMatrix VecTriHold ;
@@ -866,13 +880,10 @@ VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const
}
// Calcolo i triangoli sui blocchi
int nUpdatedBlockCount = 0 ;
for ( int t = 0 ; t < m_nNumBlock ; ++ t) {
// Se il blocco deve essere processato
if ( m_BlockToUpdate[t]) {
// processo ...
nModifiedBlocks[t] = nUpdatedBlockCount ;
++ nUpdatedBlockCount ;
ExtMarchingCubes( int( t), vVoxContainerVec[t]) ;
}
}
@@ -882,15 +893,15 @@ VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const
// Costruisco i triangoli di feature
bool bCalcInterBlock = false ;
for ( int t = 0 ; t < int( m_nNumBlock) ; ++ t) {
for ( int t = 0 ; t < m_nNumBlock ; ++ t) {
// Se il blocco è stato processato
if ( m_BlockToUpdate[t]) {
CreateSharpFeatureTriangle( t, vVoxContainerVec[t]) ;
++ m_BlockUpdatingCounter[t] ;
// Flipping fra voxel interni
FlipEdgesII( t) ;
bCalcInterBlock = true ;
m_BlockToUpdate[t] = false ;
++ m_BlockUpdatingCounter[t] ;
// Sistemo le normali ai vertici (ciclo sui voxel)
for ( int t1 = 0 ; t1 < int( m_BlockSharpTria[t].size()) ; ++ t1) {
// ciclo sulle componenti connesse del voxel
@@ -916,25 +927,23 @@ VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const
SharpTriaMatrix InterBlockTria ;
if ( bCalcInterBlock) {
// Eseguo
m_InterBlockToBeFlippedSharpTria = m_InterBlockOriginalSharpTria ;
++ m_BlockUpdatingCounter[m_nNumBlock] ;
m_InterBlockSharpTria = m_InterBlockOriginalSharpTria ;
FlipEdgesBB() ;
// Aggiungo indice modificati
nModifiedBlocks.back() = nUpdatedBlockCount ;
++ m_BlockUpdatingCounter[m_nNumBlock] ;
// Sistemo le normali ai vertici
for ( int t = 0 ; t < int( m_InterBlockToBeFlippedSharpTria.size()) ; ++ t) {
for ( int t1 = 0 ; t1 < int( m_InterBlockToBeFlippedSharpTria[t].size()) ; ++ t1) {
for ( int t2 = 0 ; t2 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria.size()) ; ++ t2) {
for ( int t3 = 0 ; t3 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) {
if ( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) {
for ( int t = 0 ; t < int( m_InterBlockSharpTria.size()) ; ++ t) {
for ( int t1 = 0 ; t1 < int( m_InterBlockSharpTria[t].size()) ; ++ t1) {
for ( int t2 = 0 ; t2 < int( m_InterBlockSharpTria[t][t1].vCompoTria.size()) ; ++ t2) {
for ( int t3 = 0 ; t3 < int( m_InterBlockSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) {
if ( m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) {
// Controllo normali
Vector3d vtN = m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetN() ;
Vector3d vtN = m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].GetN() ;
bool bNormN = vtN.IsNormalized() ;
for ( int nV = 0 ; nV < 3 ; ++ nV) {
Vector3d vtNV = m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetVertexNorm( nV) ;
Vector3d vtNV = m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].GetVertexNorm( nV) ;
bool bNormV = vtNV.IsNormalized() ;
if ( bNormN && bNormV && vtN * vtNV < 0.7)
m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].SetVertexNorm( nV, vtN) ;
m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].SetVertexNorm( nV, vtN) ;
}
}
}
@@ -946,60 +955,6 @@ VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::UpdateSingleMapGraphics( INTVECTOR& nModifiedBlocks) const
{
const int MAX_DIM_CHUNK = 128 ;
int nUpdatedBlockCount = 0 ;
// Ciclo sui blocchi
for ( int t = 0 ; t < m_nNumBlock ; ++ t) {
// Se il blocco deve essere aggiornato, eseguo
if ( m_BlockToUpdate[t]) {
m_SingleMapTria[t].clear() ;
// Calcolo posizione del blocco nella griglia
int nIBlock = int( t) % int( m_nFracLin[0]) ;
int nJBlock = int( t) / int( m_nFracLin[0]) ;
// Calcolo limiti per l'indice i
int nStartI = nIBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ;
int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ?
int( m_nNx[0]) : ( nIBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ;
// Calcolo limiti per l'indice j
int nStartJ = nJBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ;
int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ?
int( m_nNy[0]) : ( nJBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ;
// Ciclo su i e j
for ( int i = nStartI ; i < nEndI ; i += MAX_DIM_CHUNK) {
int nDimChunkX = min( MAX_DIM_CHUNK, nEndI - i) ;
for ( int j = nStartJ ; j < nEndJ ; j += MAX_DIM_CHUNK) {
int nDimChunkY = min( MAX_DIM_CHUNK, nEndJ - j) ;
GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, t) ;
}
}
++ m_BlockUpdatingCounter[t] ;
nModifiedBlocks[t] = nUpdatedBlockCount ;
++ nUpdatedBlockCount ;
m_BlockToUpdate[t] = false ;
}
else
nModifiedBlocks[t] = -1 ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
@@ -3177,7 +3132,7 @@ bool
VolZmap::FlipEdgesBB() const
{
// Numero di blocchi
int nBlocksNum = int( m_InterBlockToBeFlippedSharpTria.size()) ;
int nBlocksNum = int( m_InterBlockSharpTria.size()) ;
// ciclo sui blocchi
for ( int tFB = 0 ; tFB < nBlocksNum ; ++ tFB) {
int nFBijk[3] ;
@@ -3191,45 +3146,45 @@ VolZmap::FlipEdgesBB() const
abs( nFBijk[2] - nLBijk[2]) <= 1))
continue ;
// Numero di voxel nei blocchi correnti
int nVoxelNumFB = int( m_InterBlockToBeFlippedSharpTria[tFB].size()) ;
int nVoxelNumLB = int( m_InterBlockToBeFlippedSharpTria[tLB].size()) ;
int nVoxelNumFB = int( m_InterBlockSharpTria[tFB].size()) ;
int nVoxelNumLB = int( m_InterBlockSharpTria[tLB].size()) ;
// Ciclo sui voxel dei due blocchi
for ( int tVFB = 0 ; tVFB < nVoxelNumFB ; ++ tVFB) {
for ( int tVLB = 0 ; tVLB < nVoxelNumLB ; ++ tVLB) {
// Se i voxel non sono adiacenti salto l'iterazione
if ( ! ( abs( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].i - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].i) <= 1 &&
abs( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].j - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].j) <= 1 &&
abs( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].k - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].k) <= 1))
if ( ! ( abs( m_InterBlockSharpTria[tFB][tVFB].i - m_InterBlockSharpTria[tLB][tVLB].i) <= 1 &&
abs( m_InterBlockSharpTria[tFB][tVFB].j - m_InterBlockSharpTria[tLB][tVLB].j) <= 1 &&
abs( m_InterBlockSharpTria[tFB][tVFB].k - m_InterBlockSharpTria[tLB][tVLB].k) <= 1))
continue ;
// Numero di componenti connesse dei voxel
int nCompoVFBNum = int( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].ptCompoVert.size()) ;
int nCompoVLBNum = int( m_InterBlockToBeFlippedSharpTria[tLB][tVLB].ptCompoVert.size()) ;
int nCompoVFBNum = int( m_InterBlockSharpTria[tFB][tVFB].ptCompoVert.size()) ;
int nCompoVLBNum = int( m_InterBlockSharpTria[tLB][tVLB].ptCompoVert.size()) ;
// Ciclo sulle componenti connesse
for ( int tCmpF = 0 ; tCmpF < nCompoVFBNum ; ++ tCmpF) {
for ( int tCmpL = 0 ; tCmpL < nCompoVLBNum ; ++ tCmpL) {
// Numero di triangoli delle componenti connesse
int nTriFBNum = int( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF].size()) ;
int nTriLBNum = int( m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL].size()) ;
int nTriFBNum = int( m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF].size()) ;
int nTriLBNum = int( m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL].size()) ;
// Ciclo sui triangoli
for ( int tTriFB = 0 ; tTriFB < nTriFBNum ; ++ tTriFB) {
bool bModified = false ;
for ( int tTriLB = 0 ; tTriLB < nTriLBNum ; ++ tTriLB) {
// Punti che devono essere in comune fra i due triangoli
Point3d ptPF1 = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ;
Point3d ptPF2 = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ;
Point3d ptPL1 = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 1) ;
Point3d ptPL2 = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 2) ;
Point3d ptPF1 = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ;
Point3d ptPF2 = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ;
Point3d ptPL1 = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 1) ;
Point3d ptPL2 = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 2) ;
// Si deve operare la modifica dei triangoli
if ( AreSamePointEpsilon( ptPF1, ptPL2, EPS_ZERO) &&
AreSamePointEpsilon( ptPF2, ptPL1, EPS_ZERO) &&
! ( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] ||
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB])) {
! ( m_InterBlockSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] ||
m_InterBlockSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB])) {
// Assegno l'array dei punti di contorno
Point3d vPnt[4] ;
vPnt[0] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ;
vPnt[1] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].ptCompoVert[tCmpF] ;
vPnt[2] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ;
vPnt[3] = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].ptCompoVert[tCmpL] ;
vPnt[0] = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ;
vPnt[1] = m_InterBlockSharpTria[tFB][tVFB].ptCompoVert[tCmpF] ;
vPnt[2] = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ;
vPnt[3] = m_InterBlockSharpTria[tLB][tVLB].ptCompoVert[tCmpL] ;
// Valuto se i triangoli giacciono su un piano
PolygonPlane Polygon ;
for ( int i = 0 ; i < 4 ; ++ i)
@@ -3241,8 +3196,8 @@ VolZmap::FlipEdgesBB() const
// Se sono su un piano controllo se avviene inversione
bool bInv = false ;
if ( bOnPlane) {
Triangle3dEx trTF = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB] ;
Triangle3dEx trTL = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB] ;
Triangle3dEx trTF = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB] ;
Triangle3dEx trTL = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB] ;
int nVertF, nVertL ;
// Determino gli indici dei punti sharp-feature
for ( int nP = 0 ; nP < 3 ; ++ nP) {
@@ -3260,26 +3215,26 @@ VolZmap::FlipEdgesBB() const
// Se non vi è inversione eseguo il flipping
if ( ! bInv) {
// Vertice condiviso fra nTri1 e quello del suo fan
int nColF = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ;
int nColL = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ;
int nColF = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ;
int nColL = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ;
// modifico punti e colori
m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetP( 1, m_InterBlockToBeFlippedSharpTria[tLB][tVLB].ptCompoVert[tCmpL]) ;
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetP( 1, m_InterBlockToBeFlippedSharpTria[tFB][tVFB].ptCompoVert[tCmpF]) ;
m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nColF) ;
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nColL) ;
m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetP( 1, m_InterBlockSharpTria[tLB][tVLB].ptCompoVert[tCmpL]) ;
m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetP( 1, m_InterBlockSharpTria[tFB][tVFB].ptCompoVert[tCmpF]) ;
m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nColF) ;
m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nColL) ;
// Valido i triangoli
m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].Validate( true) ;
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].Validate( true) ;
m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].Validate( true) ;
m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].Validate( true) ;
// Setto le normali a ogni vertice
Vector3d vtNormF = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ;
Vector3d vtNormL = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ;
m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 1, vtNormF) ;
m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 0, vtNormF) ;
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 1, vtNormL) ;
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 0, vtNormL) ;
Vector3d vtNormF = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ;
Vector3d vtNormL = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ;
m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 1, vtNormF) ;
m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 0, vtNormF) ;
m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 1, vtNormL) ;
m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 0, vtNormL) ;
// Setto i triangoli come flippati
m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] = true ;
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB] = true ;
m_InterBlockSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] = true ;
m_InterBlockSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB] = true ;
bModified = true ;
break ;
}
@@ -3288,14 +3243,14 @@ VolZmap::FlipEdgesBB() const
// quindi hanno normali concordi. A entrambi assegno il colore del vertice con
// normale più concorde a quella del triangolo
double dDotVec[4] ;
dDotVec[0] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() *
m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 1) ;
dDotVec[1] = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() *
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ;
dDotVec[2] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() *
m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ;
dDotVec[3] = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() *
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 1) ;
dDotVec[0] = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() *
m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 1) ;
dDotVec[1] = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() *
m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ;
dDotVec[2] = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() *
m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ;
dDotVec[3] = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() *
m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 1) ;
// Cerco il massimo dei prodotti scalari
int nMaxPos = 0 ;
double dMaxDot = - 1 ;
@@ -3309,21 +3264,21 @@ VolZmap::FlipEdgesBB() const
int nCol ;
switch ( nMaxPos) {
case 0 :
nCol = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 1) ;
nCol = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 1) ;
break ;
case 1 :
nCol = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ;
nCol = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ;
break ;
case 2 :
nCol = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ;
nCol = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ;
break ;
case 3 :
nCol = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 1) ;
nCol = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 1) ;
break ;
}
// Assegno il colore ai triangoli
m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nCol) ;
m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nCol) ;
m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nCol) ;
m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nCol) ;
}
}
}