diff --git a/VolZmap.h b/VolZmap.h index c7fcb86..2be989f 100644 --- a/VolZmap.h +++ b/VolZmap.h @@ -258,9 +258,12 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtD, const Vector3d& vtA) ; bool MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs, const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) ; + bool SelectGeneralMotion( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtDs, const Vector3d& vtDe, const int nPhase = VolZmap::MillingPhase::ONLY_LATERAL_SURF) ; bool SelectMotion( int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtL, const Vector3d& vtAL) ; bool InitializePointsAndVectors( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtDs, const Vector3d& vtAs, Point3d ptLs[3], Point3d ptLe[3], Vector3d vtLs[3], Vector3d vtALs[3]) ; + bool 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]) ; // SOTTRAZIONI // UTENSILI // Asse di simmetria parallelo a Z @@ -341,7 +344,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW // BBox per utensili e solidi semplici con movimenti di traslazione inline bool TestToolBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, int& nStI, int& nStJ, int& nEnI, int& nEnJ) ; - inline bool TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, + inline bool 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) ; inline bool TestParaBBox( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtD, const Vector3d& vtA, @@ -432,6 +435,13 @@ class VolZmap : public IVolZmap, public IGeoObjRW const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM) ; bool AddMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig, const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM) ; + public : + // ------------------------- ENUM ---------------------------------------------------------------- + enum MillingPhase { + COUNT_START_CYL = 0 , + ONLY_LATERAL_SURF = 1 , + COUNT_END_CYL = 2 + } ; private : enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ; diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index fd78d24..4cc2ed8 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -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 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 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 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> 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))