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

EgtGeomKernel 1.8j3 :

Browse Source 
- migliorata classificazione tratti di curve dopo intersezione
- migliorata ClonePart di Zmap.
This commit is contained in:
Dario Sassi
2017-10-12 17:51:36 +00:00
parent fc74341862
commit 31658bb165
6 changed files with 160 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmap.cpp
+85 -44
View File
@@ -905,16 +905,16 @@ VolZmap::ClonePart( int nPart) const
// Se è definita una sola griglia non sono definibili le parti, errore
if ( m_nMapNum == 1)
return nullptr ;
// Se è richiesta una componente fuori intervallo restituisco nullptr.
// Se è richiesta una componente fuori intervallo, errore
if ( nPart < 0 || nPart >= m_nConnectedCompoCount)
return nullptr ;
// Se il numero di componenti è indefinito, lo ricalcolo.
if ( m_nConnectedCompoCount == - 1)
const_cast<VolZmap*>(this)->CheckMapConnection() ;
// Se non vi sono componenti restituisco nullptr.
// 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 ;
@@ -924,31 +924,28 @@ VolZmap::ClonePart( int nPart) const
pVolume->m_nMapNum = m_nMapNum ;
// Minimi e massimi indici i,j della componente per le tre griglie
int nMinIndI[3] ;
int nMaxIndI[3] ;
int nMinIndJ[3] ;
int nMaxIndJ[3] ;
int nMinIndI[N_MAPS] ;
int nMaxIndI[N_MAPS] ;
int nMinIndJ[N_MAPS] ;
int nMaxIndJ[N_MAPS] ;
// Coordinate dell'origine del sistema di riferimento
// del nuovo Zmap
double dNewOx, dNewOy, dNewOz ;
// Ciclo sulle mappe
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
nMinIndI[nMap] = m_nNx[nMap] ;
nMinIndJ[nMap] = m_nNy[nMap] ;
nMaxIndI[nMap] = 0 ;
nMaxIndJ[nMap] = 0 ;
// Della componente connessa in questione calcolo
// indici i e j massimi e minimi.
pVolume->m_dMinZ[nMap] = m_dMaxZ[nMap] ;
pVolume->m_dMaxZ[nMap] = m_dMinZ[nMap] ;
// Della componente connessa in questione calcolo indici i e j massimi e minimi.
// Inoltre cerco la minima e massima Z.
for ( int nIndI = 0 ; nIndI < int( m_nNx[nMap]) ; ++ nIndI) {
for ( int nIndJ = 0 ; nIndJ < int( m_nNy[nMap]) ; ++ nIndJ) {
int nDex = nIndJ * m_nNx[nMap] + nIndI ;
for ( int nInt = 0 ; nInt < int( m_Values[nMap][nDex].size()) ; ++ nInt) {
if ( m_Values[nMap][nDex][nInt].nCompo == nPart + 1) {
if ( nIndI < nMinIndI[nMap])
nMinIndI[nMap] = nIndI ;
if ( nIndJ < nMinIndJ[nMap])
@@ -957,55 +954,98 @@ 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].dMax > pVolume->m_dMaxZ[nMap])
pVolume->m_dMaxZ[nMap] = m_Values[nMap][nDex][nInt].dMax ;
}
}
}
}
}
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
if ( nMinIndI[nMap] > 0)
-- nMinIndI[nMap] ;
if ( nMaxIndI[nMap] < int( m_nNx[nMap]) - 1)
++ nMaxIndI[nMap] ;
if ( nMinIndJ[nMap] > 0)
-- nMinIndJ[nMap] ;
if ( nMaxIndJ[nMap] < int( m_nNy[nMap]) - 1)
++ nMaxIndJ[nMap] ;
pVolume->m_nNx[nMap] = nMaxIndI[nMap] - nMinIndI[nMap] + 1 ;
pVolume->m_nNy[nMap] = nMaxIndJ[nMap] - nMinIndJ[nMap] + 1 ;
pVolume->m_nDim[nMap] = pVolume->m_nNx[nMap] * pVolume->m_nNy[nMap] ;
pVolume->m_Values[nMap].resize( pVolume->m_nDim[nMap]) ;
pVolume->m_dMinZ[nMap] = m_dMaxZ[nMap] ;
pVolume->m_dMaxZ[nMap] = m_dMinZ[nMap] ;
}
// Copio gli intervalli nella griglia del nuovo oggetto
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
for ( int nIndJ = 0 ; nIndJ < int( pVolume->m_nNy[nMap]) ; ++ nIndJ) {
for ( int nIndI = 0 ; nIndI < int( pVolume->m_nNx[nMap]) ; ++ nIndI) {
int nNewDex = nIndJ * pVolume->m_nNx[nMap] + nIndI ;
int nOldDex = ( nIndJ + nMinIndJ[nMap]) * m_nNx[nMap] + nIndI + nMinIndI[nMap] ;
for ( int nInt = 0 ; nInt < int( m_Values[nMap][nOldDex].size()) ; ++ nInt) {
if ( m_Values[nMap][nOldDex][nInt].nCompo == nPart + 1) {
pVolume->m_Values[nMap][nNewDex].emplace_back( m_Values[nMap][nOldDex][nInt]) ;
pVolume->m_Values[nMap][nNewDex][pVolume->m_Values[nMap][nNewDex].size() - 1].nCompo = 1 ;
if ( m_Values[nMap][nOldDex][nInt].dMin < pVolume->m_dMinZ[nMap])
pVolume->m_dMinZ[nMap] = m_Values[nMap][nOldDex][nInt].dMin ;
if ( m_Values[nMap][nOldDex][nInt].dMax > pVolume->m_dMaxZ[nMap])
pVolume->m_dMaxZ[nMap] = m_Values[nMap][nOldDex][nInt].dMax ;
}
// Copio gli intervalli nelle griglie del nuovo oggetto:
// Griglia 0
for ( int nIndJ = 0 ; nIndJ < int( pVolume->m_nNy[0]) ; ++ nIndJ) {
for ( int nIndI = 0 ; nIndI < int( pVolume->m_nNx[0]) ; ++ nIndI) {
int nNewDex = nIndJ * pVolume->m_nNx[0] + nIndI ;
int nOldDex = ( nIndJ + nMinIndJ[0]) * m_nNx[0] + nIndI + nMinIndI[0] ;
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 ;
}
}
}
}
// Griglia 1
for ( int nIndJ = 0 ; nIndJ < int( pVolume->m_nNy[1]) ; ++ nIndJ) {
for ( int nIndI = 0 ; nIndI < int( pVolume->m_nNx[1]) ; ++ nIndI) {
int nNewDex = nIndJ * pVolume->m_nNx[1] + nIndI ;
int nOldDex = ( nIndJ + nMinIndJ[1]) * m_nNx[1] + nIndI + nMinIndI[1] ;
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 ;
}
}
}
}
// Griglia 2
for ( int nIndJ = 0 ; nIndJ < int( pVolume->m_nNy[2]) ; ++ nIndJ) {
for ( int nIndI = 0 ; nIndI < int( pVolume->m_nNx[2]) ; ++ nIndI) {
int nNewDex = nIndJ * pVolume->m_nNx[2] + nIndI ;
int nOldDex = ( nIndJ + nMinIndJ[2]) * m_nNx[2] + nIndI + nMinIndI[2] ;
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 ;
}
}
}
}
// Coordinate x,y dell'origine del sistema di riferimento
dNewOx = nMinIndI[0] * m_dStep ;
dNewOy = nMinIndJ[0] * m_dStep ;
dNewOz = nMinIndJ[1] * m_dStep ;
//dNewOz = pVolume->m_dMinZ[0] ;
// Porto i dexel nel nuovo sistema di riferimento
// Porto i dexel nel nuovo sistema di riferimento e le quote estreme Z. Non c'è bisogno di trasformare le normali,
// infatti i sistemi di riferimento in gioco differiscono al più per una traslazione.
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
for ( int nDex = 0 ; nDex < int( pVolume->m_nDim[nMap]) ; ++ nDex) {
// Quote estreme Z
switch ( nMap) {
case 0 :
pVolume->m_dMinZ[nMap] -= dNewOz ;
pVolume->m_dMaxZ[nMap] -= dNewOz ;
break ;
case 1 :
pVolume->m_dMinZ[nMap] -= dNewOx ;
pVolume->m_dMaxZ[nMap] -= dNewOx ;
break ;
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 nInt = 0 ; nInt < int( pVolume->m_Values[nMap][nDex].size()) ; ++ nInt) {
switch ( nMap) {
case 0 :
pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOz ;
@@ -1024,7 +1064,7 @@ VolZmap::ClonePart( int nPart) const
}
}
// Definisco il numero di blocchi lungo x,y e z
// Definisco il numero di blocchi lungo x, y e z
pVolume->m_nFracLin[0] = max( 1u,
pVolume->m_nNx[0] / pVolume->m_nDexNumPBlock +
( pVolume->m_nNx[0] % pVolume->m_nDexNumPBlock >= pVolume->m_nDexNumPBlock / 2 ? 1 : 0)) ;
@@ -1038,7 +1078,7 @@ VolZmap::ClonePart( int nPart) const
// 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 ricalcolare (per quanto riguarda la grafica)
// 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 ;
@@ -1053,6 +1093,7 @@ VolZmap::ClonePart( int nPart) const
// Setto lo stato del nuovo Solido
pVolume->m_nStatus = m_nStatus ;
// Restituisco il nuovo solido
return Release( pVolume) ;
}