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

EgtGeomKernel 1.9a1 :

Browse Source 
- aggiunte funzioni per conversione colore RGB in HSV e viceversa
- modifiche a VolZmap per gestione Flag utensile.
This commit is contained in:
Dario Sassi
2018-01-16 12:15:11 +00:00
parent fd4657d797
commit a2a63bf5c1
5 changed files with 246 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmap.cpp
+108 -108
View File
@@ -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<VolZmap*>(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<VolZmap> 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) ;
}