From 7cf76d31750f75482a084c30d87b2e9e9a4bd519 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Fri, 3 Nov 2017 12:29:26 +0000 Subject: [PATCH] EgtGeomKernel 1.8j6 : - correzioni e migliorie a Triangle3d - migliorie a Zmap. --- EgtGeomKernel.rc | Bin 11718 -> 11718 bytes EgtGeomKernel.vcxproj | 10 + EgtGeomKernel.vcxproj.filters | 30 ++ VolTriZmapGraphics.cpp | 430 ++++++++++++----- VolTriZmapVolume.cpp | 849 +++++++++------------------------- 5 files changed, 568 insertions(+), 751 deletions(-) diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index 38dc9ed7e85de257c950cee5c5fd996d829dcade..e2b58e292ffc7c11b2db4f49fe6d5da342dde352 100644 GIT binary patch delta 110 zcmX>WeJpyzA2vp_&G-4vGfl1&(wY2&Q;pGVvZAo=W*@FeEMOU1X1ItOWeJpyzA2vqQ&G-4vGfl1&(wY2&Q;pGdvZAo=W*@FeEMOU1X1ItO + @@ -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