From 85d6365fac4fc3b666b12051acf5e21c665cebf7 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Sat, 3 Mar 2018 18:20:55 +0000 Subject: [PATCH] EgtMachKernel : - piccole modifiche a Zmap. --- VolZmap.cpp | 4 +- VolZmapCreation.cpp | 6 +- VolZmapGraphics.cpp | 518 +++++++++++++++++++++----------------------- 3 files changed, 254 insertions(+), 274 deletions(-) diff --git a/VolZmap.cpp b/VolZmap.cpp index d421e16..658a68a 100644 --- a/VolZmap.cpp +++ b/VolZmap.cpp @@ -1053,7 +1053,7 @@ VolZmap::ClonePart( int nPart) const case 2 : pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOy ; pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOy ; - break ; + break ; } } } @@ -1063,7 +1063,7 @@ VolZmap::ClonePart( int nPart) const 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) ; + ( 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) ; diff --git a/VolZmapCreation.cpp b/VolZmapCreation.cpp index 36aa22f..eab5a9a 100644 --- a/VolZmapCreation.cpp +++ b/VolZmapCreation.cpp @@ -51,7 +51,7 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL // 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) ; + 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, nVoxNumX / m_nVoxNumPerBlock + @@ -198,7 +198,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double // 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) ; + 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, nVoxNumX / m_nVoxNumPerBlock + @@ -522,7 +522,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bTriDex // 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) ; + 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, nVoxNumX / m_nVoxNumPerBlock + diff --git a/VolZmapGraphics.cpp b/VolZmapGraphics.cpp index 60705ad..3842efa 100644 --- a/VolZmapGraphics.cpp +++ b/VolZmapGraphics.cpp @@ -80,7 +80,7 @@ TestOnNormal( const VectorField CompoVert[], int nCompoElem) dMaxAbsCos = dAbsCurrentCos ; } // se esiste normale diretta quasi come potenziale edge, allora corner - const double CORNER_COS = 0.7 ; + const double CORNER_COS = 0.5 ; if ( dMaxAbsCos > CORNER_COS) return CORNER ; else @@ -642,7 +642,7 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr { // 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 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. @@ -652,7 +652,7 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr return false ; // Classificazione dei vertici: interni o esterni al materiale - int nIndex = CalcIndex( nVoxI, nVoxJ , nVoxK) ; + int nIndex = CalcIndex( nVoxI, nVoxJ, nVoxK) ; // Se vi è qualche intersezione fra segmenti e superficie // continuo altrimenti passo al prossimo voxel. @@ -719,33 +719,33 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr int nStdTabOff = 0 ; // Carico le matrici CompoVert e CompoTriVert - for ( int nCompCount = 1 ; nCompCount <= nComponents ; ++ nCompCount) { + for ( int nComp = 0 ; nComp < nComponents ; ++ nComp) { // Numero vertici per componenti - nVertComp[nCompCount - 1] = TriangleTableEn[nIndex][1][nCompCount] ; + nVertComp[nComp] = TriangleTableEn[nIndex][1][nComp+1] ; // Riempio il nCompCount-esimo vettore di vertici della base del fan - for ( int nVertCount = 0 ; nVertCount < nVertComp[nCompCount - 1] ; ++ nVertCount) - CompoVert[nCompCount - 1][nVertCount] = VecField[TriangleTableEn[nIndex][1][nVertCount + nExtTabOff + 1]] ; + for ( int nVertCount = 0 ; nVertCount < nVertComp[nComp] ; ++ nVertCount) + CompoVert[nComp][nVertCount] = VecField[TriangleTableEn[nIndex][1][nVertCount + nExtTabOff + 1]] ; // Serve per la gestione del caso ... - if ( nVertComp[nCompCount - 1] == 4) { - for ( int nVertCount = 0 ; nVertCount < nVertComp[nCompCount - 1] ; ++ nVertCount) - nIndArrey[nCompCount - 1][nVertCount] = TriangleTableEn[nIndex][1][nVertCount + nExtTabOff + 1] ; + if ( nVertComp[nComp] == 4) { + for ( int nVert = 0 ; nVert < nVertComp[nComp] ; ++ nVert) + nIndArrey[nComp][nVert] = TriangleTableEn[nIndex][1][nVert + nExtTabOff + 1] ; } // Riempio il nCompCount-esimo vettore di vertici dei triangoli in assenza di // sharp feature: in una mesh di triangoli con n vertici vi sono n - 2 triangoli. - for ( int nVertCount = 0 ; nVertCount < 3 * ( nVertComp[nCompCount - 1] - 2) ; nVertCount += 3) { - CompoTriVert[nCompCount - 1][nVertCount] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVertCount+2]] ; - CompoTriVert[nCompCount - 1][nVertCount+1] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVertCount+1]] ; - CompoTriVert[nCompCount - 1][nVertCount+2] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVertCount]] ; + for ( int nVert = 0 ; nVert < 3 * ( nVertComp[nComp] - 2) ; nVert += 3) { + CompoTriVert[nComp][nVert] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVert+2]] ; + CompoTriVert[nComp][nVert+1] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVert+1]] ; + CompoTriVert[nComp][nVert+2] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVert]] ; } // Aggiorno gli offsets per raggiungere i // vertici della componente successiva. - nExtTabOff += nVertComp[nCompCount - 1] ; - nStdTabOff += 3 * ( nVertComp[nCompCount - 1] - 2) ; + nExtTabOff += nVertComp[nComp] ; + nStdTabOff += 3 * ( nVertComp[nComp] - 2) ; } // Test sulla topologia: dal momento che il nostro test @@ -792,21 +792,21 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr nComponents = Cases3Plus[nRotCase][1][0] ; - // Riaggiorno gli offsets + // Riaggiorno gli offsets nExtTabOff = nComponents ; nStdTabOff = 0 ; - // Modifico le matrici + // Modifico le matrici for ( int nC = 1 ; nC <= nComponents ; ++ nC) { - // Numero vertici per componenti + // Numero vertici per componenti nVertComp[nC - 1] = Cases3Plus[nRotCase][1][nC] ; - // Matrice dei vertici della base del fan + // Matrice dei vertici della base del fan for ( int nFanVert = 0 ; nFanVert < nVertComp[nC - 1] ; ++ nFanVert) CompoVert[nC - 1][nFanVert] = VecField[Cases3Plus[nRotCase][1][nFanVert + nExtTabOff + 1]] ; - // Matrici dei vertici dei triangoli in assenza di sharp feature + // Matrici dei vertici dei triangoli in assenza di sharp feature for ( int nTriVert = 0 ; nTriVert < 3 * ( nVertComp[nC - 1] - 2) ; nTriVert += 3) { CompoTriVert[nC - 1][nTriVert] = VecField[Cases3Plus[nRotCase][0][nStdTabOff + nTriVert+2]] ; @@ -814,8 +814,7 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr CompoTriVert[nC - 1][nTriVert+2] = VecField[Cases3Plus[nRotCase][0][nStdTabOff + nTriVert]] ; } - // Aggiorno gli offsets per raggiungere i - // vertici della componente successiva. + // Aggiorno gli offsets per raggiungere i vertici della componente successiva. nExtTabOff += nVertComp[nC - 1] ; nStdTabOff += 3 * ( nVertComp[nC - 1] - 2) ; } @@ -824,7 +823,7 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr else if ( nAllConfig[nIndex] == 6) { - // Procedura analoga a quella della configurazione 3 + // Procedura analoga a quella della configurazione 3 Vector3d vtCmpAvg0, vtCmpAvg1 ; bool bTest0 = DotTest( CompoVert[0], 4, vtCmpAvg0, 0.7) ; @@ -848,17 +847,17 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr nComponents = 1 ; - // Riaggiorno gli offsets + // Riaggiorno gli offsets nExtTabOff = nComponents ; nStdTabOff = 0 ; - // Modifico le matrici + // Modifico le matrici for ( int nC = 1 ; nC <= nComponents ; ++ nC) { - // Numero vertici per componenti + // Numero vertici per componenti nVertComp[nC - 1] = 7 ; - // Matrici dei vertici dei triangoli in assenza di sharp feature + // Matrici dei vertici dei triangoli in assenza di sharp feature for ( int nTriVert = 0 ; nTriVert < 3 * ( nVertComp[nC - 1] - 2) ; nTriVert += 3) { CompoTriVert[nC - 1][nTriVert] = VecField[Cases3Plus[nRotCase][0][nStdTabOff + nTriVert+2]] ; @@ -866,8 +865,7 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr CompoTriVert[nC - 1][nTriVert+2] = VecField[Cases3Plus[nRotCase][0][nStdTabOff + nTriVert]] ; } - // Aggiorno gli offsets per raggiungere i - // vertici della componente successiva. + // Aggiorno gli offsets per raggiungere i vertici della componente successiva. nExtTabOff += nVertComp[nC - 1] ; nStdTabOff += 3 * ( nVertComp[nC - 1] - 2) ; } @@ -879,10 +877,10 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr Vector3d vtCmpAvg0, vtCmpAvg1 ; - // Verifico se i versori delle componenti sono tutti - // più o meno concordi (per esserlo non devono esserci - // due vettori di una medesima componente con prodotto - // scalare inferiore a 0). decidere se 0.0 o 0.7 + // Verifico se i versori delle componenti sono tutti + // più o meno concordi (per esserlo non devono esserci + // due vettori di una medesima componente con prodotto + // scalare inferiore a 0). decidere se 0.0 o 0.7 bool bTest0 = DotTest( CompoVert[0], 4, vtCmpAvg0) ; bool bTest1 = DotTest( CompoVert[1], 4, vtCmpAvg1) ; @@ -894,27 +892,27 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr int nRotCase = nIndexVsIndex10[nt][1] ; - // Riaggiorno gli offsets + // Riaggiorno gli offsets nExtTabOff = 2 ; nStdTabOff = 0 ; - // Modifico le matrici + // Modifico le matrici for ( int nC = 1 ; nC <= 2 ; ++ nC) { - // Numero vertici per componenti + // Numero vertici per componenti nVertComp[nC - 1] = Cases10Plus[nRotCase][1][nC] ; - // Matrice dei vertici della base del fan + // Matrice dei vertici della base del fan for ( int nFanVert = 0 ; nFanVert < 4 ; ++ nFanVert) CompoVert[nC - 1][nFanVert] = VecField[Cases10Plus[nRotCase][1][nFanVert + nExtTabOff + 1]] ; - // Matrici dei vertici dei triangoli in assenza di sharp feature + // Matrici dei vertici dei triangoli in assenza di sharp feature for ( int nTriVert = 0 ; nTriVert < 6 ; nTriVert += 3) { CompoTriVert[nC - 1][nTriVert] = VecField[Cases10Plus[nRotCase][0][nStdTabOff + nTriVert+2]] ; CompoTriVert[nC - 1][nTriVert+1] = VecField[Cases10Plus[nRotCase][0][nStdTabOff + nTriVert+1]] ; CompoTriVert[nC - 1][nTriVert+2] = VecField[Cases10Plus[nRotCase][0][nStdTabOff + nTriVert]] ; } - // Aggiorno gli offsets per raggiungere i vertici della componente successiva. + // Aggiorno gli offsets per raggiungere i vertici della componente successiva. nExtTabOff += nVertComp[nC - 1] ; nStdTabOff += 3 * ( nVertComp[nC - 1] - 2) ; } @@ -922,79 +920,77 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr } } - // Numero di feature nel voxel: al più vi è una feature per componente connessa. + // Numero di feature nel voxel: al più vi è una feature per componente connessa. int nInnerFeatureInVoxel = 0 ; int nBorderFeatureInVoxel = 0 ; - // Ciclo sulle componenti - for ( int nCompCount = 1 ; nCompCount <= nComponents ; ++ nCompCount) { + // Ciclo sulle componenti + for ( int nComp = 0 ; nComp < nComponents ; ++ nComp) { int nFeatureType = NO_FEATURE ; - // Se i componenti sono regolari valuto le normali per stabilire se eseguire ExtMC o MC + // Se i componenti sono regolari valuto le normali per stabilire se eseguire ExtMC o MC if ( bReg) - nFeatureType = TestOnNormal( CompoVert[nCompCount - 1], nVertComp[nCompCount - 1]) ; + nFeatureType = TestOnNormal( CompoVert[nComp], nVertComp[nComp]) ; - // Flag ExtMC + // Flag ExtMC bool bExtMC = ( nFeatureType != NO_FEATURE) && ( ! bSecondConfig6) && bEnh ; - // Extended MC + // Extended MC if ( bExtMC) { - // Passo al sistema di riferimento del baricentro + // Passo al sistema di riferimento del baricentro Point3d ptGravityCenter( 0, 0, 0) ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) - ptGravityCenter = ptGravityCenter + CompoVert[nCompCount - 1][ni].ptInt ; - ptGravityCenter = ptGravityCenter / nVertComp[nCompCount - 1] ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) + ptGravityCenter = ptGravityCenter + CompoVert[nComp][ni].ptInt ; + ptGravityCenter = ptGravityCenter / nVertComp[nComp] ; Vector3d vtTrasf[12] ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) - vtTrasf[ni] = CompoVert[nCompCount - 1][ni].ptInt - ptGravityCenter ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) + vtTrasf[ni] = CompoVert[nComp][ni].ptInt - ptGravityCenter ; // Preparo le matrici per il sistema typedef Eigen::Matrix dSystemMatrix ; typedef Eigen::Matrix dSystemVector ; typedef Eigen::JacobiSVD DecomposerSVD ; - dSystemMatrix dMatrixN( nVertComp[nCompCount - 1], 3) ; - dSystemVector dKnownVector( nVertComp[nCompCount - 1], 1) ; + dSystemMatrix dMatrixN( nVertComp[nComp], 3) ; + dSystemVector dKnownVector( nVertComp[nComp], 1) ; - // Caso generale - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - dMatrixN( ni, 0) = CompoVert[nCompCount - 1][ni].vtNorm.x ; - dMatrixN( ni, 1) = CompoVert[nCompCount - 1][ni].vtNorm.y ; - dMatrixN( ni, 2) = CompoVert[nCompCount - 1][ni].vtNorm.z ; - dKnownVector( ni) = CompoVert[nCompCount - 1][ni].vtNorm * vtTrasf[ni] ; + // Caso generale + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + dMatrixN( ni, 0) = CompoVert[nComp][ni].vtNorm.x ; + dMatrixN( ni, 1) = CompoVert[nComp][ni].vtNorm.y ; + dMatrixN( ni, 2) = CompoVert[nComp][ni].vtNorm.z ; + dKnownVector( ni) = CompoVert[nComp][ni].vtNorm * vtTrasf[ni] ; } - // calcolo SVD + // calcolo SVD DecomposerSVD svd( dMatrixN, Eigen::ComputeThinU | Eigen::ComputeThinV) ; dSystemMatrix dMatrixV = svd.matrixV() ; dSystemVector dSingularValue = svd.singularValues() ; - // Se la feature è un edge annullo il valore singolare minore. + // Se la feature è un edge annullo il valore singolare minore. if ( nFeatureType == EDGE) { double dThres = 0.5 * ( dSingularValue( 1) + dSingularValue( 2)) / dSingularValue( 0) ; svd.setThreshold( dThres) ; } - // risolvo il sistema con SVD, quindi ai minimi quadrati + // risolvo il sistema con SVD, quindi ai minimi quadrati dSystemVector dUnknownVector( 3, 1) ; dUnknownVector = svd.solve( dKnownVector) ; - // Vettore Baricentro-Feature + // Vettore Baricentro-Feature Vector3d vtFeature( dUnknownVector( 0), dUnknownVector( 1), dUnknownVector( 2)) ; - // Esprimo la soluzione nel sistema di riferimento z-map + // Esprimo la soluzione nel sistema di riferimento z-map Point3d ptSol = ptGravityCenter + vtFeature ; - // Limito la feature entro i secondi voxel vicini, - // nel caso essa esca dal reticolo la limito entro una - // distanza dal baricentro pari alla diagonale del voxel. + // Limito la feature entro i secondi voxel vicini, + // nel caso essa esca dal reticolo la limito entro una + // distanza dal baricentro pari alla diagonale del voxel. bool bOutside = false ; - int nFtVxI, nFtVxJ, nFtVxK ; if ( GetPointVoxel( ptSol, nFtVxI, nFtVxJ, nFtVxK)) { - if ( abs( nFtVxI - nVoxI) > 2 || abs( nFtVxJ - nVoxJ) > 2 || abs( nFtVxK - nVoxK) > 2) @@ -1006,34 +1002,33 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr bOutside = ( dDistFeature > MAX_DIST) ; } + // Costruisco triangoli del fan TRIA3DVECTOR triContainer ; - - // Costruisco triangoli di prova - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; - // Il triangolo è pronto + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; + // Il triangolo è pronto Triangle3d CurrentTriangle ; - CurrentTriangle.Set( ptSol, CompoVert[nCompCount - 1][nj].ptInt, CompoVert[nCompCount - 1][ni].ptInt) ; + CurrentTriangle.Set( ptSol, CompoVert[nComp][nj].ptInt, CompoVert[nComp][ni].ptInt) ; CurrentTriangle.Validate( true) ; - // Aggiungo triangolo al vettore temporaneo + // Aggiungo triangolo al vettore temporaneo triContainer.emplace_back( CurrentTriangle) ; } - // Controllo delle inversioni dei triangoli + // Controllo delle inversioni dei triangoli bool bDangerInversion = false ; - // Caso ventaglio con tre vertici di base - if ( nVertComp[nCompCount - 1] == 3) { + // Caso ventaglio con tre vertici di base + if ( nVertComp[nComp] == 3) { - // Controllo se esiste almeno un triangolo con normale avente prodotto scalare - // negativo con la normale di almeno uno dei vertici di base del ventaglio. + // Controllo se esiste almeno un triangolo con normale avente prodotto scalare + // negativo con la normale di almeno uno dei vertici di base del ventaglio. bool bInversione = false ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; - double dDI = triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm ; - double dDJ = triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm ; + double dDI = triContainer[ni].GetN() * CompoVert[nComp][ni].vtNorm ; + double dDJ = triContainer[ni].GetN() * CompoVert[nComp][nj].vtNorm ; if ( dDI < - EPS_SMALL || dDJ < - EPS_SMALL) { bInversione = true ; @@ -1041,26 +1036,26 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr } } - // Se tale triangolo esiste procedo + // Se tale triangolo esiste procedo if ( bInversione) { - // Conto le coppie di normali con angolo compreso maggiore di 90° + // Conto le coppie di normali con angolo compreso maggiore di 90° int nNegDot = 0 ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] - 1 ; ++ ni) { - for ( int nj = ni + 1 ; nj < nVertComp[nCompCount - 1] ; ++ nj) { - if ( CompoVert[nCompCount - 1][ni].vtNorm * CompoVert[nCompCount - 1][nj].vtNorm < - EPS_SMALL) + for ( int ni = 0 ; ni < nVertComp[nComp] - 1 ; ++ ni) { + for ( int nj = ni + 1 ; nj < nVertComp[nComp] ; ++ nj) { + if ( CompoVert[nComp][ni].vtNorm * CompoVert[nComp][nj].vtNorm < - EPS_SMALL) nNegDot ++ ; } } - if ( nNegDot == nVertComp[nCompCount - 1] - 1) { - // Cerco se esiste un punto in cui la normale ha prodotto scalre negativo - // con le normali di entrambi i triangoli che lo contengono + if ( nNegDot == nVertComp[nComp] - 1) { + // Cerco se esiste un punto in cui la normale ha prodotto scalre negativo + // con le normali di entrambi i triangoli che lo contengono bool bInversione2 = false ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni == 0 ? nVertComp[nCompCount - 1] - 1 : ni - 1) ; - double dDLast = triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm ; - double dDPrev = triContainer[nj].GetN() * CompoVert[nCompCount - 1][ni].vtNorm ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni == 0 ? nVertComp[nComp] - 1 : ni - 1) ; + double dDLast = triContainer[ni].GetN() * CompoVert[nComp][ni].vtNorm ; + double dDPrev = triContainer[nj].GetN() * CompoVert[nComp][ni].vtNorm ; if ( ( dDLast < EPS_SMALL && dDPrev < EPS_SMALL) || ( dDLast < - 0.75 || dDPrev < - 0.75)) { bInversione2 = true ; @@ -1068,14 +1063,14 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr } } - // Se tale normale esiste + // Se tale normale esiste if ( bInversione2) { - // Soluzione del sistema nel sistema Zmap + // Soluzione del sistema nel sistema Zmap Point3d ptSolZMapFrame = ptSol ; - // Se la soluzione non cade nel voxel di appartenenza vedo se può - // essere riportata dentro muovendosi lungo la linea di feature. + // Se la soluzione non cade nel voxel di appartenenza vedo se può + // essere riportata dentro muovendosi lungo la linea di feature. if ( ! IsPointInsideVoxelApprox( nVoxI, nVoxJ, nVoxK, ptSolZMapFrame)) { Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ; @@ -1084,8 +1079,8 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr ( 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 + // 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)) { triContainer.resize( 0) ; @@ -1097,27 +1092,27 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr ptSol = ptNewSol ; - // Costruisco triangoli di prova - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; - // Il triangolo è pronto + // Costruisco triangoli di prova + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; + // Il triangolo è pronto Triangle3d CurrentTriangle ; - CurrentTriangle.Set( ptSol, CompoVert[nCompCount - 1][nj].ptInt, CompoVert[nCompCount - 1][ni].ptInt) ; + CurrentTriangle.Set( ptSol, CompoVert[nComp][nj].ptInt, CompoVert[nComp][ni].ptInt) ; CurrentTriangle.Validate( true) ; - // Aggiungo triangolo al vettore temporaneo + // Aggiungo triangolo al vettore temporaneo triContainer.emplace_back( CurrentTriangle) ; } } - // Caso in cui non può essere riportata dentro: - // si passa alla routine standard se il voxel - // in cui cade è pieno. + // Caso in cui non può essere riportata dentro: + // si passa alla routine standard se il voxel + // in cui cade è pieno. else { int nAdjVoxI, nAdjVoxJ, nAdjVoxK ; if ( GetPointVoxel( ptSolZMapFrame, nAdjVoxI, nAdjVoxJ, nAdjVoxK)) { - // Classificazione del voxel adiacente + // Classificazione del voxel adiacente int nAdjIndex = CalcIndex( nAdjVoxI, nAdjVoxJ, nAdjVoxK) ; - // Se il voxel è pieno + // Se il voxel è pieno if ( EdgeTable[nAdjIndex] != 0) bDangerInversion = true ; } @@ -1128,25 +1123,25 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr } } - // Ventaglio con base a quattro vertici - else if ( nVertComp[nCompCount - 1] == 4) { + // Ventaglio con base a quattro vertici + else if ( nVertComp[nComp] == 4) { // Controllo se esiste almeno un triangolo con normale avente prodotto scalare - // negativo con la normale di almeno uno dei vertici di base del ventaglio. + // negativo con la normale di almeno uno dei vertici di base del ventaglio. bool bInversione = false ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; - double dDI = triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm ; - double dDJ = triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm ; + double dDI = triContainer[ni].GetN() * CompoVert[nComp][ni].vtNorm ; + double dDJ = triContainer[ni].GetN() * CompoVert[nComp][nj].vtNorm ; if ( dDI < - EPS_SMALL || dDJ < - EPS_SMALL) bInversione = true ; } - // Se tale triangolo esiste continuo i test + // Se tale triangolo esiste continuo i test if ( bInversione) { - // Se la feature non cade nel suo voxel + // Se la feature non cade nel suo voxel if ( ! IsPointInsideVoxelApprox( nVoxI, nVoxJ, nVoxK, ptSol)) { Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ; double dParInt1, dParInt2 ; @@ -1154,34 +1149,34 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr ( 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 + // Se è possibile riportarla dentro e il voxel in cui cade è pieno, la riporto nel suo voxel + // lungo la sua linea if ( IntersLineBox( ptSol, vtNullSpace, ptVoxMin, ptVoxMax, dParInt1, dParInt2)) { triContainer.resize( 0) ; double dPar = abs( dParInt1) < abs( dParInt2) ? dParInt1 + ( dParInt2 - dParInt1) / 100 : dParInt2 + ( dParInt1 - dParInt2) / 100 ; Point3d ptNewSol = ptSol + dPar * vtNullSpace ; ptSol = ptNewSol ; - // Costruisco triangoli di prova - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; - // Il triangolo è pronto + // Costruisco triangoli di prova + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; + // Il triangolo è pronto Triangle3d CurrentTriangle ; - CurrentTriangle.Set( ptSol, CompoVert[nCompCount - 1][nj].ptInt, CompoVert[nCompCount - 1][ni].ptInt) ; + CurrentTriangle.Set( ptSol, CompoVert[nComp][nj].ptInt, CompoVert[nComp][ni].ptInt) ; CurrentTriangle.Validate( true) ; - // Aggiungo triangolo al vettore temporaneo + // Aggiungo triangolo al vettore temporaneo triContainer.emplace_back( CurrentTriangle) ; } } - // Se non è possibile riportarla dentro e il voxel in - // cui cade è pieno passo alla routine standard + // Se non è possibile riportarla dentro e il voxel in + // cui cade è pieno passo alla routine standard else { int nAdjVoxI, nAdjVoxJ, nAdjVoxK ; if ( GetPointVoxel( ptSol, nAdjVoxI, nAdjVoxJ, nAdjVoxK)) { - // Classificazione del voxel adiacente + // Classificazione del voxel adiacente int nAdjIndex = CalcIndex( nAdjVoxI, nAdjVoxJ, nAdjVoxK) ; - // Se il voxel è pieno + // Se il voxel è pieno if ( EdgeTable[nAdjIndex] != 0) bDangerInversion = true ; } @@ -1190,28 +1185,18 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr } } - // Valuto normali: questo è ancora un controllo - // sulle normali, se risultano in tutti i punti - // approssimativamente uguali passiamo alla - // routine standard - int nContSize = int( triContainer.size()) ; - + // Verifico se il fan di triangoli è piano bool bPlane = true ; - - for ( int ni = 0 ; ni < nContSize - 1 ; ++ ni) { - for ( int nj = ni + 1 ; nj < nContSize ; ++ nj) { - - Vector3d vtI = triContainer[ni].GetN() ; + int nContSize = int( triContainer.size()) ; + if ( nContSize > 0) { + Vector3d vtI = triContainer[0].GetN() ; + for ( int nj = 1 ; nj < nContSize ; ++ nj) { Vector3d vtJ = triContainer[nj].GetN() ; - if ( ! AreSameVectorApprox( vtI, vtJ)) { bPlane = false ; break ; } } - - if ( ! bPlane) - break ; } // Se feature nei limiti e triangoli non in un piano, confermo ExtMC @@ -1267,12 +1252,12 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr // ExtMC non confermato, si passa a MC else { // Costruzione dei triangoli - for ( int TriIndex = 0; TriIndex < ( nVertComp[nCompCount - 1] - 2) * 3 ; TriIndex += 3) { + for ( int TriIndex = 0; TriIndex < ( nVertComp[nComp] - 2) * 3 ; TriIndex += 3) { // Il triangolo è pronto Triangle3d CurrentTriangle ; - CurrentTriangle.Set( CompoTriVert[nCompCount - 1][TriIndex].ptInt, - CompoTriVert[nCompCount - 1][TriIndex+1].ptInt, - CompoTriVert[nCompCount - 1][TriIndex+2].ptInt) ; + CurrentTriangle.Set( CompoTriVert[nComp][TriIndex].ptInt, + CompoTriVert[nComp][TriIndex+1].ptInt, + CompoTriVert[nComp][TriIndex+2].ptInt) ; bool bV = CurrentTriangle.Validate( true) ; // Aggiungo alla lista lstTria.emplace_back( CurrentTriangle) ; @@ -1283,12 +1268,12 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, Tr // Standard MC else { // Costruzione dei triangoli - for ( int TriIndex = 0; TriIndex < ( nVertComp[nCompCount - 1] - 2) * 3 ; TriIndex += 3) { + for ( int TriIndex = 0; TriIndex < ( nVertComp[nComp] - 2) * 3 ; TriIndex += 3) { // Il triangolo è pronto Triangle3d CurrentTriangle ; - CurrentTriangle.Set( CompoTriVert[nCompCount - 1][TriIndex].ptInt, - CompoTriVert[nCompCount - 1][TriIndex+1].ptInt, - CompoTriVert[nCompCount - 1][TriIndex+2].ptInt) ; + CurrentTriangle.Set( CompoTriVert[nComp][TriIndex].ptInt, + CompoTriVert[nComp][TriIndex+1].ptInt, + CompoTriVert[nComp][TriIndex+2].ptInt) ; bool bV = CurrentTriangle.Validate( true) ; // Aggiungo alla lista lstTria.emplace_back( CurrentTriangle) ; @@ -1324,7 +1309,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold VoxelContainer VoxContYZInf( nDim) ; VoxelContainer VoxContYZSup( nDim) ; - // Ciclo su tutti i voxel dello Zmap + // Ciclo su tutti i voxel del blocco for ( int i = nLimits[0] ; i < nLimits[1] ; ++ i) { for ( int j = nLimits[2] ; j < nLimits[3] ; ++ j) { for ( int k = nLimits[4] ; k < nLimits[5] ; ++ k) { @@ -1398,32 +1383,32 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold int nStdTabOff = 0 ; // Carico le matrici CompoVert e CompoTriVert - for ( int nCompCount = 1 ; nCompCount <= nComponents ; ++ nCompCount) { + for ( int nComp = 0 ; nComp < nComponents ; ++ nComp) { // Numero vertici per componenti - nVertComp[nCompCount - 1] = TriangleTableEn[nIndex][1][nCompCount] ; + nVertComp[nComp] = TriangleTableEn[nIndex][1][nComp+1] ; // Riempio il nCompCount-esimo vettore di vertici della base del fan - for ( int nVertCount = 0 ; nVertCount < nVertComp[nCompCount - 1] ; ++ nVertCount) - CompoVert[nCompCount - 1][nVertCount] = VecField[TriangleTableEn[nIndex][1][nVertCount + nExtTabOff + 1]] ; + for ( int nVert = 0 ; nVert < nVertComp[nComp] ; ++ nVert) + CompoVert[nComp][nVert] = VecField[TriangleTableEn[nIndex][1][nVert + nExtTabOff + 1]] ; // Serve per la gestione del caso ... - if ( nVertComp[nCompCount - 1] == 4) { - for ( int nVertCount = 0 ; nVertCount < nVertComp[nCompCount - 1] ; ++ nVertCount) - nIndArrey[nCompCount - 1][nVertCount] = TriangleTableEn[nIndex][1][nVertCount + nExtTabOff + 1] ; + if ( nVertComp[nComp] == 4) { + for ( int nVert = 0 ; nVert < nVertComp[nComp] ; ++ nVert) + nIndArrey[nComp][nVert] = TriangleTableEn[nIndex][1][nVert + nExtTabOff + 1] ; } // Riempio il nCompCount-esimo vettore di vertici dei triangoli in assenza di // sharp feature: in una mesh di triangoli con n vertici vi sono n - 2 triangoli. - for ( int nVertCount = 0 ; nVertCount < 3 * ( nVertComp[nCompCount - 1] - 2) ; nVertCount += 3) { - CompoTriVert[nCompCount - 1][nVertCount] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVertCount+2]] ; - CompoTriVert[nCompCount - 1][nVertCount+1] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVertCount+1]] ; - CompoTriVert[nCompCount - 1][nVertCount+2] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVertCount]] ; + for ( int nVert = 0 ; nVert < 3 * ( nVertComp[nComp] - 2) ; nVert += 3) { + CompoTriVert[nComp][nVert] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVert+2]] ; + CompoTriVert[nComp][nVert+1] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVert+1]] ; + CompoTriVert[nComp][nVert+2] = VecField[TriangleTableEn[nIndex][0][nStdTabOff + nVert]] ; } // Aggiorno gli offsets per raggiungere i vertici della componente successiva. - nExtTabOff += nVertComp[nCompCount - 1] ; - nStdTabOff += 3 * ( nVertComp[nCompCount - 1] - 2) ; + nExtTabOff += nVertComp[nComp] ; + nStdTabOff += 3 * ( nVertComp[nComp] - 2) ; } // Controllo se il voxel ha una sola faccia che giace in un piano canonico e quindi ha gestione speciale @@ -1666,12 +1651,12 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold int nBorderFeatureInVoxel = 0 ; // Ciclo sulle componenti - for ( int nCompCount = 1 ; nCompCount <= nComponents ; ++ nCompCount) { + for ( int nComp = 0 ; nComp < nComponents ; ++ nComp) { int nFeatureType = NO_FEATURE ; // Se i componenti sono regolari valuto le normali per stabilire se eseguire ExtMC o MC if ( bReg) - nFeatureType = TestOnNormal( CompoVert[nCompCount - 1], nVertComp[nCompCount - 1]) ; + nFeatureType = TestOnNormal( CompoVert[nComp], nVertComp[nComp]) ; // Flag ExtMC bool bExtMC = ( nFeatureType != NO_FEATURE) ; @@ -1681,28 +1666,28 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold // Passo al sistema di riferimento del baricentro Point3d ptGravityCenter( 0, 0, 0) ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) - ptGravityCenter += CompoVert[nCompCount - 1][ni].ptInt ; - ptGravityCenter = ptGravityCenter / nVertComp[nCompCount - 1] ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) + ptGravityCenter += CompoVert[nComp][ni].ptInt ; + ptGravityCenter = ptGravityCenter / nVertComp[nComp] ; Vector3d vtTrasf[12] ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) - vtTrasf[ni] = CompoVert[nCompCount - 1][ni].ptInt - ptGravityCenter ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) + vtTrasf[ni] = CompoVert[nComp][ni].ptInt - ptGravityCenter ; // Preparo le matrici per il sistema typedef Eigen::Matrix dSystemMatrix ; typedef Eigen::Matrix dSystemVector ; typedef Eigen::JacobiSVD DecomposerSVD ; - dSystemMatrix dMatrixN( nVertComp[nCompCount - 1], 3) ; - dSystemVector dKnownVector( nVertComp[nCompCount - 1], 1) ; + dSystemMatrix dMatrixN( nVertComp[nComp], 3) ; + dSystemVector dKnownVector( nVertComp[nComp], 1) ; // medio le normali adiacenti molto vicine (delta angolare inferiore a 22.5 deg) Vector3d vtNorm[12] ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) - vtNorm[ni] = CompoVert[nCompCount - 1][ni].vtNorm ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni + 1) % nVertComp[nCompCount - 1] ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) + vtNorm[ni] = CompoVert[nComp][ni].vtNorm ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni + 1) % nVertComp[nComp] ; if ( vtNorm[ni] * vtNorm[nj] > 0.92) { Vector3d vtNI = ( 0.6 * vtNorm[ni] + 0.4 * vtNorm[nj]) ; Vector3d vtNJ = ( 0.4 * vtNorm[ni] + 0.6 * vtNorm[nj]) ; @@ -1715,7 +1700,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold } // Caso generale - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { dMatrixN( ni, 0) = vtNorm[ni].x ; dMatrixN( ni, 1) = vtNorm[ni].y ; dMatrixN( ni, 2) = vtNorm[ni].z ; @@ -1747,7 +1732,6 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold // nel caso essa esca dal reticolo la limito entro una // distanza dal baricentro pari alla diagonale del voxel. bool bOutside = false ; - int nFtVxI, nFtVxJ, nFtVxK ; if ( GetPointVoxel( ptSol, nFtVxI, nFtVxJ, nFtVxK)) { if ( abs( nFtVxI - i) > 2 || @@ -1761,18 +1745,17 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold bOutside = ( dDistFeature > MAX_DIST) ; } + // Costruisco triangoli del fan TRIA3DEXVECTOR triContainer ; - - // Costruisco triangoli di prova - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; // Il triangolo è pronto Triangle3dEx CurrentTriangle ; // Setto i punti - CurrentTriangle.Set( ptSol, CompoVert[nCompCount - 1][nj].ptInt, CompoVert[nCompCount - 1][ni].ptInt) ; + CurrentTriangle.Set( ptSol, CompoVert[nComp][nj].ptInt, CompoVert[nComp][ni].ptInt) ; // Setto il numero di utensile ai vertici di base del fan - CurrentTriangle.SetAttrib( 1, CompoVert[nCompCount - 1][nj].nToolFlag) ; - CurrentTriangle.SetAttrib( 2, CompoVert[nCompCount - 1][ni].nToolFlag) ; + CurrentTriangle.SetAttrib( 1, CompoVert[nComp][nj].nToolFlag) ; + CurrentTriangle.SetAttrib( 2, CompoVert[nComp][ni].nToolFlag) ; // Setto il numero di utensile al triangolo nel complesso if ( CurrentTriangle.GetAttrib( 1) < 0 || CurrentTriangle.GetAttrib( 2) < 0) @@ -1783,8 +1766,8 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold else CurrentTriangle.SetGrade( 0) ; // Setto le normali a ogni vertice - CurrentTriangle.SetVertexNorm( 1, CompoVert[nCompCount - 1][nj].vtNorm) ; - CurrentTriangle.SetVertexNorm( 2, CompoVert[nCompCount - 1][ni].vtNorm) ; + CurrentTriangle.SetVertexNorm( 1, CompoVert[nComp][nj].vtNorm) ; + CurrentTriangle.SetVertexNorm( 2, CompoVert[nComp][ni].vtNorm) ; if ( CurrentTriangle.GetVertexNorm( 1) * CurrentTriangle.GetVertexNorm( 2) > 0.5) CurrentTriangle.SetVertexNorm( 0, 0.5 * ( CurrentTriangle.GetVertexNorm( 1) + CurrentTriangle.GetVertexNorm( 2))) ; @@ -1798,14 +1781,14 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold bool bDangerInversion = false ; // Caso ventaglio con tre vertici di base - if ( nVertComp[nCompCount - 1] == 3) { + if ( nVertComp[nComp] == 3) { // Controllo se esiste almeno un triangolo con normale avente prodotto scalare // negativo con la normale di almeno uno dei vertici di base del ventaglio. bool bInversione = false ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; - double dDI = triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm ; - double dDJ = triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; + double dDI = triContainer[ni].GetN() * CompoVert[nComp][ni].vtNorm ; + double dDJ = triContainer[ni].GetN() * CompoVert[nComp][nj].vtNorm ; if ( dDI < - EPS_SMALL || dDJ < - EPS_SMALL) { bInversione = true ; break ; @@ -1815,20 +1798,20 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold if ( bInversione) { // Conto le coppie di normali con angolo compreso maggiore di 90° int nNegDot = 0 ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] - 1 ; ++ ni) { - for ( int nj = ni + 1 ; nj < nVertComp[nCompCount - 1] ; ++ nj) { - if ( CompoVert[nCompCount - 1][ni].vtNorm * CompoVert[nCompCount - 1][nj].vtNorm < - EPS_SMALL) + for ( int ni = 0 ; ni < nVertComp[nComp] - 1 ; ++ ni) { + for ( int nj = ni + 1 ; nj < nVertComp[nComp] ; ++ nj) { + if ( CompoVert[nComp][ni].vtNorm * CompoVert[nComp][nj].vtNorm < - EPS_SMALL) nNegDot ++ ; } } - if ( nNegDot == nVertComp[nCompCount - 1] - 1) { + if ( nNegDot == nVertComp[nComp] - 1) { // Cerco se esiste un punto in cui la normale ha prodotto scalre negativo // con le normali di entrambi i triangoli che lo contengono bool bInversione2 = false ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni == 0 ? nVertComp[nCompCount - 1] - 1 : ni - 1) ; - double dDLast = triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm ; - double dDPrev = triContainer[nj].GetN() * CompoVert[nCompCount - 1][ni].vtNorm ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni == 0 ? nVertComp[nComp] - 1 : ni - 1) ; + double dDLast = triContainer[ni].GetN() * CompoVert[nComp][ni].vtNorm ; + double dDPrev = triContainer[nj].GetN() * CompoVert[nComp][ni].vtNorm ; if ( ( dDLast < EPS_SMALL && dDPrev < EPS_SMALL) || ( dDLast < - 0.75 || dDPrev < - 0.75)) { bInversione2 = true ; @@ -1854,15 +1837,15 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold dParInt2 + ( dParInt1 - dParInt2) / 100 ; ptSol += dPar * vtNullSpace ; // Costruisco triangoli di prova - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; // Il triangolo è pronto Triangle3dEx CurrentTriangle ; - CurrentTriangle.Set( ptSol, CompoVert[nCompCount - 1][nj].ptInt, CompoVert[nCompCount - 1][ni].ptInt) ; - CurrentTriangle.SetAttrib( 1, CompoVert[nCompCount - 1][nj].nToolFlag) ; - CurrentTriangle.SetAttrib( 2, CompoVert[nCompCount - 1][ni].nToolFlag) ; - CurrentTriangle.SetVertexNorm( 1, CompoVert[nCompCount - 1][nj].vtNorm) ; - CurrentTriangle.SetVertexNorm( 2, CompoVert[nCompCount - 1][ni].vtNorm) ; + CurrentTriangle.Set( ptSol, CompoVert[nComp][nj].ptInt, CompoVert[nComp][ni].ptInt) ; + CurrentTriangle.SetAttrib( 1, CompoVert[nComp][nj].nToolFlag) ; + CurrentTriangle.SetAttrib( 2, CompoVert[nComp][ni].nToolFlag) ; + CurrentTriangle.SetVertexNorm( 1, CompoVert[nComp][nj].vtNorm) ; + CurrentTriangle.SetVertexNorm( 2, CompoVert[nComp][ni].vtNorm) ; if ( CurrentTriangle.GetVertexNorm( 1) * CurrentTriangle.GetVertexNorm( 2) > 0.5) CurrentTriangle.SetVertexNorm( 0, 0.5 * ( CurrentTriangle.GetVertexNorm( 1) + CurrentTriangle.GetVertexNorm( 2))) ; @@ -1900,13 +1883,13 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold } } // Ventaglio con base a quattro vertici - else if ( nVertComp[nCompCount - 1] == 4) { + else if ( nVertComp[nComp] == 4) { // Controllo preliminare sulle normali bool bInversione = false ; - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; - double dDI = triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm ; - double dDJ = triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; + double dDI = triContainer[ni].GetN() * CompoVert[nComp][ni].vtNorm ; + double dDJ = triContainer[ni].GetN() * CompoVert[nComp][nj].vtNorm ; if ( dDI < - EPS_SMALL || dDJ < - EPS_SMALL) { bInversione = true ; break ; @@ -1915,10 +1898,10 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold // Si necessita di un ulteriore controllo if ( bInversione) { PolygonPlane Polygon ; - Point3d ptP0 = CompoVert[nCompCount - 1][0].ptInt ; - Point3d ptP1 = CompoVert[nCompCount - 1][1].ptInt ; - Point3d ptP2 = CompoVert[nCompCount - 1][2].ptInt ; - Point3d ptP3 = CompoVert[nCompCount - 1][3].ptInt ; + Point3d ptP0 = CompoVert[nComp][0].ptInt ; + Point3d ptP1 = CompoVert[nComp][1].ptInt ; + Point3d ptP2 = CompoVert[nComp][2].ptInt ; + Point3d ptP3 = CompoVert[nComp][3].ptInt ; Polygon.AddPoint( ptP0) ; Polygon.AddPoint( ptP1) ; Polygon.AddPoint( ptP2) ; @@ -1959,8 +1942,8 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold for ( int nE = 0 ; nE < 4 ; ++ nE) { if ( dIn[nE] < dThr) { int nF = nE + 1 < 4 ? nE + 1 : 0 ; - double dDE = triContainer[nE].GetN() * CompoVert[nCompCount - 1][nE].vtNorm ; - double dDF = triContainer[nE].GetN() * CompoVert[nCompCount - 1][nF].vtNorm ; + double dDE = triContainer[nE].GetN() * CompoVert[nComp][nE].vtNorm ; + double dDF = triContainer[nE].GetN() * CompoVert[nComp][nF].vtNorm ; double dLim = - 0.5/*EPS_SMALL*/ ; if ( dDE < dLim || dDF < dLim) { bSpecial = true ; @@ -1986,15 +1969,15 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold dParInt2 + ( dParInt1 - dParInt2) / 100 ; ptSol += dPar * vtNullSpace ; // Costruisco triangoli di prova - for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) { - int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ; + for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { + int nj = ( ni + 1 < nVertComp[nComp]) ? ni + 1 : 0 ; // Il triangolo è pronto Triangle3dEx CurrentTriangle ; - CurrentTriangle.Set( ptSol, CompoVert[nCompCount - 1][nj].ptInt, CompoVert[nCompCount - 1][ni].ptInt) ; - CurrentTriangle.SetAttrib( 1, CompoVert[nCompCount - 1][nj].nToolFlag) ; - CurrentTriangle.SetAttrib( 2, CompoVert[nCompCount - 1][ni].nToolFlag) ; - CurrentTriangle.SetVertexNorm( 1, CompoVert[nCompCount - 1][nj].vtNorm) ; - CurrentTriangle.SetVertexNorm( 2, CompoVert[nCompCount - 1][ni].vtNorm) ; + CurrentTriangle.Set( ptSol, CompoVert[nComp][nj].ptInt, CompoVert[nComp][ni].ptInt) ; + CurrentTriangle.SetAttrib( 1, CompoVert[nComp][nj].nToolFlag) ; + CurrentTriangle.SetAttrib( 2, CompoVert[nComp][ni].nToolFlag) ; + CurrentTriangle.SetVertexNorm( 1, CompoVert[nComp][nj].vtNorm) ; + CurrentTriangle.SetVertexNorm( 2, CompoVert[nComp][ni].vtNorm) ; if ( CurrentTriangle.GetVertexNorm( 1) * CurrentTriangle.GetVertexNorm( 2) > 0.5) CurrentTriangle.SetVertexNorm( 0, 0.5 * ( CurrentTriangle.GetVertexNorm( 1) + CurrentTriangle.GetVertexNorm( 2))) ; @@ -2031,21 +2014,18 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold } } - // Controllo sulle normali, se risultano in tutti i punti - // approssimativamente uguali passiamo alla routine standard - int nContSize = int( triContainer.size()) ; + // Verifico se il fan di triangoli è piano bool bPlane = true ; - for ( int ni = 0 ; ni < nContSize - 1 ; ++ ni) { - for ( int nj = ni + 1 ; nj < nContSize ; ++ nj) { - Vector3d vtI = triContainer[ni].GetN() ; + int nContSize = int( triContainer.size()) ; + if ( nContSize > 0) { + Vector3d vtI = triContainer[0].GetN() ; + for ( int nj = 1 ; nj < nContSize ; ++ nj) { Vector3d vtJ = triContainer[nj].GetN() ; if ( ! AreSameVectorApprox( vtI, vtJ)) { bPlane = false ; break ; } } - if ( ! bPlane) - break ; } // Se feature nei limiti e triangoli non in un piano, confermo ExtMC @@ -2162,16 +2142,16 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold else { vector vTria ; // Costruzione dei triangoli - for ( int TriIndex = 0; TriIndex < ( nVertComp[nCompCount - 1] - 2) * 3 ; TriIndex += 3) { + for ( int TriIndex = 0; TriIndex < ( nVertComp[nComp] - 2) * 3 ; TriIndex += 3) { // Il triangolo è pronto Triangle3dEx CurrentTriangle ; - CurrentTriangle.Set( CompoTriVert[nCompCount - 1][TriIndex].ptInt, - CompoTriVert[nCompCount - 1][TriIndex+1].ptInt, - CompoTriVert[nCompCount - 1][TriIndex+2].ptInt) ; + CurrentTriangle.Set( CompoTriVert[nComp][TriIndex].ptInt, + CompoTriVert[nComp][TriIndex+1].ptInt, + CompoTriVert[nComp][TriIndex+2].ptInt) ; // Setto il numero di utensile (conta solo positivo, nullo o negativo) - int nTool0 = Clamp( CompoTriVert[nCompCount - 1][TriIndex].nToolFlag, -1, 1) ; - int nTool1 = Clamp( CompoTriVert[nCompCount - 1][TriIndex+1].nToolFlag, -1, 1) ; - int nTool2 = Clamp( CompoTriVert[nCompCount - 1][TriIndex+2].nToolFlag, -1, 1) ; + int nTool0 = Clamp( CompoTriVert[nComp][TriIndex].nToolFlag, -1, 1) ; + int nTool1 = Clamp( CompoTriVert[nComp][TriIndex+1].nToolFlag, -1, 1) ; + int nTool2 = Clamp( CompoTriVert[nComp][TriIndex+2].nToolFlag, -1, 1) ; // Setto il numero dei colori if ( nTool0 == nTool1 || nTool0 == nTool2) CurrentTriangle.SetGrade( nTool0) ; @@ -2180,7 +2160,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold // Valido il triangolo e setto le normali del campo vettoriale ai corrispondenti vertici if ( CurrentTriangle.Validate( true)) { for ( int nV = 0 ; nV < 3 ; ++ nV) { - const Vector3d& vtVertNorm = CompoTriVert[nCompCount - 1][TriIndex+nV].vtNorm ; + const Vector3d& vtVertNorm = CompoTriVert[nComp][TriIndex+nV].vtNorm ; if ( CurrentTriangle.GetN() * vtVertNorm > 0.6) CurrentTriangle.SetVertexNorm( nV, vtVertNorm) ; else @@ -2213,16 +2193,16 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold else { vector vTria ; // Costruzione dei triangoli - for ( int TriIndex = 0; TriIndex < ( nVertComp[nCompCount - 1] - 2) * 3 ; TriIndex += 3) { + for ( int TriIndex = 0; TriIndex < ( nVertComp[nComp] - 2) * 3 ; TriIndex += 3) { // Il triangolo è pronto Triangle3dEx CurrentTriangle ; - CurrentTriangle.Set( CompoTriVert[nCompCount - 1][TriIndex].ptInt, - CompoTriVert[nCompCount - 1][TriIndex+1].ptInt, - CompoTriVert[nCompCount - 1][TriIndex+2].ptInt) ; + CurrentTriangle.Set( CompoTriVert[nComp][TriIndex].ptInt, + CompoTriVert[nComp][TriIndex+1].ptInt, + CompoTriVert[nComp][TriIndex+2].ptInt) ; // Setto il numero di utensile (conta solo positivo, nullo o negativo) - int nTool0 = Clamp( CompoTriVert[nCompCount - 1][TriIndex].nToolFlag, -1, 1) ; - int nTool1 = Clamp( CompoTriVert[nCompCount - 1][TriIndex+1].nToolFlag, -1, 1) ; - int nTool2 = Clamp( CompoTriVert[nCompCount - 1][TriIndex+2].nToolFlag, -1, 1) ; + int nTool0 = Clamp( CompoTriVert[nComp][TriIndex].nToolFlag, -1, 1) ; + int nTool1 = Clamp( CompoTriVert[nComp][TriIndex+1].nToolFlag, -1, 1) ; + int nTool2 = Clamp( CompoTriVert[nComp][TriIndex+2].nToolFlag, -1, 1) ; if ( nTool0 == nTool1 || nTool0 == nTool2) CurrentTriangle.SetGrade( nTool0) ; else if ( nTool1 == nTool2) @@ -2230,7 +2210,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, TriHolder& triHold // Valido il triangolo e setto le normali del campo vettoriale ai corrispondenti vertici if ( CurrentTriangle.Validate( true)) { for ( int nV = 0 ; nV < 3 ; ++ nV) { - const Vector3d& vtVertNorm = CompoTriVert[nCompCount - 1][TriIndex+nV].vtNorm ; + const Vector3d& vtVertNorm = CompoTriVert[nComp][TriIndex+nV].vtNorm ; if ( CurrentTriangle.GetN() * vtVertNorm > 0.6) CurrentTriangle.SetVertexNorm( nV, vtVertNorm) ; else @@ -2907,7 +2887,7 @@ VolZmap::IsValidVoxel( int nN) const { // 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 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)) ; @@ -2919,7 +2899,7 @@ VolZmap::IsValidVoxel( int nI, int nJ, int nK) const { // Calcolo il numero di voxel lungo X,Y e Z int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ; - int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] / N_DEXVOXRATIO == 0 ? 1 : 2)) ; + int 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 && @@ -2933,7 +2913,7 @@ 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 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 @@ -2957,7 +2937,7 @@ VolZmap::GetVoxNFromIJK( int nI, int nJ, int nK, int& nN) const { // Calcolo il numero di voxel lungo X,Y e Z int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ; - int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] / N_DEXVOXRATIO == 0 ? 1 : 2)) ; + int 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 @@ -3018,7 +2998,7 @@ VolZmap::GetBlockLimitsIJK( const int nIJK[], int nLimits[]) 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 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 @@ -3045,7 +3025,7 @@ VolZmap::IsPointInsideVoxelApprox( int nI, int nJ, int nK, const Point3d& ptP, d { // 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 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 || @@ -3072,7 +3052,7 @@ VolZmap::GetPointVoxel( const Point3d& ptP, int& nVoxI, int& nVoxJ, int& nVoxK) { // 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 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))) ; @@ -3090,7 +3070,7 @@ 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 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] >= nVoxNumX - 1 || @@ -3135,7 +3115,7 @@ VolZmap::IsAVoxelOnBoundary( const int nLimits[], const int nIJK[], bool bType) { // 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 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