diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index f1f86f7..d8e9aad 100644 Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ diff --git a/VolZmap.cpp b/VolZmap.cpp index 8940c95..ad12015 100644 --- a/VolZmap.cpp +++ b/VolZmap.cpp @@ -138,12 +138,18 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc) m_nTempProp = vzmSrc.m_nTempProp ; // dimensiono membri legati ai blocchi - m_BlockToUpdate.resize( m_nNumBlock) ; - m_InterBlockVox.resize( m_nNumBlock) ; - m_InterBlockTria.resize( m_nNumBlock) ; - m_SliceXY.resize( m_nNumBlock) ; - m_SliceXZ.resize( m_nNumBlock) ; - m_SliceYZ.resize( m_nNumBlock) ; + m_BlockToUpdate = vzmSrc.m_BlockToUpdate ; + m_BlockUpGradingCounter = vzmSrc.m_BlockUpGradingCounter ; + m_InterBlockVox = vzmSrc.m_InterBlockVox ; + m_InterBlockOriginalSharpTria = vzmSrc.m_InterBlockOriginalSharpTria ; + m_InterBlockToBeFlippedSharpTria = vzmSrc.m_InterBlockToBeFlippedSharpTria ; + m_BlockSharpTria = vzmSrc.m_BlockSharpTria ; + m_BlockSmoothTria = vzmSrc.m_BlockSmoothTria ; + m_BlockBigTria = vzmSrc.m_BlockBigTria ; + m_SingleMapTria = vzmSrc.m_SingleMapTria ; + m_SliceXY = vzmSrc.m_SliceXY ; + m_SliceXZ = vzmSrc.m_SliceXZ ; + m_SliceYZ = vzmSrc.m_SliceYZ ; // imposto ricalcolo grafica ResetGraphics() ; @@ -156,7 +162,7 @@ bool VolZmap::ResetGraphics( void) { m_OGrMgr.Reset() ; - for ( unsigned int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount) + for ( int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount) m_BlockToUpdate[nCount] = true ; return true ; } @@ -196,7 +202,7 @@ VolZmap::Dump( string& sOut, bool bMM, const char* szNewLine) const sOut += "Dim=" + ToString( m_nDim[0]) + "(" + ToString( m_nNx[0]) + "x" + ToString( m_nNy[0]) + ")" + szNewLine ; else { - for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) + for ( int i = 0 ; i < m_nMapNum ; ++ i) sOut += "Dim" + ToString( i+1) + "=" + ToString( m_nDim[i]) + "(" + ToString( m_nNx[i]) + "x" + ToString( m_nNy[i]) + ")" + szNewLine ; } @@ -245,7 +251,7 @@ VolZmap::Save( NgeWriter& ngeOut) const if ( ! ngeOut.WriteFrame( m_MapFrame, ";", true)) return false ; // per ogni mappa : numero di passi in X e Y e quote z estremali - for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { + for ( int i = 0 ; i < m_nMapNum ; ++ i) { if ( ! ngeOut.WriteInt( m_nNx[i], ",", false)) return false ; if ( ! ngeOut.WriteInt( m_nNy[i], ",", false)) @@ -256,11 +262,11 @@ VolZmap::Save( NgeWriter& ngeOut) const return false ; } // ciclo sulle mappe - for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { + for ( int i = 0 ; i < m_nMapNum ; ++ i) { // ciclo sui dexel - for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) { + for ( int j = 0 ; j < m_nDim[i] ; ++ j) { // numero di estremi - unsigned int nDim = unsigned int( m_Values[i][j].size()) ; + int nDim = int( m_Values[i][j].size()) ; if ( ! ngeOut.WriteInt( nDim, ":", false)) return false ; // se dexel nullo @@ -271,7 +277,7 @@ VolZmap::Save( NgeWriter& ngeOut) const } // altrimenti else { - for ( unsigned int k = 0 ; k < nDim ; ++ k) { + for ( int k = 0 ; k < nDim ; ++ k) { if ( ! ngeOut.WriteDouble( m_Values[i][j][k].dMin, ",", false)) return false ; if ( ! ngeOut.WriteInt( m_Values[i][j][k].nToolMin, ";", false)) @@ -327,7 +333,7 @@ VolZmap::Load( NgeReader& ngeIn) if ( ! ngeIn.ReadFrame( m_MapFrame, ";", true)) return false ; // per ogni mappa : numero di passi in X e Y e quote z estremali - for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { + for ( int i = 0 ; i < m_nMapNum ; ++ i) { if ( ! ngeIn.ReadInt( m_nNx[i], ",", false)) return false ; if ( ! ngeIn.ReadInt( m_nNy[i], ",", false)) @@ -339,13 +345,13 @@ VolZmap::Load( NgeReader& ngeIn) return false ; } // ciclo sulle mappe - for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { + for ( int i = 0 ; i < m_nMapNum ; ++ i) { // dimensiono i vettori m_Values[i].resize( m_nDim[i]) ; // ciclo sui dexel - for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) { + for ( int j = 0 ; j < m_nDim[i] ; ++ j) { // leggo il numero di estremi nel dexel - unsigned int nDim ; + int nDim ; if ( ! ngeIn.ReadInt( nDim, ":", false)) return false ; // se dexel nullo @@ -360,7 +366,7 @@ VolZmap::Load( NgeReader& ngeIn) // dimensiono l'array m_Values[i][j].resize( nDim) ; // leggo i valori - for ( unsigned int k = 0 ; k < nDim ; ++ k) { + for ( int k = 0 ; k < nDim ; ++ k) { if ( ! ngeIn.ReadDouble( m_Values[i][j][k].dMin, ",", false)) return false ; if ( ! ngeIn.ReadInt( m_Values[i][j][k].nToolMin, ";", false)) @@ -381,13 +387,17 @@ VolZmap::Load( NgeReader& ngeIn) } // imposto aggiornamento obbligatorio su tutti i blocchi - m_BlockToUpdate.resize( m_nNumBlock) ; - for ( unsigned int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount) - m_BlockToUpdate[nCount] = true ; + m_BlockToUpdate.resize( m_nNumBlock, true) ; + m_BlockUpGradingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ; // per triangoli di feature di frontiera tra blocchi m_InterBlockVox.resize( m_nNumBlock) ; - m_InterBlockTria.resize( m_nNumBlock) ; + m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ; + m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ; + m_BlockSharpTria.resize( m_nNumBlock) ; + m_BlockSmoothTria.resize( m_nNumBlock) ; + m_BlockBigTria.resize( m_nNumBlock) ; + m_SingleMapTria.resize( m_nNumBlock) ; m_SliceXY.resize( m_nNumBlock) ; m_SliceXZ.resize( m_nNumBlock) ; m_SliceYZ.resize( m_nNumBlock) ; @@ -415,13 +425,13 @@ VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const // calcolo preciso // ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga) double dY = 0 ; - for ( size_t j = 0 ; j <= m_nNy[0] ; ++ j) { - size_t jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] - 1) ; + for ( int j = 0 ; j <= m_nNy[0] ; ++ j) { + int jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] - 1) ; double dX = 0 ; // punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo) - for ( size_t i = 0 ; i <= m_nNx[0] ; ++ i) { - size_t ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] - 1) ; - size_t nPos = ic + jc * m_nNx[0] ; + for ( int i = 0 ; i <= m_nNx[0] ; ++ i) { + int ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] - 1) ; + int nPos = ic + jc * m_nNx[0] ; if ( m_Values[0][nPos].size() > 0) { Point3d ptP = m_MapFrame.Orig() + dX * m_MapFrame.VersX() + dY * m_MapFrame.VersY() ; b3Loc.Add( ptP + m_Values[0][nPos][0].dMin * m_MapFrame.VersZ()) ; @@ -459,13 +469,13 @@ VolZmap::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const // calcolo preciso // ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga) double dY = 0 ; - for ( size_t j = 0 ; j <= m_nNy[0] ; ++ j) { - size_t jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] -1) ; + for ( int j = 0 ; j <= m_nNy[0] ; ++ j) { + int jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] -1) ; double dX = 0 ; // punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo) - for ( size_t i = 0 ; i <= m_nNx[0] ; ++ i) { - size_t ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] -1) ; - size_t nPos = ic + jc * m_nNx[0] ; + for ( int i = 0 ; i <= m_nNx[0] ; ++ i) { + int ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] -1) ; + int nPos = ic + jc * m_nNx[0] ; if ( m_Values[0][nPos].size() > 0) { Point3d ptP = frUse.Orig() + dX * frUse.VersX() + dY * frUse.VersY() ; b3Ref.Add( ptP + m_Values[0][nPos][0].dMin * frUse.VersZ()) ; @@ -607,9 +617,9 @@ VolZmap::CheckMapConnection( void) m_nConnectedCompoCount = 0 ; // Imposto a 0 tutti il valore del numero della componente // connessa di ciascun tratto di ciascun dexel. - for ( size_t tMap = 0 ; tMap < m_nMapNum ; ++ tMap) { - for ( size_t tDex = 0 ; tDex < m_nDim[tMap] ; ++ tDex) { - for ( size_t tInt = 0 ; tInt < m_Values[tMap][tDex].size() ; ++ tInt) { + for ( int tMap = 0 ; tMap < m_nMapNum ; ++ tMap) { + for ( int tDex = 0 ; tDex < m_nDim[tMap] ; ++ tDex) { + for ( int tInt = 0 ; tInt < int( m_Values[tMap][tDex].size()) ; ++ tInt) { m_Values[tMap][tDex][tInt].nCompo = 0 ; // Controlli sui tratti di dexel non incidenti su nodi del reticolo @@ -651,14 +661,14 @@ VolZmap::CheckMapConnection( void) } // Ciclo sui dexel lungo Z - for ( size_t tI = 0 ; tI < m_nNx[0] ; ++ tI) { - for ( size_t tJ = 0 ; tJ < m_nNy[0] ; ++ tJ) { + for ( int tI = 0 ; tI < m_nNx[0] ; ++ tI) { + for ( int tJ = 0 ; tJ < m_nNy[0] ; ++ tJ) { // Numero del dexel lungo Z - size_t tDexZ = tJ * m_nNx[0] + tI ; + int tDexZ = tJ * m_nNx[0] + tI ; // Numero di intervalli nel dexel - size_t tStopIntZ = m_Values[0][tDexZ].size() ; + int tStopIntZ = int( m_Values[0][tDexZ].size()) ; // Ciclo sugli intervalli del dexel - for ( size_t tIntZ = 0 ; tIntZ < tStopIntZ ; ++ tIntZ) { + for ( int tIntZ = 0 ; tIntZ < tStopIntZ ; ++ tIntZ) { if ( m_Values[0][tDexZ][tIntZ].nCompo == 0) { ++ m_nConnectedCompoCount ; @@ -708,10 +718,10 @@ VolZmap::ExpandFromXInterval( IntContaier& IntCont) // Copio i dati dell'intervallo corrente IntervalIndexes CurrInterval = IntCont.top() ; IntCont.pop() ; - size_t tDex = CurrInterval.tDex ; - size_t tGrIndex1 = CurrInterval.tDex % m_nNx[1] ; - size_t tGrIndex2 = CurrInterval.tDex / m_nNx[1] ; - size_t tInt = CurrInterval.tInt ; + int tDex = CurrInterval.tDex ; + int tGrIndex1 = CurrInterval.tDex % m_nNx[1] ; + int tGrIndex2 = CurrInterval.tDex / m_nNx[1] ; + int tInt = CurrInterval.tInt ; // Quote estreme del segmento lungo X double dMinX = m_Values[1][tDex][tInt].dMin ; double dMaxX = m_Values[1][tDex][tInt].dMax ; @@ -719,17 +729,17 @@ VolZmap::ExpandFromXInterval( IntContaier& IntCont) double dMaxDX = max( floor( ( dMaxX + EPS_SMALL) / m_dStep - 0.5), 0.) ; // Indici estremi dei dei dexel ortogonali // che possono intersecare il segmento di partenza - size_t tStartI = min( size_t( dMinDX), size_t( m_nNx[0] - 1)) ; - size_t tStopI = min( size_t( dMaxDX), size_t( m_nNx[0] - 1)) ; + int tStartI = min( int( dMinDX), ( m_nNx[0] - 1)) ; + int tStopI = min( int( dMaxDX), ( m_nNx[0] - 1)) ; // Posizione YZ del dexel double dY = ( tGrIndex1 + 0.5) * m_dStep ; double dZ = ( tGrIndex2 + 0.5) * m_dStep ; // Ciclo sugli indici dei dexel che potrebbero // intersecare il segmento di partenza - for ( size_t tI = tStartI ; tI <= tStopI ; ++ tI) { + for ( int tI = tStartI ; tI <= tStopI ; ++ tI) { // Analizzo i dexel della griglia 0. - size_t tStopZ = m_Values[0][tGrIndex1 * m_nNx[0] + tI].size() ; - for ( size_t tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) { + int tStopZ = int( m_Values[0][tGrIndex1 * m_nNx[0] + tI].size()) ; + for ( int tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) { // Estremi del dexel lunog Z double dZmin = m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].dMin ; double dZmax = m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].dMax ; @@ -748,8 +758,8 @@ VolZmap::ExpandFromXInterval( IntContaier& IntCont) } } // Analizzo i dexel della griglia 2 - size_t tStopY = m_Values[2][tI * m_nNx[2] + tGrIndex2].size() ; - for ( size_t tIntY = 0 ; tIntY < tStopY ; ++ tIntY) { + int tStopY = int( m_Values[2][tI * m_nNx[2] + tGrIndex2].size()) ; + for ( int tIntY = 0 ; tIntY < tStopY ; ++ tIntY) { // Estremi del segmento del dexel lungo Y double dYmin = m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].dMin ; double dYmax = m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].dMax ; @@ -779,10 +789,10 @@ VolZmap::ExpandFromYInterval( IntContaier& IntCont) // Copio i dati dell'intervallo corrente IntervalIndexes CurrInterval = IntCont.top() ; IntCont.pop() ; - size_t tDex = CurrInterval.tDex ; - size_t tGrIndex1 = CurrInterval.tDex % m_nNx[2] ; - size_t tGrIndex2 = CurrInterval.tDex / m_nNx[2] ; - size_t tInt = CurrInterval.tInt ; + int tDex = CurrInterval.tDex ; + int tGrIndex1 = CurrInterval.tDex % m_nNx[2] ; + int tGrIndex2 = CurrInterval.tDex / m_nNx[2] ; + int tInt = CurrInterval.tInt ; // Quote estreme del segmento lungo Y double dMinY = m_Values[2][tDex][tInt].dMin ; double dMaxY = m_Values[2][tDex][tInt].dMax ; @@ -790,17 +800,17 @@ VolZmap::ExpandFromYInterval( IntContaier& IntCont) double dMaxDY = max( floor( ( dMaxY + EPS_SMALL) / m_dStep - 0.5), 0.) ; // Indici estremi dei dei dexel ortogonali // che possono intersecare il segmento di partenza - size_t tStartJ = min( size_t( dMinDY), size_t( m_nNy[0] - 1)) ; - size_t tStopJ = min( size_t( dMaxDY), size_t( m_nNy[0] - 1)) ; + int tStartJ = min( int( dMinDY), ( m_nNy[0] - 1)) ; + int tStopJ = min( int( dMaxDY), ( m_nNy[0] - 1)) ; // Posizione XZ del dexel double dX = ( tGrIndex2 + 0.5) * m_dStep ; double dZ = ( tGrIndex1 + 0.5) * m_dStep ; // Ciclo sugli indici dei dexel che potrebbero // intersecare il segmento di partenza - for ( size_t tJ = tStartJ ; tJ <= tStopJ ; ++ tJ) { + for ( int tJ = tStartJ ; tJ <= tStopJ ; ++ tJ) { // Analizzo i dexel della griglia 0. - size_t tStopZ = m_Values[0][tJ * m_nNx[0] + tGrIndex2].size() ; - for ( size_t tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) { + int tStopZ = int( m_Values[0][tJ * m_nNx[0] + tGrIndex2].size()) ; + for ( int tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) { // Estremi del dexel lunog Z double dZmin = m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].dMin ; double dZmax = m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].dMax ; @@ -819,8 +829,8 @@ VolZmap::ExpandFromYInterval( IntContaier& IntCont) } } // Analizzo i dexel della griglia 1 - size_t tStopX = m_Values[1][tGrIndex1 * m_nNx[1] + tJ].size() ; - for ( size_t tIntX = 0 ; tIntX < tStopX ; ++ tIntX) { + int tStopX = int( m_Values[1][tGrIndex1 * m_nNx[1] + tJ].size()) ; + for ( int tIntX = 0 ; tIntX < tStopX ; ++ tIntX) { // Estremi del segmento del dexel lungo X double dXmin = m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].dMin ; double dXmax = m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].dMax ; @@ -850,10 +860,10 @@ VolZmap::ExpandFromZInterval( IntContaier& IntCont) // Copio i dati dell'intervallo corrente IntervalIndexes CurrInterval = IntCont.top() ; IntCont.pop() ; - size_t tDex = CurrInterval.tDex ; - size_t tGrIndex1 = CurrInterval.tDex % m_nNx[0] ; - size_t tGrIndex2 = CurrInterval.tDex / m_nNx[0] ; - size_t tInt = CurrInterval.tInt ; + int tDex = CurrInterval.tDex ; + int tGrIndex1 = CurrInterval.tDex % m_nNx[0] ; + int tGrIndex2 = CurrInterval.tDex / m_nNx[0] ; + int tInt = CurrInterval.tInt ; // Quote estreme del segmento lungo Z double dMinZ = m_Values[0][tDex][tInt].dMin ; double dMaxZ = m_Values[0][tDex][tInt].dMax ; @@ -861,17 +871,17 @@ VolZmap::ExpandFromZInterval( IntContaier& IntCont) double dMaxDZ = max( floor( ( dMaxZ + EPS_SMALL) / m_dStep - 0.5), 0.) ; // Indici estremi dei dexel ortogonali // che possono intersecare il segmento di partenza - size_t tStartK = min( size_t( dMinDZ), size_t( m_nNy[1] - 1)) ; - size_t tStopK = min( size_t( dMaxDZ), size_t( m_nNy[1] - 1)) ; + int tStartK = min( int( dMinDZ), ( m_nNy[1] - 1)) ; + int tStopK = min( int( dMaxDZ), ( m_nNy[1] - 1)) ; // Posizione XY del dexel double dX = ( tGrIndex1 + 0.5) * m_dStep ; double dY = ( tGrIndex2 + 0.5) * m_dStep ; // Ciclo sugli indici dei dexel che potrebbero // intersecare il segmento di partenza - for ( size_t tK = tStartK ; tK <= tStopK ; ++ tK) { + for ( int tK = tStartK ; tK <= tStopK ; ++ tK) { // Analizzo i dexel della griglia 1. - size_t tStopX = m_Values[1][tK * m_nNx[1] + tGrIndex2].size() ; - for ( size_t tIntX = 0 ; tIntX < tStopX ; ++ tIntX) { + int tStopX = int( m_Values[1][tK * m_nNx[1] + tGrIndex2].size()) ; + for ( int tIntX = 0 ; tIntX < tStopX ; ++ tIntX) { // Estremi del segmento del dexel lungo X double dXmin = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMin ; double dXmax = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMax ; @@ -890,8 +900,8 @@ VolZmap::ExpandFromZInterval( IntContaier& IntCont) } } // Analizzo i dexel della griglia 2 - size_t tStopY = m_Values[2][tGrIndex1 * m_nNx[2] + tK].size() ; - for ( size_t tIntY = 0 ; tIntY < tStopY ; ++ tIntY) { + int tStopY = int( m_Values[2][tGrIndex1 * m_nNx[2] + tK].size()) ; + for ( int tIntY = 0 ; tIntY < tStopY ; ++ tIntY) { // Estremi del segmento del dexel lungo Y double dYmin = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMin ; double dYmax = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMax ; @@ -1084,32 +1094,33 @@ VolZmap::ClonePart( int nPart) const } // 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) ; + int nVoxNumX = pVolume->m_nNx[0] / pVolume->N_DEXVOXRATIO + + ( pVolume->m_nNx[0] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumY = pVolume->m_nNy[0] / pVolume->N_DEXVOXRATIO + + ( pVolume->m_nNy[0] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumZ = pVolume->m_nNy[1] / pVolume->N_DEXVOXRATIO + + ( pVolume->m_nNy[1] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; // Definisco il numero di blocchi lungo x,y e z - pVolume->m_nFracLin[0] = max( 1u, nVoxNumX / pVolume->m_nVoxNumPerBlock + + pVolume->m_nFracLin[0] = max( 1, nVoxNumX / pVolume->m_nVoxNumPerBlock + ( nVoxNumX % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ; - pVolume->m_nFracLin[1] = max( 1u, nVoxNumY / pVolume->m_nVoxNumPerBlock + + pVolume->m_nFracLin[1] = max( 1, nVoxNumY / pVolume->m_nVoxNumPerBlock + ( nVoxNumY % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ; - pVolume->m_nFracLin[2] = max( 1u, nVoxNumZ / pVolume->m_nVoxNumPerBlock + + pVolume->m_nFracLin[2] = max( 1, nVoxNumZ / pVolume->m_nVoxNumPerBlock + ( nVoxNumZ % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ; // Dimensiono il vettore dei blocchi pVolume->m_nNumBlock = pVolume->m_nFracLin[0] * pVolume->m_nFracLin[1] * pVolume->m_nFracLin[2] ; - pVolume->m_BlockToUpdate.resize( pVolume->m_nNumBlock) ; - // Setto tutti i blocchi come da aggiornare per la grafica - for ( unsigned int nCount = 0 ; nCount < pVolume->m_nNumBlock ; ++ nCount) - pVolume->m_BlockToUpdate[nCount] = true ; - + pVolume->m_BlockToUpdate.resize( pVolume->m_nNumBlock, true) ; + // Dimensiono il vettore dei contatori degli aggiornamenti della grafica dei blocchi + pVolume->m_BlockUpGradingCounter.resize( pVolume->m_nNumBlock + 1, 0) ; // Dimensiono raccolta di voxel di confine pVolume->m_InterBlockVox.resize( pVolume->m_nNumBlock) ; // Dimensiono raccolta triangoli di feature tra blocchi - pVolume->m_InterBlockTria.resize( pVolume->m_nNumBlock) ; + pVolume->m_InterBlockOriginalSharpTria.resize( pVolume->m_nNumBlock) ; + pVolume->m_BlockSharpTria.resize( pVolume->m_nNumBlock) ; + pVolume->m_BlockSmoothTria.resize( pVolume->m_nNumBlock) ; + pVolume->m_BlockBigTria.resize( pVolume->m_nNumBlock) ; pVolume->m_SliceXY.resize( pVolume->m_nNumBlock) ; pVolume->m_SliceXZ.resize( pVolume->m_nNumBlock) ; pVolume->m_SliceYZ.resize( pVolume->m_nNumBlock) ; @@ -1147,7 +1158,7 @@ VolZmap::RemovePart( int nPart) // Elimino i segmenti con indice nPart + 1 e aggiorno quelli con indice superiore // Ciclo sulle mappe. - for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) { + for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) { // Ciclo sui dexel della mappa. for ( int nDex = 0 ; nDex < int( m_Values[nMap].size()) ; ++ nDex) { // Ciclo sugli intervalli del dexel. @@ -1155,8 +1166,8 @@ VolZmap::RemovePart( int nPart) // Se l'intervallo appartiene alla componente da eliminare, lo cancello. if ( m_Values[nMap][nDex][nInt].nCompo == nPart + 1) { SetToModifyDexelBlocks( nMap, nDex, nInt) ; - m_Values[nMap][nDex].erase( m_Values[nMap][nDex].begin() + nInt) ; - -- nInt ; + m_Values[nMap][nDex].erase( m_Values[nMap][nDex].begin() + nInt) ; + -- nInt ; } else if ( m_Values[nMap][nDex][nInt].nCompo > nPart + 1) m_Values[nMap][nDex][nInt].nCompo -= 1 ; @@ -1240,7 +1251,7 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt) } } - else if ( nGrid == 1) { + else if ( nGrid == 1) { int nYStop = 1 ; int nZStop = 1 ; @@ -1577,26 +1588,27 @@ VolZmap::Compact( void) } // 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) ; + int nVoxNumX = m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumY = m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ; // Definisco il numero di blocchi lungo x,y e z - m_nFracLin[0] = max( 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)) ; - m_nFracLin[2] = max( 1u, nVoxNumZ / m_nVoxNumPerBlock + ( nVoxNumZ % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; + m_nFracLin[0] = max( 1, nVoxNumX / m_nVoxNumPerBlock + ( nVoxNumX % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; + m_nFracLin[1] = max( 1, nVoxNumY / m_nVoxNumPerBlock + ( nVoxNumY % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; + m_nFracLin[2] = max( 1, nVoxNumZ / m_nVoxNumPerBlock + ( nVoxNumZ % m_nVoxNumPerBlock >= m_nVoxNumPerBlock / 2 ? 1 : 0)) ; // Dimensiono il vettore dei blocchi m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ; - m_BlockToUpdate.resize( m_nNumBlock) ; - // Setto tutti i blocchi come da aggiornare per la grafica - for ( int nCount = 0 ; nCount < int( m_nNumBlock) ; ++ nCount) - m_BlockToUpdate[nCount] = true ; - + m_BlockToUpdate.resize( m_nNumBlock, true) ; + // Dimensiono il vettore dei contatori di aggiornamenti dei blocchi + m_BlockUpGradingCounter.resize( m_nNumBlock, 0) ; // Dimensiono raccolta di voxel di confine m_InterBlockVox.resize( m_nNumBlock) ; // Dimensiono raccolta triangoli di feature tra blocchi - m_InterBlockTria.resize( m_nNumBlock) ; + m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ; + m_BlockSharpTria.resize( m_nNumBlock) ; + m_BlockSmoothTria.resize( m_nNumBlock) ; + m_BlockBigTria.resize( m_nNumBlock) ; m_SliceXY.resize( m_nNumBlock) ; m_SliceXZ.resize( m_nNumBlock) ; m_SliceYZ.resize( m_nNumBlock) ; diff --git a/VolZmap.h b/VolZmap.h index db9d809..49d8aed 100644 --- a/VolZmap.h +++ b/VolZmap.h @@ -1,7 +1,7 @@ //---------------------------------------------------------------------------- -// EgalTech 2015-2015 +// EgalTech 2015-2019 //---------------------------------------------------------------------------- -// File : VolZmap.h Data : 22.01.15 Versione : 1.6a4 +// File : VolZmap.h Data : 11.02.19 Versione : 2.1b1 // Contenuto : Dichiarazione della classe Volume Zmap. // // @@ -84,12 +84,12 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const override ; bool SetTolerances( double dLinTol, double dAngTolDeg = 90) override ; bool SetStdTool( const std::string& sToolName, double dH, double dR, double dCornR, int nFlag) override ; - bool SetAdvTool( const std::string& sToolName, - double dH, double dR, double dTipH, double dTipR, double dCornR, int nFlag) override ; + bool SetAdvTool( const std::string& sToolName, + double dH, double dR, double dTipH, double dTipR, double dCornR, int nFlag) override ; bool SetSawTool( const std::string& sToolName, double dH, double dR, double dThick, double dStemR, double dCornR, int nFlag) override ; bool SetGenTool( const std::string& sToolName, const ICurveComposite* pToolOutline, int nFlag) override ; - bool SetMortiserTool( const std::string& sToolName, double dH, double dW, double dTh, double dRc, int nFlag) override ; + bool SetMortiserTool( const std::string& sToolName, double dH, double dW, double dTh, double dRc, int nFlag) override ; bool SetChiselTool( const std::string& sToolName, double dH, double dW, double dTh, int nFlag) override ; const ICurveComposite& GetToolOutline( bool bApprox = false) const override { return ( bApprox ? m_Tool.GetApproxOutline() : m_Tool.GetOutline()) ;} @@ -108,6 +108,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool Cut( const Plane3d& plPlane) override ; bool Compact( void) override ; + public : // IGeoObjRW int GetNgeId( void) const override ; bool Save( NgeWriter& ngeOut) const override ; @@ -123,7 +124,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW LOG_ERROR( GetEGkLogger(), "VolZmap : copy error") return *this ; } - private : + private : enum CubeType { VOX_EXTERN = 1, VOX_ON_BOUNDARY = 0, VOX_INNER = -1} ; @@ -136,8 +137,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW } ; typedef std::unordered_map FlatVoxelContainer ; // Struttura indici di voxel - struct VoxelIndexes { - int nI, nJ, nK ; + struct VoxelIndexes { + int nI, nJ, nK ; } ; // Struttura per componenti connesse struct ConComp { @@ -154,17 +155,26 @@ class VolZmap : public IVolZmap, public IGeoObjRW int nNumComp ; ConComp Compo[4] ; } ; - // Triangoli - struct TriaStruct { + // Triangoli sharp-feature + struct SharpTriaStruct { int i, j, k ; PNTVECTOR ptCompoVert ; std::vector vCompoTria ; std::vector vbFlipped ; } ; - // Vettore di TriaStruct con sharp feature interni a un blocco - typedef std::vector TriHolder ; - // Vettore di TriHolder con sharp feature di frontiera: il primo indice individua il blocco, il secondo il voxel - typedef std::vector TriaMatrix ; + // Triangoli smooth + struct SmoothTriaStruct { + int i, j, k ; + TRIA3DEXVECTOR vTria ; + }; + // Vettore di SharpTriaStruct con sharp feature + typedef std::vector SharpTriHolder ; + // Vettore di SmoothTriaStruct con triangoli smooth + typedef std::vector SmoothTriHolder ; + // Vettore di SharpTriHolder con sharp feature: il primo indice individua il blocco, il secondo il voxel + typedef std::vector SharpTriaMatrix ; + // Vettore di SmoothTriHolder smooth: il primo indice individua il blocco, il secondo il voxel + typedef std::vector SmoothTriaMatrix ; // Tavola hash di Voxel typedef std::unordered_map VoxelContainer ; // Unordered map per la coerenza topologica @@ -173,121 +183,122 @@ class VolZmap : public IVolZmap, public IGeoObjRW private : bool CopyFrom( const VolZmap& clSrc) ; bool ResetGraphics( void) ; - bool GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk, TRIA3DEXLIST& lstTria) const ; - bool CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DEXLIST& lstTria) const ; - bool CalcDexelPrisms( int nPos1, int nPos2, TRIA3DEXLIST& lstTria) const ; + bool GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk, int nBlock) const ; + bool CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nBlock) const ; + bool CalcDexelPrisms( int nPos1, int nPos2, int nBlock) const ; bool AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Point3d& ptQ, - const Vector3d& vtZ, const Vector3d& vtNorm, TRIA3DEXLIST& lstTria) const ; - bool ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, VoxelContainer& VoxCont, bool bEnh) const ; + const Vector3d& vtZ, const Vector3d& vtNorm, int nBlock) const ; bool ProcessCell( int nGrid, int nCellI, int nCellJ, const Plane3d& plPlane, std::vector& vLine) const ; - bool ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vVox) const ; - bool ExtMarchingCubes( std::vector& vVox, TRIA3DEXLIST& lstTria, bool bEnh) const ; + bool UpGradeGraphics( bool bAllBlocks, INTVECTOR& nModifiedBlocks) const ; + bool UpGradeGraphicsSingleMap( bool bAllBlocks, INTVECTOR& nModifiedBlocks) const ; + bool ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const ; bool RegulateFeaturesChain( std::vector& vVecVox) const ; - bool CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVox, TriHolder& triHold) const ; - bool CreateSharpFeatureTriangle( const VoxelContainer& vVox, TriHolder& triHold) const ; - bool FlipEdgesII( TriHolder& TriHold) const ; - bool FlipEdgesBB( TriaMatrix& InterTria) const ; + bool CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVox) const ; + bool CreateSharpFeatureTriangle( const VoxelContainer& vVox, SharpTriHolder& triHold) const ; + bool CreateSmoothTriangle( int nIndex, int nVertNum, AppliedVector TriVert[], bool bWasSharp, SmoothTriaStruct& VoxSmoothTria) const ; + bool FlipEdgesII( int nBlock) const ; + bool FlipEdgesBB() const ; bool IsThereMat( int nI, int nJ, int nK) const ; bool InOut( const Plane3d& plPlane, int nGrid, int nI, int nJ) const ; int CalcIndex( int nI, int nJ, int nK) const ; - int CalcIndexForPlaneCells( const Plane3d& plPlane, int nGrid, int nCellI, int nCellJ) const ; + int CalcIndexForPlaneCells( const Plane3d& plPlane, int nGrid, int nCellI, int nCellJ) const ; bool IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, AppliedVector& vfField) 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 ; bool IsZInsideInterval( int nGrid, int nDex, double dZ) const ; - // Per regolarizzazione della catena di feature + // Per regolarizzazione della catena di feature bool FindAdjComp( const std::vector& vVecVox, int nCurBlock, int nCurVox, int nCurComp, INTVECTOR& vAdjBlockVoxComp, INTVECTOR& vAdjBordBlockVoxComp) const ; // OPERAZIONI SU INTERVALLI - bool SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, + bool SubtractIntervals( int nGrid, int nI, int nJ, double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) ; - bool AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, + bool AddIntervals( int nGrid, int nI, int nJ, double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) ; // SOTTRAZIONI // UTENSILI // Asse di simmetria parallelo a Z - bool CylBall_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool CylBall_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Conus_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Conus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Mrt_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; - bool Mrt_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; - bool Chs_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; - bool Chs_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; - bool GenTool_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool GenTool_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool CylBall_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool CylBall_ZPerp( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool CylBall_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Conus_ZDrilling( int nGrid, const Point3d & ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Conus_ZPerp( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Conus_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Mrt_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; + bool Mrt_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; + bool Chs_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; + bool Chs_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; + bool GenTool_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool GenTool_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; // Asse di simmetria nel piano - bool CylBall_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool CylBall_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool CylBall_XYMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Conus_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Conus_XYMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool CylBall_XYDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool CylBall_XYPerp( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool CylBall_XYMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Conus_XYDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Conus_XYPerp( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Conus_XYMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; // Asse di simmetria con orientazione generica - bool CylBall_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool CylBall_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Conus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Conus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool Mrt_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; - bool Mrt_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; // E' in realtà un Perp - bool Chs_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; - bool Chs_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; // E' in realtà un Perp - bool GenTool_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool GenTool_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool CylBall_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool CylBall_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Conus_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Conus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool Mrt_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; + bool Mrt_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; // E' in realtà un Perp + bool Chs_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; + bool Chs_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; // E' in realtà un Perp + bool GenTool_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; + bool GenTool_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; // COMPONENTI // Asse di simmetria diretto come l'asse Z - bool CompCyl_ZDrilling( unsigned int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir, + bool CompCyl_ZDrilling( int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir, double dHei, double dRad) ; - bool CompConus_ZDrilling( unsigned int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir, + bool CompConus_ZDrilling( int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) ; - bool CompPar_ZDrilling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ, + bool CompPar_ZDrilling( int nGrid, double dLenX, double dLenY, double dLenZ, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; - bool CompCyl_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, + bool CompCyl_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad) ; - bool CompConus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, + bool CompConus_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) ; - bool CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ, + bool CompPar_ZMilling( int nGrid, double dLenX, double dLenY, double dLenZ, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; // E' in realtà MillingPerp // Asse di simmetria con orientazione generica - bool CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, + bool CompCyl_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad, bool bTapB, bool bTapT) ; - bool CompConus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, + bool CompConus_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad, bool bTapB, bool bTapT) ; - bool CompPar_Drilling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ, + bool CompPar_Drilling( int nGrid, double dLenX, double dLenY, double dLenZ, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; - bool CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, + bool CompCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad, bool bTapB, bool bTapT) ; - bool CompConus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, + bool CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad, bool bTapB, bool bTapT) ; - bool CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ, + bool CompPar_Milling( int nGrid, double dLenX, double dLenY, double dLenZ, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ; // E' in realtà MillingPerp // Generica traslazione sfera - bool CompBall_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, double dRad) ; + bool CompBall_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, double dRad) ; // BBox per utensili e solidi semplici con movimenti di traslazione - inline bool TestToolBBox( unsigned int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, - unsigned int& nStI, unsigned int& nStJ, unsigned int& nEnI, unsigned int& nEnJ) ; - inline bool TestCompoBBox( unsigned int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, + inline bool TestToolBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, + int& nStI, int& nStJ, int& nEnI, int& nEnJ) ; + inline bool TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, double dRad, double dTipRad, double dHei, - unsigned int& nStI, unsigned int& nStJ, unsigned int& nEnI, unsigned int& nEnJ) ; - inline bool TestParaBBox( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtD, const Vector3d& vtA, + int& nStI, int& nStJ, int& nEnI, int& nEnJ) ; + inline bool TestParaBBox( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtD, const Vector3d& vtA, double dLenX, double dLenY, double dLenZ, - unsigned int& nStI, unsigned int& nStJ, unsigned int& nEnI, unsigned int& nEnJ) ; + int& nStI, int& nStJ, int& nEnI, int& nEnJ) ; // Intersezioni bool IntersLineBox( const Point3d& ptP, const Vector3d& vtV, const Point3d& ptMin, const Point3d& ptMax) const ; bool IntersLineBox( const Point3d& ptP, const Vector3d& vtV, const Point3d& ptMin, const Point3d& ptMax, double& dU1, double& dU2) const ; bool IntersLineZMapLattice( const Point3d& ptP, const Vector3d& vtV, double& dU1, double& dU2) const ; bool IntersLineZMapBBox( const Point3d& ptP, const Vector3d& vtV, double& dU1, double& dU2) const ; - bool IntersLineDexel( const Point3d& ptP, const Vector3d& vtV, unsigned int nGrid, unsigned int nI, unsigned int nJ, + bool IntersLineDexel( const Point3d& ptP, const Vector3d& vtV, int nGrid, int nI, int nJ, double& dU1, double& dU2) const ; - bool IntersRayDexel( const Point3d& ptP, const Vector3d& vtV, unsigned int nGrid, unsigned int nI, unsigned int nJ, + bool IntersRayDexel( const Point3d& ptP, const Vector3d& vtV, int nGrid, int nI, int nJ, double& dU1, double& dU2) const ; bool IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir, const Frame3d& CylFrame, double dH, double dRad, bool bTapLow, bool bTapUp, @@ -301,11 +312,11 @@ class VolZmap : public IVolZmap, public IGeoObjRW Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) ; bool IntersLineMyPolyhedron( const Point3d& ptLineSt, const Vector3d& vtLineDir, const Frame3d& PolyFrame, double dLenX, double dLenY, double dLenZ, double dDeltaX, - Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) ; + Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) ; bool TestIntersPlaneZmapBBox( const Plane3d& plPlane) const ; // Voxel: esistenza e passaggio da N a ijk per i voxel bool IsValidVoxel( int nN) const ; - bool IsValidVoxel( int nI, int nJ, int nK) const ; + bool IsValidVoxel( int nI, int nJ, int nK) const ; bool GetVoxIJKFromN( int nN, int& nI, int& nJ, int& nK) const ; bool GetVoxNFromIJK( int nI, int nJ, int nK, int& nN) const ; // Funzioni di gestione dei blocchi @@ -320,18 +331,18 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool GetFirstVoxIJK( int& i, int& j, int& k) const ; bool GetLastVoxIJK( int& i, int& j, int& k) const ; bool IsVoxelOnBoxEdge( int i, int j, int k) const ; - bool IsTriangleOnBorder( const Triangle3dEx& trTria, const int nBlockLimits[], const int nVoxIJK[]) const ; + bool IsTriangleOnBorder( const Triangle3dEx& trTria, const int nBlockLimits[], const int nVoxIJK[]) const ; // Funzioni per facce canoniche con grandi triangoli - bool ProcessVoxContXY( FlatVoxelContainer& VoxContXY, bool bPlus, TRIA3DEXLIST& lstTria) const ; - bool ProcessVoxContYZ( FlatVoxelContainer& VoxContYZ, bool bPlus, TRIA3DEXLIST& lstTria) const ; - bool ProcessVoxContXZ( FlatVoxelContainer& VoxContXZ, bool bPlus, TRIA3DEXLIST& lstTria) const ; + bool ProcessVoxContXY( FlatVoxelContainer& VoxContXY, int nBlock, bool bPlus) const ; + bool ProcessVoxContYZ( FlatVoxelContainer& VoxContYZ, int nBlock, bool bPlus) const ; + bool ProcessVoxContXZ( FlatVoxelContainer& VoxContXZ, int nBlock, bool bPlus) const ; bool Find( const FlatVoxelContainer& VoxCont, int nI, int nJ, int nK, double dPos, int nTool) const ; bool Remove( FlatVoxelContainer& VoxCont, int nI, int nJ, int nK) const ; // Connessione Zmap struct IntervalIndexes { - size_t tMap ; - size_t tDex ; - size_t tInt ; + int tMap ; + int tDex ; + int tInt ; } ; typedef std::stack IntContaier ; bool CheckMapConnection( void) ; @@ -350,13 +361,13 @@ class VolZmap : public IVolZmap, public IGeoObjRW private : ObjGraphicsMgr m_OGrMgr ; // gestore grafica dell'oggetto Status m_nStatus ; // stato - int m_nTempProp ; // proprietà temporanea + int m_nTempProp ; // proprietà temporanea double m_dStep ; // passo delle griglie - unsigned int m_nMapNum ; // numero di griglie ( 1 o 3) + int m_nMapNum ; // numero di griglie ( 1 o 3) Frame3d m_MapFrame ; // riferimento intrinseco dello Zmap - unsigned int m_nNx[N_MAPS] ; // dimensione di ciascuna griglia in X - unsigned int m_nNy[N_MAPS] ; // dimensione di ciascuna griglia in Y - unsigned int m_nDim[N_MAPS] ; // dimensione di ciascuna griglia ( X * Y) + int m_nNx[N_MAPS] ; // dimensione di ciascuna griglia in X + int m_nNy[N_MAPS] ; // dimensione di ciascuna griglia in Y + int m_nDim[N_MAPS] ; // dimensione di ciascuna griglia ( X * Y) double m_dMinZ[N_MAPS] ; // minimo in Zlocale di ciascuna griglia double m_dMaxZ[N_MAPS] ; // massimo in Zlocale di ciascuna griglia @@ -373,17 +384,23 @@ class VolZmap : public IVolZmap, public IGeoObjRW int m_nShape ; // Forma : 0 generica, 1 box, 2 estrusione - 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 + int m_nVoxNumPerBlock ; // Numero di voxel per blocco + int m_nFracLin[3] ; // Numero di blocchi per ogni asse + int m_nNumBlock ; // Numero totale di blocchi mutable BOOLVECTOR m_BlockToUpdate ; + mutable INTVECTOR m_BlockUpGradingCounter ; int m_nConnectedCompoCount ; // Se == - 1 il numero di componenti non è noto // Se >= 0 è il numero di componenti connesse - mutable std::vector m_InterBlockVox ; - mutable TriaMatrix m_InterBlockTria ; + mutable std::vector m_InterBlockVox ; + mutable SharpTriaMatrix m_InterBlockOriginalSharpTria ; + mutable SharpTriaMatrix m_InterBlockToBeFlippedSharpTria ; + mutable SharpTriaMatrix m_BlockSharpTria ; + mutable SmoothTriaMatrix m_BlockSmoothTria ; + mutable std::vector m_BlockBigTria ; + mutable std::vector m_SingleMapTria ; mutable std::vector m_SliceXY ; mutable std::vector m_SliceXZ ; @@ -408,5 +425,3 @@ inline VolZmap* GetBasicVolZmap( IGeoObj* pGObj) { if ( pGObj == nullptr || pGObj->GetType() != VOL_ZMAP) return nullptr ; return (static_cast(pGObj)) ; } - - diff --git a/VolZmapCalculus.cpp b/VolZmapCalculus.cpp index 395d286..6822448 100644 --- a/VolZmapCalculus.cpp +++ b/VolZmapCalculus.cpp @@ -16,11 +16,11 @@ #include "CurveLine.h" #include "VolZmap.h" #include "GeoConst.h" -#include "/EgtDev/Include/EgtNumUtils.h" #include "/EgtDev/Include/EGkIntersLineTria.h" #include "/EgtDev/Include/EGkIntersLinePlane.h" #include "/EgtDev/Include/EGkIntersLineSphere.h" #include "/EgtDev/Include/EGkChainCurves.h" +#include "/EgtDev/Include/EgtNumUtils.h" using namespace std ; @@ -122,12 +122,12 @@ VolZmap::IntersLineZMapBBox( const Point3d& ptP, const Vector3d& vtV, double& dU // con quello intrinseco dello Zmap solo nel caso della prima griglia. Per le altre griglie // è necessario permutare ciclicamente le coordinate. bool -VolZmap::IntersLineDexel( const Point3d& ptP, const Vector3d& vtV, unsigned int nGrid, unsigned int nI, unsigned int nJ, +VolZmap::IntersLineDexel( const Point3d& ptP, const Vector3d& vtV, int nGrid, int nI, int nJ, double& dU1, double& dU2) const { // Determino l'indice del dexel e il numero di suoi intervalli - unsigned int nDexelPos = nJ * m_nNx[nGrid] + nI ; - unsigned int nDexelSize = unsigned int( m_Values[nGrid][nDexelPos].size()) ; + int nDexelPos = nJ * m_nNx[nGrid] + nI ; + int nDexelSize = int( m_Values[nGrid][nDexelPos].size()) ; // Se non c'è materiale non devo fare alcunché if ( nDexelSize == 0) @@ -143,7 +143,7 @@ VolZmap::IntersLineDexel( const Point3d& ptP, const Vector3d& vtV, unsigned int dU1 = INFINITO ; dU2 = - INFINITO ; bool bInters = false ; - for ( unsigned int nIndex = 0 ; nIndex < nDexelSize ; nIndex += 1) { + for ( int nIndex = 0 ; nIndex < nDexelSize ; nIndex += 1) { // estremi del box del singolo intervallo Point3d ptE1( dXmin, dYmin, m_Values[nGrid][nDexelPos][nIndex].dMin) ; Point3d ptE2( dXmax, dYmax, m_Values[nGrid][nDexelPos][nIndex].dMax) ; @@ -164,12 +164,12 @@ VolZmap::IntersLineDexel( const Point3d& ptP, const Vector3d& vtV, unsigned int // con quello intrinseco dello Zmap solo nel caso della prima griglia. Per le altre griglie // è necessario permutare ciclicamente le coordinate. bool -VolZmap::IntersRayDexel( const Point3d& ptP, const Vector3d& vtV, unsigned int nGrid, unsigned int nI, unsigned int nJ, +VolZmap::IntersRayDexel( const Point3d& ptP, const Vector3d& vtV, int nGrid, int nI, int nJ, double& dU1, double& dU2) const { // Determino l'indice del dexel e il numero di suoi intervalli - unsigned int nDexelPos = nJ * m_nNx[nGrid] + nI ; - unsigned int nDexelSize = unsigned int( m_Values[nGrid][nDexelPos].size()) ; + int nDexelPos = nJ * m_nNx[nGrid] + nI ; + int nDexelSize = int( m_Values[nGrid][nDexelPos].size()) ; // Se non c'è materiale non devo fare alcunché if ( nDexelSize == 0) @@ -185,7 +185,7 @@ VolZmap::IntersRayDexel( const Point3d& ptP, const Vector3d& vtV, unsigned int n dU1 = INFINITO ; dU2 = - INFINITO ; bool bInters = false ; - for ( unsigned int nIndex = 0 ; nIndex < nDexelSize ; nIndex += 1) { + for ( int nIndex = 0 ; nIndex < nDexelSize ; nIndex += 1) { // estremi del box del singolo intervallo Point3d ptE1( dXmin, dYmin, m_Values[nGrid][nDexelPos][nIndex].dMin) ; Point3d ptE2( dXmax, dYmax, m_Values[nGrid][nDexelPos][nIndex].dMax) ; @@ -391,6 +391,13 @@ VolZmap::GetDepthWithDexel( const Point3d& ptP, const Vector3d& vtV, double& dIn bool VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dInLength, double& dOutLength, bool bEnh) const { + // Serve che punto e vettore siano espressi sia nel sistema intrinseco dello Zmap (m_MapFrame) sia in quello + // in cui esso è immerso; questo perché i dexel sono espressi in quello intrinseco e i triangoli in quello + // in cui esso è immerso. + Point3d ptOutP = ptP ; + Vector3d vtOutD = vtD ; + ptOutP.ToGlob( m_MapFrame) ; + vtOutD.ToGlob( m_MapFrame) ; // Intersezione fra semiretta e BBox dello Zmap double dU1, dU2 ; bool bLineBBoxInters = IntersLineZMapBBox( ptP, vtD, dU1, dU2) && ( dU1 > 0 || dU2 > 0) ; @@ -402,6 +409,15 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn return true ; } + // Se la grafica non è aggiornata la ricalcolo + bool bUpGrade = false ; + for ( int nBl = 0 ; nBl < int( m_nNumBlock) ; ++ nBl) { + bUpGrade = bUpGrade || m_BlockToUpdate[nBl] ; + } + INTVECTOR nModifiedBlocks ; + if ( bUpGrade) + UpGradeGraphics( false, nModifiedBlocks) ; + // Determino il voxel di partenza int nVoxI, nVoxJ, nVoxK ; if ( ! GetPointVoxel( ptP, nVoxI, nVoxJ, nVoxK)) { @@ -429,12 +445,15 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn ( ( 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)) { - VoxelIndexes NewVox ; - NewVox.nI = nVoxI ; - NewVox.nJ = nVoxJ ; - NewVox.nK = nVoxK ; - vVox.emplace_back( NewVox) ; + if ( IntersLineBox( ptP, vtD, ptMin, ptMax)) { + int nCurVoxIndex = CalcIndex( nVoxI, nVoxJ, nVoxK) ; + if ( nCurVoxIndex != 0 && nCurVoxIndex != 255) { + VoxelIndexes NewVox ; + NewVox.nI = nVoxI ; + NewVox.nJ = nVoxJ ; + NewVox.nK = nVoxK ; + vVox.emplace_back( NewVox) ; + } } // Interseco la retta con i piani frontiera del voxel double dMaxTX = ( abs( vtD.x) > EPS_ZERO ? @@ -458,10 +477,6 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn } } - // Triangoli di frontiera dei voxel - TRIA3DEXLIST lstTria ; - ExtMarchingCubes( vVox, lstTria, bEnh) ; - // Dati dell'intersezione struct LineTriaInt { int nNum ; @@ -474,31 +489,157 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn : nNum( 2), dPar1( dP1), dPar2( dP2), dDot( dD) {} } ; vector vInt ; - - // Ciclo sui triangoli dei voxel - for ( auto it = lstTria.begin() ; it != lstTria.end() ; ++it ) { - // Triangolo corrente e suoi punti di intersezione con la retta - const Triangle3d& CurrTria = *it ; - Point3d ptLineTria1, ptLineTria2 ; - // Studio dell'intersezione della retta con il triangolo corrente - int nIntType = IntersLineTria( ptP, vtD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ; - // Se non ci sono intersezioni passo al prossimo triangolo - if ( nIntType == ILTT_NO) - continue ; - // se altrimenti c'è una sola intersezione - else if ( nIntType == ILTT_VERT || - nIntType == ILTT_EDGE || - nIntType == ILTT_IN) { - vInt.emplace_back( ( ptLineTria1 - ptP) * vtD, vtD * CurrTria.GetN()) ; - } - // altrimenti ci sono due intersezioni - else { - double dP1 = ( ptLineTria1 - ptP) * vtD ; - double dP2 = ( ptLineTria2 - ptP) * vtD ; - double dD = vtD * CurrTria.GetN() ; - vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ; + int nPrevBlockN = - 1 ; + // Ciclo sui voxel + for ( int nVx = 0 ; nVx < int( vVox.size()) ; ++ nVx) { + int nCurVoxIJK[3] = { vVox[nVx].nI, vVox[nVx].nJ, vVox[nVx].nK} ; + int nCurBlockIJK[3] ; + if ( GetVoxelBlockIJK( nCurVoxIJK, nCurBlockIJK)) { + int nCurBlockN ; + GetBlockNFromIJK( nCurBlockIJK, nCurBlockN) ; + // Triangoli sharp fra blocchi + for ( int nBlVx = 0 ; nBlVx < int( m_InterBlockToBeFlippedSharpTria[nCurBlockN].size()) ; ++ nBlVx) { + if ( m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] && + m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] && + m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) { + for ( int nBlCm = 0 ; nBlCm < int( m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].vCompoTria.size()) ; ++ nBlCm) { + for ( int nBlTr = 0 ; nBlTr < int( m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm].size()) ; ++ nBlTr) { + Triangle3d CurrTria = m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm][nBlTr] ; + Point3d ptLineTria1, ptLineTria2 ; + // Studio dell'intersezione della retta con il triangolo corrente + int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ; + // Se non ci sono intersezioni passo al prossimo triangolo + if ( nIntType == ILTT_NO) + continue ; + // se altrimenti c'è una sola intersezione + else if ( nIntType == ILTT_VERT || + nIntType == ILTT_EDGE || + nIntType == ILTT_IN) { + vInt.emplace_back( ( ptLineTria1 - ptOutP) * vtOutD, vtOutD * CurrTria.GetN()) ; + } + // altrimenti ci sono due intersezioni + else { + double dP1 = ( ptLineTria1 - ptOutP) * vtOutD ; + double dP2 = ( ptLineTria2 - ptOutP) * vtOutD ; + double dD = vtOutD * CurrTria.GetN() ; + vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ; + } + } + } + } + } + // Triangoli sharp interni + for ( int nBlVx = 0 ; nBlVx < int( m_BlockSharpTria[nCurBlockN].size()) ; ++ nBlVx) { + if ( m_BlockSharpTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] && + m_BlockSharpTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] && + m_BlockSharpTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) { + for ( int nBlCm = 0 ; nBlCm < int( m_BlockSharpTria[nCurBlockN][nBlVx].vCompoTria.size()) ; ++ nBlCm) { + for ( int nBlTr = 0 ; nBlTr < int( m_BlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm].size()) ; ++ nBlTr) { + Triangle3d CurrTria = m_BlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm][nBlTr] ; + Point3d ptLineTria1, ptLineTria2 ; + // Studio dell'intersezione della retta con il triangolo corrente + int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ; + // Se non ci sono intersezioni passo al prossimo triangolo + if ( nIntType == ILTT_NO) + continue ; + // se altrimenti c'è una sola intersezione + else if ( nIntType == ILTT_VERT || + nIntType == ILTT_EDGE || + nIntType == ILTT_IN) { + vInt.emplace_back( ( ptLineTria1 - ptOutP) * vtOutD, vtOutD * CurrTria.GetN()) ; + } + // altrimenti ci sono due intersezioni + else { + double dP1 = ( ptLineTria1 - ptOutP) * vtOutD ; + double dP2 = ( ptLineTria2 - ptOutP) * vtOutD ; + double dD = vtOutD * CurrTria.GetN() ; + vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ; + } + } + } + } + } + // Triangoli smooth + for ( int nBlVx = 0 ; nBlVx < int( m_BlockSmoothTria[nCurBlockN].size()) ; ++ nBlVx) { + if ( m_BlockSmoothTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] && + m_BlockSmoothTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] && + m_BlockSmoothTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) { + for ( int nBlTr = 0 ; nBlTr < int( m_BlockSmoothTria[nCurBlockN][nBlVx].vTria.size()) ; ++ nBlTr) { + Triangle3d CurrTria = m_BlockSmoothTria[nCurBlockN][nBlVx].vTria[nBlTr] ; + Point3d ptLineTria1, ptLineTria2 ; + // Studio dell'intersezione della retta con il triangolo corrente + int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ; + // Se non ci sono intersezioni passo al prossimo triangolo + if ( nIntType == ILTT_NO) + continue ; + // se altrimenti c'è una sola intersezione + else if ( nIntType == ILTT_VERT || + nIntType == ILTT_EDGE || + nIntType == ILTT_IN) { + vInt.emplace_back( ( ptLineTria1 - ptOutP) * vtOutD, vtOutD * CurrTria.GetN()) ; + } + // altrimenti ci sono due intersezioni + else { + double dP1 = ( ptLineTria1 - ptOutP) * vtOutD ; + double dP2 = ( ptLineTria2 - ptOutP) * vtOutD ; + double dD = vtOutD * CurrTria.GetN() ; + vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ; + } + } + } + } + // Triangoli grandi + if ( nCurBlockN != nPrevBlockN) { + for ( int nBlTr = 0 ; nBlTr < int( m_BlockBigTria[nCurBlockN].size()) ; ++ nBlTr) { + Triangle3d CurrTria = m_BlockBigTria[nCurBlockN][nBlTr] ; + Point3d ptLineTria1, ptLineTria2 ; + // Studio dell'intersezione della retta con il triangolo corrente + int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ; + // Se non ci sono intersezioni passo al prossimo triangolo + if ( nIntType == ILTT_NO) + continue ; + // se altrimenti c'è una sola intersezione + else if ( nIntType == ILTT_VERT || + nIntType == ILTT_EDGE || + nIntType == ILTT_IN) { + vInt.emplace_back( ( ptLineTria1 - ptOutP) * vtOutD, vtOutD * CurrTria.GetN()) ; + } + // altrimenti ci sono due intersezioni + else { + double dP1 = ( ptLineTria1 - ptOutP) * vtOutD ; + double dP2 = ( ptLineTria2 - ptOutP) * vtOutD ; + double dD = vtOutD * CurrTria.GetN() ; + vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ; + } + } + nPrevBlockN = nCurBlockN ; + } } } + // Ciclo sui triangoli dei voxel + //for ( auto it = lstTria.begin() ; it != lstTria.end() ; ++it ) { + // // Triangolo corrente e suoi punti di intersezione con la retta + // const Triangle3d& CurrTria = *it ; + // Point3d ptLineTria1, ptLineTria2 ; + // // Studio dell'intersezione della retta con il triangolo corrente + // int nIntType = IntersLineTria( ptP, vtD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ; + // // Se non ci sono intersezioni passo al prossimo triangolo + // if ( nIntType == ILTT_NO) + // continue ; + // // se altrimenti c'è una sola intersezione + // else if ( nIntType == ILTT_VERT || + // nIntType == ILTT_EDGE || + // nIntType == ILTT_IN) { + // vInt.emplace_back( ( ptLineTria1 - ptP) * vtD, vtD * CurrTria.GetN()) ; + // } + // // altrimenti ci sono due intersezioni + // else { + // double dP1 = ( ptLineTria1 - ptP) * vtD ; + // double dP2 = ( ptLineTria2 - ptP) * vtD ; + // double dD = vtD * CurrTria.GetN() ; + // vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ; + // } + //} // Ordino le intersezioni in base al parametro distanza con segno da ptP sort( vInt.begin(), vInt.end(), @@ -734,7 +875,7 @@ VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir, } // Determino le intersezioni con la superficie laterale del cilindro - DBLVECTOR vdCoef( 3) ; + DBLVECTOR vdCoef(3) ; double dSqRad = dRad * dRad ; vdCoef[0] = ptP.x * ptP.x + ptP.y * ptP.y - dSqRad ; vdCoef[1] = 2 * ( ptP.x * vtV.x + ptP.y * vtV.y) ; diff --git a/VolZmapCreation.cpp b/VolZmapCreation.cpp index 20b11a0..ee2970a 100644 --- a/VolZmapCreation.cpp +++ b/VolZmapCreation.cpp @@ -46,16 +46,16 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL m_MapFrame.Set( ptO, X_AX, Y_AX, Z_AX) ; // Definisco i vettori dei limiti su indici - m_nNx[0] = unsigned int( ( dLengthX + EPS_SMALL) / m_dStep + 0.5) ; - m_nNy[0] = unsigned int( ( dLengthY + EPS_SMALL) / m_dStep + 0.5) ; + m_nNx[0] = int( ( dLengthX + EPS_SMALL) / m_dStep + 0.5) ; + m_nNy[0] = int( ( dLengthY + EPS_SMALL) / m_dStep + 0.5) ; // Calcolo il numero di voxel lungo X e Y - 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) ; + int nVoxNumX = m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumY = m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; // Definisco il numero di blocchi lungo x e y - m_nFracLin[0] = max( 1u, unsigned int( nVoxNumX * 1.0 / m_nVoxNumPerBlock + 0.7)) ; - m_nFracLin[1] = max( 1u, unsigned int( nVoxNumY * 1.0 / m_nVoxNumPerBlock + 0.7)) ; + m_nFracLin[0] = max( 1, int( nVoxNumX * 1.0 / m_nVoxNumPerBlock + 0.7)) ; + m_nFracLin[1] = max( 1, int( nVoxNumY * 1.0 / m_nVoxNumPerBlock + 0.7)) ; // Numero di componenti connesse m_nConnectedCompoCount = 1 ; @@ -63,13 +63,13 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL // Se tridexel if ( bTriDex) { m_nNx[1] = m_nNy[0] ; - m_nNy[1] = unsigned int( ( dLengthZ + EPS_SMALL) / m_dStep + 0.5) ; + m_nNy[1] = int( ( dLengthZ + EPS_SMALL) / m_dStep + 0.5) ; m_nNx[2] = m_nNy[1] ; m_nNy[2] = m_nNx[0] ; // Calcolo il numero di voxel lungo Z - unsigned int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ; // Definisco il numero di blocchi lungo z - m_nFracLin[2] = max( 1u, unsigned int( nVoxNumZ * 1.0 / m_nVoxNumPerBlock + 0.7)) ; + m_nFracLin[2] = max( 1, int( nVoxNumZ * 1.0 / m_nVoxNumPerBlock + 0.7)) ; } // altrimenti mono dexel @@ -86,16 +86,16 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL // Creazione delle mappe // Calcolo del numero di celle per ogni mappa - for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) + for ( int i = 0 ; i < m_nMapNum ; ++ i) m_nDim[i] = m_nNx[i] * m_nNy[i] ; // Creazione delle celle per ogni mappa - for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) + for ( int i = 0 ; i < m_nMapNum ; ++ i) m_Values[i].resize( m_nDim[i]) ; // Riempimento delle celle - for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) - for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) { + for ( int i = 0 ; i < m_nMapNum ; ++ i) + for ( int j = 0 ; j < m_nDim[i] ; ++ j) { // Aggiungo il tratto al dexel vuoto m_Values[i][j].resize( 1) ; @@ -133,17 +133,24 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL m_dMinZ[2] = 0 ; m_dMaxZ[2] = ( bTriDex ? dLengthY : 0) ; - // Dimensiono e setto il vettore dei blocchi a da ricalcolare + // Dimensiono e setto il vettore dei blocchi a da ricalcolare e il vettore di contatori di aggiornamenti della grafica m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ; m_BlockToUpdate.clear() ; m_BlockToUpdate.resize( m_nNumBlock, true) ; + m_BlockUpGradingCounter.clear() ; + m_BlockUpGradingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ; // Tipologia m_nShape = BOX ; // Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel m_InterBlockVox.resize( m_nNumBlock) ; - m_InterBlockTria.resize( m_nNumBlock) ; + m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ; + m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ; + m_BlockSharpTria.resize( m_nNumBlock) ; + m_BlockSmoothTria.resize( m_nNumBlock) ; + m_BlockBigTria.resize( m_nNumBlock) ; + m_SingleMapTria.resize( m_nNumBlock) ; m_SliceXY.resize( m_nNumBlock) ; m_SliceXZ.resize( m_nNumBlock) ; m_SliceYZ.resize( m_nNumBlock) ; @@ -182,19 +189,19 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double // A partire dalle dimensioni di xy del grezzo determino il numero di colonne e righe // della griglia Zmap e da questi la dimensione del vettore di dexel - m_nNx[0] = unsigned int( ( dLengthX + EPS_SMALL) / m_dStep + 0.5) ; - m_nNy[0] = unsigned int( ( dLengthY + EPS_SMALL) / m_dStep + 0.5) ; + m_nNx[0] = int( ( dLengthX + EPS_SMALL) / m_dStep + 0.5) ; + m_nNy[0] = int( ( dLengthY + EPS_SMALL) / m_dStep + 0.5) ; m_nDim[0] = m_nNx[0] * m_nNy[0] ; // Ridimensiono il vettore di dexel e creo lo Zmap m_Values[0].resize( m_nDim[0]) ; // Calcolo il numero di voxel lungo X e Y - 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) ; + int nVoxNumX = m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumY = m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; // Definisco il numero di blocchi lungo x e y - m_nFracLin[0] = max( 1u, unsigned int( nVoxNumX * 1.0 / m_nVoxNumPerBlock + 0.7)) ; - m_nFracLin[1] = max( 1u, unsigned int( nVoxNumY * 1.0 / m_nVoxNumPerBlock + 0.7)) ; + m_nFracLin[0] = max( 1, int( nVoxNumX * 1.0 / m_nVoxNumPerBlock + 0.7)) ; + m_nFracLin[1] = max( 1, int( nVoxNumY * 1.0 / m_nVoxNumPerBlock + 0.7)) ; // Numero di componenti connesse m_nConnectedCompoCount = Surf.GetChunkCount() ; @@ -202,7 +209,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double // Se Tridexel ridimensiono anche gli altri vettori if ( bTriDex) { m_nNx[1] = m_nNy[0] ; - m_nNy[1] = unsigned int( ( dDimZ + EPS_SMALL) / m_dStep + 0.5) ; + m_nNy[1] = int( ( dDimZ + EPS_SMALL) / m_dStep + 0.5) ; m_nDim[1] = m_nNx[1] * m_nNy[1] ; m_Values[1].resize( m_nDim[1]) ; m_nNx[2] = m_nNy[1] ; @@ -210,9 +217,9 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double m_nDim[2] = m_nNx[2] * m_nNy[2] ; 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) ; + 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, unsigned int( nVoxNumZ * 1.0 / m_nVoxNumPerBlock + 0.7)) ; + m_nFracLin[2] = max( 1, int( nVoxNumZ * 1.0 / m_nVoxNumPerBlock + 0.7)) ; } else { @@ -242,7 +249,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double } // Calcolo griglia 0=XY ( se tridexel anche griglia 2=ZX) - for ( unsigned int i = 0 ; i < m_nNx[0] ; ++ i) { + for ( int i = 0 ; i < m_nNx[0] ; ++ i) { // Definisco la retta diretta come Y da intersecare con la regione double dX = ( i + 0.5) * m_dStep ; @@ -274,7 +281,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double int nFind = 0 ; int nCompo = 0 ; Vector3d vtN1 = - Y_AX ; Vector3d vtN2 = Y_AX ; - for ( size_t m = 0 ; m < vpCrvs.size() ; ++ m) { + for ( int m = 0 ; m < int( vpCrvs.size()) ; ++ m) { // recupero la curva ICurve* pCurve = vpCrvs[m] ; // determino posizione primo punto su curva @@ -326,9 +333,9 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double // Se tridexel riempio i singoli dexel della griglia 2 con gli intervalli if ( bTriDex) { - for ( size_t n = 0 ; n < m_nNx[2] ; ++ n) { - size_t nPos2 = i * m_nNx[2] + n ; - size_t nCurrSize = m_Values[2][nPos2].size( ) ; + for ( int n = 0 ; n < m_nNx[2] ; ++ n) { + int nPos2 = i * m_nNx[2] + n ; + int nCurrSize = int( m_Values[2][nPos2].size()) ; // Aggiungo un tratto al dexel m_Values[2][nPos2].resize( nCurrSize + 1) ; // Aggiorno i dati del tratto di dexel @@ -349,7 +356,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double if ( bTriDex) { // ciclo sul lato orizzontale della griglia - for ( unsigned int i = 0 ; i < m_nNx[1] ; ++ i) { + for ( int i = 0 ; i < m_nNx[1] ; ++ i) { // Definisco la retta diretta come X da intersecare con la regione double dY = ( i + 0.5) * m_dStep ; @@ -381,7 +388,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double int nFind = 0 ; int nCompo = 0 ; Vector3d vtN1 = -X_AX ; Vector3d vtN2 = X_AX ; - for ( size_t m = 0 ; m < vpCrvs.size() ; ++ m) { + for ( int m = 0 ; m < int( vpCrvs.size()) ; ++ m) { // recupero la curva ICurve* pCurve = vpCrvs[m] ; // determino posizione primo punto su curva @@ -413,9 +420,9 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double LOG_ERROR( GetEGkLogger(), "Error in VolZmap::CreateFromFlatRegion : point not on baundary") // aggiorno i dexel impilati - for ( size_t j = 0 ; j < m_nNy[1] ; ++ j) { - size_t nPos1 = j * m_nNx[1] + i ; - size_t nCurrSize = m_Values[1][nPos1].size() ; + for ( int j = 0 ; j < m_nNy[1] ; ++ j) { + int nPos1 = j * m_nNx[1] + i ; + int nCurrSize = int( m_Values[1][nPos1].size()) ; // Aggiungo un tratto al dexel m_Values[1][nPos1].resize( nCurrSize + 1) ; // Assegno i dati @@ -440,14 +447,21 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double m_dMinZ[2] = 0 ; m_dMaxZ[2] = ( bTriDex ? dLengthY : 0) ; - // Dimensiono e setto il vettore dei blocchi a da ricalcolare + // Dimensiono e setto il vettore dei blocchi a da ricalcolare e il vettore di contatori di aggiornamenti della grafica m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ; m_BlockToUpdate.clear() ; m_BlockToUpdate.resize( m_nNumBlock, true) ; + m_BlockUpGradingCounter.clear() ; + m_BlockUpGradingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ; // Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel m_InterBlockVox.resize( m_nNumBlock) ; - m_InterBlockTria.resize( m_nNumBlock) ; + m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ; + m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ; + m_BlockSharpTria.resize( m_nNumBlock) ; + m_BlockSmoothTria.resize( m_nNumBlock) ; + m_BlockBigTria.resize( m_nNumBlock) ; + m_SingleMapTria.resize( m_nNumBlock) ; m_SliceXY.resize( m_nNumBlock) ; m_SliceXZ.resize( m_nNumBlock) ; m_SliceYZ.resize( m_nNumBlock) ; @@ -495,17 +509,17 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex // A partire dalle dimensioni di xy del grezzo determino il numero di colonne e righe // della griglia Zmap e da questi la dimensione del vettore di dexel - m_nNx[0] = unsigned int( ( vtLen.x + EPS_SMALL) / m_dStep + 0.5) ; - m_nNy[0] = unsigned int( ( vtLen.y + EPS_SMALL) / m_dStep + 0.5) ; + m_nNx[0] = int( ( vtLen.x + EPS_SMALL) / m_dStep + 0.5) ; + m_nNy[0] = int( ( vtLen.y + EPS_SMALL) / m_dStep + 0.5) ; m_nDim[0] = m_nNx[0] * m_nNy[0] ; // Ridimensiono il vettore di dexel e creo lo Zmap m_Values[0].resize( m_nDim[0]) ; // Calcolo il numero di voxel lungo X e Y - 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) ; + int nVoxNumX = m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumY = m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; // Definisco il numero di blocchi lungo x e y - m_nFracLin[0] = max( 1u, unsigned int( nVoxNumX * 1.0 / m_nVoxNumPerBlock + 0.7)) ; - m_nFracLin[1] = max( 1u, unsigned int( nVoxNumY * 1.0 / m_nVoxNumPerBlock + 0.7)) ; + m_nFracLin[0] = max( 1, int( nVoxNumX * 1.0 / m_nVoxNumPerBlock + 0.7)) ; + m_nFracLin[1] = max( 1, int( nVoxNumY * 1.0 / m_nVoxNumPerBlock + 0.7)) ; // Numero di componenti connesse da calcolare m_nConnectedCompoCount = - 1 ; @@ -513,7 +527,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex // Se Tridexel ridimensiono anche gli altri vettori if ( bTriDex) { m_nNx[1] = m_nNy[0] ; - m_nNy[1] = unsigned int( ( vtLen.z + EPS_SMALL) / m_dStep + 0.5) ; + m_nNy[1] = int( ( vtLen.z + EPS_SMALL) / m_dStep + 0.5) ; m_nDim[1] = m_nNx[1] * m_nNy[1] ; m_Values[1].resize( m_nDim[1]) ; m_nNx[2] = m_nNy[1] ; @@ -521,9 +535,9 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex m_nDim[2] = m_nNx[2] * m_nNy[2] ; 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) ; + 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, unsigned int( nVoxNumZ * 1.0 / m_nVoxNumPerBlock + 0.7)) ; + m_nFracLin[2] = max( 1, int( nVoxNumZ * 1.0 / m_nVoxNumPerBlock + 0.7)) ; } else { @@ -538,7 +552,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex } // ciclo sulle griglie - for ( unsigned int g = 0 ; g < m_nMapNum ; ++ g) { + for ( int g = 0 ; g < m_nMapNum ; ++ g) { // Definisco dei sistemi di riferimento ausiliari Frame3d frMapFrame ; @@ -553,8 +567,8 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex IntersParLinesSurfTm intPLSTM( frMapFrame, Surf) ; // Determinazione e ridimensionamento dei dexel interni alla trimesh - for ( unsigned int i = 0 ; i < m_nNx[g] ; ++ i) { - for ( unsigned int j = 0 ; j < m_nNy[g] ; ++ j) { + for ( int i = 0 ; i < m_nNx[g] ; ++ i) { + for ( int j = 0 ; j < m_nNy[g] ; ++ j) { // Definisco la retta da intersecare con la trimesh double dX = ( i + 0.5) * m_dStep ; @@ -567,7 +581,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex int nInt = int( IntersectionResults.size()) ; - unsigned int nPos = j * m_nNx[g] + i ; + int nPos = j * m_nNx[g] + i ; bool bInside = false ; Point3d ptIn ; @@ -606,7 +620,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex Vector3d vtOutN ; Surf.GetFacetNormal( nF, vtOutN) ; - unsigned int nCurrentSize = unsigned int( m_Values[g][nPos].size()) ; + int nCurrentSize = int( m_Values[g][nPos].size()) ; // Aggiungo un tratto al dexel m_Values[g][nPos].resize( nCurrentSize + 1) ; @@ -636,14 +650,21 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex m_dMinZ[2] = 0 ; m_dMaxZ[2] = ( bTriDex ? vtLen.y : 0) ; - // Dimensiono e setto il vettore dei blocchi a da ricalcolare + // Dimensiono e setto il vettore dei blocchi a da ricalcolare e il vettore di contatori di aggiornamenti della grafica m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ; m_BlockToUpdate.clear() ; m_BlockToUpdate.resize( m_nNumBlock, true) ; + m_BlockUpGradingCounter.clear() ; + m_BlockUpGradingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ; // Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel m_InterBlockVox.resize( m_nNumBlock) ; - m_InterBlockTria.resize( m_nNumBlock) ; + m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ; + m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ; + m_BlockSharpTria.resize( m_nNumBlock) ; + m_BlockSmoothTria.resize( m_nNumBlock) ; + m_BlockBigTria.resize( m_nNumBlock) ; + m_SingleMapTria.resize( m_nNumBlock) ; m_SliceXY.resize( m_nNumBlock) ; m_SliceXZ.resize( m_nNumBlock) ; m_SliceYZ.resize( m_nNumBlock) ; diff --git a/VolZmapGraphics.cpp b/VolZmapGraphics.cpp index 945f8a1..7c4aae5 100644 --- a/VolZmapGraphics.cpp +++ b/VolZmapGraphics.cpp @@ -48,6 +48,16 @@ static int NeighbourTable[8][4] = { enum FatureType { NO_FEATURE = 0, CORNER = 1, EDGE = 2} ; enum CanonicDir { X_PLUS = 1, X_MINUS = -1, Y_PLUS = 2, Y_MINUS = -2, Z_PLUS = 3, Z_MINUS = -3} ; +//---------------------------------------------------------------------------- +bool +Config2VertOrder( int nInd) +{ + if ( nInd == 111 || nInd == 119 || nInd == 159 || nInd == 187 || nInd == 207 || nInd == 221 || + nInd == 238 || nInd == 243 || nInd == 246 || nInd == 249 || nInd == 205) + return true ; + return false ; +} + //---------------------------------------------------------------------------- int TestOnNormal( const AppliedVector CompoField[], int nCompoElem) @@ -460,7 +470,7 @@ VolZmap::GetAllTriangles( TRIA3DEXLIST& lstTria) const if ( ! GetTriangles( true, nModifiedBlocks, vLstTria)) return false ; lstTria.clear() ; - for ( size_t i = 0 ; i < vLstTria.size() ; ++ i) { + for ( int i = 0 ; i < int( vLstTria.size()) ; ++ i) { lstTria.splice( lstTria.end(), vLstTria[i]) ; } @@ -471,51 +481,31 @@ VolZmap::GetAllTriangles( TRIA3DEXLIST& lstTria) const bool VolZmap::GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DEXLISTVECTOR& vLstTria) const { + // Se nessun blocco modificato, è richiesta esterna e li considero tutti modificati + bool bSomeModif = false ; + for ( int i = 0 ; i < m_nNumBlock ; ++ i) { + if ( m_BlockToUpdate[i]) { + bSomeModif = true ; + break ; + } + } + if ( ! bSomeModif) + bAllBlocks = true ; + // Caso di singola mappa if ( m_nMapNum == 1) { - const int MAX_DIM_CHUNK = 128 ; - nModifiedBlocks.resize( m_nNumBlock) ; vLstTria.reserve( m_nNumBlock) ; - // Ciclo sui blocchi - for ( size_t t = 0 ; t < m_nNumBlock ; ++ t) { + UpGradeGraphicsSingleMap( bAllBlocks, nModifiedBlocks) ; - // Se il blocco deve essere aggiornato, eseguo - if ( bAllBlocks || m_BlockToUpdate[t]) { - - // preparo lista + for ( int t = 0 ; t < m_nNumBlock ; ++ t) { + if ( nModifiedBlocks[t] >= 0) { vLstTria.emplace_back() ; - nModifiedBlocks[t] = int( vLstTria.size()) - 1 ; - - // Calcolo posizione del blocco nella griglia - int nIBlock = int( t) % int( m_nFracLin[0]) ; - int nJBlock = int( t) / int( m_nFracLin[0]) ; - - // Calcolo limiti per l'indice i - int nStartI = nIBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ; - int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ? - int( m_nNx[0]) : ( nIBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ; - - // Calcolo limiti per l'indice j - int nStartJ = nJBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ; - int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ? - 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) { - int nDimChunkX = min( MAX_DIM_CHUNK, nEndI - i) ; - for ( int j = nStartJ ; j < nEndJ ; j += MAX_DIM_CHUNK) { - int nDimChunkY = min( MAX_DIM_CHUNK, nEndJ - j) ; - GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, vLstTria.back()) ; - } - } - - m_BlockToUpdate[t] = false ; + for ( int tDx = 0 ; tDx < int( m_SingleMapTria[t].size()) ; ++ tDx) + vLstTria.back().emplace_back( m_SingleMapTria[t][tDx]) ; } - else - nModifiedBlocks[t] = -1 ; } } @@ -525,147 +515,51 @@ VolZmap::GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DEXLIST nModifiedBlocks.resize( m_nNumBlock + 1) ; vLstTria.reserve( m_nNumBlock + 1) ; - vector vVoxContainerVec ; - vVoxContainerVec.resize( m_nNumBlock) ; - TriaMatrix VecTriHold ; - VecTriHold.resize( m_nNumBlock) ; - - // Ciclo sui blocchi per eliminare le slice fra blocchi da aggiornare - for ( size_t t = 0 ; t < m_nNumBlock ; ++ t) { - for ( auto it = m_SliceXY[t].begin() ; it != m_SliceXY[t].end() ;) { - int nSlIJK[3] ; - if ( GetVoxIJKFromN( it->first, nSlIJK[0], nSlIJK[1], nSlIJK[2])) { - int nBlockIJK[3] ; - if ( GetVoxelBlockIJK( nSlIJK, nBlockIJK)) { - int nLimits[6] ; - int nDeltaIndex[3] ; - if ( GetBlockLimitsIJK( nBlockIJK, nLimits) && - IsAVoxelOnBoundary( nLimits, nSlIJK, nDeltaIndex)) { - for ( int nInd = 0 ; nInd < 3 ; ++ nInd) - nSlIJK[nInd] += nDeltaIndex[nInd] ; - int nAdBlockIJK[3] ; - int nAdBlockNum ; - if ( GetVoxelBlockIJK( nSlIJK, nAdBlockIJK) && - GetBlockNFromIJK( nAdBlockIJK, nAdBlockNum) && - m_BlockToUpdate[nAdBlockNum]) { - it = m_SliceXY[t].erase( it) ; - continue ; - } - } - } - } - ++ it ; - } - for ( auto it = m_SliceXZ[t].begin() ; it != m_SliceXZ[t].end() ;) { - int nSlIJK[3] ; - if ( GetVoxIJKFromN( it->first, nSlIJK[0], nSlIJK[1], nSlIJK[2])) { - int nBlockIJK[3] ; - if ( GetVoxelBlockIJK( nSlIJK, nBlockIJK)) { - int nLimits[6] ; - int nDeltaIndex[3] ; - if ( GetBlockLimitsIJK( nBlockIJK, nLimits) && - IsAVoxelOnBoundary( nLimits, nSlIJK, nDeltaIndex)) { - for ( int nInd = 0 ; nInd < 3 ; ++ nInd) - nSlIJK[nInd] += nDeltaIndex[nInd] ; - int nAdBlockIJK[3] ; - int nAdBlockNum ; - if ( GetVoxelBlockIJK( nSlIJK, nAdBlockIJK) && - GetBlockNFromIJK( nAdBlockIJK, nAdBlockNum) && - m_BlockToUpdate[nAdBlockNum]) { - it = m_SliceXZ[t].erase( it) ; - continue ; - } - } - } - } - ++ it ; - } - for ( auto it = m_SliceYZ[t].begin() ; it != m_SliceYZ[t].end() ;) { - int nSlIJK[3] ; - if ( GetVoxIJKFromN( it->first, nSlIJK[0], nSlIJK[1], nSlIJK[2])) { - int nBlockIJK[3] ; - if ( GetVoxelBlockIJK( nSlIJK, nBlockIJK)) { - int nLimits[6] ; - int nDeltaIndex[3] ; - if ( GetBlockLimitsIJK( nBlockIJK, nLimits) && - IsAVoxelOnBoundary( nLimits, nSlIJK, nDeltaIndex)) { - for ( int nInd = 0 ; nInd < 3 ; ++ nInd) - nSlIJK[nInd] += nDeltaIndex[nInd] ; - int nAdBlockIJK[3] ; - int nAdBlockNum ; - if ( GetVoxelBlockIJK( nSlIJK, nAdBlockIJK) && - GetBlockNFromIJK( nAdBlockIJK, nAdBlockNum) && - m_BlockToUpdate[nAdBlockNum]) { - it = m_SliceYZ[t].erase( it) ; - continue ; - } - } - } - } - ++ it ; - } - } - - bool bCalcInterBlock = false ; + UpGradeGraphics( bAllBlocks, nModifiedBlocks) ; // Calcolo i triangoli sui blocchi - for ( size_t t = 0 ; t < m_nNumBlock ; ++ t) { - // Se il blocco deve essere processato - if ( bAllBlocks || m_BlockToUpdate[t]) { - // processo ... + for ( int t = 0 ; t < m_nNumBlock ; ++ t) { + // Se il blocco è stato aggiornato + if ( nModifiedBlocks[t] >= 0) { vLstTria.emplace_back() ; - nModifiedBlocks[t] = int( vLstTria.size()) - 1 ; - ExtMarchingCubes( int( t), vLstTria.back(), vVoxContainerVec[t]) ; - } - else - nModifiedBlocks[t] = -1 ; - } - - // Regolarizzo la catena - RegulateFeaturesChain( vVoxContainerVec) ; - - // Costruisco i triangoli di feature - for ( size_t t = 0 ; t < m_nNumBlock ; ++ t) { - // Se il blocco è stato processato - if ( bAllBlocks || m_BlockToUpdate[t]) { - CreateSharpFeatureTriangle( int( t), vVoxContainerVec[t], VecTriHold[t]) ; - // Flipping fra voxel interni - FlipEdgesII( VecTriHold[t]) ; - bCalcInterBlock = true ; - m_BlockToUpdate[t] = false ; + // Copio i triangoli nella lista + for ( int nVx = 0 ; nVx < int( m_BlockSmoothTria[t].size()) ; ++ nVx) { + for ( int nTr = 0 ; nTr < int( m_BlockSmoothTria[t][nVx].vTria.size()) ; ++ nTr) { + vLstTria.back().emplace_back( m_BlockSmoothTria[t][nVx].vTria[nTr]) ; + } + } } } - // Calcolo i triangoli di frontiera tra feature di blocchi diversi - // copio i triangoli di frontiera in una matrice gemella - // di m_InterBlockTria per avere sempre a disposizione - // i triangoli non flippati. - TriaMatrix InterBlockTria ; - if ( bCalcInterBlock) { - InterBlockTria = m_InterBlockTria ; - FlipEdgesBB( InterBlockTria) ; + // Inserisco i triangoli grandi piatti + for ( int t = 0 ; t < m_nNumBlock ; ++ t) { + if ( nModifiedBlocks[t] >= 0) { + for ( int tBl = 0 ; tBl < int( m_BlockBigTria[t].size()) ; ++ tBl) { + vLstTria[nModifiedBlocks[t]].emplace_back( m_BlockBigTria[t][tBl]) ; + } + } } // Inserisco in lista i triangoli di feature derivanti dai blocchi - for ( size_t t = 0 ; t < m_nNumBlock ; ++ t) { + for ( int t = 0 ; t < m_nNumBlock ; ++ t) { if ( nModifiedBlocks[t] >= 0) { // ciclo sui voxel del blocco - for ( size_t t1 = 0 ; t1 < VecTriHold[t].size() ; ++ t1) { + for ( int t1 = 0 ; t1 < int( m_BlockSharpTria[t].size()) ; ++ t1) { // ciclo sulle componenti connesse del voxel - for ( size_t t2 = 0 ; t2 < VecTriHold[t][t1].vCompoTria.size() ; ++ t2) { + for ( int t2 = 0 ; t2 < int( m_BlockSharpTria[t][t1].vCompoTria.size()) ; ++ t2) { // ciclo sui triangoli delle componenti connesse - for ( size_t t3 = 0 ; t3 < VecTriHold[t][t1].vCompoTria[t2].size() ; ++ t3) { + for ( int t3 = 0 ; t3 < int( m_BlockSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) { // Controllo normali - Vector3d vtN = VecTriHold[t][t1].vCompoTria[t2][t3].GetN() ; + Vector3d vtN = m_BlockSharpTria[t][t1].vCompoTria[t2][t3].GetN() ; bool bNormN = vtN.IsNormalized() ; for ( int nV = 0 ; nV < 3 ; ++ nV) { - Vector3d vtNV = VecTriHold[t][t1].vCompoTria[t2][t3].GetVertexNorm( nV) ; + Vector3d vtNV = m_BlockSharpTria[t][t1].vCompoTria[t2][t3].GetVertexNorm( nV) ; bool bNormV = vtNV.IsNormalized() ; if ( bNormN && bNormV && vtN * vtNV < 0.7) - VecTriHold[t][t1].vCompoTria[t2][t3].SetVertexNorm( nV, vtN) ; + m_BlockSharpTria[t][t1].vCompoTria[t2][t3].SetVertexNorm( nV, vtN) ; } // aggiungo triangolo alla lista - vLstTria[nModifiedBlocks[t]].emplace_back( VecTriHold[t][t1].vCompoTria[t2][t3]) ; + vLstTria[nModifiedBlocks[t]].emplace_back( m_BlockSharpTria[t][t1].vCompoTria[t2][t3]) ; } } } @@ -673,34 +567,32 @@ VolZmap::GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DEXLIST } // Inserisco in lista i triangoli di frontiera tra feature di blocchi diversi - if ( bCalcInterBlock) { + if ( nModifiedBlocks[nModifiedBlocks.size() - 1] >= 0) { vLstTria.resize( vLstTria.size() + 1) ; - size_t nPos = size_t( vLstTria.size() - 1) ; - for ( size_t t = 0 ; t < InterBlockTria.size() ; ++ t) { - for ( size_t t1 = 0 ; t1 < InterBlockTria[t].size() ; ++ t1) { - for ( size_t t2 = 0 ; t2 < InterBlockTria[t][t1].vCompoTria.size() ; ++ t2) { - for ( size_t t3 = 0 ; t3 < InterBlockTria[t][t1].vCompoTria[t2].size() ; ++ t3) { - if ( InterBlockTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) { + int nPos = int( vLstTria.size()) - 1 ; + for ( int t = 0 ; t < int( m_InterBlockToBeFlippedSharpTria.size()) ; ++ t) { + for ( int t1 = 0 ; t1 < int( m_InterBlockToBeFlippedSharpTria[t].size()) ; ++ t1) { + for ( int t2 = 0 ; t2 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria.size()) ; ++ t2) { + for ( int t3 = 0 ; t3 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) { + if ( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) { // Controllo normali - Vector3d vtN = InterBlockTria[t][t1].vCompoTria[t2][t3].GetN() ; + Vector3d vtN = m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetN() ; bool bNormN = vtN.IsNormalized() ; for ( int nV = 0 ; nV < 3 ; ++ nV) { - Vector3d vtNV = InterBlockTria[t][t1].vCompoTria[t2][t3].GetVertexNorm( nV) ; + Vector3d vtNV = m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetVertexNorm( nV) ; bool bNormV = vtNV.IsNormalized() ; if ( bNormN && bNormV && vtN * vtNV < 0.7) - InterBlockTria[t][t1].vCompoTria[t2][t3].SetVertexNorm( nV, vtN) ; + m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].SetVertexNorm( nV, vtN) ; } // aggiungo triangolo alla lista - vLstTria[nPos].emplace_back( InterBlockTria[t][t1].vCompoTria[t2][t3]) ; + vLstTria[nPos].emplace_back( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3]) ; } } } } + m_InterBlockToBeFlippedSharpTria[t].clear() ; } - nModifiedBlocks.back() = int( nPos) ; } - else - nModifiedBlocks.back() = - 1 ; } return true ; @@ -715,7 +607,7 @@ VolZmap::GetBlockCount( void) const //---------------------------------------------------------------------------- bool -VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk, TRIA3DEXLIST& lstTria) const +VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk, int nBlock) const { // determino se è un semplice parallelepipedo bool bIsSimple = true ; @@ -739,7 +631,7 @@ VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk // se semplice parallelepipedo if ( bIsSimple) { - CalcChunkPrisms( nPos1, nPos2, nDim1, nDim2, lstTria) ; + CalcChunkPrisms( nPos1, nPos2, nDim1, nDim2, nBlock) ; } // se chunk di dimensioni accettabili else if ( nDimChk >= 4) { @@ -748,7 +640,7 @@ VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk int nDimChunkX = min( nNewDimChk, int( nPos1 + nDim1) - i) ; for ( int j = nPos2 ; j < int( nPos2 + nDim2) ; j += nNewDimChk) { int nDimChunkY = min( nNewDimChk, int( nPos2 + nDim2) - j) ; - GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, nNewDimChk, lstTria) ; + GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, nNewDimChk, nBlock) ; } } } @@ -757,7 +649,7 @@ VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk // elaboro ogni singolo dexel for ( int i = 0 ; i < nDim1 ; ++ i) { for ( int j = 0 ; j < nDim2 ; ++ j) { - CalcDexelPrisms( nPos1 + i, nPos2 + j, lstTria) ; + CalcDexelPrisms( nPos1 + i, nPos2 + j, nBlock) ; } } } @@ -766,7 +658,7 @@ VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk //---------------------------------------------------------------------------- bool -VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DEXLIST& lstTria) const +VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nBlock) const { // verifiche sugli indici if ( nPos1 < 0 || nPos1 + nDim1 > int( m_nNx[0]) || nPos2 < 0 || nPos2 + nDim2 > int( m_nNy[0])) @@ -787,15 +679,15 @@ VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DEXLI Vector3d vtDZt = m_Values[0][nPos][0].dMax * m_MapFrame.VersZ() ; Vector3d vtDZb = m_Values[0][nPos][0].dMin * m_MapFrame.VersZ() ; // faccia superiore P1t->P2t->P3t->P4t : sempre visibile - lstTria.emplace_back() ; - lstTria.back().Set( ptP1 + vtDZt, ptP2 + vtDZt, ptP3 + vtDZt, m_MapFrame.VersZ()) ; - lstTria.emplace_back() ; - lstTria.back().Set( ptP3 + vtDZt, ptP4 + vtDZt, ptP1 + vtDZt, m_MapFrame.VersZ()) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptP1 + vtDZt, ptP2 + vtDZt, ptP3 + vtDZt, m_MapFrame.VersZ()) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptP3 + vtDZt, ptP4 + vtDZt, ptP1 + vtDZt, m_MapFrame.VersZ()) ; // faccia inferiore P1b->P4b->P3b->P2b : sempre visibile - lstTria.emplace_back() ; - lstTria.back().Set( ptP1 + vtDZb, ptP4 + vtDZb, ptP3 + vtDZb, - m_MapFrame.VersZ()) ; - lstTria.emplace_back() ; - lstTria.back().Set( ptP3 + vtDZb, ptP2 + vtDZb, ptP1 + vtDZb, - m_MapFrame.VersZ()) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptP1 + vtDZb, ptP4 + vtDZb, ptP3 + vtDZb, - m_MapFrame.VersZ()) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptP3 + vtDZb, ptP2 + vtDZb, ptP1 + vtDZb, - m_MapFrame.VersZ()) ; // creo le facce laterali for ( int j = 0 ; j < nDim2 ; ++ j) { @@ -803,28 +695,28 @@ VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DEXLI int nPosEst = ( nPos1 + nDim1 - 1 < int( m_nNx[0] - 1) ? nPosD + 1 : - 1) ; Point3d ptP2D = ptP2 + j * m_dStep * m_MapFrame.VersY() ; Point3d ptP3D = ptP2D + m_dStep * m_MapFrame.VersY() ; - AddDexelSideFace( nPosD, nPosEst, ptP2D, ptP3D, m_MapFrame.VersZ(), m_MapFrame.VersX(), lstTria) ; + AddDexelSideFace( nPosD, nPosEst, ptP2D, ptP3D, m_MapFrame.VersZ(), m_MapFrame.VersX(), nBlock) ; } for ( int i = 0 ; i < nDim1 ; ++ i) { int nPosD = nPos + ( nDim2 - 1) * m_nNx[0] + i ; int nPosNord = ( nPos2 + nDim2 - 1 < int( m_nNy[0] - 1) ? nPosD + m_nNx[0] : - 1) ; Point3d ptP4D = ptP4 + i * m_dStep * m_MapFrame.VersX() ; Point3d ptP3D = ptP4D + m_dStep * m_MapFrame.VersX() ; - AddDexelSideFace( nPosD, nPosNord, ptP3D, ptP4D, m_MapFrame.VersZ(), m_MapFrame.VersY(), lstTria) ; + AddDexelSideFace( nPosD, nPosNord, ptP3D, ptP4D, m_MapFrame.VersZ(), m_MapFrame.VersY(), nBlock) ; } for ( int j = 0 ; j < nDim2 ; ++ j) { int nPosD = nPos + j * m_nNx[0] ; int nPosWest = ( nPos1 > 0 ? nPosD - 1 : - 1) ; Point3d ptP1D = ptP1 + j * m_dStep * m_MapFrame.VersY() ; Point3d ptP4D = ptP1D + m_dStep * m_MapFrame.VersY() ; - AddDexelSideFace( nPosD, nPosWest, ptP4D, ptP1D, m_MapFrame.VersZ(), - m_MapFrame.VersX(), lstTria) ; + AddDexelSideFace( nPosD, nPosWest, ptP4D, ptP1D, m_MapFrame.VersZ(), - m_MapFrame.VersX(), nBlock) ; } for ( int i = 0 ; i < nDim1 ; ++ i) { int nPosD = nPos + i ; int nPosSud = ( nPos2 > 0 ? nPosD - m_nNx[0] : - 1) ; Point3d ptP1D = ptP1 + i * m_dStep * m_MapFrame.VersX() ; Point3d ptP2D = ptP1D + m_dStep * m_MapFrame.VersX() ; - AddDexelSideFace( nPosD, nPosSud, ptP1D, ptP2D, m_MapFrame.VersZ(), - m_MapFrame.VersY(), lstTria) ; + AddDexelSideFace( nPosD, nPosSud, ptP1D, ptP2D, m_MapFrame.VersZ(), - m_MapFrame.VersY(), nBlock) ; } // return true ; @@ -832,7 +724,7 @@ VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DEXLI //---------------------------------------------------------------------------- bool -VolZmap::CalcDexelPrisms( int nPos1, int nPos2, TRIA3DEXLIST& lstTria) const +VolZmap::CalcDexelPrisms( int nPos1, int nPos2, int nBlock) const { // verifiche sugli indici if ( nPos1 < 0 || nPos1 >= int( m_nNx[0]) || nPos2 < 0 || nPos2 >= int( m_nNy[0])) @@ -854,26 +746,26 @@ VolZmap::CalcDexelPrisms( int nPos1, int nPos2, TRIA3DEXLIST& lstTria) const Vector3d vtDZt = m_Values[0][nPos][i].dMax * m_MapFrame.VersZ() ; Vector3d vtDZb = m_Values[0][nPos][i].dMin * m_MapFrame.VersZ() ; // faccia superiore P1t->P2t->P3t->P4t : sempre visibile - lstTria.emplace_back() ; - lstTria.back().Set( ptP1 + vtDZt, ptP2 + vtDZt, ptP3 + vtDZt, m_MapFrame.VersZ()) ; - lstTria.emplace_back() ; - lstTria.back().Set( ptP3 + vtDZt, ptP4 + vtDZt, ptP1 + vtDZt, m_MapFrame.VersZ()) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptP1 + vtDZt, ptP2 + vtDZt, ptP3 + vtDZt, m_MapFrame.VersZ()) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptP3 + vtDZt, ptP4 + vtDZt, ptP1 + vtDZt, m_MapFrame.VersZ()) ; // faccia inferiore P1b->P4b->P3b->P2b : sempre visibile - lstTria.emplace_back() ; - lstTria.back().Set( ptP1 + vtDZb, ptP4 + vtDZb, ptP3 + vtDZb, - m_MapFrame.VersZ()) ; - lstTria.emplace_back() ; - lstTria.back().Set( ptP3 + vtDZb, ptP2 + vtDZb, ptP1 + vtDZb, - m_MapFrame.VersZ()) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptP1 + vtDZb, ptP4 + vtDZb, ptP3 + vtDZb, - m_MapFrame.VersZ()) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptP3 + vtDZb, ptP2 + vtDZb, ptP1 + vtDZb, - m_MapFrame.VersZ()) ; } // creo le facce laterali int nPosEst = ( nPos1 < int( m_nNx[0] - 1) ? nPos + 1 : - 1) ; - AddDexelSideFace( nPos, nPosEst, ptP2, ptP3, m_MapFrame.VersZ(), m_MapFrame.VersX(), lstTria) ; + AddDexelSideFace( nPos, nPosEst, ptP2, ptP3, m_MapFrame.VersZ(), m_MapFrame.VersX(), nBlock) ; int nPosNord = ( nPos2 < int( m_nNy[0] - 1) ? nPos + m_nNx[0] : - 1) ; - AddDexelSideFace( nPos, nPosNord, ptP3, ptP4, m_MapFrame.VersZ(), m_MapFrame.VersY(), lstTria) ; + AddDexelSideFace( nPos, nPosNord, ptP3, ptP4, m_MapFrame.VersZ(), m_MapFrame.VersY(), nBlock) ; int nPosWest = ( nPos1 > 0 ? nPos - 1 : - 1) ; - AddDexelSideFace( nPos, nPosWest, ptP4, ptP1, m_MapFrame.VersZ(), - m_MapFrame.VersX(), lstTria) ; + AddDexelSideFace( nPos, nPosWest, ptP4, ptP1, m_MapFrame.VersZ(), - m_MapFrame.VersX(), nBlock) ; int nPosSud = ( nPos2 > 0 ? nPos - m_nNx[0] : - 1) ; - AddDexelSideFace( nPos, nPosSud, ptP1, ptP2, m_MapFrame.VersZ(), - m_MapFrame.VersY(), lstTria) ; + AddDexelSideFace( nPos, nPosSud, ptP1, ptP2, m_MapFrame.VersZ(), - m_MapFrame.VersY(), nBlock) ; return true ; } @@ -881,7 +773,7 @@ VolZmap::CalcDexelPrisms( int nPos1, int nPos2, TRIA3DEXLIST& lstTria) const //---------------------------------------------------------------------------- bool VolZmap::AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Point3d& ptQ, - const Vector3d& vtZ, const Vector3d& vtNorm, TRIA3DEXLIST& lstTria) const + const Vector3d& vtZ, const Vector3d& vtNorm, int nBlock) const { Intervals intFace ; for ( int i = 0 ; i < int( m_Values[0][nPos].size()) ; i += 1) @@ -895,453 +787,222 @@ VolZmap::AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Poin while ( bFound) { Vector3d vtDZt = dMax * vtZ ; Vector3d vtDZb = dMin * vtZ ; - lstTria.emplace_back() ; - lstTria.back().Set( ptP + vtDZb, ptQ + vtDZb, ptQ + vtDZt, vtNorm) ; - lstTria.emplace_back() ; - lstTria.back().Set( ptQ + vtDZt, ptP + vtDZt, ptP + vtDZb, vtNorm) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptP + vtDZb, ptQ + vtDZb, ptQ + vtDZt, vtNorm) ; + m_SingleMapTria[nBlock].emplace_back() ; + m_SingleMapTria[nBlock].back().Set( ptQ + vtDZt, ptP + vtDZt, ptP + vtDZb, vtNorm) ; bFound = intFace.GetNext( dMin, dMax) ; } return true ; } //---------------------------------------------------------------------------- -// Calcola i triangoli del voxel con indici nVoxI, nVoxJ, nVoxK; se si vuole -// il riconoscimento delle sharp-feature bEnh deve valere true. -// I triangoli formanti sharp-feature vengono messi nel TriHolder, gli altri nella lista. -bool -VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DEXLIST& lstTria, VoxelContainer& VoxCont, bool bEnh) const +bool +VolZmap::UpGradeGraphics( bool bAllBlocks, INTVECTOR& nModifiedBlocks) 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 + 2 > nVoxNumX || - nVoxJ + 1 < 0 || nVoxJ + 2 > nVoxNumY || - nVoxK + 1 < 0 || nVoxK + 2 > nVoxNumZ) - return false ; - - // Classificazione dei vertici: interni o esterni al materiale - int nIndex = CalcIndex( nVoxI, nVoxJ, nVoxK) ; - - // Se vi è qualche intersezione fra segmenti e superficie - // continuo altrimenti passo al prossimo voxel. - if ( EdgeTable[nIndex] != 0) { - - // Indici i,j,k dei vertici - int IndexCorner[8][3] = { - { nVoxI, nVoxJ, nVoxK}, - { nVoxI + 1, nVoxJ, nVoxK}, - { nVoxI + 1, nVoxJ + 1, nVoxK}, - { nVoxI, nVoxJ + 1, nVoxK}, - { nVoxI, nVoxJ, nVoxK + 1}, - { nVoxI + 1, nVoxJ, nVoxK + 1}, - { nVoxI + 1, nVoxJ + 1, nVoxK + 1}, - { nVoxI, nVoxJ + 1, nVoxK + 1} - } ; - - static int intersections[12][2] = { - { 0, 1 }, { 1, 2 }, { 3, 2 }, { 0, 3 }, { 4, 5 }, { 5, 6 }, - { 7, 6 }, { 4, 7 }, { 0, 4 }, { 1, 5 }, { 2, 6 }, { 3, 7 } - } ; - - // Array di strutture punto di intersezione e normale alla superficie in esso. - AppliedVector VecField[12] ; - - // Flag di regolarità dei campi scalare e vettoriale - bool bReg = true ; - - // Ciclo sui segmenti - for ( int EdgeIndex = 0 ; EdgeIndex < 12 ; ++ EdgeIndex) { - // Se il segmento non attraversa la superficie passo al successivo - if ( ( EdgeTable[nIndex] & ( 1 << EdgeIndex)) == 0) - continue ; - // Indici per linee di griglia sui vertici - int n1 = intersections[EdgeIndex][0] ; - int n2 = intersections[EdgeIndex][1] ; - // Flag posizione corner - bool bN1 = ( ( nIndex & ( 1 << n1)) != 0) ; - // Determino con precisione il punto di intersezione sullo spigolo, - // se i campi scalare e vettoriale non sono regolari bReg diviene falso. - if ( ! IntersPos( IndexCorner[n1], IndexCorner[n2], bN1, VecField[EdgeIndex])) - bReg = false ; + // Se nessun blocco modificato, è richiesta esterna e li considero tutti modificati + bool bSomeModif = false ; + for ( int i = 0 ; i < m_nNumBlock ; ++ i) { + if ( m_BlockToUpdate[i]) { + bSomeModif = true ; + break ; } + } + if ( ! bSomeModif) + bAllBlocks = true ; - // Determino il numero di componenti connesse nel voxel in caso di configurazione standard - int nComponents = TriangleTableEn[nIndex][1][0] ; - - // Matrici di campi vettoriali: - // CompoVert[i] ha i vertici della base del triangle fan della (i+1)-esima componente connessa; - // CompoTriVert[i] ha i vertici di tutti i triangoli, nel caso di assenza di sharp feature, - // della (i+1)-esima componente connessa. - AppliedVector CompoVert[4][7] ; - AppliedVector CompoTriVert[4][17] ; - - // Array numero di vertici della base del fan per componente - // connessa: nVertComp[i] contiene il numero di vertici - // della base del fan della (i+1)-esima componente connessa. - int nVertComp[4] ; - - int nExtTabOff = nComponents ; - int nStdTabOff = 0 ; - - // Carico le matrici CompoVert e CompoTriVert - for ( int nComp = 0 ; nComp < nComponents ; ++ nComp) { - - // Numero vertici per componenti - nVertComp[nComp] = TriangleTableEn[nIndex][1][nComp+1] ; - - // Riempio il nCompCount-esimo vettore di vertici della base del fan - for ( int nVertCount = 0 ; nVertCount < nVertComp[nComp] ; ++ nVertCount) - CompoVert[nComp][nVertCount] = VecField[TriangleTableEn[nIndex][1][nVertCount + 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 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[nComp] ; - nStdTabOff += 3 * ( nVertComp[nComp] - 2) ; - } - - // Test sulla topologia: richiede campo regolare perchè si fonda su angoli tra normali - if ( bReg) { - // Configurazione 3 - if ( nAllConfig[nIndex] == 3) { - // Test sulla topologia - double dDotSum = 0 ; - for ( int nFV = 0 ; nFV < 3 ; ++ nFV) { - for ( int nTV = 0 ; nTV < 2 ; ++ nTV) { - dDotSum += CompoVert[0][nFV].vtVec * CompoVert[1][nTV].vtVec ; - } - } - for ( int nFVI = 0 ; nFVI < 2 ; ++ nFVI) { - for ( int nFVJ = nFVI + 1 ; nFVJ < 3 ; ++ nFVJ) { - dDotSum -= CompoVert[0][nFVI].vtVec * CompoVert[0][nFVJ].vtVec ; - } - } - for ( int nTVI = 0 ; nTVI < 2 ; ++ nTVI) { - for ( int nTVJ = nTVI + 1 ; nTVJ < 3 ; ++ nTVJ) { - dDotSum -= CompoVert[1][nTVI].vtVec * CompoVert[1][nTVJ].vtVec ; - } - } - bool bTestOnSum = dDotSum > - EPS_SMALL ; - // Si passa alla seconda topologia - if ( bTestOnSum) { - // Ricerca del caso corrispondente della nuova topologia - int nt = 0 ; - while ( nIndexVsIndex3[nt][0] != nIndex) - ++ nt ; - int nRotCase = nIndexVsIndex3[nt][1] ; - // Aggiorno numero di componenti - nComponents = Cases3Plus[nRotCase][1][0] ; - // Riaggiorno gli offsets - nExtTabOff = nComponents ; - nStdTabOff = 0 ; - // Modifico le matrici - for ( int nC = 1 ; nC <= nComponents ; ++ nC) { - // Numero vertici per componenti - nVertComp[nC - 1] = Cases3Plus[nRotCase][1][nC] ; - // 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 - for ( int nTriVert = 0 ; nTriVert < 3 * ( nVertComp[nC - 1] - 2) ; nTriVert += 3) { - CompoTriVert[nC - 1][nTriVert] = VecField[Cases3Plus[nRotCase][0][nStdTabOff + nTriVert+2]] ; - CompoTriVert[nC - 1][nTriVert+1] = VecField[Cases3Plus[nRotCase][0][nStdTabOff + nTriVert+1]] ; - CompoTriVert[nC - 1][nTriVert+2] = VecField[Cases3Plus[nRotCase][0][nStdTabOff + nTriVert]] ; - } - // Aggiorno gli offsets per raggiungere i vertici della componente successiva. - nExtTabOff += nVertComp[nC - 1] ; - nStdTabOff += 3 * ( nVertComp[nC - 1] - 2) ; - } - } - } - - // Configurazione 6 - else if ( nAllConfig[nIndex] == 6) { - // Test sulla topologia - double dDotSum = 0 ; - for ( int nFV = 0 ; nFV < 4 ; ++ nFV) { - for ( int nTV = 0 ; nTV < 3 ; ++ nTV) { - dDotSum += CompoVert[0][nFV].vtVec * CompoVert[1][nTV].vtVec ; - } - } - for ( int nFVI = 0 ; nFVI < 3 ; ++ nFVI) { - for ( int nFVJ = nFVI + 1 ; nFVJ < 4 ; ++ nFVJ) { - dDotSum -= CompoVert[0][nFVI].vtVec * CompoVert[0][nFVJ].vtVec ; - } - } - for ( int nTVI = 0 ; nTVI < 2 ; ++ nTVI) { - for ( int nTVJ = nTVI + 1 ; nTVJ < 3 ; ++ nTVJ) { - dDotSum -= CompoVert[1][nTVI].vtVec * CompoVert[1][nTVJ].vtVec ; - } - } - bool bTestOnSum = dDotSum > - 4 ; - // Si deve passare alla seconda topologia - if ( bTestOnSum) { - // Ricerca del caso corrispondente della nuova topologia - int nt = 0 ; - while ( nIndexVsIndex6[nt][0] != nIndex) - ++ nt ; - int nRotCase = nIndexVsIndex6[nt][1] ; - - // Costruzione dei triangoli - for ( int TriIndex = 0 ; TriIndex < 15 ; TriIndex += 3) { - // Indici vertici - int i0 = Cases6Plus[nRotCase][0][TriIndex + 2] ; - int i1 = Cases6Plus[nRotCase][0][TriIndex + 1] ; - int i2 = Cases6Plus[nRotCase][0][TriIndex] ; - // Costruzione triangolo - Triangle3dEx CurrentTriangle ; - CurrentTriangle.Set( VecField[i0].ptPApp, VecField[i1].ptPApp, VecField[i2].ptPApp) ; - CurrentTriangle.Validate( true) ; - CurrentTriangle.SetVertexNorm( 0, VecField[i0].vtVec) ; - CurrentTriangle.SetVertexNorm( 1, VecField[i1].vtVec) ; - CurrentTriangle.SetVertexNorm( 2, VecField[i2].vtVec) ; - // Setto il numero di utensile (conta solo positivo, nullo o negativo) - int nTool0 = Clamp( VecField[i0].nPropIndex, -1, 1) ; - int nTool1 = Clamp( VecField[i1].nPropIndex, -1, 1) ; - int nTool2 = Clamp( VecField[i2].nPropIndex, -1, 1) ; - if ( nTool0 == nTool1 || nTool0 == nTool2) - CurrentTriangle.SetGrade( nTool0) ; - else if ( nTool1 == nTool2) - CurrentTriangle.SetGrade( nTool1) ; - // Valido il triangolo e setto le normali del campo vettoriale ai corrispondenti vertici - if ( CurrentTriangle.Validate( true)) { - Vector3d vtVertNorm = VecField[i0].vtVec ; - if ( CurrentTriangle.GetN() * vtVertNorm > 0.6) - CurrentTriangle.SetVertexNorm( 0, vtVertNorm) ; - else - CurrentTriangle.SetVertexNorm( 0, CurrentTriangle.GetN()) ; - vtVertNorm = VecField[i1].vtVec ; - if ( CurrentTriangle.GetN() * vtVertNorm > 0.6) - CurrentTriangle.SetVertexNorm( 1, vtVertNorm) ; - else - CurrentTriangle.SetVertexNorm( 1, CurrentTriangle.GetN()) ; - vtVertNorm = VecField[i2].vtVec ; - if ( CurrentTriangle.GetN() * vtVertNorm > 0.6) - CurrentTriangle.SetVertexNorm( 2, vtVertNorm) ; - else - CurrentTriangle.SetVertexNorm( 2, CurrentTriangle.GetN()) ; - } - // Riporto il triangolo nel sistema in cui è immerso quello dello Zmap - CurrentTriangle.ToGlob( m_MapFrame) ; - // Aggiungo alla lista - lstTria.emplace_back( CurrentTriangle) ; - } - return true ; - } - } - // Configurazione 10 - else if ( nAllConfig[nIndex] == 10) { - // Verifico concordanza tra i versori di una stessa componente - // (ogni coppia di vettori di una medesima componente deve avere prodotto scalare non inferiore a 0.0) - Vector3d vtCmpAvg0, vtCmpAvg1 ; - bool bTest0 = DotTest( CompoVert[0], 4, vtCmpAvg0, 0.0) ; - bool bTest1 = DotTest( CompoVert[1], 4, vtCmpAvg1, 0.0) ; - // Si passa alla seconda topologia - if ( ! bTest0 || ! bTest1) { - // Ricerca del caso corrispondente della nuova topologia - int nt = 0 ; - while ( nIndexVsIndex10[nt][0] != nIndex) - ++ nt ; - // Riaggiorno gli offsets - nExtTabOff = 2 ; - nStdTabOff = 0 ; - // Modifico le matrici - int nRotCase = nIndexVsIndex10[nt][1] ; - for ( int nC = 1 ; nC <= 2 ; ++ nC) { - // Numero vertici per componenti - nVertComp[nC - 1] = Cases10Plus[nRotCase][1][nC] ; - // 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 - 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. - nExtTabOff += nVertComp[nC - 1] ; - nStdTabOff += 3 * ( nVertComp[nC - 1] - 2) ; - } - } - } - } - - Voxel CurrVox ; - CurrVox.nNumComp = 0 ; + nModifiedBlocks.resize( m_nNumBlock + 1) ; - // Numero di feature nel voxel: al più vi è una feature per componente connessa. - int nFeatureInVoxel = 0 ; + vector vVoxContainerVec ; + vVoxContainerVec.resize( m_nNumBlock) ; + SharpTriaMatrix VecTriHold ; + VecTriHold.resize( m_nNumBlock) ; - // 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 - if ( bReg) - nFeatureType = TestOnNormal( CompoVert[nComp], nVertComp[nComp]) ; - - // Extended MC - if ( nFeatureType != NO_FEATURE) { - - // Passo al sistema di riferimento del baricentro - Point3d ptGravityCenter( 0, 0, 0) ; - for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) - ptGravityCenter += CompoVert[nComp][ni].ptPApp ; - ptGravityCenter = ptGravityCenter / nVertComp[nComp] ; - - Vector3d vtTrasf[12] ; - for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) - vtTrasf[ni] = CompoVert[nComp][ni].ptPApp - ptGravityCenter ; - - // Preparo le matrici per il sistema - SvdMatrix dMatrixN( nVertComp[nComp], 3) ; - SvdVector dKnownVector( nVertComp[nComp]) ; - - // medio le normali adiacenti molto vicine (delta angolare inferiore a 22.5 deg) - Vector3d vtNorm[12] ; - for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) - vtNorm[ni] = CompoVert[nComp][ni].vtVec ; - 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]) ; - vtNorm[ni] = vtNI ; - vtNorm[ni].Normalize() ; - vtNorm[nj] = vtNJ ; - vtNorm[nj].Normalize() ; - ++ ni ; - } - } - - // Definisco la matrice del sistema - 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 ; - dKnownVector( ni) = vtNorm[ni] * vtTrasf[ni] ; - } - - // calcolo SVD - SvdDecomposer svd( dMatrixN, Eigen::ComputeThinU | Eigen::ComputeThinV) ; - auto dMatrixV = svd.matrixV() ; - auto dSingularValue = svd.singularValues() ; - - // 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 - auto dUnknownVector = svd.solve( dKnownVector) ; - // Vettore Baricentro-Feature - Vector3d vtFeature( dUnknownVector( 0), dUnknownVector( 1), dUnknownVector( 2)) ; - // Esprimo la soluzione nel sistema di riferimento z-map - Point3d ptSol = ptGravityCenter + vtFeature ; - - Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ; - if ( nFeatureType == EDGE && vtNullSpace.Normalize() && - ! IsPointInsideVoxelApprox( nVoxI, nVoxJ, nVoxK, ptSol)) { - for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { - Vector3d vtBaseVert = CompoVert[nComp][ni].ptPApp - ptSol ; - Vector3d vtDist = vtBaseVert - vtBaseVert * vtNullSpace * vtNullSpace ; - double dMaxDist = 0.005 * N_DEXVOXRATIO * m_dStep ; - if ( vtDist.SqLen() < dMaxDist * dMaxDist) { - ptSol = CompoVert[nComp][ni].ptPApp ; - break ; - } - } - } - - size_t tOldCompo = CurrVox.nNumComp ; - ++ CurrVox.nNumComp ; - CurrVox.Compo[tOldCompo].nVertNum = nVertComp[nComp] ; - for ( int nV = 0 ; nV < nVertComp[nComp] ; ++ nV) { - CurrVox.Compo[tOldCompo].CompVecField[nV] = CompoVert[nComp][nV] ; - } - CurrVox.Compo[tOldCompo].ptVert = ptSol ; - CurrVox.Compo[tOldCompo].bInside = IsPointInsideVoxelApprox( nVoxI, nVoxJ, nVoxK, ptSol, EPS_SMALL) ; - CurrVox.Compo[tOldCompo].bCorner = ( nFeatureType == CORNER) ; - } - - // Standard MC - else { - vector vTria ; - // Costruzione dei triangoli - for ( int TriIndex = 0; TriIndex < ( nVertComp[nComp] - 2) * 3 ; TriIndex += 3) { - // Il triangolo è pronto - Triangle3dEx CurrentTriangle ; - CurrentTriangle.Set( CompoTriVert[nComp][TriIndex].ptPApp, - CompoTriVert[nComp][TriIndex+1].ptPApp, - CompoTriVert[nComp][TriIndex+2].ptPApp) ; - // Setto il numero di utensile (conta solo positivo, nullo o negativo) - int nTool0 = Clamp( CompoTriVert[nComp][TriIndex].nPropIndex, -1, 1) ; - int nTool1 = Clamp( CompoTriVert[nComp][TriIndex+1].nPropIndex, -1, 1) ; - int nTool2 = Clamp( CompoTriVert[nComp][TriIndex+2].nPropIndex, -1, 1) ; - if ( nTool0 == nTool1 || nTool0 == nTool2) - CurrentTriangle.SetGrade( nTool0) ; - else if ( nTool1 == nTool2) - CurrentTriangle.SetGrade( nTool1) ; - // 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[nComp][TriIndex+nV].vtVec ; - if ( CurrentTriangle.GetN() * vtVertNorm > 0.5) - CurrentTriangle.SetVertexNorm( nV, vtVertNorm) ; - else - CurrentTriangle.SetVertexNorm( nV, CurrentTriangle.GetN()) ; + // Ciclo sui blocchi per eliminare le slice fra blocchi da aggiornare + for ( int t = 0 ; t < m_nNumBlock ; ++ t) { + for ( auto it = m_SliceXY[t].begin() ; it != m_SliceXY[t].end() ;) { + int nSlIJK[3] ; + if ( GetVoxIJKFromN( it->first, nSlIJK[0], nSlIJK[1], nSlIJK[2])) { + int nBlockIJK[3] ; + if ( GetVoxelBlockIJK( nSlIJK, nBlockIJK)) { + int nLimits[6] ; + int nDeltaIndex[3] ; + if ( GetBlockLimitsIJK( nBlockIJK, nLimits) && + IsAVoxelOnBoundary( nLimits, nSlIJK, nDeltaIndex)) { + for ( int nInd = 0 ; nInd < 3 ; ++ nInd) + nSlIJK[nInd] += nDeltaIndex[nInd] ; + int nAdBlockIJK[3] ; + int nAdBlockNum ; + if ( GetVoxelBlockIJK( nSlIJK, nAdBlockIJK) && + GetBlockNFromIJK( nAdBlockIJK, nAdBlockNum) && + m_BlockToUpdate[nAdBlockNum]) { + it = m_SliceXY[t].erase( it) ; + continue ; } - } - // Riporto le coordinate nel sistema in cui è immerso lo Zmap - // CurrentTriangle.ToGlob( m_MapFrame) ; - // Aggiungo alla lista - vTria.emplace_back( CurrentTriangle) ; - } - // Controllo i colori di configurazioni 2 e 8 - if ( ( nAllConfig[nIndex] == 2 || nAllConfig[nIndex] == 8) && - vTria[0].GetN() * vTria[1].GetN() > 0.8) { - if ( vTria[0].GetGrade() < 0 || vTria[1].GetGrade() < 0) { - vTria[0].SetGrade( -1) ; - vTria[1].SetGrade( -1) ; } - else if ( vTria[0].GetGrade() > 0 || vTria[1].GetGrade() > 0) { - vTria[0].SetGrade( 1) ; - vTria[1].SetGrade( 1) ; - } } - for ( int nT = 0 ; nT < int( vTria.size()) ; ++ nT) - lstTria.emplace_back( vTria[nT]) ; - } - } - // Se nel voxel abbiamo trovato feature - // aggiorniamo i contenitori. - if ( CurrVox.nNumComp > 0) { - CurrVox.i = nVoxI ; - CurrVox.j = nVoxJ ; - CurrVox.k = nVoxK ; - int nIJK[3] = { nVoxI, nVoxJ, nVoxK} ; - int nKey ; - GetVoxNFromIJK( nVoxI, nVoxJ, nVoxK, nKey) ; - VoxCont.emplace( nKey, CurrVox) ; + } + ++ it ; + } + for ( auto it = m_SliceXZ[t].begin() ; it != m_SliceXZ[t].end() ;) { + int nSlIJK[3] ; + if ( GetVoxIJKFromN( it->first, nSlIJK[0], nSlIJK[1], nSlIJK[2])) { + int nBlockIJK[3] ; + if ( GetVoxelBlockIJK( nSlIJK, nBlockIJK)) { + int nLimits[6] ; + int nDeltaIndex[3] ; + if ( GetBlockLimitsIJK( nBlockIJK, nLimits) && + IsAVoxelOnBoundary( nLimits, nSlIJK, nDeltaIndex)) { + for ( int nInd = 0 ; nInd < 3 ; ++ nInd) + nSlIJK[nInd] += nDeltaIndex[nInd] ; + int nAdBlockIJK[3] ; + int nAdBlockNum ; + if ( GetVoxelBlockIJK( nSlIJK, nAdBlockIJK) && + GetBlockNFromIJK( nAdBlockIJK, nAdBlockNum) && + m_BlockToUpdate[nAdBlockNum]) { + it = m_SliceXZ[t].erase( it) ; + continue ; + } + } + } + } + ++ it ; } - } + for ( auto it = m_SliceYZ[t].begin() ; it != m_SliceYZ[t].end() ;) { + int nSlIJK[3] ; + if ( GetVoxIJKFromN( it->first, nSlIJK[0], nSlIJK[1], nSlIJK[2])) { + int nBlockIJK[3] ; + if ( GetVoxelBlockIJK( nSlIJK, nBlockIJK)) { + int nLimits[6] ; + int nDeltaIndex[3] ; + if ( GetBlockLimitsIJK( nBlockIJK, nLimits) && + IsAVoxelOnBoundary( nLimits, nSlIJK, nDeltaIndex)) { + for ( int nInd = 0 ; nInd < 3 ; ++ nInd) + nSlIJK[nInd] += nDeltaIndex[nInd] ; + int nAdBlockIJK[3] ; + int nAdBlockNum ; + if ( GetVoxelBlockIJK( nSlIJK, nAdBlockIJK) && + GetBlockNFromIJK( nAdBlockIJK, nAdBlockNum) && + m_BlockToUpdate[nAdBlockNum]) { + it = m_SliceYZ[t].erase( it) ; + continue ; + } + } + } + } + ++ it ; + } + } + + bool bCalcInterBlock = false ; + + int nUpDatedBlockCount = 0 ; + + // Calcolo i triangoli sui blocchi + for ( int t = 0 ; t < m_nNumBlock ; ++ t) { + // Se il blocco deve essere processato + if ( bAllBlocks || m_BlockToUpdate[t]) { + // processo ... + nModifiedBlocks[t] = nUpDatedBlockCount ; + ++ nUpDatedBlockCount ; + ExtMarchingCubes( int( t), vVoxContainerVec[t]) ; + } + else + nModifiedBlocks[t] = -1 ; + } + + // Regolarizzo la catena + RegulateFeaturesChain( vVoxContainerVec) ; + + // Costruisco i triangoli di feature + for ( int t = 0 ; t < int( m_nNumBlock) ; ++ t) { + // Se il blocco è stato processato + if ( bAllBlocks || m_BlockToUpdate[t]) { + CreateSharpFeatureTriangle( t, vVoxContainerVec[t]) ; + ++ m_BlockUpGradingCounter[t] ; + // Flipping fra voxel interni + FlipEdgesII( t) ; + bCalcInterBlock = true ; + m_BlockToUpdate[t] = false ; + } + } + + // Calcolo i triangoli di frontiera tra feature di blocchi diversi + // copio i triangoli di frontiera in una matrice gemella + // di m_InterBlockTria per avere sempre a disposizione i triangoli non flippati. + SharpTriaMatrix InterBlockTria ; + if ( bCalcInterBlock) { + m_InterBlockToBeFlippedSharpTria = m_InterBlockOriginalSharpTria ; + ++ m_BlockUpGradingCounter[m_nNumBlock] ; + FlipEdgesBB() ; + } + + // Inserisco in lista i triangoli di frontiera tra feature di blocchi diversi + if ( bCalcInterBlock) + nModifiedBlocks.back() = nUpDatedBlockCount ; + else + nModifiedBlocks.back() = - 1 ; + return true ; } //---------------------------------------------------------------------------- bool -VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vVox) const +VolZmap::UpGradeGraphicsSingleMap( bool bAllBlocks, INTVECTOR& nModifiedBlocks) const +{ + const int MAX_DIM_CHUNK = 128 ; + + int nUpDatedBlockCount = 0 ; + + // Ciclo sui blocchi + for ( int t = 0 ; t < m_nNumBlock ; ++ t) { + + // Se il blocco deve essere aggiornato, eseguo + if ( bAllBlocks || m_BlockToUpdate[t]) { + + m_SingleMapTria[t].clear() ; + + // Calcolo posizione del blocco nella griglia + int nIBlock = int( t) % int( m_nFracLin[0]) ; + int nJBlock = int( t) / int( m_nFracLin[0]) ; + + // Calcolo limiti per l'indice i + int nStartI = nIBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ; + int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ? + int( m_nNx[0]) : ( nIBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ; + + // Calcolo limiti per l'indice j + int nStartJ = nJBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ; + int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ? + 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) { + int nDimChunkX = min( MAX_DIM_CHUNK, nEndI - i) ; + for ( int j = nStartJ ; j < nEndJ ; j += MAX_DIM_CHUNK) { + int nDimChunkY = min( MAX_DIM_CHUNK, nEndJ - j) ; + GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, t) ; + } + } + + ++ m_BlockUpGradingCounter[t] ; + + nModifiedBlocks[t] = nUpDatedBlockCount ; + + ++ nUpDatedBlockCount ; + + m_BlockToUpdate[t] = false ; + } + else + nModifiedBlocks[t] = -1 ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const { // Controllo sulla validità del blocco if ( nBlock < 0 || nBlock >= int( m_nNumBlock)) @@ -1357,6 +1018,10 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV // Pulisco il contenitore dei voxel di frontiera m_InterBlockVox[nBlock].clear() ; + m_InterBlockOriginalSharpTria[nBlock].clear() ; + m_BlockSharpTria[nBlock].clear() ; + m_BlockSmoothTria[nBlock].clear() ; + m_BlockBigTria[nBlock].clear() ; // Unordered Map per la riduzione del numero di triangoli int nDim = m_nVoxNumPerBlock * m_nVoxNumPerBlock ; @@ -1376,7 +1041,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV for ( int i = nLimits[0] ; i < nLimits[1] ; ++ i) { for ( int j = nLimits[2] ; j < nLimits[3] ; ++ j) { for ( int k = nLimits[4] ; k < nLimits[5] ; ++ k) { - + if ( m_nShape == BOX && ! IsVoxelOnBoxEdge( i, j, k)) continue ; // Classificazione dei vertici: interni o esterni al materiale @@ -2152,6 +1817,10 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV Voxel VoxConf ; VoxConf.nNumComp = 0 ; + SmoothTriaStruct VoxSmoothTria ; + int nVoxSmootSizePrev = int( VoxSmoothTria.vTria.size()) ; + int nVoxSmootSize = nVoxSmootSizePrev ; + // Numero di feature nel voxel: al più vi è una feature per componente connessa. int nFeatureInVoxel = 0 ; @@ -2223,77 +1892,150 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV // Esprimo la soluzione nel sistema di riferimento z-map Point3d ptSol = ptGravityCenter + vtFeature ; + bool bExtConfirmed = true ; Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ; if ( nFeatureType == EDGE && vtNullSpace.Normalize() && ! IsPointInsideVoxelApprox( i, j, k, ptSol)) { + bool bVertMoved = false ; for ( int ni = 0 ; ni < nVertComp[nComp] ; ++ ni) { Vector3d vtBaseVert = CompoVert[nComp][ni].ptPApp - ptSol ; Vector3d vtDist = vtBaseVert - vtBaseVert * vtNullSpace * vtNullSpace ; double dMaxDist = 0.005 * N_DEXVOXRATIO * m_dStep ; if ( vtDist.SqLen() < dMaxDist * dMaxDist) { ptSol = CompoVert[nComp][ni].ptPApp ; + bVertMoved = true ; break ; } } + // Gestione del caso configurazione 2 lungo creste di sharp-feature + if ( ! bVertMoved && nAllConfig[nIndex] == 2) { + // La tabella ha i vertici disposti in due modalità + int nV0 = 0 ; + int nV1 = 1 ; + int nV2 = 2 ; + int nV3 = 3 ; + if ( ! Config2VertOrder( nIndex)) { + int nTempV = nV3 ; + nV3 = nV2 ; + nV2 = nV1 ; + nV1 = nV0 ; + nV0 = nTempV ; + } + // Se le normali sono a due a due qauasi parallele e posizionate da dar origine a un ribaltamento + if ( AreSameVectorApprox( CompoVert[nComp][nV0].vtVec, CompoVert[nComp][nV1].vtVec) && + AreSameVectorApprox( CompoVert[nComp][nV2].vtVec, CompoVert[nComp][nV3].vtVec)) { + // Triangolo di prova + Triangle3d trHintTria ; + trHintTria.Set( ptSol, CompoVert[nComp][nV1].ptPApp, CompoVert[nComp][nV0].ptPApp) ; + trHintTria.Validate( true) ; + // Se avviene un ribaltamento non confermiamo ExtMC + if ( trHintTria.GetN() * CompoVert[nComp][nV0].vtVec < - 0.9) + bExtConfirmed = false ; + if ( bExtConfirmed) { + trHintTria.Set( ptSol, CompoVert[nComp][nV3].ptPApp, CompoVert[nComp][nV2].ptPApp) ; + trHintTria.Validate( true) ; + if ( trHintTria.GetN() * CompoVert[nComp][nV2].vtVec < - 0.9) + bExtConfirmed = false ; + } + } + } + if ( ! bVertMoved && nAllConfig[nIndex] == 8) { + bool bSpecialCase = false ; + /* int nV0, nV1, nV2, nV3 ; + if ( CompoVert[nComp][0].vtVec * CompoVert[nComp][1].vtVec > 0.7 && + CompoVert[nComp][2].vtVec * CompoVert[nComp][3].vtVec > 0.7) { + nV0 = 0 ; + nV1 = 1 ; + nV2 = 2 ; + nV3 = 3 ; + bSpecialCase = true ; + } + if ( CompoVert[nComp][0].vtVec * CompoVert[nComp][2].vtVec > 0.7 && + CompoVert[nComp][1].vtVec * CompoVert[nComp][3].vtVec > 0.7) { + nV0 = 0 ; + nV1 = 2 ; + nV2 = 1 ; + nV3 = 3 ; + bSpecialCase = true ; + }*/ + /*int nCouple[4] = { -1, -1, -1, -1} ; + int nFirstFree = 0 ; + for ( int a = 0 ; a < 3 ; ++ a) { + for ( int b = a + 1 ; b < 4 ; ++ b) { + if ( CompoVert[nComp][a].vtVec * CompoVert[nComp][b].vtVec > 0.9) { + bool bNewCoupleValid = true ; + for ( int d = 0 ; d < nFirstFree ; ++ d) { + if ( nCouple[d] == a || nCouple[d] == b) { + bNewCoupleValid = false ; + break ; + } + } + if ( bNewCoupleValid) { + nCouple[nFirstFree] = a ; + nCouple[nFirstFree + 1] = b ; + nFirstFree += 2 ; + } + } + } + }*/ + int nCouple[4] = { -1, -1, -1, -1} ; + int nFirstFree = 0 ; + for ( int a = 0 ; a < 4 ; ++ a) { + int nNa = ( a + 1) % 4 ; + if ( CompoVert[nComp][a].vtVec * CompoVert[nComp][nNa].vtVec > 0.9) { + bool bNewCoupleValid = true ; + for ( int b = 0 ; b < nFirstFree ; ++ b) { + if ( nCouple[b] == a || nCouple[b] == nNa) { + bNewCoupleValid = false ; + break ; + } + } + if ( bNewCoupleValid) { + nCouple[nFirstFree] = a ; + nCouple[nFirstFree + 1] = nNa ; + nFirstFree += 2 ; + } + } + } + if ( nCouple[3] != -1) + bSpecialCase = true ; + // Se le normali sono a due a due quasi parallele e posizionate da dar origine a un ribaltamento + if ( bSpecialCase) { + // Triangolo di prova + Triangle3d trHintTria ; + trHintTria.Set( ptSol, CompoVert[nComp][nCouple[1]].ptPApp, CompoVert[nComp][nCouple[0]].ptPApp) ; + trHintTria.Validate( true) ; + // Se avviene un ribaltamento non confermiamo ExtMC + if ( trHintTria.GetN() * CompoVert[nComp][nCouple[0]].vtVec < - 0.9) + bExtConfirmed = false ; + if ( bExtConfirmed) { + trHintTria.Set( ptSol, CompoVert[nComp][nCouple[3]].ptPApp, CompoVert[nComp][nCouple[2]].ptPApp) ; + trHintTria.Validate( true) ; + if ( trHintTria.GetN() * CompoVert[nComp][nCouple[2]].vtVec < - 0.9) + bExtConfirmed = false ; + } + } + } } - - size_t tOldCompo = VoxConf.nNumComp ; - ++ VoxConf.nNumComp ; - VoxConf.Compo[tOldCompo].nVertNum = nVertComp[nComp] ; - for ( int nV = 0 ; nV < nVertComp[nComp] ; ++ nV) { - VoxConf.Compo[tOldCompo].CompVecField[nV] = CompoVert[nComp][nV] ; + // ExtMC confermato + if ( bExtConfirmed) { + int tOldCompo = VoxConf.nNumComp ; + ++ VoxConf.nNumComp ; + VoxConf.Compo[tOldCompo].nVertNum = nVertComp[nComp] ; + for ( int nV = 0 ; nV < nVertComp[nComp] ; ++ nV) { + VoxConf.Compo[tOldCompo].CompVecField[nV] = CompoVert[nComp][nV] ; + } + VoxConf.Compo[tOldCompo].ptVert = ptSol ; + VoxConf.Compo[tOldCompo].vtNullSpace = vtNullSpace ; + VoxConf.Compo[tOldCompo].bInside = IsPointInsideVoxelApprox( i, j, k, ptSol, EPS_SMALL) ; + VoxConf.Compo[tOldCompo].bCorner = ( nFeatureType == CORNER) ; } - VoxConf.Compo[tOldCompo].ptVert = ptSol ; - VoxConf.Compo[tOldCompo].vtNullSpace = vtNullSpace ; - VoxConf.Compo[tOldCompo].bInside = IsPointInsideVoxelApprox( i, j, k, ptSol, EPS_SMALL) ; - VoxConf.Compo[tOldCompo].bCorner = ( nFeatureType == CORNER) ; + // ExtMC non confermato + else + CreateSmoothTriangle( nIndex, nVertComp[nComp], CompoTriVert[nComp], true, VoxSmoothTria) ; } // Standard MC - else if ( m_nShape != BOX) { - vector vTria ; - // Costruzione dei triangoli - for ( int TriIndex = 0 ; TriIndex < ( nVertComp[nComp] - 2) * 3 ; TriIndex += 3) { - // Il triangolo è pronto - Triangle3dEx CurrentTriangle ; - CurrentTriangle.Set( CompoTriVert[nComp][TriIndex].ptPApp, - CompoTriVert[nComp][TriIndex+1].ptPApp, - CompoTriVert[nComp][TriIndex+2].ptPApp) ; - // Setto il numero di utensile (conta solo positivo, nullo o negativo) - int nTool0 = Clamp( CompoTriVert[nComp][TriIndex].nPropIndex, -1, 1) ; - int nTool1 = Clamp( CompoTriVert[nComp][TriIndex+1].nPropIndex, -1, 1) ; - int nTool2 = Clamp( CompoTriVert[nComp][TriIndex+2].nPropIndex, -1, 1) ; - if ( nTool0 == nTool1 || nTool0 == nTool2) - CurrentTriangle.SetGrade( nTool0) ; - else if ( nTool1 == nTool2) - CurrentTriangle.SetGrade( nTool1) ; - // 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[nComp][TriIndex+nV].vtVec ; - if ( CurrentTriangle.GetN() * vtVertNorm > 0.5) - CurrentTriangle.SetVertexNorm( nV, vtVertNorm) ; - else - CurrentTriangle.SetVertexNorm( nV, CurrentTriangle.GetN()) ; - } - } - // Riporto le coordinate nel sistema in cui è immerso lo Zmap - CurrentTriangle.ToGlob( m_MapFrame) ; - // Aggiungo alla lista - vTria.emplace_back( CurrentTriangle) ; - } - // Controllo i colori di configurazioni 2 e 8 - if ( ( nAllConfig[nIndex] == 2 || nAllConfig[nIndex] == 8) && - vTria[0].GetN() * vTria[1].GetN() > 0.8) { - if ( vTria[0].GetGrade() < 0 || vTria[1].GetGrade() < 0) { - vTria[0].SetGrade( -1) ; - vTria[1].SetGrade( -1) ; - } - else if ( vTria[0].GetGrade() > 0 || vTria[1].GetGrade() > 0) { - vTria[0].SetGrade( 1) ; - vTria[1].SetGrade( 1) ; - } - } - for ( int nT = 0 ; nT < int( vTria.size()) ; ++ nT) - lstTria.emplace_back( vTria[nT]) ; + else if ( m_nShape != BOX) { + CreateSmoothTriangle( nIndex, nVertComp[nComp], CompoTriVert[nComp], false, VoxSmoothTria) ; } } // Se nel voxel abbiamo trovato feature @@ -2310,6 +2052,16 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV else vVox.emplace( nKey, VoxConf) ; } + // Se nel voxel abbiamo trovato componenti smooth + // aggiorno i contenitori + nVoxSmootSize = int( VoxSmoothTria.vTria.size()) ; + if ( nVoxSmootSize > nVoxSmootSizePrev) { + VoxSmoothTria.i = i ; + VoxSmoothTria.j = j ; + VoxSmoothTria.k = k ; + m_BlockSmoothTria[nBlock].emplace_back( VoxSmoothTria) ; + nVoxSmootSizePrev = nVoxSmootSize ; + } } } } @@ -2350,8 +2102,8 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV CreateBigTriangleYZ( dYMin, dYMax, dZMin, dZMax, m_dMinZ[1], false, nFaceInfGrade, trTria1, trTria2) ; trTria1.ToGlob( m_MapFrame) ; trTria2.ToGlob( m_MapFrame) ; - lstTria.emplace_back( trTria1) ; - lstTria.emplace_back( trTria2) ; + m_BlockBigTria[nBlock].emplace_back( trTria1) ; + m_BlockBigTria[nBlock].emplace_back( trTria2) ; } // Piano di coordinata x superiore: versore normale rivolto come X+ if ( nBlockIJK[0] + 1 == m_nFracLin[0]) { @@ -2359,8 +2111,8 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV CreateBigTriangleYZ( dYMin, dYMax, dZMin, dZMax, m_dMaxZ[1], true, nFaceSupGrade, trTria1, trTria2) ; trTria1.ToGlob( m_MapFrame) ; trTria2.ToGlob( m_MapFrame) ; - lstTria.emplace_back( trTria1) ; - lstTria.emplace_back( trTria2) ; + m_BlockBigTria[nBlock].emplace_back( trTria1) ; + m_BlockBigTria[nBlock].emplace_back( trTria2) ; } } // Costruisco i triangoli paralleli al piano XZ @@ -2389,8 +2141,8 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV CreateBigTriangleXZ( dXMin, dXMax, dZMin, dZMax, m_dMinZ[2], false, nFaceInfGrade, trTria1, trTria2) ; trTria1.ToGlob( m_MapFrame) ; trTria2.ToGlob( m_MapFrame) ; - lstTria.emplace_back( trTria1) ; - lstTria.emplace_back( trTria2) ; + m_BlockBigTria[nBlock].emplace_back( trTria1) ; + m_BlockBigTria[nBlock].emplace_back( trTria2) ; } // Piano di coordinata y superiore: versore normale rivolto come Y+ if ( nBlockIJK[1] + 1 == m_nFracLin[1]) { @@ -2398,8 +2150,8 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV CreateBigTriangleXZ( dXMin, dXMax, dZMin, dZMax, m_dMaxZ[2], true, nFaceSupGrade, trTria1, trTria2) ; trTria1.ToGlob( m_MapFrame) ; trTria2.ToGlob( m_MapFrame) ; - lstTria.emplace_back( trTria1) ; - lstTria.emplace_back( trTria2) ; + m_BlockBigTria[nBlock].emplace_back( trTria1) ; + m_BlockBigTria[nBlock].emplace_back( trTria2) ; } } // Costruisco i triangoli paralleli al piano XY @@ -2428,8 +2180,8 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV CreateBigTriangleXY( dXMin, dXMax, dYMin, dYMax, m_dMinZ[0], false, nFaceInfGrade, trTria1, trTria2) ; trTria1.ToGlob( m_MapFrame) ; trTria2.ToGlob( m_MapFrame) ; - lstTria.emplace_back( trTria1) ; - lstTria.emplace_back( trTria2) ; + m_BlockBigTria[nBlock].emplace_back( trTria1) ; + m_BlockBigTria[nBlock].emplace_back( trTria2) ; } // Piano di coordinata Z superiore: versore normale rivolto come Z+ if ( nBlockIJK[2] + 1 == m_nFracLin[2]) { @@ -2437,19 +2189,19 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV CreateBigTriangleXY( dXMin, dXMax, dYMin, dYMax, m_dMaxZ[0], true, nFaceSupGrade, trTria1, trTria2) ; trTria1.ToGlob( m_MapFrame) ; trTria2.ToGlob( m_MapFrame) ; - lstTria.emplace_back( trTria1) ; - lstTria.emplace_back( trTria2) ; + m_BlockBigTria[nBlock].emplace_back( trTria1) ; + m_BlockBigTria[nBlock].emplace_back( trTria2) ; } } } // Processo i Voxel con possibile superficie piana else { - ProcessVoxContXY( VoxContXYInf, false, lstTria) ; - ProcessVoxContXY( VoxContXYSup, true, lstTria) ; - ProcessVoxContYZ( VoxContYZInf, false, lstTria) ; - ProcessVoxContYZ( VoxContYZSup, true, lstTria) ; - ProcessVoxContXZ( VoxContXZInf, false, lstTria) ; - ProcessVoxContXZ( VoxContXZSup, true, lstTria) ; + ProcessVoxContXY( VoxContXYInf, nBlock, false) ; + ProcessVoxContXY( VoxContXYSup, nBlock, true) ; + ProcessVoxContYZ( VoxContYZInf, nBlock, false) ; + ProcessVoxContYZ( VoxContYZSup, nBlock, true) ; + ProcessVoxContXZ( VoxContXZInf, nBlock, false) ; + ProcessVoxContXZ( VoxContXZSup, nBlock, true) ; } return true ; @@ -2729,13 +2481,272 @@ VolZmap::RegulateFeaturesChain( vector& vVecVox) const } return true ; } +//bool +//VolZmap::RegulateFeaturesChain( vector& vVecVox) const +//{ +// // Ciclo sui blocchi +// for ( int nBlock = 0 ; nBlock < int( m_nNumBlock) ; ++ nBlock) { +// // Se il blocco è da aggiornare +// if ( m_BlockToUpdate[nBlock]) { +// // Ciclo sui voxel interni +// for ( auto itVox = vVecVox[nBlock].begin() ; itVox != vVecVox[nBlock].end() ; ++ itVox) { +// int nVox ; +// Voxel& CurVox = itVox->second ; +// GetVoxNFromIJK( CurVox.i, CurVox.j, CurVox.k, nVox) ; +// // Ciclo sulle componenti +// for ( int nComp = 0 ; nComp < CurVox.nNumComp ; ++ nComp) { +// // Caso feature +// if ( ! CurVox.Compo[nComp].bCorner) { +// // Vertice fuori dal suo voxel +// if ( ! CurVox.Compo[nComp].bInside) { +// Point3d ptMin( ( CurVox.i * N_DEXVOXRATIO + 0.5) * m_dStep, +// ( CurVox.j * N_DEXVOXRATIO + 0.5) * m_dStep, +// ( CurVox.k * N_DEXVOXRATIO + 0.5) * m_dStep) ; +// Point3d ptMax( ( ( CurVox.i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, +// ( ( CurVox.j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, +// ( ( CurVox.k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ; +// double dU1, dU2 ; +// if ( IntersLineBox( CurVox.Compo[nComp].ptVert, CurVox.Compo[nComp].vtNullSpace, ptMin, ptMax, dU1, dU2)) { +// double dU = abs( dU1) < abs( dU2) ? dU1 : dU2 ; +// //CurVox.Compo[nComp].ptVert += ( dU * CurVox.Compo[nComp].vtNullSpace) ; +// } +// } +// } +// } +// } +// // Ciclo sui voxel di frontiera +// for ( auto itVox = m_InterBlockVox[nBlock].begin() ; itVox != m_InterBlockVox[nBlock].end() ; ++ itVox) { +// // int nVox ; +// // Voxel& CurVox = itVox->second ; +// // GetVoxNFromIJK( CurVox.i, CurVox.j, CurVox.k, nVox) ; +// //// Ciclo sulle componenti +// // for ( int nComp = 0 ; nComp < CurVox.nNumComp ; ++ nComp) { +// // // Vertice fuori dal suo voxel +// // if ( ! CurVox.Compo[nComp].bInside) { +// // // Caso feature +// // if ( ! CurVox.Compo[nComp].bCorner) { +// // INTVECTOR vNearInn, vNearBord ; +// // FindAdjComp( vVecVox, nBlock, nVox, nComp, vNearInn, vNearBord) ; +// // int nSizeInn = int( vNearInn.size()) ; +// // int nSizeBord = int( vNearBord.size() ); +// // if ( nSizeInn + nSizeBord == 6) { +// // const Voxel* pVoxSt = nullptr ; +// // const Voxel* pVoxEn = nullptr ; +// // if ( nSizeInn == 6) { +// // pVoxSt = &( vVecVox[vNearInn[0]].find( vNearInn[1])->second) ; +// // pVoxEn = &( vVecVox[vNearInn[3]].find( vNearInn[4])->second) ; +// // } +// // else if ( nSizeBord == 6) { +// // pVoxSt = &( m_InterBlockVox[vNearBord[0]].find( vNearBord[1])->second) ; +// // pVoxEn = &( m_InterBlockVox[vNearBord[3]].find( vNearBord[4])->second) ; +// // } +// // else { +// // pVoxSt = &( vVecVox[vNearInn[0]].find( vNearInn[1])->second) ; +// // pVoxEn = &( m_InterBlockVox[vNearBord[0]].find( vNearBord[1])->second) ; +// // } +// // Point3d ptPCur = CurVox.Compo[nComp].ptVert ; +// // Point3d ptPSt ; +// // Point3d ptPEn ; +// // if ( nSizeInn == 6) { +// // ptPSt = pVoxSt->Compo[vNearInn[2]].ptVert ; +// // ptPEn = pVoxEn->Compo[vNearInn[5]].ptVert ; +// // } +// // else if ( nSizeBord == 6) { +// // ptPSt = pVoxSt->Compo[vNearBord[2]].ptVert ; +// // ptPEn = pVoxEn->Compo[vNearBord[5]].ptVert ; +// // } +// // else { +// // ptPSt = pVoxSt->Compo[vNearInn[2]].ptVert ; +// // ptPEn = pVoxEn->Compo[vNearBord[2]].ptVert ; +// // } +// // Vector3d vtStCurr = ptPCur - ptPSt ; +// // Vector3d vtStEn = ptPEn - ptPSt ; +// // Vector3d vtCurrEn = ptPEn - ptPCur ; +// // vtStCurr.Normalize() ; +// // vtStEn.Normalize() ; +// // vtCurrEn.Normalize() ; +// // Point3d ptMid = 0.5 * ( ptPSt + ptPEn) ; +// // double dMidU = ( ptMid - ptPSt) * vtStEn ; +// // double dCurU = ( ptPCur - ptPSt) * vtStEn ; +// // Point3d ptNew ; +// // Point3d ptPLine ; +// // Vector3d vtDLine ; +// // if ( dMidU < dCurU) { +// // ptPLine = ptPEn ; +// // vtDLine = - vtCurrEn ; +// // ptNew = ptPEn + ( ptMid - ptPEn) * vtCurrEn * vtCurrEn ; +// // } +// // else { +// // ptPLine = ptPSt ; +// // vtDLine = vtStCurr ; +// // ptNew = ptPSt + ( ptMid - ptPSt) * vtStCurr * vtStCurr ; +// // } +// // Point3d ptCubeInf( ( CurVox.i * N_DEXVOXRATIO + 0.5) * m_dStep, +// // ( CurVox.j * N_DEXVOXRATIO + 0.5) * m_dStep, +// // ( CurVox.k * N_DEXVOXRATIO + 0.5) * m_dStep) ; +// // Point3d ptCubeSup( ( ( CurVox.i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, +// // ( ( CurVox.j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, +// // ( ( CurVox.k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ; +// // double dU1, dU2 ; +// // if ( 1 - abs( vtStCurr * vtCurrEn ) < EPS_ZERO && +// // IntersLineBox( ptPLine, vtDLine, ptCubeInf, ptCubeSup, dU1, dU2)) { +// // double dU = abs( dU1) < abs( dU2) ? dU1 + ( dU2 - dU1) / 2 : dU2 + ( dU1 - dU2) / 2 ; +// // ptNew = ptPLine + dU * vtDLine ; +// // } +// // bool bNewInside = IsPointInsideVoxelApprox( CurVox.i, CurVox.j, CurVox.k, ptNew, 0) ; +// // if ( abs( vtStCurr * vtStEn) > 0.95 && abs( vtStCurr * vtCurrEn) > 0.95 && +// // abs( vtStEn * vtCurrEn) > 0.95 /*&& bNewInside*/) { +// // CurVox.Compo[nComp].ptVert = ptNew ; +// // } +// // } +// // } +// // } +// // } +// } +// } +// } +// return true ; +//} +//bool +//VolZmap::RegulateFeaturesChain( vector& vVecVox) const +//{ +// // Ciclo sui blocchi +// for ( int nBlock = 0 ; nBlock < int( m_nNumBlock) ; ++ nBlock) { +// // Se il blocco è da aggiornare +// if ( m_BlockToUpdate[nBlock]) { +// // Ciclo sui voxel interni +// for ( auto itVox = vVecVox[nBlock].begin() ; itVox != vVecVox[nBlock].end() ; ++ itVox) { +// int nVox ; +// Voxel& CurVox = itVox->second ; +// GetVoxNFromIJK( CurVox.i, CurVox.j, CurVox.k, nVox) ; +// // Ciclo sulle componenti +// for ( int nComp = 0 ; nComp < CurVox.nNumComp ; ++ nComp) { +// // Caso feature +// if ( ! CurVox.Compo[nComp].bCorner) { +// // Vertice fuori dal suo voxel +// if ( ! CurVox.Compo[nComp].bInside) { +// int nPointVoxIJK[3] ; +// int nPointVoxN ; +// if ( GetPointVoxel( CurVox.Compo[nComp].ptVert, nPointVoxIJK[0], nPointVoxIJK[1], nPointVoxIJK[2]) && +// GetVoxNFromIJK( nPointVoxIJK[0], nPointVoxIJK[1], nPointVoxIJK[2], nPointVoxN)) { +// auto itPointVox = vVecVox[nBlock].find( nPointVoxN) ; +// Voxel& PointVox = itPointVox->second ; +// for ( int nPoitVoxComp = 0 ; nPoitVoxComp < PointVox.nNumComp ; ++ nPoitVoxComp) { +// if ( ! PointVox.Compo[nPoitVoxComp].bCorner && +// AreSameOrOppositeVectorApprox( CurVox.Compo[nComp].vtNullSpace, +// PointVox.Compo[nPoitVoxComp].vtNullSpace)) { +// Point3d ptAvLine = ( CurVox.Compo[nComp].ptVert + PointVox.Compo[nPoitVoxComp].ptVert) / 2 ; +// Vector3d vtS = CurVox.Compo[nComp].ptVert - ptAvLine ; +// vtS -= ( vtS * CurVox.Compo[nComp].vtNullSpace) * CurVox.Compo[nComp].vtNullSpace ; +// CurVox.Compo[nComp].ptVert -= vtS ; +// break ; +// } +// } +// } +// } +// } +// } +// } +// // Ciclo sui voxel di frontiera +// for ( auto itVox = m_InterBlockVox[nBlock].begin() ; itVox != m_InterBlockVox[nBlock].end() ; ++ itVox) { +// // int nVox ; +// // Voxel& CurVox = itVox->second ; +// // GetVoxNFromIJK( CurVox.i, CurVox.j, CurVox.k, nVox) ; +// //// Ciclo sulle componenti +// // for ( int nComp = 0 ; nComp < CurVox.nNumComp ; ++ nComp) { +// // // Vertice fuori dal suo voxel +// // if ( ! CurVox.Compo[nComp].bInside) { +// // // Caso feature +// // if ( ! CurVox.Compo[nComp].bCorner) { +// // INTVECTOR vNearInn, vNearBord ; +// // FindAdjComp( vVecVox, nBlock, nVox, nComp, vNearInn, vNearBord) ; +// // int nSizeInn = int( vNearInn.size()) ; +// // int nSizeBord = int( vNearBord.size() ); +// // if ( nSizeInn + nSizeBord == 6) { +// // const Voxel* pVoxSt = nullptr ; +// // const Voxel* pVoxEn = nullptr ; +// // if ( nSizeInn == 6) { +// // pVoxSt = &( vVecVox[vNearInn[0]].find( vNearInn[1])->second) ; +// // pVoxEn = &( vVecVox[vNearInn[3]].find( vNearInn[4])->second) ; +// // } +// // else if ( nSizeBord == 6) { +// // pVoxSt = &( m_InterBlockVox[vNearBord[0]].find( vNearBord[1])->second) ; +// // pVoxEn = &( m_InterBlockVox[vNearBord[3]].find( vNearBord[4])->second) ; +// // } +// // else { +// // pVoxSt = &( vVecVox[vNearInn[0]].find( vNearInn[1])->second) ; +// // pVoxEn = &( m_InterBlockVox[vNearBord[0]].find( vNearBord[1])->second) ; +// // } +// // Point3d ptPCur = CurVox.Compo[nComp].ptVert ; +// // Point3d ptPSt ; +// // Point3d ptPEn ; +// // if ( nSizeInn == 6) { +// // ptPSt = pVoxSt->Compo[vNearInn[2]].ptVert ; +// // ptPEn = pVoxEn->Compo[vNearInn[5]].ptVert ; +// // } +// // else if ( nSizeBord == 6) { +// // ptPSt = pVoxSt->Compo[vNearBord[2]].ptVert ; +// // ptPEn = pVoxEn->Compo[vNearBord[5]].ptVert ; +// // } +// // else { +// // ptPSt = pVoxSt->Compo[vNearInn[2]].ptVert ; +// // ptPEn = pVoxEn->Compo[vNearBord[2]].ptVert ; +// // } +// // Vector3d vtStCurr = ptPCur - ptPSt ; +// // Vector3d vtStEn = ptPEn - ptPSt ; +// // Vector3d vtCurrEn = ptPEn - ptPCur ; +// // vtStCurr.Normalize() ; +// // vtStEn.Normalize() ; +// // vtCurrEn.Normalize() ; +// // Point3d ptMid = 0.5 * ( ptPSt + ptPEn) ; +// // double dMidU = ( ptMid - ptPSt) * vtStEn ; +// // double dCurU = ( ptPCur - ptPSt) * vtStEn ; +// // Point3d ptNew ; +// // Point3d ptPLine ; +// // Vector3d vtDLine ; +// // if ( dMidU < dCurU) { +// // ptPLine = ptPEn ; +// // vtDLine = - vtCurrEn ; +// // ptNew = ptPEn + ( ptMid - ptPEn) * vtCurrEn * vtCurrEn ; +// // } +// // else { +// // ptPLine = ptPSt ; +// // vtDLine = vtStCurr ; +// // ptNew = ptPSt + ( ptMid - ptPSt) * vtStCurr * vtStCurr ; +// // } +// // Point3d ptCubeInf( ( CurVox.i * N_DEXVOXRATIO + 0.5) * m_dStep, +// // ( CurVox.j * N_DEXVOXRATIO + 0.5) * m_dStep, +// // ( CurVox.k * N_DEXVOXRATIO + 0.5) * m_dStep) ; +// // Point3d ptCubeSup( ( ( CurVox.i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, +// // ( ( CurVox.j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, +// // ( ( CurVox.k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ; +// // double dU1, dU2 ; +// // if ( 1 - abs( vtStCurr * vtCurrEn ) < EPS_ZERO && +// // IntersLineBox( ptPLine, vtDLine, ptCubeInf, ptCubeSup, dU1, dU2)) { +// // double dU = abs( dU1) < abs( dU2) ? dU1 + ( dU2 - dU1) / 2 : dU2 + ( dU1 - dU2) / 2 ; +// // ptNew = ptPLine + dU * vtDLine ; +// // } +// // bool bNewInside = IsPointInsideVoxelApprox( CurVox.i, CurVox.j, CurVox.k, ptNew, 0) ; +// // if ( abs( vtStCurr * vtStEn) > 0.95 && abs( vtStCurr * vtCurrEn) > 0.95 && +// // abs( vtStEn * vtCurrEn) > 0.95 /*&& bNewInside*/) { +// // CurVox.Compo[nComp].ptVert = ptNew ; +// // } +// // } +// // } +// // } +// // } +// } +// } +// } +// return true ; +//} //---------------------------------------------------------------------------- // A partire dalla struttura dati di tipo voxel con sharp features crea i triangoli corrispondenti. // Accetta come parametri il numero del blocco, l'unordered map di voxel e l'apposito contenitore // ove salva i triangoli. bool -VolZmap::CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVoxel, TriHolder& triHold) const +VolZmap::CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVoxel) const { // Calcolo i limiti sugli indici dei voxel del blocco // Vettore indici i,j,k del blocco @@ -2747,18 +2758,18 @@ VolZmap::CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVoxel, T // Ciclo sui voxel interni for ( auto it = vVoxel.begin() ; it != vVoxel.end() ; ++ it) { - size_t tOldSize = triHold.size() ; - triHold.resize( tOldSize + 1) ; - triHold[tOldSize].i = it->second.i ; - triHold[tOldSize].j = it->second.j ; - triHold[tOldSize].k = it->second.k ; + int tOldSize = int( m_BlockSharpTria[nBlock].size()) ; + m_BlockSharpTria[nBlock].resize( tOldSize + 1) ; + m_BlockSharpTria[nBlock][tOldSize].i = it->second.i ; + m_BlockSharpTria[nBlock][tOldSize].j = it->second.j ; + m_BlockSharpTria[nBlock][tOldSize].k = it->second.k ; // Ciclo sulle componenti connesse del voxel for ( int nComp = 0 ; nComp < it->second.nNumComp ; ++ nComp) { - triHold[tOldSize].ptCompoVert.emplace_back( it->second.Compo[nComp].ptVert) ; - triHold[tOldSize].ptCompoVert.back().ToGlob( m_MapFrame) ; - size_t tOldCompNum = triHold[tOldSize].vCompoTria.size() ; - triHold[tOldSize].vCompoTria.resize( tOldCompNum + 1) ; - triHold[tOldSize].vbFlipped.resize( tOldCompNum + 1) ; + m_BlockSharpTria[nBlock][tOldSize].ptCompoVert.emplace_back( it->second.Compo[nComp].ptVert) ; + m_BlockSharpTria[nBlock][tOldSize].ptCompoVert.back().ToGlob( m_MapFrame) ; + int tOldCompNum = int( m_BlockSharpTria[nBlock][tOldSize].vCompoTria.size()) ; + m_BlockSharpTria[nBlock][tOldSize].vCompoTria.resize( tOldCompNum + 1) ; + m_BlockSharpTria[nBlock][tOldSize].vbFlipped.resize( tOldCompNum + 1) ; // ciclo sui vertici della componente connessa int nNumVert = it->second.Compo[nComp].nVertNum ; for ( int nVert = 0 ; nVert < nNumVert ; ++ nVert) { @@ -2788,36 +2799,36 @@ VolZmap::CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVoxel, T CurrTri.GetVertexNorm( 2))) ; // Valido il triangolo CurrTri.Validate( true) ; - triHold[tOldSize].vCompoTria[tOldCompNum].emplace_back( CurrTri) ; - triHold[tOldSize].vCompoTria[tOldCompNum].back().ToGlob( m_MapFrame) ; - size_t tTri = triHold[tOldSize].vbFlipped[tOldCompNum].size() ; - triHold[tOldSize].vbFlipped[tOldCompNum].resize( tTri + 1) ; - triHold[tOldSize].vbFlipped[tOldCompNum][tTri] = false ; + m_BlockSharpTria[nBlock][tOldSize].vCompoTria[tOldCompNum].emplace_back( CurrTri) ; + m_BlockSharpTria[nBlock][tOldSize].vCompoTria[tOldCompNum].back().ToGlob( m_MapFrame) ; + int nTri = int( m_BlockSharpTria[nBlock][tOldSize].vbFlipped[tOldCompNum].size()) ; + m_BlockSharpTria[nBlock][tOldSize].vbFlipped[tOldCompNum].resize( nTri + 1) ; + m_BlockSharpTria[nBlock][tOldSize].vbFlipped[tOldCompNum][nTri] = false ; } } } // Pulisco il contenitore dei voxel di frontiera - m_InterBlockTria[nBlock].clear() ; + m_InterBlockOriginalSharpTria[nBlock].clear() ; // Ciclo sui voxel di frontiera for ( auto itVox = m_InterBlockVox[nBlock].begin() ; itVox != m_InterBlockVox[nBlock].end() ; ++ itVox) { // Indici del voxel int nVoxIJK[3] = { itVox->second.i, - itVox->second.j, - itVox->second.k} ; + itVox->second.j, + itVox->second.k} ; // Ridimensiono il contenitore dei triangoli interni - int nOldSizeInn = int( triHold.size()) ; - triHold.resize( nOldSizeInn + 1) ; - triHold[nOldSizeInn].i = nVoxIJK[0] ; - triHold[nOldSizeInn].j = nVoxIJK[1] ; - triHold[nOldSizeInn].k = nVoxIJK[2] ; + int nOldSizeInn = int( m_BlockSharpTria[nBlock].size()) ; + m_BlockSharpTria[nBlock].resize( nOldSizeInn + 1) ; + m_BlockSharpTria[nBlock][nOldSizeInn].i = nVoxIJK[0] ; + m_BlockSharpTria[nBlock][nOldSizeInn].j = nVoxIJK[1] ; + m_BlockSharpTria[nBlock][nOldSizeInn].k = nVoxIJK[2] ; // Ridimensiono il contenitore dei triangoli di frontiera - int nOldSizeBor = int( m_InterBlockTria[nBlock].size()) ; - m_InterBlockTria[nBlock].resize( nOldSizeBor + 1) ; - m_InterBlockTria[nBlock][nOldSizeBor].i = nVoxIJK[0] ; - m_InterBlockTria[nBlock][nOldSizeBor].j = nVoxIJK[1] ; - m_InterBlockTria[nBlock][nOldSizeBor].k = nVoxIJK[2] ; + int nOldSizeBor = int( m_InterBlockOriginalSharpTria[nBlock].size()) ; + m_InterBlockOriginalSharpTria[nBlock].resize( nOldSizeBor + 1) ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].i = nVoxIJK[0] ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].j = nVoxIJK[1] ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].k = nVoxIJK[2] ; // Ciclo sulle componenti connesse del voxel for ( int nComp = 0 ; nComp < itVox->second.nNumComp ; ++ nComp) { bool bNewCompInn = true ; @@ -2829,8 +2840,8 @@ VolZmap::CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVoxel, T // Definisco il triangolo Triangle3dEx CurrTri ; CurrTri.Set( itVox->second.Compo[nComp].ptVert, - itVox->second.Compo[nComp].CompVecField[nNextVert].ptPApp, - itVox->second.Compo[nComp].CompVecField[nVert].ptPApp) ; + itVox->second.Compo[nComp].CompVecField[nNextVert].ptPApp, + itVox->second.Compo[nComp].CompVecField[nVert].ptPApp) ; // Setto il numero di utensile ai vertici di base del fan CurrTri.SetAttrib( 1, itVox->second.Compo[nComp].CompVecField[nNextVert].nPropIndex) ; CurrTri.SetAttrib( 2, itVox->second.Compo[nComp].CompVecField[nVert].nPropIndex) ; @@ -2858,36 +2869,36 @@ VolZmap::CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVoxel, T if ( bNewCompBor) { Point3d ptVert = itVox->second.Compo[nComp].ptVert ; ptVert.ToGlob( m_MapFrame) ; - m_InterBlockTria[nBlock][nOldSizeBor].ptCompoVert.emplace_back( ptVert) ; - size_t tOldComp = m_InterBlockTria[nBlock][nOldSizeBor].vCompoTria.size() ; - m_InterBlockTria[nBlock][nOldSizeBor].vCompoTria.resize( tOldComp + 1) ; - m_InterBlockTria[nBlock][nOldSizeBor].vbFlipped.resize( tOldComp + 1) ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].ptCompoVert.emplace_back( ptVert) ; + int tOldComp = int( m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].vCompoTria.size()) ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].vCompoTria.resize( tOldComp + 1) ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].vbFlipped.resize( tOldComp + 1) ; bNewCompBor = false ; } - size_t tCurrSz = m_InterBlockTria[nBlock][nOldSizeBor].vCompoTria.size() ; - m_InterBlockTria[nBlock][nOldSizeBor].vCompoTria[tCurrSz - 1].emplace_back( CurrTri) ; - m_InterBlockTria[nBlock][nOldSizeBor].vCompoTria[tCurrSz - 1].back().ToGlob( m_MapFrame) ; - size_t tTri = m_InterBlockTria[nBlock][nOldSizeBor].vbFlipped[tCurrSz - 1].size() ; - m_InterBlockTria[nBlock][nOldSizeBor].vbFlipped[tCurrSz - 1].resize( tTri + 1) ; - m_InterBlockTria[nBlock][nOldSizeBor].vbFlipped[tCurrSz - 1][tTri] = false ; + int tCurrSz = int( m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].vCompoTria.size()) ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].vCompoTria[tCurrSz - 1].emplace_back( CurrTri) ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].vCompoTria[tCurrSz - 1].back().ToGlob( m_MapFrame) ; + int tTri =int( m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].vbFlipped[tCurrSz - 1].size()) ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].vbFlipped[tCurrSz - 1].resize( tTri + 1) ; + m_InterBlockOriginalSharpTria[nBlock][nOldSizeBor].vbFlipped[tCurrSz - 1][tTri] = false ; } // Triangolo interno else { if ( bNewCompInn) { Point3d ptVert = itVox->second.Compo[nComp].ptVert ; ptVert.ToGlob( m_MapFrame) ; - triHold[nOldSizeInn].ptCompoVert.emplace_back( ptVert) ; - size_t tOldComp = triHold[nOldSizeInn].vCompoTria.size() ; - triHold[nOldSizeInn].vCompoTria.resize( tOldComp + 1) ; - triHold[nOldSizeInn].vbFlipped.resize( tOldComp + 1) ; + m_BlockSharpTria[nBlock][nOldSizeInn].ptCompoVert.emplace_back( ptVert) ; + int tOldComp = int( m_BlockSharpTria[nBlock][nOldSizeInn].vCompoTria.size()) ; + m_BlockSharpTria[nBlock][nOldSizeInn].vCompoTria.resize( tOldComp + 1) ; + m_BlockSharpTria[nBlock][nOldSizeInn].vbFlipped.resize( tOldComp + 1) ; bNewCompInn = false ; } - size_t tCurrSz = triHold[nOldSizeInn].vCompoTria.size() ; - triHold[nOldSizeInn].vCompoTria[tCurrSz - 1].emplace_back( CurrTri) ; - triHold[nOldSizeInn].vCompoTria[tCurrSz - 1].back().ToGlob( m_MapFrame) ; - size_t tTri = triHold[nOldSizeInn].vbFlipped[tCurrSz - 1].size() ; - triHold[nOldSizeInn].vbFlipped[tCurrSz - 1].resize( tTri + 1) ; - triHold[nOldSizeInn].vbFlipped[tCurrSz - 1][tTri] = false ; + int tCurrSz = int( m_BlockSharpTria[nBlock][nOldSizeInn].vCompoTria.size()) ; + m_BlockSharpTria[nBlock][nOldSizeInn].vCompoTria[tCurrSz - 1].emplace_back( CurrTri) ; + m_BlockSharpTria[nBlock][nOldSizeInn].vCompoTria[tCurrSz - 1].back().ToGlob( m_MapFrame) ; + int tTri = int( m_BlockSharpTria[nBlock][nOldSizeInn].vbFlipped[tCurrSz - 1].size()) ; + m_BlockSharpTria[nBlock][nOldSizeInn].vbFlipped[tCurrSz - 1].resize( tTri + 1) ; + m_BlockSharpTria[nBlock][nOldSizeInn].vbFlipped[tCurrSz - 1][tTri] = false ; } } } @@ -2898,11 +2909,11 @@ VolZmap::CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVoxel, T //---------------------------------------------------------------------------- bool -VolZmap::CreateSharpFeatureTriangle( const VoxelContainer& vVoxel, TriHolder& triHold) const +VolZmap::CreateSharpFeatureTriangle( const VoxelContainer& vVoxel, SharpTriHolder& triHold) const { // Ciclo sui voxel interni for ( auto it = vVoxel.begin() ; it != vVoxel.end() ; ++ it) { - size_t tOldSize = triHold.size() ; + int tOldSize = int( triHold.size()) ; triHold.resize( tOldSize + 1) ; triHold[tOldSize].i = it->second.i ; triHold[tOldSize].j = it->second.j ; @@ -2910,8 +2921,7 @@ VolZmap::CreateSharpFeatureTriangle( const VoxelContainer& vVoxel, TriHolder& tr // Ciclo sulle componenti connesse del voxel for ( int nComp = 0 ; nComp < it->second.nNumComp ; ++ nComp) { triHold[tOldSize].ptCompoVert.emplace_back( it->second.Compo[nComp].ptVert) ; - // triHold[tOldSize].ptCompoVert.back().ToGlob( m_MapFrame) ; - size_t tOldCompNum = triHold[tOldSize].vCompoTria.size() ; + int tOldCompNum = int( triHold[tOldSize].vCompoTria.size()) ; triHold[tOldSize].vCompoTria.resize( tOldCompNum + 1) ; triHold[tOldSize].vbFlipped.resize( tOldCompNum + 1) ; // ciclo sui vertici della componente connessa @@ -2945,9 +2955,9 @@ VolZmap::CreateSharpFeatureTriangle( const VoxelContainer& vVoxel, TriHolder& tr CurrTri.Validate( true) ; triHold[tOldSize].vCompoTria[tOldCompNum].emplace_back( CurrTri) ; //triHold[tOldSize].vCompoTria[tOldCompNum].back().ToGlob( m_MapFrame) ; - size_t tTri = triHold[tOldSize].vbFlipped[tOldCompNum].size() ; - triHold[tOldSize].vbFlipped[tOldCompNum].resize( tTri + 1) ; - triHold[tOldSize].vbFlipped[tOldCompNum][tTri] = false ; + int nTri = int( triHold[tOldSize].vbFlipped[tOldCompNum].size()) ; + triHold[tOldSize].vbFlipped[tOldCompNum].resize( nTri + 1) ; + triHold[tOldSize].vbFlipped[tOldCompNum][nTri] = false ; } } } @@ -2956,125 +2966,103 @@ VolZmap::CreateSharpFeatureTriangle( const VoxelContainer& vVoxel, TriHolder& tr } //---------------------------------------------------------------------------- -// Calcola i triangoli dei voxel contenuti nel vettore, se si vuole il riconoscimento -// delle sharp-feature passare true in bEhn. In questo caso vengono analizzai anche i -// voxel adiacenti a quelli contenenti sharp-feature, e viene eseguito il flipping. bool -VolZmap::ExtMarchingCubes( vector& vVox, TRIA3DEXLIST& lstTria, bool bEnh) const +VolZmap::CreateSmoothTriangle( int nIndex, int nVertNum, AppliedVector TriVert[], bool bWasSharp, SmoothTriaStruct& VoxSmoothTria) const { - // - VoxelContainer vVoxCont ; - int nOriginalSize = int( vVox.size()) ; - for ( int nV = 0 ; nV < int( vVox.size()) ; ++ nV) { - // I voxel intersecati dalla retta hanno indice nel vettore - // nV < OriginalSize; quelli adiacenti avranno indice - // nV >= OriginalSize - if ( nV < nOriginalSize) { - // Se a questa iterazione troviamo una sharp-feature - // la dimensione del TriHolder aumenta - int nCurrentSize = int( vVoxCont.size()) ; - ProcessCube( vVox[nV].nI, vVox[nV].nJ, vVox[nV].nK, lstTria, vVoxCont, bEnh) ; - int nNewSize = int( vVoxCont.size()) ; - - // Se abbiamo trovato una sharp-feature - if ( nNewSize > nCurrentSize) { - // Ciclo fra tutti i possibili voxel adiacenti - for ( int i = - 1 ; i <= 1 ; ++ i) { - for ( int j = - 1 ; j <= 1 ; ++ j) { - for ( int k = - 1 ; k <= 1 ; ++ k) { - if ( i == 0 && j == 0 && k == 0) - continue ; - if ( IsValidVoxel( vVox[nV].nI + i, vVox[nV].nJ + j, vVox[nV].nK + k)) { - // Se il voxel adiacente è già nella lista di quelli attraversati dalla retta - // lo ignoro, altrimenti lo metto in coda nel TriHolder. - int nOldV = 0 ; - for ( ; nOldV < nOriginalSize ; ++ nOldV) { - if ( vVox[nOldV].nI == vVox[nV].nI + i || - vVox[nOldV].nJ == vVox[nV].nJ + j || - vVox[nOldV].nK == vVox[nV].nK + k) - continue ; - } - if ( nOldV == nOriginalSize) { - VoxelIndexes NewVox ; - NewVox.nI = vVox[nV].nI + i ; - NewVox.nJ = vVox[nV].nJ + j ; - NewVox.nK = vVox[nV].nK + k ; - vVox.emplace_back( NewVox) ; - } - } - } - } - } + vector vTria ; + // Costruzione dei triangoli + for ( int TriIndex = 0 ; TriIndex < ( nVertNum - 2) * 3 ; TriIndex += 3) { + // Il triangolo è pronto + Triangle3dEx CurrentTriangle ; + CurrentTriangle.Set( TriVert[TriIndex].ptPApp, + TriVert[TriIndex+1].ptPApp, + TriVert[TriIndex+2].ptPApp) ; + // Setto il numero di utensile (conta solo positivo, nullo o negativo) + int nTool0 = Clamp( TriVert[TriIndex].nPropIndex, -1, 1) ; + int nTool1 = Clamp( TriVert[TriIndex+1].nPropIndex, -1, 1) ; + int nTool2 = Clamp( TriVert[TriIndex+2].nPropIndex, -1, 1) ; + if ( nTool0 == nTool1 || nTool0 == nTool2) + CurrentTriangle.SetGrade( nTool0) ; + else if ( nTool1 == nTool2) + CurrentTriangle.SetGrade( nTool1) ; + // Valido il triangolo e setto le normali del campo vettoriale ai corrispondenti vertici + if ( CurrentTriangle.Validate( true)) { + double dCosAngThreshold = bWasSharp ? 0.7 : 0.5 ; + for ( int nV = 0 ; nV < 3 ; ++ nV) { + const Vector3d& vtVertNorm = TriVert[TriIndex+nV].vtVec ; + if ( CurrentTriangle.GetN() * vtVertNorm > dCosAngThreshold) + CurrentTriangle.SetVertexNorm( nV, vtVertNorm) ; + else + CurrentTriangle.SetVertexNorm( nV, CurrentTriangle.GetN()) ; } } - // Se il voxel non è attraversato dalla retta, ma fa parte di - // quelli adiacenti lo processiamo normalmente - else - ProcessCube( vVox[nV].nI, vVox[nV].nJ, vVox[nV].nK, lstTria, vVoxCont, bEnh) ; + // Riporto le coordinate nel sistema in cui è immerso lo Zmap + CurrentTriangle.ToGlob( m_MapFrame) ; + // Aggiungo alla lista + vTria.emplace_back( CurrentTriangle) ; } - - // Contenitore dei triangoli costituenti sharp-feaure - TriHolder triHold ; - CreateSharpFeatureTriangle( vVoxCont, triHold) ; - // Eseguo il flipping - FlipEdgesII( triHold) ; - // Aggiungo alla lista di triangoli, tutti quelli che formano una sharp-feature. - for ( int nVox = 0 ; nVox < int( triHold.size()) ; ++ nVox) { - for ( int nCompo = 0 ; nCompo < int( triHold[nVox].vCompoTria.size()) ; ++ nCompo) { - for ( int nTri = 0 ; nTri < int( triHold[nVox].vCompoTria[nCompo].size()) ; ++ nTri) { - lstTria.emplace_back( triHold[nVox].vCompoTria[nCompo][nTri]) ; - } + // Controllo i colori di configurazioni 2 e 8 + if ( ( nAllConfig[nIndex] == 2 || nAllConfig[nIndex] == 8) && + vTria[0].GetN() * vTria[1].GetN() > 0.8) { + if ( vTria[0].GetGrade() < 0 || vTria[1].GetGrade() < 0) { + vTria[0].SetGrade( -1) ; + vTria[1].SetGrade( -1) ; + } + else if ( vTria[0].GetGrade() > 0 || vTria[1].GetGrade() > 0) { + vTria[0].SetGrade( 1) ; + vTria[1].SetGrade( 1) ; } } - - return true ; + for ( int nT = 0 ; nT < int( vTria.size()) ; ++ nT) + VoxSmoothTria.vTria.emplace_back( vTria[nT]) ; + return true ; } //---------------------------------------------------------------------------- // Esegue il flipping dei triangoli contenuti nel TriHolder, // bGraph indica se chiamata per grafica o per calcolo di profondità. bool -VolZmap::FlipEdgesII( TriHolder& TriHold) const +VolZmap::FlipEdgesII( int nBlock) const { // Numero di voxel in cui si presentano sharp feature - int nVoxelNum = int( TriHold.size()) ; + int nVoxelNum = int( m_BlockSharpTria[nBlock].size()) ; // Ciclo sui voxel con sharp feature for ( int n1 = 0 ; n1 < nVoxelNum ; ++ n1) { for ( int n2 = n1 ; n2 < nVoxelNum ; ++ n2) { // Se i voxel sono adiacenti proseguo - if ( abs( TriHold[n2].i - TriHold[n1].i) <= 1 || - abs( TriHold[n2].j - TriHold[n1].j) <= 1 || - abs( TriHold[n2].k - TriHold[n1].k) <= 1 ) { + if ( abs( m_BlockSharpTria[nBlock][n2].i - m_BlockSharpTria[nBlock][n1].i) <= 1 || + abs( m_BlockSharpTria[nBlock][n2].j - m_BlockSharpTria[nBlock][n1].j) <= 1 || + abs( m_BlockSharpTria[nBlock][n2].k - m_BlockSharpTria[nBlock][n1].k) <= 1 ) { // Numero delle componenti connesse nei due voxel - int nNumCompo1 = int( TriHold[n1].ptCompoVert.size()) ; - int nNumCompo2 = int( TriHold[n2].ptCompoVert.size()) ; + int nNumCompo1 = int( m_BlockSharpTria[nBlock][n1].ptCompoVert.size()) ; + int nNumCompo2 = int( m_BlockSharpTria[nBlock][n2].ptCompoVert.size()) ; // Ciclo sulle componenti int nCompo1 = 0 ; for ( ; nCompo1 < nNumCompo1 ; ++ nCompo1) { int nCompo2 = ( n1 == n2 ? nCompo1 + 1 : 0) ; for ( ; nCompo2 < nNumCompo2 ; ++ nCompo2) { // Numero di triangoli per le componenti connesse - int nTriNum1 = int( TriHold[n1].vCompoTria[nCompo1].size()) ; - int nTriNum2 = int( TriHold[n2].vCompoTria[nCompo2].size()) ; + int nTriNum1 = int( m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1].size()) ; + int nTriNum2 = int( m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2].size()) ; for ( int nTri1 = 0 ; nTri1 < nTriNum1 ; ++ nTri1) { bool bModified = false ; for ( int nTri2 = 0 ; nTri2 < nTriNum2 ; ++ nTri2) { // Punti che devono essere in comune fra i due triangoli - Point3d ptP11 = TriHold[n1].vCompoTria[nCompo1][nTri1].GetP( 1) ; - Point3d ptP12 = TriHold[n1].vCompoTria[nCompo1][nTri1].GetP( 2) ; - Point3d ptP21 = TriHold[n2].vCompoTria[nCompo2][nTri2].GetP( 1) ; - Point3d ptP22 = TriHold[n2].vCompoTria[nCompo2][nTri2].GetP( 2) ; + Point3d ptP11 = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetP( 1) ; + Point3d ptP12 = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetP( 2) ; + Point3d ptP21 = m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetP( 1) ; + Point3d ptP22 = m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetP( 2) ; // I triangoli sono da flippare if ( AreSamePointEpsilon( ptP11, ptP22, EPS_ZERO) && AreSamePointEpsilon( ptP12, ptP21, EPS_ZERO) && - ! ( TriHold[n1].vbFlipped[nCompo1][nTri1] || - TriHold[n2].vbFlipped[nCompo2][nTri2])) { + ! ( m_BlockSharpTria[nBlock][n1].vbFlipped[nCompo1][nTri1] || + m_BlockSharpTria[nBlock][n2].vbFlipped[nCompo2][nTri2])) { // Assegno l'array dei punti di contorno Point3d vPnt[4] ; - vPnt[0] = TriHold[n1].vCompoTria[nCompo1][nTri1].GetP( 1) ; - vPnt[1] = TriHold[n1].ptCompoVert[nCompo1] ; - vPnt[2] = TriHold[n1].vCompoTria[nCompo1][nTri1].GetP( 2) ; - vPnt[3] = TriHold[n2].ptCompoVert[nCompo2] ; + vPnt[0] = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetP( 1) ; + vPnt[1] = m_BlockSharpTria[nBlock][n1].ptCompoVert[nCompo1] ; + vPnt[2] = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetP( 2) ; + vPnt[3] = m_BlockSharpTria[nBlock][n2].ptCompoVert[nCompo2] ; // Valuto se i triangoli giacciono su un piano PolygonPlane Polygon ; for ( int i = 0 ; i < 4 ; ++ i) @@ -3086,8 +3074,8 @@ VolZmap::FlipEdgesII( TriHolder& TriHold) const // Se sono su un piano controllo se avviene inversione bool bInv = false ; if ( bOnPlane) { - Triangle3d trT1 = TriHold[n1].vCompoTria[nCompo1][nTri1] ; - Triangle3d trT2 = TriHold[n2].vCompoTria[nCompo2][nTri2] ; + Triangle3d trT1 = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1] ; + Triangle3d trT2 = m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2] ; int nVert1, nVert2 ; // Determino gli indici dei punti sharp-feature for ( int nP = 0 ; nP < 3 ; ++ nP) { @@ -3105,26 +3093,26 @@ VolZmap::FlipEdgesII( TriHolder& TriHold) const // Se non vi è inversione eseguo il flipping if ( ! bInv) { // Vertice condiviso fra nTri1 e quello del suo fan - int nCol1 = TriHold[n1].vCompoTria[nCompo1][nTri1].GetAttrib( 2) ; - int nCol2 = TriHold[n2].vCompoTria[nCompo2][nTri2].GetAttrib( 2) ; + int nCol1 = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetAttrib( 2) ; + int nCol2 = m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetAttrib( 2) ; // Modifico i punti e gli indici - TriHold[n1].vCompoTria[nCompo1][nTri1].SetP( 1, TriHold[n2].ptCompoVert[nCompo2]) ; - TriHold[n2].vCompoTria[nCompo2][nTri2].SetP( 1, TriHold[n1].ptCompoVert[nCompo1]) ; - TriHold[n1].vCompoTria[nCompo1][nTri1].SetGrade( nCol1) ; - TriHold[n2].vCompoTria[nCompo2][nTri2].SetGrade( nCol2) ; + m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].SetP( 1, m_BlockSharpTria[nBlock][n2].ptCompoVert[nCompo2]) ; + m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].SetP( 1, m_BlockSharpTria[nBlock][n1].ptCompoVert[nCompo1]) ; + m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].SetGrade( nCol1) ; + m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].SetGrade( nCol2) ; // Setto le normali - Vector3d vtN1 = TriHold[n1].vCompoTria[nCompo1][nTri1].GetVertexNorm( 2) ; - Vector3d vtN2 = TriHold[n2].vCompoTria[nCompo2][nTri2].GetVertexNorm( 2) ; - TriHold[n1].vCompoTria[nCompo1][nTri1].SetVertexNorm( 0, vtN1) ; - TriHold[n1].vCompoTria[nCompo1][nTri1].SetVertexNorm( 1, vtN1) ; - TriHold[n2].vCompoTria[nCompo2][nTri2].SetVertexNorm( 0, vtN2) ; - TriHold[n2].vCompoTria[nCompo2][nTri2].SetVertexNorm( 1, vtN2) ; + Vector3d vtN1 = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetVertexNorm( 2) ; + Vector3d vtN2 = m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetVertexNorm( 2) ; + m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].SetVertexNorm( 0, vtN1) ; + m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].SetVertexNorm( 1, vtN1) ; + m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].SetVertexNorm( 0, vtN2) ; + m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].SetVertexNorm( 1, vtN2) ; // Setto i triangoli come flippati - TriHold[n1].vbFlipped[nCompo1][nTri1] = true ; - TriHold[n2].vbFlipped[nCompo2][nTri2] = true ; + m_BlockSharpTria[nBlock][n1].vbFlipped[nCompo1][nTri1] = true ; + m_BlockSharpTria[nBlock][n2].vbFlipped[nCompo2][nTri2] = true ; // Valido i triangoli - TriHold[n1].vCompoTria[nCompo1][nTri1].Validate( true) ; - TriHold[n2].vCompoTria[nCompo2][nTri2].Validate( true) ; + m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].Validate( true) ; + m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].Validate( true) ; // Avvenuto flipping bModified = true ; break ; @@ -3134,14 +3122,14 @@ VolZmap::FlipEdgesII( TriHolder& TriHold) const // quindi hanno normali concordi. A entrambi assegno il colore del vertice con // normale più concorde a quella del triangolo double dDotVec[4] ; - dDotVec[0] = TriHold[n1].vCompoTria[nCompo1][nTri1].GetN() * - TriHold[n1].vCompoTria[nCompo1][nTri1].GetVertexNorm( 1) ; - dDotVec[1] = TriHold[n2].vCompoTria[nCompo2][nTri2].GetN() * - TriHold[n2].vCompoTria[nCompo2][nTri2].GetVertexNorm( 2) ; - dDotVec[2] = TriHold[n1].vCompoTria[nCompo1][nTri1].GetN() * - TriHold[n1].vCompoTria[nCompo1][nTri1].GetVertexNorm( 2) ; - dDotVec[3] = TriHold[n2].vCompoTria[nCompo2][nTri2].GetN() * - TriHold[n2].vCompoTria[nCompo2][nTri2].GetVertexNorm( 1) ; + dDotVec[0] = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetN() * + m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetVertexNorm( 1) ; + dDotVec[1] = m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetN() * + m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetVertexNorm( 2) ; + dDotVec[2] = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetN() * + m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetVertexNorm( 2) ; + dDotVec[3] = m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetN() * + m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetVertexNorm( 1) ; // Cerco il massimo dei prodotti scalari int nMaxPos = 0 ; double dMaxDot = - 1 ; @@ -3155,21 +3143,21 @@ VolZmap::FlipEdgesII( TriHolder& TriHold) const int nCol ; switch ( nMaxPos) { case 0 : - nCol = TriHold[n1].vCompoTria[nCompo1][nTri1].GetAttrib( 1) ; + nCol = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetAttrib( 1) ; break ; case 1 : - nCol = TriHold[n2].vCompoTria[nCompo2][nTri2].GetAttrib( 2) ; + nCol = m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetAttrib( 2) ; break ; case 2 : - nCol = TriHold[n1].vCompoTria[nCompo1][nTri1].GetAttrib( 2) ; + nCol = m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].GetAttrib( 2) ; break ; case 3 : - nCol = TriHold[n2].vCompoTria[nCompo2][nTri2].GetAttrib( 1) ; + nCol = m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].GetAttrib( 1) ; break ; } // Assegno il colore ai triangoli - TriHold[n1].vCompoTria[nCompo1][nTri1].SetGrade( nCol) ; - TriHold[n2].vCompoTria[nCompo2][nTri2].SetGrade( nCol) ; + m_BlockSharpTria[nBlock][n1].vCompoTria[nCompo1][nTri1].SetGrade( nCol) ; + m_BlockSharpTria[nBlock][n2].vCompoTria[nCompo2][nTri2].SetGrade( nCol) ; } } } @@ -3186,15 +3174,15 @@ VolZmap::FlipEdgesII( TriHolder& TriHold) const //---------------------------------------------------------------------------- bool -VolZmap::FlipEdgesBB( TriaMatrix& InterTria) const +VolZmap::FlipEdgesBB() const { // Numero di blocchi - size_t nBlocksNum = InterTria.size() ; + int nBlocksNum = int( m_InterBlockToBeFlippedSharpTria.size()) ; // ciclo sui blocchi - for ( size_t tFB = 0 ; tFB < nBlocksNum ; ++ tFB) { + for ( int tFB = 0 ; tFB < nBlocksNum ; ++ tFB) { int nFBijk[3] ; GetBlockIJKFromN( int( tFB), nFBijk) ; - for ( size_t tLB = tFB ; tLB < nBlocksNum ; ++ tLB) { + for ( int tLB = tFB ; tLB < nBlocksNum ; ++ tLB) { int nLBijk[3] ; GetBlockIJKFromN( int( tLB), nLBijk) ; // Se i blocchi non sono adiacenti salto l'iterazione @@ -3203,45 +3191,45 @@ VolZmap::FlipEdgesBB( TriaMatrix& InterTria) const abs( nFBijk[2] - nLBijk[2]) <= 1)) continue ; // Numero di voxel nei blocchi correnti - size_t nVoxelNumFB = InterTria[tFB].size() ; - size_t nVoxelNumLB = InterTria[tLB].size() ; + int nVoxelNumFB = int( m_InterBlockToBeFlippedSharpTria[tFB].size()) ; + int nVoxelNumLB = int( m_InterBlockToBeFlippedSharpTria[tLB].size()) ; // Ciclo sui voxel dei due blocchi - for ( size_t tVFB = 0 ; tVFB < nVoxelNumFB ; ++ tVFB) { - for ( size_t tVLB = 0 ; tVLB < nVoxelNumLB ; ++ tVLB) { + for ( int tVFB = 0 ; tVFB < nVoxelNumFB ; ++ tVFB) { + for ( int tVLB = 0 ; tVLB < nVoxelNumLB ; ++ tVLB) { // Se i voxel non sono adiacenti salto l'iterazione - if ( ! ( abs( InterTria[tFB][tVFB].i - InterTria[tLB][tVLB].i) <= 1 && - abs( InterTria[tFB][tVFB].j - InterTria[tLB][tVLB].j) <= 1 && - abs( InterTria[tFB][tVFB].k - InterTria[tLB][tVLB].k) <= 1)) + if ( ! ( abs( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].i - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].i) <= 1 && + abs( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].j - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].j) <= 1 && + abs( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].k - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].k) <= 1)) continue ; // Numero di componenti connesse dei voxel - size_t nCompoVFBNum = InterTria[tFB][tVFB].ptCompoVert.size() ; - size_t nCompoVLBNum = InterTria[tLB][tVLB].ptCompoVert.size() ; + int nCompoVFBNum = int( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].ptCompoVert.size()) ; + int nCompoVLBNum = int( m_InterBlockToBeFlippedSharpTria[tLB][tVLB].ptCompoVert.size()) ; // Ciclo sulle componenti connesse - for ( size_t tCmpF = 0 ; tCmpF < nCompoVFBNum ; ++ tCmpF) { - for ( size_t tCmpL = 0 ; tCmpL < nCompoVLBNum ; ++ tCmpL) { + for ( int tCmpF = 0 ; tCmpF < nCompoVFBNum ; ++ tCmpF) { + for ( int tCmpL = 0 ; tCmpL < nCompoVLBNum ; ++ tCmpL) { // Numero di triangoli delle componenti connesse - size_t nTriFBNum = InterTria[tFB][tVFB].vCompoTria[tCmpF].size() ; - size_t nTriLBNum = InterTria[tLB][tVLB].vCompoTria[tCmpL].size() ; + int nTriFBNum = int( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF].size()) ; + int nTriLBNum = int( m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL].size()) ; // Ciclo sui triangoli - for ( size_t tTriFB = 0 ; tTriFB < nTriFBNum ; ++ tTriFB) { + for ( int tTriFB = 0 ; tTriFB < nTriFBNum ; ++ tTriFB) { bool bModified = false ; - for ( size_t tTriLB = 0 ; tTriLB < nTriLBNum ; ++ tTriLB) { + for ( int tTriLB = 0 ; tTriLB < nTriLBNum ; ++ tTriLB) { // Punti che devono essere in comune fra i due triangoli - Point3d ptPF1 = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ; - Point3d ptPF2 = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ; - Point3d ptPL1 = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 1) ; - Point3d ptPL2 = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 2) ; + Point3d ptPF1 = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ; + Point3d ptPF2 = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ; + Point3d ptPL1 = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 1) ; + Point3d ptPL2 = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 2) ; // Si deve operare la modifica dei triangoli if ( AreSamePointEpsilon( ptPF1, ptPL2, EPS_ZERO) && AreSamePointEpsilon( ptPF2, ptPL1, EPS_ZERO) && - ! ( InterTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] || - InterTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB])) { + ! ( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] || + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB])) { // Assegno l'array dei punti di contorno Point3d vPnt[4] ; - vPnt[0] = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ; - vPnt[1] = InterTria[tFB][tVFB].ptCompoVert[tCmpF] ; - vPnt[2] = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ; - vPnt[3] = InterTria[tLB][tVLB].ptCompoVert[tCmpL] ; + vPnt[0] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ; + vPnt[1] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].ptCompoVert[tCmpF] ; + vPnt[2] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ; + vPnt[3] = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].ptCompoVert[tCmpL] ; // Valuto se i triangoli giacciono su un piano PolygonPlane Polygon ; for ( int i = 0 ; i < 4 ; ++ i) @@ -3253,8 +3241,8 @@ VolZmap::FlipEdgesBB( TriaMatrix& InterTria) const // Se sono su un piano controllo se avviene inversione bool bInv = false ; if ( bOnPlane) { - Triangle3dEx trTF = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB] ; - Triangle3dEx trTL = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB] ; + Triangle3dEx trTF = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB] ; + Triangle3dEx trTL = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB] ; int nVertF, nVertL ; // Determino gli indici dei punti sharp-feature for ( int nP = 0 ; nP < 3 ; ++ nP) { @@ -3272,26 +3260,26 @@ VolZmap::FlipEdgesBB( TriaMatrix& InterTria) const // Se non vi è inversione eseguo il flipping if ( ! bInv) { // Vertice condiviso fra nTri1 e quello del suo fan - int nColF = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ; - int nColL = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ; + int nColF = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ; + int nColL = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ; // modifico punti e colori - InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetP( 1, InterTria[tLB][tVLB].ptCompoVert[tCmpL]) ; - InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetP( 1, InterTria[tFB][tVFB].ptCompoVert[tCmpF]) ; - InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nColF) ; - InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nColL) ; + m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetP( 1, m_InterBlockToBeFlippedSharpTria[tLB][tVLB].ptCompoVert[tCmpL]) ; + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetP( 1, m_InterBlockToBeFlippedSharpTria[tFB][tVFB].ptCompoVert[tCmpF]) ; + m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nColF) ; + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nColL) ; // Valido i triangoli - InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].Validate( true) ; - InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].Validate( true) ; + m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].Validate( true) ; + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].Validate( true) ; // Setto le normali a ogni vertice - Vector3d vtNormF = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ; - Vector3d vtNormL = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ; - InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 1, vtNormF) ; - InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 0, vtNormF) ; - InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 1, vtNormL) ; - InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 0, vtNormL) ; + Vector3d vtNormF = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ; + Vector3d vtNormL = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ; + m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 1, vtNormF) ; + m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 0, vtNormF) ; + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 1, vtNormL) ; + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 0, vtNormL) ; // Setto i triangoli come flippati - InterTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] = true ; - InterTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB] = true ; + m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] = true ; + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB] = true ; bModified = true ; break ; } @@ -3300,14 +3288,14 @@ VolZmap::FlipEdgesBB( TriaMatrix& InterTria) const // quindi hanno normali concordi. A entrambi assegno il colore del vertice con // normale più concorde a quella del triangolo double dDotVec[4] ; - dDotVec[0] = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() * - InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 1) ; - dDotVec[1] = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() * - InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ; - dDotVec[2] = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() * - InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ; - dDotVec[3] = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() * - InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 1) ; + dDotVec[0] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() * + m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 1) ; + dDotVec[1] = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() * + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ; + dDotVec[2] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() * + m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ; + dDotVec[3] = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() * + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 1) ; // Cerco il massimo dei prodotti scalari int nMaxPos = 0 ; double dMaxDot = - 1 ; @@ -3321,21 +3309,21 @@ VolZmap::FlipEdgesBB( TriaMatrix& InterTria) const int nCol ; switch ( nMaxPos) { case 0 : - nCol = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 1) ; + nCol = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 1) ; break ; case 1 : - nCol = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ; + nCol = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ; break ; case 2 : - nCol = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ; + nCol = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ; break ; case 3 : - nCol = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 1) ; + nCol = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 1) ; break ; } // Assegno il colore ai triangoli - InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nCol) ; - InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nCol) ; + m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nCol) ; + m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nCol) ; } } } @@ -3370,7 +3358,7 @@ VolZmap::IsThereMat( int nI, int nJ, int nK) const int nCount = 0 ; for ( int nGrid = 0 ; nGrid < int ( m_nMapNum) ; ++ nGrid) { // assegnazione dati vertice dipendenti dalla griglia - unsigned int nGrI, nGrJ ; + int nGrI, nGrJ ; double dZ ; switch ( nGrid) { case 0 : @@ -3390,27 +3378,16 @@ VolZmap::IsThereMat( int nI, int nJ, int nK) const break ; } // verifica spillone su vertice - unsigned int nPos = nGrJ * m_nNx[nGrid] + nGrI ; + int nIndex = 0 ; + int nPos = nGrJ * m_nNx[nGrid] + nGrI ; int nDexSize = int( m_Values[nGrid][nPos].size()) ; - int nMin = 0 ; - int nMax = nDexSize - 1 ; - if ( nMin <= nMax && - dZ >= m_Values[nGrid][nPos][nMin].dMin - 2 * EPS_SMALL && - dZ <= m_Values[nGrid][nPos][nMax].dMax + 2 * EPS_SMALL) { - while ( nMin <= nMax) { - int nTest = ( nMin + nMax) / 2 ; - // se prima - if ( dZ < m_Values[nGrid][nPos][nTest].dMin - 2 * EPS_SMALL) - nMax = nTest - 1 ; - // se altrimenti dopo - else if ( dZ > m_Values[nGrid][nPos][nTest].dMax + 2 * EPS_SMALL) - nMin = nTest + 1 ; - // altrimenti è nell'intervallo, trovato ed esco - else { - ++ nCount ; - break ; - } - } + while ( nIndex < nDexSize) { + if ( dZ > m_Values[nGrid][nPos][nIndex].dMin - 2 * EPS_SMALL && + dZ < m_Values[nGrid][nPos][nIndex].dMax + 2 * EPS_SMALL) { + ++ nCount ; + break ; + } + nIndex += 1 ; } } return ( nCount == 3) ; @@ -3459,7 +3436,7 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, AppliedVector& vfField.ptPApp.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ; vfField.ptPApp.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ; - size_t nDexel = ( nVec1[2] * m_nNx[1] + nVec1[1]) * N_DEXVOXRATIO ; + int nDexel = ( nVec1[2] * m_nNx[1] + nVec1[1]) * N_DEXVOXRATIO ; int nSize = int( m_Values[1][nDexel].size()) ; if ( bFirstCorner) { @@ -3511,7 +3488,7 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, AppliedVector& vfField.ptPApp.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ; vfField.ptPApp.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ; - size_t nDexel = ( nVec1[0] * m_nNx[2] + nVec1[2]) * N_DEXVOXRATIO ; + int nDexel = ( nVec1[0] * m_nNx[2] + nVec1[2]) * N_DEXVOXRATIO ; int nSize = int( m_Values[2][nDexel].size()) ; if ( bFirstCorner) { @@ -3563,7 +3540,7 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, AppliedVector& vfField.ptPApp.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ; vfField.ptPApp.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ; - size_t nDexel = ( nVec1[1] * m_nNx[0] + nVec1[0]) * N_DEXVOXRATIO ; + int nDexel = ( nVec1[1] * m_nNx[0] + nVec1[0]) * N_DEXVOXRATIO ; int nSize = int( m_Values[0][nDexel].size()) ; if ( bFirstCorner) { @@ -3612,11 +3589,11 @@ bool 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 nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumX = m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumY = m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2) ; + int nVoxNumZ = m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2) ; // Verifico la validità del voxel - return ( nN >= 0 && nN < int( nVoxNumX * nVoxNumY * nVoxNumZ)) ; + return ( nN >= 0 && nN < ( nVoxNumX * nVoxNumY * nVoxNumZ)) ; } //---------------------------------------------------------------------------- @@ -4080,7 +4057,7 @@ VolZmap::IsTriangleOnBorder( const Triangle3dEx& trTria, const int nBlockLimits[ //---------------------------------------------------------------------------- bool -VolZmap::ProcessVoxContXY( FlatVoxelContainer& VoxContXY, bool bPlus, TRIA3DEXLIST& lstTria) const +VolZmap::ProcessVoxContXY( FlatVoxelContainer& VoxContXY, int nBlock, bool bPlus) const { for ( auto it = VoxContXY.cbegin() ; it != VoxContXY.end() ; @@ -4188,8 +4165,8 @@ VolZmap::ProcessVoxContXY( FlatVoxelContainer& VoxContXY, bool bPlus, TRIA3DEXLI bool bV0 = Tria0.Validate( true) ; bool bV1 = Tria1.Validate( true) ; // Aggiungo alla lista - lstTria.emplace_back( Tria0) ; - lstTria.emplace_back( Tria1) ; + m_BlockBigTria[nBlock].emplace_back( Tria0) ; + m_BlockBigTria[nBlock].emplace_back( Tria1) ; // Elimino il voxel da cui sono partito a ingrandire. VoxContXY.erase( nN) ; @@ -4200,7 +4177,7 @@ VolZmap::ProcessVoxContXY( FlatVoxelContainer& VoxContXY, bool bPlus, TRIA3DEXLI //---------------------------------------------------------------------------- bool -VolZmap::ProcessVoxContYZ( FlatVoxelContainer& VoxContYZ, bool bPlus, TRIA3DEXLIST& lstTria) const +VolZmap::ProcessVoxContYZ( FlatVoxelContainer& VoxContYZ, int nBlock, bool bPlus) const { for ( auto it = VoxContYZ.begin() ; it != VoxContYZ.end() ; @@ -4308,8 +4285,8 @@ VolZmap::ProcessVoxContYZ( FlatVoxelContainer& VoxContYZ, bool bPlus, TRIA3DEXLI bool bV0 = Tria0.Validate( true) ; bool bV1 = Tria1.Validate( true) ; // Aggiungo alla lista - lstTria.emplace_back( Tria0) ; - lstTria.emplace_back( Tria1) ; + m_BlockBigTria[nBlock].emplace_back( Tria0) ; + m_BlockBigTria[nBlock].emplace_back( Tria1) ; // Elimino il voxel da cui sono partito a ingrandire. VoxContYZ.erase( nN) ; @@ -4320,7 +4297,7 @@ VolZmap::ProcessVoxContYZ( FlatVoxelContainer& VoxContYZ, bool bPlus, TRIA3DEXLI //---------------------------------------------------------------------------- bool -VolZmap::ProcessVoxContXZ( FlatVoxelContainer& VoxContXZ, bool bPlus, TRIA3DEXLIST& lstTria) const +VolZmap::ProcessVoxContXZ( FlatVoxelContainer& VoxContXZ, int nBlock, bool bPlus) const { for ( auto it = VoxContXZ.begin() ; it != VoxContXZ.end() ; @@ -4428,8 +4405,8 @@ VolZmap::ProcessVoxContXZ( FlatVoxelContainer& VoxContXZ, bool bPlus, TRIA3DEXLI bool bV0 = Tria0.Validate( true) ; bool bV1 = Tria1.Validate( true) ; // Aggiungo alla lista - lstTria.emplace_back( Tria0) ; - lstTria.emplace_back( Tria1) ; + m_BlockBigTria[nBlock].emplace_back( Tria0) ; + m_BlockBigTria[nBlock].emplace_back( Tria1) ; // Elimino il voxel da cui sono partito a ingrandire. VoxContXZ.erase( nN) ; diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 9996d35..80ed107 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -27,7 +27,7 @@ using namespace std ; //---------------------------------------------------------------------------- bool -VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, +VolZmap::SubtractIntervals( int nGrid, int nI, int nJ, double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) { // Controllo che dMin e dMax non siano quasi coincidenti @@ -66,7 +66,7 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ } // Recupero dexel da modificare - unsigned int nPos = nJ * m_nNx[nGrid] + nI ; + int nPos = nJ * m_nNx[nGrid] + nI ; vector& vDexel = m_Values[nGrid][nPos] ; // Ciclo sugli intervalli del dexel (ordinati in senso crescente) @@ -237,7 +237,7 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ //---------------------------------------------------------------------------- bool -VolZmap::AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, +VolZmap::AddIntervals( int nGrid, int nI, int nJ, double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) { // // Controllo che dMin e dMax non siano quasi coincidenti @@ -550,7 +550,7 @@ VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& } // Ciclo sulle mappe - for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { + for ( int i = 0 ; i < m_nMapNum ; ++ i) { // Direzione utensile costante: pura traslazione if ( AreSameVectorApprox( vtLs[i], vtLe[i])) { @@ -761,10 +761,10 @@ VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& // ---------- Cilindro e sfera ----------------------------------------------- //---------------------------------------------------------------------------- bool -VolZmap::CylBall_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) +VolZmap::CylBall_ZDrilling( int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestToolBBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -783,8 +783,8 @@ VolZmap::CylBall_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point double dMinStemZ = min( min( ptS.z, ptTStemS.z), min( ptE.z, ptTStemE.z)) ; double dMaxStemZ = max( max( ptS.z, ptTStemS.z), max( ptE.z, ptTStemE.z)) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; Point3d ptC( dX, dY, 0) ; Vector3d vtC = ptC - ptSxy ; @@ -816,10 +816,10 @@ VolZmap::CylBall_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point //---------------------------------------------------------------------------- bool -VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::CylBall_ZPerp( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestToolBBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -848,8 +848,8 @@ VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& p Vector3d vtV2 = vtV1 ; vtV2.Rotate( Z_AX, 0, 1) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -942,10 +942,10 @@ VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& p //---------------------------------------------------------------------------- bool -VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) +VolZmap::CylBall_ZMilling( int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestToolBBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -1004,8 +1004,8 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3 double dMin, dMax ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -1075,10 +1075,10 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3 // ---------- Coni ----------------------------------------------------------- //---------------------------------------------------------------------------- bool -VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) +VolZmap::Conus_ZDrilling( int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestToolBBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -1107,8 +1107,8 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d if ( m_Tool.GetTipRadius() < m_Tool.GetRadius()) { // Ciclo sui punti - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -1162,8 +1162,8 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d else { // Ciclo sui punti - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -1216,10 +1216,10 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d //---------------------------------------------------------------------------- bool -VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) +VolZmap::Conus_ZPerp( int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestToolBBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -1262,8 +1262,8 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p Point3d ptVS = ptS - vtToolDir * ( dStemHeigth + dL) ; Point3d ptVE = ptE - vtToolDir * ( dStemHeigth + dL) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -1389,8 +1389,8 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p Point3d ptVS = ptS - vtToolDir * ( m_Tool.GetHeigth() - dL) ; Point3d ptVE = ptE - vtToolDir * ( m_Tool.GetHeigth() - dL) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -1506,7 +1506,7 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p //---------------------------------------------------------------------------- bool -VolZmap::Conus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::Conus_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { double dStemH = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ; @@ -1531,7 +1531,7 @@ VolZmap::Conus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& // ---------------------------------------------------------------------------- bool -VolZmap::Mrt_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) +VolZmap::Mrt_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { // Proiezione della traiettoria sul piano dei movimenti possibili Vector3d vtMoveOnP = ( ptE - ptS) * vtToolDir * vtToolDir ; @@ -1584,7 +1584,7 @@ VolZmap::Mrt_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& p //---------------------------------------------------------------------------- bool -VolZmap::Mrt_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) +VolZmap::Mrt_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { // Proiezione della traiettoria sul piano di movimento Vector3d vtPlV = vtToolDir ^ vtAux ; @@ -1637,7 +1637,7 @@ VolZmap::Mrt_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& pt //---------------------------------------------------------------------------- bool -VolZmap::Chs_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) +VolZmap::Chs_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { CompPar_ZDrilling( nGrid, m_Tool.GetMrtChsWidth(), m_Tool.GetMrtChsThickness(), m_Tool.GetHeigth(), ptS, ptE, vtToolDir, vtAux) ; @@ -1646,7 +1646,7 @@ VolZmap::Chs_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& p //---------------------------------------------------------------------------- bool -VolZmap::Chs_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) +VolZmap::Chs_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { // Proiezione della traiettoria sul piano dei moti possibili Point3d ptSp = ptS ; @@ -1662,7 +1662,7 @@ VolZmap::Chs_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& pt //---------------------------------------------------------------------------- bool -VolZmap::GenTool_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::GenTool_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Descrizione geometrica del moto Point3d ptI = ptS ; @@ -1738,7 +1738,7 @@ VolZmap::GenTool_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3 //---------------------------------------------------------------------------- bool -VolZmap::GenTool_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::GenTool_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Descrizione geometrica del moto Point3d ptI = ptS ; @@ -1817,10 +1817,10 @@ VolZmap::GenTool_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d // --------- Cilindro e sfera ------------------------------------------------ //---------------------------------------------------------------------------- bool -VolZmap::CylBall_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::CylBall_XYDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestToolBBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -1843,8 +1843,8 @@ VolZmap::CylBall_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point Vector3d vtV2 = vtV1 ; vtV2.Rotate( Z_AX, 0, 1) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -1899,10 +1899,10 @@ VolZmap::CylBall_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point //---------------------------------------------------------------------------- bool -VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d & vtToolDir) +VolZmap::CylBall_XYPerp( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d & vtToolDir) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestToolBBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -1963,8 +1963,8 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& if ( dLenXY < EPS_SMALL) { - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -2020,8 +2020,8 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& } else { - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -2163,7 +2163,7 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& //---------------------------------------------------------------------------- bool -VolZmap::CylBall_XYMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::CylBall_XYMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { if ( m_Tool.GetType() == Tool::CYLMILL) return CompCyl_Milling( nGrid, ptS, ptE, vtToolDir, m_Tool.GetHeigth(), m_Tool.GetRadius(), false, false) ; @@ -2183,10 +2183,10 @@ VolZmap::CylBall_XYMilling( unsigned int nGrid, const Point3d& ptS, const Point3 // --------- Coni ------------------------------------------------------------ //---------------------------------------------------------------------------- bool -VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::Conus_XYDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestToolBBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -2230,8 +2230,8 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d Point3d ptIxy( ptI.x, ptI.y, 0) ; // Ciclo sui punti - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -2312,10 +2312,10 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d //---------------------------------------------------------------------------- bool -VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::Conus_XYPerp( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestToolBBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -2361,8 +2361,8 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt Vector3d vtV1 = - vtToolDir ; Vector3d vtV2( - vtV1.y, vtV1.x, 0) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -2466,8 +2466,8 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt Vector3d vtNmin, vtNmax ; Point3d ptInt ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -2614,7 +2614,7 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt //---------------------------------------------------------------------------- bool -VolZmap::Conus_XYMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::Conus_XYMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { double dStemHeigth = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ; @@ -2640,7 +2640,7 @@ VolZmap::Conus_XYMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& // ---------- Cilindro e sfera ----------------------------------------------- //---------------------------------------------------------------------------- bool -VolZmap::CylBall_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::CylBall_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Altezza cilindro double dStemHeigth = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ; @@ -2657,7 +2657,7 @@ VolZmap::CylBall_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d //---------------------------------------------------------------------------- bool -VolZmap::CylBall_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::CylBall_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Altezza cilindro double dStemHeigth = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ; @@ -2675,7 +2675,7 @@ VolZmap::CylBall_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& // ---------- Coni ----------------------------------------------------------- //---------------------------------------------------------------------------- bool -VolZmap::Conus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::Conus_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { double dStemHeigth = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ; @@ -2699,7 +2699,7 @@ VolZmap::Conus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& //---------------------------------------------------------------------------- bool -VolZmap::Conus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::Conus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { double dStemHeigth = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ; @@ -2726,7 +2726,7 @@ VolZmap::Conus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& p // ---------- Mortasatrice --------------------------------------------------- //---------------------------------------------------------------------------- bool -VolZmap::Mrt_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) +VolZmap::Mrt_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { // Proiezione della traiettoria sul piano dei movimenti possibili Point3d ptEOnP = ptS + ( ptE - ptS) * vtToolDir * vtToolDir ; @@ -2776,7 +2776,7 @@ VolZmap::Mrt_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& pt //---------------------------------------------------------------------------- bool -VolZmap::Mrt_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) +VolZmap::Mrt_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { // Proiezione della traiettoria sul piano dei movimenti possibili Point3d ptSp = ptS ; @@ -2828,7 +2828,7 @@ VolZmap::Mrt_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE // ---------- Chisel --------------------------------------------------------- //---------------------------------------------------------------------------- bool -VolZmap::Chs_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) +VolZmap::Chs_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { // Proiezione della traiettoria sulla varietà del movimento Point3d ptProjE = ptS + ( ptE - ptS) * vtToolDir * vtToolDir ; @@ -2840,7 +2840,7 @@ VolZmap::Chs_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& pt //---------------------------------------------------------------------------- bool -VolZmap::Chs_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) +VolZmap::Chs_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { // Proiezione della traiettoria sul piano dei movimenti possibili Vector3d vtMoveOnP = ( ptE - ptS) - ( ptE - ptS) * vtToolDir * vtToolDir ; @@ -2854,7 +2854,7 @@ VolZmap::Chs_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE // ---------- Utensile generico ---------------------------------------------- //---------------------------------------------------------------------------- bool -VolZmap::GenTool_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::GenTool_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Descrizione geometrica del moto Point3d ptI = ptS ; @@ -2958,7 +2958,7 @@ VolZmap::GenTool_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d //---------------------------------------------------------------------------- bool -VolZmap::GenTool_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +VolZmap::GenTool_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) { // Descrizione geometrica del moto Point3d ptI = ptS ; @@ -3065,10 +3065,10 @@ VolZmap::GenTool_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& //---------------------------------------------------------------------------- bool -VolZmap::CompCyl_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad) +VolZmap::CompCyl_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad) { // Verifica sull'interferenza con lo Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3087,8 +3087,8 @@ VolZmap::CompCyl_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3 double dMaxStemZ = max( max( ptS.z, ptTStemS.z), max( ptE.z, ptTStemE.z)) ; // Ciclo sui punti - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -3108,10 +3108,10 @@ VolZmap::CompCyl_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3 //---------------------------------------------------------------------------- bool -VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) +VolZmap::CompConus_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) { // Verifica sull'interferenza con lo Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3143,8 +3143,8 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Poin Vector3d vtMin, vtMax ; // Ciclo sui punti - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -3200,7 +3200,7 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Poin //---------------------------------------------------------------------------- bool -VolZmap::CompPar_ZDrilling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ, +VolZmap::CompPar_ZDrilling( int nGrid, double dLenX, double dLenY, double dLenZ, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { @@ -3212,7 +3212,7 @@ VolZmap::CompPar_ZDrilling( unsigned int nGrid, double dLenX, double dLenY, doub dLenZ -= ( 2 * EPS_SMALL) ; // Controllo sull'interferenza utensile-solido - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestParaBBox( nGrid, ptMyS, ptMyE, vtToolDir, vtAux, dLenX, dLenY, dLenZ, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3225,8 +3225,8 @@ VolZmap::CompPar_ZDrilling( unsigned int nGrid, double dLenX, double dLenY, doub double dMinZ = min( min( ptMyS.z, ptMyS.z - vtToolDir.z * dLenZ), min( ptMyE.z, ptMyE.z - vtToolDir.z * dLenZ)) ; double dMaxZ = max( max( ptMyS.z, ptMyS.z - vtToolDir.z * dLenZ), max( ptMyE.z, ptMyE.z - vtToolDir.z * dLenZ)) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -3249,10 +3249,10 @@ VolZmap::CompPar_ZDrilling( unsigned int nGrid, double dLenX, double dLenY, doub //---------------------------------------------------------------------------- bool -VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad) +VolZmap::CompCyl_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad) { // Verifica sull'interferenza con lo Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3311,8 +3311,8 @@ VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d double dMin, dMax ; Vector3d vtMin, vtMax ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -3377,9 +3377,9 @@ VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d //---------------------------------------------------------------------------- bool -VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) +VolZmap::CompConus_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) { - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3436,9 +3436,9 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point Point3d ptInt ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -3646,7 +3646,7 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point //---------------------------------------------------------------------------- bool // E' in realtà MillingPerp -VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ, +VolZmap::CompPar_ZMilling( int nGrid, double dLenX, double dLenY, double dLenZ, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { @@ -3658,7 +3658,7 @@ VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, doubl dLenZ -= ( 2 * EPS_SMALL) ; // Controllo sull'interferenza utensile-solido - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestParaBBox( nGrid, ptMyS, ptMyE, vtToolDir, vtAux, dLenX, dLenY, dLenZ, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3689,8 +3689,8 @@ VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, doubl double dLenW2 = vtW2.Len() ; vtW2 /= dLenW2 ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -3726,16 +3726,14 @@ VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, doubl return true ; } - // Asse di simmetria con orientazione generica: FORATURA - //---------------------------------------------------------------------------- bool -VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, +VolZmap::CompCyl_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad, bool bTapB, bool bTapT) { // Verifico che il cilindro con il suo movimento intersechi la griglia - unsigned int nStartI, nEndI, nStartJ, nEndJ ; + int nStartI, nEndI, nStartJ, nEndJ ; if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3749,8 +3747,8 @@ VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d // Sistema di riferimento del cilindro Frame3d CylFrame ; CylFrame.Set( ptF, vtToolDir) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -3764,10 +3762,10 @@ VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d //---------------------------------------------------------------------------- bool -VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, +VolZmap::CompConus_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad, bool bTapB, bool bTapT) { - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3788,8 +3786,8 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point // L'altezza del cilindro è il movimento double dH = ( ptE - ptS).Len() ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -3817,7 +3815,7 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point //---------------------------------------------------------------------------- bool -VolZmap::CompPar_Drilling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ, +VolZmap::CompPar_Drilling( int nGrid, double dLenX, double dLenY, double dLenZ, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { @@ -3829,7 +3827,7 @@ VolZmap::CompPar_Drilling( unsigned int nGrid, double dLenX, double dLenY, doubl dLenZ -= ( 2 * EPS_SMALL) ; // Controllo sull'interferenza utensile-solido - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestParaBBox( nGrid, ptMyS, ptMyE, vtToolDir, vtAux, dLenX, dLenY, dLenZ, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3843,8 +3841,8 @@ VolZmap::CompPar_Drilling( unsigned int nGrid, double dLenX, double dLenY, doubl Point3d ptO = ptMyS - ( ( ptMyE - ptMyS) * vtV1 > 0 ? dLenZ : dLenZ + dLenMove) * vtV1 - ( 0.5 * dLenX) * vtV2 ; Frame3d ParaFrame ; ParaFrame.Set( ptO, vtV2, vtV3, vtV1) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -3866,11 +3864,11 @@ VolZmap::CompPar_Drilling( unsigned int nGrid, double dLenX, double dLenY, doubl // Asse di simmetria con orientazione generica: FRESATURA //---------------------------------------------------------------------------- bool -VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, +VolZmap::CompCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad, bool bTapB, bool bTapT) { // Verifica sull'interferenza utensile Zmap - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -3901,8 +3899,8 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& bool bElpsB = ( abs( vtToolDir * vtUmv) > EPS_SMALL ? true : bTapB) ; bool bElpsT = ( abs( vtToolDir * vtUmv) > EPS_SMALL ? true : bTapT) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; @@ -3952,11 +3950,11 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& //---------------------------------------------------------------------------- bool -VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, +VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad, bool bTapB, bool bTapT) { // Verifico interferenza - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -4040,8 +4038,8 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3 if ( dRatio * dTan <= 1) { - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; @@ -4212,8 +4210,8 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3 } else { - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; @@ -4240,7 +4238,7 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3 //---------------------------------------------------------------------------- bool -VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ, +VolZmap::CompPar_Milling( int nGrid, double dLenX, double dLenY, double dLenZ, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) { @@ -4252,7 +4250,7 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ -= ( 2 * EPS_SMALL) ; // Controllo sull'interferenza utensile-solido - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestParaBBox( nGrid, ptMyS, ptMyE, vtToolDir, vtAux, dLenX, dLenY, dLenZ, nStartI, nStartJ, nEndI, nEndJ)) return true ; @@ -4283,8 +4281,8 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double Vector3d vtW2 = vtW3 ^ vtW1 ; MotionFrame.Set( ptOrig, vtW1, vtW2, vtW3) ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; @@ -4317,10 +4315,10 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double //---------------------------------------------------------------------------- bool -VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d& ptLs, const Point3d& ptLe, double dRad) +VolZmap::CompBall_Milling( int nGrid, const Point3d& ptLs, const Point3d& ptLe, double dRad) { // Verifico interferisca - unsigned int nStartI, nStartJ, nEndI, nEndJ ; + int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestCompoBBox( nGrid, ptLs, ptLe, V_NULL, dRad, 0, 0, nStartI, nStartJ, nEndI, nEndJ)) return true ; // Vettore modivemnto @@ -4334,8 +4332,8 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d& ptLs, const Point3 double dSqRad = dRad * dRad ; - for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { - for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -4425,8 +4423,8 @@ GetSphereMoveBBox( const Point3d& ptP1, const Point3d& ptP2, double dRad) //---------------------------------------------------------------------------- inline bool -VolZmap::TestToolBBox( unsigned int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, - unsigned int& nStI, unsigned int& nStJ, unsigned int& nEnI, unsigned int& nEnJ) +VolZmap::TestToolBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, + int& nStI, int& nStJ, int& nEnI, int& nEnJ) { return TestCompoBBox( nGrid, ptP1, ptP2, vtV, m_Tool.GetRadius(), m_Tool.GetTipRadius(), m_Tool.GetHeigth(), nStI, nStJ, nEnI, nEnJ) ; @@ -4434,9 +4432,9 @@ VolZmap::TestToolBBox( unsigned int nGrid, const Point3d& ptP1, const Point3d& p //---------------------------------------------------------------------------- inline bool -VolZmap::TestCompoBBox( unsigned int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, +VolZmap::TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, double dRad, double dTipRad, double dHei, - unsigned int& nStI, unsigned int& nStJ, unsigned int& nEnI, unsigned int& nEnJ) + int& nStI, int& nStJ, int& nEnI, int& nEnJ) { // I punti e i vettori devono essere nel sistema di riferimento opportuno @@ -4457,18 +4455,18 @@ VolZmap::TestCompoBBox( unsigned int nGrid, const Point3d& ptP1, const Point3d& // Limiti su indici nStI = max( 0, int( b3Box.GetMin().x / m_dStep)) ; - nEnI = min( m_nNx[nGrid] - 1, unsigned int( b3Box.GetMax().x / m_dStep)) ; + nEnI = min( m_nNx[nGrid] - 1, int( b3Box.GetMax().x / m_dStep)) ; nStJ = max( 0, int( b3Box.GetMin().y / m_dStep)) ; - nEnJ = min( m_nNy[nGrid] - 1, unsigned int( b3Box.GetMax().y / m_dStep)) ; + nEnJ = min( m_nNy[nGrid] - 1, int( b3Box.GetMax().y / m_dStep)) ; return true ; } //---------------------------------------------------------------------------- inline bool -VolZmap::TestParaBBox( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtD, const Vector3d& vtA, +VolZmap::TestParaBBox( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtD, const Vector3d& vtA, double dLenX, double dLenY, double dLenZ, - unsigned int& nStI, unsigned int& nStJ, unsigned int& nEnI, unsigned int& nEnJ) + int& nStI, int& nStJ, int& nEnI, int& nEnJ) { // I punti e i vettori devono essere nel sistema di riferimento opportuno @@ -4487,8 +4485,8 @@ VolZmap::TestParaBBox( unsigned int nGrid, const Point3d& ptS, const Point3d& pt double dMaxY = max( max( ptS.y, ptSTip.y), max( ptE.y, ptETip.y)) + dSemiDiag ; double dMaxZ = max( max( ptS.z, ptSTip.z), max( ptE.z, ptETip.z)) + dSemiDiag ; - unsigned int nMaxNx = m_nNx[nGrid] ; - unsigned int nMaxNy = m_nNy[nGrid] ; + int nMaxNx = m_nNx[nGrid] ; + int nMaxNy = m_nNy[nGrid] ; double dMaxXValue = nMaxNx * m_dStep ; double dMaxYValue = nMaxNy * m_dStep ; @@ -4504,10 +4502,10 @@ VolZmap::TestParaBBox( unsigned int nGrid, const Point3d& ptS, const Point3d& pt return false ; // Limiti su indici - nStI = ( dMinX < EPS_SMALL ? 0 : static_cast ( dMinX / m_dStep)) ; - nEnI = ( dMaxX > dMaxXValue - EPS_SMALL ? nMaxNx - 1 : static_cast ( dMaxX / m_dStep)) ; - nStJ = ( dMinY < EPS_SMALL ? 0 : static_cast ( dMinY / m_dStep)) ; - nEnJ = ( dMaxY > dMaxYValue - EPS_SMALL ? nMaxNy - 1 : static_cast ( dMaxY / m_dStep)) ; + nStI = ( dMinX < EPS_SMALL ? 0 : static_cast ( dMinX / m_dStep)) ; + nEnI = ( dMaxX > dMaxXValue - EPS_SMALL ? nMaxNx - 1 : static_cast ( dMaxX / m_dStep)) ; + nStJ = ( dMinY < EPS_SMALL ? 0 : static_cast ( dMinY / m_dStep)) ; + nEnJ = ( dMaxY > dMaxYValue - EPS_SMALL ? nMaxNy - 1 : static_cast ( dMaxY / m_dStep)) ; return true ; }