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

EgtGeomKernel :

Browse Source 
- codice di test per Zmap.
This commit is contained in:
Riccardo Elitropi
2024-04-22 08:06:33 +02:00
parent a5a96c2bb5
commit 9bc315bd1d
4 changed files with 767 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmapVolume.cpp
+354 -231
View File
@@ -132,10 +132,10 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
// Imposto ricalcolo della grafica
m_OGrMgr.Reset() ;
// Imposto forma generica
m_nShape = GENERIC ;
// Imposto forma generica
m_nShape = GENERIC ;
// Imposto ricalcolo numero di componenti connesse
m_nConnectedCompoCount = - 1 ;
m_nConnectedCompoCount = - 1 ;
// Passo da indici di dexel a indici di voxel
nI /= m_nDexVoxRatio ;
@@ -160,7 +160,7 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
++ nYStop ;
}
// Voxel lungo Z
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nMinK = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumZ - 2) ;
int nMaxK = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumZ - 2) ;
int nMinZBlock = ( m_nMapNum == 1 ? 0 : Clamp( nMinK / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[2] - 1))) ;
@@ -227,8 +227,8 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
nZBlock[1] = nZBlock[0] - 1 ;
++ nZStop ;
}
// Voxel lungo Y
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Voxel lungo Y
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nMinJ = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumY - 2) ;
int nMaxJ = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumY - 2) ;
int nMinYBlock = Clamp( nMinJ / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[1] - 1)) ;
@@ -249,232 +249,355 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
//----------------------------------------------------------------------------
bool
VolZmap::AddIntervals( int nGrid, int nI, int nJ,
double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax, int nToolNum)
VolZmap::AddIntervals( int nGrid, int nI, int nJ, double dMin, double dMax, const Vector3d& vtNMin,
const Vector3d& vtNMax, int nToolNum)
{
// // Controllo che dMin e dMax non siano quasi coincidenti
// if ( abs( dMax - dMin) < EPS_SMALL)
// return true ;
//
// // Controllo che il numero di griglia sia entro i limiti
// if ( nGrid < 0 || nGrid > 2)
// return false ;
//
// // Controllo che dMin < dMax
// if ( dMin > dMax)
// swap( dMin, dMax) ;
//
// // Controllo che indici nI, nJ siano entro i limiti
// if ( nI < 0 && nI >= m_nNx[nGrid] &&
// nJ < 0 && nJ >= m_nNy[nGrid])
// return false ;
//
// // Riporto le coordinate cicliche nell'ordine di partenza
// Vector3d vtNmi = vtNMin ;
// Vector3d vtNma = vtNMax ;
// if ( nGrid == 1) {
// swap( vtNmi.x, vtNmi.z) ;
// swap( vtNmi.y, vtNmi.z) ;
// swap( vtNma.x, vtNma.z) ;
// swap( vtNma.y, vtNma.z) ;
// }
// else if ( nGrid == 2) {
// swap( vtNmi.y, vtNmi.z) ;
// swap( vtNmi.x, vtNmi.z) ;
// swap( vtNma.y, vtNma.z) ;
// swap( vtNma.x, vtNma.z) ;
// }
//
// // Calcolo nPos
// unsigned int nPos = nJ * m_nNx[nGrid] + nI ;
//
//
// // Se spillone vuoto
// if ( m_Values[nGrid][nPos].size() == 0) {
//
// m_Values[nGrid][nPos].resize( 1) ;
//
// m_Values[nGrid][nPos][0].dMin = dMin ;
// m_Values[nGrid][nPos][0].dMax = dMax ;
//
// m_Values[nGrid][nPos][0].vtMinN = vtNmi ;
// m_Values[nGrid][nPos][0].vtMaxN = vtNma ;
//
// if ( dMax > m_dMaxZ[nGrid])
// m_dMinZ[nGrid] = dMax ;
//
// if ( dMin < m_dMinZ[nGrid])
// m_dMinZ[nGrid] = dMin ;
//
// m_OGrMgr.Reset() ;
//
// return true ;
// }
//
// // Ciclo sugli intervalli dello spillone
// bool bModified = false ;
// unsigned int i = 0 ;
// while ( i < m_Values[nGrid][nPos].size()) {
//
// // Eventuale aggiustamento di intervalli sovrapposti
// if ( i < m_Values[nGrid][nPos].size() - 1) {
// if ( m_Values[nGrid][nPos][i].dMax > m_Values[nGrid][nPos][i + 1].dMin - EPS_SMALL) {
//
// // Se l'intervallo corrente non è contenuto totalmente si esegue l'istruzione successiva
// if ( m_Values[nGrid][nPos][i].dMin < m_Values[nGrid][nPos][i + 1].dMin + EPS_SMALL) {
//
// m_Values[nGrid][nPos][i].dMax = m_Values[nGrid][nPos][i + 1].dMax ;
// m_Values[nGrid][nPos][i].vtMaxN = m_Values[nGrid][nPos][i + 1].vtMaxN ;
// }
// // altrimenti
// else {
//
// m_Values[nGrid][nPos][i].dMin = m_Values[nGrid][nPos][i].dMin ;
// m_Values[nGrid][nPos][i].vtMinN = m_Values[nGrid][nPos][i].vtMinN ;
//
// m_Values[nGrid][nPos][i].dMax = m_Values[nGrid][nPos][i].dMax ;
// m_Values[nGrid][nPos][i].vtMaxN = m_Values[nGrid][nPos][i].vtMaxN ;
// }
//
// for ( unsigned int j = i + 1 ; j < m_Values[nGrid][nPos].size() - 1 ; ++ j) {
//
// m_Values[nGrid][nPos][j].dMin = m_Values[nGrid][nPos][j + 1].dMin ;
// m_Values[nGrid][nPos][j].vtMinN = m_Values[nGrid][nPos][j + 1].vtMinN ;
//
// m_Values[nGrid][nPos][j].dMax = m_Values[nGrid][nPos][j + 1].dMax ;
// m_Values[nGrid][nPos][j].vtMaxN = m_Values[nGrid][nPos][j + 1].vtMaxN ;
// }
//
// m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() - 1) ;
//
// i = i - 1 ;
// }
// }
//
//
// // Caso in cui devo aggiungere un intervallo a sinistra dell'intervallo corrente
// if ( m_Values[nGrid][nPos][i].dZVal > dMax + EPS_SMALL) {
//
// bModified = true ;
//
// m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ;
//
// for ( size_t j = m_Values[nGrid][nPos].size() - 1 ; j >= i + 2 ; -- j) {
//
// m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j - 2].dZVal ;
// m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j - 2].vtN ;
// }
//
//
// m_Values[nGrid][nPos][i].dZVal = dMin ;
// m_Values[nGrid][nPos][i + 1].dZVal = dMax ;
//
// m_Values[nGrid][nPos][i].vtN = vtNMin ;
// m_Values[nGrid][nPos][i + 1].vtN = vtNMax ;
//
// i = i + 2 ;
// }
//
// // Casi d'intersezione:
// else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMax - EPS_SMALL) {
//
// // Se l'intervallo da aggiungere sconfina a sinistra modifico il minimo dell'intervalo corrente
// if ( m_Values[nGrid][nPos][i].dZVal > dMin - EPS_SMALL) {
//
// bModified = true ;
// m_Values[nGrid][nPos][i].dZVal = dMin ;
// m_Values[nGrid][nPos][i].vtN = vtNmi ;
// }
// }
//
// else {
// // Se l'intervallo corrente è tutto contenuto nell'intervallo da aggungere modifico gli estremi
// if ( m_Values[nGrid][nPos][i].dZVal > dMin + EPS_SMALL) {
//
// bModified = true ;
// m_Values[nGrid][nPos][i].dZVal = dMin ;
// m_Values[nGrid][nPos][i + 1].dZVal = dMax ;
// m_Values[nGrid][nPos][i].vtN = vtNMin ;
// m_Values[nGrid][nPos][i + 1].vtN = vtNma ;
// }
// // Se l'intervallo da aggiungere sconfina a destra modifico il massimo dell'intervallo corrente
// else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMin - EPS_SMALL) {
//
// bModified = true ;
// m_Values[nGrid][nPos][i + 1].dZVal = dMax ;
// m_Values[nGrid][nPos][i + 1].vtN = vtNma ;
// }
// else {
// // Aggiungo intervallo a destra dell'ultimo intervallo
// if ( i == m_Values[nGrid][nPos].size() - 2) {
//
// bModified = true ;
// m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ;
//
// m_Values[nGrid][nPos][i + 2].dZVal = dMin ;
// m_Values[nGrid][nPos][i + 3].dZVal = dMax ;
// m_Values[nGrid][nPos][i + 2].vtN = vtNmi ;
// m_Values[nGrid][nPos][i + 3].vtN = vtNma ;
//
// i = i + 2 ;
// }
// }
// }
//
// i = i + 2 ;
// }
//
// // se eseguita modifica, imposto ricalcolo della grafica
// if ( bModified) {
//
// // Determino quali blocchi sono stati modificati
// int nLayerBlock = m_nFracLin[0] * m_nFracLin[1] ;
//
// if ( nGrid == 0) {
//
// int nXBlock = min( nI / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
// int nYBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
// int nMinZBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
// int nMaxZBlock = min( int( m_nFracLin[2] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
//
// for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k)
//
// m_BlockToUpdate[k * nLayerBlock + nYBlock * m_nFracLin[0] + nXBlock] = true ;
// }
// else if ( nGrid == 1) {
//
// int nYBlock = min( nI / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
// int nZBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
// int nMinXBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
// int nMaxXBlock = min( int( m_nFracLin[0] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
//
// for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k)
//
// m_BlockToUpdate[nZBlock * nLayerBlock + nYBlock * m_nFracLin[0] + k] = true ;
// }
// else if ( nGrid == 2) {
//
// int nXBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
// int nZBlock = min( nI / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
// int nMinYBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
// int nMaxYBlock = min( int( m_nFracLin[1] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
//
// for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k)
//
// m_BlockToUpdate[nZBlock * nLayerBlock + k * m_nFracLin[0] + nXBlock] = true ;
// }
//
// m_OGrMgr.Reset() ;
//
// // Aggiorno massima e minima Z
// // sullo Zmap
// if ( dMax > m_dMaxZ[nGrid])
// m_dMinZ[nGrid] = dMax ;
//
// if ( dMin < m_dMinZ[nGrid])
// m_dMinZ[nGrid] = dMin ;
// }
//
// Controllo che il numero di griglia sia entro i limiti
if ( nGrid < 0 || nGrid > 2)
return false ;
// Controllo che indici nI, nJ siano entro i limiti
if ( nI < 0 && nI >= m_nNx[nGrid] && nJ < 0 && nJ >= m_nNy[nGrid])
return false ;
// Controllo che dMin < dMax ( nel caso swap parametri e vettori )
Vector3d vtNmi = vtNMin ;
Vector3d vtNma = vtNMax ;
if ( dMin > dMax) {
swap( dMin, dMax) ;
swap( vtNmi, vtNma) ;
}
// Restringo minimo e massimo entro i limiti della mappa
if ( dMin < m_dMinZ[nGrid]) {
dMin = m_dMinZ[nGrid] ;
vtNmi = - Z_AX ;
}
else if ( dMin > m_dMaxZ[nGrid]) {
dMin = m_dMaxZ[nGrid] ;
vtNmi = - Z_AX ;
}
if ( dMax < m_dMinZ[nGrid]) {
dMax = m_dMinZ[nGrid] ;
vtNma = Z_AX ;
}
else if ( dMax > m_dMaxZ[nGrid]) {
dMax = m_dMaxZ[nGrid] ;
vtNma = Z_AX ;
}
// Controllo che dMin e dMax non siano quasi coincidenti ( la limitazione dei range può
// far collassare gli intervalli )
if ( abs( dMax - dMin) < EPS_SMALL)
return true ;
// Riporto le coordinate cicliche nell'ordine di partenza
if ( nGrid == 1) {
swap( vtNmi.x, vtNmi.z) ;
swap( vtNmi.y, vtNmi.z) ;
swap( vtNma.x, vtNma.z) ;
swap( vtNma.y, vtNma.z) ;
}
else if ( nGrid == 2) {
swap( vtNmi.y, vtNmi.z) ;
swap( vtNmi.x, vtNmi.z) ;
swap( vtNma.y, vtNma.z) ;
swap( vtNma.x, vtNma.z) ;
}
// Calcolo nPos
unsigned int nPos = nJ * m_nNx[nGrid] + nI ;
vector<Data>& vDexel = m_Values[nGrid][nPos] ;
bool bModified = false ;
// se non esistono segmenti...
if ( int( vDexel.size()) == 0) { // ... definisco il primo
vDexel.emplace_back() ;
vDexel.back().dMin = dMin ;
vDexel.back().vtMinN = vtNmi ;
vDexel.back().nToolMin = nToolNum ;
vDexel.back().dMax = dMax ;
vDexel.back().vtMaxN = vtNma ;
vDexel.back().nToolMax = nToolNum ;
m_OGrMgr.Reset() ;
bModified = true ; // modifica effettuata
}
// se ne esiste almeno uno, devo controllare possibili overlaps
else {
// Cerco l'ultimo intervallo a sinistra e l'ultimo intervallo a destra di quello da aggiungere,
// che non interferiscono con quest'ultimo
auto itLastLeft = vDexel.end() ;
auto itFirstRight = vDexel.end() ; // per bloccare la prima iterazione...
for ( auto it = vDexel.begin() ; it != vDexel.end() ; ++ it) {
// se il minimo attuale è maggiore del massimo it-esimo, l'intervallo it-esimo è a sinistra
if ( dMin > it->dMax + EPS_SMALL)
itLastLeft = it ; // aggiorno
// se il massimo attuale è minore del minimo it-esimo, l'interallo it-esimo è a destra
if ( dMax < it->dMin - EPS_SMALL && itFirstRight == vDexel.end())
itFirstRight = it ; // aggiorno
}
// se esistono intervalli a sinistra... ( inizialmente l'iteratore è inizializzato su end())
if ( itLastLeft != vDexel.end()) {
// prendo il successivo dell'ultimo più vicino
auto itNextToLastLeft = itLastLeft ;
++ itNextToLastLeft ;
// e se il successivo a sinistra non esiste...
if ( itNextToLastLeft == vDexel.end()) {
// aggiorno l'ultimo intervallo
vDexel.emplace_back() ;
vDexel.back().dMin = dMin ;
vDexel.back().dMax = dMax ;
vDexel.back().vtMinN = vtNmi ;
vDexel.back().vtMaxN = vtNma;
vDexel.back().nToolMin = nToolNum ;
vDexel.back().nToolMax = nToolNum ;
bModified = true ;
}
// se esiste...
else {
// controllo se coincide con il primo trovato a destra...
if ( itNextToLastLeft == itFirstRight) {
// in questo caso definisco il nuovo intervallo
Data NewSegment ;
NewSegment.dMin = dMin ;
NewSegment.dMax = dMax ;
NewSegment.vtMinN = vtNmi ;
NewSegment.vtMaxN = vtNma ;
NewSegment.nToolMin = nToolNum ;
NewSegment.nToolMax = nToolNum ;
vDexel.insert( itFirstRight, NewSegment) ; // inserimento intervallo
bModified = true ;
}
else {
// se il successivo non esce a sinistra da quello da aggiungere
if ( itNextToLastLeft->dMin > dMin + EPS_SMALL) {
itNextToLastLeft->dMin = dMin ;
itNextToLastLeft->vtMinN = vtNmi ;
itNextToLastLeft->nToolMin = nToolNum ;
}
// cerco poi l'ultimo segmento che interferisce con quello da aggiungere
auto itPrevToFirstRight = vDexel.end() ;
for ( auto it = itNextToLastLeft ; it != itFirstRight ; ++ it)
itPrevToFirstRight = it ;
// anche in qesto caso, se l'ultimo che interferisce non esce a destra da quello da aggiungere
if ( itPrevToFirstRight->dMax < dMax - EPS_SMALL) {
itNextToLastLeft->dMax = dMax ;
itNextToLastLeft->vtMaxN = vtNma ;
itNextToLastLeft->nToolMax = nToolNum ;
bModified = true ;
}
else {
itNextToLastLeft->dMax = itPrevToFirstRight->dMax ;
itNextToLastLeft->vtMaxN = itPrevToFirstRight->vtMaxN ;
itNextToLastLeft->nToolMax = nToolNum ;
bModified = true ;
}
// cancello il successivo...
auto itFirstToCancel = itNextToLastLeft ;
++ itFirstToCancel ;
vDexel.erase( itFirstToCancel, itFirstRight) ;
}
}
}
// se non esiste da destra ...
else if ( itFirstRight == m_Values[nGrid][nPos].end()) {
// e il primo intervallo non sporge a sinistra ...
if ( vDexel.begin()->dMin > dMin + EPS_SMALL) {
vDexel.begin()->dMin = dMin ;
vDexel.begin()->vtMinN = vtNmi ;
vDexel.begin()->nToolMin = nToolNum ;
bModified = true ;
}
// se sporge da destra
if ( m_Values[nGrid][nPos].back().dMax > dMax + EPS_SMALL) {
// allora ci sono più segmenti, inglobo tutti nel primo
if ( vDexel.back().dMax > vDexel.begin()->dMax + EPS_SMALL) {
vDexel.begin()->dMax = vDexel.back().dMax ;
vDexel.begin()->vtMaxN = vDexel.back().vtMaxN ;
vDexel.begin()->nToolMax = nToolNum ;
bModified = true ;
}
}
// se l'ultimo intervallo non sporge a destra.
else {
vDexel.begin()->dMax = dMax ;
vDexel.begin()->vtMaxN = vtNma ;
vDexel.begin()->nToolMax = nToolNum ;
bModified = true ;
}
// cancello quelli inglobati
vDexel.erase( vDexel.begin() + 1, vDexel.end()) ;
}
// Casi Estremi...
else {
// 1) Tutti i segmenti sono a destra da quello da aggiungere...
if ( itFirstRight == vDexel.begin()) {
// -> inserisco il nuovo intervallo
Data NewSegment ;
NewSegment.dMin = dMin ;
NewSegment.dMax = dMax ;
NewSegment.vtMinN = vtNmi ;
NewSegment.vtMaxN = vtNma ;
NewSegment.nToolMin = nToolNum ;
NewSegment.nToolMax = nToolNum ;
vDexel.insert( vDexel.begin(), NewSegment) ; // posizione iniziale
bModified = true ;
}
else {
// se il primo segmento non esce a sinistra da quello da aggiungere, cambio l'inizio
if ( vDexel.begin()->dMin > dMin + EPS_SMALL) {
vDexel.begin()->dMin = dMin ;
vDexel.begin()->vtMinN = vtNmi ;
vDexel.begin()->nToolMin = nToolNum ;
bModified = true ;
}
// cerco l'ultimo segmento che interferisce con quello da aggiungere
auto itPrevToFirstRight = vDexel.begin() ;
for ( auto it = m_Values[nGrid][nPos].begin() ; it != itFirstRight ; ++ it)
itPrevToFirstRight = it ;
// se l'ultimo che interferisce non esce a destra da quello da aggiungere...
if ( itPrevToFirstRight->dMax < dMax - EPS_SMALL) {
vDexel.begin()->dMax = dMax ;
vDexel.begin()->vtMaxN = vtNma ;
vDexel.begin()->nToolMax = nToolNum ;
bModified = true ;
}
// ... altrimenti
else {
vDexel.begin()->dMax = itPrevToFirstRight->dMax ;
vDexel.begin()->vtMaxN = itPrevToFirstRight->vtMaxN ;
vDexel.begin()->nToolMax = nToolNum ;
bModified = true ;
}
// cancello gli inglobati ( come prima )
auto itFirstToCancel = vDexel.begin() ;
++ itFirstToCancel ;
vDexel.erase( itFirstToCancel, itFirstRight) ;
}
}
}
// Se nessuna modifica, esco
if ( ! bModified)
return true ;
// Imposto ricalcolo della grafica
m_OGrMgr.Reset() ;
// Imposto forma generica
m_nShape = GENERIC ;
// Imposto ricalcolo numero di componenti connesse
m_nConnectedCompoCount = - 1 ;
// Passo da indici di dexel a indici di voxel
nI /= m_nDexVoxRatio ;
nJ /= m_nDexVoxRatio ;
// Determino quali blocchi sono stati modificati a seconda della griglia
if ( nGrid == 0) {
// Voxel lungo X
int nXStop = 1 ;
int nXBlock[2] ;
nXBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ;
if ( nI % N_VOXBLOCK == 0 && nXBlock[0] > 0) {
nXBlock[1] = nXBlock[0] - 1 ;
++ nXStop ;
}
// Voxel lungo Y
int nYStop = 1 ;
int nYBlock[2] ;
nYBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ;
if ( nJ % N_VOXBLOCK == 0 && nYBlock[0] > 0) {
nYBlock[1] = nYBlock[0] - 1 ;
++ nYStop ;
}
// Voxel lungo Z
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nMinK = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumZ - 2) ;
int nMaxK = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumZ - 2) ;
int nMinZBlock = ( m_nMapNum == 1 ? 0 : Clamp( nMinK / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[2] - 1))) ;
int nMaxZBlock = min( int( m_nFracLin[2] - 1), nMaxK / int( m_nVoxNumPerBlock)) ;
// Assegno flag ai voxel
for ( int tI = 0 ; tI < nXStop ; ++ tI) {
for ( int tJ = 0 ; tJ < nYStop ; ++ tJ) {
for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) {
int nBlockNum = k * m_nFracLin[0] * m_nFracLin[1] + nYBlock[tJ] * m_nFracLin[0] + nXBlock[tI] ;
m_BlockToUpdate[nBlockNum] = true ;
}
}
}
}
else if ( nGrid == 1) {
// Voxel lungo Y
int nYStop = 1 ;
int nYBlock[2] ;
nYBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ;
if ( nI % N_VOXBLOCK == 0 && nYBlock[0] > 0) {
nYBlock[1] = nYBlock[0] - 1 ;
++ nYStop ;
}
// Voxel lungo Z
int nZStop = 1 ;
int nZBlock[2] ;
nZBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ;
if ( nJ % N_VOXBLOCK == 0 && nZBlock[0] > 0) {
nZBlock[1] = nZBlock[0] - 1 ;
++ nZStop ;
}
// Voxel lungo X
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nMinI = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumX - 2) ;
int nMaxI = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumX - 2) ;
int nMinXBlock = Clamp( nMinI / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[0] - 1)) ;
int nMaxXBlock = min( int( m_nFracLin[0] - 1), nMaxI / int( m_nVoxNumPerBlock)) ;
// Assegno flag ai voxel
for ( int tI = 0 ; tI < nYStop ; ++ tI) {
for ( int tJ = 0 ; tJ < nZStop ; ++ tJ) {
for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) {
int nBlockNum = nZBlock[tJ] * m_nFracLin[0] * m_nFracLin[1] + nYBlock[tI] * m_nFracLin[0] + k ;
m_BlockToUpdate[nBlockNum] = true ;
}
}
}
}
else if ( nGrid == 2) {
// Voxel lungo X
int nXStop = 1 ;
int nXBlock[2] ;
nXBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ;
if ( nJ % N_VOXBLOCK == 0 && nXBlock[0] > 0) {
nXBlock[1] = nXBlock[0] - 1 ;
++ nXStop ;
}
// Voxel lungo Z
int nZStop = 1 ;
int nZBlock[2] ;
nZBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ;
if ( nI % N_VOXBLOCK == 0 && nZBlock[0] > 0) {
nZBlock[1] = nZBlock[0] - 1 ;
++ nZStop ;
}
// Voxel lungo Y
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nMinJ = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumY - 2) ;
int nMaxJ = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumY - 2) ;
int nMinYBlock = Clamp( nMinJ / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[1] - 1)) ;
int nMaxYBlock = min( int( m_nFracLin[1] - 1), nMaxJ / int( m_nVoxNumPerBlock)) ;
// Assegno flag ai voxel
for ( int tI = 0 ; tI < nZStop ; ++ tI) {
for ( int tJ = 0 ; tJ < nXStop ; ++ tJ) {
for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) {
int nBlockNum = nZBlock[tI] * m_nFracLin[0] * m_nFracLin[1] + k * m_nFracLin[0] + nXBlock[tJ] ;
m_BlockToUpdate[nBlockNum] = true ;
}
}
}
}
return true ;
}