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