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

EgtGeomKernel :

Browse Source 
- aggiunta di una funzione per  la VirtualMilling a 5 assi usando le bilineari.
This commit is contained in:
Daniele Bariletti
2025-05-15 12:13:55 +02:00
parent 8b75b6e4c3
commit 79dfb4ae87
2 changed files with 389 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmapVolume.cpp
+378 -44
View File
@@ -21,6 +21,8 @@
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/ENkPolynomialRoots.h"
#include <future>
using namespace std ;
@@ -905,6 +907,247 @@ GetAlongAcrossRotation( const Vector3d& vtDir1, const Vector3d& vtDir2, const Ve
return true ;
}
bool
UpdateMaxMin(Point3d ptBez, Vector3d vtN, double& dMin, double& dMax, Point3d& ptMin, Point3d& ptMax, Vector3d& vtMin, Vector3d& vtMax) {
if ( ptBez.z > dMax) {
dMax = ptBez.z ;
ptMax = ptBez ;
vtMax = -vtN ; // inverto il segno della normale, perché devo passare la normale della supercie tagliata, non di quella di taglio
}
if ( ptBez.z < dMin) {
dMin = ptBez.z ;
ptMin = ptBez ;
vtMin = -vtN ; // inverto il segno della normale, perché devo passare la normale della supercie tagliata, non di quella di taglio
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::InitializeAuxPoints( Point3d ptTop1s[3], Point3d ptTop1e[3], Point3d ptTop2s[3], Point3d ptTop2e[3],
Point3d ptBottom1s[3], Point3d ptBottom1e[3], Point3d ptBottom2s[3], Point3d ptBottom2e[3])
{
// per ogni array il punto epr la prima griglia è già settato, devo aggiungere i punti per le altre due, permutando le coordinate
if ( m_nMapNum > 1) {
ptTop1s[1].x = ptTop1s[0].y ; ptTop1s[1].y = ptTop1s[0].z ; ptTop1s[1].z = ptTop1s[0].x ;
ptTop1s[2].x = ptTop1s[0].z ; ptTop1s[2].y = ptTop1s[0].x ; ptTop1s[2].z = ptTop1s[0].y ;
ptTop1e[1].x = ptTop1e[0].y ; ptTop1e[1].y = ptTop1e[0].z ; ptTop1e[1].z = ptTop1e[0].x ;
ptTop1e[2].x = ptTop1e[0].z ; ptTop1e[2].y = ptTop1e[0].x ; ptTop1e[2].z = ptTop1e[0].y ;
ptTop2s[1].x = ptTop2s[0].y ; ptTop2s[1].y = ptTop2s[0].z ; ptTop2s[1].z = ptTop2s[0].x ;
ptTop2s[2].x = ptTop2s[0].z ; ptTop2s[2].y = ptTop2s[0].x ; ptTop2s[2].z = ptTop2s[0].y ;
ptTop2e[1].x = ptTop2e[0].y ; ptTop2e[1].y = ptTop2e[0].z ; ptTop2e[1].z = ptTop2e[0].x ;
ptTop2e[2].x = ptTop2e[0].z ; ptTop2e[2].y = ptTop2e[0].x ; ptTop2e[2].z = ptTop2e[0].y ;
ptBottom1s[1].x = ptBottom1s[0].y ; ptBottom1s[1].y = ptBottom1s[0].z ; ptBottom1s[1].z = ptBottom1s[0].x ;
ptBottom1s[2].x = ptBottom1s[0].z ; ptBottom1s[2].y = ptBottom1s[0].x ; ptBottom1s[2].z = ptBottom1s[0].y ;
ptBottom1e[1].x = ptBottom1e[0].y ; ptBottom1e[1].y = ptBottom1e[0].z ; ptBottom1e[1].z = ptBottom1e[0].x ;
ptBottom1e[2].x = ptBottom1e[0].z ; ptBottom1e[2].y = ptBottom1e[0].x ; ptBottom1e[2].z = ptBottom1e[0].y ;
ptBottom2s[1].x = ptBottom2s[0].y ; ptBottom2s[1].y = ptBottom2s[0].z ; ptBottom2s[1].z = ptBottom2s[0].x ;
ptBottom2s[2].x = ptBottom2s[0].z ; ptBottom2s[2].y = ptBottom2s[0].x ; ptBottom2s[2].z = ptBottom2s[0].y ;
ptBottom2e[1].x = ptBottom2e[0].y ; ptBottom2e[1].y = ptBottom2e[0].z ; ptBottom2e[1].z = ptBottom2e[0].x ;
ptBottom2e[2].x = ptBottom2e[0].z ; ptBottom2e[2].y = ptBottom2e[0].x ; ptBottom2e[2].z = ptBottom2e[0].y ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::SelectGeneralMotion( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtDs, const Vector3d& vtDe, const int nPhase)
{
///////////////////////////////////////////////////////////////////////////////////////////
// qui al momento gestisco solo il caso del cilindro, ma dovrò gestire anche gli altri casi
///////////////////////////////////////////////////////////////////////////////////////////
// tolgo il volume dei cilindri all'inzio e alla fine del tratto e poi uso delle bilineari per approssimare il volume spazzato
Point3d ptLs[N_MAPS] ;
Point3d ptLe[N_MAPS] ;
Vector3d vtLs[N_MAPS] ;
Vector3d vtLe[N_MAPS] ;
InitializePointsAndVectors( ptPs, ptPe, vtDs, vtDe, ptLs, ptLe, vtLs, vtLe) ;
// recupero le info del tool
Tool& CurrTool = m_vTool[m_nCurrTool] ;
double dHeight = CurrTool.GetHeigth() ;
double dRadius = CurrTool.GetRadius() ;
Point3d ptTop1s[N_MAPS] ;
Point3d ptTop1e[N_MAPS] ;
Point3d ptTop2s[N_MAPS] ;
Point3d ptTop2e[N_MAPS] ;
Point3d ptBottom1s[N_MAPS] ;
Point3d ptBottom1e[N_MAPS] ;
Point3d ptBottom2s[N_MAPS] ;
Point3d ptBottom2e[N_MAPS] ;
// determino la posizone della punta del tool nella posizone inizale e in quella finale
Point3d ptP1T = ptPs - dHeight * vtDs ;
Point3d ptP2T = ptPe - dHeight * vtDe ;
// determino la direzione di movimento del top del tool e della punta del tool
Vector3d vtDirTop = ptPe - ptPs ;
Vector3d vtDirTip = ptP2T - ptP1T ;
// determino i punti laterali del top e del bottom(tip), nella posizione di partenza
Vector3d vtAuxTopS = vtDs ^ vtDirTop ;
vtAuxTopS.Normalize() ;
vtAuxTopS *= dRadius ;
ptTop1s[0] = ptPs + vtAuxTopS ;
ptTop2s[0] = ptPs - vtAuxTopS ;
Vector3d vtAuxBottomS = vtDs ^ vtDirTip ;
vtAuxBottomS.Normalize() ;
vtAuxBottomS *= dRadius ;
ptBottom1s[0] = ptP1T + vtAuxBottomS ;
ptBottom2s[0] = ptP1T - vtAuxBottomS ;
// determino i punti laterali del top e del bottom(tip), nella posizione di arrivo
Vector3d vtAuxTopE = vtDe ^ vtDirTop ;
vtAuxTopE.Normalize() ;
vtAuxTopE *= dRadius ;
ptTop1e[0] = ptPe + vtAuxTopE ;
ptTop2e[0] = ptPe - vtAuxTopE ;
Vector3d vtAuxBottomE = vtDe ^ vtDirTip ;
vtAuxBottomE.Normalize() ;
vtAuxBottomE *= dRadius ;
ptBottom1e[0] = ptP2T + vtAuxBottomE ;
ptBottom2e[0] = ptP2T - vtAuxBottomE ;
InitializeAuxPoints( ptTop1s, ptTop1e, ptTop2s, ptTop2e, ptBottom1s, ptBottom1e, ptBottom2s, ptBottom2e) ;
vector<IGeoObj*> vGeo ;
for ( int z = 0 ; z < m_nMapNum ; ++z) {
//CompCyl_AcrossMilling() // questa potrebbe essere la funzione che raccoglie tutto quello che ci sarà in questo for
// tolgo il volume del cilindro iniziale e finale del moto
if ( nPhase == VolZmap::MillingPhase::COUNT_START_CYL) {
// in base all'orientamento del tool scelgo la funzione adatta
if ( vtLs[z].SqLenXY() < EPS_SMALL * EPS_SMALL)
CompCyl_ZDrilling( z, ptLs[z], ptLs[z], vtLs[z], dHeight, dRadius, CurrTool.GetToolNum()) ;
else
CompCyl_Drilling( z, ptLs[z], ptLs[z], vtLs[z], dHeight, dRadius, false, false, CurrTool.GetToolNum()) ;
}
if ( nPhase == VolZmap::MillingPhase::COUNT_END_CYL) {
if ( vtLs[z].SqLenXY() < EPS_SMALL * EPS_SMALL)
CompCyl_ZDrilling( z, ptLe[z], ptLe[z], vtLe[z], dHeight, dRadius, CurrTool.GetToolNum()) ;
else
CompCyl_Drilling( z, ptLe[z], ptLe[z], vtLe[z], dHeight, dRadius, false, false, CurrTool.GetToolNum()) ;
}
// tolgo il volume spazzato dal tool durante il movimento
// Verifica sull'interferenza con lo Zmap
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( z, ptLs[z], ptLe[z], vtLs[z], vtLe[z], dRadius, dRadius, dHeight, nStartI, nStartJ, nEndI, nEndJ))
return true ;
int nDegU = 1 ; int nDegV = 1 ;
int nSpanU = 1 ; int nSpanV = 1 ;
bool bRat = false ;
vector<PNTVECTOR> vvPtCtrl ;
PNTVECTOR vPtCtrl0 = { ptBottom1s[z], ptTop1s[z], ptBottom1e[z], ptTop1e[z]} ;
vvPtCtrl.push_back( move( vPtCtrl0)) ;
PNTVECTOR vPtCtrl1 = { ptBottom2s[z], ptBottom1s[z], ptBottom2e[z], ptBottom1e[z]} ;
vvPtCtrl.push_back( move( vPtCtrl1)) ;
PNTVECTOR vPtCtrl2 = { ptTop2s[z], ptBottom2s[z], ptTop2e[z], ptBottom2e[z]} ;
vvPtCtrl.push_back( move( vPtCtrl2)) ;
PNTVECTOR vPtCtrl3 = { ptTop1s[z], ptTop2s[z], ptTop1e[z], ptTop2e[z]} ;
vvPtCtrl.push_back( move( vPtCtrl3)) ;
PNTVECTOR vPtCtrl4 = { ptBottom1s[z], ptBottom2s[z], ptTop1s[z], ptTop2s[z]} ;
vvPtCtrl.push_back( move( vPtCtrl4)) ;
PNTVECTOR vPtCtrl5 = { ptBottom2e[z], ptBottom1e[z], ptTop2e[z], ptTop1e[z]} ;
vvPtCtrl.push_back( move( vPtCtrl5)) ;
// per ognuna delle 6 superfici bilineari
ISURFBEZPOVECTOR vSurfBez ;
//VCT3DVECTOR a ;
//VCT3DVECTOR b ;
//VCT3DVECTOR c ;
PNTVECTOR d ;
Vector3d q = Z_AX ;
DBLVECTOR A1, B1, C1, A2, B2, C2 ;
for( int s = 0 ; s < 6 ; ++s) {
// inzializzo la superficie
vSurfBez.emplace_back( CreateSurfBezier()) ;
vSurfBez.back()->Init(nDegU, nDegV, nSpanU, nSpanV, bRat) ;
vSurfBez.back()->SetControlPoint( 0, vvPtCtrl[s][0]) ;
vSurfBez.back()->SetControlPoint( 1, vvPtCtrl[s][1]) ;
vSurfBez.back()->SetControlPoint( 2, vvPtCtrl[s][2]) ;
vSurfBez.back()->SetControlPoint( 3, vvPtCtrl[s][3]) ;
// salvo i parametri per il calcolo delle intersezioni
//a.push_back( vvPtCtrl[s][3] - vvPtCtrl[s][1] + ( vvPtCtrl[s][0] - vvPtCtrl[s][2])) ;
//b.push_back( vvPtCtrl[s][1] - vvPtCtrl[s][0]) ;
//c.push_back( vvPtCtrl[s][2] - vvPtCtrl[s][0]) ;
Vector3d a = vvPtCtrl[s][3] - vvPtCtrl[s][1] + ( vvPtCtrl[s][0] - vvPtCtrl[s][2]) ;
Vector3d b = vvPtCtrl[s][1] - vvPtCtrl[s][0] ;
Vector3d c = vvPtCtrl[s][2] - vvPtCtrl[s][0] ;
d.push_back( vvPtCtrl[s][0]) ;
A1.push_back( a.x * q.z - a.z * q.x) ;
B1.push_back( b.x * q.z - b.z * q.x) ;
C1.push_back( c.x * q.z - c.z * q.x) ;
A2.push_back( a.y * q.z - a.z * q.y) ;
B2.push_back( b.y * q.z - b.z * q.y) ;
C2.push_back( c.y * q.z - c.z * q.y) ;
}
// scorro tutti gli spilloni interessati
for ( int i = nStartI ; i <= nEndI ; ++ i) {
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
Point3d r( dX, dY, 0) ;
Point3d ptMin, ptMax ;
double dMin = INFINITO, dMax = -10 ;
Vector3d vtMin, vtMax ;
for( int s = 0 ; s < 6 ; ++s) {
// di queste variabili probabilmente posso portare fuori dai for nested tutte quelle che non dipendono da r ed esplicitare già qx = 0, qy= 0 , qz = 1
//double A1 = a[s].x * q.z - a[s].z * q.x ;
//double B1 = b[s].x * q.z - b[s].z * q.x ;
//double C1 = c[s].x * q.z - c[s].z * q.x ;
double D1 = ( d[s].x - r.x) * q.z - ( d[s].z - r.z) * q.x ;
//double A2 = a[s].y * q.z - a[s].z * q.y ;
//double B2 = b[s].y * q.z - b[s].z * q.y ;
//double C2 = c[s].y * q.z - c[s].z * q.y ;
double D2 = ( d[s].y - r.y) * q.z - ( d[s].z - r.z) * q.y ;
DBLVECTOR vdCoeff, vdRoots ;
vdCoeff = { (B2[s] * D1 - B1[s] * D2), ( A2[s] * D1 - A1[s] * D2 + B2[s] * C1[s] - B1[s] * C2[s]), ( A2[s] * C1[s] - A1[s] * C2[s])} ;
int nRoots = PolynomialRoots( 2, vdCoeff, vdRoots) ;
if ( nRoots != 0) {
double dU1 = 0, dV1 = 0 ;
double dU2 = 0, dV2 = 0 ;
if ( vdRoots[0] > 0 - EPS_ZERO && vdRoots[0] < 1 + EPS_ZERO) {
dV1 = vdRoots[0] ;
dU1 = (dV1 * (C1[s] - C2[s]) + ( D1 - D2)) / ( dV1 * ( A2[s] - A1[s]) + ( B2[s] - B1[s])) ;
if ( dU1 > - EPS_ZERO && dU1 < 1 + EPS_ZERO) {
Point3d ptBez1 ;
Vector3d vtN1 ;
vSurfBez[s]->GetPointNrmD1D2(dU1, dV1, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptBez1, vtN1) ;
UpdateMaxMin( ptBez1, vtN1, dMin, dMax, ptMin, ptMax, vtMin, vtMax) ;
}
}
if ( nRoots > 1 && vdRoots[1] > 0 - EPS_ZERO && vdRoots[1] < 1 + EPS_ZERO) {
dV2 = vdRoots[1] ;
dU2 = (dV2 * (C1[s] - C2[s]) + ( D1 - D2)) / ( dV2 * ( A2[s] - A1[s]) + ( B2[s] - B1[s])) ;
if ( dU2 > - EPS_ZERO && dU2 < 1 + EPS_ZERO) {
Point3d ptBez2 ;
Vector3d vtN2 ;
vSurfBez[s]->GetPointNrmD1D2(dU2, dV2, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptBez2, vtN2) ;
UpdateMaxMin( ptBez2, vtN2, dMin, dMax, ptMin, ptMax, vtMin, vtMax) ;
}
}
}
}
if ( dMax > 0 && dMin < dMax)
SubtractIntervals( z, i, j, dMin, dMax, vtMin, vtMax, CurrTool.GetToolNum()) ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
@@ -914,27 +1157,58 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co
double dAlongAngDeg, dAcrossAngDeg ;
GetAlongAcrossRotation( vtDs, vtDe, ptPe - ptPs, dAlongAngDeg, dAcrossAngDeg) ;
// Divido il movimento in tratti con direzione utensile costante
const double ANG_ACROSS_STEP = 0.04 ;
const double ANG_ACROSS_STEP = 4 ;
const double ANG_ALONG_STEP = 1.0 ;
int nStepCnt = int( max( { abs( dAlongAngDeg) / ANG_ALONG_STEP, abs( dAcrossAngDeg) / ANG_ACROSS_STEP, 1.})) ;
bool bOk = true ;
Point3d ptSt = ptPs ;
// valori allo step i-esimo
Point3d ptSt = ptPs ; ///////////////////// commentato per debug
Point3d ptSti = ptPs ;
Vector3d vtDSi = vtDs ;
double dCorr = 0.05 * 1. / nStepCnt ; // creo una sovrapposizone tra uno step e il successivo
for ( int i = 0 ; i <= nStepCnt && bOk ; ++ i) {
double dPosCoeff, dDirCoeff ;
if ( i < nStepCnt) {
dPosCoeff = ( i + 0.5) / nStepCnt ;
dDirCoeff = double( i) / nStepCnt ;
}
else {
dPosCoeff = 1 ;
dDirCoeff = 1 ;
}
Point3d ptEn = Media( ptPs, ptPe, dPosCoeff) ;
Vector3d vtD = Media( vtDs, vtDe, dDirCoeff) ; vtD.Normalize() ;
Vector3d vtA = Media( vtAs, vtAe, dDirCoeff) ; vtA.Normalize() ;
bOk = bOk && MillingTranslationStep( ptSt, ptEn, vtD, vtA) ;
// aggiorno prossimo inizio
ptSt = ptEn ;
//////////////////////////////////////////////// commentato per debug
// double dPosCoeff, dDirCoeff ;
// if ( i < nStepCnt) {
// dPosCoeff = ( i + 0.5) / nStepCnt ;
// dDirCoeff = double( i) / nStepCnt ;
// }
// else {
// dPosCoeff = 1 ;
// dDirCoeff = 1 ;
// }
// Point3d ptEn = Media( ptPs, ptPe, dPosCoeff) ;
// Vector3d vtD = Media( vtDs, vtDe, dDirCoeff) ; vtD.Normalize() ;
// Vector3d vtA = Media( vtAs, vtAe, dDirCoeff) ; vtA.Normalize() ;
// bOk = bOk && MillingTranslationStep( ptSt, ptEn, vtD, vtA) ;
//// aggiorno prossimo inizio
// ptSt = ptEn ;
//// replico il tutto ma tenendo degli step più ampi e usando i veri vettori di start e end del tratto
double dPosCoeffE, dDirCoeffE, dPosCoeffS, dDirCoeffS ;
dPosCoeffS = double( i) / (nStepCnt + 1) ;
dDirCoeffS = double( i) / (nStepCnt + 1) ;
dPosCoeffE = double( i + 1) / (nStepCnt + 1) ;
dDirCoeffE = double( i + 1) / (nStepCnt + 1) ;
if ( i != 0)
ptSti = Media( ptPs, ptPe, dPosCoeffS - dCorr) ;
Point3d ptEni = Media( ptPs, ptPe, i != nStepCnt ? dPosCoeffE : (dPosCoeffE + dCorr)) ;
if ( i != 0)
vtDSi = Media( vtDs, vtDe, dDirCoeffS - dCorr) ; vtDSi.Normalize() ;
Vector3d vtDEi = Media( vtDs, vtDe, i != nStepCnt ? dDirCoeffE : (dPosCoeffE + dCorr)) ; vtDEi.Normalize() ;
int nPhase = VolZmap::MillingPhase::ONLY_LATERAL_SURF ;
if ( i == 0)
nPhase = VolZmap::MillingPhase::COUNT_START_CYL ;
if ( i == nStepCnt)
nPhase = VolZmap::MillingPhase::COUNT_END_CYL ;
bOk = bOk && SelectGeneralMotion( ptSti, ptEni, vtDSi, vtDEi,nPhase) ;
}
return bOk ;
}
@@ -948,14 +1222,15 @@ VolZmap::MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const
Vector3d vtLs[N_MAPS] ;
Vector3d vtALs[N_MAPS] ;
InitializePointsAndVectors( ptPs, ptPe, vtD, vtA, ptLs, ptLe, vtLs, vtALs) ;
// Ciclo sulle mappe (scommentare solo per DEBUG)
//{
// bool bOk = true ;
// for ( int i = 0 ; i < m_nMapNum ; ++ i) {
// bOk = SelectMotion( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) && bOk ;
// }
// return true ;
//}
//// Ciclo sulle mappe (scommentare solo per DEBUG)
// {
// bool bOk = true ;
// for ( int i = 0 ; i < m_nMapNum ; ++ i) {
// bOk = SelectMotion( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) && bOk ;
// }
// return true ;
// }
// Ciclo sulle mappe
vector< future<bool>> vRes ;
vRes.resize( m_nMapNum) ;
@@ -2092,7 +2367,7 @@ VolZmap::GenTool_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
return false ;
Tool& CurrTool = m_vTool[m_nCurrTool] ;
// Descrizione geometrica del moto
// Descrizione geometrica del moto
Point3d ptI = ptS ;
Point3d ptF = ptE ;
Vector3d vtMove = ptE - ptS ;
@@ -3653,7 +3928,7 @@ VolZmap::CompCyl_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
{
// Verifica sull'interferenza con lo Zmap
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, V_NULL, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Proiezione dei punti sul piano
@@ -3698,7 +3973,7 @@ VolZmap::CompConus_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& ptE,
{
// Verifica sull'interferenza con lo Zmap
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, V_NULL, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
Point3d ptO( ptS.x, ptS.y, 0) ;
@@ -3858,7 +4133,7 @@ VolZmap::CompCyl_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, co
{
// Verifica sull'interferenza con lo Zmap
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, V_NULL, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Parametri geometrici
@@ -3871,8 +4146,8 @@ VolZmap::CompCyl_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, co
Point3d ptFT = ptF - vtToolDir * dHei ;
Point3d ptIxy( ptI.x, ptI.y, 0) ;
Point3d ptIUp( ptI.x, ptI.y, max( ptI.z, ptIT.z)) ;
Point3d ptIDw( ptI.x, ptI.y, min( ptI.z, ptIT.z)) ;
//Point3d ptIUp( ptI.x, ptI.y, max( ptI.z, ptIT.z)) ;
//Point3d ptIDw( ptI.x, ptI.y, min( ptI.z, ptIT.z)) ;
// Quote iniziali e finali massime e
// minime del gambo dell'utensile e DeltaZ
@@ -3919,7 +4194,7 @@ VolZmap::CompCyl_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, co
double dX1 = vtC * vtV1 ;
double dX2 = vtC * vtV2 ;
Point3d ptInt ;
//Point3d ptInt ;
// Se il punto appartiene alla proiezione del volume spazzato valuto massimo e minimo
if ( ( dX1 > 0 && dX1 < dLenXY && abs( dX2) < dSafeRad) ||
@@ -3978,7 +4253,7 @@ VolZmap::CompConus_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE,
const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum)
{
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, V_NULL, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ;
@@ -4390,7 +4665,7 @@ VolZmap::CompCyl_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, co
{
// Verifico che il cilindro con il suo movimento intersechi la griglia
int nStartI, nEndI, nStartJ, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, V_NULL, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Studio delle simmetrie
@@ -4423,7 +4698,7 @@ VolZmap::CompConus_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE,
const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum)
{
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, V_NULL, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Apertura del cono
@@ -4544,7 +4819,7 @@ VolZmap::CompCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE,
{
// Verifica sull'interferenza utensile Zmap
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, V_NULL, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Studio delle simmetrie
@@ -4678,7 +4953,7 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
{
// Verifico interferenza
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, V_NULL, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Geometria del cono
@@ -5155,7 +5430,7 @@ VolZmap::CompBall_Milling( int nGrid, const Point3d& ptLs, const Point3d& ptLe,
{
// Verifico interferisca
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptLs, ptLe, V_NULL, dRad, 0, 0, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptLs, ptLe, V_NULL, V_NULL, dRad, 0, 0, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Vettore modivemnto
Vector3d vtV = ptLe - ptLs ;
@@ -5330,7 +5605,7 @@ VolZmap::AddingCylinder( int nGrid, const Point3d& ptS, const Point3d& ptE, cons
// Verifica sull'interferenza utensile Zmap
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, V_NULL, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
Vector3d vtV1 = ptE - ptS ;
@@ -5384,7 +5659,7 @@ VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE,
// Verifico interferenza
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, V_NULL, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Geometria del cono
@@ -5706,7 +5981,7 @@ VolZmap::AddingSphere( int nGrid, const Point3d& ptS, const Point3d& ptE, double
// Verifico interferisca
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, V_NULL, dRad, 0, 0, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, V_NULL, V_NULL, dRad, 0, 0, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Vettore movimento
Vector3d vtV = ptE - ptS ;
@@ -5796,6 +6071,59 @@ GetCylMoveBBox( const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, d
return b3Box ;
}
//----------------------------------------------------------------------------
inline BBox3d
GetCylMoveRotBBox( const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV1, const Vector3d& vtV2, double dRad, double dH)
{
// Determinazione dei punti più laterali del tool, rispetto alla direzione di movimento
// per la testa e per la punta del tool
Point3d ptP1T = ptP1 - dH * vtV1 ;
Point3d ptP2T = ptP2 - dH * vtV2 ;
Vector3d vtDirTop = ptP2 - ptP1 ;
Vector3d vtDirTip = ptP2T - ptP1T ;
// determino i punti laterali del top e del bottom(tip), nella posizione di partenza
Vector3d vtAuxTopS = vtV1 ^ vtDirTop ;
vtAuxTopS.Normalize() ;
vtAuxTopS *= dRad ;
Point3d ptPTop1 = ptP1 + vtAuxTopS ;
Point3d ptPTop2 = ptP1 - vtAuxTopS ;
Vector3d vtAuxBottomS = vtV1 ^ vtDirTip ;
vtAuxBottomS.Normalize() ;
vtAuxBottomS *= dRad ;
Point3d ptPBottom1 = ptP1T + vtAuxBottomS ;
Point3d ptPBottom2 = ptP1T - vtAuxBottomS ;
// determino i punti laterali del top e del bottom(tip), nella posizione di arrivo
Vector3d vtAuxTopE = vtV2 ^ vtDirTop ;
vtAuxTopE.Normalize() ;
vtAuxTopE *= dRad ;
Point3d ptPTop3 = ptP2 + vtAuxTopE ;
Point3d ptPTop4 = ptP2 - vtAuxTopE ;
Vector3d vtAuxBottomE = vtV2 ^ vtDirTip ;
vtAuxBottomE.Normalize() ;
vtAuxBottomE *= dRad ;
Point3d ptPBottom3 = ptP2T + vtAuxBottomE ;
Point3d ptPBottom4 = ptP2T - vtAuxBottomE ;
// Calcolo del box del volume spazzato dal tool
BBox3d b3Box ;
b3Box.Add( ptPTop1) ;
b3Box.Add( ptPTop2) ;
b3Box.Add( ptPBottom1) ;
b3Box.Add( ptPBottom2) ;
b3Box.Add( ptPTop3) ;
b3Box.Add( ptPTop4) ;
b3Box.Add( ptPBottom3) ;
b3Box.Add( ptPBottom4) ;
// Restituisco il box calcolato
return b3Box ;
}
//----------------------------------------------------------------------------
inline BBox3d
GetSphereMoveBBox( const Point3d& ptP1, const Point3d& ptP2, double dRad)
@@ -5820,13 +6148,13 @@ VolZmap::TestToolBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, cons
return false ;
Tool& CurrTool = m_vTool[m_nCurrTool] ;
return TestCompoBBox( nGrid, ptP1, ptP2, vtV, CurrTool.GetRadius(), CurrTool.GetTipRadius(), CurrTool.GetHeigth(),
return TestCompoBBox( nGrid, ptP1, ptP2, vtV, V_NULL, CurrTool.GetRadius(), CurrTool.GetTipRadius(), CurrTool.GetHeigth(),
nStI, nStJ, nEnI, nEnJ) ;
}
//----------------------------------------------------------------------------
inline bool
VolZmap::TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV,
VolZmap::TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, const Vector3d& vtV2,
double dRad, double dTipRad, double dHei,
int& nStI, int& nStJ, int& nEnI, int& nEnJ)
{
@@ -5841,7 +6169,13 @@ VolZmap::TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, con
// BBox dell'utensile nel suo movimento
double dMaxRad = max( dRad, dTipRad) ;
BBox3d b3Box = ( vtV.IsSmall() ? GetSphereMoveBBox( ptP1, ptP2, dRad) : GetCylMoveBBox( ptP1, ptP2, vtV, dMaxRad, dHei)) ;
BBox3d b3Box ;
if ( vtV.IsSmall())
b3Box = GetSphereMoveBBox( ptP1, ptP2, dRad) ;
else if( AreSameVectorExact(vtV2, V_NULL))
b3Box = GetCylMoveBBox( ptP1, ptP2, vtV, dMaxRad, dHei) ;
else
b3Box = GetCylMoveRotBBox( ptP1, ptP2, vtV, vtV2, dRad, dHei) ;
// Verifica dell'interferenza dell'utensile con lo Zmap
if ( ! b3Zmap.FindIntersection( b3Box, b3Box))