From a2a63bf5c18144b05617abdc619d81284ff2a151 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Tue, 16 Jan 2018 12:15:11 +0000 Subject: [PATCH] EgtGeomKernel 1.9a1 : - aggiunte funzioni per conversione colore RGB in HSV e viceversa - modifiche a VolZmap per gestione Flag utensile. --- Color.cpp | 71 +++++++++++++++ EgtGeomKernel.rc | Bin 11718 -> 11710 bytes VolZmap.cpp | 216 ++++++++++++++++++++++---------------------- VolZmap.h | 18 ++-- VolZmapGraphics.cpp | 126 ++++++++++++-------------- 5 files changed, 246 insertions(+), 185 deletions(-) diff --git a/Color.cpp b/Color.cpp index b972986..be8d844 100644 --- a/Color.cpp +++ b/Color.cpp @@ -13,8 +13,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" +#include "/EgtDev/Include/EGkGeoConst.h" #include "/EgtDev/Include/EGkColor.h" +#include "/EgtDev/Include/EGkAngle.h" #include "/EgtDev/Include/EGnStringUtils.h" +#include "/EgtDev/Include/EGtNumUtils.h" +#include using namespace std ; @@ -103,3 +107,70 @@ GetSurfBackColor( Color cCol) 0.4 * fLum + 0.6 * cCol.GetBlue(), cCol.GetAlpha()) ; } + +//---------------------------------------------------------------------------- +HSV +GetHSVFromColor( const Color& cCol) +{ + double dMin = std::min( std::min( cCol.GetRed(), cCol.GetGreen()), cCol.GetBlue()) ; + double dMax = std::max( std::max( cCol.GetRed(), cCol.GetGreen()), cCol.GetBlue()) ; + double dDelta = dMax - dMin ; + + if ( dDelta < EPS_ZERO) + return HSV( dMax, 0, 0) ; + + if ( dMax < EPS_ZERO) + return HSV( 0, 0, 0) ; + + HSV hsv ; + hsv.dVal = dMax ; + hsv.dSat = dDelta / dMax ; + if ( cCol.GetRed() >= dMax) // tra giallo e magenta + hsv.dHue = ( cCol.GetGreen() - cCol.GetBlue()) / dDelta ; + else if( cCol.GetGreen() >= dMax) // tra ciano e giallo + hsv.dHue = 2.0 + ( cCol.GetBlue() - cCol.GetRed()) / dDelta ; + else // tra magenta e ciano + hsv.dHue = 4.0 + ( cCol.GetRed() - cCol.GetGreen()) / dDelta ; + // trasformo in gradi + hsv.dHue *= 60.0 ; + // porto in 0-360 deg + if ( hsv.dHue < 0.0) + hsv.dHue += 360.0 ; + + return hsv; +} + +//---------------------------------------------------------------------------- +Color +GetColorFromHSV( const HSV& hsv) +{ + // porto i valori nei limiti + double dHue = AngleNearAngle( hsv.dHue, ANG_STRAIGHT) ; + double dSat = Clamp( hsv.dSat, 0., 1.) ; + double dVal = Clamp( hsv.dVal, 0., 1.) ; + // se saturazione nulla + if ( dSat < EPS_ZERO) + return Color( dVal, dVal, dVal) ; + // calcolo + double dFraz = dHue / 60. ; + int nInd = int( dFraz) ; + double dRem = dFraz - nInd ; + double dP = dVal * ( 1.0 - dSat) ; + double dQ = dVal * ( 1.0 - ( dSat * dRem)) ; + double dT = dVal * ( 1.0 - ( dSat * (1.0 - dRem))) ; + + switch ( nInd) { + case 0 : + return Color( dVal, dT, dP) ; + case 1 : + return Color( dQ, dVal, dP) ; + case 2 : + return Color( dP, dVal, dT) ; + case 3 : + return Color( dP, dQ, dVal) ; + case 4 : + return Color( dT, dP, dVal) ; + default : + return Color( dVal, dP, dQ) ; + } +} diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index 0eaa179914e50843a9699397cf8d1f956eeefd68..cfa5bef94dc87ac2050a2a434e2b57df468493fc 100644 GIT binary patch delta 234 zcmX>Wy)SyhCpK0~1|0^&$+!7*87((+@-JnYTqmS6`3I*GP$Cg1p(w07*@tTbqs8XG zT*Zt)HHAFMOlX?;nb8$b{>wFW@&w^~VD*uVn@@;xF%qY#Pa2{rka6+@R*uOhM6)Iv c$SpwAi`$hzi>FU6QoaMWn2~XFfNB{B04J|Rp#T5? delta 258 zcmdlNeJpyzCpLBq1|0@N2BXR6<#ZV>HZzJZWtv>ar87A}l4J5ePAOIkh8zaN$%@>% zlfAe$Fq&`v%~j0EXfgRBhxq0?87s!k2Y7`TG0fm+M%Op_H`mn3J;L{pv`#+2%dz>0 hC>PP%JERfXeV8yT#qV&S1Ex>TQoaLqK%7bfCjd%&N@D;3 diff --git a/VolZmap.cpp b/VolZmap.cpp index 81edb10..15d0a4f 100644 --- a/VolZmap.cpp +++ b/VolZmap.cpp @@ -58,7 +58,7 @@ VolZmap::Clear( void) m_nNumBlock = 0 ; m_nConnectedCompoCount = 0 ; m_MapFrame.Reset() ; - for ( int i = 0 ; i < N_MAPS ; ++ i) { + for ( int i = 0 ; i < N_MAPS ; ++ i) { m_nNx[i] = 0 ; m_nNy[i] = 0 ; m_nDim[i] = 0 ; @@ -218,7 +218,7 @@ VolZmap::Save( NgeWriter& ngeOut) const for ( int i = 0 ; i < 3 ; ++ i) { if ( ! ngeOut.WriteInt( m_nFracLin[i], ",", false)) return false ; - } + } // numero di componenti connesse if ( ! ngeOut.WriteInt( m_nConnectedCompoCount, ",", false)) return false ; @@ -229,7 +229,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 ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { if ( ! ngeOut.WriteInt( m_nNx[i], ",", false)) return false ; if ( ! ngeOut.WriteInt( m_nNy[i], ",", false)) @@ -272,11 +272,11 @@ VolZmap::Save( NgeWriter& ngeOut) const return false ; } } - } - } + } + } return true ; } - + //---------------------------------------------------------------------------- bool VolZmap::Load( NgeReader& ngeIn) @@ -306,7 +306,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 ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { if ( ! ngeIn.ReadInt( m_nNx[i], ",", false)) return false ; if ( ! ngeIn.ReadInt( m_nNy[i], ",", false)) @@ -320,13 +320,13 @@ VolZmap::Load( NgeReader& ngeIn) // ciclo sulle mappe for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { // dimensiono i vettori - m_Values[i].resize( m_nDim[i]) ; + m_Values[i].resize( m_nDim[i]) ; // ciclo sui dexel for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) { // leggo il numero di estremi nel dexel unsigned int nDim ; if ( ! ngeIn.ReadInt( nDim, ":", false)) - return false ; + return false ; // se dexel nullo if ( nDim == 0) { // leggo un valore dummy @@ -339,7 +339,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 ( unsigned 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)) @@ -366,7 +366,7 @@ VolZmap::Load( NgeReader& ngeIn) // per triangoli di feature di frontiera tra blocchi m_InterBlockTria.resize( m_nNumBlock) ; - + m_nStatus = OK ; return true ; } @@ -523,7 +523,7 @@ VolZmap::ToGlob( const Frame3d& frRef) return false ; // imposto ricalcolo della grafica ResetGraphics() ; - // trasformo il riferimento + // trasformo il riferimento m_MapFrame.ToGlob( frRef) ; return true ; } @@ -588,7 +588,7 @@ VolZmap::CheckMapConnection( void) m_Values[tMap][tDex][tInt].nCompo = 0 ; // Controlli sui tratti di dexel non incidenti su nodi del reticolo - if ( tMap == 0) { + if ( tMap == 0) { // Z degli estremi del segmento double dZMin = m_Values[tMap][tDex][tInt].dMin ; double dZMax = m_Values[tMap][tDex][tInt].dMax ; @@ -607,7 +607,7 @@ VolZmap::CheckMapConnection( void) int nImin = int( floor( ( dXMin - EPS_SMALL) / m_dStep - 0.5)) ; int nImax = int( floor( ( dXMax + EPS_SMALL) / m_dStep - 0.5)) ; // Se cadono nello stesso voxel imposto a -1 il valore della componente connessa - if ( nImax - nImin == 0) + if ( nImax - nImin == 0) m_Values[tMap][tDex][tInt].nCompo = -1 ; } else { @@ -624,10 +624,10 @@ 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 ( size_t tJ = 0 ; tJ < m_nNy[0] ; ++ tJ) { // Numero del dexel lungo Z size_t tDexZ = tJ * m_nNx[0] + tI ; // Numero di intervalli nel dexel @@ -635,10 +635,10 @@ VolZmap::CheckMapConnection( void) // Ciclo sugli intervalli del dexel for ( size_t tIntZ = 0 ; tIntZ < tStopIntZ ; ++ tIntZ) { - if ( m_Values[0][tDexZ][tIntZ].nCompo == 0) { + if ( m_Values[0][tDexZ][tIntZ].nCompo == 0) { ++ m_nConnectedCompoCount ; m_Values[0][tDexZ][tIntZ].nCompo = m_nConnectedCompoCount ; - // Espando in tutta la componente + // Espando in tutta la componente // Segmento corrente IntervalIndexes NewInt ; NewInt.tMap = 0 ; @@ -651,9 +651,9 @@ VolZmap::CheckMapConnection( void) // Processo gli intervalli trovati while ( ! IntervalsToProcess.empty()) { - + switch ( IntervalsToProcess.top().tMap) { - case 0 : + case 0 : ExpandFromZInterval( IntervalsToProcess) ; break ; case 1 : @@ -678,7 +678,7 @@ VolZmap::CheckMapConnection( void) //---------------------------------------------------------------------------- bool -VolZmap::ExpandFromXInterval( IntContaier& IntCont) +VolZmap::ExpandFromXInterval( IntContaier& IntCont) { // Copio i dati dell'intervallo corrente IntervalIndexes CurrInterval = IntCont.top() ; @@ -691,45 +691,45 @@ VolZmap::ExpandFromXInterval( IntContaier& IntCont) double dMinX = m_Values[1][tDex][tInt].dMin ; double dMaxX = m_Values[1][tDex][tInt].dMax ; double dMinDX = max( floor( ( dMinX - EPS_SMALL) / m_dStep - 0.5), 0.) ; - 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 + 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)) ; - // Posizione YZ del dexel + // 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 + // Ciclo sugli indici dei dexel che potrebbero + // intersecare il segmento di partenza for ( size_t 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) { - // Estremi del dexel lunog Z + // 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 ; // Se i segmenti si incrociano e il nuovo trovato non - // ha già un indice assegnato, assegno l'indice e + // ha già un indice assegnato, assegno l'indice e // aggiungo l'intervallo trovato allo stack. if ( dZmin - EPS_SMALL < dZ && dZmax + EPS_SMALL > dZ && - m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].nCompo == 0) { + m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].nCompo == 0) { m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].nCompo = m_Values[1][tDex][tInt].nCompo ; IntervalIndexes NewInterval ; NewInterval.tMap = 0 ; NewInterval.tDex = tGrIndex1 * m_nNx[0] + tI ; NewInterval.tInt = tIntZ ; IntCont.push( NewInterval) ; - } + } } // 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) { - // Estremi del segmento del dexel lungo Y + // 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 ; // Se i segmenti si incrociano e il nuovo trovato non - // ha già un indice assegnato, assegno l'indice e + // ha già un indice assegnato, assegno l'indice e // aggiungo l'intervallo trovato allo stack. if ( dYmin - EPS_SMALL < dY && dYmax + EPS_SMALL > dY && @@ -740,10 +740,10 @@ VolZmap::ExpandFromXInterval( IntContaier& IntCont) NewInterval.tDex = tI * m_nNx[2] + tGrIndex2 ; NewInterval.tInt = tIntY ; IntCont.push( NewInterval) ; - } + } } } - + return true ; } @@ -756,65 +756,65 @@ VolZmap::ExpandFromYInterval( IntContaier& IntCont) 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 ; - // Quote estreme del segmento lungo Y + size_t tGrIndex2 = CurrInterval.tDex / m_nNx[2] ; + size_t 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 ; double dMinDY = max( floor( ( dMinY - EPS_SMALL) / m_dStep - 0.5), 0.) ; 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 + // 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)) ; // 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 + 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) { // 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) { - // Estremi del dexel lunog Z + // 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 ; // Se i segmenti si incrociano e il nuovo trovato non - // ha già un indice assegnato, assegno l'indice e + // ha già un indice assegnato, assegno l'indice e // aggiungo l'intervallo trovato allo stack. if ( dZmin - EPS_SMALL < dZ && dZmax + EPS_SMALL > dZ && - m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].nCompo == 0) { + m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].nCompo == 0) { m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].nCompo = m_Values[2][tDex][tInt].nCompo ; IntervalIndexes NewInterval ; NewInterval.tMap = 0 ; NewInterval.tDex = tJ * m_nNx[0] + tGrIndex2 ; NewInterval.tInt = tIntZ ; - IntCont.push( NewInterval) ; - } + IntCont.push( NewInterval) ; + } } // 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) { - // Estremi del segmento del dexel lungo X + // 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 ; // Se i segmenti si incrociano e il nuovo trovato non - // ha già un indice assegnato, assegno l'indice e + // ha già un indice assegnato, assegno l'indice e // aggiungo l'intervallo trovato allo stack. if ( dXmin - EPS_SMALL < dX && dXmax + EPS_SMALL > dX && - m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].nCompo == 0) { + m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].nCompo == 0) { m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].nCompo = m_Values[2][tDex][tInt].nCompo ; IntervalIndexes NewInterval ; NewInterval.tMap = 1 ; NewInterval.tDex = tGrIndex1 * m_nNx[1] + tJ ; NewInterval.tInt = tIntX ; - IntCont.push( NewInterval) ; - } + IntCont.push( NewInterval) ; + } } } - + return true ; } @@ -827,62 +827,62 @@ VolZmap::ExpandFromZInterval( IntContaier& IntCont) 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 ; - // Quote estreme del segmento lungo Z + size_t tGrIndex2 = CurrInterval.tDex / m_nNx[0] ; + size_t 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 ; double dMinDZ = max( floor( ( dMinZ - EPS_SMALL) / m_dStep - 0.5), 0.) ; double dMaxDZ = max( floor( ( dMaxZ + EPS_SMALL) / m_dStep - 0.5), 0.) ; - // Indici estremi dei dexel ortogonali - // che possono intersecare il segmento di partenza + // 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)) ; - // Posizione XY del dexel + // 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 + // Ciclo sugli indici dei dexel che potrebbero // intersecare il segmento di partenza for ( size_t 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) { - // Estremi del segmento del dexel lungo X + // 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 ; // Se i segmenti si incrociano e il nuovo trovato non - // ha già un indice assegnato, assegno l'indice e + // ha già un indice assegnato, assegno l'indice e // aggiungo l'intervallo trovato allo stack. if ( dXmin - EPS_SMALL < dX && dXmax + EPS_SMALL > dX && - m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].nCompo == 0) { + m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].nCompo == 0) { m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].nCompo = m_Values[0][tDex][tInt].nCompo ; IntervalIndexes NewInterval ; NewInterval.tMap = 1 ; NewInterval.tDex = tK * m_nNx[1] + tGrIndex2 ; NewInterval.tInt = tIntX ; - IntCont.push( NewInterval) ; - } + IntCont.push( NewInterval) ; + } } // 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) { - // Estremi del segmento del dexel lungo Y + // 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 ; // Se i segmenti si incrociano e il nuovo trovato non - // ha già un indice assegnato, assegno l'indice e + // ha già un indice assegnato, assegno l'indice e // aggiungo l'intervallo trovato allo stack. if ( dYmin - EPS_SMALL < dY && - dYmax + EPS_SMALL > dY && - m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].nCompo == 0) { + dYmax + EPS_SMALL > dY && + m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].nCompo == 0) { m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].nCompo = m_Values[0][tDex][tInt].nCompo ; IntervalIndexes NewInterval ; NewInterval.tMap = 2 ; NewInterval.tDex = tGrIndex1 * m_nNx[2] + tK ; NewInterval.tInt = tIntY ; - IntCont.push( NewInterval) ; - } + IntCont.push( NewInterval) ; + } } } @@ -905,14 +905,14 @@ VolZmap::ClonePart( int nPart) const // Se il numero di componenti è indefinito, lo ricalcolo. if ( m_nConnectedCompoCount == - 1) const_cast(this)->CheckMapConnection() ; - // Se non vi sono componenti, errore + // Se non vi sono componenti, errore if ( m_nConnectedCompoCount == 0) return nullptr ; // Creo nuovo oggetto Zmap PtrOwner pVolume( CreateBasicVolZmap()) ; if ( IsNull( pVolume)) return nullptr ; - // Setto per il nuovo Zmap le seguenti variabili + // Setto per il nuovo Zmap le seguenti variabili pVolume->m_nConnectedCompoCount = 1 ; pVolume->m_dStep = m_dStep ; pVolume->m_nMapNum = m_nMapNum ; @@ -922,7 +922,7 @@ VolZmap::ClonePart( int nPart) const int nMaxIndI[N_MAPS] ; int nMinIndJ[N_MAPS] ; int nMaxIndJ[N_MAPS] ; - // Coordinate dell'origine del sistema di riferimento + // Coordinate dell'origine del sistema di riferimento // del nuovo Zmap double dNewOx, dNewOy, dNewOz ; // Ciclo sulle mappe @@ -948,10 +948,10 @@ VolZmap::ClonePart( int nPart) const nMaxIndI[nMap] = nIndI ; if ( nIndJ > nMaxIndJ[nMap]) nMaxIndJ[nMap] = nIndJ ; - if ( m_Values[nMap][nDex][nInt].dMin < pVolume->m_dMinZ[nMap]) - pVolume->m_dMinZ[nMap] = m_Values[nMap][nDex][nInt].dMin ; + if ( m_Values[nMap][nDex][nInt].dMin < pVolume->m_dMinZ[nMap]) + pVolume->m_dMinZ[nMap] = m_Values[nMap][nDex][nInt].dMin ; if ( m_Values[nMap][nDex][nInt].dMax > pVolume->m_dMaxZ[nMap]) - pVolume->m_dMaxZ[nMap] = m_Values[nMap][nDex][nInt].dMax ; + pVolume->m_dMaxZ[nMap] = m_Values[nMap][nDex][nInt].dMax ; } } } @@ -972,7 +972,7 @@ VolZmap::ClonePart( int nPart) const pVolume->m_nDim[nMap] = pVolume->m_nNx[nMap] * pVolume->m_nNy[nMap] ; pVolume->m_Values[nMap].resize( pVolume->m_nDim[nMap]) ; } - + // Copio gli intervalli nelle griglie del nuovo oggetto: // Griglia 0 for ( int nIndJ = 0 ; nIndJ < int( pVolume->m_nNy[0]) ; ++ nIndJ) { @@ -982,7 +982,7 @@ VolZmap::ClonePart( int nPart) const for ( int nInt = 0 ; nInt < int( m_Values[0][nOldDex].size()) ; ++ nInt) { if ( m_Values[0][nOldDex][nInt].nCompo == nPart + 1) { pVolume->m_Values[0][nNewDex].emplace_back( m_Values[0][nOldDex][nInt]) ; - pVolume->m_Values[0][nNewDex].back().nCompo = 1 ; + pVolume->m_Values[0][nNewDex].back().nCompo = 1 ; } } } @@ -995,7 +995,7 @@ VolZmap::ClonePart( int nPart) const for ( int nInt = 0 ; nInt < int( m_Values[1][nOldDex].size()) ; ++ nInt) { if ( m_Values[1][nOldDex][nInt].nCompo == nPart + 1) { pVolume->m_Values[1][nNewDex].emplace_back( m_Values[1][nOldDex][nInt]) ; - pVolume->m_Values[1][nNewDex].back().nCompo = 1 ; + pVolume->m_Values[1][nNewDex].back().nCompo = 1 ; } } } @@ -1008,7 +1008,7 @@ VolZmap::ClonePart( int nPart) const for ( int nInt = 0 ; nInt < int( m_Values[2][nOldDex].size()) ; ++ nInt) { if ( m_Values[2][nOldDex][nInt].nCompo == nPart + 1) { pVolume->m_Values[2][nNewDex].emplace_back( m_Values[2][nOldDex][nInt]) ; - pVolume->m_Values[2][nNewDex].back().nCompo = 1 ; + pVolume->m_Values[2][nNewDex].back().nCompo = 1 ; } } } @@ -1024,24 +1024,24 @@ VolZmap::ClonePart( int nPart) const for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) { // Quote estreme Z switch ( nMap) { - case 0 : + case 0 : pVolume->m_dMinZ[nMap] -= dNewOz ; pVolume->m_dMaxZ[nMap] -= dNewOz ; break ; - case 1 : + case 1 : pVolume->m_dMinZ[nMap] -= dNewOx ; pVolume->m_dMaxZ[nMap] -= dNewOx ; break ; - case 2 : + case 2 : pVolume->m_dMinZ[nMap] -= dNewOy ; pVolume->m_dMaxZ[nMap] -= dNewOy ; break ; } // Dexel - for ( int nDex = 0 ; nDex < int( pVolume->m_nDim[nMap]) ; ++ nDex) { + for ( int nDex = 0 ; nDex < int( pVolume->m_nDim[nMap]) ; ++ nDex) { for ( int nInt = 0 ; nInt < int( pVolume->m_Values[nMap][nDex].size()) ; ++ nInt) { switch ( nMap) { - case 0 : + case 0 : pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOz ; pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOz ; break ; @@ -1060,11 +1060,11 @@ 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) ; + ( pVolume->m_nNx[0] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; unsigned int nVoxNumY = pVolume->m_nNy[0] / pVolume->N_DEXVOXRATIO + - ( pVolume->m_nNy[0] / pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; + ( pVolume->m_nNy[0] / pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; unsigned int nVoxNumZ = pVolume->m_nNy[1] / pVolume->N_DEXVOXRATIO + - ( pVolume->m_nNy[1] % pVolume->N_DEXVOXRATIO == 0 ? 1 : 2) ; + ( 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 + @@ -1074,7 +1074,7 @@ VolZmap::ClonePart( int nPart) const pVolume->m_nFracLin[2] = max( 1u, nVoxNumZ / pVolume->m_nVoxNumPerBlock + ( nVoxNumZ % pVolume->m_nVoxNumPerBlock >= pVolume->m_nVoxNumPerBlock / 2 ? 1 : 0)) ; - // Dimensiono il vettore dei blocchi + // 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 @@ -1084,10 +1084,10 @@ VolZmap::ClonePart( int nPart) const // Dimensiono raccolta triangoli di feature tra blocchi pVolume->m_InterBlockTria.resize( pVolume->m_nNumBlock) ; - // Sistema di riferimento intrinseco del nuovo solido + // Sistema di riferimento intrinseco del nuovo solido Point3d ptNewO( dNewOx, dNewOy, dNewOz) ; pVolume->m_MapFrame.Set( ptNewO, X_AX, Y_AX, Z_AX) ; - + // Setto lo stato del nuovo Solido pVolume->m_nStatus = m_nStatus ; @@ -1097,12 +1097,12 @@ VolZmap::ClonePart( int nPart) const //---------------------------------------------------------------------------- bool -VolZmap::RemovePart( int nPart) +VolZmap::RemovePart( int nPart) { // verifico lo stato if ( m_nStatus != OK) return false ; - // Se è definita una sola griglia non sono definibili le parti, errore + // Se è definita una sola griglia non sono definibili le parti, errore if ( m_nMapNum == 1) return false ; // Se il numero di componenti è indefinito, lo ricalcolo @@ -1111,9 +1111,9 @@ VolZmap::RemovePart( int nPart) // Se non vi sono componenti, abbiamo finito if ( m_nConnectedCompoCount == 0) return true ; - - // Elimino i segmenti con indice nPart + 1 e aggiorno quelli con indice superiore - // Ciclo sulle mappe. + + // 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) { // Ciclo sui dexel della mappa. for ( int nDex = 0 ; nDex < int( m_Values[nMap].size()) ; ++ nDex) { @@ -1148,36 +1148,36 @@ VolZmap::SetTolerances( double dLinTol, double dAngTolDeg) //---------------------------------------------------------------------------- bool -VolZmap::SetStdTool( const std::string& sToolName, double dH, double dR, double dCornR) +VolZmap::SetStdTool( const std::string& sToolName, double dH, double dR, double dCornR, int nFlag) { - return m_Tool.SetStdTool( sToolName, dH, dR, dCornR, 1) ; + return m_Tool.SetStdTool( sToolName, dH, dR, dCornR, nFlag) ; } //---------------------------------------------------------------------------- bool VolZmap::SetAdvTool( const std::string& sToolName, - double dH, double dR, double dTipH, double dTipR, double dCornR) + double dH, double dR, double dTipH, double dTipR, double dCornR, int nFlag) { - return m_Tool.SetAdvTool( sToolName, dH, dR, dTipH, dTipR, dCornR, 1) ; + return m_Tool.SetAdvTool( sToolName, dH, dR, dTipH, dTipR, dCornR, nFlag) ; } //---------------------------------------------------------------------------- bool -VolZmap::SetGenTool( const std::string& sToolName, const ICurveComposite* pToolOutline) +VolZmap::SetGenTool( const std::string& sToolName, const ICurveComposite* pToolOutline, int nFlag) { - return m_Tool.SetGenTool( sToolName, pToolOutline, 1) ; + return m_Tool.SetGenTool( sToolName, pToolOutline, nFlag) ; } //---------------------------------------------------------------------------- bool -VolZmap::SetMortiserTool( const std::string& sToolName, double dH, double dW, double dTh, double dRc) +VolZmap::SetMortiserTool( const std::string& sToolName, double dH, double dW, double dTh, double dRc, int nFlag) { - return m_Tool.SetMortiserTool( sToolName, dH, dW, dTh, dRc, 1) ; + return m_Tool.SetMortiserTool( sToolName, dH, dW, dTh, dRc, nFlag) ; } //---------------------------------------------------------------------------- bool -VolZmap::SetChiselTool( const std::string& sToolName, double dH, double dW, double dTh) +VolZmap::SetChiselTool( const std::string& sToolName, double dH, double dW, double dTh, int nFlag) { - return m_Tool.SetChiselTool( sToolName, dH, dW, dTh, 1) ; + return m_Tool.SetChiselTool( sToolName, dH, dW, dTh, nFlag) ; } diff --git a/VolZmap.h b/VolZmap.h index b59b7c4..d542e4c 100644 --- a/VolZmap.h +++ b/VolZmap.h @@ -43,8 +43,9 @@ typedef std::vector TriaMatrix ; // ------------------------- STRUTTURA VERTICE TRIANGOLO - NORMALE ALLA SUPERFICIE ------------------------------------------------ struct VectorField { - Point3d ptInt ; + Point3d ptInt ; Vector3d vtNorm ; + int nToolFlag ; } ; //---------------------------------------------------------------------------- @@ -96,14 +97,15 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DLISTVECTOR& vLstTria) const override ; 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) 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) override ; - bool SetGenTool( const std::string& sToolName, const ICurveComposite* pToolOutline) override ; - bool SetMortiserTool( const std::string& sToolName, double dH, double dW, double dTh, double dRc) override ; - bool SetChiselTool( const std::string& sToolName, double dH, double dW, double dTh) override ; + double dH, double dR, double dTipH, double dTipR, 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 SetChiselTool( const std::string& sToolName, double dH, double dW, double dTh, int nFlag) override ; bool MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Point3d& ptPe, const Vector3d& vtDe) override ; - bool MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs, const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) override ; + bool MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs, + const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) override ; bool GetDepth( const Point3d& ptP, const Vector3d& vtD, double& dInLength, double& dOutLength, bool bExact) const override ; bool GetDepthWithDexel( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength) const ; bool GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength, bool bEnh) const ; @@ -157,7 +159,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW 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 ; - bool IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, Vector3d& vtNormal) const ; + bool IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, VectorField& 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 ; diff --git a/VolZmapGraphics.cpp b/VolZmapGraphics.cpp index 57b9cb0..f114184 100644 --- a/VolZmapGraphics.cpp +++ b/VolZmapGraphics.cpp @@ -12,25 +12,21 @@ //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- - #include "stdafx.h" #include "CurveLine.h" #include "VolZmap.h" #include "GeoConst.h" #include "IntersLineSurfTm.h" #include "MC_Tables.h" +#include "PolygonPlane.h" #include "/EgtDev/Include/EGkIntervals.h" #include "/EgtDev/Include/EgtNumUtils.h" #include "/EgtDev/Include/EGkStringUtils3d.h" #include "/EgtDev/Extern/Eigen\Core" #include "/EgtDev/Extern/Eigen\SVD" -#include "PolygonPlane.h" - using namespace std ; - - // ------------------------- UNORDERED MAP PER LA GESTIONE DEI TRIANGOLI GRANDI --------------------------------------------------- // ------------------------- TABELLA BLOCCHI ADIACENTI ---------------------------------------------------------------------------- @@ -186,7 +182,6 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], ( nIndArrey[nCompCount - 1][0] == 5 && nIndArrey[nCompCount - 1][1] == 7 && nIndArrey[nCompCount - 1][2] == 8 && nIndArrey[nCompCount - 1][3] == 9 )) { - if ( AreSameVectorApprox( VecField[nIndArrey[nCompCount - 1][0]].vtNorm, VecField[nIndArrey[nCompCount - 1][1]].vtNorm) && abs( VecField[nIndArrey[nCompCount - 1][0]].vtNorm * VecField[nIndArrey[nCompCount - 1][2]].vtNorm) < EPS_SMALL && abs( VecField[nIndArrey[nCompCount - 1][0]].vtNorm * VecField[nIndArrey[nCompCount - 1][3]].vtNorm) < EPS_SMALL) { @@ -197,16 +192,13 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], Vector3d vtVecField = VecField[nIndArrey[nCompCount - 1][0]].vtNorm ; if ( vtVecField.x * vtVecField.x > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.x - ptBarycenter.x) < EPS_SMALL) { - double dXBar = ptBarycenter.x / m_dStep - 0.5 ; int nBarLimSup = int( m_nNx[0]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dXInd = double( nBarInd) ; if ( abs( dXInd - dXBar) < EPS_SMALL) { @@ -217,17 +209,15 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } - else if ( vtVecField.y * vtVecField.y > 1 - EPS_SMALL * EPS_SMALL) { + else if ( vtVecField.y * vtVecField.y > 1 - EPS_SMALL * EPS_SMALL) { if ( abs( CompoVert[nCompCount - 1][0].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.y - ptBarycenter.y) < EPS_SMALL) { - double dYBar = ptBarycenter.y / m_dStep - 0.5 ; int nBarLimSup = int( m_nNy[0]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dYInd = double( nBarInd) ; if ( abs( dYInd - dYBar) < EPS_SMALL) { @@ -238,17 +228,15 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } + else if ( vtVecField.z * vtVecField.z > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.z - ptBarycenter.z) < EPS_SMALL) { - double dZBar = ptBarycenter.z / m_dStep - 0.5 ; int nBarLimSup = int( m_nNy[1]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dZInd = double( nBarInd) ; if ( abs( dZInd - dZBar) < EPS_SMALL) { @@ -260,6 +248,7 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } + else if ( AreSameVectorApprox( VecField[nIndArrey[nCompCount - 1][2]].vtNorm, VecField[nIndArrey[nCompCount - 1][3]].vtNorm) && abs( VecField[nIndArrey[nCompCount - 1][2]].vtNorm * VecField[nIndArrey[nCompCount - 1][0]].vtNorm) < EPS_SMALL && abs( VecField[nIndArrey[nCompCount - 1][2]].vtNorm * VecField[nIndArrey[nCompCount - 1][1]].vtNorm) < EPS_SMALL) { @@ -270,16 +259,13 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], Vector3d vtVecField = VecField[nIndArrey[nCompCount - 1][2]].vtNorm ; if ( vtVecField.x * vtVecField.x > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.x - ptBarycenter.x) < EPS_SMALL) { - double dXBar = ptBarycenter.x / m_dStep - 0.5 ; int nBarLimSup = int( m_nNx[0]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dXInd = double( nBarInd) ; if ( abs( dXInd - dXBar) < EPS_SMALL) { @@ -290,17 +276,15 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } - else if ( vtVecField.y * vtVecField.y > 1 - EPS_SMALL * EPS_SMALL) { + else if ( vtVecField.y * vtVecField.y > 1 - EPS_SMALL * EPS_SMALL) { if ( abs( CompoVert[nCompCount - 1][0].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.y - ptBarycenter.y) < EPS_SMALL) { - double dYBar = ptBarycenter.y / m_dStep - 0.5 ; int nBarLimSup = int( m_nNy[0]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dYInd = double( nBarInd) ; if ( abs( dYInd - dYBar) < EPS_SMALL) { @@ -311,17 +295,15 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } + else if ( vtVecField.z * vtVecField.z > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.z - ptBarycenter.z) < EPS_SMALL) { - double dZBar = ptBarycenter.z / m_dStep - 0.5 ; int nBarLimSup = int( m_nNy[1]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dZInd = double( nBarInd) ; if ( abs( dZInd - dZBar) < EPS_SMALL) { @@ -355,16 +337,13 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], Vector3d vtVecField = VecField[nIndArrey[nCompCount - 1][0]].vtNorm ; if ( vtVecField.x * vtVecField.x > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.x - ptBarycenter.x) < EPS_SMALL) { - double dXBar = ptBarycenter.x / m_dStep - 0.5 ; int nBarLimSup = int( m_nNx[0]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dXInd = double( nBarInd) ; if ( abs( dXInd - dXBar) < EPS_SMALL) { @@ -375,17 +354,15 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } + else if ( vtVecField.y * vtVecField.y > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.y - ptBarycenter.y) < EPS_SMALL) { - double dYBar = ptBarycenter.y / m_dStep - 0.5 ; int nBarLimSup = int( m_nNy[0]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dYInd = double( nBarInd) ; if ( abs( dYInd - dYBar) < EPS_SMALL) { @@ -396,17 +373,15 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } + else if ( vtVecField.z * vtVecField.z > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.z - ptBarycenter.z) < EPS_SMALL) { - double dZBar = ptBarycenter.z / m_dStep - 0.5 ; int nBarLimSup = int( m_nNy[1]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dZInd = double( nBarInd) ; if ( abs( dZInd - dZBar) < EPS_SMALL) { @@ -418,6 +393,7 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } + else if ( AreSameVectorApprox( VecField[nIndArrey[nCompCount - 1][1]].vtNorm, VecField[nIndArrey[nCompCount - 1][3]].vtNorm) && abs( VecField[nIndArrey[nCompCount - 1][1]].vtNorm * VecField[nIndArrey[nCompCount - 1][0]].vtNorm) < EPS_SMALL && abs( VecField[nIndArrey[nCompCount - 1][1]].vtNorm * VecField[nIndArrey[nCompCount - 1][2]].vtNorm) < EPS_SMALL) { @@ -428,16 +404,13 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], Vector3d vtVecField = VecField[nIndArrey[nCompCount - 1][0]].vtNorm ; if ( vtVecField.x * vtVecField.x > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.x - ptBarycenter.x) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.x - ptBarycenter.x) < EPS_SMALL) { - double dXBar = ptBarycenter.x / m_dStep - 0.5 ; int nBarLimSup = int( m_nNx[0]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dXInd = double( nBarInd) ; if ( abs( dXInd - dXBar) < EPS_SMALL) { @@ -448,17 +421,15 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } + else if ( vtVecField.y * vtVecField.y > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.y - ptBarycenter.y) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.y - ptBarycenter.y) < EPS_SMALL) { - double dYBar = ptBarycenter.y / m_dStep - 0.5 ; int nBarLimSup = int( m_nNy[0]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dYInd = double( nBarInd) ; if ( abs( dYInd - dYBar) < EPS_SMALL) { @@ -469,17 +440,15 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } + else if ( vtVecField.z * vtVecField.z > 1 - EPS_SMALL * EPS_SMALL) { - if ( abs( CompoVert[nCompCount - 1][0].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][1].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][2].ptInt.z - ptBarycenter.z) < EPS_SMALL && abs( CompoVert[nCompCount - 1][3].ptInt.z - ptBarycenter.z) < EPS_SMALL) { - double dZBar = ptBarycenter.z / m_dStep - 0.5 ; int nBarLimSup = int( m_nNy[1]) ; int nBarInd = 0 ; - while ( nBarInd < nBarLimSup) { double dZInd = double( nBarInd) ; if ( abs( dZInd - dZBar) < EPS_SMALL) { @@ -491,7 +460,8 @@ VolZmap::GridControl( VectorField VecField[], VectorField CompoVert[][12], } } } - } + } + return true ; } @@ -1028,8 +998,7 @@ VolZmap::ProcessCube( int nVoxI, int nVoxJ, int nVoxK, TRIA3DLIST& lstTria, TriH 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].ptInt, VecField[EdgeIndex].vtNorm)) + if ( ! IntersPos( IndexCorner[n1], IndexCorner[n2], bN1, VecField[EdgeIndex])) bReg = false ; } @@ -1726,8 +1695,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold) 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].ptInt, VecField[EdgeIndex].vtNorm)) + if ( ! IntersPos( IndexCorner[n1], IndexCorner[n2], bN1, VecField[EdgeIndex])) bReg = false ; } @@ -2422,6 +2390,13 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold) CurrentTriangle.Set( CompoTriVert[nCompCount - 1][TriIndex].ptInt, CompoTriVert[nCompCount - 1][TriIndex+1].ptInt, CompoTriVert[nCompCount - 1][TriIndex+2].ptInt) ; + // Setto il numero di utensile + int nTool0 = CompoTriVert[nCompCount - 1][TriIndex].nToolFlag ; + int nTool1 = CompoTriVert[nCompCount - 1][TriIndex+1].nToolFlag ; + int nTool2 = CompoTriVert[nCompCount - 1][TriIndex+2].nToolFlag ; + if ( nTool0 == nTool1 && nTool0 == nTool2) + CurrentTriangle.SetFlag( nTool0) ; + // bool bV = CurrentTriangle.Validate( true) ; // Riporto le coordinate nel sistema in cui è immerso lo Zmap CurrentTriangle.ToGlob( m_MapFrame) ; @@ -2440,6 +2415,13 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold) CurrentTriangle.Set( CompoTriVert[nCompCount - 1][TriIndex].ptInt, CompoTriVert[nCompCount - 1][TriIndex+1].ptInt, CompoTriVert[nCompCount - 1][TriIndex+2].ptInt) ; + // Setto il numero di utensile + int nTool0 = CompoTriVert[nCompCount - 1][TriIndex].nToolFlag ; + int nTool1 = CompoTriVert[nCompCount - 1][TriIndex+1].nToolFlag ; + int nTool2 = CompoTriVert[nCompCount - 1][TriIndex+2].nToolFlag ; + if ( nTool0 == nTool1 && nTool0 == nTool2) + CurrentTriangle.SetFlag( nTool0) ; + // bool bV = CurrentTriangle.Validate( true) ; // Riporto le coordinate nel sistema in cui è immerso lo Zmap CurrentTriangle.ToGlob( m_MapFrame) ; @@ -2927,7 +2909,7 @@ VolZmap::CalcIndex( int nI, int nJ, int nK) const //---------------------------------------------------------------------------- bool -VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, Vector3d& vtNormal) const +VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, VectorField& vfField) const { const double dEps = 2 * EPS_SMALL ; @@ -2941,8 +2923,8 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, double dMinX = ( nMinI + 0.5) * m_dStep ; double dMaxX = ( nMaxI + 0.5) * m_dStep ; - ptInt.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ; - ptInt.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ; + vfField.ptInt.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ; + vfField.ptInt.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ; size_t nDexel = ( nVec1[2] * m_nNx[1] + nVec1[1]) * N_DEXVOXRATIO ; int nSize = int( m_Values[1][nDexel].size()) ; @@ -2952,8 +2934,9 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, double dX = m_Values[1][nDexel][n].dMax ; while ( n >= 0 && dX > dMinX - dEps) { if ( dX < dMaxX + dEps) { - ptInt.x = dX ; - vtNormal = m_Values[1][nDexel][n].vtMaxN ; + vfField.ptInt.x = dX ; + vfField.vtNorm = m_Values[1][nDexel][n].vtMaxN ; + vfField.nToolFlag = m_Values[1][nDexel][n].nToolMax ; bFound = true ; break ; } @@ -2968,8 +2951,9 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, double dX = m_Values[1][nDexel][n].dMin ; while ( n < nSize && dX < dMaxX + dEps) { if ( dX > dMinX - dEps) { - ptInt.x = dX ; - vtNormal = m_Values[1][nDexel][n].vtMinN ; + vfField.ptInt.x = dX ; + vfField.vtNorm = m_Values[1][nDexel][n].vtMinN ; + vfField.nToolFlag = m_Values[1][nDexel][n].nToolMin ; bFound = true ; break ; } @@ -2980,7 +2964,7 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, } if ( ! bFound) - ptInt.x = 0.5 * ( dMinX + dMaxX) ; + vfField.ptInt.x = 0.5 * ( dMinX + dMaxX) ; } else if ( nVec1[1] != nVec2[1]) { @@ -2991,8 +2975,8 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, double dMinY = ( nMinJ + 0.5) * m_dStep ; double dMaxY = ( nMaxJ + 0.5) * m_dStep ; - ptInt.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ; - ptInt.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ; + vfField.ptInt.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ; + vfField.ptInt.z = ( nVec1[2] * N_DEXVOXRATIO + 0.5) * m_dStep ; size_t nDexel = ( nVec1[0] * m_nNx[2] + nVec1[2]) * N_DEXVOXRATIO ; int nSize = int( m_Values[2][nDexel].size()) ; @@ -3002,8 +2986,9 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, double dY = m_Values[2][nDexel][n].dMax ; while ( n >= 0 && dY > dMinY - dEps) { if ( dY < dMaxY + dEps) { - ptInt.y = dY ; - vtNormal = m_Values[2][nDexel][n].vtMaxN ; + vfField.ptInt.y = dY ; + vfField.vtNorm = m_Values[2][nDexel][n].vtMaxN ; + vfField.nToolFlag = m_Values[2][nDexel][n].nToolMax; bFound = true ; break ; } @@ -3018,8 +3003,9 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, double dY = m_Values[2][nDexel][n].dMin ; while ( n < nSize && dY < dMaxY + dEps) { if ( dY > dMinY - dEps) { - ptInt.y = dY ; - vtNormal = m_Values[2][nDexel][n].vtMinN ; + vfField.ptInt.y = dY ; + vfField.vtNorm = m_Values[2][nDexel][n].vtMinN ; + vfField.nToolFlag = m_Values[2][nDexel][n].nToolMin ; bFound = true ; break ; } @@ -3030,7 +3016,7 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, } if ( ! bFound) - ptInt.y = 0.5 * ( dMinY + dMaxY) ; + vfField.ptInt.y = 0.5 * ( dMinY + dMaxY) ; } else if ( nVec1[2] != nVec2[2]) { @@ -3041,8 +3027,8 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, double dMinZ = ( nMinK + 0.5) * m_dStep ; double dMaxZ = ( nMaxK + 0.5) * m_dStep ; - ptInt.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ; - ptInt.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ; + vfField.ptInt.x = ( nVec1[0] * N_DEXVOXRATIO + 0.5) * m_dStep ; + vfField.ptInt.y = ( nVec1[1] * N_DEXVOXRATIO + 0.5) * m_dStep ; size_t nDexel = ( nVec1[1] * m_nNx[0] + nVec1[0]) * N_DEXVOXRATIO ; int nSize = int( m_Values[0][nDexel].size()) ; @@ -3052,8 +3038,9 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, double dZ = m_Values[0][nDexel][n].dMax ; while ( n >= 0 && dZ > dMinZ - dEps) { if ( dZ < dMaxZ + dEps) { - ptInt.z = dZ ; - vtNormal = m_Values[0][nDexel][n].vtMaxN ; + vfField.ptInt.z = dZ ; + vfField.vtNorm = m_Values[0][nDexel][n].vtMaxN ; + vfField.nToolFlag = m_Values[0][nDexel][n].nToolMax ; bFound = true ; break ; } @@ -3068,8 +3055,9 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, double dZ = m_Values[0][nDexel][n].dMin ; while ( n < nSize && dZ < dMaxZ + dEps) { if ( dZ > dMinZ - dEps) { - ptInt.z = dZ ; - vtNormal = m_Values[0][nDexel][n].vtMinN ; + vfField.ptInt.z = dZ ; + vfField.vtNorm = m_Values[0][nDexel][n].vtMinN ; + vfField.nToolFlag = m_Values[0][nDexel][n].nToolMin ; bFound = true ; break ; } @@ -3080,7 +3068,7 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, } if ( ! bFound) - ptInt.z = 0.5 * ( dMinZ + dMaxZ) ; + vfField.ptInt.z = 0.5 * ( dMinZ + dMaxZ) ; } return bFound ;