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

EgtGeomKernel 1.8j5 :

Browse Source 
- modifiche a Zmap per moltiplicatore tra dexel e voxel.
This commit is contained in:
Dario Sassi
2017-10-30 08:43:06 +00:00
parent 2ecd82c61f
commit 1862e2dea1
7 changed files with 368 additions and 460 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolTriZmapGraphics.cpp
+247 -379
View File
@@ -302,14 +302,14 @@ VolZmap::GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DLISTVE
int nJBlock = int( t) / int( m_nFracLin[0]) ;
// Calcolo limiti per l'indice i
int nStartI = nIBlock * int( m_nDexNumPBlock) ;
int nStartI = nIBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ;
int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ?
int( m_nNx[0]) : ( nIBlock + 1) * int( m_nDexNumPBlock)) ;
int( m_nNx[0]) : ( nIBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ;
// Calcolo limiti per l'indice j
int nStartJ = nJBlock * int( m_nDexNumPBlock) ;
int nStartJ = nJBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ;
int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ?
int( m_nNy[0]) : ( nJBlock + 1) * int( m_nDexNumPBlock)) ;
int( m_nNy[0]) : ( nJBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ;
// Ciclo su i e j
for ( int i = nStartI ; i < nEndI ; i += MAX_DIM_CHUNK) {
@@ -337,7 +337,7 @@ VolZmap::GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DLISTVE
VecTriHold.resize( m_nNumBlock) ;
bool bCalcInterBlock = false ;
// Calcolo i triangoli sui blocchi
for ( size_t t = 0 ; t < m_nNumBlock ; ++ t) {
@@ -621,10 +621,15 @@ VolZmap::AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Poin
bool
VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriHolder& triHold, bool bEnh) 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)) ;
// Se il voxel non esiste, vi è un errore.
if ( nVoxI + 1 < 0 || nVoxI + 1 > int( m_nNx[0]) ||
nVoxJ + 1 < 0 || nVoxJ + 1 > int( m_nNy[0]) ||
nVoxK + 1 < 0 || nVoxK + 1 > int( m_nNy[1]))
if ( nVoxI + 1 < 0 || nVoxI + 2 > nVoxNumX ||
nVoxJ + 1 < 0 || nVoxJ + 2 > nVoxNumY ||
nVoxK + 1 < 0 || nVoxK + 2 > nVoxNumZ)
return false ;
// Classificazione dei vertici: interni o esterni al materiale
@@ -928,21 +933,21 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
}
if ( ( nIndArrey[nCompCount - 1][0] == 0 && nIndArrey[nCompCount - 1][1] == 2 &&
nIndArrey[nCompCount - 1][2] == 9 && nIndArrey[nCompCount - 1][3] == 10) ||
( nIndArrey[nCompCount - 1][0] == 4 && nIndArrey[nCompCount - 1][1] == 6 &&
nIndArrey[nCompCount - 1][2] == 9 && nIndArrey[nCompCount - 1][3] == 10) ||
( nIndArrey[nCompCount - 1][0] == 4 && nIndArrey[nCompCount - 1][1] == 6 &&
nIndArrey[nCompCount - 1][2] == 8 && nIndArrey[nCompCount - 1][3] == 11) ||
( nIndArrey[nCompCount - 1][0] == 0 && nIndArrey[nCompCount - 1][1] == 2 &&
nIndArrey[nCompCount - 1][2] == 8 && nIndArrey[nCompCount - 1][3] == 11) ||
( nIndArrey[nCompCount - 1][0] == 1 && nIndArrey[nCompCount - 1][1] == 3 &&
nIndArrey[nCompCount - 1][2] == 8 && nIndArrey[nCompCount - 1][3] == 9 ) ||
( nIndArrey[nCompCount - 1][0] == 1 && nIndArrey[nCompCount - 1][1] == 3 &&
nIndArrey[nCompCount - 1][2] == 10 && nIndArrey[nCompCount - 1][3] == 11) ||
( nIndArrey[nCompCount - 1][0] == 5 && nIndArrey[nCompCount - 1][1] == 7 &&
nIndArrey[nCompCount - 1][2] == 10 && nIndArrey[nCompCount - 1][3] == 11) ||
( nIndArrey[nCompCount - 1][0] == 5 && nIndArrey[nCompCount - 1][1] == 7 &&
nIndArrey[nCompCount - 1][2] == 8 && nIndArrey[nCompCount - 1][3] == 9 )) {
nIndArrey[nCompCount - 1][2] == 9 && nIndArrey[nCompCount - 1][3] == 10) ||
( nIndArrey[nCompCount - 1][0] == 4 && nIndArrey[nCompCount - 1][1] == 6 &&
nIndArrey[nCompCount - 1][2] == 9 && nIndArrey[nCompCount - 1][3] == 10) ||
( nIndArrey[nCompCount - 1][0] == 4 && nIndArrey[nCompCount - 1][1] == 6 &&
nIndArrey[nCompCount - 1][2] == 8 && nIndArrey[nCompCount - 1][3] == 11) ||
( nIndArrey[nCompCount - 1][0] == 0 && nIndArrey[nCompCount - 1][1] == 2 &&
nIndArrey[nCompCount - 1][2] == 8 && nIndArrey[nCompCount - 1][3] == 11) ||
( nIndArrey[nCompCount - 1][0] == 1 && nIndArrey[nCompCount - 1][1] == 3 &&
nIndArrey[nCompCount - 1][2] == 8 && nIndArrey[nCompCount - 1][3] == 9 ) ||
( nIndArrey[nCompCount - 1][0] == 1 && nIndArrey[nCompCount - 1][1] == 3 &&
nIndArrey[nCompCount - 1][2] == 10 && nIndArrey[nCompCount - 1][3] == 11) ||
( nIndArrey[nCompCount - 1][0] == 5 && nIndArrey[nCompCount - 1][1] == 7 &&
nIndArrey[nCompCount - 1][2] == 10 && nIndArrey[nCompCount - 1][3] == 11) ||
( nIndArrey[nCompCount - 1][0] == 5 && nIndArrey[nCompCount - 1][1] == 7 &&
nIndArrey[nCompCount - 1][2] == 8 && nIndArrey[nCompCount - 1][3] == 9 )) {
VectorField LocVecF[12], LocCompV[12] ;
@@ -959,12 +964,12 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
abs( LocVecF[nIndArrey[nCompCount - 1][2]].vtNorm * LocVecF[nIndArrey[nCompCount - 1][1]].vtNorm) < EPS_SMALL)) {
Point3d ptBarycenter = ( LocCompV[0].ptInt + LocCompV[1].ptInt +
LocCompV[2].ptInt + LocCompV[3].ptInt) / 4 ;
LocCompV[2].ptInt + LocCompV[3].ptInt) / 4 ;
if ( abs( LocCompV[0].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[1].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[2].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[3].ptInt.x - ptBarycenter.x) < EPS_SMALL) {
abs( LocCompV[1].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[2].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[3].ptInt.x - ptBarycenter.x) < EPS_SMALL) {
double dXBar = ptBarycenter.x / m_dStep - 0.5 ;
int nBarLimSup = int( m_nNx[0]) ;
@@ -983,9 +988,9 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
}
}
else if ( abs( LocCompV[0].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[1].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[2].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[3].ptInt.y - ptBarycenter.y) < EPS_SMALL) {
abs( LocCompV[1].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[2].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[3].ptInt.y - ptBarycenter.y) < EPS_SMALL) {
double dYBar = ptBarycenter.y / m_dStep - 0.5 ;
int nBarLimSup = int( m_nNy[0]) ;
@@ -1004,9 +1009,9 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
}
}
else if ( abs( LocCompV[0].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[1].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[2].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[3].ptInt.z - ptBarycenter.z) < EPS_SMALL) {
abs( LocCompV[1].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[2].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[3].ptInt.z - ptBarycenter.z) < EPS_SMALL) {
double dZBar = ptBarycenter.z / m_dStep - 0.5 ;
int nBarLimSup = int( m_nNy[1]) ;
@@ -1028,11 +1033,11 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
}
else if ( ( nIndArrey[nCompCount - 1][0] == 0 && nIndArrey[nCompCount - 1][1] == 1 &&
nIndArrey[nCompCount - 1][2] == 4 && nIndArrey[nCompCount - 1][3] == 5) ||
( nIndArrey[nCompCount - 1][0] == 1 && nIndArrey[nCompCount - 1][1] == 2 &&
( nIndArrey[nCompCount - 1][0] == 1 && nIndArrey[nCompCount - 1][1] == 2 &&
nIndArrey[nCompCount - 1][2] == 5 && nIndArrey[nCompCount - 1][3] == 6) ||
( nIndArrey[nCompCount - 1][0] == 2 && nIndArrey[nCompCount - 1][1] == 3 &&
( nIndArrey[nCompCount - 1][0] == 2 && nIndArrey[nCompCount - 1][1] == 3 &&
nIndArrey[nCompCount - 1][2] == 6 && nIndArrey[nCompCount - 1][3] == 7) ||
( nIndArrey[nCompCount - 1][0] == 0 && nIndArrey[nCompCount - 1][1] == 3 &&
( nIndArrey[nCompCount - 1][0] == 0 && nIndArrey[nCompCount - 1][1] == 3 &&
nIndArrey[nCompCount - 1][2] == 4 && nIndArrey[nCompCount - 1][3] == 7)) {
VectorField LocVecF[12], LocCompV[12] ;
@@ -1043,19 +1048,19 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
}
if ( ( AreSameVectorApprox( LocVecF[nIndArrey[nCompCount - 1][0]].vtNorm, LocVecF[nIndArrey[nCompCount - 1][2]].vtNorm) &&
abs( LocVecF[nIndArrey[nCompCount - 1][0]].vtNorm * LocVecF[nIndArrey[nCompCount - 1][1]].vtNorm) < EPS_SMALL &&
abs( LocVecF[nIndArrey[nCompCount - 1][0]].vtNorm * LocVecF[nIndArrey[nCompCount - 1][3]].vtNorm) < EPS_SMALL) ||
( AreSameVectorApprox( LocVecF[nIndArrey[nCompCount - 1][1]].vtNorm, LocVecF[nIndArrey[nCompCount - 1][3]].vtNorm) &&
abs( LocVecF[nIndArrey[nCompCount - 1][1]].vtNorm * LocVecF[nIndArrey[nCompCount - 1][0]].vtNorm) < EPS_SMALL &&
abs( LocVecF[nIndArrey[nCompCount - 1][1]].vtNorm * LocVecF[nIndArrey[nCompCount - 1][2]].vtNorm) < EPS_SMALL)) {
abs( LocVecF[nIndArrey[nCompCount - 1][0]].vtNorm * LocVecF[nIndArrey[nCompCount - 1][1]].vtNorm) < EPS_SMALL &&
abs( LocVecF[nIndArrey[nCompCount - 1][0]].vtNorm * LocVecF[nIndArrey[nCompCount - 1][3]].vtNorm) < EPS_SMALL) ||
( AreSameVectorApprox( LocVecF[nIndArrey[nCompCount - 1][1]].vtNorm, LocVecF[nIndArrey[nCompCount - 1][3]].vtNorm) &&
abs( LocVecF[nIndArrey[nCompCount - 1][1]].vtNorm * LocVecF[nIndArrey[nCompCount - 1][0]].vtNorm) < EPS_SMALL &&
abs( LocVecF[nIndArrey[nCompCount - 1][1]].vtNorm * LocVecF[nIndArrey[nCompCount - 1][2]].vtNorm) < EPS_SMALL)) {
Point3d ptBarycenter = ( LocCompV[0].ptInt + LocCompV[1].ptInt +
LocCompV[2].ptInt + LocCompV[3].ptInt) / 4 ;
LocCompV[2].ptInt + LocCompV[3].ptInt) / 4 ;
if ( abs( LocCompV[0].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[1].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[2].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[3].ptInt.x - ptBarycenter.x) < EPS_SMALL) {
abs( LocCompV[1].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[2].ptInt.x - ptBarycenter.x) < EPS_SMALL &&
abs( LocCompV[3].ptInt.x - ptBarycenter.x) < EPS_SMALL) {
double dXBar = ptBarycenter.x / m_dStep - 0.5 ;
int nBarLimSup = int( m_nNx[0]) ;
@@ -1074,9 +1079,9 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
}
}
else if ( abs( LocCompV[0].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[1].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[2].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[3].ptInt.y - ptBarycenter.y) < EPS_SMALL) {
abs( LocCompV[1].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[2].ptInt.y - ptBarycenter.y) < EPS_SMALL &&
abs( LocCompV[3].ptInt.y - ptBarycenter.y) < EPS_SMALL) {
double dYBar = ptBarycenter.y / m_dStep - 0.5 ;
int nBarLimSup = int( m_nNy[0]) ;
@@ -1095,9 +1100,9 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
}
}
else if ( abs( LocCompV[0].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[1].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[2].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[3].ptInt.z - ptBarycenter.z) < EPS_SMALL) {
abs( LocCompV[1].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[2].ptInt.z - ptBarycenter.z) < EPS_SMALL &&
abs( LocCompV[3].ptInt.z - ptBarycenter.z) < EPS_SMALL) {
double dZBar = ptBarycenter.z / m_dStep - 0.5 ;
int nBarLimSup = int( m_nNy[1]) ;
@@ -1175,7 +1180,7 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
// Limito la feature a una distanza dal baricentro pari alla diagonale del voxel
double dDistFeature = vtFeature.Len() ;
const double MAX_DIST = sqrt( 3) * m_dStep ;
const double MAX_DIST = sqrt( 3) * N_DEXVOXRATIO * m_dStep ;
bool bOutside = ( dDistFeature > MAX_DIST) ;
TRIA3DVECTOR triContainer ;
@@ -1252,8 +1257,10 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ;
double dParInt1, dParInt2 ;
Point3d ptVoxMin( ( nVoxI + 0.5) * m_dStep, ( nVoxJ + 0.5) * m_dStep, ( nVoxK + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( nVoxI + 1.5) * m_dStep, ( nVoxJ + 1.5) * m_dStep, ( nVoxK + 1.5) * m_dStep) ;
Point3d ptVoxMin( ( nVoxI * N_DEXVOXRATIO + 0.5) * m_dStep,
( nVoxJ * N_DEXVOXRATIO + 0.5) * m_dStep, ( nVoxK * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( ( nVoxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nVoxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, ( ( nVoxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// Caso in cui può essere riportata dentro: se il voxel in cui cade la feature è pieno
// la riporto muovendola lungo la sua linea
if ( IntersLineBox( ptSolZMapFrame, vtNullSpace, ptVoxMin, ptVoxMax, dParInt1, dParInt2)) {
@@ -1341,8 +1348,10 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ;
double dParInt1, dParInt2 ;
Point3d ptVoxMin( ( nVoxI + 0.5) * m_dStep, ( nVoxJ + 0.5) * m_dStep, ( nVoxK + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( nVoxI + 1.5) * m_dStep, ( nVoxJ + 1.5) * m_dStep, ( nVoxK + 1.5) * m_dStep) ;
Point3d ptVoxMin( ( nVoxI * N_DEXVOXRATIO + 0.5) * m_dStep,
( nVoxJ * N_DEXVOXRATIO + 0.5) * m_dStep, ( nVoxK * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( ( nVoxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nVoxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, ( ( nVoxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// Se è possibile riportarla dentro e il voxel in cui cade è pieno, la riporto nel suo voxel
// lungo la sua linea
@@ -1394,8 +1403,10 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ;
double dParInt1, dParInt2 ;
Point3d ptVoxMin( ( nVoxI + 0.5) * m_dStep, ( nVoxJ + 0.5) * m_dStep, ( nVoxK + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( nVoxI + 1.5) * m_dStep, ( nVoxJ + 1.5) * m_dStep, ( nVoxK + 1.5) * m_dStep) ;
Point3d ptVoxMin( ( nVoxI * N_DEXVOXRATIO + 0.5) * m_dStep,
( nVoxJ * N_DEXVOXRATIO + 0.5) * m_dStep, ( nVoxK * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( ( nVoxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nVoxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, ( ( nVoxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
if ( IntersLineBox( ptSolZMapFrame, vtNullSpace, ptVoxMin, ptVoxMax, dParInt1, dParInt2)) {
@@ -1474,10 +1485,10 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
}
// Media dei vettori coppia
Vector3d vtAv01 = 0.5 * ( CompoVert[nCompCount - 1][nCoupleIndex[0]].vtNorm +
CompoVert[nCompCount - 1][nCoupleIndex[1]].vtNorm) ;
CompoVert[nCompCount - 1][nCoupleIndex[1]].vtNorm) ;
// vettore nello spazio genenrato dai due non appartenenti alla coppia
Vector3d vtAv23 = 0.5 * ( CompoVert[nCompCount - 1][nCoupleIndex[2]].vtNorm +
CompoVert[nCompCount - 1][nCoupleIndex[3]].vtNorm) ;
CompoVert[nCompCount - 1][nCoupleIndex[3]].vtNorm) ;
vtAv01.Normalize() ;
vtAv23.Normalize() ;
@@ -1487,7 +1498,7 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
for ( int ni = 0 ; ni < 4 ; ++ ni) {
int nj = ni == 3 ? 0 : ni + 1 ;
if ( triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm < - 0.95 &&
triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm < - 0.95) {
triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm < - 0.95) {
bDangerInversion = true ;
break ;
}
@@ -1496,13 +1507,13 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
else {
double dD23 = CompoVert[nCompCount - 1][nCoupleIndex[2]].vtNorm *
CompoVert[nCompCount - 1][nCoupleIndex[3]].vtNorm ;
CompoVert[nCompCount - 1][nCoupleIndex[3]].vtNorm ;
if ( dD23 > 0.7 && dDAvAV < 0.7) {
for ( int ni = 0 ; ni < 4 ; ++ ni) {
int nj = ni == 3 ? 0 : ni + 1 ;
if ( triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm < - 0.9 &&
triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm < - 0.9) {
triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm < - 0.9) {
bDangerInversion = true ;
break ;
}
@@ -1625,102 +1636,6 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::MarchingCubes( int nBlock, TRIA3DLIST& lstTria) const
{
if ( nBlock < 0 || nBlock >= int( m_nNumBlock))
return false ;
// Calcolo posizione del blocco nel reticolo
int nIBlock = ( nBlock % int( m_nFracLin[0] * m_nFracLin[1])) % int( m_nFracLin[0]) ;
int nJBlock = ( nBlock % int( m_nFracLin[0] * m_nFracLin[1])) / int( m_nFracLin[0]) ;
int nKBlock = ( nBlock / int( m_nFracLin[0] * m_nFracLin[1])) ;
// Calcolo limiti per l'indice i
int nStartI = nIBlock * int( m_nDexNumPBlock) - 1 ;
int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ?
int( m_nNx[0]) : ( nIBlock + 1) * int( m_nDexNumPBlock)) ;
// Calcolo limiti per l'indice j
int nStartJ = nJBlock * int( m_nDexNumPBlock) - 1 ;
int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ?
int( m_nNy[0]) : ( nJBlock + 1) * int( m_nDexNumPBlock)) ;
// Calcolo limiti per l'indice k
int nStartK = nKBlock * int( m_nDexNumPBlock) - 1 ;
int nEndK = ( nKBlock + 1 == int( m_nFracLin[2]) ?
int( m_nNy[1]) : ( nKBlock + 1) * int( m_nDexNumPBlock)) ;
// Ciclo su tutti i voxel dello Zmap
for ( int i = nStartI ; i < nEndI ; ++ i) {
for ( int j = nStartJ ; j < nEndJ ; ++ j) {
for ( int k = nStartK ; k < nEndK ; ++ k) {
// Classificazione dei vertici: interni o esterni al materiale
int nIndex = CalcIndex( i, j , k) ;
// Se vi è qualche intersezione fra segmenti e superficie
// continuo altrimenti passo al prossimo voxel
if ( EdgeTable[nIndex] == 0)
continue ;
// Indici i,j,k dei vertici
int IndexCorner[8][3] = {
{ i, j, k},
{ i + 1, j, k},
{ i + 1, j + 1, k},
{ i, j + 1, k},
{ i, j, k + 1},
{ i + 1, j, k + 1},
{ i + 1, j + 1, k + 1},
{ i, j + 1, k + 1}
} ;
static int intersections[12][2] = {
{ 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 0 }, { 4, 5 }, { 5, 6 },
{ 6, 7 }, { 7, 4 }, { 0, 4 }, { 1, 5 }, { 2, 6 }, { 3, 7 }
} ;
// Ciclo sui segmenti
Point3d ptIntPoint[12] ;
for ( int EdgeIndex = 0 ; EdgeIndex < 12 ; ++ EdgeIndex) {
// Se il segmento non attraversa la superficie passo al successivo
if ( ! ( EdgeTable[nIndex] & ( 1 << EdgeIndex)))
continue ;
int n1 = intersections[EdgeIndex][0] ;
int n2 = intersections[EdgeIndex][1] ;
// Determino con precisione il punto di intersezione sullo spigolo
IntersPos( IndexCorner[n1], IndexCorner[n2], ptIntPoint[EdgeIndex]) ;
ptIntPoint[EdgeIndex].ToGlob( m_MapFrame[0]) ;
}
// Costruzione dei triangoli
for ( int TriIndex = 0 ; TriangleTableEn[nIndex][0][TriIndex] != - 1 ; TriIndex += 3) {
// Costruzione triangolo
int i0 = TriangleTableEn[nIndex][0][TriIndex + 2] ;
int i1 = TriangleTableEn[nIndex][0][TriIndex + 1] ;
int i2 = TriangleTableEn[nIndex][0][TriIndex] ;
// Il triangolo è pronto
Triangle3d CurrentTriangle ;
CurrentTriangle.Set( ptIntPoint[i0], ptIntPoint[i1], ptIntPoint[i2]) ;
bool bV = CurrentTriangle.Validate( true) ;
// Aggiungo triangolo
lstTria.emplace_back( CurrentTriangle) ;
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold) const
@@ -1738,7 +1653,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold)
GetBlockLimitsIJK( nIJK, nLimits) ;
// Unordered Map per la riduzione del numero di triangoli
int nDim = m_nDexNumPBlock * m_nDexNumPBlock ;
int nDim = m_nVoxNumPerBlock * m_nVoxNumPerBlock ;
VoxelContainer VoxContXZInf( nDim) ;
VoxelContainer VoxContXZSup( nDim) ;
VoxelContainer VoxContXYInf( nDim) ;
@@ -2336,7 +2251,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold)
// Limito la feature a una distanza dal baricentro pari alla diagonale del voxel
double dDistFeature = vtFeature.Len() ;
const double MAX_DIST = sqrt( 3) * m_dStep ;
const double MAX_DIST = sqrt( 3) * N_DEXVOXRATIO * m_dStep ;
bool bOutside = ( dDistFeature > MAX_DIST) ;
TRIA3DVECTOR triContainer ;
@@ -2413,8 +2328,10 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold)
Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ;
double dParInt1, dParInt2 ;
Point3d ptVoxMin( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, ( k + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( i + 1.5) * m_dStep, ( j + 1.5) * m_dStep, ( k + 1.5) * m_dStep) ;
Point3d ptVoxMin( ( i * N_DEXVOXRATIO + 0.5) * m_dStep,
( j * N_DEXVOXRATIO + 0.5) * m_dStep, ( k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( ( i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, ( ( k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// Caso in cui può essere riportata dentro: se il voxel in cui cade la feature è pieno
// la riporto muovendola lungo la sua linea
if ( IntersLineBox( ptSolZMapFrame, vtNullSpace, ptVoxMin, ptVoxMax, dParInt1, dParInt2)) {
@@ -2502,8 +2419,10 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold)
Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ;
double dParInt1, dParInt2 ;
Point3d ptVoxMin( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, ( k + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( i + 1.5) * m_dStep, ( j + 1.5) * m_dStep, ( k + 1.5) * m_dStep) ;
Point3d ptVoxMin( ( i * N_DEXVOXRATIO + 0.5) * m_dStep,
( j * N_DEXVOXRATIO + 0.5) * m_dStep, ( k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( ( i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, ( ( k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// Se è possibile riportarla dentro e il voxel in cui cade è pieno, la riporto nel suo voxel
// lungo la sua linea
if ( IntersLineBox( ptSolZMapFrame, vtNullSpace, ptVoxMin, ptVoxMax, dParInt1, dParInt2)) {
@@ -2554,8 +2473,10 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold)
Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ;
double dParInt1, dParInt2 ;
Point3d ptVoxMin( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, ( k + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( i + 1.5) * m_dStep, ( j + 1.5) * m_dStep, ( k + 1.5) * m_dStep) ;
Point3d ptVoxMin( ( i * N_DEXVOXRATIO + 0.5) * m_dStep,
( j * N_DEXVOXRATIO + 0.5) * m_dStep, ( k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptVoxMax( ( ( i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, ( ( k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
if ( IntersLineBox( ptSolZMapFrame, vtNullSpace, ptVoxMin, ptVoxMax, dParInt1, dParInt2)) {
@@ -3267,9 +3188,15 @@ VolZmap::FlipEdgesBB( TriaMatrix& InterTria) const
bool
VolZmap::IsThereMat( int nI, int nJ, int nK) const
{
if ( nI == - 1 || nI == m_nNx[0] ||
nJ == - 1 || nJ == m_nNy[0] ||
nK == - 1 || nK == m_nNy[1])
// Trasformo gl indici della griglia voxel in quelli della griglia dexel
nI *= N_DEXVOXRATIO ;
nJ *= N_DEXVOXRATIO ;
nK *= N_DEXVOXRATIO ;
// Se l'indice è alla frontiera del reticolo non vi è materiale
if ( nI <= - 1 || nI >= int( m_nNx[0]) ||
nJ <= - 1 || nJ >= int( m_nNy[0]) ||
nK <= - 1 || nK >= int( m_nNy[1]))
return false ;
// ciclo sulle griglie
@@ -3335,118 +3262,6 @@ VolZmap::CalcIndex( int nI, int nJ, int nK) const
return nIndex ;
}
//----------------------------------------------------------------------------
bool
VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d& ptInt) const
{
if ( nVec1[0] != nVec2[0]) {
ptInt.y = ( nVec1[1] + 0.5) * m_dStep ;
ptInt.z = ( nVec1[2] + 0.5) * m_dStep ;
int nMinI = min( nVec1[0], nVec2[0]) ;
int nMaxI = max( nVec1[0], nVec2[0]) ;
double dMinX = ( nMinI + 0.5) * m_dStep ;
double dMaxX = ( nMaxI + 0.5) * m_dStep ;
unsigned int nDexel = nVec1[2] * m_nNx[1] + nVec1[1] ;
size_t nSize = m_Values[1][nDexel].size() ;
bool bFound = false ;
for ( size_t i = 0 ; i < nSize ; i += 1) {
double dx1 = m_Values[1][nDexel][i].dMin ;
double dx2 = m_Values[1][nDexel][i].dMax ;
if ( dx1 < dMinX - EPS_SMALL && dx2 > dMinX - EPS_SMALL && dx2 < dMaxX + EPS_SMALL) {
ptInt.x = dx2 ;
bFound = true ;
break ;
}
else if ( dx1 > dMinX - EPS_SMALL && dx1 < dMaxX + EPS_SMALL && dx2 > dMaxX + EPS_SMALL) {
ptInt.x = dx1 ;
bFound = true ;
break ;
}
}
if ( ! bFound)
ptInt.x = ( dMinX + dMaxX) / 2 ;
}
else if ( nVec1[1] != nVec2[1]) {
ptInt.x = ( nVec1[0] + 0.5) * m_dStep ;
ptInt.z = ( nVec1[2] + 0.5) * m_dStep ;
int nMinJ = min( nVec1[1], nVec2[1]) ;
int nMaxJ = max( nVec1[1], nVec2[1]) ;
double dMinY = ( nMinJ + 0.5) * m_dStep ;
double dMaxY = ( nMaxJ + 0.5) * m_dStep ;
unsigned int nDexel = nVec1[0] * m_nNx[2] + nVec1[2] ;
size_t nSize = m_Values[2][nDexel].size() ;
bool bFound = false ;
for ( size_t j = 0 ; j < nSize ; j += 1) {
double dy1 = m_Values[2][nDexel][j].dMin ;
double dy2 = m_Values[2][nDexel][j].dMax ;
if ( dy1 < dMinY - EPS_SMALL && dy2 > dMinY - EPS_SMALL && dy2 < dMaxY + EPS_SMALL) {
ptInt.y = dy2 ;
bFound = true ;
break ;
}
else if ( dy1 > dMinY - EPS_SMALL && dy1 < dMaxY + EPS_SMALL && dy2 > dMaxY + EPS_SMALL) {
ptInt.y = dy1 ;
bFound = true ;
break ;
}
}
if ( ! bFound)
ptInt.y = ( dMinY + dMaxY) / 2 ;
}
else if ( nVec1[2] != nVec2[2]) {
ptInt.x = ( nVec1[0] + 0.5) * m_dStep ;
ptInt.y = ( nVec1[1] + 0.5) * m_dStep ;
int nMinK = min( nVec1[2], nVec2[2]) ;
int nMaxK = max( nVec1[2], nVec2[2]) ;
double dMinZ = ( nMinK + 0.5) * m_dStep ;
double dMaxZ = ( nMaxK + 0.5) * m_dStep ;
unsigned int nDexel = nVec1[1] * m_nNx[0] + nVec1[0] ;
size_t nSize = m_Values[0][nDexel].size() ;
bool bFound = false ;
for ( size_t k = 0 ; k < nSize ; k += 1) {
double dz1 = m_Values[0][nDexel][k].dMin ;
double dz2 = m_Values[0][nDexel][k].dMax ;
if ( dz1 < dMinZ - EPS_SMALL && dz2 > dMinZ - EPS_SMALL && dz2 < dMaxZ + EPS_SMALL) {
ptInt.z = dz2 ;
bFound = true ;
break ;
}
else if ( dz1 > dMinZ - EPS_SMALL && dz1 < dMaxZ + EPS_SMALL && dz2 > dMaxZ + EPS_SMALL) {
ptInt.z = dz1 ;
bFound = true ;
break ;
}
}
if ( ! bFound)
ptInt.z = ( dMinZ + dMaxZ) / 2 ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, Vector3d& vtNormal) const
@@ -3457,16 +3272,16 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt,
if ( nVec1[0] != nVec2[0]) {
int nMinI = min( nVec1[0], nVec2[0]) ;
int nMaxI = max( nVec1[0], nVec2[0]) ;
int nMinI = min( nVec1[0], nVec2[0]) * N_DEXVOXRATIO ;
int nMaxI = max( nVec1[0], nVec2[0]) * N_DEXVOXRATIO ;
double dMinX = ( nMinI + 0.5) * m_dStep ;
double dMaxX = ( nMaxI + 0.5) * m_dStep ;
ptInt.y = ( nVec1[1] + 0.5) * m_dStep ;
ptInt.z = ( nVec1[2] + 0.5) * m_dStep ;
ptInt.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ;
ptInt.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ;
size_t nDexel = nVec1[2] * m_nNx[1] + nVec1[1] ;
size_t nDexel = ( nVec1[2] * m_nNx[1] + nVec1[1]) * N_DEXVOXRATIO ;
int nSize = int( m_Values[1][nDexel].size()) ;
if ( bFirstCorner) {
@@ -3507,16 +3322,16 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt,
else if ( nVec1[1] != nVec2[1]) {
int nMinJ = min( nVec1[1], nVec2[1]) ;
int nMaxJ = max( nVec1[1], nVec2[1]) ;
int nMinJ = min( nVec1[1], nVec2[1]) * N_DEXVOXRATIO ;
int nMaxJ = max( nVec1[1], nVec2[1]) * N_DEXVOXRATIO ;
double dMinY = ( nMinJ + 0.5) * m_dStep ;
double dMaxY = ( nMaxJ + 0.5) * m_dStep ;
ptInt.x = ( nVec1[0] + 0.5) * m_dStep ;
ptInt.z = ( nVec1[2] + 0.5) * m_dStep ;
ptInt.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ;
ptInt.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ;
size_t nDexel = nVec1[0] * m_nNx[2] + nVec1[2] ;
size_t nDexel = ( nVec1[0] * m_nNx[2] + nVec1[2]) * N_DEXVOXRATIO ;
int nSize = int( m_Values[2][nDexel].size()) ;
if ( bFirstCorner) {
@@ -3557,16 +3372,16 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt,
else if ( nVec1[2] != nVec2[2]) {
int nMinK = min( nVec1[2], nVec2[2]) ;
int nMaxK = max( nVec1[2], nVec2[2]) ;
int nMinK = min( nVec1[2], nVec2[2]) * N_DEXVOXRATIO ;
int nMaxK = max( nVec1[2], nVec2[2]) * N_DEXVOXRATIO ;
double dMinZ = ( nMinK + 0.5) * m_dStep ;
double dMaxZ = ( nMaxK + 0.5) * m_dStep ;
ptInt.x = ( nVec1[0] + 0.5) * m_dStep ;
ptInt.y = ( nVec1[1] + 0.5) * m_dStep ;
ptInt.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ;
ptInt.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ;
size_t nDexel = nVec1[1] * m_nNx[0] + nVec1[0] ;
size_t nDexel = ( nVec1[1] * m_nNx[0] + nVec1[0]) * N_DEXVOXRATIO ;
int nSize = int( m_Values[0][nDexel].size()) ;
if ( bFirstCorner) {
@@ -3612,53 +3427,73 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt,
bool
VolZmap::IsValidVoxel( int nN) const
{
return ( nN >= 0 && nN < int( ( m_nNx[0] + 1) * ( m_nNy[0] + 1) * ( m_nNy[1] + 1))) ;
// Calcolo il numero di voxel lungo X,Y e Z
unsigned int nVoxNumX = m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
unsigned int nVoxNumY = m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] / N_DEXVOXRATIO == 0 ? 1 : 2) ;
unsigned int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ;
// Verifico la validità del voxel
return ( nN >= 0 && nN < int( nVoxNumX * nVoxNumY * nVoxNumZ)) ;
}
//----------------------------------------------------------------------------
bool
VolZmap::IsValidVoxel( int nI, int nJ, int nK) const
{
return ( nI >= - 1 && nI < int( m_nNx[0]) &&
nJ >= - 1 && nJ < int( m_nNy[0]) &&
nK >= - 1 && nK < int( m_nNy[1]) ) ;
// 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)) ;
// Verifico la validità del voxel
return ( nI >= - 1 && nI < nVoxNumX - 1 &&
nJ >= - 1 && nJ < nVoxNumY - 1 &&
nK >= - 1 && nK < nVoxNumZ - 1 ) ;
}
//----------------------------------------------------------------------------
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)) ;
// Controllo sulla validità del voxel
if ( nN < 0 || nN >= int( ( m_nNx[0] + 1) * ( m_nNy[0] + 1) * ( m_nNy[1] + 1)))
if ( nN < 0 || nN >= nVoxNumX * nVoxNumY * nVoxNumZ)
return false ;
// Calcolo gli indici
nI = ( nN % ( ( m_nNx[0] + 1) * ( m_nNy[0] + 1))) % ( m_nNx[0] + 1) - 1 ;
nJ = ( nN % ( ( m_nNx[0] + 1) * ( m_nNy[0] + 1))) / ( m_nNx[0] + 1) - 1 ;
nK = ( nN / ( ( m_nNx[0] + 1) * ( m_nNy[0] + 1))) - 1 ;
nI = ( nN % ( nVoxNumX * nVoxNumY)) % nVoxNumX - 1 ;
nJ = ( nN % ( nVoxNumX * nVoxNumY)) / nVoxNumX - 1 ;
nK = ( nN / ( nVoxNumX * nVoxNumY)) - 1 ;
// Controllo la sensatezza del risultato ottenuto
return ( nI >= - 1 && nI < int( m_nNx[0]) &&
nJ >= - 1 && nJ < int( m_nNy[0]) &&
nK >= - 1 && nK < int( m_nNy[1]) ) ;
return ( nI >= - 1 && nI < nVoxNumX - 1 &&
nJ >= - 1 && nJ < nVoxNumY - 1 &&
nK >= - 1 && nK < nVoxNumZ - 1 ) ;
}
//----------------------------------------------------------------------------
bool
VolZmap::GetVoxNFromIJK( int nI, int nJ, int nK, int& nN) const
{
// Controllo sull'esistenza del voxel
if ( nI <= - 2 || nI >= int( m_nNx[0]) ||
nJ <= - 2 || nJ >= int( m_nNy[0]) ||
nK <= - 2 || nK >= int( m_nNy[1]) )
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)) ;
// Controllo la validità del voxel
if ( nI <= - 2 || nI >= nVoxNumX - 1 ||
nJ <= - 2 || nJ >= nVoxNumY - 1 ||
nK <= - 2 || nK >= nVoxNumZ - 1 )
return false ;
// Calcolo il numero di Voxel
nN = ( m_nNx[0] + 1) * ( m_nNy[0] + 1) * ( nK + 1) +
( m_nNx[0] + 1) * ( nJ + 1) + nI + 1 ;
nN = nVoxNumX * nVoxNumY * ( nK + 1) +
nVoxNumX * ( nJ + 1) + nI + 1 ;
// controllo sulla sensatezza del numero ottenuto
return ( nN >= 0 && nN < int( ( m_nNx[0] + 1) * ( m_nNy[0] + 1) * ( m_nNy[1] + 1))) ;
return ( nN >= 0 && nN < nVoxNumX * nVoxNumY * nVoxNumZ) ;
}
//----------------------------------------------------------------------------
@@ -3675,7 +3510,7 @@ VolZmap::GetBlockIJKFromN( int nBlock, int nIJK[]) const
nIJK[2] = ( nBlock / int( m_nFracLin[0] * m_nFracLin[1])) ;
return true ;
}
}
//----------------------------------------------------------------------------
bool
@@ -3703,20 +3538,25 @@ VolZmap::GetBlockLimitsIJK( const int nIJK[], int nLimits[]) const
nIJK[2] < 0 || nIJK[2] >= int( m_nFracLin[2]))
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)) ;
// Calcolo limiti per l'indice i
nLimits[0] = ( nIJK[0] == 0 ? - 1 : nIJK[0] * int( m_nDexNumPBlock)) ;
nLimits[0] = ( nIJK[0] == 0 ? - 1 : nIJK[0] * int( m_nVoxNumPerBlock)) ;
nLimits[1] = ( nIJK[0] + 1 == int( m_nFracLin[0]) ?
int( m_nNx[0]) : ( nIJK[0] + 1) * int( m_nDexNumPBlock)) ;
nVoxNumX - 1 : ( nIJK[0] + 1) * int( m_nVoxNumPerBlock)) ;
// Calcolo limiti per l'indice j
nLimits[2] =( nIJK[1] == 0 ? - 1 : nIJK[1] * int( m_nDexNumPBlock)) ;
nLimits[2] = ( nIJK[1] == 0 ? - 1 : nIJK[1] * int( m_nVoxNumPerBlock)) ;
nLimits[3] = ( nIJK[1] + 1 == int( m_nFracLin[1]) ?
int( m_nNy[0]) : ( nIJK[1] + 1) * int( m_nDexNumPBlock)) ;
nVoxNumY - 1 : ( nIJK[1] + 1) * int( m_nVoxNumPerBlock)) ;
// Calcolo limiti per l'indice k
nLimits[4] = ( nIJK[2] == 0 ? - 1 : nIJK[2] * int( m_nDexNumPBlock)) ;
nLimits[4] = ( nIJK[2] == 0 ? - 1 : nIJK[2] * int( m_nVoxNumPerBlock)) ;
nLimits[5] = ( nIJK[2] + 1 == int( m_nFracLin[2]) ?
int( m_nNy[1]) : ( nIJK[2] + 1) * int( m_nDexNumPBlock)) ;
nVoxNumZ - 1 : ( nIJK[2] + 1) * int( m_nVoxNumPerBlock)) ;
return true ;
}
@@ -3725,53 +3565,64 @@ VolZmap::GetBlockLimitsIJK( const int nIJK[], int nLimits[]) const
bool
VolZmap::IsPointInsideVoxelApprox( int nI, int nJ, int nK, const Point3d& ptP, double dPrec) const
{
// Controllo sull'ammissibilità del voxel
if ( nI < - 1 || nI >= int( m_nNx[0]) ||
nJ < - 1 || nJ >= int( m_nNy[0]) ||
nK < - 1 || nK >= int( m_nNy[1]))
// 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)) ;
// Controllo sulla validità del voxel
if ( nI <= - 2 || nI >= nVoxNumX - 1 ||
nJ <= - 2 || nJ >= nVoxNumY - 1 ||
nK <= - 2 || nK >= nVoxNumZ - 1 )
return false ;
// Se la tolleranza è minore di EPS_SMALL, la considero nulla
if ( dPrec < EPS_ZERO)
dPrec = 0 ;
bool bI = ptP.x > ( nI + 0.5) * m_dStep - dPrec &&
ptP.x < ( nI + 1.5) * m_dStep + dPrec ;
bool bJ = ptP.y > ( nJ + 0.5) * m_dStep - dPrec &&
ptP.y < ( nJ + 1.5) * m_dStep + dPrec ;
bool bK = ptP.z > ( nK + 0.5) * m_dStep - dPrec &&
ptP.z < ( nK + 1.5) * m_dStep + dPrec ;
return ( bI && bJ && bK) ;
// 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 ;
return ( bI && bJ && bK) ;
}
//----------------------------------------------------------------------------
bool
VolZmap::GetPointVoxel( const Point3d& ptP, int& nVoxI, int& nVoxJ, int& nVoxK) const
{
nVoxI = int( floor( ( ptP.x - 0.5 * m_dStep) / m_dStep)) ;
nVoxJ = int( floor( ( ptP.y - 0.5 * m_dStep) / m_dStep)) ;
nVoxK = int( floor( ( ptP.z - 0.5 * m_dStep) / m_dStep)) ;
return ( nVoxI >= -1 && nVoxI < int( m_nNx[0])) &&
( nVoxJ >= -1 && nVoxJ < int( m_nNy[0])) &&
( nVoxK >= -1 && nVoxK < int( m_nNy[1])) ;
// 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)) ;
// 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))) ;
// Controllo la validità del voxel
return ( nVoxI >= - 1 && nVoxI < nVoxNumX - 1) &&
( nVoxJ >= - 1 && nVoxJ < nVoxNumY - 1) &&
( nVoxK >= - 1 && nVoxK < nVoxNumZ - 1) ;
}
//----------------------------------------------------------------------------
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)) ;
// Controllo sull'ammissibilità del voxel
if ( nVoxIJK[0] <= -2 || nVoxIJK[0] >= int( m_nNx[0]) ||
nVoxIJK[1] <= -2 || nVoxIJK[1] >= int( m_nNy[0]) ||
nVoxIJK[2] <= -2 || nVoxIJK[2] >= int( m_nNy[1]))
if ( nVoxIJK[0] <= - 2 || nVoxIJK[0] >= nVoxNumX - 1 ||
nVoxIJK[1] <= - 2 || nVoxIJK[1] >= nVoxNumY - 1 ||
nVoxIJK[2] <= - 2 || nVoxIJK[2] >= nVoxNumZ - 1 )
return false ;
// Divisioni intere
int nIntRatio0 = nVoxIJK[0] / m_nDexNumPBlock ;
int nIntRatio1 = nVoxIJK[1] / m_nDexNumPBlock ;
int nIntRatio2 = nVoxIJK[2] / m_nDexNumPBlock ;
int nIntRatio0 = nVoxIJK[0] / m_nVoxNumPerBlock ;
int nIntRatio1 = nVoxIJK[1] / m_nVoxNumPerBlock ;
int nIntRatio2 = nVoxIJK[2] / m_nVoxNumPerBlock ;
// Calcolo indici del blocco
nBlockIJK[0] = ( nVoxIJK[0] == -1 ? 0 : max( 0, nIntRatio0 - ( nIntRatio0 == m_nFracLin[0] ? 1 : 0))) ;
nBlockIJK[1] = ( nVoxIJK[1] == -1 ? 0 : max( 0, nIntRatio1 - ( nIntRatio1 == m_nFracLin[1] ? 1 : 0))) ;
@@ -3785,9 +3636,9 @@ bool
VolZmap::GetAdjBlockToBlock( int nBlockN, int nDeltaI, int nDeltaJ, int nDeltaK, int& nAdjBlockN) const
{
// Test sulla validità degli incrementi su i,j,k
if ( nDeltaI < - 1 || nDeltaI > 1 ||
nDeltaJ < - 1 || nDeltaJ > 1 ||
nDeltaK < - 1 || nDeltaK > 1)
if ( nDeltaI < - 1 || nDeltaI > 1 ||
nDeltaJ < - 1 || nDeltaJ > 1 ||
nDeltaK < - 1 || nDeltaK > 1)
return false ;
// Determino blocco adiacente
@@ -3797,26 +3648,31 @@ VolZmap::GetAdjBlockToBlock( int nBlockN, int nDeltaI, int nDeltaJ, int nDeltaK,
nAdjBlockN += nDeltaK * m_nFracLin[0] * m_nFracLin[1] ;
// Se il blocco adiacente esiste restituisco vero, altrimenti falso.
return ( nAdjBlockN > -1 && nAdjBlockN < int( m_nNumBlock)) ;
return ( nAdjBlockN > -1 && nAdjBlockN < int( m_nNumBlock)) ;
}
//----------------------------------------------------------------------------
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)) ;
// Test sulla validità dei limiti
if ( nLimits[0] < -1 || nLimits[0] > int( m_nNx[0]) ||
nLimits[1] < -1 || nLimits[1] > int( m_nNx[0]) ||
nLimits[2] < -1 || nLimits[2] > int( m_nNy[0]) ||
nLimits[3] < -1 || nLimits[3] > int( m_nNy[0]) ||
nLimits[4] < -1 || nLimits[4] > int( m_nNy[1]) ||
nLimits[5] < -1 || nLimits[5] > int( m_nNy[1]))
if ( nLimits[0] < - 1 || nLimits[0] > nVoxNumX - 1 ||
nLimits[1] < - 1 || nLimits[1] > nVoxNumX - 1 ||
nLimits[2] < - 1 || nLimits[2] > nVoxNumY - 1 ||
nLimits[3] < - 1 || nLimits[3] > nVoxNumY - 1 ||
nLimits[4] < - 1 || nLimits[4] > nVoxNumZ - 1 ||
nLimits[5] < - 1 || nLimits[5] > nVoxNumZ - 1 )
return false ;
// Controllo sull'ammissibilità del voxel
if ( nIJK[0] <= -2 || nIJK[0] >= int( m_nNx[0]) ||
nIJK[1] <= -2 || nIJK[1] >= int( m_nNx[1]) ||
nIJK[2] <= -2 || nIJK[2] >= int( m_nNy[1]))
if ( nIJK[0] <= -2 || nIJK[0] > nVoxNumX - 2 ||
nIJK[1] <= -2 || nIJK[1] > nVoxNumY - 2 ||
nIJK[2] <= -2 || nIJK[2] > nVoxNumZ - 2)
return false ;
// Se cerchiamo i voxel che sono sulla frontiera del blocco
@@ -3895,13 +3751,13 @@ VolZmap::IsATriangleOnBorder( const Triangle3d& trTria, const Point3d& ptVert,
// 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] + 0.5) * m_dStep ;
double dGrid = ( nBlockLimits[2*nC] * N_DEXVOXRATIO + 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] + 0.5) * m_dStep ;
double dGrid = ( nBlockLimits[2*nC+1] * N_DEXVOXRATIO + 0.5) * m_dStep ;
if ( abs( ptFirstGrPt.v[nC] - dGrid) < EPS_SMALL &&
abs( ptSecondGrPt.v[nC] - dGrid) < EPS_SMALL)
return true ;
@@ -3991,10 +3847,14 @@ VolZmap::ProcessVoxContXY( VoxelContainer& VoxContXY, bool bPlus, TRIA3DLIST& ls
}
}
Point3d ptT0( ( nMinI + 0.5) * m_dStep, ( ( nMinJ + 0.5) * m_dStep), dCordZ) ;
Point3d ptT1( ( nMaxI + 1.5) * m_dStep, ( ( nMinJ + 0.5) * m_dStep), dCordZ) ;
Point3d ptT2( ( nMaxI + 1.5) * m_dStep, ( ( nMaxJ + 1.5) * m_dStep), dCordZ) ;
Point3d ptT3( ( nMinI + 0.5) * m_dStep, ( ( nMaxJ + 1.5) * m_dStep), dCordZ) ;
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) ;
ptT0.ToGlob( m_MapFrame[0]) ;
ptT1.ToGlob( m_MapFrame[0]) ;
@@ -4106,10 +3966,14 @@ VolZmap::ProcessVoxContYZ( VoxelContainer& VoxContYZ, bool bPlus, TRIA3DLIST& ls
}
}
Point3d ptT0( dCordX, ( nMinJ + 0.5) * m_dStep, ( ( nMinK + 0.5) * m_dStep)) ;
Point3d ptT1( dCordX, ( nMaxJ + 1.5) * m_dStep, ( ( nMinK + 0.5) * m_dStep)) ;
Point3d ptT2( dCordX, ( nMaxJ + 1.5) * m_dStep, ( ( nMaxK + 1.5) * m_dStep)) ;
Point3d ptT3( dCordX, ( nMinJ + 0.5) * m_dStep, ( ( nMaxK + 1.5) * m_dStep)) ;
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)) ;
ptT0.ToGlob( m_MapFrame[0]) ;
ptT1.ToGlob( m_MapFrame[0]) ;
@@ -4221,10 +4085,14 @@ VolZmap::ProcessVoxContXZ( VoxelContainer& VoxContXZ, bool bPlus, TRIA3DLIST& ls
}
}
Point3d ptT0( ( nMinI + 0.5) * m_dStep, dCordY, ( ( nMinK + 0.5) * m_dStep)) ;
Point3d ptT1( ( nMaxI + 1.5) * m_dStep, dCordY, ( ( nMinK + 0.5) * m_dStep)) ;
Point3d ptT2( ( nMaxI + 1.5) * m_dStep, dCordY, ( ( nMaxK + 1.5) * m_dStep)) ;
Point3d ptT3( ( nMinI + 0.5) * m_dStep, dCordY, ( ( nMaxK + 1.5) * m_dStep)) ;
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)) ;
ptT0.ToGlob( m_MapFrame[0]) ;
ptT1.ToGlob( m_MapFrame[0]) ;