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
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) ;
}
}
}