diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index 7886cff..38dc9ed 100644 Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ diff --git a/VolTriZmapCalculus.cpp b/VolTriZmapCalculus.cpp index 9a8430e..258f074 100644 --- a/VolTriZmapCalculus.cpp +++ b/VolTriZmapCalculus.cpp @@ -355,12 +355,12 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn // Ciclo sui voxel while ( IsValidVoxel( nVoxI, nVoxJ, nVoxK)) { // Estremi della diagonale del voxel corrente - Point3d ptMin( ( nVoxI + 0.5) * m_dStep, - ( nVoxJ + 0.5) * m_dStep, - ( nVoxK + 0.5) * m_dStep) ; - Point3d ptMax( ( nVoxI + 1.5) * m_dStep, - ( nVoxJ + 1.5) * m_dStep, - ( nVoxK + 1.5) * m_dStep) ; + Point3d ptMin( ( nVoxI * N_DEXVOXRATIO + 0.5) * m_dStep, + ( nVoxJ * N_DEXVOXRATIO + 0.5) * m_dStep, + ( nVoxK * N_DEXVOXRATIO + 0.5) * m_dStep) ; + Point3d ptMax( ( ( nVoxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, + ( ( nVoxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, + ( ( nVoxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ; // Studio il voxel corrente if ( IntersLineBox( ptP, vtD, ptMin, ptMax)) { Voxel NewVox ; @@ -370,9 +370,12 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn vVox.emplace_back( NewVox) ; } // Interseco la retta con i piani frontiera del voxel - double dMaxTX = ( abs( vtD.x) > EPS_ZERO ? abs( ( ( nVoxI + nPlaneI + 0.5) * m_dStep - ptP.x) / vtD.x) : INFINITO) ; - double dMaxTY = ( abs( vtD.y) > EPS_ZERO ? abs( ( ( nVoxJ + nPlaneJ + 0.5) * m_dStep - ptP.y) / vtD.y) : INFINITO) ; - double dMaxTZ = ( abs( vtD.z) > EPS_ZERO ? abs( ( ( nVoxK + nPlaneK + 0.5) * m_dStep - ptP.z) / vtD.z) : INFINITO) ; + double dMaxTX = ( abs( vtD.x) > EPS_ZERO ? + abs( ( ( ( nVoxI + nPlaneI) * N_DEXVOXRATIO + 0.5) * m_dStep - ptP.x) / vtD.x) : INFINITO) ; + double dMaxTY = ( abs( vtD.y) > EPS_ZERO ? + abs( ( ( ( nVoxJ + nPlaneJ) * N_DEXVOXRATIO + 0.5) * m_dStep - ptP.y) / vtD.y) : INFINITO) ; + double dMaxTZ = ( abs( vtD.z) > EPS_ZERO ? + abs( ( ( ( nVoxK + nPlaneK) * N_DEXVOXRATIO + 0.5) * m_dStep - ptP.z) / vtD.z) : INFINITO) ; if ( dMaxTX < dMaxTY) { if ( dMaxTX < dMaxTZ) diff --git a/VolTriZmapCreation.cpp b/VolTriZmapCreation.cpp index f646076..3a80fc5 100644 --- a/VolTriZmapCreation.cpp +++ b/VolTriZmapCreation.cpp @@ -49,13 +49,15 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL m_nNx[0] = static_cast ( floor( ( dLengthX + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ; m_nNy[0] = static_cast ( floor( ( dLengthY + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ; + // Calcolo il numero di voxel lungo X e Y + 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) ; + // Definisco il numero di blocchi lungo x e y - m_nFracLin[0] = max( 1u, - m_nNx[0] / m_nDexNumPBlock + - ( m_nNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; - m_nFracLin[1] = max( 1u, - m_nNy[0] / m_nDexNumPBlock + - ( m_nNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; + m_nFracLin[0] = max( 1u, nVoxNumX / m_nVoxNumPerBlock + + ( nVoxNumX % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; + m_nFracLin[1] = max( 1u, nVoxNumY / m_nVoxNumPerBlock + + ( nVoxNumY % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; // Numero di componenti connesse m_nConnectedCompoCount = 1 ; @@ -71,10 +73,12 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL m_nNx[2] = static_cast ( floor( ( dLengthZ + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ; m_nNy[2] = static_cast ( floor( ( dLengthX + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ; + // Calcolo il numero di voxel lungo Z + unsigned 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( 1u, - m_nNy[1] / m_nDexNumPBlock + - ( m_nNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; + m_nFracLin[2] = max( 1u, nVoxNumZ / m_nVoxNumPerBlock + + ( nVoxNumZ % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; } // altrimenti mono dexel @@ -196,13 +200,15 @@ 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 + 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) ; + // Definisco il numero di blocchi lungo x e y - m_nFracLin[0] = max( 1u, - m_nNx[0] / m_nDexNumPBlock + - ( m_nNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; - m_nFracLin[1] = max( 1u, - m_nNy[0] / m_nDexNumPBlock + - ( m_nNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; + m_nFracLin[0] = max( 1u, nVoxNumX / m_nVoxNumPerBlock + + ( nVoxNumX % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; + m_nFracLin[1] = max( 1u, nVoxNumY / m_nVoxNumPerBlock + + ( nVoxNumY % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; // Numero di componenti connesse m_nConnectedCompoCount = Surf.GetChunkCount() ; @@ -226,10 +232,12 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double m_Values[1].resize( m_nDim[1]) ; m_Values[2].resize( m_nDim[2]) ; + // Calcolo il numero di voxel lungo Z + unsigned 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( 1u, - m_nNy[1] / m_nDexNumPBlock + - ( m_nNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; + m_nFracLin[2] = max( 1u, nVoxNumZ / m_nVoxNumPerBlock + + ( nVoxNumZ % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; } else { @@ -521,13 +529,15 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bTriDex // 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 + 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) ; + // Definisco il numero di blocchi lungo x e y - m_nFracLin[0] = max( 1u, - m_nNx[0] / m_nDexNumPBlock + - ( m_nNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; - m_nFracLin[1] = max( 1u, - m_nNy[0] / m_nDexNumPBlock + - ( m_nNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; + m_nFracLin[0] = max( 1u, nVoxNumX / m_nVoxNumPerBlock + + ( nVoxNumX % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; + m_nFracLin[1] = max( 1u, nVoxNumY / m_nVoxNumPerBlock + + ( nVoxNumY % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; // Numero di componenti connesse m_nConnectedCompoCount = - 1 ; @@ -550,10 +560,12 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bTriDex m_Values[1].resize( m_nDim[1]) ; m_Values[2].resize( m_nDim[2]) ; + // Calcolo il numero di voxel lungo Z + unsigned 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( 1u, - m_nNy[1] / m_nDexNumPBlock + - ( m_nNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; + m_nFracLin[2] = max( 1u, nVoxNumZ / m_nVoxNumPerBlock + + ( nVoxNumZ % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; } else { diff --git a/VolTriZmapGraphics.cpp b/VolTriZmapGraphics.cpp index ab37e44..ae421d5 100644 --- a/VolTriZmapGraphics.cpp +++ b/VolTriZmapGraphics.cpp @@ -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]) ; diff --git a/VolTriZmapVolume.cpp b/VolTriZmapVolume.cpp index 9cb3644..b04552a 100644 --- a/VolTriZmapVolume.cpp +++ b/VolTriZmapVolume.cpp @@ -194,24 +194,31 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ int nXBlock[2] ; int nYBlock[2] ; - nXBlock[0] = min( nI / m_nDexNumPBlock, m_nFracLin[0] - 1) ; - nYBlock[0] = min( nJ / m_nDexNumPBlock, m_nFracLin[1] - 1) ; + // Passo dal dexel al voxel + nI /= N_DEXVOXRATIO ; + nJ /= N_DEXVOXRATIO ; - if ( nI % N_DEXBLOCK == 0 && nXBlock[0] > 0) { + nXBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ; + nYBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ; + + if ( nI % N_VOXBLOCK == 0 && nXBlock[0] > 0) { nXBlock[1] = nXBlock[0] - 1 ; ++ nXStop ; } - if ( nJ % N_DEXBLOCK == 0 && nYBlock[0] > 0) { + if ( nJ % N_VOXBLOCK == 0 && nYBlock[0] > 0) { nYBlock[1] = nYBlock[0] - 1 ; ++ nYStop ; } - int nMinK = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / m_dStep - EPS_SMALL))), 0, m_nNy[1] - 1) ; - int nMaxK = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / m_dStep + EPS_SMALL))), 0, m_nNy[1] - 1) ; + // Numero di voxel lungo Z + int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ; - int nMinZBlock = ( m_nMapNum == 1 ? 0 : max( 0, nMinK / int( m_nDexNumPBlock))) ; - int nMaxZBlock = min( int( m_nFracLin[2] - 1), nMaxK / int( m_nDexNumPBlock)) ; + 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 nMinZBlock = ( m_nMapNum == 1 ? 0 : max( 0, nMinK / int( m_nVoxNumPerBlock))) ; + int nMaxZBlock = min( int( m_nFracLin[2] - 1), nMaxK / int( m_nVoxNumPerBlock)) ; for ( int tI = 0 ; tI < nXStop ; ++ tI) { for ( int tJ = 0 ; tJ < nYStop ; ++ tJ) { @@ -240,24 +247,31 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ int nYBlock[2] ; int nZBlock[2] ; - nYBlock[0] = min( nI / m_nDexNumPBlock, m_nFracLin[1] - 1) ; - nZBlock[0] = min( nJ / m_nDexNumPBlock, m_nFracLin[2] - 1) ; + // Passo dal dexel al voxel + nI /= N_DEXVOXRATIO ; + nJ /= N_DEXVOXRATIO ; - if ( nI % N_DEXBLOCK == 0 && nYBlock[0] > 0) { + nYBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ; + nZBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ; + + if ( nI % N_VOXBLOCK == 0 && nYBlock[0] > 0) { nYBlock[1] = nYBlock[0] - 1 ; ++ nYStop ; } - if ( nJ % N_DEXBLOCK == 0 && nZBlock[0] > 0) { + if ( nJ % N_VOXBLOCK == 0 && nZBlock[0] > 0) { nZBlock[1] = nZBlock[0] - 1 ; ++ nZStop ; } - int nMinI = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / m_dStep - EPS_SMALL))), 0, m_nNx[0] - 1) ; - int nMaxI = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / m_dStep + EPS_SMALL))), 0, m_nNx[0] - 1) ; + // Numero di 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 nMinXBlock = max( 0, nMinI / int( m_nDexNumPBlock)) ; - int nMaxXBlock = min( int( m_nFracLin[0] - 1), nMaxI / int( m_nDexNumPBlock)) ; + int nMinXBlock = max( 0, nMinI / int( m_nVoxNumPerBlock)) ; + int nMaxXBlock = min( int( m_nFracLin[0] - 1), nMaxI / int( m_nVoxNumPerBlock)) ; for ( int tI = 0 ; tI < nYStop ; ++ tI) { for ( int tJ = 0 ; tJ < nZStop ; ++ tJ) { @@ -286,24 +300,31 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ int nXBlock[2] ; int nZBlock[2] ; - nXBlock[0] = min( nJ / m_nDexNumPBlock, m_nFracLin[0] - 1) ; - nZBlock[0] = min( nI / m_nDexNumPBlock, m_nFracLin[2] - 1) ; + // Passo dal dexel al voxel + nI /= N_DEXVOXRATIO ; + nJ /= N_DEXVOXRATIO ; - if ( nJ % N_DEXBLOCK == 0 && nXBlock[0] > 0) { + nXBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ; + nZBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ; + + if ( nJ % N_VOXBLOCK == 0 && nXBlock[0] > 0) { nXBlock[1] = nXBlock[0] - 1 ; ++ nXStop ; } - if ( nI % N_DEXBLOCK == 0 && nZBlock[0] > 0) { + if ( nI % N_VOXBLOCK == 0 && nZBlock[0] > 0) { nZBlock[1] = nZBlock[0] - 1 ; ++ nZStop ; } - - int nMinJ = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / m_dStep - EPS_SMALL))), 0, m_nNy[0] - 1) ; - int nMaxJ = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / m_dStep + EPS_SMALL))), 0, m_nNy[0] - 1) ; - int nMinYBlock = max( 0, nMinJ / int( m_nDexNumPBlock)) ; - int nMaxYBlock = min( int( m_nFracLin[1] - 1), nMaxJ / int( m_nDexNumPBlock)) ; + // Numero di 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 nMinYBlock = max( 0, nMinJ / int( m_nVoxNumPerBlock)) ; + int nMaxYBlock = min( int( m_nFracLin[1] - 1), nMaxJ / int( m_nVoxNumPerBlock)) ; for ( int tI = 0 ; tI < nZStop ; ++ tI) { for ( int tJ = 0 ; tJ < nXStop ; ++ tJ) { diff --git a/VolZmap.cpp b/VolZmap.cpp index cb46688..261dd37 100644 --- a/VolZmap.cpp +++ b/VolZmap.cpp @@ -30,7 +30,7 @@ GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ; //---------------------------------------------------------------------------- VolZmap::VolZmap(void) : m_nStatus( TO_VERIFY), m_dStep( EPS_SMALL), m_nTempProp( 0), m_dLinTol( LIN_TOL_STD), m_dAngTolDeg( ANG_TOL_APPROX_DEG), - m_nDexNumPBlock( N_DEXBLOCK) + m_nVoxNumPerBlock( N_VOXBLOCK) { m_nMapNum = 0 ; m_nNumBlock = 0 ; @@ -114,7 +114,7 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc) m_nMapNum = vzmSrc.m_nMapNum ; m_nNumBlock = vzmSrc.m_nNumBlock ; - m_nDexNumPBlock = vzmSrc.m_nDexNumPBlock ; + m_nVoxNumPerBlock = vzmSrc.m_nVoxNumPerBlock ; m_nFracLin[0] = vzmSrc.m_nFracLin[0] ; m_nFracLin[1] = vzmSrc.m_nFracLin[1] ; m_nFracLin[2] = vzmSrc.m_nFracLin[2] ; @@ -215,7 +215,7 @@ VolZmap::Save( NgeWriter& ngeOut) const if ( ! ngeOut.WriteInt( m_nNumBlock, ",", false)) return false ; // numero di dexel per blocco - if ( ! ngeOut.WriteInt( m_nDexNumPBlock, ",", false)) + if ( ! ngeOut.WriteInt( m_nVoxNumPerBlock, ",", false)) return false ; // numero di blocchi per ogni asse for ( int i = 0 ; i < 3 ; ++ i) { @@ -291,7 +291,7 @@ VolZmap::Load( NgeReader& ngeIn) if ( ! ngeIn.ReadInt( m_nNumBlock, ",", false)) return false ; // numero di dexel per blocco - if ( ! ngeIn.ReadInt( m_nDexNumPBlock, ",", false)) + if ( ! ngeIn.ReadInt( m_nVoxNumPerBlock, ",", false)) return false ; // numero di blocchi per ogni asse for ( int i = 0 ; i < 3 ; ++ i) { @@ -1064,16 +1064,21 @@ VolZmap::ClonePart( int nPart) const } } - // Definisco il numero di blocchi lungo x, y e z - pVolume->m_nFracLin[0] = max( 1u, - pVolume->m_nNx[0] / pVolume->m_nDexNumPBlock + - ( pVolume->m_nNx[0] % pVolume->m_nDexNumPBlock >= pVolume->m_nDexNumPBlock / 2 ? 1 : 0)) ; - pVolume->m_nFracLin[1] = max( 1u, - pVolume->m_nNy[0] / pVolume->m_nDexNumPBlock + - ( pVolume->m_nNy[0] % pVolume->m_nDexNumPBlock >= pVolume->m_nDexNumPBlock / 2 ? 1 : 0)) ; - pVolume->m_nFracLin[2] = max( 1u, - pVolume->m_nNy[1] / pVolume->m_nDexNumPBlock + - ( pVolume->m_nNy[1] % pVolume->m_nDexNumPBlock >= pVolume->m_nDexNumPBlock / 2 ? 1 : 0)) ; + // Calcolo il numero di voxel lungo x,y e z + unsigned int nVoxNumX = pVolume->m_nNx[0] / pVolume->N_DEXVOXRATIO + + ( pVolume->m_nNx[0] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; + unsigned int nVoxNumY = pVolume->m_nNy[0] / pVolume->N_DEXVOXRATIO + + ( pVolume->m_nNy[0] / pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; + unsigned int nVoxNumZ = pVolume->m_nNy[1] / pVolume->N_DEXVOXRATIO + + ( pVolume->m_nNy[1] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; + + // Definisco il numero di blocchi lungo x,y e z + pVolume->m_nFracLin[0] = max( 1u, nVoxNumX / pVolume->m_nVoxNumPerBlock + + ( nVoxNumX % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ; + pVolume->m_nFracLin[1] = max( 1u, nVoxNumY / pVolume->m_nVoxNumPerBlock + + ( nVoxNumY % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ; + pVolume->m_nFracLin[2] = max( 1u, 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] ; diff --git a/VolZmap.h b/VolZmap.h index 94a2b8e..efa9fe8 100644 --- a/VolZmap.h +++ b/VolZmap.h @@ -145,15 +145,13 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Point3d& ptQ, const Vector3d& vtZ, const Vector3d& vtNorm, TRIA3DLIST& lstTria) const ; bool ProcessCube( int nVoxI, int nVoxJ, int nVoxK, int& nCubeIndex, TRIA3DLIST& lstTria) const ; - bool ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriHolder& triHold, bool bExt) const ; ///// ora - bool MarchingCubes( int nBlock, TRIA3DLIST& lstTria) const ; + bool ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriHolder& triHold, bool bExt) const ; ///// ora bool ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold) const ; bool ExtMarchingCubes( std::vector& vVox, TRIA3DLIST& lstTria, bool bEnh) const ; bool FlipEdgesII( TriHolder& TriHold, bool bGraph) const ; bool FlipEdgesBB( TriaMatrix& InterTria) 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[], Point3d & ptInt) const ; + int CalcIndex( int nI, int nJ, int nK) const ; bool IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, Vector3d& vtNormal) const ; bool IsPointInsideVoxelApprox( int nI, int nJ, int nK, const Point3d& ptP, double dPrec = EPS_SMALL) const ; bool GetPointVoxel( const Point3d& ptP, int& nVoxI, int& nVoxJ, int& nVoxK) const ; @@ -309,7 +307,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW private : enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ; static const int N_MAPS = 3 ; - static const int N_DEXBLOCK = 32 ; + static const int N_VOXBLOCK = 32 ; + static const int N_DEXVOXRATIO = 2 ; private : ObjGraphicsMgr m_OGrMgr ; // gestore grafica dell'oggetto @@ -336,7 +335,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW std::vector> m_Values[N_MAPS] ; // dexel delle 3 griglie - unsigned int m_nDexNumPBlock ; // Numero di dexel per blocco + unsigned int m_nVoxNumPerBlock ; // Numero di voxel per blocco unsigned int m_nFracLin[3] ; // Numero di blocchi per ogni asse unsigned int m_nNumBlock ; // Numero totale di blocchi