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

EgtGeomKernel :

Browse Source 
- migliorie varie a Zmap, compresa suddivisione adattativa per visualizzazione.
This commit is contained in:
Dario Sassi
2016-10-29 15:45:54 +00:00
parent 916ca1e00b
commit 78e5b03411
2 changed files with 83 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmap.cpp
+81 -239
View File
@@ -399,47 +399,37 @@ VolZmap::CreateMap( const Point3d& ptO, double dLengthX, double dLengthY, double
bool
VolZmap::SubtractIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMax)
{
unsigned int nPos ;
// Controllo che dMin e dMax non siano quasi coincidenti
// Controllo che dMin e dMax non siano quasi coincidenti
if ( abs( dMax - dMin) < EPS_SMALL)
return true ;
// Controllo che dMin < dMax
if ( dMax < dMin ) {
// Controllo che dMin < dMax
if ( dMax < dMin )
swap( dMax, dMin) ;
double dTemp = dMax ;
dMax = dMin ;
dMin = dTemp ; // cambiato il 3/2
}
// Calcolo nPos
nPos = nJ*m_nNx + nI ; // O nJ*m_Nx + nI + 1 ?
// Calcolo nPos dello spillone
unsigned int nPos = nJ * m_nNx + nI ;
// Ciclo sugli intervalli dello spillone
bool bModified = false ;
unsigned int i = 0 ;
while ( i + 1 < m_ZValues[nPos].size()) {
while ( i < m_ZValues[nPos].size() - 1) {
if ( m_ZValues[nPos].size() == 0)
return true ;
// Casi:
// Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione
// Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione
if ( m_ZValues[nPos][i] > dMax - EPS_SMALL) {
;
}
// Intersezione
// Intersezione
else if ( m_ZValues[nPos][i + 1] > dMax + EPS_SMALL) {
// L'intervallo corrente corrente viene limitato a sinistra
if ( m_ZValues[nPos][i] > dMin - EPS_SMALL) {
bModified = true ;
m_ZValues[nPos][i] = dMax ;
}
// L'intervallo si divide in due intervalli
else {
bModified = true ;
m_ZValues[nPos].resize( m_ZValues[nPos].size() + 2) ;
for ( size_t j = m_ZValues[nPos].size() - 1 ; j >= i + 3 ; -- j)
@@ -452,10 +442,11 @@ VolZmap::SubtractIntervals( unsigned int nI, unsigned int nJ, double dMin, doubl
i = i + 2 ;
}
}
else {
// L'intervallo corrente viene eliminato
// L'intervallo corrente viene eliminato
if ( m_ZValues[nPos][i] > dMin - EPS_SMALL) {
bModified = true ;
for ( unsigned int j = i ; j < m_ZValues[nPos].size() - 2 ; ++ j)
m_ZValues[nPos][j] = m_ZValues[nPos][j + 2] ;
@@ -464,192 +455,23 @@ VolZmap::SubtractIntervals( unsigned int nI, unsigned int nJ, double dMin, doubl
i = i - 2 ;
}
// L'intervallo corrente viene limitato a destra
// L'intervallo corrente viene limitato a destra
else if ( m_ZValues[nPos][i + 1] > dMin + EPS_SMALL) {
bModified = true ;
m_ZValues[nPos][i + 1] = dMin ;
}
// L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione
// L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione
else {
;
}
}
i = i + 2 ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::SubtractIntervals2( unsigned int nI, unsigned int nJ, double dMin, double dMax)
{
unsigned int nPos ;
// Controllo che dMin e dMax non siano quasi coincidenti
if ( abs( dMax - dMin) < EPS_SMALL)
return true ;
// Controllo che dMin < dMax
if ( dMax < dMin ) {
double dTemp = dMax ;
dMax = dMin ;
dMin = dTemp ;
}
// Calcolo nPos
nPos = nJ * m_nNx2 + nI ;
unsigned int i = 0 ;
while ( i < m_ZValues2[nPos].size() - 1) {
if ( m_ZValues2[nPos].size() == 0)
return true ;
// Casi:
// Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione
if ( m_ZValues2[nPos][i] > dMax - EPS_SMALL) {
}
// Intersezione
else if ( m_ZValues2[nPos][i + 1] > dMax + EPS_SMALL) {
// L'intervallo corrente corrente viene limitato a sinistra
if ( m_ZValues2[nPos][i] > dMin - EPS_SMALL) {
m_ZValues2[nPos][i] = dMax ;
}
// L'intervallo si divide in due intervalli
else {
m_ZValues2[nPos].resize( m_ZValues2[nPos].size() + 2) ;
for ( size_t j = m_ZValues2[nPos].size() - 1 ; j >= i + 3 ; -- j)
m_ZValues2[nPos][j] = m_ZValues2[nPos][j - 2] ;
m_ZValues2[nPos][i + 1] = dMin ;
m_ZValues2[nPos][i + 2] = dMax ;
i = i + 2 ;
}
}
else {
// L'intervallo corrente viene eliminato
if ( m_ZValues2[nPos][i] > dMin - EPS_SMALL) {
for ( unsigned int j = i ; j < m_ZValues2[nPos].size() - 2 ; ++ j)
m_ZValues2[nPos][j] = m_ZValues2[nPos][j + 2] ;
m_ZValues2[nPos].resize( m_ZValues2[nPos].size() - 2) ;
i = i - 2 ;
}
// L'intervallo corrente viene limitato a destra
else if ( m_ZValues2[nPos][i + 1] > dMin + EPS_SMALL) {
m_ZValues2[nPos][i + 1] = dMin ;
}
// L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione
else {
}
}
i = i + 2 ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::SubtractIntervals3( unsigned int nI, unsigned int nJ, double dMin, double dMax)
{
unsigned int nPos ;
// Controllo che dMin e dMax non siano quasi coincidenti
if ( abs( dMax - dMin) < EPS_SMALL)
return true ;
// Controllo che dMin < dMax
if ( dMax < dMin ) {
double dTemp = dMax ;
dMax = dMin ;
dMin = dTemp ;
}
// Calcolo nPos
nPos = nJ * m_nNx3 + nI ;
unsigned int i = 0 ;
while ( i < m_ZValues3[nPos].size() - 1) {
if ( m_ZValues3[nPos].size() == 0)
return true ;
// Casi:
// Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione
if ( m_ZValues3[nPos][i] > dMax - EPS_SMALL) {
}
// Intersezione
else if ( m_ZValues3[nPos][i + 1] > dMax + EPS_SMALL) {
// L'intervallo corrente corrente viene limitato a sinistra
if ( m_ZValues3[nPos][i] > dMin - EPS_SMALL) {
m_ZValues3[nPos][i] = dMax ;
}
// L'intervallo si divide in due intervalli
else {
m_ZValues3[nPos].resize( m_ZValues3[nPos].size() + 2) ;
for ( size_t j = m_ZValues3[nPos].size() - 1 ; j >= i + 3 ; -- j)
m_ZValues3[nPos][j] = m_ZValues3[nPos][j - 2] ;
m_ZValues3[nPos][i + 1] = dMin ;
m_ZValues3[nPos][i + 2] = dMax ;
i = i + 2 ;
}
}
else {
// L'intervallo corrente viene eliminato
if ( m_ZValues3[nPos][i] > dMin - EPS_SMALL) {
for ( unsigned int j = i ; j < m_ZValues3[nPos].size() - 2 ; ++ j)
m_ZValues3[nPos][j] = m_ZValues3[nPos][j + 2] ;
m_ZValues3[nPos].resize( m_ZValues3[nPos].size() - 2) ;
i = i - 2 ;
}
// L'intervallo corrente viene limitato a destra
else if ( m_ZValues3[nPos][i + 1] > dMin + EPS_SMALL) {
m_ZValues3[nPos][i + 1] = dMin ;
}
// L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione
else {
}
}
i = i + 2 ;
}
// Se eseguita modifica, imposto ricalcolo della grafica
if ( bModified)
m_OGrMgr.Reset() ;
return true ;
}
@@ -668,8 +490,7 @@ VolZmap::SubtractIntervals( const Point3d& ptP, double dMin, double dMax)
dX = ptPL.x ; dY = ptPL.y ; dZ = ptPL.z ;
dhMin = dZ + dMin ; dhMax = dZ + dMax ;
// Cerco il punto della griglia più vicino
// Cerco il punto della griglia più vicino (indice è l'intero appena più basso)
double integerPartX = floor( dX / m_dStep) ;
double integerPartY = floor( dY / m_dStep) ;
@@ -699,12 +520,13 @@ VolZmap::AddIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMa
return true ;
// Controllo che dMin < dMax
if ( dMax < dMin )
swap( dMin, dMax) ;
if ( dMax < dMin)
swap( dMax, dMin) ;
// Calcolo nPos
unsigned int nPos = nJ * m_nNx + nI ; // O nJ*m_Nx + nI + 1 ?
// Calcolo nPos
unsigned int nPos = nJ * m_nNx + nI ;
// Se spillone vuoto
if ( m_ZValues[nPos].size() == 0) {
m_ZValues[nPos].resize( 2) ;
@@ -712,23 +534,25 @@ VolZmap::AddIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMa
m_ZValues[nPos][0] = dMin ;
m_ZValues[nPos][1] = dMax ;
m_OGrMgr.Reset() ;
return true ;
}
// Ciclo sugli intervalli dello spillone
bool bModified = false ;
unsigned int i = 0 ;
while ( i + 1 < m_ZValues[nPos].size()) {
while ( i < m_ZValues[nPos].size() - 1) {
// Eventuale aggiustamento di intervalli sovrapposti
if ( i > 0) {
// Caso in cui un intervallo precedente sconfini in quello corrente
if ( m_ZValues[nPos][i] < m_ZValues[nPos][i - 1] + EPS_SMALL) {
// Se l'intervallo corrente non è contenuto totalmente si esegue l'istruzione successiva
// Se l'intervallo corrente non è contenuto totalmente si esegue l'istruzione successiva
if ( m_ZValues[nPos][i - 1] < m_ZValues[nPos][i + 1] + EPS_SMALL)
m_ZValues[nPos][i - 1] = m_ZValues[nPos][i + 1] ;
for ( unsigned int j = i ; j < m_ZValues[nPos].size() - 2 ; ++ j)
m_ZValues[nPos][j] = m_ZValues[nPos][j + 2] ;
m_ZValues[nPos].resize( m_ZValues[nPos].size() - 2) ;
@@ -737,44 +561,46 @@ VolZmap::AddIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMa
}
}
// Caso in cui devo aggiungere un intervallo a sinistra dell'intervallo corrente
// Caso in cui devo aggiungere un intervallo a sinistra dell'intervallo corrente
if ( m_ZValues[nPos][i] > dMax + EPS_SMALL) {
bModified = true ;
m_ZValues[nPos].resize( m_ZValues[nPos].size() + 2) ;
m_ZValues[nPos].resize( m_ZValues[nPos].size() + 2) ;
for ( size_t j = m_ZValues[nPos].size() - 1 ; j >= i + 2 ; -- j)
m_ZValues[nPos][j] = m_ZValues[nPos][j - 2] ;
for ( size_t j = m_ZValues[nPos].size() - 1 ; j >= i + 2 ; -- j)
m_ZValues[nPos][j] = m_ZValues[nPos][j - 2] ;
m_ZValues[nPos][i] = dMin ;
m_ZValues[nPos][i + 1] = dMax ;
m_ZValues[nPos][i] = dMin ;
m_ZValues[nPos][i + 1] = dMax ;
i = i + 2 ;
i = i + 2 ;
}
// Casi d'intersezione:
// Casi d'intersezione:
else if ( m_ZValues[nPos][i + 1] > dMax - EPS_SMALL) {
// Se l'intervallo da aggiungere sconfina a sinistra modifico il minimo dell'intervalo corrente
if (m_ZValues[nPos][i] > dMin - EPS_SMALL) {
if ( m_ZValues[nPos][i] > dMin - EPS_SMALL) {
bModified = true ;
m_ZValues[nPos][i] = dMin ;
}
}
else {
// Se l'intervallo corrente è tutto contenuto nell'intervallo da aggungere modifico gli estremi
if ( m_ZValues[nPos][i] > dMin + EPS_SMALL) {
bModified = true ;
m_ZValues[nPos][i] = dMin ;
m_ZValues[nPos][i + 1] = dMax ;
}
// Se l'intervallo da aggiungere sconfina a destra modifico il massimo dell'intervallo corrente
else if ( m_ZValues[nPos][i + 1] > dMin - EPS_SMALL) {
bModified = true ;
m_ZValues[nPos][i + 1] = dMax ;
}
else {
// Aggiungo intervallo a destra dell'ultimo intervallo
if ( i == m_ZValues[nPos].size() - 2) {
bModified = true ;
m_ZValues[nPos].resize( m_ZValues[nPos].size() + 2) ;
m_ZValues[nPos][i + 2] = dMin ;
@@ -788,6 +614,10 @@ VolZmap::AddIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMa
i = i + 2 ;
}
// se eseguita modifica, imposto ricalcolo della grafica
if ( bModified)
m_OGrMgr.Reset() ;
return true ;
}
@@ -857,12 +687,12 @@ VolZmap::GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) con
bool
VolZmap::GetAllTriangles( TRIA3DLIST& lstTria) const
{
const int DIM_CHUNK = 4 ;
for ( int i = 0 ; i < int( m_nNx) ; i += DIM_CHUNK) {
int nDimChunkX = min( DIM_CHUNK, int( m_nNx) - i) ;
for ( int j = 0 ; j < int( m_nNy) ; j += DIM_CHUNK) {
int nDimChunkY = min( DIM_CHUNK, int( m_nNy) - j) ;
GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, lstTria) ;
const int MAX_DIM_CHUNK = 128 ;
for ( int i = 0 ; i < int( m_nNx) ; i += MAX_DIM_CHUNK) {
int nDimChunkX = min( MAX_DIM_CHUNK, int( m_nNx) - i) ;
for ( int j = 0 ; j < int( m_nNy) ; j += MAX_DIM_CHUNK) {
int nDimChunkY = min( MAX_DIM_CHUNK, int( m_nNy) - j) ;
GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, lstTria) ;
}
}
return true ;
@@ -870,7 +700,7 @@ VolZmap::GetAllTriangles( TRIA3DLIST& lstTria) const
//----------------------------------------------------------------------------
bool
VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST& lstTria) const
VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk, TRIA3DLIST& lstTria) const
{
// determino se è un semplice parallelepipedo
bool bIsSimple = true ;
@@ -896,6 +726,17 @@ VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST&
if ( bIsSimple) {
CalcChunkPrisms( nPos1, nPos2, nDim1, nDim2, lstTria) ;
}
// se chunk di dimensioni accettabili
else if ( nDimChk >= 4) {
int nNewDimChk = nDimChk / 2 ;
for ( int i = nPos1 ; i < int( nPos1 + nDim1) ; i += nNewDimChk) {
int nDimChunkX = min( nNewDimChk, int( nPos1 + nDim1) - i) ;
for ( int j = nPos2 ; j < int( nPos2 + nDim2) ; j += nNewDimChk) {
int nDimChunkY = min( nNewDimChk, int( nPos2 + nDim2) - j) ;
GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, nNewDimChk, lstTria) ;
}
}
}
// altrimenti
else {
// elaboro ogni singolo dexel
@@ -1081,8 +922,8 @@ VolZmap::SetStdTool( const string& sToolName, double dH, double dR, double dCorn
m_dHeight = dH ;
m_dRadius = dR ;
m_dTipHeight = dCornR ;
m_dTipRadius = m_dRadius ;
m_dRCorner = dR - dCornR ;
m_dTipRadius = dR - dCornR ;
m_dRCorner = dCornR ;
// come profilo
m_nToolType = GenericTool ;
Point3d pt0( 0, 0, 0) ;
@@ -1097,6 +938,7 @@ VolZmap::SetStdTool( const string& sToolName, double dH, double dR, double dCorn
m_ToolOutline.AddLine( pt2);
m_ToolOutline.AddArcTg( pt3) ;
m_ToolOutline.AddLine( pt4) ;
return SetGenTool( sToolName, &m_ToolOutline) ;
}
// utensile sferico
else if ( dCornR < dR + EPS_SMALL) {
@@ -9159,7 +9001,7 @@ VolZmap::MillConusAux( const Point3d& ptI, const Point3d& ptF, const Vector3d& v
// Traslazioni
//----------------------------------------------------------------------------
bool
VolZmap::Ball( const Point3d& ptLs, const Point3d& ptLe, const double& dRad)
VolZmap::Ball( const Point3d& ptLs, const Point3d& ptLe, double dRad)
{
double dMin, dMax ;
unsigned int nStartI, nStartJ, nEndI, nEndJ ;