EgtGeomKernel :
- in Zmap resa funzionante ClonePart.
This commit is contained in:
Dario Sassi
+135
-110
@@ -566,10 +566,16 @@ VolZmap::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
|
||||
int
|
||||
VolZmap::GetPartCount( void) const
|
||||
{
|
||||
// Se mono-dexel la connessione è incalcolabile.
|
||||
if ( m_nMapNum == 1)
|
||||
return - 1 ;
|
||||
// Se il numero delle componenti è indefinito
|
||||
// lo ricalcolo e restituisco il risultato.
|
||||
if ( m_nConnectedCompoCount == - 1) {
|
||||
const_cast<VolZmap*>(this)->CheckMapConnection() ;
|
||||
return m_nConnectedCompoCount ;
|
||||
}
|
||||
// Altrimenti restituisco direttamente il numero di componenti.
|
||||
else
|
||||
return m_nConnectedCompoCount ;
|
||||
}
|
||||
@@ -893,138 +899,157 @@ VolZmap::ExpandFromZInterval( IntContaier& IntCont)
|
||||
VolZmap*
|
||||
VolZmap::ClonePart( int nPart) const
|
||||
{
|
||||
|
||||
// Se è usata una sola griglia, i risultati non
|
||||
// sarebbero attendibili; restituisco nullptr.
|
||||
if ( m_nMapNum == 1)
|
||||
return nullptr ;
|
||||
|
||||
#if 0
|
||||
// Se il vettore non è vuoto lo pulisco
|
||||
if ( vMap.size() > 0)
|
||||
vMap.resize( 0) ;
|
||||
// Se il numero di componenti è
|
||||
// indefinito, lo ricalcolo.
|
||||
// Se è richiesta una componente fuori intervallo restituisco nullptr.
|
||||
if ( nPart < 0 || nPart >= m_nConnectedCompoCount)
|
||||
return nullptr ;
|
||||
// Se il numero di componenti è indefinito, lo ricalcolo.
|
||||
if ( m_nConnectedCompoCount == - 1)
|
||||
IsMapConnected() ;
|
||||
const_cast<VolZmap*>(this)->CheckMapConnection() ;
|
||||
// Se non vi sono componenti restituisco nullptr.
|
||||
if ( m_nConnectedCompoCount == 0)
|
||||
return nullptr ;
|
||||
|
||||
// Se il numero di componenti è
|
||||
// superiore a 1, creo più Zmap.
|
||||
if ( m_nConnectedCompoCount > 1)
|
||||
vMap.reserve( m_nConnectedCompoCount - 1) ;
|
||||
else
|
||||
return true ;
|
||||
PtrOwner<VolZmap> pVolume( CreateBasicVolZmap()) ;
|
||||
if ( IsNull( pVolume))
|
||||
return nullptr ;
|
||||
// Setto per il nuovo Zmap le seguenti variabili
|
||||
pVolume->m_nConnectedCompoCount = 1 ;
|
||||
pVolume->m_dStep = m_dStep ;
|
||||
pVolume->m_nMapNum = m_nMapNum ;
|
||||
|
||||
// Ciclo sulle componenti connesse con indice superiore a uno
|
||||
for ( int nC = 2 ; nC <= m_nConnectedCompoCount ; ++ nC) {
|
||||
|
||||
VolZmap TempMap ;
|
||||
TempMap.m_nConnectedCompoCount = 1 ;
|
||||
TempMap.m_dStep = m_dStep ;
|
||||
TempMap.m_nMapNum = m_nMapNum ;
|
||||
|
||||
int nMinIndI, nMaxIndI, nMinIndJ, nMaxIndJ ;
|
||||
|
||||
double dNewOx, dNewOy, dNewOz ;
|
||||
// Ciclo sulle mappe
|
||||
for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
|
||||
int nMinIndI[3] ;
|
||||
int nMaxIndI[3] ;
|
||||
int nMinIndJ[3] ;
|
||||
int nMaxIndJ[3] ;
|
||||
// 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 = m_nNx[nMap] ;
|
||||
nMinIndJ = m_nNy[nMap] ;
|
||||
nMaxIndI = 0 ;
|
||||
nMaxIndJ = 0 ;
|
||||
// Della componente connessa in questione calcolo
|
||||
// indici i e j massimi e minimi.
|
||||
for ( int nIndI = 0 ; nIndI < m_nNx[nMap] ; ++ nIndI) {
|
||||
for ( int nIndJ = 0 ; nIndJ < m_nNy[nMap] ; ++ nIndJ) {
|
||||
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.
|
||||
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[0] + nIndI ;
|
||||
int nDex = nIndJ * m_nNx[nMap] + nIndI ;
|
||||
|
||||
for ( int nInt = 0 ; nInt < m_Values[nMap][nDex].size() ; ++ nInt) {
|
||||
for ( int nInt = 0 ; nInt < int( m_Values[nMap][nDex].size()) ; ++ nInt) {
|
||||
|
||||
if ( m_Values[nMap][nDex][nInt].nCompo == nC) {
|
||||
if ( m_Values[nMap][nDex][nInt].nCompo == nPart + 1) {
|
||||
|
||||
if ( nIndI < nMinIndI)
|
||||
nMinIndI = nIndI ;
|
||||
if ( nIndJ < nMinIndJ)
|
||||
nMinIndJ = nIndJ ;
|
||||
if ( nIndI > nMaxIndI)
|
||||
nMaxIndI = nIndI ;
|
||||
if ( nIndJ > nMaxIndJ)
|
||||
nMaxIndJ = nIndJ ;
|
||||
}
|
||||
if ( nIndI < nMinIndI[nMap])
|
||||
nMinIndI[nMap] = nIndI ;
|
||||
if ( nIndJ < nMinIndJ[nMap])
|
||||
nMinIndJ[nMap] = nIndJ ;
|
||||
if ( nIndI > nMaxIndI[nMap])
|
||||
nMaxIndI[nMap] = nIndI ;
|
||||
if ( nIndJ > nMaxIndJ[nMap])
|
||||
nMaxIndJ[nMap] = nIndJ ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TempMap.m_nNx[nMap] = nMaxIndI - nMinIndI + 1 ;
|
||||
TempMap.m_nNy[nMap] = nMaxIndJ - nMinIndJ + 1 ;
|
||||
TempMap.m_nDim[nMap] = TempMap.m_nNx[nMap] * TempMap.m_nNy[nMap] ;
|
||||
TempMap.m_Values[nMap].resize( TempMap.m_nDim[nMap]) ;
|
||||
TempMap.m_dMinZ[nMap] = m_dMaxZ[nMap] ;
|
||||
TempMap.m_dMaxZ[nMap] = m_dMinZ[nMap] ;
|
||||
|
||||
// Coordinate x,y dell'origine del sistema di riferimento
|
||||
if ( nMap == 0) {
|
||||
dNewOx = ( nMinIndI - 0.5) * m_dStep ;
|
||||
dNewOy = ( nMinIndJ - 0.5) * m_dStep ;
|
||||
dNewOz = TempMap.m_dMinZ[nMap] ;
|
||||
}
|
||||
if ( nMap == 1) {
|
||||
|
||||
dNewOz = ( nMinIndJ - 0.5) * m_dStep ;
|
||||
}
|
||||
}
|
||||
// Copio gli intervalli nella griglia del nuovo oggetto
|
||||
// e li cancello da quella del vecchio.
|
||||
for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
|
||||
|
||||
for ( int nIndJ = 0 ; nIndJ < TempMap.m_nNy[nMap] ; ++ nIndJ) {
|
||||
for ( int nIndI = 0 ; nIndI < TempMap.m_nNx[nMap] ; ++ nIndI) {
|
||||
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) {
|
||||
|
||||
int nNewDex = nIndJ * TempMap.m_nNx[nMap] + nIndI ;
|
||||
int nOldDex = ( nIndJ + nMinIndJ) * m_nNx[nMap] + nIndI + nMinIndI ;
|
||||
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 < m_Values[nMap][nOldDex].size() ; ++ nInt) {
|
||||
for ( int nInt = 0 ; nInt < int( m_Values[nMap][nOldDex].size()) ; ++ nInt) {
|
||||
|
||||
if ( m_Values[nMap][nOldDex][nInt].nCompo == nC) {
|
||||
if ( m_Values[nMap][nOldDex][nInt].nCompo == nPart + 1) {
|
||||
|
||||
TempMap.m_Values[nMap][nNewDex].emplace_back( m_Values[nMap][nOldDex][nInt]) ;
|
||||
m_Values[nMap][nOldDex].erase( m_Values[nMap][nOldDex].begin() + nInt) ;
|
||||
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 < TempMap.m_dMinZ[nMap])
|
||||
TempMap.m_dMinZ[nMap] = m_Values[nMap][nOldDex][nInt].dMin ;
|
||||
if ( m_Values[nMap][nOldDex][nInt].dMax > TempMap.m_dMaxZ[nMap])
|
||||
TempMap.m_dMaxZ[nMap] = m_Values[nMap][nOldDex][nInt].dMax ;
|
||||
}
|
||||
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 ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Definisco il numero di blocchi lungo x e y
|
||||
TempMap.m_nFracLin[0] = max( 1u,
|
||||
TempMap.m_nNx[0] / TempMap.m_nDexNumPBlock +
|
||||
( TempMap.m_nNx[0] % TempMap.m_nDexNumPBlock >= TempMap.m_nDexNumPBlock / 2 ? 1 : 0)) ;
|
||||
TempMap.m_nFracLin[1] = max( 1u,
|
||||
TempMap.m_nNy[0] / TempMap.m_nDexNumPBlock +
|
||||
( TempMap.m_nNy[0] % TempMap.m_nDexNumPBlock >= TempMap.m_nDexNumPBlock / 2 ? 1 : 0)) ;
|
||||
|
||||
// Se vi sono tre griglie definisco il numero di blocchi lungo z
|
||||
if ( TempMap.m_nMapNum > 1)
|
||||
TempMap.m_nFracLin[2] = max( 1u,
|
||||
TempMap.m_nNy[1] / TempMap.m_nDexNumPBlock +
|
||||
( TempMap.m_nNy[1] % TempMap.m_nDexNumPBlock >= TempMap.m_nDexNumPBlock / 2 ? 1 : 0)) ;
|
||||
|
||||
// Sistema di riferimento
|
||||
Point3d ptNewO( dNewOx, dNewOy, dNewOz) ;
|
||||
TempMap.m_MapFrame[0].Set( ptNewO, X_AX, Y_AX, Z_AX) ;
|
||||
|
||||
if ( TempMap.m_nMapNum > 1) {
|
||||
|
||||
TempMap.m_MapFrame[1].Set( ptNewO, Y_AX, Z_AX, X_AX) ;
|
||||
TempMap.m_MapFrame[2].Set( ptNewO, Z_AX, X_AX, Y_AX) ;
|
||||
}
|
||||
// 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
|
||||
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
|
||||
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 ;
|
||||
pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOz ;
|
||||
break ;
|
||||
case 1 :
|
||||
pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOx ;
|
||||
pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOx ;
|
||||
break ;
|
||||
case 2 :
|
||||
pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOy ;
|
||||
pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOy ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
vMap.emplace_back( TempMap) ;
|
||||
}
|
||||
return true ;
|
||||
#endif
|
||||
}
|
||||
|
||||
// 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)) ;
|
||||
pVolume->m_nFracLin[1] = max( 1u,
|
||||
pVolume->m_nNy[0] / pVolume->m_nDexNumPBlock +
|
||||
( pVolume->m_nNy[0] % pVolume->m_nDexNumPBlock >= pVolume->m_nDexNumPBlock / 2 ? 1 : 0)) ;
|
||||
pVolume->m_nFracLin[2] = max( 1u,
|
||||
pVolume->m_nNy[1] / pVolume->m_nDexNumPBlock +
|
||||
( pVolume->m_nNy[1] % pVolume->m_nDexNumPBlock >= pVolume->m_nDexNumPBlock / 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 ricalcolare (per quanto riguarda la grafica)
|
||||
for ( unsigned int nCount = 0 ; nCount < pVolume->m_nNumBlock ; ++ nCount)
|
||||
pVolume->m_BlockToUpdate[nCount] = true ;
|
||||
|
||||
// Dimensiono raccolta triangoli di feature tra blocchi
|
||||
pVolume->m_InterBlockTria.resize( pVolume->m_nNumBlock) ;
|
||||
|
||||
// Sistemi di riferimento delle griglie del nuovo solido
|
||||
Point3d ptNewO( dNewOx, dNewOy, dNewOz) ;
|
||||
pVolume->m_MapFrame[0].Set( ptNewO, X_AX, Y_AX, Z_AX) ;
|
||||
pVolume->m_MapFrame[1].Set( ptNewO, Y_AX, Z_AX, X_AX) ;
|
||||
pVolume->m_MapFrame[2].Set( ptNewO, Z_AX, X_AX, Y_AX) ;
|
||||
|
||||
// Setto lo stato del nuovo Solido
|
||||
pVolume->m_nStatus = m_nStatus ;
|
||||
// Restituisco il nuovo solido
|
||||
return Release( pVolume) ;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user