Merge branch 'master' into FasterVMill5Axis_Bez3x1
This commit is contained in:
Daniele Bariletti
+137
-120
@@ -617,134 +617,157 @@ VolZmap::AddIntervals( int nGrid, int nI, int nJ,
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::AddSubIntervalInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, int nK,
|
||||
double& dMin, double& dMax, Vector3d& vtMin, Vector3d& vtMax)
|
||||
VolZmap::ManageSubIntervalInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, int nK,
|
||||
double& dMin, double& dMax, Vector3d& vtMin, Vector3d& vtMax)
|
||||
{
|
||||
// se non Tridex, esco
|
||||
// Se non Tridex, esco
|
||||
if ( ! IsTriDexel())
|
||||
return true ;
|
||||
|
||||
|
||||
// Controllo che il numero di griglia sia entro i limiti
|
||||
if ( nGrid < 0 || nGrid > 2)
|
||||
return false ;
|
||||
|
||||
// Controllo che indici nI, nJ siano entro i limiti
|
||||
if ( nI < 0 && nI >= m_nNx[nGrid] &&
|
||||
nJ < 0 && nJ >= m_nNy[nGrid])
|
||||
if ( nI < 0 && nI >= m_nNx[nGrid] && nJ < 0 && nJ >= m_nNy[nGrid])
|
||||
return false ;
|
||||
|
||||
// valori di default
|
||||
vector<double> vTdMin = { -1., -1., -1., -1.} ;
|
||||
vector<double> vTdMax = { -1., -1., -1., -1.} ;
|
||||
VCT3DVECTOR vtNMin = { V_INVALID, V_INVALID, V_INVALID, V_INVALID} ;
|
||||
VCT3DVECTOR vtNMax = { V_INVALID, V_INVALID, V_INVALID, V_INVALID} ;
|
||||
// Valori di Default
|
||||
DBLVECTOR vdMin = { -1., -1., -1., -1.} ;
|
||||
DBLVECTOR vdMax = { -1., -1., -1., -1.} ;
|
||||
VCT3DVECTOR vNMin = { V_INVALID, V_INVALID, V_INVALID, V_INVALID} ;
|
||||
VCT3DVECTOR vNMax = { V_INVALID, V_INVALID, V_INVALID, V_INVALID} ;
|
||||
|
||||
// se esiste un precedente lungo x-locale
|
||||
// Se esiste un voxel precedente lungo x-locale ( nI - 1, nJ)
|
||||
if ( nI != 0) {
|
||||
int nPos = nJ * m_nNx[nGrid] + ( nI - 1) ; // recupero posizione dexel
|
||||
// cerco l'intervallo corretto sullo Zmap di riferimento
|
||||
// Ne recupero la posizione
|
||||
int nPos = nJ * m_nNx[nGrid] + ( nI - 1) ;
|
||||
// Scorro tutti gli intervalli del dexel in (nI - 1, nJ)
|
||||
for ( int it = 0 ; it < int( VolZmapRef->m_Values[nGrid][nPos].size()) ; ++ it) {
|
||||
// Se nei pressi dell'estremo superiore
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMax + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMax - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
vtNMax[0] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
|
||||
vTdMax[0] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
|
||||
// Memorizzo i parametri
|
||||
vNMax[0] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
|
||||
vdMax[0] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
|
||||
}
|
||||
// Se nei pressi dell'estremo inferiore
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMin + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMin - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
vtNMin[0] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
|
||||
vTdMin[0] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
|
||||
// Memorizzo i parametri
|
||||
vNMin[0] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
|
||||
vdMin[0] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
|
||||
}
|
||||
}
|
||||
}
|
||||
// se esiste il successivo lungo x-locale
|
||||
if ( nI != m_dMaxZ[( nGrid + 2) % 3]) {
|
||||
int nPos = nJ * m_nNx[nGrid] + ( nI + 1) ; // recupero posizione dexel
|
||||
|
||||
// Se esiste un voxel successivo lungo x-locale, ne recupero la posizione
|
||||
int nPos = nJ * m_nNx[nGrid] + ( nI + 1) ;
|
||||
if ( nPos < int( VolZmapRef->m_Values[nGrid].size())) {
|
||||
// Cerco l'intervallo corretto sullo Zmap di riferimento
|
||||
for ( int it = 0 ; it < int( VolZmapRef->m_Values[nGrid][nPos].size()) ; ++ it) {
|
||||
// cerco l'intervallo corretto sullo Zmap di riferimento
|
||||
// Se nei pressi dell'estremo superiore
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMax + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMax - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
vtNMax[1] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
|
||||
vTdMax[1] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
|
||||
// Memorizzo i parametri
|
||||
vNMax[1] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
|
||||
vdMax[1] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
|
||||
}
|
||||
// Se nei pressi dell'estremo inferiore
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMin + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMin - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
vtNMin[1] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
|
||||
vTdMin[1] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
|
||||
// Memorizzo i parametri
|
||||
vNMin[1] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
|
||||
vdMin[1] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
|
||||
}
|
||||
}
|
||||
}
|
||||
// se esiste il precedente lungo y-locale
|
||||
|
||||
// Se esiste un voxel precedente lungo y-locale
|
||||
if ( nJ != 0) {
|
||||
int nPos = ( nJ - 1) * m_nNx[nGrid] + nI ; // recupero posizione dexel
|
||||
// Ne recupero la posizione
|
||||
int nPos = ( nJ - 1) * m_nNx[nGrid] + nI ;
|
||||
// Cerco l'intervallo corretto sullo Zmap di riferimento
|
||||
for ( int it = 0 ; it < int( VolZmapRef->m_Values[nGrid][nPos].size()) ; ++ it) {
|
||||
// cerco l'intervallo corretto sullo Zmap di riferimento
|
||||
// Se nei pressi dell'estremo superiore
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMax + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMax - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
vtNMax[2] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
|
||||
vTdMax[2] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
|
||||
// Memorizzo i parametri
|
||||
vNMax[2] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
|
||||
vdMax[2] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
|
||||
}
|
||||
// Se nei pressi dell'estremo inferiore
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMin + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMin - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
vtNMin[2] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
|
||||
vTdMin[2] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
|
||||
}
|
||||
}
|
||||
}
|
||||
// se esiste il successivo lungo y-locale
|
||||
if ( nJ != m_dMaxZ[( nGrid + 1) % 3]) {
|
||||
int nPos = ( nJ + 1) * m_nNx[nGrid] + nI ; // recupero posizione dexel
|
||||
// cerco l'intervallo corretto sullo Zmap di riferimento
|
||||
for ( int it = 0 ; it < int( VolZmapRef->m_Values[nGrid][nPos].size()) ; ++ it) {
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMax + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMax - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
vtNMax[3] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
|
||||
vTdMax[3] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
|
||||
}
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMin + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMin - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
vtNMin[3] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
|
||||
vTdMin[3] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
|
||||
// Memorizzo i parametri
|
||||
vNMin[2] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
|
||||
vdMin[2] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// scelgo le normali che si discostano il meno possibile dalla normale della faccia del voxel
|
||||
// Se esiste un voxel successivo lungo y-locale, ne recupero la posizione
|
||||
nPos = ( nJ + 1) * m_nNx[nGrid] + nI ;
|
||||
if ( nPos < int( VolZmapRef->m_Values[nGrid].size())) {
|
||||
// Cerco l'intervallo corretto sullo Zmap di riferimento
|
||||
for ( int it = 0 ; it < int( VolZmapRef->m_Values[nGrid][nPos].size()) ; ++ it) {
|
||||
// Se nei pressi dell'estremo superiore
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMax + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMax - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
// Memorizzo i parametri
|
||||
vNMax[3] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
|
||||
vdMax[3] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
|
||||
}
|
||||
// Se nei pressi dell'estremo inferiore
|
||||
if ( VolZmapRef->m_Values[nGrid][nPos][it].dMin + EPS_SMALL > nK * m_dStep &&
|
||||
VolZmapRef->m_Values[nGrid][nPos][it].dMin - EPS_SMALL < ( nK + 1) * m_dStep) {
|
||||
// Memorizzo i parametri
|
||||
vNMin[3] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
|
||||
vdMin[3] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// analisi dei massimi e delle normali ---------------------------
|
||||
// 1) angolo minimo tra la normale trovata la faccia del voxel
|
||||
// --- Scelgo le normali che si discostano il meno possibile dalla normale della faccia del voxel
|
||||
|
||||
// 1) Angolo minimo tra la normale trovata la faccia del voxel
|
||||
double dMinAngle = ANG_FULL ;
|
||||
// 2) vettore di riferimento per la direzione della normale
|
||||
// 2) Vettore di riferimento per la direzione della normale
|
||||
vtMax = ( nGrid == 0 ? m_MapFrame.VersZ() :
|
||||
( nGrid == 1 ? m_MapFrame.VersX() : m_MapFrame.VersY())) ;
|
||||
nGrid == 1 ? m_MapFrame.VersX() :
|
||||
nGrid == 2 ? m_MapFrame.VersY() :
|
||||
V_INVALID) ;
|
||||
Vector3d vtRef = vtMax ;
|
||||
// 3) determino il massimo per questo intervallo
|
||||
// 3) Determino il massimo per questo intervallo
|
||||
dMax = ( nK + 1) * m_dStep ;
|
||||
for ( int i = 0 ; i < 4 ; ++ i) { // scorro le normali
|
||||
if ( vtNMax[i].IsValid()) { // se normale trovata, quindi valida...
|
||||
double dCurrAngle ; // angolo corrente tra la normale della TriMesh e quella della faccia del voxel
|
||||
vtNMax[i].GetAngle( vtRef, dCurrAngle) ;
|
||||
if ( abs( dCurrAngle) < dMinAngle) { // se angolo minore del minimo trovato...
|
||||
// aggiorno i parametri
|
||||
for ( int i = 0 ; i < 4 ; ++ i) {
|
||||
// Scorro le normali valide trovate
|
||||
if ( vNMax[i].IsValid()) {
|
||||
// Angolo corrente tra la normale di riferimento e quella della faccia del voxel
|
||||
double dCurrAngle ; vNMax[i].GetAngle( vtRef, dCurrAngle) ;
|
||||
// Se angolo minore del minimo trovato...
|
||||
if ( abs( dCurrAngle) < dMinAngle) {
|
||||
// ... Aggiorno i parametri
|
||||
dMinAngle = dCurrAngle ;
|
||||
vtMax = vtNMax[i] ;
|
||||
dMax = vTdMax[i] ;
|
||||
vtMax = vNMax[i] ;
|
||||
dMax = vdMax[i] ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// analisi dei minimi e delle normali ---------------------------
|
||||
// Ripeto lo stesso ragionamento per le normali dei massimi
|
||||
dMinAngle = ANG_FULL ;
|
||||
vtRef.Invert() ;
|
||||
dMin = nK * m_dStep ;
|
||||
vtMin = vtRef ;
|
||||
for ( int i = 0 ; i < 4 ; ++ i) {
|
||||
if ( vtNMin[i].IsValid()) {
|
||||
if ( vNMin[i].IsValid()) {
|
||||
double dCurrAngle ;
|
||||
vtNMin[i].GetAngle( vtRef, dCurrAngle) ;
|
||||
vNMin[i].GetAngle( vtRef, dCurrAngle) ;
|
||||
if ( abs( dCurrAngle) < dMinAngle) {
|
||||
dMinAngle = dCurrAngle ;
|
||||
vtMin = vtNMin[i] ;
|
||||
dMin = vTdMin[i] ;
|
||||
vtMin = vNMin[i] ;
|
||||
dMin = vdMin[i] ;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -754,72 +777,66 @@ VolZmap::AddSubIntervalInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ,
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::AddMissingIntervalsInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, double dZ, double dToler,
|
||||
Vector3d vtToolMin, Vector3d vtToolMax, int nToolNum)
|
||||
VolZmap::UniformIntervalsInVoxel( int nGrid, int nI, int nJ, double dZMin,
|
||||
double dZMax, double dToler, bool bAdd, int nToolNum, const Vector3d& vtToolMin,
|
||||
const Vector3d& vtToolMax)
|
||||
{
|
||||
|
||||
// se non Tridex, esco
|
||||
// Se non Tridex, esco
|
||||
if ( ! IsTriDexel())
|
||||
return true ;
|
||||
|
||||
|
||||
// Controllo che il numero di griglia sia entro i limiti
|
||||
if ( nGrid < 0 || nGrid > 2)
|
||||
return false ;
|
||||
|
||||
// Controllo che indici nI, nJ siano entro i limiti
|
||||
if ( nI < 0 && nI >= m_nNx[nGrid] &&
|
||||
nJ < 0 && nJ >= m_nNy[nGrid])
|
||||
if ( nI < 0 && nI >= m_nNx[nGrid] && nJ < 0 && nJ >= m_nNy[nGrid])
|
||||
return false ;
|
||||
|
||||
// passo da indici di dexel a indici di voxel
|
||||
nI /= m_nDexVoxRatio ;
|
||||
nJ /= m_nDexVoxRatio ;
|
||||
// Numero di voxel contenuti nel dexel corrente ( uguale per ogni dexel di una specifica griglia)
|
||||
int nVoxNum = int( m_nNy[(( nGrid + 1) % 3)] / m_nDexVoxRatio +
|
||||
( m_nNy[(( nGrid + 1) % 3)] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
|
||||
|
||||
// numero di voxel nel dexel corrente
|
||||
int nVoxNum = int( m_nNy[(( nGrid+1) % 3)] / m_nDexVoxRatio +
|
||||
( m_nNy[(( nGrid+1) % 3)] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
|
||||
|
||||
int nK = 0 ;
|
||||
for ( int i = 0 ; i < nVoxNum ; ++ i) {
|
||||
// controllo se sono nel voxel corrente
|
||||
if ( i * m_dStep < dZ && ( i + 1) * m_dStep > dZ) {
|
||||
nK = i ;
|
||||
break ;
|
||||
// Scorro i Voxel correnti
|
||||
for ( int nVox = 0 ; nVox < nVoxNum ; ++ nVox) {
|
||||
// Considero solo i Voxel interni all'intervallo corrente
|
||||
if ( dZMin - m_dStep / 2. < nVox * m_dStep && nVox * m_dStep < dZMax + m_dStep / 2.) {
|
||||
// recupero gli indici per la griglia successiva
|
||||
int nMyGrid = ( nGrid + 1) % 3 ;
|
||||
int nMyI = nJ ;
|
||||
int nMyJ = nVox ;
|
||||
int nMyK = nI ;
|
||||
double dMyMinZ = nMyK * m_dStep ; // shift di -Step / 2
|
||||
double dMyMaxZ = ( nMyK + 1) * m_dStep ; // shift di Step / 2
|
||||
Vector3d vtMyMaxN = ( vtToolMax.IsValid() ? vtToolMax :
|
||||
nMyGrid == 0 ? m_MapFrame.VersZ() :
|
||||
nMyGrid == 1 ? m_MapFrame.VersX() :
|
||||
m_MapFrame.VersY()) ;
|
||||
Vector3d vtMyMinN = ( vtToolMin.IsValid() ? vtToolMin : - vtMyMaxN) ;
|
||||
if ( bAdd)
|
||||
AddIntervals( nMyGrid, nMyI, nMyJ, dMyMinZ, dMyMaxZ, vtMyMinN, vtMyMaxN, nToolNum, true) ;
|
||||
else
|
||||
SubtractIntervals( nMyGrid, nMyI, nMyJ, dMyMinZ, dMyMaxZ, vtMyMinN, vtMyMaxN, nToolNum, true) ;
|
||||
// recupero gli indici della griglia precedente
|
||||
nMyGrid = ( nGrid + 2) % 3 ;
|
||||
nMyI = nVox ;
|
||||
nMyJ = nI ;
|
||||
nMyK = nJ ;
|
||||
dMyMinZ = nMyK * m_dStep ; // shift di -Step / 2
|
||||
dMyMaxZ = ( nMyK + 1) * m_dStep ; // shift di Step / 2
|
||||
vtMyMaxN = ( vtToolMax.IsValid() ? vtToolMax :
|
||||
nMyGrid == 0 ? m_MapFrame.VersZ() :
|
||||
nMyGrid == 1 ? m_MapFrame.VersX() :
|
||||
m_MapFrame.VersY()) ;
|
||||
vtMyMinN = ( vtToolMin.IsValid() ? vtToolMin : - vtMyMaxN) ;
|
||||
if ( bAdd)
|
||||
AddIntervals( nMyGrid, nMyI, nMyJ, dMyMinZ, dMyMaxZ, vtMyMinN, vtMyMaxN, nToolNum, true) ;
|
||||
else
|
||||
SubtractIntervals( nMyGrid, nMyI, nMyJ, dMyMinZ, dMyMaxZ, vtMyMinN, vtMyMaxN, nToolNum, true) ;
|
||||
}
|
||||
}
|
||||
|
||||
// ----------- griglia successiva -----------
|
||||
{
|
||||
int nMyGrid = ( nGrid + 1) % 3 ;
|
||||
int nMyI = nJ ;
|
||||
int nMyJ = nK ;
|
||||
int nMyK = nI ;
|
||||
double dMyMin ;
|
||||
double dMyMax ;
|
||||
Vector3d vtMyMin ;
|
||||
Vector3d vtMyMax ;
|
||||
AddSubIntervalInVoxel( VolZmapRef, nMyGrid, nMyI, nMyJ, nMyK, dMyMin, dMyMax, vtMyMin, vtMyMax) ;
|
||||
AddIntervals( nMyGrid, nMyI, nMyJ, dMyMin - EPS_SMALL, dMyMax + EPS_SMALL, vtMyMin, vtMyMax,
|
||||
nToolNum, true) ;
|
||||
}
|
||||
|
||||
// ----------- griglia precedente -----------
|
||||
{
|
||||
int nMyGrid = ( nGrid + 2) % 3 ;
|
||||
int nMyI = nK ;
|
||||
int nMyJ = nI ;
|
||||
int nMyK = nJ ;
|
||||
double dMyMin ;
|
||||
double dMyMax ;
|
||||
Vector3d vtMyMin ;
|
||||
Vector3d vtMyMax ;
|
||||
AddSubIntervalInVoxel( VolZmapRef, nMyGrid, nMyI, nMyJ, nMyK, dMyMin, dMyMax, vtMyMin, vtMyMax) ;
|
||||
AddIntervals( nMyGrid, nMyI, nMyJ, dMyMin - EPS_SMALL, dMyMax + EPS_SMALL, vtMyMin, vtMyMax,
|
||||
nToolNum, true) ;
|
||||
}
|
||||
|
||||
return true ;
|
||||
|
||||
}
|
||||
|
||||
// ------------------------- BOUNDING BOX --------------------------------------------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user