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

EgtGeomKernel 2.1b1 :

Browse Source 
- modifiche a Zmap per mantenimento liste triangoli.
This commit is contained in:
Dario Sassi
2019-02-11 11:55:33 +00:00
parent 48ae6e5da5
commit fca22fc56b
7 changed files with 1576 additions and 1412 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmap.cpp
+116 -104
View File
@@ -138,12 +138,18 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc)
m_nTempProp = vzmSrc.m_nTempProp ;
// dimensiono membri legati ai blocchi
m_BlockToUpdate.resize( m_nNumBlock) ;
m_InterBlockVox.resize( m_nNumBlock) ;
m_InterBlockTria.resize( m_nNumBlock) ;
m_SliceXY.resize( m_nNumBlock) ;
m_SliceXZ.resize( m_nNumBlock) ;
m_SliceYZ.resize( m_nNumBlock) ;
m_BlockToUpdate = vzmSrc.m_BlockToUpdate ;
m_BlockUpGradingCounter = vzmSrc.m_BlockUpGradingCounter ;
m_InterBlockVox = vzmSrc.m_InterBlockVox ;
m_InterBlockOriginalSharpTria = vzmSrc.m_InterBlockOriginalSharpTria ;
m_InterBlockToBeFlippedSharpTria = vzmSrc.m_InterBlockToBeFlippedSharpTria ;
m_BlockSharpTria = vzmSrc.m_BlockSharpTria ;
m_BlockSmoothTria = vzmSrc.m_BlockSmoothTria ;
m_BlockBigTria = vzmSrc.m_BlockBigTria ;
m_SingleMapTria = vzmSrc.m_SingleMapTria ;
m_SliceXY = vzmSrc.m_SliceXY ;
m_SliceXZ = vzmSrc.m_SliceXZ ;
m_SliceYZ = vzmSrc.m_SliceYZ ;
// imposto ricalcolo grafica
ResetGraphics() ;
@@ -156,7 +162,7 @@ bool
VolZmap::ResetGraphics( void)
{
m_OGrMgr.Reset() ;
for ( unsigned int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount)
for ( int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount)
m_BlockToUpdate[nCount] = true ;
return true ;
}
@@ -196,7 +202,7 @@ VolZmap::Dump( string& sOut, bool bMM, const char* szNewLine) const
sOut += "Dim=" + ToString( m_nDim[0]) +
"(" + ToString( m_nNx[0]) + "x" + ToString( m_nNy[0]) + ")" + szNewLine ;
else {
for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i)
for ( int i = 0 ; i < m_nMapNum ; ++ i)
sOut += "Dim" + ToString( i+1) + "=" + ToString( m_nDim[i]) +
"(" + ToString( m_nNx[i]) + "x" + ToString( m_nNy[i]) + ")" + szNewLine ;
}
@@ -245,7 +251,7 @@ VolZmap::Save( NgeWriter& ngeOut) const
if ( ! ngeOut.WriteFrame( m_MapFrame, ";", true))
return false ;
// per ogni mappa : numero di passi in X e Y e quote z estremali
for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) {
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
if ( ! ngeOut.WriteInt( m_nNx[i], ",", false))
return false ;
if ( ! ngeOut.WriteInt( m_nNy[i], ",", false))
@@ -256,11 +262,11 @@ VolZmap::Save( NgeWriter& ngeOut) const
return false ;
}
// ciclo sulle mappe
for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) {
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
// ciclo sui dexel
for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) {
for ( int j = 0 ; j < m_nDim[i] ; ++ j) {
// numero di estremi
unsigned int nDim = unsigned int( m_Values[i][j].size()) ;
int nDim = int( m_Values[i][j].size()) ;
if ( ! ngeOut.WriteInt( nDim, ":", false))
return false ;
// se dexel nullo
@@ -271,7 +277,7 @@ VolZmap::Save( NgeWriter& ngeOut) const
}
// altrimenti
else {
for ( unsigned int k = 0 ; k < nDim ; ++ k) {
for ( int k = 0 ; k < nDim ; ++ k) {
if ( ! ngeOut.WriteDouble( m_Values[i][j][k].dMin, ",", false))
return false ;
if ( ! ngeOut.WriteInt( m_Values[i][j][k].nToolMin, ";", false))
@@ -327,7 +333,7 @@ VolZmap::Load( NgeReader& ngeIn)
if ( ! ngeIn.ReadFrame( m_MapFrame, ";", true))
return false ;
// per ogni mappa : numero di passi in X e Y e quote z estremali
for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) {
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
if ( ! ngeIn.ReadInt( m_nNx[i], ",", false))
return false ;
if ( ! ngeIn.ReadInt( m_nNy[i], ",", false))
@@ -339,13 +345,13 @@ VolZmap::Load( NgeReader& ngeIn)
return false ;
}
// ciclo sulle mappe
for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) {
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
// dimensiono i vettori
m_Values[i].resize( m_nDim[i]) ;
// ciclo sui dexel
for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) {
for ( int j = 0 ; j < m_nDim[i] ; ++ j) {
// leggo il numero di estremi nel dexel
unsigned int nDim ;
int nDim ;
if ( ! ngeIn.ReadInt( nDim, ":", false))
return false ;
// se dexel nullo
@@ -360,7 +366,7 @@ VolZmap::Load( NgeReader& ngeIn)
// dimensiono l'array
m_Values[i][j].resize( nDim) ;
// leggo i valori
for ( unsigned int k = 0 ; k < nDim ; ++ k) {
for ( int k = 0 ; k < nDim ; ++ k) {
if ( ! ngeIn.ReadDouble( m_Values[i][j][k].dMin, ",", false))
return false ;
if ( ! ngeIn.ReadInt( m_Values[i][j][k].nToolMin, ";", false))
@@ -381,13 +387,17 @@ VolZmap::Load( NgeReader& ngeIn)
}
// imposto aggiornamento obbligatorio su tutti i blocchi
m_BlockToUpdate.resize( m_nNumBlock) ;
for ( unsigned int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount)
m_BlockToUpdate[nCount] = true ;
m_BlockToUpdate.resize( m_nNumBlock, true) ;
m_BlockUpGradingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ;
// per triangoli di feature di frontiera tra blocchi
m_InterBlockVox.resize( m_nNumBlock) ;
m_InterBlockTria.resize( m_nNumBlock) ;
m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ;
m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ;
m_BlockSharpTria.resize( m_nNumBlock) ;
m_BlockSmoothTria.resize( m_nNumBlock) ;
m_BlockBigTria.resize( m_nNumBlock) ;
m_SingleMapTria.resize( m_nNumBlock) ;
m_SliceXY.resize( m_nNumBlock) ;
m_SliceXZ.resize( m_nNumBlock) ;
m_SliceYZ.resize( m_nNumBlock) ;
@@ -415,13 +425,13 @@ VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
// calcolo preciso
// ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
double dY = 0 ;
for ( size_t j = 0 ; j <= m_nNy[0] ; ++ j) {
size_t jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] - 1) ;
for ( int j = 0 ; j <= m_nNy[0] ; ++ j) {
int jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] - 1) ;
double dX = 0 ;
// punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
for ( size_t i = 0 ; i <= m_nNx[0] ; ++ i) {
size_t ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] - 1) ;
size_t nPos = ic + jc * m_nNx[0] ;
for ( int i = 0 ; i <= m_nNx[0] ; ++ i) {
int ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] - 1) ;
int nPos = ic + jc * m_nNx[0] ;
if ( m_Values[0][nPos].size() > 0) {
Point3d ptP = m_MapFrame.Orig() + dX * m_MapFrame.VersX() + dY * m_MapFrame.VersY() ;
b3Loc.Add( ptP + m_Values[0][nPos][0].dMin * m_MapFrame.VersZ()) ;
@@ -459,13 +469,13 @@ VolZmap::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
// calcolo preciso
// ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
double dY = 0 ;
for ( size_t j = 0 ; j <= m_nNy[0] ; ++ j) {
size_t jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] -1) ;
for ( int j = 0 ; j <= m_nNy[0] ; ++ j) {
int jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] -1) ;
double dX = 0 ;
// punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
for ( size_t i = 0 ; i <= m_nNx[0] ; ++ i) {
size_t ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] -1) ;
size_t nPos = ic + jc * m_nNx[0] ;
for ( int i = 0 ; i <= m_nNx[0] ; ++ i) {
int ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] -1) ;
int nPos = ic + jc * m_nNx[0] ;
if ( m_Values[0][nPos].size() > 0) {
Point3d ptP = frUse.Orig() + dX * frUse.VersX() + dY * frUse.VersY() ;
b3Ref.Add( ptP + m_Values[0][nPos][0].dMin * frUse.VersZ()) ;
@@ -607,9 +617,9 @@ VolZmap::CheckMapConnection( void)
m_nConnectedCompoCount = 0 ;
// Imposto a 0 tutti il valore del numero della componente
// connessa di ciascun tratto di ciascun dexel.
for ( size_t tMap = 0 ; tMap < m_nMapNum ; ++ tMap) {
for ( size_t tDex = 0 ; tDex < m_nDim[tMap] ; ++ tDex) {
for ( size_t tInt = 0 ; tInt < m_Values[tMap][tDex].size() ; ++ tInt) {
for ( int tMap = 0 ; tMap < m_nMapNum ; ++ tMap) {
for ( int tDex = 0 ; tDex < m_nDim[tMap] ; ++ tDex) {
for ( int tInt = 0 ; tInt < int( m_Values[tMap][tDex].size()) ; ++ tInt) {
m_Values[tMap][tDex][tInt].nCompo = 0 ;
// Controlli sui tratti di dexel non incidenti su nodi del reticolo
@@ -651,14 +661,14 @@ VolZmap::CheckMapConnection( void)
}
// Ciclo sui dexel lungo Z
for ( size_t tI = 0 ; tI < m_nNx[0] ; ++ tI) {
for ( size_t tJ = 0 ; tJ < m_nNy[0] ; ++ tJ) {
for ( int tI = 0 ; tI < m_nNx[0] ; ++ tI) {
for ( int tJ = 0 ; tJ < m_nNy[0] ; ++ tJ) {
// Numero del dexel lungo Z
size_t tDexZ = tJ * m_nNx[0] + tI ;
int tDexZ = tJ * m_nNx[0] + tI ;
// Numero di intervalli nel dexel
size_t tStopIntZ = m_Values[0][tDexZ].size() ;
int tStopIntZ = int( m_Values[0][tDexZ].size()) ;
// Ciclo sugli intervalli del dexel
for ( size_t tIntZ = 0 ; tIntZ < tStopIntZ ; ++ tIntZ) {
for ( int tIntZ = 0 ; tIntZ < tStopIntZ ; ++ tIntZ) {
if ( m_Values[0][tDexZ][tIntZ].nCompo == 0) {
++ m_nConnectedCompoCount ;
@@ -708,10 +718,10 @@ VolZmap::ExpandFromXInterval( IntContaier& IntCont)
// Copio i dati dell'intervallo corrente
IntervalIndexes CurrInterval = IntCont.top() ;
IntCont.pop() ;
size_t tDex = CurrInterval.tDex ;
size_t tGrIndex1 = CurrInterval.tDex % m_nNx[1] ;
size_t tGrIndex2 = CurrInterval.tDex / m_nNx[1] ;
size_t tInt = CurrInterval.tInt ;
int tDex = CurrInterval.tDex ;
int tGrIndex1 = CurrInterval.tDex % m_nNx[1] ;
int tGrIndex2 = CurrInterval.tDex / m_nNx[1] ;
int tInt = CurrInterval.tInt ;
// Quote estreme del segmento lungo X
double dMinX = m_Values[1][tDex][tInt].dMin ;
double dMaxX = m_Values[1][tDex][tInt].dMax ;
@@ -719,17 +729,17 @@ VolZmap::ExpandFromXInterval( IntContaier& IntCont)
double dMaxDX = max( floor( ( dMaxX + EPS_SMALL) / m_dStep - 0.5), 0.) ;
// Indici estremi dei dei dexel ortogonali
// che possono intersecare il segmento di partenza
size_t tStartI = min( size_t( dMinDX), size_t( m_nNx[0] - 1)) ;
size_t tStopI = min( size_t( dMaxDX), size_t( m_nNx[0] - 1)) ;
int tStartI = min( int( dMinDX), ( m_nNx[0] - 1)) ;
int tStopI = min( int( dMaxDX), ( m_nNx[0] - 1)) ;
// Posizione YZ del dexel
double dY = ( tGrIndex1 + 0.5) * m_dStep ;
double dZ = ( tGrIndex2 + 0.5) * m_dStep ;
// Ciclo sugli indici dei dexel che potrebbero
// intersecare il segmento di partenza
for ( size_t tI = tStartI ; tI <= tStopI ; ++ tI) {
for ( int tI = tStartI ; tI <= tStopI ; ++ tI) {
// Analizzo i dexel della griglia 0.
size_t tStopZ = m_Values[0][tGrIndex1 * m_nNx[0] + tI].size() ;
for ( size_t tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) {
int tStopZ = int( m_Values[0][tGrIndex1 * m_nNx[0] + tI].size()) ;
for ( int tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) {
// Estremi del dexel lunog Z
double dZmin = m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].dMin ;
double dZmax = m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].dMax ;
@@ -748,8 +758,8 @@ VolZmap::ExpandFromXInterval( IntContaier& IntCont)
}
}
// Analizzo i dexel della griglia 2
size_t tStopY = m_Values[2][tI * m_nNx[2] + tGrIndex2].size() ;
for ( size_t tIntY = 0 ; tIntY < tStopY ; ++ tIntY) {
int tStopY = int( m_Values[2][tI * m_nNx[2] + tGrIndex2].size()) ;
for ( int tIntY = 0 ; tIntY < tStopY ; ++ tIntY) {
// Estremi del segmento del dexel lungo Y
double dYmin = m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].dMin ;
double dYmax = m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].dMax ;
@@ -779,10 +789,10 @@ VolZmap::ExpandFromYInterval( IntContaier& IntCont)
// Copio i dati dell'intervallo corrente
IntervalIndexes CurrInterval = IntCont.top() ;
IntCont.pop() ;
size_t tDex = CurrInterval.tDex ;
size_t tGrIndex1 = CurrInterval.tDex % m_nNx[2] ;
size_t tGrIndex2 = CurrInterval.tDex / m_nNx[2] ;
size_t tInt = CurrInterval.tInt ;
int tDex = CurrInterval.tDex ;
int tGrIndex1 = CurrInterval.tDex % m_nNx[2] ;
int tGrIndex2 = CurrInterval.tDex / m_nNx[2] ;
int tInt = CurrInterval.tInt ;
// Quote estreme del segmento lungo Y
double dMinY = m_Values[2][tDex][tInt].dMin ;
double dMaxY = m_Values[2][tDex][tInt].dMax ;
@@ -790,17 +800,17 @@ VolZmap::ExpandFromYInterval( IntContaier& IntCont)
double dMaxDY = max( floor( ( dMaxY + EPS_SMALL) / m_dStep - 0.5), 0.) ;
// Indici estremi dei dei dexel ortogonali
// che possono intersecare il segmento di partenza
size_t tStartJ = min( size_t( dMinDY), size_t( m_nNy[0] - 1)) ;
size_t tStopJ = min( size_t( dMaxDY), size_t( m_nNy[0] - 1)) ;
int tStartJ = min( int( dMinDY), ( m_nNy[0] - 1)) ;
int tStopJ = min( int( dMaxDY), ( m_nNy[0] - 1)) ;
// Posizione XZ del dexel
double dX = ( tGrIndex2 + 0.5) * m_dStep ;
double dZ = ( tGrIndex1 + 0.5) * m_dStep ;
// Ciclo sugli indici dei dexel che potrebbero
// intersecare il segmento di partenza
for ( size_t tJ = tStartJ ; tJ <= tStopJ ; ++ tJ) {
for ( int tJ = tStartJ ; tJ <= tStopJ ; ++ tJ) {
// Analizzo i dexel della griglia 0.
size_t tStopZ = m_Values[0][tJ * m_nNx[0] + tGrIndex2].size() ;
for ( size_t tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) {
int tStopZ = int( m_Values[0][tJ * m_nNx[0] + tGrIndex2].size()) ;
for ( int tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) {
// Estremi del dexel lunog Z
double dZmin = m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].dMin ;
double dZmax = m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].dMax ;
@@ -819,8 +829,8 @@ VolZmap::ExpandFromYInterval( IntContaier& IntCont)
}
}
// Analizzo i dexel della griglia 1
size_t tStopX = m_Values[1][tGrIndex1 * m_nNx[1] + tJ].size() ;
for ( size_t tIntX = 0 ; tIntX < tStopX ; ++ tIntX) {
int tStopX = int( m_Values[1][tGrIndex1 * m_nNx[1] + tJ].size()) ;
for ( int tIntX = 0 ; tIntX < tStopX ; ++ tIntX) {
// Estremi del segmento del dexel lungo X
double dXmin = m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].dMin ;
double dXmax = m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].dMax ;
@@ -850,10 +860,10 @@ VolZmap::ExpandFromZInterval( IntContaier& IntCont)
// Copio i dati dell'intervallo corrente
IntervalIndexes CurrInterval = IntCont.top() ;
IntCont.pop() ;
size_t tDex = CurrInterval.tDex ;
size_t tGrIndex1 = CurrInterval.tDex % m_nNx[0] ;
size_t tGrIndex2 = CurrInterval.tDex / m_nNx[0] ;
size_t tInt = CurrInterval.tInt ;
int tDex = CurrInterval.tDex ;
int tGrIndex1 = CurrInterval.tDex % m_nNx[0] ;
int tGrIndex2 = CurrInterval.tDex / m_nNx[0] ;
int tInt = CurrInterval.tInt ;
// Quote estreme del segmento lungo Z
double dMinZ = m_Values[0][tDex][tInt].dMin ;
double dMaxZ = m_Values[0][tDex][tInt].dMax ;
@@ -861,17 +871,17 @@ VolZmap::ExpandFromZInterval( IntContaier& IntCont)
double dMaxDZ = max( floor( ( dMaxZ + EPS_SMALL) / m_dStep - 0.5), 0.) ;
// Indici estremi dei dexel ortogonali
// che possono intersecare il segmento di partenza
size_t tStartK = min( size_t( dMinDZ), size_t( m_nNy[1] - 1)) ;
size_t tStopK = min( size_t( dMaxDZ), size_t( m_nNy[1] - 1)) ;
int tStartK = min( int( dMinDZ), ( m_nNy[1] - 1)) ;
int tStopK = min( int( dMaxDZ), ( m_nNy[1] - 1)) ;
// Posizione XY del dexel
double dX = ( tGrIndex1 + 0.5) * m_dStep ;
double dY = ( tGrIndex2 + 0.5) * m_dStep ;
// Ciclo sugli indici dei dexel che potrebbero
// intersecare il segmento di partenza
for ( size_t tK = tStartK ; tK <= tStopK ; ++ tK) {
for ( int tK = tStartK ; tK <= tStopK ; ++ tK) {
// Analizzo i dexel della griglia 1.
size_t tStopX = m_Values[1][tK * m_nNx[1] + tGrIndex2].size() ;
for ( size_t tIntX = 0 ; tIntX < tStopX ; ++ tIntX) {
int tStopX = int( m_Values[1][tK * m_nNx[1] + tGrIndex2].size()) ;
for ( int tIntX = 0 ; tIntX < tStopX ; ++ tIntX) {
// Estremi del segmento del dexel lungo X
double dXmin = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMin ;
double dXmax = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMax ;
@@ -890,8 +900,8 @@ VolZmap::ExpandFromZInterval( IntContaier& IntCont)
}
}
// Analizzo i dexel della griglia 2
size_t tStopY = m_Values[2][tGrIndex1 * m_nNx[2] + tK].size() ;
for ( size_t tIntY = 0 ; tIntY < tStopY ; ++ tIntY) {
int tStopY = int( m_Values[2][tGrIndex1 * m_nNx[2] + tK].size()) ;
for ( int tIntY = 0 ; tIntY < tStopY ; ++ tIntY) {
// Estremi del segmento del dexel lungo Y
double dYmin = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMin ;
double dYmax = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMax ;
@@ -1084,32 +1094,33 @@ VolZmap::ClonePart( int nPart) const
}
// Calcolo il numero di voxel lungo x,y e z
unsigned int nVoxNumX = pVolume->m_nNx[0] / pVolume->N_DEXVOXRATIO +
( pVolume->m_nNx[0] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ;
unsigned int nVoxNumY = pVolume->m_nNy[0] / pVolume->N_DEXVOXRATIO +
( pVolume->m_nNy[0] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ;
unsigned int nVoxNumZ = pVolume->m_nNy[1] / pVolume->N_DEXVOXRATIO +
( pVolume->m_nNy[1] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ;
int nVoxNumX = pVolume->m_nNx[0] / pVolume->N_DEXVOXRATIO +
( pVolume->m_nNx[0] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ;
int nVoxNumY = pVolume->m_nNy[0] / pVolume->N_DEXVOXRATIO +
( pVolume->m_nNy[0] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ;
int nVoxNumZ = pVolume->m_nNy[1] / pVolume->N_DEXVOXRATIO +
( pVolume->m_nNy[1] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ;
// Definisco il numero di blocchi lungo x,y e z
pVolume->m_nFracLin[0] = max( 1u, nVoxNumX / pVolume->m_nVoxNumPerBlock +
pVolume->m_nFracLin[0] = max( 1, nVoxNumX / pVolume->m_nVoxNumPerBlock +
( nVoxNumX % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
pVolume->m_nFracLin[1] = max( 1u, nVoxNumY / pVolume->m_nVoxNumPerBlock +
pVolume->m_nFracLin[1] = max( 1, nVoxNumY / pVolume->m_nVoxNumPerBlock +
( nVoxNumY % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
pVolume->m_nFracLin[2] = max( 1u, nVoxNumZ / pVolume->m_nVoxNumPerBlock +
pVolume->m_nFracLin[2] = max( 1, nVoxNumZ / pVolume->m_nVoxNumPerBlock +
( nVoxNumZ % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
// Dimensiono il vettore dei blocchi
pVolume->m_nNumBlock = pVolume->m_nFracLin[0] * pVolume->m_nFracLin[1] * pVolume->m_nFracLin[2] ;
pVolume->m_BlockToUpdate.resize( pVolume->m_nNumBlock) ;
// Setto tutti i blocchi come da aggiornare per la grafica
for ( unsigned int nCount = 0 ; nCount < pVolume->m_nNumBlock ; ++ nCount)
pVolume->m_BlockToUpdate[nCount] = true ;
pVolume->m_BlockToUpdate.resize( pVolume->m_nNumBlock, true) ;
// Dimensiono il vettore dei contatori degli aggiornamenti della grafica dei blocchi
pVolume->m_BlockUpGradingCounter.resize( pVolume->m_nNumBlock + 1, 0) ;
// Dimensiono raccolta di voxel di confine
pVolume->m_InterBlockVox.resize( pVolume->m_nNumBlock) ;
// Dimensiono raccolta triangoli di feature tra blocchi
pVolume->m_InterBlockTria.resize( pVolume->m_nNumBlock) ;
pVolume->m_InterBlockOriginalSharpTria.resize( pVolume->m_nNumBlock) ;
pVolume->m_BlockSharpTria.resize( pVolume->m_nNumBlock) ;
pVolume->m_BlockSmoothTria.resize( pVolume->m_nNumBlock) ;
pVolume->m_BlockBigTria.resize( pVolume->m_nNumBlock) ;
pVolume->m_SliceXY.resize( pVolume->m_nNumBlock) ;
pVolume->m_SliceXZ.resize( pVolume->m_nNumBlock) ;
pVolume->m_SliceYZ.resize( pVolume->m_nNumBlock) ;
@@ -1147,7 +1158,7 @@ VolZmap::RemovePart( int nPart)
// Elimino i segmenti con indice nPart + 1 e aggiorno quelli con indice superiore
// Ciclo sulle mappe.
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
// Ciclo sui dexel della mappa.
for ( int nDex = 0 ; nDex < int( m_Values[nMap].size()) ; ++ nDex) {
// Ciclo sugli intervalli del dexel.
@@ -1155,8 +1166,8 @@ VolZmap::RemovePart( int nPart)
// Se l'intervallo appartiene alla componente da eliminare, lo cancello.
if ( m_Values[nMap][nDex][nInt].nCompo == nPart + 1) {
SetToModifyDexelBlocks( nMap, nDex, nInt) ;
m_Values[nMap][nDex].erase( m_Values[nMap][nDex].begin() + nInt) ;
-- nInt ;
m_Values[nMap][nDex].erase( m_Values[nMap][nDex].begin() + nInt) ;
-- nInt ;
}
else if ( m_Values[nMap][nDex][nInt].nCompo > nPart + 1)
m_Values[nMap][nDex][nInt].nCompo -= 1 ;
@@ -1240,7 +1251,7 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
}
}
else if ( nGrid == 1) {
else if ( nGrid == 1) {
int nYStop = 1 ;
int nZStop = 1 ;
@@ -1577,26 +1588,27 @@ VolZmap::Compact( void)
}
// Calcolo il numero di voxel lungo x,y e z
unsigned int nVoxNumX = m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
unsigned int nVoxNumY = m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
unsigned int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
int nVoxNumX = m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
int nVoxNumY = m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
// Definisco il numero di blocchi lungo x,y e z
m_nFracLin[0] = max( 1u, nVoxNumX / m_nVoxNumPerBlock + ( nVoxNumX % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
m_nFracLin[1] = max( 1u, nVoxNumY / m_nVoxNumPerBlock + ( nVoxNumY % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
m_nFracLin[2] = max( 1u, nVoxNumZ / m_nVoxNumPerBlock + ( nVoxNumZ % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
m_nFracLin[0] = max( 1, nVoxNumX / m_nVoxNumPerBlock + ( nVoxNumX % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
m_nFracLin[1] = max( 1, nVoxNumY / m_nVoxNumPerBlock + ( nVoxNumY % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
m_nFracLin[2] = max( 1, nVoxNumZ / m_nVoxNumPerBlock + ( nVoxNumZ % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
// Dimensiono il vettore dei blocchi
m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
m_BlockToUpdate.resize( m_nNumBlock) ;
// Setto tutti i blocchi come da aggiornare per la grafica
for ( int nCount = 0 ; nCount < int( m_nNumBlock) ; ++ nCount)
m_BlockToUpdate[nCount] = true ;
m_BlockToUpdate.resize( m_nNumBlock, true) ;
// Dimensiono il vettore dei contatori di aggiornamenti dei blocchi
m_BlockUpGradingCounter.resize( m_nNumBlock, 0) ;
// Dimensiono raccolta di voxel di confine
m_InterBlockVox.resize( m_nNumBlock) ;
// Dimensiono raccolta triangoli di feature tra blocchi
m_InterBlockTria.resize( m_nNumBlock) ;
m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ;
m_BlockSharpTria.resize( m_nNumBlock) ;
m_BlockSmoothTria.resize( m_nNumBlock) ;
m_BlockBigTria.resize( m_nNumBlock) ;
m_SliceXY.resize( m_nNumBlock) ;
m_SliceXZ.resize( m_nNumBlock) ;
m_SliceYZ.resize( m_nNumBlock) ;