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

EgtGeomKernel 2.2i2 :

Browse Source 
- in VolZmap possibilità di modifica dinamica del rapporto VoxToDex con la funzione ChangeResolution
- in VolZmap calcolo triangoli superficie corretta gestione soluzioni duali
- in VolZmap corretti problemi quando non c'è alcun dexel.
This commit is contained in:
Dario Sassi
2020-09-18 10:02:47 +00:00
parent b72320adbe
commit 2fcc500ac4
6 changed files with 295 additions and 366 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtGeomKernel.rc
BIN
View File
Binary file not shown.
VolZmap.cpp
+85 -74
View File
@@ -35,7 +35,7 @@ GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;
//----------------------------------------------------------------------------
VolZmap::VolZmap(void)
: m_nStatus( TO_VERIFY), m_nMapNum( 0), m_nNumBlock( 0), m_nConnectedCompoCount( 0), m_dStep( 10.0),
m_nVoxNumPerBlock( N_VOXBLOCK), m_nShape( GENERIC), m_nTempProp( 0), m_Tool( true)
m_nVoxNumPerBlock( N_VOXBLOCK), m_nDexVoxRatio( 1), m_nShape( GENERIC), m_nTempProp( 0), m_Tool( true)
{
for ( int i = 0 ; i < N_MAPS ; ++ i) {
m_nNx[i] = 0 ;
@@ -473,13 +473,13 @@ VolZmap::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
// ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
double dY = 0 ;
for ( int j = 0 ; j <= m_nNy[0] ; ++ j) {
int jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] -1) ;
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 ( int i = 0 ; i <= m_nNx[0] ; ++ i) {
int ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] -1) ;
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) {
if ( nPos >= 0 && 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()) ;
b3Ref.Add( ptP + m_Values[0][nPos][m_Values[0][nPos].size()-1].dMax * frUse.VersZ()) ;
@@ -1269,37 +1269,9 @@ VolZmap::ClonePart( int nPart) const
}
}
// Calcolo il numero di voxel lungo x,y e z
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( 1, nVoxNumX / pVolume->m_nVoxNumPerBlock +
( nVoxNumX % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ;
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( 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, true) ;
// Dimensiono il vettore dei contatori degli aggiornamenti della grafica dei blocchi
pVolume->m_BlockUpdatingCounter.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_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) ;
if ( ! pVolume->CalcBlockNum())
return false ;
// Sistema di riferimento intrinseco del nuovo solido
Point3d ptNewO = m_MapFrame.Orig() + Vector3d( dNewOx, dNewOy, dNewOz) ;
@@ -1446,8 +1418,8 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
int nYBlock[2] ;
// Passo dal dexel al voxel
nI /= N_DEXVOXRATIO ;
nJ /= N_DEXVOXRATIO ;
nI /= m_nDexVoxRatio ;
nJ /= m_nDexVoxRatio ;
nXBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ;
nYBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ;
@@ -1463,10 +1435,10 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
}
// Numero di voxel lungo Z
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 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) / ( N_DEXVOXRATIO * m_dStep) - EPS_SMALL))), 0, nVoxNumZ - 2) ;
int nMaxK = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( N_DEXVOXRATIO * m_dStep) + EPS_SMALL))), 0, nVoxNumZ - 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)) ;
@@ -1490,8 +1462,8 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
int nZBlock[2] ;
// Passo dal dexel al voxel
nI /= N_DEXVOXRATIO ;
nJ /= N_DEXVOXRATIO ;
nI /= m_nDexVoxRatio ;
nJ /= m_nDexVoxRatio ;
nYBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ;
nZBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ;
@@ -1507,10 +1479,10 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
}
// Numero di voxel lungo X
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
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) / ( N_DEXVOXRATIO * m_dStep) - EPS_SMALL))), 0, nVoxNumX - 2) ;
int nMaxI = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( N_DEXVOXRATIO * m_dStep) + EPS_SMALL))), 0, nVoxNumX - 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)) ;
@@ -1534,8 +1506,8 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
int nZBlock[2] ;
// Passo dal dexel al voxel
nI /= N_DEXVOXRATIO ;
nJ /= N_DEXVOXRATIO ;
nI /= m_nDexVoxRatio ;
nJ /= m_nDexVoxRatio ;
nXBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ;
nZBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ;
@@ -1551,10 +1523,10 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
}
// Numero di voxel lungo Y
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
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) / ( N_DEXVOXRATIO * m_dStep) - EPS_SMALL))), 0, nVoxNumY - 2) ;
int nMaxJ = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( N_DEXVOXRATIO * m_dStep) + EPS_SMALL))), 0, nVoxNumY - 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)) ;
@@ -1823,32 +1795,10 @@ VolZmap::Compact( void)
m_Values[nMap].emplace_back( Values[nMap][nD]) ;
}
}
// Calcolo il numero di voxel lungo x,y e z
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( 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, true) ;
// Dimensiono il vettore dei contatori di aggiornamenti dei blocchi
m_BlockUpdatingCounter.resize( m_nNumBlock, 0) ;
// Dimensiono raccolta di voxel di confine
m_InterBlockVox.resize( m_nNumBlock) ;
// Dimensiono raccolta triangoli di feature tra blocchi
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) ;
if ( ! CalcBlockNum())
return false ;
// Sistema di riferimento intrinseco del nuovo solido
Point3d ptNewO = m_MapFrame.Orig() + Vector3d( dNewOx, dNewOy, dNewOz) ;
@@ -1860,6 +1810,67 @@ VolZmap::Compact( void)
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::ChangeResolution( int nDexVoxRatio)
{
if ( nDexVoxRatio < 1 || nDexVoxRatio > 2)
return false ;
if ( nDexVoxRatio != m_nDexVoxRatio) {
m_nDexVoxRatio = nDexVoxRatio ;
if ( CalcBlockNum()) {
ResetGraphics() ;
m_OGrMgr.Clear() ;
return true ;
}
m_nDexVoxRatio = ( m_nDexVoxRatio == 1 ? 2 : 1) ;
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::CalcBlockNum( void)
{
// Calcolo il numero di voxel lungo X e Y
int nVoxNumX = m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2) ;
int nVoxNumY = m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2) ;
if ( nVoxNumX == 0 || nVoxNumY == 0)
return false ;
// Definisco il numero di blocchi lungo X e Y
m_nFracLin[0] = max( 1, nVoxNumX / m_nVoxNumPerBlock + ( nVoxNumX % m_nVoxNumPerBlock > m_nVoxNumPerBlock / 4 ? 1 : 0)) ;
m_nFracLin[1] = max( 1, nVoxNumY / m_nVoxNumPerBlock + ( nVoxNumY % m_nVoxNumPerBlock > m_nVoxNumPerBlock / 4 ? 1 : 0)) ;
if ( m_nMapNum == 1) {
m_nFracLin[2] = 1 ;
m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
return true ;
}
// Calcolo il numero di voxel lungo Z
int nVoxNumZ = m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2) ;
// Definisco il numero di blocchi lungo Z
m_nFracLin[2] = max( 1, nVoxNumZ / m_nVoxNumPerBlock + ( nVoxNumZ % m_nVoxNumPerBlock > m_nVoxNumPerBlock / 4 ? 1 : 0)) ;
// Dimensiono e setto il vettore dei blocchi a da ricalcolare e il vettore di contatori di aggiornamenti della grafica
m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
m_BlockToUpdate.clear() ;
m_BlockToUpdate.resize( m_nNumBlock, true) ;
m_BlockUpdatingCounter.clear() ;
m_BlockUpdatingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ;
// 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_InterBlockSharpTria.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) ;
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::SetTolerances( double dLinTol, double dAngTolDeg)
VolZmap.h
+4 -2
View File
@@ -105,6 +105,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
VolZmap* ClonePart( int nPart) const override ;
bool RemovePart( int nPart) override ;
int GetPartMinDistFromPoint( const Point3d& ptP) const override ;
bool ChangeResolution( int nDexVoxRatio) ;
public : // IGeoObjRW
int GetNgeId( void) const override ;
@@ -193,7 +194,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVox) const ;
bool CreateSmoothTriangle( int nIndex, int nVertNum, AppliedVector TriVert[], bool bWasSharp, SmoothTriaStruct& VoxSmoothTria) const ;
bool FlipEdgesII( int nBlock) const ;
bool FlipEdgesBB() const ;
bool FlipEdgesBB( void) const ;
bool IsThereMat( int nI, int nJ, int nK) const ;
int CalcIndex( int nI, int nJ, int nK) const ;
bool IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, AppliedVector& vfField) const ;
@@ -331,6 +332,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool IsVoxelOnBoxEdge( int i, int j, int k) const ;
bool CheckForFanNodeInterferance( AppliedVector CompVecField[], Point3d& ptFanVert,
int nBasePointNum, int nVoxConfig, int nVoxI, int nVoxJ, int nVoxK) const ;
bool CalcBlockNum( void) ;
bool IsTriangleOnBorder( const Triangle3dEx& trTria, const int nBlockLimits[], const int nVoxIJK[]) const ;
// Funzioni per facce canoniche con grandi triangoli
bool ProcessVoxContXY( FlatVoxelContainer& VoxContXY, int nBlock, bool bPlus) const ;
@@ -359,7 +361,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
enum Shape { GENERIC = 0, BOX = 1, EXTRUSION = 2} ;
static const int N_MAPS = 3 ;
static const int N_VOXBLOCK = 32 ;
static const int N_DEXVOXRATIO = 1 ;
private :
ObjGraphicsMgr m_OGrMgr ; // gestore grafica dell'oggetto
@@ -388,6 +389,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
int m_nShape ; // Forma : 0 generica, 1 box, 2 estrusione
int m_nVoxNumPerBlock ; // Numero di voxel per blocco
int m_nDexVoxRatio ; // Rapporto dexel voxel
int m_nFracLin[3] ; // Numero di blocchi per ogni asse
int m_nNumBlock ; // Numero totale di blocchi
VolZmapCreation.cpp
+18 -103
View File
@@ -46,16 +46,8 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
m_MapFrame.Set( ptO, X_AX, Y_AX, Z_AX) ;
// Definisco i vettori dei limiti su indici
m_nNx[0] = int( ( dLengthX + EPS_SMALL) / m_dStep + 0.5) ;
m_nNy[0] = int( ( dLengthY + EPS_SMALL) / m_dStep + 0.5) ;
// Calcolo il numero di voxel lungo X e Y
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) ;
// Definisco il numero di blocchi lungo x e y
m_nFracLin[0] = max( 1, int( nVoxNumX * 1.0 / m_nVoxNumPerBlock + 0.7)) ;
m_nFracLin[1] = max( 1, int( nVoxNumY * 1.0 / m_nVoxNumPerBlock + 0.7)) ;
m_nNx[0] = max( int( ( dLengthX + EPS_SMALL) / m_dStep + 0.5), 1) ;
m_nNy[0] = max( int( ( dLengthY + EPS_SMALL) / m_dStep + 0.5), 1) ;
// Numero di componenti connesse
m_nConnectedCompoCount = 1 ;
@@ -63,13 +55,9 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
// Se tridexel
if ( bTriDex) {
m_nNx[1] = m_nNy[0] ;
m_nNy[1] = int( ( dLengthZ + EPS_SMALL) / m_dStep + 0.5) ;
m_nNy[1] = max( int( ( dLengthZ + EPS_SMALL) / m_dStep + 0.5), 1) ;
m_nNx[2] = m_nNy[1] ;
m_nNy[2] = m_nNx[0] ;
// Calcolo il numero di voxel lungo Z
int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
// Definisco il numero di blocchi lungo z
m_nFracLin[2] = max( 1, int( nVoxNumZ * 1.0 / m_nVoxNumPerBlock + 0.7)) ;
}
// altrimenti mono dexel
@@ -78,10 +66,12 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
m_nNy[1] = 0 ;
m_nNx[2] = 0 ;
m_nNy[2] = 0 ;
// Definisco il numero di blocchi lungo z
m_nFracLin[2] = 1 ;
}
// Definisco il numero di blocchi lungo x,y e z
if ( ! CalcBlockNum())
return false ;
// Definizione della mappa
// Creazione delle mappe
@@ -133,28 +123,9 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
m_dMinZ[2] = 0 ;
m_dMaxZ[2] = ( bTriDex ? dLengthY : 0) ;
// Dimensiono e setto il vettore dei blocchi a da ricalcolare e il vettore di contatori di aggiornamenti della grafica
m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
m_BlockToUpdate.clear() ;
m_BlockToUpdate.resize( m_nNumBlock, true) ;
m_BlockUpdatingCounter.clear() ;
m_BlockUpdatingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ;
// Tipologia
// Tipologia
m_nShape = BOX ;
// 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_InterBlockSharpTria.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) ;
// Aggiornamento dello stato
m_nStatus = OK ;
@@ -195,14 +166,6 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
// Ridimensiono il vettore di dexel e creo lo Zmap
m_Values[0].resize( m_nDim[0]) ;
// Calcolo il numero di voxel lungo X e Y
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) ;
// Definisco il numero di blocchi lungo x e y
m_nFracLin[0] = max( 1, int( nVoxNumX * 1.0 / m_nVoxNumPerBlock + 0.7)) ;
m_nFracLin[1] = max( 1, int( nVoxNumY * 1.0 / m_nVoxNumPerBlock + 0.7)) ;
// Numero di componenti connesse
m_nConnectedCompoCount = Surf.GetChunkCount() ;
@@ -216,10 +179,6 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
m_nNy[2] = m_nNx[0] ;
m_nDim[2] = m_nNx[2] * m_nNy[2] ;
m_Values[2].resize( m_nDim[2]) ;
// Calcolo il numero di voxel lungo Z
int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
// Definisco il numero di blocchi lungo z
m_nFracLin[2] = max( 1, int( nVoxNumZ * 1.0 / m_nVoxNumPerBlock + 0.7)) ;
}
else {
@@ -229,10 +188,12 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
m_nNx[2] = 0 ;
m_nNy[2] = 0 ;
m_nDim[2] = 0 ;
// Definisco il numero di blocchi lungo z
m_nFracLin[2] = 1 ;
}
// Definisco il numero di blocchi lungo x,y e z
if ( ! CalcBlockNum())
return false ;
// Metto in cache le curve di contorno della regione
ICURVEPOVECTOR vpCrvs ;
INTVECTOR vnCompo ;
@@ -447,25 +408,6 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
m_dMinZ[2] = 0 ;
m_dMaxZ[2] = ( bTriDex ? dLengthY : 0) ;
// Dimensiono e setto il vettore dei blocchi a da ricalcolare e il vettore di contatori di aggiornamenti della grafica
m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
m_BlockToUpdate.clear() ;
m_BlockToUpdate.resize( m_nNumBlock, true) ;
m_BlockUpdatingCounter.clear() ;
m_BlockUpdatingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ;
// 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_InterBlockSharpTria.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) ;
// Tipologia
m_nShape = ( IsBox() ? BOX : EXTRUSION) ;
@@ -515,13 +457,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
m_nDim[0] = m_nNx[0] * m_nNy[0] ;
// Ridimensiono il vettore di dexel e creo lo Zmap
m_Values[0].resize( m_nDim[0]) ;
// Calcolo il numero di voxel lungo X e Y
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) ;
// Definisco il numero di blocchi lungo x e y
m_nFracLin[0] = max( 1, int( nVoxNumX * 1.0 / m_nVoxNumPerBlock + 0.7)) ;
m_nFracLin[1] = max( 1, int( nVoxNumY * 1.0 / m_nVoxNumPerBlock + 0.7)) ;
// Numero di componenti connesse da calcolare
m_nConnectedCompoCount = - 1 ;
@@ -535,10 +471,6 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
m_nNy[2] = m_nNx[0] ;
m_nDim[2] = m_nNx[2] * m_nNy[2] ;
m_Values[2].resize( m_nDim[2]) ;
// Calcolo il numero di voxel lungo Z
int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
// Definisco il numero di blocchi lungo z
m_nFracLin[2] = max( 1, int( nVoxNumZ * 1.0 / m_nVoxNumPerBlock + 0.7)) ;
}
else {
@@ -548,10 +480,12 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
m_nNx[2] = 0 ;
m_nNy[2] = 0 ;
m_nDim[2] = 0 ;
// Definisco il numero di blocchi lungo z
m_nFracLin[2] = 1 ;
}
// Definisco il numero di blocchi lungo x,y e z
if ( ! CalcBlockNum())
return false ;
// ciclo sulle griglie
for ( int g = 0 ; g < m_nMapNum ; ++ g) {
@@ -667,25 +601,6 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
m_dMinZ[2] = 0 ;
m_dMaxZ[2] = ( bTriDex ? vtLen.y : 0) ;
// Dimensiono e setto il vettore dei blocchi a da ricalcolare e il vettore di contatori di aggiornamenti della grafica
m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
m_BlockToUpdate.clear() ;
m_BlockToUpdate.resize( m_nNumBlock, true) ;
m_BlockUpdatingCounter.clear() ;
m_BlockUpdatingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ;
// 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_InterBlockSharpTria.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) ;
// Tipologia
m_nShape = ( IsBox() ? BOX : GENERIC) ;
VolZmapGraphics.cpp
+177 -176
View File
@@ -327,8 +327,8 @@ VolZmap::FindAdjComp( const vector<VoxelContainer>& vVecVox, int nCurBlock, int
int nCurIJK[3] ;
GetVoxIJKFromN( nCurVox, nCurIJK[0], nCurIJK[1], nCurIJK[2]) ;
bool bInnerVox = ! IsAVoxelOnBoundary( nLimits, nCurIJK, true) ;
Voxel CurVox = bInnerVox ? ( * vVecVox[nCurBlock].find( nCurVox)).second :
( * m_InterBlockVox[nCurBlock].find( nCurVox)).second ;
Voxel CurVox = ( bInnerVox ? ( *vVecVox[nCurBlock].find( nCurVox)).second :
( *m_InterBlockVox[nCurBlock].find( nCurVox)).second) ;
// Ciclo su tutti i voxel adiacenti
for ( int nI = - 1 ; nI <= 1 ; ++ nI) {
for ( int nJ = - 1 ; nJ <= 1 ; ++ nJ) {
@@ -625,14 +625,14 @@ VolZmap::UpdateSingleMapGraphics( void) const
int nJBlock = int( t) / int( m_nFracLin[0]) ;
// Calcolo limiti per l'indice i
int nStartI = nIBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ;
int nStartI = nIBlock * int( m_nVoxNumPerBlock) * m_nDexVoxRatio ;
int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ?
int( m_nNx[0]) : ( nIBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ;
int( m_nNx[0]) : ( nIBlock + 1) * int( m_nVoxNumPerBlock)) * m_nDexVoxRatio ;
// Calcolo limiti per l'indice j
int nStartJ = nJBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ;
int nStartJ = nJBlock * int( m_nVoxNumPerBlock) * m_nDexVoxRatio ;
int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ?
int( m_nNy[0]) : ( nJBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ;
int( m_nNy[0]) : ( nJBlock + 1) * int( m_nVoxNumPerBlock)) * m_nDexVoxRatio ;
// Ciclo su i e j
for ( int i = nStartI ; i < nEndI ; i += MAX_DIM_CHUNK) {
@@ -1063,7 +1063,7 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
for ( int i = nLimits[0] ; i < nLimits[1] ; ++ i) {
for ( int j = nLimits[2] ; j < nLimits[3] ; ++ j) {
for ( int k = nLimits[4] ; k < nLimits[5] ; ++ k) {
if ( m_nShape == BOX && ! IsVoxelOnBoxEdge( i, j, k))
continue ;
// Classificazione dei vertici: interni o esterni al materiale
@@ -1364,7 +1364,7 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
}
}
bool bNewTopology = Config3Duality( nIndex) ? bMatOnSlice : ! bMatOnSlice ;
bool bNewTopology = ( bDefTopology ? ! bMatOnSlice : bMatOnSlice) ;
// Si passa alla seconda topologia
if ( bNewTopology) {
@@ -1541,7 +1541,7 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
m_SliceXY[nSlBlockN].emplace( nSliceN, bMatOnSlice) ;
}
}
bool bNewTopology = ( Config6Duality( nIndex) ? bMatOnSlice : ! bMatOnSlice) ;
bool bNewTopology = ( bDefTopology ? ! bMatOnSlice : bMatOnSlice) ;
// Si deve passare alla seconda topologia
if ( bNewTopology) {
// Ricerca del caso corrispondente della nuova topologia
@@ -1756,14 +1756,14 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
}
// Uso le informazioni per scegliere la topologia
int nFaceWithMatNum = 0 ;
if ( bMatOnSliceXZ)
if ( bMatOnSliceXZ && ! bDefSliceXZ)
++ nFaceWithMatNum ;
if ( bMatOnSliceYZ)
if ( bMatOnSliceYZ && ! bDefSliceYZ)
++ nFaceWithMatNum ;
if ( bMatOnSliceXY)
if ( bMatOnSliceXY && ! bDefSliceXY)
++ nFaceWithMatNum ;
if ( nFaceWithMatNum == 1) {
int nFaceCase = ( bMatOnSliceYZ ? 0 : (bMatOnSliceXZ ? 1 : 2)) ;
int nFaceCase = ( bMatOnSliceYZ ? 0 : ( bMatOnSliceXZ ? 1 : 2)) ;
// Aggiorno numero di componenti
nComponents = Cases7Plus[nCount][nFaceCase][1][0] ;
// Riaggiorno gli offsets
@@ -1900,7 +1900,7 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
}
}
}
bool bNewTopology = bMatOnSlice ;
bool bNewTopology = ( bDefStTopology ? ! bMatOnSlice : bMatOnSlice) ;
// Si passa alla seconda topologia
if ( bNewTopology) {
// Ricerca del caso corrispondente della nuova topologia
@@ -2044,12 +2044,12 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
}
}
if ( bOverTurning) {
Point3d ptMinDiag( ( i * N_DEXVOXRATIO + 0.5) * m_dStep,
( j * N_DEXVOXRATIO + 0.5) * m_dStep,
( k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptMaxDiag( ( ( i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptMinDiag( ( i * m_nDexVoxRatio + 0.5) * m_dStep,
( j * m_nDexVoxRatio + 0.5) * m_dStep,
( k * m_nDexVoxRatio + 0.5) * m_dStep) ;
Point3d ptMaxDiag( ( ( i + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( j + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( k + 1) * m_nDexVoxRatio + 0.5) * m_dStep) ;
double dNewU1, dNewU2 ;
if ( IntersLineBox( ptSol, vtNullSpace, ptMinDiag, ptMaxDiag, dNewU1, dNewU2)) {
if ( dNewU1 > 0.) {
@@ -2112,8 +2112,8 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
break ;
}
}
int nPrevL = nNotParIndex > 0 ? nNotParIndex - 1 : nVertComp[nComp] - 1 ;
int nNextL = nNotParIndex < nVertComp[nComp] - 1 ? nNotParIndex + 1 : 0 ;
int nPrevL = ( nNotParIndex > 0 ? nNotParIndex - 1 : nVertComp[nComp] - 1) ;
int nNextL = ( nNotParIndex < nVertComp[nComp] - 1 ? nNotParIndex + 1 : 0) ;
Vector3d vtPrevN = ( CompoVert[nComp][nNotParIndex].ptPApp - ptSol) ^ ( CompoVert[nComp][nPrevL].ptPApp - ptSol) ;
Vector3d vtNextN = ( CompoVert[nComp][nNextL].ptPApp - ptSol) ^ ( CompoVert[nComp][nNotParIndex].ptPApp - ptSol) ;
vtPrevN.Normalize() ;
@@ -2205,15 +2205,15 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
// Costruisco i triangoli paralleli al piano YZ
if ( nBlockIJK[0] == 0 || nBlockIJK[0] + 1 == m_nFracLin[0]) {
// Indici dei dexel corrispondenti al confine inferiore fra voxel piatti e feature
int nDexMinJ = ( nBlockIJK[1] == 0 ? N_DEXVOXRATIO * ( nFirstVoxJ + 1) :
N_DEXVOXRATIO * nBlockIJK[1] * m_nVoxNumPerBlock) ;
int nDexMinK = ( nBlockIJK[2] == 0 ? N_DEXVOXRATIO * ( nFirstVoxK + 1) :
N_DEXVOXRATIO * nBlockIJK[2] * m_nVoxNumPerBlock) ;
int nDexMinJ = ( nBlockIJK[1] == 0 ? m_nDexVoxRatio * ( nFirstVoxJ + 1) :
m_nDexVoxRatio * nBlockIJK[1] * m_nVoxNumPerBlock) ;
int nDexMinK = ( nBlockIJK[2] == 0 ? m_nDexVoxRatio * ( nFirstVoxK + 1) :
m_nDexVoxRatio * nBlockIJK[2] * m_nVoxNumPerBlock) ;
// Indici dei dexel corrispondenti al confine superiore fra voxel piatti e feature
int nDexMaxJ = ( nBlockIJK[1] + 1 < int( m_nFracLin[1]) ? N_DEXVOXRATIO * ( nBlockIJK[1] + 1) * m_nVoxNumPerBlock :
N_DEXVOXRATIO * nLastVoxJ) ;
int nDexMaxK = ( nBlockIJK[2] + 1 < int( m_nFracLin[2]) ? N_DEXVOXRATIO * ( nBlockIJK[2] + 1) * m_nVoxNumPerBlock :
N_DEXVOXRATIO * nLastVoxK) ;
int nDexMaxJ = ( nBlockIJK[1] + 1 < int( m_nFracLin[1]) ? m_nDexVoxRatio * ( nBlockIJK[1] + 1) * m_nVoxNumPerBlock :
m_nDexVoxRatio * nLastVoxJ) ;
int nDexMaxK = ( nBlockIJK[2] + 1 < int( m_nFracLin[2]) ? m_nDexVoxRatio * ( nBlockIJK[2] + 1) * m_nVoxNumPerBlock :
m_nDexVoxRatio * nLastVoxK) ;
// Determino coordinate minime e massime dei punti dei triangoli
double dYMin = ( nDexMinJ + 0.5) * m_dStep ;
double dZMin = ( nDexMinK + 0.5) * m_dStep ;
@@ -2244,15 +2244,15 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
// Costruisco i triangoli paralleli al piano XZ
if ( nBlockIJK[1] == 0 || nBlockIJK[1] + 1 == m_nFracLin[1]) {
// Indici dei dexel corrispondenti al confine inferiore fra voxel piatti e feature
int nDexMinI = ( nBlockIJK[0] == 0 ? N_DEXVOXRATIO * ( nFirstVoxI + 1) :
N_DEXVOXRATIO * nBlockIJK[0] * m_nVoxNumPerBlock) ;
int nDexMinK = ( nBlockIJK[2] == 0 ? N_DEXVOXRATIO * ( nFirstVoxK + 1) :
N_DEXVOXRATIO * nBlockIJK[2] * m_nVoxNumPerBlock) ;
int nDexMinI = ( nBlockIJK[0] == 0 ? m_nDexVoxRatio * ( nFirstVoxI + 1) :
m_nDexVoxRatio * nBlockIJK[0] * m_nVoxNumPerBlock) ;
int nDexMinK = ( nBlockIJK[2] == 0 ? m_nDexVoxRatio * ( nFirstVoxK + 1) :
m_nDexVoxRatio * nBlockIJK[2] * m_nVoxNumPerBlock) ;
// Indici dei dexel corrispondenti al confine superiore fra voxel piatti e feature
int nDexMaxI = ( nBlockIJK[0] + 1 < int( m_nFracLin[0]) ? N_DEXVOXRATIO * ( nBlockIJK[0] + 1) * m_nVoxNumPerBlock :
N_DEXVOXRATIO * nLastVoxI) ;
int nDexMaxK = ( nBlockIJK[2] + 1 < int( m_nFracLin[2]) ? N_DEXVOXRATIO * ( nBlockIJK[2] + 1) * m_nVoxNumPerBlock :
N_DEXVOXRATIO * nLastVoxK) ;
int nDexMaxI = ( nBlockIJK[0] + 1 < int( m_nFracLin[0]) ? m_nDexVoxRatio * ( nBlockIJK[0] + 1) * m_nVoxNumPerBlock :
m_nDexVoxRatio * nLastVoxI) ;
int nDexMaxK = ( nBlockIJK[2] + 1 < int( m_nFracLin[2]) ? m_nDexVoxRatio * ( nBlockIJK[2] + 1) * m_nVoxNumPerBlock :
m_nDexVoxRatio * nLastVoxK) ;
// Determino coordinate minime e massime dei punti dei triangoli
double dXMin = ( nDexMinI + 0.5) * m_dStep ;
double dZMin = ( nDexMinK + 0.5) * m_dStep ;
@@ -2283,15 +2283,15 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
// Costruisco i triangoli paralleli al piano XY
if ( nBlockIJK[2] == 0 || nBlockIJK[2] + 1 == m_nFracLin[2]) {
// Indici dei dexel corrispondenti al confine inferiore fra voxel piatti e feature
int nDexMinI = ( nBlockIJK[0] == 0 ? N_DEXVOXRATIO * ( nFirstVoxI + 1) :
N_DEXVOXRATIO * nBlockIJK[0] * m_nVoxNumPerBlock) ;
int nDexMinJ = ( nBlockIJK[1] == 0 ? N_DEXVOXRATIO * ( nFirstVoxJ + 1) :
N_DEXVOXRATIO * nBlockIJK[1] * m_nVoxNumPerBlock) ;
int nDexMinI = ( nBlockIJK[0] == 0 ? m_nDexVoxRatio * ( nFirstVoxI + 1) :
m_nDexVoxRatio * nBlockIJK[0] * m_nVoxNumPerBlock) ;
int nDexMinJ = ( nBlockIJK[1] == 0 ? m_nDexVoxRatio * ( nFirstVoxJ + 1) :
m_nDexVoxRatio * nBlockIJK[1] * m_nVoxNumPerBlock) ;
// Indici dei dexel corrispondenti al confine superiore fra voxel piatti e feature
int nDexMaxI = ( nBlockIJK[0] + 1 < int( m_nFracLin[0]) ? N_DEXVOXRATIO * ( nBlockIJK[0] + 1) * m_nVoxNumPerBlock :
N_DEXVOXRATIO * nLastVoxI) ;
int nDexMaxJ = ( nBlockIJK[1] + 1 < int( m_nFracLin[1]) ? N_DEXVOXRATIO * ( nBlockIJK[1] + 1) * m_nVoxNumPerBlock :
N_DEXVOXRATIO * nLastVoxJ) ;
int nDexMaxI = ( nBlockIJK[0] + 1 < int( m_nFracLin[0]) ? m_nDexVoxRatio * ( nBlockIJK[0] + 1) * m_nVoxNumPerBlock :
m_nDexVoxRatio * nLastVoxI) ;
int nDexMaxJ = ( nBlockIJK[1] + 1 < int( m_nFracLin[1]) ? m_nDexVoxRatio * ( nBlockIJK[1] + 1) * m_nVoxNumPerBlock :
m_nDexVoxRatio * nLastVoxJ) ;
// Determino coordinate minime e massime dei punti dei triangoli
double dXMin = ( nDexMinI + 0.5) * m_dStep ;
double dYMin = ( nDexMinJ + 0.5) * m_dStep ;
@@ -2362,8 +2362,8 @@ VolZmap::RegulateFeaturesChain( vector<VoxelContainer>& vVecVox) const
int nBorSizeF = int( vBordNearFirst.size()) ;
for ( int nF = 0 ; nF < nInnSizeF + nBorSizeF ; nF += 3) {
// Indice e vettore corrente dei primi vicini
int nFCur = nF < nInnSizeF ? nF : nF - nInnSizeF ;
INTVECTOR vVecNFCur = nF < nInnSizeF ? vNearFirst : vBordNearFirst ;
int nFCur = ( nF < nInnSizeF ? nF : nF - nInnSizeF) ;
INTVECTOR vVecNFCur = ( nF < nInnSizeF ? vNearFirst : vBordNearFirst) ;
// Cerco i secondi vicini
INTVECTOR vNearSecond, vBordNearSecond ;
FindAdjComp( vVecVox, vVecNFCur[nFCur], vVecNFCur[nFCur+1], vVecNFCur[nFCur+2],
@@ -2373,8 +2373,8 @@ VolZmap::RegulateFeaturesChain( vector<VoxelContainer>& vVecVox) const
int nBorSizeS = int( vBordNearSecond.size()) ;
for ( int nS = 0 ; nS < nInnSizeS + nBorSizeS ; nS += 3) {
// Indice e vettore corrente dei secondi vicini
int nNSCur = nS < nInnSizeS ? nS : nS - nInnSizeS ;
INTVECTOR vVecNSCur = nS < nInnSizeS ? vNearSecond : vBordNearSecond ;
int nNSCur = ( nS < nInnSizeS ? nS : nS - nInnSizeS) ;
INTVECTOR vVecNSCur = ( nS < nInnSizeS ? vNearSecond : vBordNearSecond) ;
// Escludo dai secondi i primi vicini
bool bFirst = false ;
if ( vVecNSCur[nNSCur] == nBlock &&
@@ -2399,10 +2399,10 @@ VolZmap::RegulateFeaturesChain( vector<VoxelContainer>& vVecVox) const
if ( bFirst)
continue ;
// Se necessario regolarizzo la catena
Voxel& VoxNearFirst = nF < nInnSizeF ? vVecVox[vVecNFCur[nFCur]].find( vVecNFCur[nFCur+1])->second :
m_InterBlockVox[vVecNFCur[nFCur]].find( vVecNFCur[nFCur+1])->second ;
Voxel& VoxNearSecond = nS < nInnSizeS ? vVecVox[vVecNSCur[nNSCur]].find( vVecNSCur[nNSCur+1])->second :
m_InterBlockVox[vVecNSCur[nNSCur]].find( vVecNSCur[nNSCur+1])->second ;
Voxel& VoxNearFirst = ( nF < nInnSizeF ? vVecVox[vVecNFCur[nFCur]].find( vVecNFCur[nFCur+1])->second :
m_InterBlockVox[vVecNFCur[nFCur]].find( vVecNFCur[nFCur+1])->second) ;
Voxel& VoxNearSecond = ( nS < nInnSizeS ? vVecVox[vVecNSCur[nNSCur]].find( vVecNSCur[nNSCur+1])->second :
m_InterBlockVox[vVecNSCur[nNSCur]].find( vVecNSCur[nNSCur+1])->second) ;
Point3d ptCurV = CurVox.Compo[nComp].ptVert ;
Point3d ptFirst = VoxNearFirst.Compo[vVecNFCur[nFCur+2]].ptVert ;
Point3d ptSecond = VoxNearSecond.Compo[vVecNSCur[nNSCur+2]].ptVert ;
@@ -2494,12 +2494,12 @@ VolZmap::RegulateFeaturesChain( vector<VoxelContainer>& vVecVox) const
//vtDLine = vtStCurr ;
ptNew = ptPSt + ( ptMid - ptPSt) * vtStCurr * vtStCurr ;
}
//Point3d ptCubeInf( ( CurVox.i * N_DEXVOXRATIO + 0.5) * m_dStep,
// ( CurVox.j * N_DEXVOXRATIO + 0.5) * m_dStep,
// ( CurVox.k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
//Point3d ptCubeSup( ( ( CurVox.i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
// ( ( CurVox.j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
// ( ( CurVox.k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
//Point3d ptCubeInf( ( CurVox.i * m_nDexVoxRatio + 0.5) * m_dStep,
// ( CurVox.j * m_nDexVoxRatio + 0.5) * m_dStep,
// ( CurVox.k * m_nDexVoxRatio + 0.5) * m_dStep) ;
//Point3d ptCubeSup( ( ( CurVox.i + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
// ( ( CurVox.j + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
// ( ( CurVox.k + 1) * m_nDexVoxRatio + 0.5) * m_dStep) ;
//double dU1, dU2 ;
//if ( 1 - abs( vtStCurr * vtCurrEn ) < EPS_ZERO &&
// IntersLineBox( ptPLine, vtDLine, ptCubeInf, ptCubeSup, dU1, dU2)) {
@@ -2585,16 +2585,16 @@ VolZmap::RegulateFeaturesChain( vector<VoxelContainer>& vVecVox) const
vtDLine = vtStCurr ;
ptNew = ptPSt + ( ptMid - ptPSt) * vtStCurr * vtStCurr ;
}
Point3d ptCubeInf( ( CurVox.i * N_DEXVOXRATIO + 0.5) * m_dStep,
( CurVox.j * N_DEXVOXRATIO + 0.5) * m_dStep,
( CurVox.k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptCubeSup( ( ( CurVox.i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( CurVox.j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( CurVox.k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptCubeInf( ( CurVox.i * m_nDexVoxRatio + 0.5) * m_dStep,
( CurVox.j * m_nDexVoxRatio + 0.5) * m_dStep,
( CurVox.k * m_nDexVoxRatio + 0.5) * m_dStep) ;
Point3d ptCubeSup( ( ( CurVox.i + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( CurVox.j + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( CurVox.k + 1) * m_nDexVoxRatio + 0.5) * m_dStep) ;
double dU1, dU2 ;
if ( 1 - abs( vtStCurr * vtCurrEn ) < EPS_ZERO &&
IntersLineBox( ptPLine, vtDLine, ptCubeInf, ptCubeSup, dU1, dU2)) {
double dU = abs( dU1) < abs( dU2) ? dU1 + ( dU2 - dU1) / 2 : dU2 + ( dU1 - dU2) / 2 ;
double dU = ( dU1 + dU2) / 2 ;
ptNew = ptPLine + dU * vtDLine ;
}
bool bNewInside = IsPointInsideVoxelApprox( CurVox.i, CurVox.j, CurVox.k, ptNew, 0) ;
@@ -3172,7 +3172,7 @@ VolZmap::FlipEdgesII( int nBlock) const
//----------------------------------------------------------------------------
bool
VolZmap::FlipEdgesBB() const
VolZmap::FlipEdgesBB( void) const
{
// Numero di blocchi
int nBlocksNum = int( m_InterBlockSharpTria.size()) ;
@@ -3367,9 +3367,9 @@ bool
VolZmap::IsThereMat( int nI, int nJ, int nK) const
{
// Trasformo gli indici della griglia voxel in quelli della griglia dexel
nI *= N_DEXVOXRATIO ;
nJ *= N_DEXVOXRATIO ;
nK *= N_DEXVOXRATIO ;
nI *= m_nDexVoxRatio ;
nJ *= m_nDexVoxRatio ;
nK *= m_nDexVoxRatio ;
// Se l'indice è alla frontiera del reticolo non vi è materiale
if ( nI <= - 1 || nI >= int( m_nNx[0]) ||
@@ -3487,16 +3487,16 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, AppliedVector&
if ( nVec1[0] != nVec2[0]) {
int nMinI = min( nVec1[0], nVec2[0]) * N_DEXVOXRATIO ;
int nMaxI = max( nVec1[0], nVec2[0]) * N_DEXVOXRATIO ;
int nMinI = min( nVec1[0], nVec2[0]) * m_nDexVoxRatio ;
int nMaxI = max( nVec1[0], nVec2[0]) * m_nDexVoxRatio ;
double dMinX = ( nMinI + 0.5) * m_dStep ;
double dMaxX = ( nMaxI + 0.5) * m_dStep ;
vfField.ptPApp.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ;
vfField.ptPApp.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ;
vfField.ptPApp.y = ( nVec1[1] * m_nDexVoxRatio + 0.5) * m_dStep ;
vfField.ptPApp.z = ( nVec1[2] * m_nDexVoxRatio + 0.5) * m_dStep ;
int nDexel = ( nVec1[2] * m_nNx[1] + nVec1[1]) * N_DEXVOXRATIO ;
int nDexel = ( nVec1[2] * m_nNx[1] + nVec1[1]) * m_nDexVoxRatio ;
int nSize = int( m_Values[1][nDexel].size()) ;
if ( bFirstCorner) {
@@ -3539,16 +3539,16 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, AppliedVector&
else if ( nVec1[1] != nVec2[1]) {
int nMinJ = min( nVec1[1], nVec2[1]) * N_DEXVOXRATIO ;
int nMaxJ = max( nVec1[1], nVec2[1]) * N_DEXVOXRATIO ;
int nMinJ = min( nVec1[1], nVec2[1]) * m_nDexVoxRatio ;
int nMaxJ = max( nVec1[1], nVec2[1]) * m_nDexVoxRatio ;
double dMinY = ( nMinJ + 0.5) * m_dStep ;
double dMaxY = ( nMaxJ + 0.5) * m_dStep ;
vfField.ptPApp.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ;
vfField.ptPApp.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ;
vfField.ptPApp.x = ( nVec1[0] * m_nDexVoxRatio + 0.5) * m_dStep ;
vfField.ptPApp.z = ( nVec1[2] * m_nDexVoxRatio + 0.5) * m_dStep ;
int nDexel = ( nVec1[0] * m_nNx[2] + nVec1[2]) * N_DEXVOXRATIO ;
int nDexel = ( nVec1[0] * m_nNx[2] + nVec1[2]) * m_nDexVoxRatio ;
int nSize = int( m_Values[2][nDexel].size()) ;
if ( bFirstCorner) {
@@ -3591,16 +3591,16 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, AppliedVector&
else if ( nVec1[2] != nVec2[2]) {
int nMinK = min( nVec1[2], nVec2[2]) * N_DEXVOXRATIO ;
int nMaxK = max( nVec1[2], nVec2[2]) * N_DEXVOXRATIO ;
int nMinK = min( nVec1[2], nVec2[2]) * m_nDexVoxRatio ;
int nMaxK = max( nVec1[2], nVec2[2]) * m_nDexVoxRatio ;
double dMinZ = ( nMinK + 0.5) * m_dStep ;
double dMaxZ = ( nMaxK + 0.5) * m_dStep ;
vfField.ptPApp.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ;
vfField.ptPApp.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ;
vfField.ptPApp.x = ( nVec1[0] * m_nDexVoxRatio + 0.5) * m_dStep ;
vfField.ptPApp.y = ( nVec1[1] * m_nDexVoxRatio + 0.5) * m_dStep ;
int nDexel = ( nVec1[1] * m_nNx[0] + nVec1[0]) * N_DEXVOXRATIO ;
int nDexel = ( nVec1[1] * m_nNx[0] + nVec1[0]) * m_nDexVoxRatio ;
int nSize = int( m_Values[0][nDexel].size()) ;
if ( bFirstCorner) {
@@ -3649,9 +3649,9 @@ bool
VolZmap::IsValidVoxel( int nN) const
{
// Calcolo il numero di voxel lungo X,Y e Z
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) ;
int nVoxNumX = m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2) ;
int nVoxNumY = m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2) ;
int nVoxNumZ = m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2) ;
// Verifico la validità del voxel
return ( nN >= 0 && nN < ( nVoxNumX * nVoxNumY * nVoxNumZ)) ;
}
@@ -3661,9 +3661,9 @@ bool
VolZmap::IsValidVoxel( int nI, int nJ, int nK) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Verifico la validità del voxel
return ( nI >= -1 && nI <= nVoxNumX - 2 &&
nJ >= -1 && nJ <= nVoxNumY - 2 &&
@@ -3675,9 +3675,9 @@ bool
VolZmap::GetVoxIJKFromN( int nN, int& nI, int& nJ, int& nK) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Controllo sulla validità del voxel
if ( nN < 0 || nN >= nVoxNumX * nVoxNumY * nVoxNumZ)
@@ -3699,9 +3699,9 @@ bool
VolZmap::GetVoxNFromIJK( int nI, int nJ, int nK, int& nN) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Controllo la validità del voxel
if ( nI < -1 || nI > nVoxNumX - 2 ||
@@ -3721,9 +3721,9 @@ bool
VolZmap::GetVoxelBox( int nI, int nJ, int nK, BBox3d& b3VoxBox) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Controllo la validità del voxel
if ( nI < -1 || nI > nVoxNumX - 2 ||
@@ -3732,12 +3732,12 @@ VolZmap::GetVoxelBox( int nI, int nJ, int nK, BBox3d& b3VoxBox) const
return false ;
// Punti della diagonale del voxel
Point3d ptCubeInf( ( nI * N_DEXVOXRATIO + 0.5) * m_dStep,
( nJ * N_DEXVOXRATIO + 0.5) * m_dStep,
( nK * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptCubeSup( ( ( nI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptCubeInf( ( nI * m_nDexVoxRatio + 0.5) * m_dStep,
( nJ * m_nDexVoxRatio + 0.5) * m_dStep,
( nK * m_nDexVoxRatio + 0.5) * m_dStep) ;
Point3d ptCubeSup( ( ( nI + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( nJ + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( nK + 1) * m_nDexVoxRatio + 0.5) * m_dStep) ;
b3VoxBox.Set( ptCubeInf, ptCubeSup) ;
return true ;
}
@@ -3785,9 +3785,9 @@ VolZmap::GetBlockLimitsIJK( const int nIJK[], int nLimits[]) const
return false ;
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Calcolo limiti per l'indice i
nLimits[0] = ( nIJK[0] == 0 ? - 1 : nIJK[0] * m_nVoxNumPerBlock) ;
@@ -3816,12 +3816,12 @@ VolZmap::GetBlockBox( const int nIJK[], BBox3d& b3VoxBox) const
if ( ! GetBlockLimitsIJK( nIJK, nLimits))
return false ;
// Costruisco il bounding-bx del blocco
Point3d ptMinDiag( ( nLimits[0] * N_DEXVOXRATIO + 0.5) * m_dStep,
( nLimits[2] * N_DEXVOXRATIO + 0.5) * m_dStep,
( nLimits[4] * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptMaxDiag( ( nLimits[1] * N_DEXVOXRATIO + 0.5) * m_dStep,
( nLimits[3] * N_DEXVOXRATIO + 0.5) * m_dStep,
( nLimits[5] * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptMinDiag( ( nLimits[0] * m_nDexVoxRatio + 0.5) * m_dStep,
( nLimits[2] * m_nDexVoxRatio + 0.5) * m_dStep,
( nLimits[4] * m_nDexVoxRatio + 0.5) * m_dStep) ;
Point3d ptMaxDiag( ( nLimits[1] * m_nDexVoxRatio + 0.5) * m_dStep,
( nLimits[3] * m_nDexVoxRatio + 0.5) * m_dStep,
( nLimits[5] * m_nDexVoxRatio + 0.5) * m_dStep) ;
b3VoxBox.Set( ptMinDiag, ptMaxDiag) ;
return true ;
}
@@ -3831,9 +3831,9 @@ bool
VolZmap::IsPointInsideVoxelApprox( int nI, int nJ, int nK, const Point3d& ptP, double dPrec) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Controllo sulla validità del voxel
if ( nI < -1 || nI > nVoxNumX - 2 ||
nJ < -1 || nJ > nVoxNumY - 2 ||
@@ -3843,12 +3843,12 @@ VolZmap::IsPointInsideVoxelApprox( int nI, int nJ, int nK, const Point3d& ptP, d
if ( dPrec < EPS_ZERO)
dPrec = 0 ;
// Controllo che ogni coordinata stia dentro le relative limitazioni del voxel
bool bI = ptP.x > ( nI * N_DEXVOXRATIO + 0.5) * m_dStep - dPrec &&
ptP.x < ( ( nI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep + dPrec ;
bool bJ = ptP.y > ( nJ * N_DEXVOXRATIO + 0.5) * m_dStep - dPrec &&
ptP.y < ( ( nJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep + dPrec ;
bool bK = ptP.z > ( nK * N_DEXVOXRATIO + 0.5) * m_dStep - dPrec &&
ptP.z < ( ( nK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep + dPrec ;
bool bI = ptP.x > ( nI * m_nDexVoxRatio + 0.5) * m_dStep - dPrec &&
ptP.x < ( ( nI + 1) * m_nDexVoxRatio + 0.5) * m_dStep + dPrec ;
bool bJ = ptP.y > ( nJ * m_nDexVoxRatio + 0.5) * m_dStep - dPrec &&
ptP.y < ( ( nJ + 1) * m_nDexVoxRatio + 0.5) * m_dStep + dPrec ;
bool bK = ptP.z > ( nK * m_nDexVoxRatio + 0.5) * m_dStep - dPrec &&
ptP.z < ( ( nK + 1) * m_nDexVoxRatio + 0.5) * m_dStep + dPrec ;
return ( bI && bJ && bK) ;
}
@@ -3858,13 +3858,13 @@ bool
VolZmap::GetPointVoxel( const Point3d& ptP, int& nVoxI, int& nVoxJ, int& nVoxK) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Calcolo gli indici del voxel
nVoxI = int( floor( ( ptP.x - 0.5 * m_dStep) / ( m_dStep * N_DEXVOXRATIO))) ;
nVoxJ = int( floor( ( ptP.y - 0.5 * m_dStep) / ( m_dStep * N_DEXVOXRATIO))) ;
nVoxK = int( floor( ( ptP.z - 0.5 * m_dStep) / ( m_dStep * N_DEXVOXRATIO))) ;
nVoxI = int( floor( ( ptP.x - 0.5 * m_dStep) / ( m_dStep * m_nDexVoxRatio))) ;
nVoxJ = int( floor( ( ptP.y - 0.5 * m_dStep) / ( m_dStep * m_nDexVoxRatio))) ;
nVoxK = int( floor( ( ptP.z - 0.5 * m_dStep) / ( m_dStep * m_nDexVoxRatio))) ;
// Controllo la validità del voxel
return ( nVoxI >= - 1 && nVoxI <= nVoxNumX - 2 &&
nVoxJ >= - 1 && nVoxJ <= nVoxNumY - 2 &&
@@ -3876,9 +3876,9 @@ bool
VolZmap::GetVoxelBlockIJK( const int nVoxIJK[], int nBlockIJK[]) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Controllo sull'ammissibilità del voxel
if ( nVoxIJK[0] < -1 || nVoxIJK[0] > nVoxNumX - 2 ||
nVoxIJK[1] < -1 || nVoxIJK[1] > nVoxNumY - 2 ||
@@ -3932,9 +3932,9 @@ bool
VolZmap::IsAVoxelOnBoundary( const int nLimits[], const int nIJK[], bool bType) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Test sulla validità dei limiti
if ( nLimits[0] < -1 || nLimits[0] > nVoxNumX - 1 ||
@@ -3999,9 +3999,9 @@ bool
VolZmap::IsAVoxelOnBoundary( const int nLimits[], const int nIJK[], int nDeltaIndex[]) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
// Test sulla validità dei limiti
if ( nLimits[0] < -1 || nLimits[0] > nVoxNumX - 1 ||
nLimits[1] < -1 || nLimits[1] > nVoxNumX - 1 ||
@@ -4068,10 +4068,11 @@ VolZmap::GetFirstVoxIJK( int& i, int& j, int& k) const
}
if ( bNotEmpty)
break ;
}
i = ni / N_DEXVOXRATIO - ( ni % N_DEXVOXRATIO) - 1 ;
j = nj / N_DEXVOXRATIO - ( nj % N_DEXVOXRATIO) - 1 ;
k = mj / N_DEXVOXRATIO - ( mj % N_DEXVOXRATIO) - 1 ;
}
i = ( ni % m_nDexVoxRatio != 0 ? (ni + m_nDexVoxRatio - 1) / m_nDexVoxRatio - 1 : ni / m_nDexVoxRatio - 1) ;
j = ( nj % m_nDexVoxRatio != 0 ? (nj + m_nDexVoxRatio - 1) / m_nDexVoxRatio - 1 : nj / m_nDexVoxRatio - 1) ;
k = ( mj % m_nDexVoxRatio != 0 ? (mj + m_nDexVoxRatio - 1) / m_nDexVoxRatio - 1 : mj / m_nDexVoxRatio - 1) ;
return true ;
}
@@ -4111,9 +4112,9 @@ VolZmap::GetLastVoxIJK( int& i, int& j, int& k) const
if ( bNotEmpty)
break ;
}
i = ni / N_DEXVOXRATIO ;
j = nj / N_DEXVOXRATIO ;
k = mj / N_DEXVOXRATIO ;
i = ni / m_nDexVoxRatio ;
j = nj / m_nDexVoxRatio ;
k = mj / m_nDexVoxRatio ;
return true ;
}
@@ -4155,13 +4156,13 @@ VolZmap::IsTriangleOnBorder( const Triangle3dEx& trTria, const int nBlockLimits[
// Verifico se tali punti sono sulla griglia
for ( int nC = 0 ; nC < 3 ; ++ nC) {
if ( nVoxIJK[nC] == nBlockLimits[2*nC]) {
double dGrid = ( nBlockLimits[2*nC] * N_DEXVOXRATIO + 0.5) * m_dStep ;
double dGrid = ( nBlockLimits[2*nC] * m_nDexVoxRatio + 0.5) * m_dStep ;
if ( abs( ptFirstGrPt.v[nC] - dGrid) < EPS_SMALL &&
abs( ptSecondGrPt.v[nC] - dGrid) < EPS_SMALL)
return true ;
}
if ( nVoxIJK[nC] + 1 == nBlockLimits[2*nC+1]) {
double dGrid = ( nBlockLimits[2*nC+1] * N_DEXVOXRATIO + 0.5) * m_dStep ;
double dGrid = ( nBlockLimits[2*nC+1] * m_nDexVoxRatio + 0.5) * m_dStep ;
if ( abs( ptFirstGrPt.v[nC] - dGrid) < EPS_SMALL &&
abs( ptSecondGrPt.v[nC] - dGrid) < EPS_SMALL)
return true ;
@@ -4190,9 +4191,9 @@ VolZmap::CheckForFanNodeInterferance( AppliedVector BaseVecField[], Point3d& ptF
++ nNodeJ ;
if ( n / 4 == 1)
++ nNodeK ;
Point3d ptNodeP( ( nNodeI * N_DEXVOXRATIO + 0.5) * m_dStep,
( nNodeJ * N_DEXVOXRATIO + 0.5) * m_dStep,
( nNodeK * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptNodeP( ( nNodeI * m_nDexVoxRatio + 0.5) * m_dStep,
( nNodeJ * m_nDexVoxRatio + 0.5) * m_dStep,
( nNodeK * m_nDexVoxRatio + 0.5) * m_dStep) ;
for ( int nV = 0 ; nV < nBasePointNum ; ++ nV) {
int nW = ( nV + 1) % nBasePointNum ;
Plane3d plPlane ;
@@ -4306,14 +4307,14 @@ VolZmap::ProcessVoxContXY( FlatVoxelContainer& VoxContXY, int nBlock, bool bPlus
}
}
Point3d ptT0( ( nMinI * N_DEXVOXRATIO + 0.5) * m_dStep,
( nMinJ * N_DEXVOXRATIO + 0.5) * m_dStep, dCordZ) ;
Point3d ptT1( ( ( nMaxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nMinJ * N_DEXVOXRATIO + 0.5) * m_dStep), dCordZ) ;
Point3d ptT2( ( ( nMaxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( ( nMaxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep), dCordZ) ;
Point3d ptT3( ( nMinI * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( ( nMaxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep), dCordZ) ;
Point3d ptT0( ( nMinI * m_nDexVoxRatio + 0.5) * m_dStep,
( nMinJ * m_nDexVoxRatio + 0.5) * m_dStep, dCordZ) ;
Point3d ptT1( ( ( nMaxI + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( nMinJ * m_nDexVoxRatio + 0.5) * m_dStep), dCordZ) ;
Point3d ptT2( ( ( nMaxI + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( ( nMaxJ + 1) * m_nDexVoxRatio + 0.5) * m_dStep), dCordZ) ;
Point3d ptT3( ( nMinI * m_nDexVoxRatio + 0.5) * m_dStep,
( ( ( nMaxJ + 1) * m_nDexVoxRatio + 0.5) * m_dStep), dCordZ) ;
ptT0.ToGlob( m_MapFrame) ;
ptT1.ToGlob( m_MapFrame) ;
@@ -4426,14 +4427,14 @@ VolZmap::ProcessVoxContYZ( FlatVoxelContainer& VoxContYZ, int nBlock, bool bPlus
}
}
Point3d ptT0( dCordX, ( nMinJ * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nMinK * N_DEXVOXRATIO + 0.5) * m_dStep)) ;
Point3d ptT1( dCordX, ( ( nMaxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nMinK * N_DEXVOXRATIO + 0.5) * m_dStep)) ;
Point3d ptT2( dCordX, ( ( nMaxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( ( nMaxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep)) ;
Point3d ptT3( dCordX, ( nMinJ * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( ( nMaxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep)) ;
Point3d ptT0( dCordX, ( nMinJ * m_nDexVoxRatio + 0.5) * m_dStep,
( ( nMinK * m_nDexVoxRatio + 0.5) * m_dStep)) ;
Point3d ptT1( dCordX, ( ( nMaxJ + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( nMinK * m_nDexVoxRatio + 0.5) * m_dStep)) ;
Point3d ptT2( dCordX, ( ( nMaxJ + 1) * m_nDexVoxRatio + 0.5) * m_dStep,
( ( ( nMaxK + 1) * m_nDexVoxRatio + 0.5) * m_dStep)) ;
Point3d ptT3( dCordX, ( nMinJ * m_nDexVoxRatio + 0.5) * m_dStep,
( ( ( nMaxK + 1) * m_nDexVoxRatio + 0.5) * m_dStep)) ;
ptT0.ToGlob( m_MapFrame) ;
ptT1.ToGlob( m_MapFrame) ;
@@ -4546,14 +4547,14 @@ VolZmap::ProcessVoxContXZ( FlatVoxelContainer& VoxContXZ, int nBlock, bool bPlus
}
}
Point3d ptT0( ( nMinI * N_DEXVOXRATIO + 0.5) * m_dStep, dCordY,
( ( nMinK * N_DEXVOXRATIO + 0.5) * m_dStep)) ;
Point3d ptT1( ( ( nMaxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, dCordY,
( ( nMinK * N_DEXVOXRATIO + 0.5) * m_dStep)) ;
Point3d ptT2( ( ( nMaxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, dCordY,
( ( ( nMaxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep)) ;
Point3d ptT3( ( nMinI * N_DEXVOXRATIO + 0.5) * m_dStep, dCordY,
( ( ( nMaxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep)) ;
Point3d ptT0( ( nMinI * m_nDexVoxRatio + 0.5) * m_dStep, dCordY,
( ( nMinK * m_nDexVoxRatio + 0.5) * m_dStep)) ;
Point3d ptT1( ( ( nMaxI + 1) * m_nDexVoxRatio + 0.5) * m_dStep, dCordY,
( ( nMinK * m_nDexVoxRatio + 0.5) * m_dStep)) ;
Point3d ptT2( ( ( nMaxI + 1) * m_nDexVoxRatio + 0.5) * m_dStep, dCordY,
( ( ( nMaxK + 1) * m_nDexVoxRatio + 0.5) * m_dStep)) ;
Point3d ptT3( ( nMinI * m_nDexVoxRatio + 0.5) * m_dStep, dCordY,
( ( ( nMaxK + 1) * m_nDexVoxRatio + 0.5) * m_dStep)) ;
ptT0.ToGlob( m_MapFrame) ;
ptT1.ToGlob( m_MapFrame) ;
VolZmapVolume.cpp
+11 -11
View File
@@ -136,8 +136,8 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
m_nConnectedCompoCount = - 1 ;
// Passo da indici di dexel a indici di voxel
nI /= N_DEXVOXRATIO ;
nJ /= N_DEXVOXRATIO ;
nI /= m_nDexVoxRatio ;
nJ /= m_nDexVoxRatio ;
// Determino quali blocchi sono stati modificati
if ( nGrid == 0) {
@@ -158,9 +158,9 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
++ nYStop ;
}
// Voxel lungo Z
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nMinK = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( N_DEXVOXRATIO * m_dStep) - EPS_SMALL))), 0, nVoxNumZ - 2) ;
int nMaxK = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( N_DEXVOXRATIO * m_dStep) + EPS_SMALL))), 0, nVoxNumZ - 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))) ;
int nMaxZBlock = min( int( m_nFracLin[2] - 1), nMaxK / int( m_nVoxNumPerBlock)) ;
// Assegno flag ai voxel
@@ -192,9 +192,9 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
++ nZStop ;
}
// Voxel lungo X
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nMinI = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( N_DEXVOXRATIO * m_dStep) - EPS_SMALL))), 0, nVoxNumX - 2) ;
int nMaxI = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( N_DEXVOXRATIO * m_dStep) + EPS_SMALL))), 0, nVoxNumX - 2) ;
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
@@ -226,9 +226,9 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
++ nZStop ;
}
// Voxel lungo Y
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nMinJ = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( N_DEXVOXRATIO * m_dStep) - EPS_SMALL))), 0, nVoxNumY - 2) ;
int nMaxJ = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( N_DEXVOXRATIO * m_dStep) + EPS_SMALL))), 0, nVoxNumY - 2) ;
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