diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index 38dc9ed..e2b58e2 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/EgtGeomKernel.vcxproj b/EgtGeomKernel.vcxproj
index afb5ca0..bcbc746 100644
--- a/EgtGeomKernel.vcxproj
+++ b/EgtGeomKernel.vcxproj
@@ -372,6 +372,7 @@ copy $(TargetPath) \EgtProg\Dll64
+
@@ -390,6 +391,7 @@ copy $(TargetPath) \EgtProg\Dll64
+
@@ -398,6 +400,7 @@ copy $(TargetPath) \EgtProg\Dll64
+
@@ -414,7 +417,9 @@ copy $(TargetPath) \EgtProg\Dll64
+
+
@@ -424,20 +429,25 @@ copy $(TargetPath) \EgtProg\Dll64
+
+
+
+
+
diff --git a/EgtGeomKernel.vcxproj.filters b/EgtGeomKernel.vcxproj.filters
index 50e6534..7fc8049 100644
--- a/EgtGeomKernel.vcxproj.filters
+++ b/EgtGeomKernel.vcxproj.filters
@@ -812,6 +812,36 @@
File di intestazione\Include
+
+ File di intestazione\Include
+
+
+ File di intestazione\Include
+
+
+ File di intestazione\Include
+
+
+ File di intestazione\Include
+
+
+ File di intestazione\Include
+
+
+ File di intestazione\Include
+
+
+ File di intestazione\Include
+
+
+ File di intestazione\Include
+
+
+ File di intestazione\Include
+
+
+ File di intestazione\Include
+
diff --git a/VolTriZmapGraphics.cpp b/VolTriZmapGraphics.cpp
index ae421d5..f77fb23 100644
--- a/VolTriZmapGraphics.cpp
+++ b/VolTriZmapGraphics.cpp
@@ -24,6 +24,7 @@
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Extern/Eigen\Core"
#include "/EgtDev/Extern/Eigen\SVD"
+#include "PolygonPlane.h"
using namespace std ;
@@ -1665,7 +1666,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold)
for ( int i = nLimits[0] ; i < nLimits[1] ; ++ i) {
for ( int j = nLimits[2] ; j < nLimits[3] ; ++ j) {
for ( int k = nLimits[4] ; k < nLimits[5] ; ++ k) {
-
+
// Classificazione dei vertici: interni o esterni al materiale
int nIndex = CalcIndex( i, j , k) ;
@@ -2597,6 +2598,224 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold)
}
}
+ // Ventaglio con base a quattro vertici
+ else if ( nVertComp[nCompCount - 1] == 4) {
+
+ // Controllo se esiste almeno un triangolo con normale avente prodotto scalare
+ // negativo con la normale di almeno uno dei vertici di base del ventaglio.
+ bool bInversione = false ;
+ for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) {
+
+ int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ;
+
+ double dDI = triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm ;
+ double dDJ = triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm ;
+
+ if ( dDI < - EPS_SMALL || dDJ < - EPS_SMALL)
+ bInversione = true ;
+ }
+ // Se tale triangolo esiste continuo i test
+ if ( bInversione) {
+
+ // Conto il numero di coppie di normali con prodotto scalare negativo
+ int nNegDot = 0 ;
+ for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] - 1 ; ++ ni) {
+ for ( int nj = ni + 1 ; nj < nVertComp[nCompCount - 1] ; ++ nj) {
+ double dDot = CompoVert[nCompCount - 1][ni].vtNorm * CompoVert[nCompCount - 1][nj].vtNorm ;
+ if ( dDot < - EPS_SMALL)
+ nNegDot ++ ;
+ }
+ }
+
+ // Caso in cui tale numero è 3
+ if ( nNegDot == nVertComp[nCompCount - 1] - 1) {
+
+ Point3d ptSolZMapFrame = ptSol ;
+
+ // Se la feature non cade nel suo voxel
+ if ( ! IsPointInsideVoxelApprox( i, j, k, ptSolZMapFrame)) {
+
+ Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ;
+
+ double dParInt1, dParInt2 ;
+ Point3d ptVoxMin( ( i * N_DEXVOXRATIO + 0.5) * m_dStep,
+ ( j * N_DEXVOXRATIO + 0.5) * m_dStep, ( k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
+ Point3d ptVoxMax( ( ( i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
+ ( ( j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, ( ( k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
+ // Se è possibile riportarla dentro e il voxel in cui cade è pieno, la riporto nel suo voxel
+ // lungo la sua linea
+ if ( IntersLineBox( ptSolZMapFrame, vtNullSpace, ptVoxMin, ptVoxMax, dParInt1, dParInt2)) {
+
+ triContainer.resize( 0) ;
+
+ double dPar = abs( dParInt1) < abs( dParInt2) ? dParInt1 + ( dParInt2 - dParInt1) / 100 :
+ dParInt2 + ( dParInt1 - dParInt2) / 100 ;
+
+ Point3d ptNewSol = ptSolZMapFrame + dPar * vtNullSpace ;
+
+ ptSol = ptNewSol ;
+
+ // Costruisco triangoli di prova
+ for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) {
+ int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ;
+ // Il triangolo è pronto
+ Triangle3d CurrentTriangle ;
+ CurrentTriangle.Set( ptSol, CompoVert[nCompCount - 1][nj].ptInt, CompoVert[nCompCount - 1][ni].ptInt) ;
+ CurrentTriangle.Validate( true) ;
+ // Aggiungo triangolo al vettore temporaneo
+ triContainer.emplace_back( CurrentTriangle) ;
+ }
+ }
+
+ // Se non è possibile riportarla dentro e il voxel in
+ // cui cade è pieno passo alla routine standard
+ else {
+ int nAdjVoxI, nAdjVoxJ, nAdjVoxK ;
+ if ( GetPointVoxel( ptSolZMapFrame, nAdjVoxI, nAdjVoxJ, nAdjVoxK)) {
+ // Classificazione del voxel adiacente
+ int nAdjIndex = CalcIndex( nAdjVoxI, nAdjVoxJ, nAdjVoxK) ;
+ // Se il voxel è pieno
+ if ( EdgeTable[nAdjIndex] != 0)
+ bDangerInversion = true ;
+ }
+ }
+ }
+ }
+ // Caso in cui il numero di coppie di normali con prodotto
+ // scalare negativo non è 3
+ else {
+
+ Point3d ptSolZMapFrame = ptSol ;
+
+ if ( ! IsPointInsideVoxelApprox( i, j, k, ptSolZMapFrame)) {
+
+ Vector3d vtNullSpace( dMatrixV( 0, 2), dMatrixV( 1, 2), dMatrixV( 2, 2)) ;
+
+ double dParInt1, dParInt2 ;
+ Point3d ptVoxMin( ( i * N_DEXVOXRATIO + 0.5) * m_dStep,
+ ( j * N_DEXVOXRATIO + 0.5) * m_dStep, ( k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
+ Point3d ptVoxMax( ( ( i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
+ ( ( j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep, ( ( k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
+
+ if ( IntersLineBox( ptSolZMapFrame, vtNullSpace, ptVoxMin, ptVoxMax, dParInt1, dParInt2)) {
+
+ triContainer.resize( 0) ;
+
+ double dPar = abs( dParInt1) < abs( dParInt2) ? dParInt1 + ( dParInt2 - dParInt1) / 100:
+ dParInt2 + ( dParInt1 - dParInt2) / 100 ;
+
+ Point3d ptNewSol = ptSolZMapFrame + dPar * vtNullSpace ;
+
+ ptSol = ptNewSol ;
+
+ // Costruisco triangoli di prova
+ for ( int ni = 0 ; ni < nVertComp[nCompCount - 1] ; ++ ni) {
+ int nj = ( ni + 1 < nVertComp[nCompCount - 1]) ? ni + 1 : 0 ;
+ // Il triangolo è pronto
+ Triangle3d CurrentTriangle ;
+ CurrentTriangle.Set( ptSol, CompoVert[nCompCount - 1][nj].ptInt, CompoVert[nCompCount - 1][ni].ptInt) ;
+ CurrentTriangle.Validate( true) ;
+ // Aggiungo triangolo al vettore temporaneo
+ triContainer.emplace_back( CurrentTriangle) ;
+ }
+ }
+
+ else {
+ int nCouple = 0 ;
+ int nCoupleIndex[4] ;
+
+ // Valuto il numero di coppie di vettori
+ // quasi coincidenti e per ogni coppia salvo gli
+ // indici dei vettori
+ for ( int nNI = 0 ; nNI < 3 ; ++ nNI) {
+ for ( int nNJ = nNI + 1 ; nNJ < 4 ; ++ nNJ) {
+ if ( AreSameVectorApprox( CompoVert[nCompCount - 1][nNI].vtNorm,
+ CompoVert[nCompCount - 1][nNJ].vtNorm)) {
+ ++ nCouple ;
+ if ( nCouple == 1) {
+ nCoupleIndex[0] = nNI ;
+ nCoupleIndex[1] = nNJ ;
+ }
+ else if ( nCouple == 2) {
+ nCoupleIndex[2] = nNI ;
+ nCoupleIndex[3] = nNJ ;
+ }
+ }
+ }
+ }
+
+ // caso due coppie
+ if ( nCouple == 2) {
+ // vedo se c'è un triangolo con normale invertita rispetto a quelle
+ // si entrambi i vertici, se esiste si passerà a std MC
+ for ( int ni = 0 ; ni < 4 ; ++ ni) {
+ int nj = ( ni == 3 ? 0 : ni + 1) ;
+ if ( triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm < - 0.95 &&
+ triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm < - 0.95) {
+ bDangerInversion = true ;
+ break ;
+ }
+ }
+ }
+ // caso una coppia
+ else if ( nCouple == 1) {
+ // cerco gli indici dei vettori non appartenenti alla coppia
+ for ( int ni = 0 ; ni < 4 ; ++ ni) {
+ if ( ni != nCoupleIndex[0] && ni != nCoupleIndex[1]) {
+ nCoupleIndex[2] = ni ;
+ break ;
+ }
+ }
+ for ( int ni = 0 ; ni < 4 ; ++ ni) {
+ if ( ni != nCoupleIndex[0] && ni != nCoupleIndex[1] && ni != nCoupleIndex[2]) {
+ nCoupleIndex[3] = ni ;
+ break ;
+ }
+ }
+ // Media dei vettori coppia
+ Vector3d vtAv01 = 0.5 * ( CompoVert[nCompCount - 1][nCoupleIndex[0]].vtNorm +
+ CompoVert[nCompCount - 1][nCoupleIndex[1]].vtNorm) ;
+ // vettore nello spazio genenrato dai due non appartenenti alla coppia
+ Vector3d vtAv23 = 0.5 * ( CompoVert[nCompCount - 1][nCoupleIndex[2]].vtNorm +
+ CompoVert[nCompCount - 1][nCoupleIndex[3]].vtNorm) ;
+
+ vtAv01.Normalize() ;
+ vtAv23.Normalize() ;
+ double dDAvAV = vtAv01 * vtAv23 ;
+ // se angolo grande si esegue std MC
+ if ( abs( vtAv01 * vtAv23) < EPS_SMALL) {
+ for ( int ni = 0 ; ni < 4 ; ++ ni) {
+ int nj = ni == 3 ? 0 : ni + 1 ;
+ if ( triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm < - 0.95 &&
+ triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm < - 0.95) {
+ bDangerInversion = true ;
+ break ;
+ }
+ }
+ }
+ else {
+
+ double dD23 = CompoVert[nCompCount - 1][nCoupleIndex[2]].vtNorm *
+ CompoVert[nCompCount - 1][nCoupleIndex[3]].vtNorm ;
+ if ( dD23 > 0.7 && dDAvAV < 0.7) {
+
+ for ( int ni = 0 ; ni < 4 ; ++ ni) {
+ int nj = ni == 3 ? 0 : ni + 1 ;
+ if ( triContainer[ni].GetN() * CompoVert[nCompCount - 1][ni].vtNorm < - 0.9 &&
+ triContainer[ni].GetN() * CompoVert[nCompCount - 1][nj].vtNorm < - 0.9) {
+ bDangerInversion = true ;
+ break ;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
// Controllo sulle normali, se risultano in tutti i punti
// approssimativamente uguali passiamo alla routine standard
int nContSize = int( triContainer.size()) ;
@@ -2934,20 +3153,55 @@ VolZmap::FlipEdgesII( TriHolder& TriHold, bool bGraph) const
// Si deve operare la modifica dei triangoli
if ( SharedIndex.size() > 2) {
- // verifico che i due lati adiacenti siano controversi
+ // Verifico che i due lati adiacenti siano controversi
int nProd = ( SharedIndex[2] - SharedIndex[0]) * ( SharedIndex[3] - SharedIndex[1]) ;
if ( nProd != 1 && nProd != - 2 && nProd != 4 && nProd != 0) {
-
- TriHold[n1].vCompoTria[nCompo1][nTri1].SetP( SharedIndex[0],
+ // Assegno l'array dei punti di contorno
+ Point3d vPnt[4] ;
+ vPnt[0] = TriHold[n1].vCompoTria[nCompo1][nTri1].GetP( SharedIndex[0]) ;
+ vPnt[1] = TriHold[n1].ptCompoVert[nCompo1] ;
+ vPnt[2] = TriHold[n1].vCompoTria[nCompo1][nTri1].GetP( SharedIndex[2]) ;
+ vPnt[3] = TriHold[n2].ptCompoVert[nCompo2] ;
+ // Valuto se i triangoli giacciono su un piano
+ PolygonPlane Polygon ;
+ for ( int i = 0 ; i < 4 ; ++ i)
+ Polygon.AddPoint( vPnt[i]) ;
+ Plane3d plPlane ;
+ bool bOnPlane = Polygon.GetPlane( plPlane) ;
+ for ( int i = 0 ; i < 4 && bOnPlane ; ++ i)
+ bOnPlane = PointInPlaneApprox( vPnt[i], plPlane) ;
+ // Se sono su un piano controllo se avviene inversione
+ bool bInv = false ;
+ if ( bOnPlane) {
+ Triangle3d trT1 = TriHold[n1].vCompoTria[nCompo1][nTri1] ;
+ Triangle3d trT2 = TriHold[n2].vCompoTria[nCompo2][nTri2] ;
+ int nVert1, nVert2 ;
+ // Determino gli indici dei punti sharp-feature
+ for ( int nP = 0 ; nP < 3 ; ++ nP) {
+ if ( nP != SharedIndex[0] && nP != SharedIndex[2])
+ nVert1 = nP ;
+ if ( nP != SharedIndex[1] && nP != SharedIndex[3])
+ nVert2 = nP ;
+ }
+ trT1.SetP( SharedIndex[0], trT2.GetP( nVert2)) ;
+ trT2.SetP( SharedIndex[3], trT1.GetP( nVert1)) ;
+ trT1.Validate( true) ;
+ trT2.Validate( true) ;
+ bInv = ( trT1.GetN() * trT2.GetN() < 0) ;
+ }
+ // Se non vi è inversione eseguo il flipping
+ if ( ! bInv) {
+ TriHold[n1].vCompoTria[nCompo1][nTri1].SetP( SharedIndex[0],
TriHold[n2].ptCompoVert[nCompo2]) ;
- TriHold[n2].vCompoTria[nCompo2][nTri2].SetP( SharedIndex[3],
+ TriHold[n2].vCompoTria[nCompo2][nTri2].SetP( SharedIndex[3],
TriHold[n1].ptCompoVert[nCompo1]) ;
- TriHold[n1].vCompoTria[nCompo1][nTri1].Validate( true) ;
- TriHold[n2].vCompoTria[nCompo2][nTri2].Validate( true) ;
+ TriHold[n1].vCompoTria[nCompo1][nTri1].Validate( true) ;
+ TriHold[n2].vCompoTria[nCompo2][nTri2].Validate( true) ;
- bModified = true ;
- break ;
+ bModified = true ;
+ break ;
+ }
}
}
}
@@ -2963,108 +3217,6 @@ VolZmap::FlipEdgesII( TriHolder& TriHold, bool bGraph) const
return true ;
}
-//////// SPERIMENTALE ///////////////////
-//bool
-//VolZmap::FlipEdgesII( TriHolder& TriHold) const
-//{
-// // Numero di voxel in cui si presentano sharp feature
-// int nVoxelNum = int( TriHold.size()) ;
-//
-// // Ciclo su tali voxel
-// for ( int n1 = 0 ; n1 < nVoxelNum ; ++ n1) {
-//
-// for ( int n2 = n1 ; n2 < nVoxelNum ; ++ n2) {
-//
-// // Se i voxel sono adiacenti proseguo
-// if ( abs( TriHold[n2].i - TriHold[n1].i) == 1 ||
-// abs( TriHold[n2].j - TriHold[n1].j) == 1 ||
-// abs( TriHold[n2].k - TriHold[n1].k) == 1) {
-//
-// // Numero delle componenti connesse nei due voxel
-// int nNumCompo1 = int( TriHold[n1].ptCompoVert.size()) ;
-// int nNumCompo2 = int( TriHold[n2].ptCompoVert.size()) ;
-//
-// int nCompo1 = 0 ;
-//
-// // Ciclo sulle componenti
-// for ( ; nCompo1 < nNumCompo1 ; ++ nCompo1) {
-//
-// int nCompo2 = ( n1 == n2 ? nCompo1 + 1 : 0) ;
-//
-// for ( ; nCompo2 < nNumCompo2 ; ++ nCompo2) {
-//
-// // Numero di triangoli per le componenti connesse
-// int nTriNum1 = int( TriHold[n1].vCompoTria[nCompo1].size()) ;
-// int nTriNum2 = int( TriHold[n2].vCompoTria[nCompo2].size()) ;
-//
-// for ( int nTri1 = 0 ; nTri1 < nTriNum1 ; ++ nTri1) {
-//
-// bool bModified = false ;
-//
-// for ( int nTri2 = 0 ; nTri2 < nTriNum2 ; ++ nTri2) {
-//
-// INTVECTOR SharedIndex ;
-//
-// for ( int nVert1 = 0 ; nVert1 < 3 ; ++ nVert1) {
-//
-// for ( int nVert2 = 0 ; nVert2 < 3 ; ++ nVert2) {
-//
-// Point3d ptP1 = TriHold[n1].vCompoTria[nCompo1][nTri1].GetP( nVert1) ;
-// Point3d ptP2 = TriHold[n2].vCompoTria[nCompo2][nTri2].GetP( nVert2) ;
-//
-// if ( AreSamePointEpsilon( ptP1, ptP2, EPS_ZERO)) {
-//
-// Point3d ptVert1 = TriHold[n1].ptCompoVert[nCompo1] ;
-// Point3d ptVert2 = TriHold[n2].ptCompoVert[nCompo2] ;
-//
-// if ( ! ( AreSamePointEpsilon( ptP1, ptVert1, EPS_ZERO) ||
-// AreSamePointEpsilon( ptP2, ptVert2, EPS_ZERO))) {
-//
-// SharedIndex.emplace_back( nVert1) ;
-// SharedIndex.emplace_back( nVert2) ;
-// }
-// }
-//
-// if ( SharedIndex.size() > 2)
-// break ;
-// }
-//
-// if ( SharedIndex.size() > 2)
-// break ;
-// }
-//
-// // Si deve operare la modifica dei triangoli
-// if ( SharedIndex.size() > 2) {
-//
-// // verifico che i due lati adiacenti siano controversi
-// int nProd = ( SharedIndex[2] - SharedIndex[0]) * ( SharedIndex[3] - SharedIndex[1]) ;
-// if ( nProd != 1 && nProd != - 2 && nProd != 4 && nProd != 0) {
-//
-// TriHold[n1].vCompoTria[nCompo1][nTri1].SetP( SharedIndex[0],
-// TriHold[n2].ptCompoVert[nCompo2]) ;
-// TriHold[n2].vCompoTria[nCompo2][nTri2].SetP( SharedIndex[3],
-// TriHold[n1].ptCompoVert[nCompo1]) ;
-//
-// TriHold[n1].vCompoTria[nCompo1][nTri1].Validate( true) ;
-// TriHold[n2].vCompoTria[nCompo2][nTri2].Validate( true) ;
-//
-// bModified = true ;
-// break ;
-// }
-// }
-// }
-//
-// if ( bModified)
-// break ;
-// }
-// }
-// }
-// }
-// }
-// }
-//
-// return true ;
-//}
//----------------------------------------------------------------------------
bool
@@ -3154,21 +3306,55 @@ VolZmap::FlipEdgesBB( TriaMatrix& InterTria) const
// Si deve operare la modifica dei triangoli
if ( SharedIndex.size() > 2) {
-
- // verifico che i due lai adiacenti siano controversi
+ // Verifico che i due lati adiacenti siano controversi
int nProd = ( SharedIndex[2] - SharedIndex[0]) * ( SharedIndex[3] - SharedIndex[1]) ;
if ( nProd != 1 && nProd != - 2 && nProd != 4 && nProd != 0) {
+ // Assegno l'array dei punti di contorno
+ Point3d vPnt[4] ;
+ vPnt[0] = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( SharedIndex[0]) ;
+ vPnt[1] = InterTria[tFB][tVFB].ptCompoVert[tCmpF] ;
+ vPnt[2] = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( SharedIndex[2]) ;
+ vPnt[3] = InterTria[tLB][tVLB].ptCompoVert[tCmpL] ;
+ // Valuto se i triangoli giacciono su un piano
+ PolygonPlane Polygon ;
+ for ( int i = 0 ; i < 4 ; ++ i)
+ Polygon.AddPoint( vPnt[i]) ;
+ Plane3d plPlane ;
+ bool bOnPlane = Polygon.GetPlane( plPlane) ;
+ for ( int i = 0 ; i < 4 && bOnPlane ; ++ i)
+ bOnPlane = PointInPlaneApprox( vPnt[i], plPlane) ;
+ // Se sono su un piano controllo se avviene inversione
+ bool bInv = false ;
+ if ( bOnPlane) {
+ Triangle3d trTF = InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB] ;
+ Triangle3d trTL = InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB] ;
+ int nVertF, nVertL ;
+ // Determino gli indici dei punti sharp-feature
+ for ( int nP = 0 ; nP < 3 ; ++ nP) {
+ if ( nP != SharedIndex[0] && nP != SharedIndex[2])
+ nVertF = nP ;
+ if ( nP != SharedIndex[1] && nP != SharedIndex[3])
+ nVertL = nP ;
+ }
+ trTF.SetP( SharedIndex[0], trTL.GetP( nVertL)) ;
+ trTF.Validate( true) ;
+ trTL.SetP( SharedIndex[3], trTF.GetP( nVertF)) ;
+ trTL.Validate( true) ;
+ bInv = ( trTF.GetN() * trTL.GetN() < 0) ;
+ }
+ // Se non vi è inversione eseguo il flipping
+ if ( ! bInv) {
+ InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetP( SharedIndex[0],
+ InterTria[tLB][tVLB].ptCompoVert[tCmpL]) ;
+ InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetP( SharedIndex[3],
+ InterTria[tFB][tVFB].ptCompoVert[tCmpF]) ;
- InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetP( SharedIndex[0],
- InterTria[tLB][tVLB].ptCompoVert[tCmpL]) ;
- InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetP( SharedIndex[3],
- InterTria[tFB][tVFB].ptCompoVert[tCmpF]) ;
+ InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].Validate( true) ;
+ InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].Validate( true) ;
- InterTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].Validate( true) ;
- InterTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].Validate( true) ;
-
- bModified = true ;
- break ;
+ bModified = true ;
+ break ;
+ }
}
}
}
diff --git a/VolTriZmapVolume.cpp b/VolTriZmapVolume.cpp
index b1ad2c3..4a8cf75 100644
--- a/VolTriZmapVolume.cpp
+++ b/VolTriZmapVolume.cpp
@@ -30,8 +30,10 @@ bool
VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ,
double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax)
{
+ const double dTol = EPS_ZERO ;
+
// Controllo che dMin e dMax non siano quasi coincidenti
- if ( abs( dMax - dMin) < EPS_SMALL)
+ if ( abs( dMax - dMin) < dTol)
return true ;
// Controllo che il numero di griglia sia entro i limiti
@@ -73,13 +75,13 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ
while ( i < m_Values[nGrid][nPos].size()) {
// Casi:
// Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione
- if ( m_Values[nGrid][nPos][i].dMin > dMax - EPS_SMALL) {
+ if ( m_Values[nGrid][nPos][i].dMin > dMax - dTol) {
;
}
// Intersezione
- else if ( m_Values[nGrid][nPos][i].dMax > dMax + EPS_SMALL) {
+ else if ( m_Values[nGrid][nPos][i].dMax > dMax + dTol) {
// L'intervallo corrente viene limitato a sinistra
- if ( m_Values[nGrid][nPos][i].dMin > dMin - EPS_SMALL) {
+ if ( m_Values[nGrid][nPos][i].dMin > dMin - dTol) {
bModified = true ;
// Aggiornamento dati del tratto di dexel
m_Values[nGrid][nPos][i].dMin = dMax ;
@@ -131,7 +133,7 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ
else {
// L'intervallo corrente viene eliminato
- if ( m_Values[nGrid][nPos][i].dMin > dMin - EPS_SMALL) {
+ if ( m_Values[nGrid][nPos][i].dMin > dMin - dTol) {
bModified = true ;
// Sposto i tratti successivi a quello corrente indietro di una posizione
for ( unsigned int j = i ; j < m_Values[nGrid][nPos].size() - 1 ; ++ j) {
@@ -154,7 +156,7 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ
i = i - 1 ;
}
// L'intervallo corrente viene limitato a destra
- else if ( m_Values[nGrid][nPos][i].dMax > dMin + EPS_SMALL) {
+ else if ( m_Values[nGrid][nPos][i].dMax > dMin + dTol) {
bModified = true ;
m_Values[nGrid][nPos][i].dMax = dMin ;
m_Values[nGrid][nPos][i].vtMaxN = vtNmi ;
@@ -975,15 +977,14 @@ VolZmap::CylBall_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
bool
VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Verifica sull'interferenza utensile Zmap
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bTest = BoundingBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ) ;
if ( ! bTest)
return true ;
- //Parametri geometrici dell'utensile
+ // Parametri geometrici dell'utensile
double dStemHeigth = m_dHeight - m_dTipHeight ;
double dSqRad = m_dRadius * m_dRadius ;
double dSafeRad = m_dRadius - EPS_SMALL ;
@@ -1005,12 +1006,9 @@ VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& p
Vector3d vtV1 = vtMove ; vtV1.Normalize() ; // se |vtMove| < EPS è un buco con dz = 0
Vector3d vtV2 = vtV1 ; vtV2.Rotate( Z_AX, 90) ;
-
-
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-
double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ;
Point3d ptC( dX, dY, 0) ; Vector3d vtC = ptC - ptSxy ;
@@ -1026,9 +1024,9 @@ VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& p
SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ, Z_AX, - Z_AX) ;
}
+
// Utensile sferico
else if ( m_nToolType == BALLMILL) {
-
if ( abs( dP2) < dSafeRad) {
@@ -1039,14 +1037,13 @@ VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& p
double dH = sqrt( dSafeSqRad - dP1 * dP1 - dP2 * dP2) ;
if ( vtToolDir.z > 0) {
-
Point3d ptInt( dX, dY, ptTStemS.z - dH) ;
Vector3d vtN = ptTStemS - ptInt ;
vtN.Normalize() ;
SubtractIntervals( nGrid, i, j, ptTStemS.z - dH, ptS.z, vtN, - Z_AX) ;
}
- else {
+ else {
Point3d ptInt( dX, dY, ptTStemS.z + dH) ;
Vector3d vtN = ptTStemS - ptInt ;
vtN.Normalize() ;
@@ -1054,40 +1051,39 @@ VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& p
}
}
}
+
else if ( dP1 < dLen) {
double dH = sqrt( dSafeSqRad - dP2 * dP2) ;
if ( vtToolDir.z > 0) {
-
Point3d ptInt( dX, dY, ptTStemS.z - dH) ;
Vector3d vtN = - ( ptInt - ptTStemS) + ( ptInt - ptTStemS) * vtV1 * vtV1 ;
vtN.Normalize() ;
SubtractIntervals( nGrid, i, j, ptTStemS.z - dH, ptS.z, vtN, - Z_AX) ;
}
- else {
+ else {
Point3d ptInt( dX, dY, ptTStemS.z + dH) ;
Vector3d vtN = - ( ptInt - ptTStemS) + ( ptInt - ptTStemS) * vtV1 * vtV1 ;
vtN.Normalize() ;
SubtractIntervals( nGrid, i, j, ptS.z, ptTStemS.z + dH, Z_AX, vtN) ;
}
}
- else {
+ else {
if ( ( dP1 - dLen) * ( dP1 - dLen) + dP2 * dP2 < dSafeSqRad) {
double dH = sqrt( dSafeSqRad - ( dP1 - dLen) * ( dP1 - dLen) - dP2 * dP2) ;
if ( vtToolDir.z > 0) {
-
Point3d ptInt( dX, dY, ptTStemE.z - dH) ;
Vector3d vtN = ptTStemE - ptInt ;
vtN.Normalize() ;
SubtractIntervals( nGrid, i, j, ptTStemE.z - dH, ptS.z, vtN, - Z_AX) ;
}
- else {
+ else {
Point3d ptInt( dX, dY, ptTStemE.z + dH) ;
Vector3d vtN = ptTStemE - ptInt ;
vtN.Normalize() ;
@@ -1106,9 +1102,8 @@ VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& p
bool
VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Verifica sull'interferenza utensile Zmap
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bTest = BoundingBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ) ;
if ( ! bTest)
@@ -1174,7 +1169,6 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -1188,7 +1182,6 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
if ( ( dX1 > 0 && dX1 < dLenXY && abs( dX2) < dSafeRadius) ||
( dX1 - dLenXY) * ( dX1 - dLenXY) + dX2 * dX2 < dSafeSqRad ||
dX1 * dX1 + dX2 * dX2 < dSafeSqRad) {
-
double dX1_0 = sqrt( dSqRad - dX2 * dX2) ;
@@ -1196,12 +1189,11 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
// Massimo
if ( ( dX1 - dLenXY) * ( dX1 - dLenXY) + dX2 * dX2 < dSqRad) {
-
vtNmax = - Z_AX ;
dMax = dZMaxF ;
}
- else {
+ else {
//vtNmax = - ( dX2 / dX1_0) * vtMove ^ vtV1 - vtMove ^ vtV2 ;
dMax = dZMaxI + dDeltaZ * ( dX1 + dX1_0) / dLenXY ;
@@ -1214,12 +1206,11 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
}
// Minimo
if ( dX1 * dX1 + dX2 * dX2 < dSqRad) {
-
vtNmin = Z_AX ;
dMin = dZMinI ;
}
- else {
+ else {
//vtNmin = - ( dX2 / dX1_0) * vtMove ^ vtV1 + vtMove ^ vtV2 ;
dMin = dZMinI + dDeltaZ * ( dX1 - dX1_0) / dLenXY ;
@@ -1249,9 +1240,8 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
bool
VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Verifica sull'interferenza utensile Zmap
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bTest = BoundingBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ) ;
if ( ! bTest)
@@ -1313,8 +1303,8 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, - Z_AX) ;
}
- else {
+ else {
double dMin = dZMin ;
double dMax = dZMax - m_dTipHeight * ( dr - dMinRad) / dDeltaRad ;
@@ -1330,6 +1320,7 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d
}
}
}
+
// Coda di rondine
else {
@@ -1346,16 +1337,15 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d
double dSqDist = vtC.SqLenXY() ;
if ( dSqDist < dSqMinRad) {
-
SubtractIntervals( nGrid, i, j, dZMin, dZMax, Z_AX, - Z_AX) ;
}
+
else if ( dSqDist < dSqMaxRad) {
double dr = sqrt( dSqDist) ;
double dl = dr * dMaxRad / dL ;
if ( vtToolDir.z > 0) {
-
double dMin = dZMin ;
double dMax = dZMax - dStemHeigth - m_dTipHeight * ( dr - dMinRad) / dDeltaRad ;
@@ -1367,8 +1357,8 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d
SubtractIntervals( nGrid, i, j, dMin, dMax, Z_AX, vtNmax) ;
}
- else {
+ else {
double dMin = dZMin + dStemHeigth + m_dTipHeight * ( dr - dMinRad) / dDeltaRad ;
double dMax = dZMax ;
@@ -1391,9 +1381,8 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d
bool
VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Verifica sull'interferenza utensile Zmap
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bTest = BoundingBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ) ;
if ( ! bTest)
@@ -1412,7 +1401,6 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
double dSafeSqMaxRad = dSafeMaxRad * dSafeMaxRad ;
double dSafeSqMinRad = dSafeMinRad * dSafeMinRad ;
-
Point3d ptSxy( ptS.x, ptS.y, 0) ;
Point3d ptExy( ptE.x, ptE.y, 0) ;
@@ -1431,12 +1419,10 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
// Lunghezza cono
double dL = m_dTipHeight * dMaxRad / dDeltaRad ;
-
-
// Punta a trapano
if ( m_dTipRadius < m_dRadius) {
- double dMin, dMax ;
+ double dMin, dMax ;
Vector3d vtV = vtToolDir ;
@@ -1460,20 +1446,20 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
double dSqLenS = vtCS.SqLenXY() ;
double dSqLenE = vtCE.SqLenXY() ;
- if ( dSqLenS < dSafeSqMaxRad || dSqLenE < dSafeSqMaxRad ||
- ( abs( dP2) < dSafeMaxRad && dP1 >= 0 && dP1 <= dLen)) {
+ if ( dSqLenS < dSafeSqMaxRad || dSqLenE < dSafeSqMaxRad ||
+ ( abs( dP2) < dSafeMaxRad && dP1 >= 0 && dP1 <= dLen)) {
- if ( dSqLenS < dSqMinRad || dSqLenE < dSqMinRad ||
- ( abs( dP2) < dMinRad && dP1 >= 0 && dP1 <= dLen)) {
+ if ( dSqLenS < dSqMinRad || dSqLenE < dSqMinRad ||
+ ( abs( dP2) < dMinRad && dP1 >= 0 && dP1 <= dLen)) {
dMin = min( dBaseZ, dTipZ) ;
dMax = max( dBaseZ, dTipZ) ;
SubtractIntervals( nGrid, i, j, dMin, dMax, Z_AX, - Z_AX) ;
}
- else {
- Vector3d vtNmin, vtNmax ;
+ else {
+ Vector3d vtNmin, vtNmax ;
if ( dP1 < 0) {
@@ -1482,28 +1468,19 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
dMin = min( dBaseZ, dTipZ + ( dStemZ - dTipZ) * ( dr - dMinRad) / dDeltaRad) ;
dMax = max( dBaseZ, dTipZ + ( dStemZ - dTipZ) * ( dr - dMinRad) / dDeltaRad) ;
-
-
if ( vtToolDir.z > 0) {
-
Point3d ptInt( dX, dY, dMin) ;
-
Vector3d vtU = ( ptInt - ptVS) - ( ptInt - ptVS) * vtV * vtV ;
-
vtU.Normalize() ;
-
vtNmin = dDeltaRad * vtV - m_dTipHeight * vtU ;
vtNmin.Normalize() ;
vtNmax = - Z_AX ;
}
+
else {
-
Point3d ptInt( dX, dY, dMax) ;
-
Vector3d vtU = ( ptInt - ptVS) - ( ptInt - ptVS) * vtV * vtV ;
-
vtU.Normalize() ;
-
vtNmin = Z_AX ;
vtNmax = dDeltaRad * vtV - m_dTipHeight * vtU ;
vtNmax.Normalize() ;
@@ -1511,75 +1488,55 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
+
else if ( dP1 <= dLen) {
-
double dr = abs( dP2) ;
-
dMin = min( dBaseZ, dTipZ + ( dStemZ - dTipZ) * ( dr - dMinRad) / dDeltaRad) ;
dMax = max( dBaseZ, dTipZ + ( dStemZ - dTipZ) * ( dr - dMinRad) / dDeltaRad) ;
-
-
Point3d ptVtemp = ptVS + vtV1 * dP1 ;
if ( vtToolDir.z > 0) {
-
Point3d ptInt( dX, dY, dMin) ;
-
Vector3d vtU = ( ptInt - ptVtemp) - ( ptInt - ptVtemp) * vtV * vtV ;
-
vtU.Normalize() ;
-
vtNmin = dDeltaRad * vtV - m_dTipHeight * vtU ;
vtNmin.Normalize() ;
vtNmax = - Z_AX ;
}
+
else {
-
Point3d ptInt( dX, dY, dMax) ;
-
Vector3d vtU = ( ptInt - ptVtemp) - ( ptInt - ptVtemp) * vtV * vtV ;
-
vtU.Normalize() ;
-
vtNmin = Z_AX ;
-
vtNmax = dDeltaRad * vtV - m_dTipHeight * vtU ;
vtNmax.Normalize() ;
}
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
+
else {
double dr = sqrt( dSqLenE) ;
dMin = min( dBaseZ, dTipZ + ( dStemZ - dTipZ) * ( dr - dMinRad) / dDeltaRad) ;
dMax = max( dBaseZ, dTipZ + ( dStemZ - dTipZ) * ( dr - dMinRad) / dDeltaRad) ;
-
if ( vtToolDir.z > 0) {
-
Point3d ptInt( dX, dY, dMin) ;
-
Vector3d vtU = ( ptInt - ptVE) - ( ptInt - ptVE) * vtV * vtV ;
-
vtU.Normalize() ;
-
vtNmin = dDeltaRad * vtV - m_dTipHeight * vtU ;
vtNmin.Normalize() ;
vtNmax = -Z_AX ;
-
}
+
else {
-
Point3d ptInt( dX, dY, dMax) ;
-
Vector3d vtU = ( ptInt - ptVE) - ( ptInt - ptVE) * vtV * vtV ;
-
vtU.Normalize() ;
-
vtNmin = Z_AX ;
-
vtNmax = dDeltaRad * vtV - m_dTipHeight * vtU ;
vtNmax.Normalize() ;
}
@@ -1591,10 +1548,10 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
}
}
}
+
// Coda di rondine
else {
-
- double dMin, dMax ;
+ double dMin, dMax ;
Vector3d vtV = - vtToolDir ;
@@ -1604,7 +1561,6 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -1619,129 +1575,93 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
double dSqLenS = vtCS.SqLenXY() ;
double dSqLenE = vtCE.SqLenXY() ;
- if ( dSqLenS < dSqMaxRad || dSqLenE < dSqMaxRad ||
- ( abs( dP2) < dMaxRad && dP1 >= 0 && dP1 <= dLen)) {
+ if ( dSqLenS < dSqMaxRad || dSqLenE < dSqMaxRad ||
+ ( abs( dP2) < dMaxRad && dP1 >= 0 && dP1 <= dLen)) {
- if ( dSqLenS < dSafeSqMinRad || dSqLenE < dSafeSqMinRad ||
- ( abs( dP2) < dSafeMinRad && dP1 >= 0 && dP1 <= dLen)) {
-
+ if ( dSqLenS < dSafeSqMinRad || dSqLenE < dSafeSqMinRad ||
+ ( abs( dP2) < dSafeMinRad && dP1 >= 0 && dP1 <= dLen)) {
dMin = min( dBaseZ, dTipZ) ;
dMax = max( dBaseZ, dTipZ) ;
-
SubtractIntervals( nGrid, i, j, dMin, dMax, Z_AX, - Z_AX) ;
}
- else {
- Vector3d vtNmin, vtNmax ;
+ else {
+ Vector3d vtNmin, vtNmax ;
if ( dP1 < 0) {
-
double dr = sqrt( dSqLenS) ;
-
dMin = min( dTipZ, dStemZ + ( dTipZ - dStemZ) * ( dr - dMinRad) / dDeltaRad) ;
dMax = max( dTipZ, dStemZ + ( dTipZ - dStemZ) * ( dr - dMinRad) / dDeltaRad) ;
if ( vtToolDir.z > 0) {
-
Point3d ptInt( dX, dY, dMax) ;
-
Vector3d vtU = ( ptInt - ptVS) - ( ptInt - ptVS) * vtV * vtV ;
vtU.Normalize() ;
-
vtNmin = Z_AX ;
-
vtNmax = dDeltaRad * vtV - m_dTipHeight * vtU ;
-
vtNmax.Normalize() ;
-
}
+
else {
-
Point3d ptInt( dX, dY, dMin) ;
-
Vector3d vtU = ( ptInt - ptVS) - ( ptInt - ptVS) * vtV * vtV ;
vtU.Normalize() ;
-
vtNmax = -Z_AX ;
-
vtNmin = dDeltaRad * vtV - m_dTipHeight * vtU ;
-
vtNmin.Normalize() ;
}
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
+
else if ( dP1 <= dLen) {
-
double dr = abs( dP2) ;
-
Point3d ptVtemp = ptVS + vtV1 * dP1 ;
-
dMin = min( dTipZ, dStemZ + ( dTipZ - dStemZ) * ( dr - dMinRad) / dDeltaRad) ;
dMax = max( dTipZ, dStemZ + ( dTipZ - dStemZ) * ( dr - dMinRad) / dDeltaRad) ;
if ( vtToolDir.z > 0) {
-
Point3d ptInt( dX, dY, dMax) ;
-
Vector3d vtU = ( ptInt - ptVtemp) - ( ptInt - ptVtemp) * vtV * vtV ;
vtU.Normalize() ;
-
vtNmin = Z_AX ;
-
vtNmax = dDeltaRad * vtV - m_dTipHeight * vtU ;
-
vtNmax.Normalize() ;
}
+
else {
-
Point3d ptInt( dX, dY, dMin) ;
-
Vector3d vtU = ( ptInt - ptVtemp) - ( ptInt - ptVtemp) * vtV * vtV ;
vtU.Normalize() ;
-
vtNmax = -Z_AX ;
-
vtNmin = dDeltaRad * vtV - m_dTipHeight * vtU ;
-
vtNmin.Normalize() ;
}
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
+
else {
-
double dr = sqrt( dSqLenE) ;
-
dMin = min( dTipZ, dStemZ + ( dTipZ - dStemZ) * ( dr - dMinRad) / dDeltaRad) ;
dMax = max( dTipZ, dStemZ + ( dTipZ - dStemZ) * ( dr - dMinRad) / dDeltaRad) ;
if ( vtToolDir.z > 0) {
-
Point3d ptInt( dX, dY, dMax) ;
-
Vector3d vtU = ( ptInt - ptVE) - ( ptInt - ptVE) * vtV * vtV ;
vtU.Normalize() ;
-
vtNmin = Z_AX ;
-
vtNmax = dDeltaRad * vtV - m_dTipHeight * vtU ;
-
vtNmax.Normalize() ;
-
}
+
else {
-
Point3d ptInt( dX, dY, dMin) ;
-
Vector3d vtU = ( ptInt - ptVE) - ( ptInt - ptVE) * vtV * vtV ;
vtU.Normalize() ;
-
vtNmax = -Z_AX ;
-
vtNmin = dDeltaRad * vtV - m_dTipHeight * vtU ;
-
vtNmin.Normalize() ;
}
@@ -1757,24 +1677,21 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
//----------------------------------------------------------------------------
bool
-VolZmap::Conus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
+VolZmap::Conus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
{
double dStemH = m_dHeight - m_dTipHeight ;
CompCyl_ZMilling( nGrid, ptS, ptE, vtToolDir, dStemH, m_dRadius) ;
if ( m_dTipRadius < m_dRadius) {
-
Point3d ptSC = ptS - vtToolDir * dStemH ;
Point3d ptEC = ptE - vtToolDir * dStemH ;
-
CompConus_ZMilling( nGrid, ptSC, ptEC, vtToolDir, m_dTipHeight, m_dRadius, m_dTipRadius) ;
}
- else {
+ else {
Point3d ptSC = ptS - vtToolDir * m_dHeight ;
Point3d ptEC = ptE - vtToolDir * m_dHeight ;
-
CompConus_ZMilling( nGrid, ptSC, ptEC, - vtToolDir, m_dTipHeight, m_dTipRadius, m_dRadius) ;
}
@@ -1823,9 +1740,9 @@ VolZmap::Mrt_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& p
CompCyl_Milling( nGrid, ptSminus, ptEminus, vtAux, dLenY, m_dRCorner, false, false) ;
CompCyl_Milling( nGrid, ptSplus, ptEplus, vtAux, dLenY, m_dRCorner, false, false) ;
}
+
// se la punta è di tipo sfera
else {
-
// Cilindro
Point3d ptCylS = ptS - dLenZ * vtToolDir + 0.5 * dLenY * vtAux ;
Point3d ptCylE = ptEOnP - dLenZ * vtToolDir + 0.5 * dLenY * vtAux ;
@@ -1860,7 +1777,6 @@ VolZmap::Mrt_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
// Se la punta è di tipo bull-nose
if ( abs( m_dMrtChsWidth - 2 * m_dRCorner) > EPS_SMALL) {
-
// Parallelepipedo di punta
Point3d ptTipS = ptPlS - dLenZ * vtToolDir ;
Point3d ptTipE = ptPlE - dLenZ * vtToolDir ;
@@ -1868,20 +1784,16 @@ VolZmap::Mrt_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
dLenX = abs( m_dMrtChsWidth - 2 * m_dRCorner) ;
dLenZ = m_dRCorner ;
- //CompPar_ZMilling( nGrid, dLenX, dLenY, dLenZ, ptTipS, ptTipE, vtToolDir, vtAux) ;
-
// Cilindro ( il moto dei due cilindri si sovrappone, quindi è inutile
// eseguire due volte il conto
Point3d ptSminus = ptTipS - ( 0.5 * dLenX) * vtPlV + 0.5 * dLenY * vtAux ;
- /*Point3d ptEminus = ptTipE - ( 0.5 * dLenX) * vtPlV + 0.5 * dLenY * vtAux ;
- Point3d ptSplus = ptTipS + ( 0.5 * dLenX) * vtPlV + 0.5 * dLenY * vtAux ;*/
Point3d ptEplus = ptTipE + ( 0.5 * dLenX) * vtPlV + 0.5 * dLenY * vtAux ;
CompCyl_Milling( nGrid, ptSminus, ptEplus, vtAux, dLenY, m_dRCorner, false, false) ;
}
+
// se la punta è di tipo sfera
else {
-
// Cilindro
Point3d ptCylS = ptPlS - dLenZ * vtToolDir + 0.5 * dLenY * vtAux ;
Point3d ptCylE = ptPlE - dLenZ * vtToolDir + 0.5 * dLenY * vtAux ;
@@ -1935,6 +1847,7 @@ VolZmap::GenTool_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
if ( m_ToolArcLineApprox.GetCurveCount() == 0)
// Se l'utensile non è stato approssimato uso l'originale
pToolProfile = &m_ToolOutline ;
+
else
// altrimenti usi l'approssimazione
pToolProfile = &m_ToolArcLineApprox ;
@@ -1944,7 +1857,6 @@ VolZmap::GenTool_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
while ( pCurve != nullptr) {
double dHeight ;
-
int nCurveType = pCurve -> GetType() ;
// Caso segmento
@@ -1961,34 +1873,31 @@ VolZmap::GenTool_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
// Il componente è un cilindro
if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) {
-
double dRadius = ptStart.x ;
-
CompCyl_ZDrilling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius) ;
}
+
// Il componente è un cono con vettore equiverso a quello dell'utensile
else if ( ptStart.x > ptEnd.x) {
-
double dMaxRad = ptStart.x ;
double dMinRad = ptEnd.x ;
-
CompConus_ZDrilling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad) ;
}
+
// Il componente è un cono con vettore opposto a quello dell'utesile
else if ( ptStart.x < ptEnd.x) {
-
double dMaxRad = ptEnd.x ;
double dMinRad = ptStart.x ;
-
Point3d ptIn = ptI - vtToolDir * dHeight ;
Point3d ptFn = ptIn + vtMove ;
-
CompConus_ZDrilling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad) ;
}
}
+
else
dHeight = 0 ;
}
+
// Caso arco
else if ( nCurveType == CRV_ARC) {
@@ -2069,31 +1978,27 @@ VolZmap::GenTool_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
// Il componente è un cilindro
if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) {
-
double dRadius = ptStart.x ;
-
CompCyl_ZMilling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius) ;
}
+
// Il componente è un cono con vettore equiverso a quello dell'utensile
else if ( ptStart.x > ptEnd.x) {
-
double dMaxRad = ptStart.x ;
double dMinRad = ptEnd.x ;
-
CompConus_ZMilling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad) ;
}
+
// Il componente è un cono con vettore opposto a quello dell'utensile
else if ( ptStart.x < ptEnd.x) {
-
double dMaxRad = ptEnd.x ;
double dMinRad = ptStart.x ;
-
Point3d ptIn = ptI - vtToolDir * dHeight ;
Point3d ptFn = ptIn + vtMove ;
-
CompConus_ZMilling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad) ;
}
}
+
else
dHeight = 0 ;
}
@@ -2282,9 +2187,8 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d
if ( dLenXY < EPS_SMALL) {
- for( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
- for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-
+ for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
+ for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -2295,10 +2199,10 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d
double dP1 = vtC * vtV1 ;
double dP2 = vtC * vtV2 ;
- Vector3d vtNmin, vtNmax ;
+ Vector3d vtNmin, vtNmax ;
- if ( dP1 > EPS_SMALL && dP1 < dStemHeigth - EPS_SMALL &&
- dP2 > - m_dRadius + EPS_SMALL &&
+ if ( dP1 > EPS_SMALL && dP1 < dStemHeigth - EPS_SMALL &&
+ dP2 > - m_dRadius + EPS_SMALL &&
dP2 < m_dRadius - EPS_SMALL) {
dInfZ = ptI.z - sqrt( dSqRad - dP2 * dP2) ;
@@ -2340,8 +2244,8 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d
}
else {
- for( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
- for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
+ for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
+ for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
double dX = ( i + 0.5) * m_dStep ;
@@ -2354,65 +2258,57 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d
double dP2 = vtC * vtV2 ;
// Parte cilindrica
- if ( dP1 > EPS_SMALL && dP1 < dStemHeigth - EPS_SMALL) {
+ if ( dP1 > EPS_SMALL && dP1 < dStemHeigth - EPS_SMALL) {
- if ( dP2 > - m_dRadius && dP2 < dLenXY + m_dRadius) {
+ if ( dP2 > - m_dRadius && dP2 < dLenXY + m_dRadius) {
Vector3d vtNmin, vtNmax ;
// Massimi
if ( dP2 < - dSmall + EPS_SMALL) {
-
double dHsq = dSqRad - dP2 * dP2 ;
double dH = ( dHsq > 0 ? sqrt( dHsq) : 0) ;
dSupZ = dZI + dH ;
-
Point3d ptInt( dX, dY, dSupZ) ;
-
vtNmax = - ( ptInt - ptI - ( ptInt - ptI) * vtToolDir * vtToolDir) ;
vtNmax.Normalize() ;
}
+
else if ( dP2 < dLenXY - dSmall - EPS_SMALL) {
-
dSupZ = ( dDotUp - dX * vtP.x - dY * vtP.y) / vtP.z ;
-
Vector3d vtT = vtToolDir ^ vtMove ;
vtNmax = ( vtT.z < 0 ? vtT : - vtT) ;
vtNmax.Normalize() ;
}
+
else {
-
double dH = sqrt( dSqRad - ( dP2 - dLenXY) * ( dP2 - dLenXY)) ;
dSupZ = dZF + dH ;
-
Point3d ptInt( dX, dY, dSupZ) ;
-
vtNmax = - ( ptInt - ptF - ( ptInt - ptF) * vtToolDir * vtToolDir) ;
vtNmax.Normalize() ;
}
+
// Minimi
if ( dP2 < dSmall + EPS_SMALL) {
double dHsq = dSqRad - dP2 * dP2 ;
double dH = ( dHsq > 0 ? sqrt( dHsq) : 0) ;
dInfZ = dZI - dH ;
-
Point3d ptInt( dX, dY, dInfZ) ;
vtNmin = - ( ( ptInt - ptI) - ( ptInt - ptI) * vtToolDir * vtToolDir) ;
vtNmin.Normalize() ;
}
- else if ( dP2 < dLenXY + dSmall - EPS_SMALL) {
-
- dInfZ = ( dDotDw - dX * vtP.x - dY * vtP.y) / vtP.z ;
+ else if ( dP2 < dLenXY + dSmall - EPS_SMALL) {
+ dInfZ = ( dDotDw - dX * vtP.x - dY * vtP.y) / vtP.z ;
Vector3d vtT = vtToolDir ^ vtMove ;
vtNmin = ( vtT.z < 0 ? - vtT : vtT) ;
vtNmin.Normalize() ;
}
- else {
+ else {
double dH = sqrt( dSqRad - ( dP2 - dLenXY) * ( dP2 - dLenXY)) ;
dInfZ = dZF - dH ;
-
Point3d ptInt( dX, dY, dInfZ) ;
vtNmin = - ( ( ptInt - ptF) - ( ptInt - ptF) * vtToolDir * vtToolDir) ;
vtNmin.Normalize() ;
@@ -2421,12 +2317,13 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d
SubtractIntervals( nGrid, i, j, dInfZ, dSupZ, vtNmin, vtNmax) ;
}
}
+
// Se l'utensile è ball-end sottraggo la punta
if ( m_nToolType == BALLMILL) {
- if ( ( ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth) + dP2 * dP2 < dSqRad ||
- ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth) + ( dP2 - dLenXY) * ( dP2 - dLenXY) < dSqRad ||
- ( dP2 > 0 && dP2 < dLenXY && dP1 < m_dHeight)) && ( dP1 > dStemHeigth - 2 * EPS_SMALL)) {
+ if ( ( ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth) + dP2 * dP2 < dSqRad ||
+ ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth) + ( dP2 - dLenXY) * ( dP2 - dLenXY) < dSqRad ||
+ ( dP2 > 0 && dP2 < dLenXY && dP1 < m_dHeight)) && ( dP1 > dStemHeigth - 2 * EPS_SMALL)) {
double dSqRoot = sqrt( dSqRad - ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth)) ;
double dP2_0 = dCos * dSqRoot ;
@@ -2438,58 +2335,44 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d
// Massimo
if ( dP2 < - dP2_0) {
-
dMax = dZI + sqrt( dSqRad - ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth) - dP2 * dP2) ;
-
Point3d ptInt( dX, dY, dMax) ;
-
vtNmax = ptIStemT - ptInt ;
vtNmax.Normalize() ;
}
else if ( dP2 < dLenXY - dP2_0) {
dMax = dZI + dH0 + dDeltaZ * ( dP2 + dP2_0) / dLenXY ;
-
Point3d ptInt( dX, dY, dMax) ;
-
vtNmax = - ( ptInt - ptIStemT) + ( ptInt - ptIStemT) * vtMove * vtMove ;
vtNmax.Normalize() ;
}
else {
dMax = dZF + sqrt( dSqRad - ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth) - ( dP2 - dLenXY) * ( dP2 - dLenXY)) ;
-
Point3d ptInt( dX, dY, dMax) ;
-
vtNmax = ptFStemT - ptInt;
vtNmax.Normalize() ;
}
// Minimo
if ( dP2 < dP2_0) {
-
dMin = dZI - sqrt( dSqRad - ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth) - dP2 * dP2) ;
-
Point3d ptInt( dX, dY, dMin) ;
-
vtNmin = ptIStemT - ptInt ;
vtNmin.Normalize() ;
}
else if ( dP2 < dLenXY + dP2_0) {
dMin = dZI - dH0 + dDeltaZ * ( dP2 - dP2_0) / dLenXY ;
-
Point3d ptInt( dX, dY, dMin) ;
-
vtNmin = - ( ptInt - ptIStemT) + ( ptInt - ptIStemT) * vtMove * vtMove ;
vtNmin.Normalize() ;
}
else {
dMin = dZF - sqrt( dSqRad - ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth) - ( dP2 - dLenXY) * ( dP2 - dLenXY)) ;
-
Point3d ptInt( dX, dY, dMin) ;
-
vtNmin = ptFStemT - ptInt ;
vtNmin.Normalize() ;
}
@@ -2505,22 +2388,18 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d
//----------------------------------------------------------------------------
bool
-VolZmap::CylBall_XYMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
+VolZmap::CylBall_XYMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
{
if ( m_nToolType == CYLMILL)
-
return CompCyl_Milling( nGrid, ptS, ptE, vtToolDir, m_dHeight, m_dRadius, false, false) ;
else if ( m_nToolType == BALLMILL) {
-
double dHei = m_dHeight - m_dTipHeight ;
-
CompCyl_Milling( nGrid, ptS, ptE, vtToolDir, dHei, m_dRadius, false, false) ;
-
CompBall_Milling( nGrid, ptS - dHei * vtToolDir, ptE - dHei * vtToolDir, m_dRadius) ;
-
return true ;
}
+
else
return false ;
}
@@ -2529,7 +2408,7 @@ VolZmap::CylBall_XYMilling( unsigned int nGrid, const Point3d & ptS, const Point
// --------- Coni ------------------------------------------------------------
//----------------------------------------------------------------------------
bool
-VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
+VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
{
unsigned int nStartI, nStartJ, nEndI, nEndJ ;
@@ -2561,17 +2440,15 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3
Vector3d vtV ; // Vettore riferimento con origine nel vertice
if ( m_dRadius > m_dTipRadius) {
-
vtV = vtToolDir ;
ptV = ( vtToolDir * ( ptE - ptS) < 0 ? ptE : ptS) - vtToolDir * ( dStemHeigth + dL) ;//dStemHeigth ;
}
+
else {
-
vtV = - vtToolDir ;
ptV = ( vtToolDir * ( ptE - ptS) < 0 ? ptS : ptE) - vtToolDir * ( m_dHeight - dL) ;//dStemHeigth ;
}
-
// Sistema di riferimento sul piano
Vector3d vtV1 = - vtToolDir ;
Vector3d vtV2 = vtV1 ;
@@ -2580,11 +2457,9 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3
// Proiezione di ptI sul piano
Point3d ptIxy( ptI.x, ptI.y, 0) ;
-
// Ciclo sui punti
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -2597,8 +2472,7 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3
double dr = m_dRadius + ( dX1 - dMatStemLen) * ( m_dTipRadius - m_dRadius) / m_dTipHeight ;
- if ( dX1 > EPS_SMALL && dX1 < dMatStemLen &&
- abs( dX2) < m_dRadius) {
+ if ( dX1 > EPS_SMALL && dX1 < dMatStemLen && abs( dX2) < m_dRadius) {
double dH = sqrt( dSqRad - dX2 * dX2) ;
double dMin = ptI.z - dH ;
@@ -2615,8 +2489,9 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3
SubtractIntervals( nGrid, i, j, ptI.z - dH, ptI.z + dH, vtNmin, vtNmax) ;
}
- else if ( dX1 >= dMatStemLen &&
- dX1 < dMatStemLen + m_dTipHeight - EPS_SMALL &&
+
+ else if ( dX1 >= dMatStemLen &&
+ dX1 < dMatStemLen + m_dTipHeight - EPS_SMALL &&
abs( dX2) < dr) {
double dH = sqrt( dr * dr - dX2 * dX2) ;
@@ -2640,8 +2515,8 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3
if ( m_dTipRadius >= m_dRadius) {
- if ( dX1 > dMatStemLen + m_dTipHeight - 2 * EPS_SMALL &&
- dX1 < dMatStemLen + m_dTipHeight + dLenXY - EPS_SMALL &&
+ if ( dX1 > dMatStemLen + m_dTipHeight - 2 * EPS_SMALL &&
+ dX1 < dMatStemLen + m_dTipHeight + dLenXY - EPS_SMALL &&
abs( dX2) < dSqTipRad) {
double dH = sqrt( dSqTipRad - dX2 * dX2) ;
@@ -2669,9 +2544,8 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3
bool
VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Verifica sull'interferenza utensile Zmap
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bTest = BoundingBox( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ) ;
if ( ! bTest)
@@ -2733,11 +2607,10 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
double dP1 = vtC * vtV1 ;
double dP2 = vtC * vtV2 ;
-
// Parte cilindrica
- if ( dP1 > EPS_SMALL && dP1 <= dStemHeigth &&
- dP2 > - m_dRadius + EPS_SMALL && dP2 < m_dRadius - EPS_SMALL) {
+ if ( dP1 > EPS_SMALL && dP1 <= dStemHeigth &&
+ dP2 > - m_dRadius + EPS_SMALL && dP2 < m_dRadius - EPS_SMALL) {
dMin = dZI - sqrt( dSqRad - dP2 * dP2) ;
dMax = dZF + sqrt( dSqRad - dP2 * dP2) ;
@@ -2753,6 +2626,7 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
+
// Parte conica
else if ( dP1 > dStemHeigth && dP1 < m_dHeight - EPS_SMALL && abs( dP2) < m_dRadius +
( m_dTipRadius - m_dRadius) * ( dP1 - dStemHeigth) / m_dTipHeight - EPS_SMALL) {
@@ -2783,24 +2657,20 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
}
}
}
- else {
+ else {
// Riferimento sul piano
Vector3d vtV1 = - vtToolDir ;
Vector3d vtV2( vtMove.x, vtMove.y, 0) ;
vtV2.Normalize() ;
-
// Vettore per individuare i punti di tangenza
// dei piani con il cilindro
Vector3d vtCross = vtToolDir ^ vtMove ;
if ( vtCross.z < 0) vtCross = - vtCross ;
-
// Punti di tangenza
Point3d ptUp = ptI - vtToolDir * dStemHeigth + m_dRadius * vtCross ;
Point3d ptDw = ptI - vtToolDir * dStemHeigth - m_dRadius * vtCross ;
-
double dSmallLength = m_dRadius * vtCross.LenXY() ;
-
// Punti di tangenza in corrispondenza della punta
Point3d ptTipUp = ptI - vtToolDir * m_dHeight + m_dTipRadius * vtCross ;
Point3d ptTipDw = ptI - vtToolDir * m_dHeight - m_dTipRadius * vtCross ;
@@ -2837,7 +2707,6 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -2855,58 +2724,47 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
// Massimi
if ( dP2 < - dSmallLength) {
-
dMax = dZI + sqrt( dSqRad - dP2 * dP2) ;
-
ptInt.Set( dX, dY, dMax) ;
-
vtNmax = - ( ptInt - ptI) + ( ptInt - ptI) * vtV1 * vtV1 ;
vtNmax.Normalize() ;
}
- else if ( dP2 < dLengthPathXY - dSmallLength) {
-
- dMax = ptUp.z + dDeltaZ * ( dP2 + dSmallLength) / dLengthPathXY ;
+ else if ( dP2 < dLengthPathXY - dSmallLength) {
+ dMax = ptUp.z + dDeltaZ * ( dP2 + dSmallLength) / dLengthPathXY ;
vtNmax = - vtCross ;
}
+
else {
-
dMax = dZF + sqrt( dSqRad - ( dP2 - dLengthPathXY) * ( dP2 - dLengthPathXY)) ;
-
ptInt.Set( dX, dY, dMax) ;
-
vtNmax = - ( ptInt - ptF) + ( ptInt - ptF) * vtV1 * vtV1 ;
vtNmax.Normalize() ;
}
// Minimi
if ( dP2 < dSmallLength) {
-
dMin = dZI - sqrt( dSqRad - dP2 * dP2) ;
-
ptInt.Set( dX, dY, dMin) ;
-
vtNmin = - ( ptInt - ptI) + ( ptInt - ptI) * vtV1 * vtV1 ;
vtNmin.Normalize() ;
}
- else if ( dP2 < dLengthPathXY + dSmallLength) {
-
- dMin = ptDw.z + dDeltaZ * ( dP2 - dSmallLength) / dLengthPathXY ;
+ else if ( dP2 < dLengthPathXY + dSmallLength) {
+ dMin = ptDw.z + dDeltaZ * ( dP2 - dSmallLength) / dLengthPathXY ;
vtNmin = vtCross ;
}
+
else {
-
dMin = dZF - sqrt( dSqRad - ( dP2 - dLengthPathXY) * ( dP2 - dLengthPathXY)) ;
-
ptInt.Set( dX, dY, dMin) ;
-
vtNmin = - ( ptInt - ptF) + ( ptInt - ptF) * vtV1 * vtV1 ;
vtNmin.Normalize() ;
}
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
+
// Parte conica
else if ( dP1 > dStemHeigth && dP1 < m_dHeight - EPS_SMALL &&
dP2 > - m_dRadius - ( m_dTipRadius - m_dRadius) * ( dP1 - dStemHeigth) / m_dTipHeight &&
@@ -2931,15 +2789,14 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
vtNmax.Normalize() ;
}
+
else if ( dP2 < dLengthPathXY - dSmallLength +
dDeltaSmall * ( dP1 - dStemHeigth) / m_dTipHeight) {
-
dMax = ( dDotUp - dX * vtUpCross.x - dY * vtUpCross.y) / vtUpCross.z ;
-
vtNmax = vtUpCross ;
}
- else {
+ else {
double dr = dP2 - dLengthPathXY ;
double dMr = m_dRadius + ( m_dTipRadius - m_dRadius) * ( dP1 - dStemHeigth) / m_dTipHeight ;
@@ -2974,12 +2831,12 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
vtNmin.Normalize() ;
}
- else if ( dP2 < dLengthPathXY + dSmallLength - dDeltaSmall * ( dP1 - dStemHeigth) / m_dTipHeight) {
-
- dMin = ( dDotDw - dX * vtDwCross.x - dY * vtDwCross.y) / vtDwCross.z ;
+ else if ( dP2 < dLengthPathXY + dSmallLength - dDeltaSmall * ( dP1 - dStemHeigth) / m_dTipHeight) {
+ dMin = ( dDotDw - dX * vtDwCross.x - dY * vtDwCross.y) / vtDwCross.z ;
vtNmin = vtDwCross ;
}
+
else {
double dr = dP2 - dLengthPathXY ;
@@ -3015,17 +2872,14 @@ VolZmap::Conus_XYMilling( unsigned int nGrid, const Point3d & ptS, const Point3d
CompCyl_Milling( nGrid, ptS, ptE, vtToolDir, dStemHeigth, m_dRadius, false, true) ;
if ( m_dTipRadius < m_dRadius) {
-
Point3d ptSTip = ptS - dStemHeigth * vtToolDir ;
Point3d ptETip = ptE - dStemHeigth * vtToolDir ;
-
CompConus_Milling( nGrid, ptSTip, ptETip, vtToolDir, m_dTipHeight, m_dRadius, m_dTipRadius, true, false) ;
}
- else {
+ else {
Point3d ptSTip = ptS - m_dHeight * vtToolDir ;
Point3d ptETip = ptE - m_dHeight * vtToolDir ;
-
CompConus_Milling( nGrid, ptSTip, ptETip, - vtToolDir, m_dTipHeight, m_dTipRadius, m_dRadius, false, true) ;
}
@@ -3042,12 +2896,11 @@ VolZmap::CylBall_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3
double dStemHeigth = m_dHeight - m_dRadius ;
CompCyl_Drilling( nGrid, ptS, ptE, vtToolDir, dStemHeigth, m_dRadius, false, false) ;
+
// Sfera
if ( m_nToolType == 2) {
-
Point3d ptSBall = ptS - dStemHeigth * vtToolDir ;
Point3d ptEBall = ptE - dStemHeigth * vtToolDir ;
-
CompBall_Milling( nGrid, ptSBall, ptEBall, m_dRadius) ;
}
@@ -3060,12 +2913,11 @@ VolZmap::CylBall_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d
double dStemHeigth = m_dHeight - m_dTipHeight ;
CompCyl_Milling( nGrid, ptS, ptE, vtToolDir, dStemHeigth, m_dRadius, false, false) ;
+
// Sfera
if ( m_nToolType == 2) {
-
Point3d ptSBall = ptS - dStemHeigth * vtToolDir ;
Point3d ptEBall = ptE - dStemHeigth * vtToolDir ;
-
CompBall_Milling( nGrid, ptSBall, ptEBall, m_dRadius) ;
}
@@ -3080,19 +2932,17 @@ VolZmap::Conus_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d
double dStemHeigth = m_dHeight - m_dTipHeight ;
CompCyl_Drilling( nGrid, ptS, ptE, vtToolDir, dStemHeigth, m_dRadius, false, true) ;
+
// Trapano
if ( m_dTipRadius < m_dRadius) {
-
Point3d ptSCone = ptS - dStemHeigth * vtToolDir ;
Point3d ptECone = ptE - dStemHeigth * vtToolDir ;
-
CompConus_Drilling( nGrid, ptSCone, ptECone, vtToolDir, m_dTipHeight, m_dRadius, m_dTipRadius, true, false) ;
}
- else {
+ else {
Point3d ptSCone = ptS - m_dHeight * vtToolDir ;
Point3d ptECone = ptE - m_dHeight * vtToolDir ;
-
CompConus_Drilling( nGrid, ptSCone, ptECone, - vtToolDir, m_dTipHeight, m_dTipRadius, m_dRadius, false, true) ;
}
@@ -3106,19 +2956,17 @@ VolZmap::Conus_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d &
double dStemHeigth = m_dHeight - m_dTipHeight ;
CompCyl_Milling( nGrid, ptS, ptE, vtToolDir, dStemHeigth, m_dRadius, false, true) ;
+
// Trapano
if ( m_dTipRadius < m_dRadius) {
-
Point3d ptSBall = ptS - dStemHeigth * vtToolDir ;
Point3d ptEBall = ptE - dStemHeigth * vtToolDir ;
-
CompConus_Milling( nGrid, ptSBall, ptEBall, vtToolDir, m_dTipHeight, m_dRadius, m_dTipRadius, true, false) ;
}
- else {
+ else {
Point3d ptSBall = ptS - m_dHeight * vtToolDir ;
Point3d ptEBall = ptE - m_dHeight * vtToolDir ;
-
CompConus_Milling( nGrid, ptSBall, ptEBall, - vtToolDir, m_dTipHeight, m_dTipRadius, m_dRadius, false, true) ;
}
@@ -3133,7 +2981,6 @@ bool
VolZmap::Mrt_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux)
{
// Proiezione della traiettoria sul piano dei movimenti possibili
- //Vector3d vtMoveOnP = ( ptE - ptS) * vtVOnP * vtVOnP ;
Point3d ptEOnP = ptS + ( ptE - ptS) * vtToolDir * vtToolDir ;
// Scompongo la mortasatrice in solidi semplici
@@ -3142,7 +2989,6 @@ VolZmap::Mrt_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
double dLenX = m_dMrtChsWidth ;
double dLenY = m_dMrtChsThickness ;
double dLenZ = m_dHeight - m_dRCorner ;
-
CompPar_Drilling( nGrid, dLenX, dLenY, dLenZ, ptS, ptEOnP, vtToolDir, vtAux) ;
// Se la punta è di tipo bull-nose
@@ -3168,13 +3014,12 @@ VolZmap::Mrt_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
CompCyl_Milling( nGrid, ptSminus, ptEminus, vtAux, dLenY, m_dRCorner, false, false) ;
CompCyl_Milling( nGrid, ptSplus, ptEplus, vtAux, dLenY, m_dRCorner, false, false) ;
}
+
// se la punta è di tipo sfera
else {
-
// Cilindro
Point3d ptCylS = ptS - dLenZ * vtToolDir + 0.5 * dLenY * vtAux ;
Point3d ptCylE = ptEOnP - dLenZ * vtToolDir + 0.5 * dLenY * vtAux ;
-
CompCyl_Milling( nGrid, ptCylS, ptCylE, vtAux, dLenY, m_dRCorner, false, false) ;
}
@@ -3251,7 +3096,6 @@ VolZmap::Chs_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& pt
bool
VolZmap::Chs_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux)
{
-
// Proiezione della traiettoria sul piano dei movimenti possibili
Point3d ptSp = ptS ;
Vector3d vtMoveOnP = ( ptE - ptS) - ( ptE - ptS) * vtToolDir * vtToolDir ;
@@ -3320,10 +3164,9 @@ VolZmap::GenTool_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3
double dDeltaXPr = ptPrevFirst.x - ptPrevLast.x ;
// Setto le variabili per il tappo superiore
- if ( pCurve == pFirstConst ||
- nPrevType == CRV_ARC ||
- ( dDeltaXPr < 0 && dAbsDYPr))
-
+ if ( pCurve == pFirstConst ||
+ nPrevType == CRV_ARC ||
+ ( dDeltaXPr < 0 && dAbsDYPr))
bTapB = false ;
else
bTapB = true ;
@@ -3343,43 +3186,37 @@ VolZmap::GenTool_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3
double dDeltaXNx = ptNextFirst.x - ptNextLast.x ;
double dAbsXEnd = abs( ptNextLast.x) ;
- if ( pCurve == nullptr ||
- nNextType == CRV_ARC ||
- ( dAbsDYNx < EPS_SMALL && ( dDeltaXNx > 0 || dAbsXEnd < EPS_SMALL)))
-
+ if ( pCurve == nullptr ||
+ nNextType == CRV_ARC ||
+ ( dAbsDYNx < EPS_SMALL && ( dDeltaXNx > 0 || dAbsXEnd < EPS_SMALL)))
bTapT = false ;
else
bTapT = true ;
// Il componente è un cilindro
if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) {
-
double dRadius = ptStart.x ;
-
CompCyl_Drilling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius, bTapB, bTapT) ;
}
+
// Il componente è un cono con vettore equiverso a quello dell'utensile
else if ( ptStart.x > ptEnd.x) {
-
double dMaxRad = ptStart.x ;
double dMinRad = ptEnd.x ;
-
CompConus_Drilling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad, bTapB, bTapT) ;
}
+
// Il componente è un cono con vettore opposto a quello dell'utensile
else if ( ptStart.x < ptEnd.x) {
-
double dMaxRad = ptEnd.x ;
double dMinRad = ptStart.x ;
-
Point3d ptIn = ptI - vtToolDir * dHeight ;
Point3d ptFn = ptIn + vtMove ;
-
CompConus_Drilling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad, bTapT, bTapB) ;
}
}
- else {
+ else {
dHeight = 0 ;
pCurve = pToolProfile -> GetNextCurve() ;
}
@@ -3408,7 +3245,6 @@ VolZmap::GenTool_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3
// Eseguo l'asportazione del materiale
CompBall_Milling( nGrid, ptOSt, ptOEn, dRadius) ;
-
// aggiorno l'altezza
dHeight = abs( ptStart.y - ptEnd.y) ;
@@ -3481,16 +3317,14 @@ VolZmap::GenTool_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d
double dDeltaXPr = ptPrevFirst.x - ptPrevLast.x ;
// Setto le variabili per il tappo superiore
- if ( pCurve == pFirstConst ||
- nPrevType == CRV_ARC ||
- ( dDeltaXPr < 0 && dAbsDYPr))
-
+ if ( pCurve == pFirstConst ||
+ nPrevType == CRV_ARC ||
+ ( dDeltaXPr < 0 && dAbsDYPr))
bTapB = false ;
else
bTapB = true ;
// Dettagli curva successiva
-
pCurve = pToolProfile -> GetNextCurve() ;
pCurve = pToolProfile -> GetNextCurve() ;
@@ -3514,33 +3348,28 @@ VolZmap::GenTool_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d
// Il componente è un cilindro
if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) {
-
double dRadius = ptStart.x ;
-
CompCyl_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius, bTapB, bTapT) ;
}
+
// Il componente è un cono con vettore equiverso a quello dell'utensile
else if ( ptStart.x > ptEnd.x) {
-
double dMaxRad = ptStart.x ;
double dMinRad = ptEnd.x ;
-
CompConus_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad, bTapB, bTapT) ;
}
+
// Il componente è un cono con vettore opposto a quello dell'utensile
else if ( ptStart.x < ptEnd.x) {
-
double dMaxRad = ptEnd.x ;
double dMinRad = ptStart.x ;
-
Point3d ptIn = ptI - vtToolDir * dHeight ;
Point3d ptFn = ptIn + vtMove ;
-
CompConus_Milling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad, bTapT, bTapB) ;
}
}
- else {
+ else {
dHeight = 0 ;
pCurve = pToolProfile -> GetNextCurve() ;
}
@@ -3569,7 +3398,6 @@ VolZmap::GenTool_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d
// Eseguo l'asportazione del materiale
CompBall_Milling( nGrid, ptOSt, ptOEn, dRadius) ;
-
// aggiorno l'altezza
dHeight = abs( ptStart.y - ptEnd.y) ;
@@ -3579,26 +3407,20 @@ VolZmap::GenTool_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d
// Determino le posizioni iniziale e finale del componente successivo
ptI = ptI - vtToolDir * dHeight ;
ptF = ptI + vtMove ;
-
- // Aggiorno il puntatore
- // pCurve = pToolProfile->GetNextCurve() ;
}
return true ;
}
-
// ------------------------- SOLIDI ELEMENTARI -----------------------------------------------------------------------------
-
// Asse di simmetria diretto come l'asse Z: FORATURA
//----------------------------------------------------------------------------
bool
VolZmap::CompCyl_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dRad)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Verifica sull'interferenza con lo Zmap
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bTest = BBoxComponent( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ,
dRad, dRad, dHei) ;
@@ -3622,7 +3444,7 @@ VolZmap::CompCyl_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
// Ciclo sui punti
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
- for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
+ for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ;
@@ -3642,9 +3464,8 @@ VolZmap::CompCyl_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
bool
VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Verifica sull'interferenza con lo Zmap
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ, dMaxRad, dMinRad, dHei) ;
if ( ! Control)
@@ -3661,17 +3482,15 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
// computazionalmente più pesante è sottrarre prima il cilindro con dSafeSqMaxRad e dopo il cono con dSqMaxRad.
// Studio delle simmetrie
if ( vtToolDir.z > 0) {
-
dZMin = ( ptS.z < ptE.z ? ptS.z - dHei : ptE.z - dHei) ;
dZMax = ( ptS.z < ptE.z ? ptE.z : ptS.z) ;
}
- else {
+ else {
dZMin = ( ptS.z < ptE.z ? ptS.z : ptE.z) ;
dZMax = ( ptS.z < ptE.z ? ptE.z + dHei : ptS.z + dHei) ;
}
-
double dL = dMaxRad * dAngC ;
Point3d ptV = ( vtToolDir * ( ptE - ptS) < 0 ? ptE : ptS) - vtToolDir * dL ;
@@ -3690,7 +3509,6 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
double dSqDist = vtC * vtC ;
if ( dSqDist < dSqMinRad)
-
SubtractIntervals( nGrid, i, j, dZMin, dZMax, Z_AX, -Z_AX) ;
else if ( dSqDist < dSafeSqMaxRad) { // dSafeSqMaxRad è sperimentale
@@ -3698,7 +3516,6 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
double dr = sqrt( dSqDist) ;
if ( vtToolDir.z > 0) {
-
dMin = dZMin + dAngC * ( dr - dMinRad) ;
dMax = dZMax ;
@@ -3716,8 +3533,8 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
SubtractIntervals( nGrid, i, j, dMin, dMax, vtMin, vtMax) ;
}
- else {
+ else {
dMin = dZMin ;
dMax = dZMax - dAngC * ( dr - dMinRad) ;
@@ -3747,9 +3564,8 @@ VolZmap::CompPar_ZDrilling( unsigned int nGrid, double dLenX, double dLenY, doub
const Point3d& ptS, const Point3d& ptE,
const Vector3d& vtToolDir, const Vector3d& vtAux)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Controllo sull'interferenza utensile-solido
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bInterf = BBoxParaComp( nGrid, dLenX, dLenY, dLenZ, ptS, ptE, vtToolDir, vtAux, nStartI, nStartJ, nEndI, nEndJ) ;
if ( ! bInterf)
return true ;
@@ -3775,9 +3591,8 @@ VolZmap::CompPar_ZDrilling( unsigned int nGrid, double dLenX, double dLenY, doub
double dR1 = vtR * vtV1 ;
double dR2 = vtR * vtV2 ;
- if ( abs( dR1) < 0.5 * dLenX - EPS_SMALL &&
+ if ( abs( dR1) < 0.5 * dLenX - EPS_SMALL &&
abs( dR2) < 0.5 * dLenY - EPS_SMALL)
-
SubtractIntervals( nGrid, i, j, dMinZ, dMaxZ, Z_AX, - Z_AX) ;
}
}
@@ -3791,9 +3606,8 @@ VolZmap::CompPar_ZDrilling( unsigned int nGrid, double dLenX, double dLenY, doub
bool
VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dRad)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Verifica sull'interferenza con lo Zmap
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bTest = BBoxComponent( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ, dRad, dRad, dHei) ;
if ( ! bTest)
@@ -3880,45 +3694,34 @@ VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
dMax = dZMaxF ;
vtMax = - Z_AX ;
}
+
else {
-
dMax = dZMaxI + dDeltaZ * ( dX1 + dX1_0) / dLenXY ;
-
if ( abs( vtMove * vtToolDir) < EPS_SMALL) {
-
vtMax = - Z_AX ;
}
else {
-
Vector3d vtCirc = dX1_0 * vtV1 - dX2 * vtV2 ;
Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
Vector3d vtCross = vtTan ^ vtMove ;
-
vtMax = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ;
vtMax.Normalize() ;
}
}
// Minimo
if ( dX1 * dX1 + dX2 * dX2 < dSqRad) {
-
dMin = dZMinI ;
-
vtMin = Z_AX ;
}
else {
-
dMin = dZMinI + dDeltaZ * ( dX1 - dX1_0) / dLenXY ;
-
if ( abs( vtMove * vtToolDir) < EPS_SMALL) {
-
vtMin = Z_AX ;
}
else {
-
Vector3d vtCirc = - dX1_0 * vtV1 - dX2 * vtV2 ;
Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
Vector3d vtCross = vtTan ^ vtMove ;
-
vtMin = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ;
vtMin.Normalize() ;
}
@@ -3932,10 +3735,9 @@ VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
//----------------------------------------------------------------------------
bool
-VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad)
+VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad)
{
unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ, dMaxRad, dMinRad, dHei) ;
if ( ! Control)
@@ -3966,7 +3768,7 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin
double dTan = dDeltaR / dHei ;
double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ;
- bool bCase = ( dRatio * dTan > 1 ? true : false) ;
+ bool bCase = ( dRatio * dTan > 1) ;
double dCos = dTan * dRatio ;
double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
@@ -4012,35 +3814,27 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin
double dFDL = vtCF * vtV2 ;
double dFVarCos = dFDL / sqrt( dSqDF) ;
- if ( dSqDI < dMaxRad * dMaxRad || dSqDF < dMaxRad * dMaxRad ||
- (abs( dIDO) < dMaxRad && dIDL > 0 && dIDL < dLOrt)) {
+ if ( dSqDI < dMaxRad * dMaxRad || dSqDF < dMaxRad * dMaxRad ||
+ ( abs( dIDO) < dMaxRad && dIDL > 0 && dIDL < dLOrt)) {
// Caso dTan * dRatio > 1
if ( bCase) {
-
// Limiti nella direzione positiva di vtV1
if ( dSqDF < dMaxRad * dMaxRad) {
-
dPLim = dZI + dDeltaZ ;
-
vtP = - vtV1 ;
}
+
else {
-
double dIDL_0 = - sqrt( dMaxRad * dMaxRad - dIDO * dIDO) ;
-
dPLim = dZI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ;
-
if ( abs( vtV1 * vtUmv) < EPS_SMALL) {
-
vtP = - vtV1 ;
}
else {
-
Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ;
Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
Vector3d vtCross = vtTan ^ vtUmv ;
-
vtP = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ;
vtP.Normalize() ;
}
@@ -4048,135 +3842,101 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin
// Limiti nella direzione negativa di vtV1
if ( dSqDI < dMinRad * dMinRad) {
-
dMLim = dZTI ;
-
vtM = vtToolDir ;
}
+
else if ( dSqDI < dMaxRad * dMaxRad) {
-
dMLim = dZTI + ( sqrt( dSqDI) - dMinRad) * ( dZI - dZTI) / dDeltaR ;
-
ptInt.Set( dX, dY, dMLim) ;
-
Vector3d vtU = ( ptInt - ptV) - ( ptInt - ptV) * vtToolDir * vtToolDir ;
-
vtU.Normalize() ;
-
vtM = dDeltaR * vtToolDir - dHei * vtU ;
-
vtM.Normalize() ;
}
+
else {
-
double dIDL_0 = sqrt( dMaxRad * dMaxRad - dIDO * dIDO) ;
-
dMLim = dZI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ;
-
if ( abs( vtUmv * vtV1) < EPS_SMALL) {
-
vtM = vtV1 ;
}
else {
-
Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ;
Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
Vector3d vtCross = vtTan ^ vtUmv ;
-
vtM = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ;
vtM.Normalize() ;
}
}
}
- else {
+ else {
// Limiti nella direzione positiva di vtV1
if ( dSqDF < dMaxRad * dMaxRad) {
-
dPLim = dZI + dDeltaZ ;
-
vtP = - vtV1 ;
}
+
else {
-
double dIDL_0 = - sqrt( dMaxRad * dMaxRad - dIDO * dIDO) ;
-
dPLim = dZI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ;
-
if ( abs( vtUmv * vtToolDir) < EPS_SMALL) {
-
vtP = - vtV1 ;
}
else {
-
Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ;
Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
Vector3d vtCross = vtTan ^ vtUmv ;
- ////////////////////////////////////////////////////////////////////////////////////////
vtP = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ; // vtCross * vtCirc o vtCross * vtMove?
- ////////////////////////////////////////////////////////////////////////////////////////
vtP.Normalize() ;
}
}
// Limiti nella direzione negativa di vtV1
if ( dSqDI < dMinRad * dMinRad) {
-
dMLim = dZTI ;
-
vtM = vtV1 ;
}
+
else if ( dSqDI >= dMinRad * dMinRad && dSqDI < dMaxRad * dMaxRad && dIVarCos < dCos) {
-
dMLim = dZTI + ( sqrt( dSqDI) - dMinRad) * ( dZI - dZTI) / dDeltaR ;
-
ptInt.Set( dX, dY, dMLim) ;
-
Vector3d vtU = ( ptInt - ptV) - ( ptInt - ptV) * vtToolDir * vtToolDir ;
-
vtU.Normalize() ;
-
vtM = dDeltaR * vtToolDir - dHei * vtU ;
-
vtM.Normalize() ;
}
+
else if ( dSqDI >= dMinRad * dMinRad && dIVarCos >= dCos && dFVarCos < dCos && abs( dIDO) < dMaxRad * dSin) { // da qui
if ( dIDO > - dMaxRad * dSin && dIDO <= - dMinRad * dSin) {
-
dMLim = ( dDotd - dX * vtNd.x - dY * vtNd.y) / vtNd.z ;
-
vtM = - vtNd ;
}
+
else if ( dIDO > - dMinRad * dSin && dIDO < dMinRad * dSin) {
-
double dIDL_0 = sqrt( dMinRad * dMinRad - dIDO * dIDO) ;
-
dMLim = dZTI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ;
-
if ( abs( vtUmv * vtV1) < EPS_SMALL) {
-
vtM = vtV1 ;
}
else {
-
Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ;
Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
Vector3d vtCross = vtTan ^ vtUmv ;
-
double dDotCrossCirc = vtCross * vtCirc ;
-
vtM = ( dDotCrossCirc > 0 ? vtCross : - vtCross) ;
vtM.Normalize() ;
}
}
+
else if ( dIDO >= dMinRad * dSin && dIDO < dMaxRad * dSin) {
-
dMLim = ( dDots - dX * vtNs.x - dY * vtNs.y) / vtNs.z ; // a qui
-
vtM = - vtNs ;
}
}
+
else if ( dFVarCos >= dCos) {
if ( dSqDF < dMinRad * dMinRad) {
@@ -4186,72 +3946,53 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin
dMLim = dZTI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ;
if ( abs( vtUmv * vtV1) < EPS_SMALL) {
-
vtM = vtV1 ;
}
else {
-
Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ;
Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
Vector3d vtCross = vtTan ^ vtUmv ;
-
vtM = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ;
vtM.Normalize() ;
}
}
+
else {
-
dMLim = dZTI + dDeltaZ + ( sqrt( dSqDF) - dMinRad) * ( dZI - dZTI) / dDeltaR ;
-
ptInt.Set( dX, dY, dMLim) ;
-
Vector3d vtU = ( ptInt - ptVF) - ( ptInt - ptVF) * vtToolDir * vtToolDir ;
-
vtU.Normalize() ;
-
vtM = dDeltaR * vtToolDir - dHei * vtU ;
-
vtM.Normalize() ;
}
}
+
else {
-
double dIDL_0 = sqrt( dMaxRad * dMaxRad - dIDO * dIDO) ;
-
dMLim = dZI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ;
-
if ( abs( vtUmv * vtV1) < EPS_SMALL) {
-
vtM = vtV1 ;
}
else {
-
Vector3d vtCirc = - dIDL * vtV2 - dIDO * vtV3 ;
Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
Vector3d vtCross = vtTan ^ vtMove ;
-
vtM = ( vtCross * vtMove > 0 ? vtCross : - vtCross) ;
vtM.Normalize() ;
}
}
}
- //dMin = min( dPLim, dMLim) ;
- //dMax = max( dPLim, dMLim) ;
-
if ( dMLim < dPLim) {
-
dMin = dMLim ;
dMax = dPLim ;
-
vtMin = vtM ;
vtMax = vtP ;
}
- else {
+ else {
dMin = dPLim ;
dMax = dMLim ;
-
vtMin = vtP ;
vtMax = vtM ;
}
@@ -4267,11 +4008,10 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin
bool // E' in realtà MillingPerp
VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, double dLenZ,
const Point3d& ptS, const Point3d& ptE,
- const Vector3d& vtToolDir, const Vector3d& vtAux) {
-
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
+ const Vector3d& vtToolDir, const Vector3d& vtAux)
+{
// Controllo sull'interferenza utensile-solido
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bInterf = BBoxParaComp( nGrid, dLenX, dLenY, dLenZ, ptS, ptE, vtToolDir, vtAux, nStartI, nStartJ, nEndI, nEndJ) ;
if ( ! bInterf)
return true ;
@@ -4305,14 +4045,10 @@ VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, doubl
Vector3d vtW3 = vtAux ;
Vector3d vtAnsatz = ( vtW3 ^ vtToolDir) ;
-
bool bSymmetry = vtMove * ( vtW3 ^ vtToolDir) > 0 ;
Vector3d vtW2 = ( bSymmetry ? vtAnsatz : - vtAnsatz) ;
Vector3d vtW1 = ( bSymmetry ? vtToolDir : - vtToolDir) ;
-
- /* Point3d ptBase = bSymmetry ? ptLs - ( 0.5 * dLenZ) * vtW1 : ptLs ; */ // mi sa che +è sbagliato: va fatto sempre non se bSymmetry è true
-
Frame3d MotionFrame ;
@@ -4328,7 +4064,6 @@ VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, doubl
Point3d ptOMot = ( vtMove * vtU1 > 0 ? ptDiagMin : ptDiagMin + vtMove) ;
Point3d ptOMotXY( ptOMot.x, ptOMot.y, 0) ;
-
double dLen1 = vtMove * vtU1 ;
double dLen2 = vtMove * vtU2 ;
@@ -4351,15 +4086,13 @@ VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, doubl
double dRE2 = vtRE * vtV2 ;
// Asportazione materiale nella posizione iniziale
- if ( abs( dRS1) < 0.5 * dLenX - EPS_SMALL &&
+ if ( abs( dRS1) < 0.5 * dLenX - EPS_SMALL &&
abs( dRS2) < 0.5 * dLenY - EPS_SMALL)
-
SubtractIntervals( nGrid, i, j, dMinZ, dMaxZ, Z_AX, - Z_AX) ;
// Asportazione materiale nella posizione finale
- if ( abs( dRE1) < 0.5 * dLenX - EPS_SMALL &&
+ if ( abs( dRE1) < 0.5 * dLenX - EPS_SMALL &&
abs( dRE2) < 0.5 * dLenY - EPS_SMALL)
-
SubtractIntervals( nGrid, i, j, dMinZ, dMaxZ, Z_AX, - Z_AX) ;
// Asportazione materiale nel moto
@@ -4368,10 +4101,9 @@ VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, doubl
double dR1 = vtR * vtU1 ;
double dR2 = vtR * vtU2 ;
- if ( dR2 > EPS_SMALL && dR2 < dLen2 - EPS_SMALL &&
- dR1 * dLen2 > dLen1 * dR2 + EPS_SMALL &&
+ if ( dR2 > EPS_SMALL && dR2 < dLen2 - EPS_SMALL &&
+ dR1 * dLen2 > dLen1 * dR2 + EPS_SMALL &&
dR1 * dLen2 < dHx * dLen2 + dLen1 * dR2 - EPS_SMALL)
-
SubtractIntervals( nGrid, i, j, dMinZ, dMaxZ, Z_AX, - Z_AX) ;
}
}
@@ -4383,14 +4115,12 @@ VolZmap::CompPar_ZMilling( unsigned int nGrid, double dLenX, double dLenY, doubl
//----------------------------------------------------------------------------
bool
-VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir,
+VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir,
double dHei, double dRad, bool bTapB, bool bTapT)
{
unsigned int nStartI, nEndI, nStartJ, nEndJ ;
-
bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ,
dRad, dRad, dHei) ;
-
if ( ! Control)
return true ;
@@ -4431,24 +4161,18 @@ VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3
Vector3d vtN1, vtN2 ;
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLen, dRad, ptInt1, ptInt2,vtN1, vtN2, bTapB, bTapT)) {
-
- //dMin = min( ptInt1.z, ptInt2.z) ;
- //dMax = max( ptInt1.z, ptInt2.z) ;
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
vtNmin = vtN2 ;
vtNmax = vtN1 ;
-
}
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
@@ -4464,10 +4188,8 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
double dHei, double dMaxRad, double dMinRad, bool bTapB, bool bTapT)
{
unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ,
dMaxRad, dMinRad, dHei) ;
-
if ( ! Control)
return true ;
@@ -4507,7 +4229,6 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -4519,17 +4240,13 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
// Cilindro
if ( IntersLineCylinder( ptC - vtV1 * dL, Z_AX, ConusFrame, dLen, dMaxRad,
ptInt1, ptInt2, vtN1, vtN2, true, bTapCylEn)) {
-
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z + vtV1.z * dL ;
dMax = ptInt2.z + vtV1.z * dL ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z + vtV1.z * dL ;
dMax = ptInt1.z + vtV1.z * dL ;
vtNmin = vtN2 ;
@@ -4542,22 +4259,19 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
// Cono
if ( IntersLineConus( ptC , Z_AX, ConusFrame, dTan, dl, dL,
ptInt1, ptInt2, vtN1, vtN2, bTapT, true)) {
-
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z /*+ vtV1.z * dL*/ ;
dMax = ptInt2.z /*+ vtV1.z * dL*/ ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z /*+ vtV1.z * dL*/ ;
dMax = ptInt1.z /*+ vtV1.z * dL*/ ;
vtNmin = vtN2 ;
vtNmax = vtN1 ;
}
+
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
}
@@ -4571,9 +4285,8 @@ VolZmap::CompPar_Drilling( unsigned int nGrid, double dLenX, double dLenY, doubl
const Point3d& ptS, const Point3d& ptE,
const Vector3d& vtToolDir, const Vector3d& vtAux)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Controllo sull'interferenza utensile-solido
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bInterf = BBoxParaComp( nGrid, dLenX, dLenY, dLenZ, ptS, ptE, vtToolDir, vtAux, nStartI, nStartJ, nEndI, nEndJ) ;
if ( ! bInterf)
return true ;
@@ -4605,14 +4318,12 @@ VolZmap::CompPar_Drilling( unsigned int nGrid, double dLenX, double dLenY, doubl
Vector3d vtNmin, vtNmax ;
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
vtNmin = vtN2 ;
@@ -4634,24 +4345,20 @@ bool
VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE,
const Vector3d& vtToolDir, double dHei, double dRad, bool bTapB, bool bTapT)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Verifica sull'interferenza utensile Zmap
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir,
nStartI, nStartJ, nEndI, nEndJ, dRad, dRad, dHei) ;
if ( ! Control)
return true ;
-
// Studio delle simmetrie
Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ;
Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ;
-
Point3d ptITip = ptI - vtToolDir * dHei ;
Point3d ptFTip = ptF - vtToolDir * dHei ;
-
// Definizione terne vettoriali e sistemi di riferimento intrinseci al movimento
Vector3d vtMove = ptF - ptI ;
Vector3d vtMoveLong = ( vtMove * vtToolDir) * vtToolDir ;
@@ -4661,9 +4368,7 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
Vector3d vtV2 = vtMoveOrt ; vtV2.Normalize() ;
Vector3d vtV3 = vtV1 ^ vtV2 ;
-
Frame3d CylFrame ; CylFrame.Set( ptITip, vtV1, vtV2, vtV3) ;
-
// Parametri geometrici di moto e cilindro
double dSqRad = dRad * dRad ;
@@ -4691,16 +4396,13 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
// Cilindro iniziale
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, ptInt1, ptInt2, vtN1, vtN2, bCylSt, bCylEn)) {
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
vtNmin = vtN2 ;
@@ -4714,17 +4416,13 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
// del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
// il vettore che congiunge le due origini.
if ( IntersLineCylinder( ptC - vtMove, Z_AX, CylFrame, dHei, dRad, ptInt1, ptInt2, vtN1, vtN2, bCylSt, bCylEn)) {
-
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z + vtMove.z ;
dMax = ptInt2.z + vtMove.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z + vtMove.z ;
dMax = ptInt1.z + vtMove.z ;
vtNmin = vtN2 ;
@@ -4734,20 +4432,15 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
-
// Poliedro interno
if ( IntersLineMyPolyhedron( ptC, Z_AX, CylFrame, dHei, dOrtLen, 2 * dRad, dLongLen, ptInt1, ptInt2, vtN1, vtN2)) {
-
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
vtNmin = vtN2 ;
@@ -4760,17 +4453,13 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
// Cilindro ellittico di punta
if ( IntersLineEllipticalCylinder( Z_AX, ptC, CylFrame, dSqRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bElpsT, bElpsT)) {
-
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
vtNmin = vtN2 ;
@@ -4785,17 +4474,13 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
// il vettore che congiunge le due origini.
if ( IntersLineEllipticalCylinder( Z_AX, ptC - dHei * vtV1, CylFrame, dSqRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bElpsB, bElpsB)) {
-
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z + dHei * vtV1.z ;
dMax = ptInt2.z + dHei * vtV1.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z + dHei * vtV1.z ;
dMax = ptInt1.z + dHei * vtV1.z ;
vtNmin = vtN2 ;
@@ -4815,10 +4500,8 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
double dHei, double dMaxRad, double dMinRad, bool bTapB, bool bTapT)
{
unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ,
dMaxRad, dMinRad, dHei) ;
-
if ( ! Control)
return true ;
@@ -4919,7 +4602,6 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -4931,20 +4613,15 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Cono iniziale
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2, vtN1, vtN2, bConeT, bConeB)) {
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
-
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
-
vtNmin = vtN2 ;
vtNmax = vtN1 ;
}
@@ -4954,21 +4631,16 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Cono finale
if ( IntersLineConus( ptC - vtMove, Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2, vtN1, vtN2, bConeT, bConeB)) {
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z + vtMove.z ;
dMax = ptInt2.z + vtMove.z ;
-
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z + vtMove.z ;
dMax = ptInt1.z + vtMove.z ;
-
vtNmin = vtN2 ;
vtNmax = vtN1 ;
}
@@ -4994,11 +4666,10 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Intersezione con la prima faccia
if ( abs( vtPoly * vtNs) > COS_ORTO_ANG_ZERO) {
- if ( dLenY * ptPoly1.x >= dLenX * ptPoly1.y &&
- dLenY * ( ptPoly1.x - dDeltaX) <= dLenX * ( ptPoly1.y - dDeltaY) &&
- dDeltaX * ptPoly1.y >= dDeltaY * ptPoly1.x &&
+ if ( dLenY * ptPoly1.x >= dLenX * ptPoly1.y &&
+ dLenY * ( ptPoly1.x - dDeltaX) <= dLenX * ( ptPoly1.y - dDeltaY) &&
+ dDeltaX * ptPoly1.y >= dDeltaY * ptPoly1.x &&
dDeltaX * ( ptPoly1.y - dLenY) <= dDeltaY * ( ptPoly1.x - dLenX)) {
-
ptInt1 = ptPoly1 ;
vtN1 = - vtNs ;
++ nIntNum ;
@@ -5006,19 +4677,17 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
}
// Intersezione con la seconda faccia
if ( abs( vtPoly * vtNd) > COS_ORTO_ANG_ZERO) {
- if ( dLenY * ptPoly2.x >= dLenX * ptPoly2.y &&
+ if ( dLenY * ptPoly2.x >= dLenX * ptPoly2.y &&
dLenY * ( ptPoly2.x - dDeltaX) <= dLenX * ( ptPoly2.y - dDeltaY) &&
- dDeltaX * ptPoly2.y >= dDeltaY * ptPoly2.x &&
+ dDeltaX * ptPoly2.y >= dDeltaY * ptPoly2.x &&
dDeltaX * ( ptPoly2.y - dLenY) <= dDeltaY * ( ptPoly2.x - dLenX)) {
if ( nIntNum == 0) {
-
ptInt1 = ptPoly2 ;
vtN1 = - vtNd ;
++ nIntNum ;
}
else if ( ( ptInt1 - ptPoly2).SqLen() > dSqIndet) {
-
ptInt2 = ptPoly2 ;
vtN2 = - vtNd ;
++ nIntNum ;
@@ -5027,18 +4696,16 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
}
// Intersezione con la terza faccia
if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) {
- if ( nIntNum < 2 &&
- ptPoly3.x >= 0 && ptPoly3.x <= dDeltaX &&
+ if ( nIntNum < 2 &&
+ ptPoly3.x >= 0 && ptPoly3.x <= dDeltaX &&
dDeltaX * abs( ptPoly3.z) < dDeltaX * dLenZ + dDeltaZ * ptPoly3.x) {
if ( nIntNum == 0) {
-
ptInt1 = ptPoly3 ;
vtN1 = - vtIF ;
++ nIntNum ;
}
else if ( ( ptInt1 - ptPoly3).SqLen() > dSqIndet) {
-
ptInt2 = ptPoly3 ;
vtN2 = - vtIF ;
++ nIntNum ;
@@ -5048,18 +4715,16 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Intersezione con la quarta faccia
if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) {
- if ( nIntNum < 2 &&
- ptPoly4.x >= dLenX && ptPoly4.x <= dLenX + dDeltaX &&
+ if ( nIntNum < 2 &&
+ ptPoly4.x >= dLenX && ptPoly4.x <= dLenX + dDeltaX &&
dDeltaX * abs( ptPoly4.z) < dDeltaX * dLenZ + dDeltaZ * ( ptPoly4.x - dLenX)) {
if ( nIntNum == 0) {
-
ptInt1 = ptPoly4 ;
vtN1 = vtIF ;
++ nIntNum ;
}
else if ( ( ptInt1 - ptPoly4).SqLen() > dSqIndet) {
-
ptInt2 = ptPoly4 ;
vtN2 = vtIF ;
++ nIntNum ;
@@ -5069,18 +4734,16 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Intersezione con la quinta faccia
if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) {
- if ( nIntNum < 2 &&
- ptPoly5.y >= 0 && ptPoly5.y <= dLenY &&
+ if ( nIntNum < 2 &&
+ ptPoly5.y >= 0 && ptPoly5.y <= dLenY &&
abs( ptPoly5.z) <= dLenZ) {
if ( nIntNum == 0) {
-
ptInt1 = ptPoly5 ;
vtN1 = - vtUD ;
++ nIntNum ;
}
else if ( ( ptInt1 - ptPoly5).SqLen() > dSqIndet) {
-
ptInt2 = ptPoly5 ;
vtN2 = - vtUD ;
++ nIntNum ;
@@ -5090,18 +4753,16 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Intersezione con la sesta faccia
if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) {
- if ( nIntNum < 2 &&
- ptPoly6.y >= dDeltaY && ptPoly6.y <= dLenY + dDeltaY &&
+ if ( nIntNum < 2 &&
+ ptPoly6.y >= dDeltaY && ptPoly6.y <= dLenY + dDeltaY &&
abs( ptPoly6.z) <= dLenZ + dDeltaZ) {
if ( nIntNum == 0) {
-
ptInt1 = ptPoly6;
vtN1 = vtUD ;
++ nIntNum ;
}
else if ( ( ptInt1 - ptPoly6).SqLen() > dSqIndet) {
-
ptInt2 = ptPoly6;
vtN2 = vtUD ;
++ nIntNum ;
@@ -5118,22 +4779,15 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
vtN1.ToGlob( PolyFrame) ;
vtN2.ToGlob( PolyFrame) ;
- //dMin = min( ptInt1.z, ptInt2.z) ;
- //dMax = max( ptInt1.z, ptInt2.z) ;
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
-
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
-
vtNmin = vtN2 ;
vtNmax = vtN1 ;
}
@@ -5144,17 +4798,13 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Traslazione ellisse di punta
if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dl, ConusFrame, dSqMinRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bElpsT, bElpsT)) {
-
-
- if( ptInt1.z < ptInt2.z) {
-
+ if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z + vtV1.z * dl ;
dMax = ptInt2.z + vtV1.z * dl ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z + vtV1.z * dl ;
dMax = ptInt1.z + vtV1.z * dl ;
vtNmin = vtN2 ;
@@ -5167,16 +4817,13 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Traslazione ellisse di base
if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bElpsB, bElpsB)) {
-
- if( ptInt1.z < ptInt2.z) {
-
+ if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z + vtV1.z * dL ;
dMax = ptInt2.z + vtV1.z * dL ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z + vtV1.z * dL ;
dMax = ptInt1.z + vtV1.z * dL ;
vtNmin = vtN2 ;
@@ -5189,8 +4836,8 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
}
return true ;
}
- else {
+ else {
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
@@ -5199,26 +4846,20 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
Point3d ptC( dX, dY, 0) ;
- Point3d ptInt1, ptInt2 ;
- Vector3d vtN1, vtN2 ;
+ Point3d ptInt1, ptInt2 ;
+ Vector3d vtN1, vtN2 ;
// Cono
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2, vtN1, vtN2, bConeT, bConeB)) {
-
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
-
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
-
vtNmin = vtN2 ;
vtNmax = vtN1 ;
}
@@ -5229,17 +4870,13 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Traslazione ellisse
if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bConeB, bConeB)) {
-
-
if( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z + vtV1.z * dL ;
dMax = ptInt2.z + vtV1.z * dL ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z + vtV1.z * dL ;
dMax = ptInt1.z + vtV1.z * dL ;
vtNmin = vtN2 ;
@@ -5260,9 +4897,8 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
const Point3d& ptS, const Point3d& ptE,
const Vector3d& vtToolDir, const Vector3d& vtAux)
{
- unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
// Controllo sull'interferenza utensile-solido
+ unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bInterf = BBoxParaComp( nGrid, dLenX, dLenY, dLenZ, ptS, ptE, vtToolDir, vtAux, nStartI, nStartJ, nEndI, nEndJ) ;
if ( ! bInterf)
return true ;
@@ -5297,12 +4933,6 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
Point3d ptBase = bSymmetry ? ptLs - dLenZ * vtW1 : ptLs ;
- /*Point3d ptOMotion = ptBase - vtW2 * ( 0.5 * dLenX) - vtW3 * ( 0.5 * dLenY) ;
-
- Vector3d vtU1 = vtW2 ;
- Vector3d vtU2 = vtW3 ;
- Vector3d vtU3 = vtW1 ; */
-
Frame3d MotionFrame ; /*MotionFrame.Set( ptOMotion, vtU1, vtU2, vtU3) ;*/
Point3d ptDiagMin = ptBase - vtW2 * ( 0.5 * dLenX) + vtW3 * ( 0.5 * dLenY) ;
@@ -5323,7 +4953,6 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
double dLen1 = abs( vtMv * vtU1) ;
double dLen2 = abs( vtMv * vtU2) ;
-
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
@@ -5338,19 +4967,15 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
// Solido nella posizione iniziale
if ( IntersLineMyPolyhedron( ptC, Z_AX, ParaFrame, dLenZ, dLenX, dLenY, 0, ptInt1, ptInt2, vtN1, vtN2)) {
-
double dMin, dMax ;
Vector3d vtNmin, vtNmax ;
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
vtNmin = vtN2 ;
@@ -5362,19 +4987,15 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
// Solido nella posizione finale
if ( IntersLineMyPolyhedron( ptC - vtMove, Z_AX, ParaFrame, dLenZ, dLenX, dLenY, 0, ptInt1, ptInt2, vtN1, vtN2)) {
-
double dMin, dMax ;
Vector3d vtNmin, vtNmax ;
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z + vtMove.z ;
dMax = ptInt2.z + vtMove.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z + vtMove.z ;
dMax = ptInt1.z + vtMove.z ;
vtNmin = vtN2 ;
@@ -5386,19 +5007,15 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
// Volume spazzato nel moto
if ( IntersLineMyPolyhedron( ptC, Z_AX, MotionFrame, dDimX, dLen2, dLenZ, dLen1, ptInt1, ptInt2, vtN1, vtN2)) {
-
double dMin, dMax ;
Vector3d vtNmin, vtNmax ;
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
vtNmin = vtN2 ;
@@ -5420,9 +5037,7 @@ bool
VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point3d & ptLe, double dRad)
{
unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
bool Control = BBoxComponent( nGrid, ptLs, ptLe, V_NULL, nStartI, nStartJ, nEndI, nEndJ, dRad, 0, 0) ;
-
if ( ! Control)
return true ;
@@ -5436,20 +5051,16 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
// Costruisco sistema di riferimento
if ( vtV.x * vtV.x > 0.3)
-
vtW.Set( - ( vtV.y + vtV.z) / vtV.x, 1, 1) ;
else if ( vtV.y * vtV.y > 0.3)
-
vtW.Set( 1, - ( vtV.x + vtV.z) / vtV.y, 1) ;
else
-
vtW.Set( 1, 1, - ( vtV.x + vtV.y) / vtV.z) ;
Point3d ptOnY = ptLs + vtW ;
-
Frame3d CylFrame ; CylFrame.Set( ptLs, ptLe, ptOnY) ;
double dSqRad = dRad * dRad ;
@@ -5470,7 +5081,6 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
// Prima sfera
if ( dStSqDXY < dSqRad) {
-
dMin = ptLs.z - sqrt( dSqRad - dStSqDXY) ;
dMax = ptLs.z + sqrt( dSqRad - dStSqDXY) ;
@@ -5488,7 +5098,6 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
// Seconda sfera
if ( dEnSqDXY < dSqRad) {
-
dMin = ptLe.z - sqrt( dSqRad - dEnSqDXY) ;
dMax = ptLe.z + sqrt( dSqRad - dEnSqDXY) ;
@@ -5509,16 +5118,13 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
// Cilindro
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLengthPath, dRad, ptInt1, ptInt2, vtN1, vtN2, false, false)) {
-
if ( ptInt1.z < ptInt2.z) {
-
dMin = ptInt1.z ;
dMax = ptInt2.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
}
else {
-
dMin = ptInt2.z ;
dMax = ptInt1.z ;
vtNmin = vtN2 ;
@@ -5532,33 +5138,26 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
return true ;
}
-
-
// ------------------------- BOUNDING BOX --------------------------------------------------------------------------------------
//----------------------------------------------------------------------------
inline bool
-VolZmap::BoundingBox( unsigned int nGrid, const Point3d & ptP1, const Point3d & ptP2, const Vector3d & vtV,
- unsigned int & nStI, unsigned int & nStJ, unsigned int & nEnI, unsigned int & nEnJ)
+VolZmap::BoundingBox( unsigned int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV,
+ unsigned int& nStI, unsigned int& nStJ, unsigned int& nEnI, unsigned int& nEnJ)
{
- // NB: E' vitale che vengano passati i punti e i vettori
- // nel sistema di riferimento opportuno.
-
+ // I punti e i vettori devono essere nel sistema di riferimento opportuno
+
// Controllo sull'ammissibilità del numero di griglia
if ( nGrid < 0 || nGrid > 2)
return false ;
- unsigned int nMaxNx, nMaxNy ;
+ unsigned int nMaxNx = m_nNx[nGrid] ;
+ unsigned int nMaxNy = m_nNy[nGrid] ;
- double dMaxXValue, dMaxYValue ;
- double dMinZValue, dMaxZValue ;
-
- nMaxNx = m_nNx[nGrid] ; nMaxNy = m_nNy[nGrid] ;
-
- dMaxXValue = nMaxNx * m_dStep ; dMaxYValue = nMaxNy * m_dStep ;
-
- dMinZValue = m_dMinZ[nGrid] ; dMaxZValue = m_dMaxZ[nGrid] ;
-
+ double dMaxXValue = nMaxNx * m_dStep ;
+ double dMaxYValue = nMaxNy * m_dStep ;
+ double dMinZValue = m_dMinZ[nGrid] ;
+ double dMaxZValue = m_dMaxZ[nGrid] ;
// Determinazione del raggio massimo dell'utensile
double dMaxRad = max( m_dRadius, m_dTipRadius) ;
@@ -5576,11 +5175,11 @@ VolZmap::BoundingBox( unsigned int nGrid, const Point3d & ptP1, const Point3d &
double dMaxZ = max( max( ptP1.z, ptP1T.z), max( ptP2.z, ptP2T.z)) + dMaxRad ;
// Verifica dell'interferenza dell'utensile con lo Zmap
- if ( dMaxX < EPS_SMALL || dMinX > dMaxXValue - EPS_SMALL)
+ if ( dMaxX < EPS_SMALL || dMinX > dMaxXValue - EPS_SMALL)
return false ;
- if ( dMaxY < EPS_SMALL || dMinY > dMaxYValue - EPS_SMALL)
+ if ( dMaxY < EPS_SMALL || dMinY > dMaxYValue - EPS_SMALL)
return false ;
- if ( dMaxZ < dMinZValue + EPS_SMALL || dMinZ > dMaxZValue - EPS_SMALL)
+ if ( dMaxZ < dMinZValue + EPS_SMALL || dMinZ > dMaxZValue - EPS_SMALL)
return false ;
// Limiti su indici
@@ -5598,23 +5197,19 @@ VolZmap::BBoxComponent( unsigned int nGrid, const Point3d & ptP1, const Point3d
unsigned int & nStI, unsigned int & nStJ, unsigned int & nEnI, unsigned int & nEnJ,
double dRad, double dTipRad, double dHei)
{
- // NB: E' vitale che vengano passati i punti e i vettori
- // nel sistema di riferimento opportuno.
+ // I punti e i vettori devono essere nel sistema di riferimento opportuno
// Controllo sull'ammissibilità del numero di griglia
if ( nGrid < 0 || nGrid > 2)
return false ;
- unsigned int nMaxNx, nMaxNy ;
+ unsigned int nMaxNx = m_nNx[nGrid] ;
+ unsigned int nMaxNy = m_nNy[nGrid] ;
- double dMaxXValue, dMaxYValue ;
- double dMinZValue, dMaxZValue ;
-
- nMaxNx = m_nNx[nGrid] ; nMaxNy = m_nNy[nGrid] ;
-
- dMaxXValue = nMaxNx * m_dStep ; dMaxYValue = nMaxNy * m_dStep ;
-
- dMinZValue = m_dMinZ[nGrid] ; dMaxZValue = m_dMaxZ[nGrid] ;
+ double dMaxXValue = nMaxNx * m_dStep ;
+ double dMaxYValue = nMaxNy * m_dStep ;
+ double dMinZValue = m_dMinZ[nGrid] ;
+ double dMaxZValue = m_dMaxZ[nGrid] ;
// Determinazione del raggio massimo del componente
double dMaxRad = max( dRad, dTipRad) ;
@@ -5632,11 +5227,11 @@ VolZmap::BBoxComponent( unsigned int nGrid, const Point3d & ptP1, const Point3d
double dMaxZ = max( max( ptP1.z, ptP1T.z), max( ptP2.z, ptP2T.z)) + dMaxRad ;
// Verifica dell'interferenza dell'utensile con lo Zmap
- if ( dMaxX < EPS_SMALL || dMinX > dMaxXValue - EPS_SMALL)
+ if ( dMaxX < EPS_SMALL || dMinX > dMaxXValue - EPS_SMALL)
return false ;
- if ( dMaxY < EPS_SMALL || dMinY > dMaxYValue - EPS_SMALL)
+ if ( dMaxY < EPS_SMALL || dMinY > dMaxYValue - EPS_SMALL)
return false ;
- if ( dMaxZ < dMinZValue + EPS_SMALL || dMinZ > dMaxZValue - EPS_SMALL)
+ if ( dMaxZ < dMinZValue + EPS_SMALL || dMinZ > dMaxZValue - EPS_SMALL)
return false ;
// Limiti su indici
@@ -5654,8 +5249,7 @@ VolZmap::BBoxParaComp( unsigned int nGrid, double dLenX, double dLenY, double dL
const Point3d& ptS, const Point3d& ptE, const Vector3d& vtD, const Vector3d& vtA,
unsigned int& nStI, unsigned int& nStJ, unsigned int& nEnI, unsigned int& nEnJ)
{
- // NB: E' vitale che vengano passati i punti e i vettori
- // nel sistema di riferimento opportuno.
+ // I punti e i vettori devono essere nel sistema di riferimento opportuno
// Determino le posizioni iniziale e
// finale della punta dell'utensile.
@@ -5672,23 +5266,20 @@ VolZmap::BBoxParaComp( unsigned int nGrid, double dLenX, double dLenY, double dL
double dMaxY = max( max( ptS.y, ptSTip.y), max( ptE.y, ptETip.y)) + dMaxDim ;
double dMaxZ = max( max( ptS.z, ptSTip.z), max( ptE.z, ptETip.z)) + dMaxDim ;
- unsigned int nMaxNx, nMaxNy ;
+ unsigned int nMaxNx = m_nNx[nGrid] ;
+ unsigned int nMaxNy = m_nNy[nGrid] ;
- double dMaxXValue, dMaxYValue ;
- double dMinZValue, dMaxZValue ;
-
- nMaxNx = m_nNx[nGrid] ; nMaxNy = m_nNy[nGrid] ;
-
- dMaxXValue = nMaxNx * m_dStep ; dMaxYValue = nMaxNy * m_dStep ;
-
- dMinZValue = m_dMinZ[nGrid] ; dMaxZValue = m_dMaxZ[nGrid] ;
+ double dMaxXValue = nMaxNx * m_dStep ;
+ double dMaxYValue = nMaxNy * m_dStep ;
+ double dMinZValue = m_dMinZ[nGrid] ;
+ double dMaxZValue = m_dMaxZ[nGrid] ;
// Verifica dell'interferenza dell'utensile con lo Zmap
- if ( dMaxX < EPS_SMALL || dMinX > dMaxXValue - EPS_SMALL)
+ if ( dMaxX < EPS_SMALL || dMinX > dMaxXValue - EPS_SMALL)
return false ;
- if ( dMaxY < EPS_SMALL || dMinY > dMaxYValue - EPS_SMALL)
+ if ( dMaxY < EPS_SMALL || dMinY > dMaxYValue - EPS_SMALL)
return false ;
- if ( dMaxZ < dMinZValue + EPS_SMALL || dMinZ > dMaxZValue - EPS_SMALL)
+ if ( dMaxZ < dMinZValue + EPS_SMALL || dMinZ > dMaxZValue - EPS_SMALL)
return false ;
// Limiti su indici