From 098bdd00767a8f6a3157f6a0bc92b74c7deada4c Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Wed, 24 Sep 2025 10:29:57 +0200 Subject: [PATCH] EgtGeomKernel : - semplificazione VM5assi. --- VolZmap.h | 22 +- VolZmapVolume.cpp | 1205 +++++++++++++++++++++------------------------ 2 files changed, 569 insertions(+), 658 deletions(-) diff --git a/VolZmap.h b/VolZmap.h index 064c388..146c9af 100644 --- a/VolZmap.h +++ b/VolZmap.h @@ -268,7 +268,7 @@ 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( int nGrid, const PNTVECTOR& ptPs, const PNTVECTOR& ptPe, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int n5AxisType) ; + bool SelectGeneralMotion( int nGrid, const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtLs, const Vector3d& vtLe, int n5AxisType) ; 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]) ; @@ -307,10 +307,10 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool GenTool_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; bool GenTool_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; // lavorazioni a 5 assi - bool GenTool_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType = ACROSS) ; - bool Cyl_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, double dHeightCorr = 0, int n5AxisType = ACROSS) ; - bool CylBall_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType = ACROSS) ; - bool Conus_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType = ACROSS) ; + bool GenTool_5AxisMilling(int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, int n5AxisType = ACROSS) ; + bool Cyl_5AxisMilling(int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, double dHeightCorr = 0, int n5AxisType = ACROSS) ; + bool CylBall_5AxisMilling(int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, int n5AxisType = ACROSS) ; + bool Conus_5AxisMilling(int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, int n5AxisType = ACROSS) ; // COMPONENTI // Asse di simmetria diretto come l'asse Z @@ -346,13 +346,13 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool CompPar_Milling( int nGrid, double dLenX, double dLenY, double dLenZ, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux, int nToolNum) ; // E' in realtà MillingPerp - // lavorazioni a 5 assi - bool Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, + // lavorazioni a 5 assi + bool Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, double dHeight, double dMaxRad, double dMinRad, int nToolNum, int n5AxisType) ; - bool CompCyl_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, - double dHeight, double dRadius, int nToolNum,int n5AxisType) ; - bool CompConus_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtToolDirS, const VCT3DVECTOR& vtToolDirE, double dHei, double dMaxRad, double dMinRad, - bool bTapB, bool bTapT,const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum, int n5AxisType) ; + bool CompCyl_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, + double dHeight, double dRadius, int nToolNum, int n5AxisType) ; + bool CompConus_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDirS, const Vector3d& vtToolDirE, double dHei, double dMaxRad, double dMinRad, + bool bTapB, bool bTapT, const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum, int n5AxisType) ; // Generica traslazione sfera bool CompBall_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, double dRad, int nToolNum) ; diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 5a86031..37962a6 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -26,6 +26,7 @@ #include "/EgtDev/Include/EGkSurfBezier.h" #include "/EgtDev/Include/ENkPolynomialRoots.h" #include "/EgtDev/Include/EGkIntersLineBox.h" +#include "/EgtDev/Include/EGkGeoObjSave.h" #include "SurfBezier.h" #include #include @@ -1173,19 +1174,17 @@ VolZmap::InitializeAuxPoints( Point3d ptTop1s[3], Point3d ptTop1e[3], Point3d pt //---------------------------------------------------------------------------- bool -VolZmap::GenTool_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, - const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType) +VolZmap::GenTool_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, + const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, int n5AxisType) { // Controllo utensile if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) return false ; Tool& CurrTool = m_vTool[m_nCurrTool] ; - int nStepCnt = ptS.size() ; - // Descrizione geometrica del moto - PNTVECTOR ptI = ptS ; - PNTVECTOR ptF = ptE ; + Point3d ptI = ptS ; + Point3d ptF = ptE ; // Vettore delle normali agli archi const VCT3DVECTOR& vArcNorm = CurrTool.GetArcNormalVec() ; // Poiché l'asse utensile è parallelo all'asse Z, definisco un sistema di @@ -1256,20 +1255,12 @@ VolZmap::GenTool_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& else { double dMaxRad = ptEnd.x ; double dMinRad = ptStart.x ; - PNTVECTOR ptIn( ptI.size()) ; - PNTVECTOR ptFn( ptF.size()) ; - for ( int i = 0 ; i < int( ptI.size()) ; ++i) { - ptIn[i] = ptI[i] - vtLs[i] * dHeight ; - ptFn[i] = ptF[i] - vtLe[i] * dHeight ; - } - vtNormEn.z = -vtNormEn.z ; - vtNormSt.z = -vtNormSt.z ; - VCT3DVECTOR vNewVtLs( vtLs.size()) ; - VCT3DVECTOR vNewVtLe( vtLe.size()) ; - for ( int i = 0 ; i < int( vtLs.size()) ; ++i) { - vNewVtLs[i] = -vtLs[i] ; - vNewVtLe[i] = -vtLe[i] ; - } + Point3d ptIn = ptI - vtLs * dHeight; + Point3d ptFn = ptF - vtLe * dHeight; + vtNormEn.z = - vtNormEn.z ; + vtNormSt.z = - vtNormSt.z ; + Vector3d vNewVtLs = - vtLs ; + Vector3d vNewVtLe = - vtLe ; CompConus_5AxisMilling( nGrid, ptIn, ptFn, vNewVtLs, vNewVtLe, dHeight, dMaxRad, dMinRad, bTapT, bTapB, vtNormEn, vtNormSt, nToolNum, n5AxisType) ; } @@ -1293,8 +1284,8 @@ VolZmap::GenTool_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& Point3d ptCen = pArc->GetCenter() ; double dRadius = pArc->GetRadius() ; // Determino le posizioni iniziale e finale del centro della sfera - Point3d ptCenS = ptI.front() - vtLs.front() * ( ptStart.y - ptCen.y ) ; - Point3d ptCenE = ptF.back() - vtLe.back() * ( ptStart.y - ptCen.y ) ; + Point3d ptCenS = ptI - vtLs * ( ptStart.y - ptCen.y ) ; + Point3d ptCenE = ptF - vtLe * ( ptStart.y - ptCen.y ) ; // Eseguo l'asportazione del materiale CompBall_Milling( nGrid, ptCenS, ptCenE, dRadius, nToolNum) ; // aggiorno l'altezza @@ -1306,10 +1297,8 @@ VolZmap::GenTool_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& // Determino le posizioni iniziale e finale del componente successivo dCumHeight += dHeight ; - for ( int j = 0 ; j < nStepCnt ; ++j) { - ptI[j] = ptS[j] - vtLs[j] * dCumHeight ; - ptF[j] = ptE[j] - vtLe[j] * dCumHeight ; - } + ptI = ptS - vtLs * dCumHeight ; + ptF = ptE - vtLe * dCumHeight ; } return true ; @@ -1608,532 +1597,493 @@ Reiterate : return true ; } +#if true + #define TEST +#endif + //---------------------------------------------------------------------------- bool -VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, +VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, double dHeight, double dMaxRad, double dMinRad, int nToolNum, int n5AxisType) { - // tolgo il volume spazzato dal tool durante il movimento - // Verifica sull'interferenza con lo Zmap - int nStartI, nStartJ, nEndI, nEndJ ; - if ( ! TestCompoBBox( nGrid, ptS[0], ptE.back(), vtLs[0], vtLe.back(), dMaxRad, dMinRad, dHeight, nStartI, nStartJ, nEndI, nEndJ) ) - return true ; + // tolgo il volume spazzato dal tool durante il movimento + // Verifica sull'interferenza con lo Zmap + int nStartI, nStartJ, nEndI, nEndJ ; + if ( ! TestCompoBBox( nGrid, ptS, ptE, vtLs, vtLe, dMaxRad, dMinRad, dHeight, nStartI, nStartJ, nEndI, nEndJ)) + return true ; - int nStepCnt = int( ptS.size()) ; - // vettori di riferimento per trovare i punti ausiliari + // vettori di riferimento per trovare i punti ausiliari - int nDegU = 3 ; int nDegV = 1 ; - int nSpanU = 1 ; int nSpanV = 1 ; - bool bRat = false ; + int nDegU = 3 ; int nDegV = 1 ; + int nSpanU = 1 ; int nSpanV = 1 ; + bool bRat = false ; - int nSub = 2 ; // numero di bezier di grado 3x1 con cui approssimare il (quasi) semi-cilindro ellissoide che descrive il volume della punta e della cima del tool - PNTVECTOR d ; - Vector3d q = Z_AX ; - - int nTotSurf = 4 ; - if ( n5AxisType == Move5Axis::NO_BASE_INTERS) - nTotSurf = 2 * nStepCnt + nSub * 2 * nStepCnt + nSub * 2 + 8 ; // sup laterali, sup superiori e inferiori, superfici verticali di inizio e fine, superfici di base dei tool - else if( n5AxisType == Move5Axis::ACROSS) - nTotSurf = 2 * nStepCnt + nSub * 4 * nStepCnt + nSub * 2 + 16 ; // come sopra + int nSub = 2 ; // numero di bezier di grado 3x1 con cui approssimare il (quasi) semi-cilindro ellissoide che descrive il volume della punta e della cima del tool + PNTVECTOR d ; + Vector3d q = Z_AX ; - int nSurfInd = 0 ; - vector vSurfBez( nTotSurf) ; - double dSide = 0 ; - // punti per le bilineari, sulle posizioni del tool alle estremità del movimento - PNTVECTOR vPntTipStartExF ; - PNTVECTOR vPntTipEndExF ; - PNTVECTOR vPntTopStartExF ; - PNTVECTOR vPntTopEndExF ; - PNTVECTOR vPntTipStartExB ; - PNTVECTOR vPntTipEndExB ; - PNTVECTOR vPntTopStartExB ; - PNTVECTOR vPntTopEndExB ; - Point3d ptP1TEx, ptP2TEx ; + int nTotSurf = 4 ; + if ( n5AxisType == Move5Axis::NO_BASE_INTERS) + nTotSurf = 2 + nSub * 2 + nSub * 2 + 8 ; // sup laterali, sup superiori e inferiori, superfici verticali di inizio e fine, superfici di base dei tool + else if ( n5AxisType == Move5Axis::ACROSS) + nTotSurf = 2 + nSub * 4 + nSub * 2 + 16 ; // come sopra - for ( int s = 0 ; s < nStepCnt ; ++s) { - // punti di riferimento sul tool - Point3d ptTop1s ; - Point3d ptTop1e ; - Point3d ptTop2s ; - Point3d ptTop2e ; - Point3d ptBottom1s ; - Point3d ptBottom1e ; - Point3d ptBottom2s ; - Point3d ptBottom2e ; - // tip del tool - Point3d ptP1T ; - Point3d ptP2T ; - // determino la posizione della punta del tool nella posizione iniziale e in quella finale - ptP1T = ptS[s] - dHeight * vtLs[s] ; - ptP2T = ptE[s] - dHeight * vtLe[s] ; - // determino la direzione di movimento del top del tool e della punta del tool - Vector3d vtDirTop = ptE[s] - ptS[s] ; - Vector3d vtDirTip = ptP2T - ptP1T ; + int nSurfInd = 0 ; + vector vSurfBez( nTotSurf) ; + double dSide = 0 ; - // determino i punti laterali del top e del bottom(tip), nella posizione di partenza - Vector3d vtAuxTopS = vtLs[s] ^ vtDirTop ; - vtAuxTopS.Normalize() ; - vtAuxTopS *= dMaxRad ; - ptTop1s = ptS[s] + vtAuxTopS ; - ptTop2s = ptS[s] - vtAuxTopS ; + // punti di riferimento sul tool + // tip del tool + Point3d ptP1T ; + Point3d ptP2T ; + // determino la posizione della punta del tool nella posizione iniziale e in quella finale + ptP1T = ptS - dHeight * vtLs ; + ptP2T = ptE - dHeight * vtLe ; + // determino la direzione di movimento del top del tool e della punta del tool + Vector3d vtDirTop = ptE - ptS ; + Vector3d vtDirTip = ptP2T - ptP1T ; - Vector3d vtAuxBottomS = vtLs[s] ^ vtDirTip ; - vtAuxBottomS.Normalize() ; - vtAuxBottomS *= dMinRad ; - ptBottom1s = ptP1T + vtAuxBottomS ; - ptBottom2s = ptP1T - vtAuxBottomS ; - - // determino i punti laterali del top e del bottom(tip), nella posizione di arrivo - Vector3d vtAuxTopE = vtLe[s] ^ vtDirTop ; - vtAuxTopE.Normalize() ; - vtAuxTopE *= dMaxRad ; - ptTop1e = ptE[s] + vtAuxTopE ; - ptTop2e = ptE[s] - vtAuxTopE ; - - Vector3d vtAuxBottomE = vtLe[s] ^ vtDirTip ; - vtAuxBottomE.Normalize() ; - vtAuxBottomE *= dMinRad ; - ptBottom1e = ptP2T + vtAuxBottomE ; - ptBottom2e = ptP2T - vtAuxBottomE ; - - // punti sul top e tip del tool che servono per costruire le bilineare di congiunzione tra step - PNTVECTOR vPntTipStartFront ; - PNTVECTOR vPntTipEndFront ; - PNTVECTOR vPntTopStartFront ; - PNTVECTOR vPntTopEndFront ; - // punti addizionali che servono nei casi che rischiedono più superfici bilineari ( tutti tranne NO_BASE_INTERS) - PNTVECTOR vPntTipStartBack ; - PNTVECTOR vPntTipEndBack ; - PNTVECTOR vPntTopStartBack ; - PNTVECTOR vPntTopEndBack ; - if ( nSub > 1) { + // punti sul top e tip del tool che servono per costruire le bilineare di congiunzione tra step + PNTVECTOR vPntTipStartFront(3) ; + PNTVECTOR vPntTipEndFront(3) ; + PNTVECTOR vPntTopStartFront(3) ; + PNTVECTOR vPntTopEndFront(3) ; + // punti addizionali che servono nei casi che rischiedono più superfici bilineari ( tutti tranne NO_BASE_INTERS) + PNTVECTOR vPntTipStartBack(3) ; + PNTVECTOR vPntTipEndBack(3) ; + PNTVECTOR vPntTopStartBack(3) ; + PNTVECTOR vPntTopEndBack(3) ; + if ( nSub > 1) { // determino in che modo collegare il cilindro iniziale con quello finale - Vector3d vtTopBaseEnd = vtDirTop - ( (vtDirTop * vtLe[s]) * vtLe[s]) ; - vtTopBaseEnd.Normalize() ; - vtTopBaseEnd *= dMaxRad ; - Point3d ptRefEnd = ptE[s] - vtTopBaseEnd ; - Vector3d vtTopBaseStart = vtDirTop - ( ( vtDirTop * vtLs[s]) * vtLs[s]) ; - vtTopBaseStart.Normalize() ; - vtTopBaseStart *= dMaxRad ; - Point3d ptRefStart = ptS[s] + vtTopBaseStart ; - dSide = (ptRefEnd - ptRefStart) * vtLs[s] ; + Vector3d vtTopBaseEnd = vtDirTop - (( vtDirTop * vtLe) * vtLe) ; + vtTopBaseEnd.Normalize() ; + vtTopBaseEnd *= dMaxRad ; + Point3d ptRefEnd = ptE - vtTopBaseEnd ; + Vector3d vtTopBaseStart = vtDirTop - (( vtDirTop * vtLs) * vtLs) ; + vtTopBaseStart.Normalize() ; + vtTopBaseStart *= dMaxRad ; + Point3d ptRefStart = ptS + vtTopBaseStart ; + dSide = ( ptRefEnd - ptRefStart) * vtLs ; // calcolo anche i vettori per le basi inferiori - Vector3d vtTipBaseStart = - (vtLs[s] ^ vtDirTip) ; - vtTipBaseStart.Normalize() ; - vtTipBaseStart *= dMinRad ; - Vector3d vtTipBaseEnd = - (vtLe[s] ^ vtDirTip) ; - vtTipBaseEnd.Normalize() ; - vtTipBaseEnd *= dMinRad ; + Vector3d vtTipBaseStart = -( vtLs ^ vtDirTip) ; + vtTipBaseStart.Normalize() ; + vtTipBaseStart *= dMinRad ; + Vector3d vtTipBaseEnd = -( vtLe ^ vtDirTip) ; + vtTipBaseEnd.Normalize() ; + vtTipBaseEnd *= dMinRad ; // aggiungo il primo punto per ognuno dei gruppi - vtTopBaseStart.Rotate( vtLs[s], 90) ; - vtTopBaseEnd.Rotate( vtLe[s], 90) ; - vPntTopStartFront.emplace_back( ptS[s] - vtTopBaseStart) ; - vPntTopEndFront.emplace_back( ptE[s] - vtTopBaseEnd) ; - vPntTipStartFront.emplace_back( ptP1T + vtTipBaseStart) ; - vPntTipEndFront.emplace_back( ptP2T + vtTipBaseEnd) ; + vtTopBaseStart.Rotate( vtLs, 90) ; + vtTopBaseEnd.Rotate( vtLe, 90) ; + vPntTopStartFront[0] = ptS - vtTopBaseStart ; + vPntTopEndFront[0] = ptE - vtTopBaseEnd ; + vPntTipStartFront[0] = ptP1T + vtTipBaseStart ; + vPntTipEndFront[0] = ptP2T + vtTipBaseEnd ; // punti addizionali per superfici bilineari - vPntTopStartBack.emplace_back( ptS[s] + vtTopBaseStart) ; - vPntTopEndBack.emplace_back( ptE[s] + vtTopBaseEnd) ; - vPntTipStartBack.emplace_back( ptP1T - vtTipBaseStart) ; - vPntTipEndBack.emplace_back( ptP2T - vtTipBaseEnd) ; - double dSubAng = 90 ; + vPntTopStartBack[0] = ptS + vtTopBaseStart ; + vPntTopEndBack[0] = ptE + vtTopBaseEnd ; + vPntTipStartBack[0] = ptP1T - vtTipBaseStart ; + vPntTipEndBack[0] = ptP2T - vtTipBaseEnd ; + double dSubAng = 90; // girano tutti in verso CCW rispetto alla normale del tool - for ( int i = 0 ; i < 2 ; ++i) { - // punti sulla base superiore dei cilindri - // start - // frontale - vPntTopStartFront.emplace_back( vPntTopStartFront.back()) ; - vPntTopStartFront.back().Rotate(ptS[s], vtLs[s], dSubAng) ; - // posteriore - vPntTopStartBack.emplace_back( vPntTopStartBack.back()) ; - vPntTopStartBack.back().Rotate(ptS[s], vtLs[s], dSubAng) ; - // end - // frontale - vPntTopEndFront.emplace_back( vPntTopEndFront.back()) ; - vPntTopEndFront.back().Rotate(ptE[s], vtLe[s], dSubAng) ; - // posteriore - vPntTopEndBack.emplace_back( vPntTopEndBack.back()) ; - vPntTopEndBack.back().Rotate(ptE[s], vtLe[s], dSubAng) ; + for ( int i = 1; i < 3; ++i) { + // punti sulla base superiore dei cilindri + // start + // frontale + vPntTopStartFront[i] = vPntTopStartFront[i - 1] ; + vPntTopStartFront[i].Rotate( ptS, vtLs, dSubAng) ; + // posteriore + vPntTopStartBack[i] = vPntTopStartBack[i - 1]; + vPntTopStartBack[i].Rotate( ptS, vtLs, dSubAng) ; + // end + // frontale + vPntTopEndFront[i] = vPntTopEndFront[i - 1] ; + vPntTopEndFront[i].Rotate( ptE, vtLe, dSubAng) ; + // posteriore + vPntTopEndBack[i] = vPntTopEndBack[i - 1] ; + vPntTopEndBack[i].Rotate( ptE, vtLe, dSubAng) ; - // punti sulla base inferiore dei cilindri - vPntTipStartFront.emplace_back( vPntTipStartFront.back()) ; - vPntTipStartFront.back().Rotate(ptP1T, vtLs[s], dSubAng) ; - vPntTipStartBack.emplace_back( vPntTipStartBack.back()) ; - vPntTipStartBack.back().Rotate(ptP1T, vtLs[s], dSubAng) ; + // punti sulla base inferiore dei cilindri + vPntTipStartFront[i] = vPntTipStartFront[i - 1] ; + vPntTipStartFront[i].Rotate( ptP1T, vtLs, dSubAng) ; + vPntTipStartBack[i] = vPntTipStartBack[i - 1] ; + vPntTipStartBack[i].Rotate( ptP1T, vtLs, dSubAng) ; - vPntTipEndFront.emplace_back( vPntTipEndFront.back()) ; - vPntTipEndFront.back().Rotate(ptP2T, vtLe[s], dSubAng) ; - vPntTipEndBack.emplace_back( vPntTipEndBack.back()) ; - vPntTipEndBack.back().Rotate(ptP2T, vtLe[s], dSubAng) ; - } - } - // mi salvo i punti ausiliari per la posizione iniziale e finale del tool - if ( s == 0) { - vPntTipStartExF = vPntTipStartFront ; - vPntTopStartExF = vPntTopStartFront ; - vPntTipStartExB = vPntTipStartBack ; - vPntTopStartExB = vPntTopStartBack ; - ptP1TEx = ptP1T ; - } - if ( s == nStepCnt - 1) { - vPntTipEndExF = vPntTipEndFront ; - vPntTopEndExF = vPntTopEndFront ; - vPntTipEndExB = vPntTipEndBack ; - vPntTopEndExB = vPntTopEndBack ; - ptP2TEx = ptP2T ; - } + vPntTipEndFront[i] = vPntTipEndFront[i - 1] ; + vPntTipEndFront[i].Rotate( ptP2T, vtLe, dSubAng) ; + vPntTipEndBack[i] = vPntTipEndBack[i - 1] ; + vPntTipEndBack[i].Rotate( ptP2T, vtLe, dSubAng) ; + } + } - vector vvPtCtrl ; - // superficie laterale sinistra - CurveLine cLineLeftStart ; cLineLeftStart.Set( ptBottom1s, ptTop1s) ; - PtrOwner cBezLeftStart( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftStart, nDegU, bRat))) ; - CurveLine cLineLeftEnd ; cLineLeftEnd.Set( ptBottom1e, ptTop1e) ; - PtrOwner cBezLeftEnd( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftEnd, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezLeftStart->GetAllControlPoints()) ; - PNTVECTOR vPntLeft = cBezLeftEnd->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntLeft.begin(), vPntLeft.end()) ; - // superficie laterale destra - CurveLine cLineRightStart ; cLineRightStart.Set( ptTop2s, ptBottom2s) ; - PtrOwner cBezRightStart( GetBasicCurveBezier( LineToBezierCurve( &cLineRightStart, nDegU, bRat))) ; - CurveLine cLineRightEnd ; cLineRightEnd.Set( ptTop2e, ptBottom2e) ; - PtrOwner cBezRightEnd( GetBasicCurveBezier( LineToBezierCurve( &cLineRightEnd, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezRightStart->GetAllControlPoints()) ; - PNTVECTOR vPntRight = cBezRightEnd->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntRight.begin(), vPntRight.end()) ; - if ( nSub == 1) { + vector vvPtCtrl ; + // superficie laterale sinistra + CurveLine cLineLeftStart ; cLineLeftStart.Set( vPntTipStartFront.back(), vPntTopStartFront.back()) ; + PtrOwner cBezLeftStart( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftStart, nDegU, bRat))) ; + CurveLine cLineLeftEnd ; cLineLeftEnd.Set( vPntTipEndFront.back(), vPntTopEndFront.back()) ; + PtrOwner cBezLeftEnd( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftEnd, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezLeftStart->GetAllControlPoints()) ; + PNTVECTOR vPntLeft = cBezLeftEnd->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntLeft.begin(), vPntLeft.end()) ; + // superficie laterale destra + CurveLine cLineRightStart ; cLineRightStart.Set( vPntTopStartFront.front(), vPntTipStartFront.front()) ; + PtrOwner cBezRightStart( GetBasicCurveBezier( LineToBezierCurve( &cLineRightStart, nDegU, bRat))) ; + CurveLine cLineRightEnd ; cLineRightEnd.Set( vPntTopEndFront.front(), vPntTipEndFront.front()) ; + PtrOwner cBezRightEnd( GetBasicCurveBezier( LineToBezierCurve( &cLineRightEnd, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezRightStart->GetAllControlPoints()) ; + PNTVECTOR vPntRight = cBezRightEnd->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntRight.begin(), vPntRight.end()) ; + if ( nSub == 1) { // superficie inferiore - vvPtCtrl.emplace_back( PNTVECTOR({ ptBottom2s, ptBottom1s, ptBottom2e, ptBottom1e})) ; + vvPtCtrl.emplace_back( PNTVECTOR( { vPntTipStartFront.front(), vPntTipStartFront.back(), vPntTipEndFront.front(), vPntTipEndFront.back() })) ; // superficie superiore - vvPtCtrl.emplace_back( PNTVECTOR({ ptTop1s, ptTop2s, ptTop1e, ptTop2e})) ; - } - else { - if ( n5AxisType == Move5Axis::NO_BASE_INTERS || n5AxisType == Move5Axis::ACROSS) { - // inferiori - CurveArc cArcTipStart1, cArcTipEnd1, cArcTipStart2,cArcTipEnd2 ; + vvPtCtrl.emplace_back( PNTVECTOR( { vPntTopStartFront.back(), vPntTopStartFront.front(), vPntTopEndFront.back(), vPntTopEndFront.front() })) ; + } + else { + if ( n5AxisType == Move5Axis::NO_BASE_INTERS || n5AxisType == Move5Axis::ACROSS) { + // inferiori + CurveArc cArcTipStart1, cArcTipEnd1, cArcTipStart2, cArcTipEnd2 ; if ( dSide > 0) { - cArcTipStart1.SetC2PN( ptP1T, vPntTipStartFront[0], vPntTipStartFront[1], vtLs[s]) ; - cArcTipEnd1.SetC2PN( ptP2T, vPntTipEndFront[0], vPntTipEndFront[1], vtLe[s]) ; - cArcTipStart2.SetC2PN( ptP1T, vPntTipStartFront[1], vPntTipStartFront[2], vtLs[s]) ; - cArcTipEnd2.SetC2PN( ptP2T, vPntTipEndFront[1], vPntTipEndFront[2], vtLe[s]) ; + cArcTipStart1.SetC2PN( ptP1T, vPntTipStartFront[0], vPntTipStartFront[1], vtLs) ; + cArcTipEnd1.SetC2PN( ptP2T, vPntTipEndFront[0], vPntTipEndFront[1], vtLe) ; + cArcTipStart2.SetC2PN( ptP1T, vPntTipStartFront[1], vPntTipStartFront[2], vtLs) ; + cArcTipEnd2.SetC2PN( ptP2T, vPntTipEndFront[1], vPntTipEndFront[2], vtLe) ; } else { - cArcTipStart1.SetC2PN( ptP1T, vPntTipStartBack[1], vPntTipStartBack[0], vtLs[s]) ; - cArcTipEnd1.SetC2PN( ptP2T, vPntTipEndBack[1], vPntTipEndBack[0], vtLe[s]) ; - cArcTipStart2.SetC2PN( ptP1T, vPntTipStartBack[2], vPntTipStartBack[1], vtLs[s]) ; - cArcTipEnd2.SetC2PN( ptP2T, vPntTipEndBack[2], vPntTipEndBack[1], vtLe[s]) ; + cArcTipStart1.SetC2PN( ptP1T, vPntTipStartBack[1], vPntTipStartBack[0], vtLs) ; + cArcTipEnd1.SetC2PN( ptP2T, vPntTipEndBack[1], vPntTipEndBack[0], vtLe) ; + cArcTipStart2.SetC2PN( ptP1T, vPntTipStartBack[2], vPntTipStartBack[1], vtLs) ; + cArcTipEnd2.SetC2PN( ptP2T, vPntTipEndBack[2], vPntTipEndBack[1], vtLe) ; } - // superfici inferiori 1 - PtrOwner cBezTipStart1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStart1, nDegU, bRat))) ; - PtrOwner cBezTipEnd1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEnd1, nDegU, bRat))) ; + // superfici inferiori 1 + PtrOwner cBezTipStart1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStart1, nDegU, bRat))) ; + PtrOwner cBezTipEnd1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEnd1, nDegU, bRat))) ; vvPtCtrl.emplace_back( cBezTipStart1->GetAllControlPoints()) ; PNTVECTOR vPntTipEnd1 = cBezTipEnd1->GetAllControlPoints() ; vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd1.begin(), vPntTipEnd1.end()) ; - // superfici inferiori 2 - PtrOwner cBezTipStart2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStart2, nDegU, bRat))) ; - PtrOwner cBezTipEnd2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEnd2, nDegU, bRat))) ; + // superfici inferiori 2 + PtrOwner cBezTipStart2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStart2, nDegU, bRat))) ; + PtrOwner cBezTipEnd2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEnd2, nDegU, bRat))) ; vvPtCtrl.emplace_back( cBezTipStart2->GetAllControlPoints()) ; PNTVECTOR vPntTipEnd2 = cBezTipEnd2->GetAllControlPoints() ; vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd2.begin(), vPntTipEnd2.end()) ; - // superiori + // superiori CurveArc cArcTopStart1, cArcTopEnd1, cArcTopStart2, cArcTopEnd2 ; if ( dSide > 0) { - cArcTopStart1.SetC2PN( ptS[s], vPntTopStartBack[0], vPntTopStartBack[1], vtLs[s]) ; - cArcTopEnd1.SetC2PN( ptE[s], vPntTopEndBack[0], vPntTopEndBack[1], vtLe[s]) ; - cArcTopStart2.SetC2PN( ptS[s], vPntTopStartBack[1], vPntTopStartBack[2], vtLs[s]) ; - cArcTopEnd2.SetC2PN( ptE[s], vPntTopEndBack[1], vPntTopEndBack[2], vtLe[s]) ; + cArcTopStart1.SetC2PN( ptS, vPntTopStartBack[0], vPntTopStartBack[1], vtLs) ; + cArcTopEnd1.SetC2PN( ptE, vPntTopEndBack[0], vPntTopEndBack[1], vtLe) ; + cArcTopStart2.SetC2PN( ptS, vPntTopStartBack[1], vPntTopStartBack[2], vtLs) ; + cArcTopEnd2.SetC2PN( ptE, vPntTopEndBack[1], vPntTopEndBack[2], vtLe) ; } else { - cArcTopStart1.SetC2PN( ptS[s], vPntTopStartFront[1], vPntTopStartFront[0], vtLs[s]) ; - cArcTopEnd1.SetC2PN( ptE[s], vPntTopEndFront[1], vPntTopEndFront[0], vtLe[s]) ; - cArcTopStart2.SetC2PN( ptS[s], vPntTopStartFront[2], vPntTopStartFront[1], vtLs[s]) ; - cArcTopEnd2.SetC2PN( ptE[s], vPntTopEndFront[2], vPntTopEndFront[1], vtLe[s]) ; + cArcTopStart1.SetC2PN( ptS, vPntTopStartFront[1], vPntTopStartFront[0], vtLs) ; + cArcTopEnd1.SetC2PN( ptE, vPntTopEndFront[1], vPntTopEndFront[0], vtLe) ; + cArcTopStart2.SetC2PN( ptS, vPntTopStartFront[2], vPntTopStartFront[1], vtLs) ; + cArcTopEnd2.SetC2PN( ptE, vPntTopEndFront[2], vPntTopEndFront[1], vtLe) ; } - // superfici superiori 1 - PtrOwner cBezTopStart1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStart1, nDegU, bRat))) ; - PtrOwner cBezTopEnd1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEnd1, nDegU, bRat))) ; + // superfici superiori 1 + PtrOwner cBezTopStart1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStart1, nDegU, bRat))) ; + PtrOwner cBezTopEnd1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEnd1, nDegU, bRat))) ; vvPtCtrl.emplace_back( cBezTopStart1->GetAllControlPoints()) ; PNTVECTOR vPntTopEnd1 = cBezTopEnd1->GetAllControlPoints() ; vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd1.begin(), vPntTopEnd1.end()) ; - // superfici superiori 2 - PtrOwner cBezTopStart2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStart2, nDegU, bRat))) ; - PtrOwner cBezTopEnd2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEnd2, nDegU, bRat))) ; + // superfici superiori 2 + PtrOwner cBezTopStart2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStart2, nDegU, bRat))) ; + PtrOwner cBezTopEnd2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEnd2, nDegU, bRat))) ; vvPtCtrl.emplace_back( cBezTopStart2->GetAllControlPoints()) ; PNTVECTOR vPntTopEnd2 = cBezTopEnd2->GetAllControlPoints() ; vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd2.begin(), vPntTopEnd2.end()) ; - // aggiungo le superfici bilineari anche nell'altro verso sia per il top che per il tip + // aggiungo le superfici bilineari anche nell'altro verso sia per il top che per il tip if ( n5AxisType == Move5Axis::ACROSS) { - // inferiori - CurveArc cArcTipStart1, cArcTipEnd1, cArcTipStart2, cArcTipEnd2 ; - if ( dSide > 0) { - cArcTipStart1.SetC2PN( ptP1T, vPntTipStartBack[1], vPntTipStartBack[0], vtLs[s]) ; - cArcTipEnd1.SetC2PN( ptP2T, vPntTipEndBack[1], vPntTipEndBack[0], vtLe[s]) ; - cArcTipStart2.SetC2PN( ptP1T, vPntTipStartBack[2], vPntTipStartBack[1], vtLs[s]) ; - cArcTipEnd2.SetC2PN( ptP2T, vPntTipEndBack[2], vPntTipEndBack[1], vtLe[s]) ; - } - else { - cArcTipStart1.SetC2PN( ptP1T, vPntTipStartFront[0], vPntTipStartFront[1], vtLs[s]) ; - cArcTipEnd1.SetC2PN( ptP2T, vPntTipEndFront[0], vPntTipEndFront[1], vtLe[s]) ; - cArcTipStart2.SetC2PN( ptP1T, vPntTipStartFront[1], vPntTipStartFront[2], vtLs[s]) ; - cArcTipEnd2.SetC2PN( ptP2T, vPntTipEndFront[1], vPntTipEndFront[2], vtLe[s]) ; - } - // inferiori 1 - PtrOwner cBezTipStart1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStart1, nDegU, bRat))) ; - PtrOwner cBezTipEnd1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEnd1, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezTipStart1->GetAllControlPoints()) ; - PNTVECTOR vPntTip1 = cBezTipEnd1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.begin(), vPntTip1.end()) ; - // inferiori 2 - PtrOwner cBezTipStart2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStart2, nDegU, bRat))) ; - PtrOwner cBezTipEnd2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEnd2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezTipStart2->GetAllControlPoints()) ; - PNTVECTOR vPntTip2 = cBezTipEnd2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.begin(), vPntTip2.end()) ; - // superiori - CurveArc cArcTopStart1, cArcTopEnd1, cArcTopStart2, cArcTopEnd2 ; - if ( dSide > 0) { - cArcTopStart1.SetC2PN( ptS[s], vPntTopStartFront[1], vPntTopStartFront[0], vtLs[s]) ; - cArcTopEnd1.SetC2PN( ptE[s], vPntTopEndFront[1], vPntTopEndFront[0], vtLe[s]) ; - cArcTopStart2.SetC2PN( ptS[s], vPntTopStartFront[2], vPntTopStartFront[1], vtLs[s]) ; - cArcTopEnd2.SetC2PN( ptE[s], vPntTopEndFront[2], vPntTopEndFront[1], vtLe[s]) ; - } - else { - cArcTopStart1.SetC2PN( ptS[s], vPntTopStartBack[0], vPntTopStartBack[1], vtLs[s]) ; - cArcTopEnd1.SetC2PN( ptE[s], vPntTopEndBack[0], vPntTopEndBack[1], vtLe[s]) ; - cArcTopStart2.SetC2PN( ptS[s], vPntTopStartBack[1], vPntTopStartBack[2], vtLs[s]) ; - cArcTopEnd2.SetC2PN( ptE[s], vPntTopEndBack[1], vPntTopEndBack[2], vtLe[s]) ; - } - // superfici superiori 1 - PtrOwner cBezTopStart1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStart1, nDegU, bRat))) ; - PtrOwner cBezTopEnd1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEnd1, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezTopStart1->GetAllControlPoints()) ; - PNTVECTOR vPntTop1 = cBezTopEnd1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop1.begin(), vPntTop1.end()) ; - // superfici superiori 2 - PtrOwner cBezTopStart2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStart2, nDegU, bRat))) ; - PtrOwner cBezTopEnd2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEnd2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezTopStart2->GetAllControlPoints()) ; - PNTVECTOR vPntTop2 = cBezTopEnd2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop2.begin(), vPntTop2.end()) ; + // inferiori + CurveArc cArcTipStart1, cArcTipEnd1, cArcTipStart2, cArcTipEnd2 ; + if ( dSide > 0) { + cArcTipStart1.SetC2PN( ptP1T, vPntTipStartBack[1], vPntTipStartBack[0], vtLs) ; + cArcTipEnd1.SetC2PN( ptP2T, vPntTipEndBack[1], vPntTipEndBack[0], vtLe) ; + cArcTipStart2.SetC2PN( ptP1T, vPntTipStartBack[2], vPntTipStartBack[1], vtLs) ; + cArcTipEnd2.SetC2PN( ptP2T, vPntTipEndBack[2], vPntTipEndBack[1], vtLe) ; + } + else { + cArcTipStart1.SetC2PN( ptP1T, vPntTipStartFront[0], vPntTipStartFront[1], vtLs) ; + cArcTipEnd1.SetC2PN( ptP2T, vPntTipEndFront[0], vPntTipEndFront[1], vtLe) ; + cArcTipStart2.SetC2PN( ptP1T, vPntTipStartFront[1], vPntTipStartFront[2], vtLs) ; + cArcTipEnd2.SetC2PN( ptP2T, vPntTipEndFront[1], vPntTipEndFront[2], vtLe) ; + } + // inferiori 1 + PtrOwner cBezTipStart1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStart1, nDegU, bRat))) ; + PtrOwner cBezTipEnd1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEnd1, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezTipStart1->GetAllControlPoints()) ; + PNTVECTOR vPntTip1 = cBezTipEnd1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.begin(), vPntTip1.end()) ; + // inferiori 2 + PtrOwner cBezTipStart2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStart2, nDegU, bRat))) ; + PtrOwner cBezTipEnd2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEnd2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezTipStart2->GetAllControlPoints()) ; + PNTVECTOR vPntTip2 = cBezTipEnd2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.begin(), vPntTip2.end()) ; + // superiori + CurveArc cArcTopStart1, cArcTopEnd1, cArcTopStart2, cArcTopEnd2 ; + if ( dSide > 0) { + cArcTopStart1.SetC2PN( ptS, vPntTopStartFront[1], vPntTopStartFront[0], vtLs) ; + cArcTopEnd1.SetC2PN( ptE, vPntTopEndFront[1], vPntTopEndFront[0], vtLe) ; + cArcTopStart2.SetC2PN( ptS, vPntTopStartFront[2], vPntTopStartFront[1], vtLs) ; + cArcTopEnd2.SetC2PN( ptE, vPntTopEndFront[2], vPntTopEndFront[1], vtLe) ; + } + else { + cArcTopStart1.SetC2PN( ptS, vPntTopStartBack[0], vPntTopStartBack[1], vtLs) ; + cArcTopEnd1.SetC2PN( ptE, vPntTopEndBack[0], vPntTopEndBack[1], vtLe) ; + cArcTopStart2.SetC2PN( ptS, vPntTopStartBack[1], vPntTopStartBack[2], vtLs) ; + cArcTopEnd2.SetC2PN( ptE, vPntTopEndBack[1], vPntTopEndBack[2], vtLe) ; + } + // superfici superiori 1 + PtrOwner cBezTopStart1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStart1, nDegU, bRat))) ; + PtrOwner cBezTopEnd1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEnd1, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezTopStart1->GetAllControlPoints()) ; + PNTVECTOR vPntTop1 = cBezTopEnd1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop1.begin(), vPntTop1.end()) ; + // superfici superiori 2 + PtrOwner cBezTopStart2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStart2, nDegU, bRat))) ; + PtrOwner cBezTopEnd2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEnd2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezTopStart2->GetAllControlPoints()) ; + PNTVECTOR vPntTop2 = cBezTopEnd2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop2.begin(), vPntTop2.end()) ; } - } + } - // all'ultimo step chiudo il volume con le superfici verticali e le basi dei tool - if ( s == nStepCnt - 1) { - // chiudo il volume con le superici verticali end 1 - CurveArc cArcTipEnd1, cArcTopEnd1, cArcTipEnd2, cArcTopEnd2 ; - cArcTipEnd1.SetC2PN( ptP2TEx, vPntTipEndExF[0], vPntTipEndExF[1], vtLe.back()) ; - cArcTopEnd1.SetC2PN( ptE.back(), vPntTopEndExF[0], vPntTopEndExF[1], vtLe.back()) ; - cArcTipEnd2.SetC2PN( ptP2TEx, vPntTipEndExF[1], vPntTipEndExF[2], vtLe.back()) ; - cArcTopEnd2.SetC2PN( ptE.back(), vPntTopEndExF[1], vPntTopEndExF[2], vtLe.back()) ; - PtrOwner cBezTipEnd1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEnd1, nDegU, bRat))) ; - PtrOwner cBezTopEnd1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEnd1, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezTipEnd1->GetAllControlPoints()) ; - PNTVECTOR vPntEnd1 = cBezTopEnd1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEnd1.begin(), vPntEnd1.end()) ; - // chiudo il volume con le superici verticali end 2 - PtrOwner cBezTipEnd2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEnd2, nDegU, bRat))) ; - PtrOwner cBezTopEnd2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEnd2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezTipEnd2->GetAllControlPoints()) ; - PNTVECTOR vPntEnd2 = cBezTopEnd2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEnd2.begin(), vPntEnd2.end()) ; + // chiudo il volume con le superfici verticali e le basi dei tool - // chiudo il volume con le superici verticali start 1 - CurveArc cArcTipStart1, cArcTopStart1, cArcTipStart2, cArcTopStart2 ; - cArcTipStart1.SetC2PN( ptP1TEx, vPntTipStartExB[0], vPntTipStartExB[1], vtLs.front()) ; - cArcTopStart1.SetC2PN( ptS.front(), vPntTopStartExB[0], vPntTopStartExB[1], vtLs.front()) ; - cArcTipStart2.SetC2PN( ptP1TEx, vPntTipStartExB[1], vPntTipStartExB[2], vtLs.front()) ; - cArcTopStart2.SetC2PN( ptS.front(), vPntTopStartExB[1], vPntTopStartExB[2], vtLs.front()) ; - PtrOwner cBezTipStart1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStart1, nDegU, bRat))) ; - PtrOwner cBezTopStart1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStart1, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezTipStart1->GetAllControlPoints()) ; - PNTVECTOR vPntStart1 = cBezTopStart1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStart1.begin(), vPntStart1.end()) ; - // chiudo il volume con le superfici verticali start 2 - PtrOwner cBezTipStart2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStart2, nDegU, bRat))) ; - PtrOwner cBezTopStart2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStart2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( cBezTipStart2->GetAllControlPoints()) ; - PNTVECTOR vPntStart2 = cBezTopStart2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStart2.begin(), vPntStart2.end()) ; + // chiudo il volume con le superici verticali end 1 + CurveArc cArcTipEnd1, cArcTopEnd1, cArcTipEnd2, cArcTopEnd2 ; + cArcTipEnd1.SetC2PN( ptP2T, vPntTipEndFront[0], vPntTipEndFront[1], vtLe) ; + cArcTopEnd1.SetC2PN( ptE, vPntTopEndFront[0], vPntTopEndFront[1], vtLe) ; + cArcTipEnd2.SetC2PN( ptP2T, vPntTipEndFront[1], vPntTipEndFront[2], vtLe) ; + cArcTopEnd2.SetC2PN( ptE, vPntTopEndFront[1], vPntTopEndFront[2], vtLe) ; + PtrOwner cBezTipEnd1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEnd1, nDegU, bRat))) ; + PtrOwner cBezTopEnd1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEnd1, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezTipEnd1->GetAllControlPoints()) ; + PNTVECTOR vPntEnd1 = cBezTopEnd1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEnd1.begin(), vPntEnd1.end()) ; + // chiudo il volume con le superici verticali end 2 + PtrOwner cBezTipEnd2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEnd2, nDegU, bRat))) ; + PtrOwner cBezTopEnd2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEnd2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezTipEnd2->GetAllControlPoints()) ; + PNTVECTOR vPntEnd2 = cBezTopEnd2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEnd2.begin(), vPntEnd2.end()) ; - // superfici di base dei tool - if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS && dSide < 0)) { - // start back tip - CurveArc cArcTipStartBack1, cArcTipStartBack2 ; - cArcTipStartBack1.SetC2PN( ptP1TEx, vPntTipStartExB[0], vPntTipStartExB[1], vtLs.front()) ; - cArcTipStartBack2.SetC2PN( ptP1TEx, vPntTipStartExB[1], vPntTipStartExB[2], vtLs.front()) ; - PtrOwner cBezTipStartBack1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStartBack1, nDegU, bRat))) ; - PtrOwner cBezTipStartBack2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStartBack2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptP1TEx, ptP1TEx, ptP1TEx, ptP1TEx}) ; - PNTVECTOR vPntTipStartBack1 = cBezTipStartBack1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipStartBack1.begin(), vPntTipStartBack1.end()) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptP1TEx, ptP1TEx, ptP1TEx, ptP1TEx}) ; - PNTVECTOR vPntTipStartBack2 = cBezTipStartBack2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipStartBack2.begin(), vPntTipStartBack2.end()) ; - // start front tip - CurveArc cArcTipStartFront1, cArcTipStartFront2 ; - cArcTipStartFront1.SetC2PN( ptP1TEx, vPntTipStartExF[0], vPntTipStartExF[1], vtLs.front()) ; - cArcTipStartFront2.SetC2PN( ptP1TEx, vPntTipStartExF[1], vPntTipStartExF[2], vtLs.front()) ; - PtrOwner cBezTipStartFront1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStartFront1, nDegU, bRat))) ; - PtrOwner cBezTipStartFront2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipStartFront2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptP1TEx, ptP1TEx, ptP1TEx, ptP1TEx}) ; - PNTVECTOR vPntTipStartFront1 = cBezTipStartFront1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipStartFront1.begin(), vPntTipStartFront1.end()) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptP1TEx, ptP1TEx, ptP1TEx, ptP1TEx}) ; - PNTVECTOR vPntTipStartFront2 = cBezTipStartFront2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipStartFront2.begin(), vPntTipStartFront2.end()) ; - } - if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS && dSide > 0)) { - // end front tip - CurveArc cArcTipEndFront1, cArcTipEndFront2 ; - cArcTipEndFront1.SetC2PN( ptP2TEx, vPntTipEndExF[0], vPntTipEndExF[1], vtLe.back()) ; - cArcTipEndFront2.SetC2PN( ptP2TEx, vPntTipEndExF[1], vPntTipEndExF[2], vtLe.back()) ; - PtrOwner cBezTipEndFront1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEndFront1, nDegU, bRat))) ; - PtrOwner cBezTipEndFront2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEndFront2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptP2TEx, ptP2TEx, ptP2TEx, ptP2TEx}) ; - PNTVECTOR vPntTipEndFront1 = cBezTipEndFront1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEndFront1.begin(), vPntTipEndFront1.end()) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptP2TEx, ptP2TEx, ptP2TEx, ptP2TEx}) ; - PNTVECTOR vPntTipEndFront2 = cBezTipEndFront2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEndFront2.begin(), vPntTipEndFront2.end()) ; - // end back tip - CurveArc cArcTipEndBack1, cArcTipEndBack2 ; - cArcTipEndBack1.SetC2PN( ptP2TEx, vPntTipEndExB[0], vPntTipEndExB[1], vtLe.back()) ; - cArcTipEndBack2.SetC2PN( ptP2TEx, vPntTipEndExB[1], vPntTipEndExB[2], vtLe.back()) ; - PtrOwner cBezTipEndBack1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEndBack1, nDegU, bRat))) ; - PtrOwner cBezTipEndBack2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTipEndBack2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptP2TEx, ptP2TEx, ptP2TEx, ptP2TEx}) ; - PNTVECTOR vPntTipEndBack1 = cBezTipEndBack1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEndBack1.begin(), vPntTipEndBack1.end()) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptP2TEx, ptP2TEx, ptP2TEx, ptP2TEx}) ; - PNTVECTOR vPntTipEndBack2 = cBezTipEndBack2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEndBack2.begin(), vPntTipEndBack2.end()) ; - } + // chiudo il volume con le superici verticali start 1 + CurveArc cArcTipStart1, cArcTopStart1, cArcTipStart2, cArcTopStart2 ; + cArcTipStart1.SetC2PN( ptP1T, vPntTipStartBack[0], vPntTipStartBack[1], vtLs) ; + cArcTopStart1.SetC2PN( ptS, vPntTopStartBack[0], vPntTopStartBack[1], vtLs) ; + cArcTipStart2.SetC2PN( ptP1T, vPntTipStartBack[1], vPntTipStartBack[2], vtLs) ; + cArcTopStart2.SetC2PN( ptS, vPntTopStartBack[1], vPntTopStartBack[2], vtLs) ; + PtrOwner cBezTipStart1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStart1, nDegU, bRat))) ; + PtrOwner cBezTopStart1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStart1, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezTipStart1->GetAllControlPoints()) ; + PNTVECTOR vPntStart1 = cBezTopStart1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStart1.begin(), vPntStart1.end()) ; + // chiudo il volume con le superfici verticali start 2 + PtrOwner cBezTipStart2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStart2, nDegU, bRat))) ; + PtrOwner cBezTopStart2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStart2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( cBezTipStart2->GetAllControlPoints()) ; + PNTVECTOR vPntStart2 = cBezTopStart2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStart2.begin(), vPntStart2.end()) ; - if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS && dSide > 0)) { - // start back top - CurveArc cArcTopStartBack1, cArcTopStartBack2 ; - cArcTopStartBack1.SetC2PN( ptS.front(), vPntTopStartExB[1], vPntTopStartExB[0], vtLs.front()) ; - cArcTopStartBack2.SetC2PN( ptS.front(), vPntTopStartExB[2], vPntTopStartExB[1], vtLs.front()) ; - PtrOwner cBezTopStartBack1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStartBack1, nDegU, bRat))) ; - PtrOwner cBezTopStartBack2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStartBack2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptS[0], ptS[0], ptS[0], ptS[0]}) ; - PNTVECTOR vPntTopStartBack1 = cBezTopStartBack1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopStartBack1.begin(), vPntTopStartBack1.end()) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptS[0], ptS[0], ptS[0], ptS[0]}) ; - PNTVECTOR vPntTopStartBack2 = cBezTopStartBack2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopStartBack2.begin(), vPntTopStartBack2.end()) ; - // start front top - CurveArc cArcTopStartFront1, cArcTopStartFront2 ; - cArcTopStartFront1.SetC2PN( ptS.front(), vPntTopStartExF[1], vPntTopStartExF[0], vtLs.front()) ; - cArcTopStartFront2.SetC2PN( ptS.front(), vPntTopStartExF[2], vPntTopStartExF[1], vtLs.front()) ; - PtrOwner cBezTopStartFront1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStartFront1, nDegU, bRat))) ; - PtrOwner cBezTopStartFront2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopStartFront2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptS[0], ptS[0], ptS[0], ptS[0]}) ; - PNTVECTOR vPntTopStartFront1 = cBezTopStartFront1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopStartFront1.begin(), vPntTopStartFront1.end()) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptS[0], ptS[0], ptS[0], ptS[0]}) ; - PNTVECTOR vPntTopStartFront2 = cBezTopStartFront2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopStartFront2.begin(), vPntTopStartFront2.end()) ; - } - if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS && dSide < 0)) { - // end front top - CurveArc cArcTopEndFront1, cArcTopEndFront2 ; - cArcTopEndFront1.SetC2PN( ptE.back(), vPntTopEndExF[1], vPntTopEndExF[0], vtLe.back()) ; - cArcTopEndFront2.SetC2PN( ptE.back(), vPntTopEndExF[2], vPntTopEndExF[1], vtLe.back()) ; - PtrOwner cBezTopEndFront1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEndFront1, nDegU, bRat))) ; - PtrOwner cBezTopEndFront2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEndFront2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptE[s], ptE[s], ptE[s], ptE[s]}) ; - PNTVECTOR vPntTopEndFront1 = cBezTopEndFront1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEndFront1.begin(), vPntTopEndFront1.end()) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptE[s], ptE[s], ptE[s], ptE[s]}) ; - PNTVECTOR vPntTopEndFront2 = cBezTopEndFront2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEndFront2.begin(), vPntTopEndFront2.end()) ; - // end back top - CurveArc cArcTopEndBack1, cArcTopEndBack2 ; - cArcTopEndBack1.SetC2PN( ptE.back(), vPntTopEndExB[1], vPntTopEndExB[0], vtLe.back()) ; - cArcTopEndBack2.SetC2PN( ptE.back(), vPntTopEndExB[2], vPntTopEndExB[1], vtLe.back()) ; - PtrOwner cBezTopEndBack1( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEndBack1, nDegU, bRat))) ; - PtrOwner cBezTopEndBack2( GetBasicCurveBezier(ArcToBezierCurve( &cArcTopEndBack2, nDegU, bRat))) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptE[s], ptE[s], ptE[s], ptE[s]}) ; - PNTVECTOR vPntTopEndBack1 = cBezTopEndBack1->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEndBack1.begin(), vPntTopEndBack1.end()) ; - vvPtCtrl.emplace_back( PNTVECTOR{ ptE[s], ptE[s], ptE[s], ptE[s]}) ; - PNTVECTOR vPntTopEndBack2 = cBezTopEndBack2->GetAllControlPoints() ; - vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEndBack2.begin(), vPntTopEndBack2.end()) ; - } - } - } + // superfici di base dei tool + if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS && dSide < 0)) { + // start back tip + CurveArc cArcTipStartBack1, cArcTipStartBack2 ; + cArcTipStartBack1.SetC2PN( ptP1T, vPntTipStartBack[0], vPntTipStartBack[1], vtLs) ; + cArcTipStartBack2.SetC2PN( ptP1T, vPntTipStartBack[1], vPntTipStartBack[2], vtLs) ; + PtrOwner cBezTipStartBack1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStartBack1, nDegU, bRat))) ; + PtrOwner cBezTipStartBack2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStartBack2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptP1T, ptP1T, ptP1T, ptP1T }) ; + PNTVECTOR vPntTipStartBack1 = cBezTipStartBack1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipStartBack1.begin(), vPntTipStartBack1.end()) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptP1T, ptP1T, ptP1T, ptP1T }) ; + PNTVECTOR vPntTipStartBack2 = cBezTipStartBack2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipStartBack2.begin(), vPntTipStartBack2.end()) ; + // start front tip + CurveArc cArcTipStartFront1, cArcTipStartFront2 ; + cArcTipStartFront1.SetC2PN( ptP1T, vPntTipStartFront[0], vPntTipStartFront[1], vtLs) ; + cArcTipStartFront2.SetC2PN( ptP1T, vPntTipStartFront[1], vPntTipStartFront[2], vtLs) ; + PtrOwner cBezTipStartFront1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStartFront1, nDegU, bRat))) ; + PtrOwner cBezTipStartFront2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipStartFront2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptP1T, ptP1T, ptP1T, ptP1T }) ; + PNTVECTOR vPntTipStartFront1 = cBezTipStartFront1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipStartFront1.begin(), vPntTipStartFront1.end()) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptP1T, ptP1T, ptP1T, ptP1T }) ; + PNTVECTOR vPntTipStartFront2 = cBezTipStartFront2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipStartFront2.begin(), vPntTipStartFront2.end()) ; + } + if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS && dSide > 0)) { + // end front tip + CurveArc cArcTipEndFront1, cArcTipEndFront2 ; + cArcTipEndFront1.SetC2PN( ptP2T, vPntTipEndFront[0], vPntTipEndFront[1], vtLe) ; + cArcTipEndFront2.SetC2PN( ptP2T, vPntTipEndFront[1], vPntTipEndFront[2], vtLe) ; + PtrOwner cBezTipEndFront1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEndFront1, nDegU, bRat))) ; + PtrOwner cBezTipEndFront2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEndFront2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptP2T, ptP2T, ptP2T, ptP2T }) ; + PNTVECTOR vPntTipEndFront1 = cBezTipEndFront1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEndFront1.begin(), vPntTipEndFront1.end()) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptP2T, ptP2T, ptP2T, ptP2T }) ; + PNTVECTOR vPntTipEndFront2 = cBezTipEndFront2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEndFront2.begin(), vPntTipEndFront2.end()) ; + // end back tip + CurveArc cArcTipEndBack1, cArcTipEndBack2 ; + cArcTipEndBack1.SetC2PN( ptP2T, vPntTipEndBack[0], vPntTipEndBack[1], vtLe) ; + cArcTipEndBack2.SetC2PN( ptP2T, vPntTipEndBack[1], vPntTipEndBack[2], vtLe) ; + PtrOwner cBezTipEndBack1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEndBack1, nDegU, bRat))) ; + PtrOwner cBezTipEndBack2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTipEndBack2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptP2T, ptP2T, ptP2T, ptP2T }) ; + PNTVECTOR vPntTipEndBack1 = cBezTipEndBack1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEndBack1.begin(), vPntTipEndBack1.end()) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptP2T, ptP2T, ptP2T, ptP2T }) ; + PNTVECTOR vPntTipEndBack2 = cBezTipEndBack2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEndBack2.begin(), vPntTipEndBack2.end()) ; + } - // inizializzo le superfici bilineari e i parametri per le intersezioni - for ( int z = 0 ; z < int( vvPtCtrl.size()) ; ++z) { - vSurfBez[nSurfInd].sBez.Init( nDegU, nDegV, nSpanU, nSpanV, bRat) ; - vSurfBez[nSurfInd].sBez.SetControlPoint( 0, vvPtCtrl[z][0]) ; - vSurfBez[nSurfInd].sBez.SetControlPoint( 1, vvPtCtrl[z][1]) ; - vSurfBez[nSurfInd].sBez.SetControlPoint( 2, vvPtCtrl[z][2]) ; - vSurfBez[nSurfInd].sBez.SetControlPoint( 3, vvPtCtrl[z][3]) ; - vSurfBez[nSurfInd].sBez.SetControlPoint( 4, vvPtCtrl[z][4]) ; - vSurfBez[nSurfInd].sBez.SetControlPoint( 5, vvPtCtrl[z][5]) ; - vSurfBez[nSurfInd].sBez.SetControlPoint( 6, vvPtCtrl[z][6]) ; - vSurfBez[nSurfInd].sBez.SetControlPoint( 7, vvPtCtrl[z][7]) ; + if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS && dSide > 0)) { + // start back top + CurveArc cArcTopStartBack1, cArcTopStartBack2 ; + cArcTopStartBack1.SetC2PN( ptS, vPntTopStartBack[1], vPntTopStartBack[0], vtLs) ; + cArcTopStartBack2.SetC2PN( ptS, vPntTopStartBack[2], vPntTopStartBack[1], vtLs) ; + PtrOwner cBezTopStartBack1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStartBack1, nDegU, bRat))) ; + PtrOwner cBezTopStartBack2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStartBack2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptS, ptS, ptS, ptS }) ; + PNTVECTOR vPntTopStartBack1 = cBezTopStartBack1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopStartBack1.begin(), vPntTopStartBack1.end()) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptS, ptS, ptS, ptS }) ; + PNTVECTOR vPntTopStartBack2 = cBezTopStartBack2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopStartBack2.begin(), vPntTopStartBack2.end()) ; + // start front top + CurveArc cArcTopStartFront1, cArcTopStartFront2 ; + cArcTopStartFront1.SetC2PN( ptS, vPntTopStartFront[1], vPntTopStartFront[0], vtLs) ; + cArcTopStartFront2.SetC2PN( ptS, vPntTopStartFront[2], vPntTopStartFront[1], vtLs) ; + PtrOwner cBezTopStartFront1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStartFront1, nDegU, bRat))) ; + PtrOwner cBezTopStartFront2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopStartFront2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptS, ptS, ptS, ptS }) ; + PNTVECTOR vPntTopStartFront1 = cBezTopStartFront1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopStartFront1.begin(), vPntTopStartFront1.end()) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptS, ptS, ptS, ptS }) ; + PNTVECTOR vPntTopStartFront2 = cBezTopStartFront2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopStartFront2.begin(), vPntTopStartFront2.end()) ; + } + if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS && dSide < 0)) { + // end front top + CurveArc cArcTopEndFront1, cArcTopEndFront2 ; + cArcTopEndFront1.SetC2PN( ptE, vPntTopEndFront[1], vPntTopEndFront[0], vtLe) ; + cArcTopEndFront2.SetC2PN( ptE, vPntTopEndFront[2], vPntTopEndFront[1], vtLe) ; + PtrOwner cBezTopEndFront1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEndFront1, nDegU, bRat))) ; + PtrOwner cBezTopEndFront2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEndFront2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptE, ptE, ptE, ptE }) ; + PNTVECTOR vPntTopEndFront1 = cBezTopEndFront1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEndFront1.begin(), vPntTopEndFront1.end()) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptE, ptE, ptE, ptE }) ; + PNTVECTOR vPntTopEndFront2 = cBezTopEndFront2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEndFront2.begin(), vPntTopEndFront2.end()) ; + // end back top + CurveArc cArcTopEndBack1, cArcTopEndBack2 ; + cArcTopEndBack1.SetC2PN( ptE, vPntTopEndBack[1], vPntTopEndBack[0], vtLe) ; + cArcTopEndBack2.SetC2PN( ptE, vPntTopEndBack[2], vPntTopEndBack[1], vtLe) ; + PtrOwner cBezTopEndBack1( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEndBack1, nDegU, bRat))) ; + PtrOwner cBezTopEndBack2( GetBasicCurveBezier( ArcToBezierCurve( &cArcTopEndBack2, nDegU, bRat))) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptE, ptE, ptE, ptE }) ; + PNTVECTOR vPntTopEndBack1 = cBezTopEndBack1->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEndBack1.begin(), vPntTopEndBack1.end()) ; + vvPtCtrl.emplace_back( PNTVECTOR{ ptE, ptE, ptE, ptE }) ; + PNTVECTOR vPntTopEndBack2 = cBezTopEndBack2->GetAllControlPoints() ; + vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEndBack2.begin(), vPntTopEndBack2.end()) ; + } + } - Vector3d A = vvPtCtrl[z][4] - vvPtCtrl[z][0] ; - Vector3d B = vvPtCtrl[z][5] - vvPtCtrl[z][1] ; - Vector3d C = vvPtCtrl[z][6] - vvPtCtrl[z][2] ; - Vector3d D = vvPtCtrl[z][7] - vvPtCtrl[z][3] ; - Vector3d E = vvPtCtrl[z][0] - ORIG ; - Vector3d F = vvPtCtrl[z][1] - ORIG ; - Vector3d G = vvPtCtrl[z][2] - ORIG ; - Vector3d H = vvPtCtrl[z][3] - ORIG ; +#ifdef TEST + vector vGeo ; + vector vCol( nTotSurf) ; +#endif - vSurfBez[nSurfInd].a3 = -A + 3*B - 3*C + D ; - vSurfBez[nSurfInd].a2 = 3*A - 6*B + 3*C ; - vSurfBez[nSurfInd].a1 = -3*A +3*B ; - vSurfBez[nSurfInd].a0 = A ; + // inizializzo le superfici bilineari e i parametri per le intersezioni + for ( int z = 0 ; z < int( vvPtCtrl.size()) ; ++z) { + vSurfBez[nSurfInd].sBez.Init( nDegU, nDegV, nSpanU, nSpanV, bRat) ; + vSurfBez[nSurfInd].sBez.SetControlPoint( 0, vvPtCtrl[z][0]) ; + vSurfBez[nSurfInd].sBez.SetControlPoint( 1, vvPtCtrl[z][1]) ; + vSurfBez[nSurfInd].sBez.SetControlPoint( 2, vvPtCtrl[z][2]) ; + vSurfBez[nSurfInd].sBez.SetControlPoint( 3, vvPtCtrl[z][3]) ; + vSurfBez[nSurfInd].sBez.SetControlPoint( 4, vvPtCtrl[z][4]) ; + vSurfBez[nSurfInd].sBez.SetControlPoint( 5, vvPtCtrl[z][5]) ; + vSurfBez[nSurfInd].sBez.SetControlPoint( 6, vvPtCtrl[z][6]) ; + vSurfBez[nSurfInd].sBez.SetControlPoint( 7, vvPtCtrl[z][7]) ; - vSurfBez[nSurfInd].b3 = -E + 3*F - 3*G + H ; - vSurfBez[nSurfInd].b2 = 3*E - 6*F + 3*G ; - vSurfBez[nSurfInd].b1 = -3*E + 3*F ; - vSurfBez[nSurfInd].b0 = E ; + Vector3d A = vvPtCtrl[z][4] - vvPtCtrl[z][0] ; + Vector3d B = vvPtCtrl[z][5] - vvPtCtrl[z][1] ; + Vector3d C = vvPtCtrl[z][6] - vvPtCtrl[z][2] ; + Vector3d D = vvPtCtrl[z][7] - vvPtCtrl[z][3] ; + Vector3d E = vvPtCtrl[z][0] - ORIG ; + Vector3d F = vvPtCtrl[z][1] - ORIG ; + Vector3d G = vvPtCtrl[z][2] - ORIG ; + Vector3d H = vvPtCtrl[z][3] - ORIG ; - Vector3d vtDirX ; - Vector3d vtDir0 = vvPtCtrl[z][4] - vvPtCtrl[z][0] ; - Vector3d vtDir1 = vvPtCtrl[z][3] - vvPtCtrl[z][0] ; - if ( vtDir0.Len() > vtDir1.Len()) + vSurfBez[nSurfInd].a3 = -A + 3 * B - 3 * C + D ; + vSurfBez[nSurfInd].a2 = 3 * A - 6 * B + 3 * C ; + vSurfBez[nSurfInd].a1 = -3 * A + 3 * B ; + vSurfBez[nSurfInd].a0 = A ; + + vSurfBez[nSurfInd].b3 = -E + 3 * F - 3 * G + H ; + vSurfBez[nSurfInd].b2 = 3 * E - 6 * F + 3 * G ; + vSurfBez[nSurfInd].b1 = -3 * E + 3 * F ; + vSurfBez[nSurfInd].b0 = E ; + + Vector3d vtDirX ; + Vector3d vtDir0 = vvPtCtrl[z][4] - vvPtCtrl[z][0] ; + Vector3d vtDir1 = vvPtCtrl[z][3] - vvPtCtrl[z][0] ; + if ( vtDir0.Len() > vtDir1.Len()) vtDirX = vtDir0 ; - else + else vtDirX = vtDir1 ; - // calcolo il box in un riferimento che usi come asse x la direzione P01 - P00 ( proiettata sul piano perperndicolare a Z) - if ( vSurfBez[nSurfInd].frZMainDim.Set( ORIG, Z_AX, vtDirX)) { - // porto tutti i punti in quel riferimento e calcolo il box + // calcolo il box in un riferimento che usi come asse x la direzione P01 - P00 ( proiettata sul piano perperndicolare a Z) + if ( vSurfBez[nSurfInd].frZMainDim.Set( ORIG, Z_AX, vtDirX)) { + // porto tutti i punti in quel riferimento e calcolo il box PNTVECTOR vPtCtrlLoc = vvPtCtrl[z] ; for ( int p = 0 ; p < int( vPtCtrlLoc.size()) ; ++p) - vPtCtrlLoc[p].ToLoc( vSurfBez[nSurfInd].frZMainDim) ; + vPtCtrlLoc[p].ToLoc( vSurfBez[nSurfInd].frZMainDim) ; vSurfBez[nSurfInd].bbSurfZ.Add( vPtCtrlLoc) ; - } - else { - // in ogni caso definisco la box rispetto al rifemento di nGrid + } + else { + // in ogni caso definisco la box rispetto al rifemento di nGrid vSurfBez[nSurfInd].bbSurfZ.Add( vvPtCtrl[z]) ; - } - if ( vSurfBez[nSurfInd].frXMainDim.Set( ORIG, X_AX, vtDirX)) { + } + if ( vSurfBez[nSurfInd].frXMainDim.Set( ORIG, X_AX, vtDirX)) { PNTVECTOR vPtCtrlLoc = vvPtCtrl[z] ; - // porto tutti i punti in quel riferimento e calcolo il box + // porto tutti i punti in quel riferimento e calcolo il box for ( int p = 0 ; p < int( vPtCtrlLoc.size()) ; ++p) - vPtCtrlLoc[p].ToLoc( vSurfBez[nSurfInd].frXMainDim) ; + vPtCtrlLoc[p].ToLoc( vSurfBez[nSurfInd].frXMainDim) ; vSurfBez[nSurfInd].bbSurfX.Add( vPtCtrlLoc) ; - } - if ( vSurfBez[nSurfInd].frYMainDim.Set( ORIG, Y_AX, vtDirX)) { + } + if ( vSurfBez[nSurfInd].frYMainDim.Set( ORIG, Y_AX, vtDirX)) { PNTVECTOR vPtCtrlLoc = vvPtCtrl[z] ; - // porto tutti i punti in quel riferimento e calcolo il box + // porto tutti i punti in quel riferimento e calcolo il box for ( int p = 0 ; p < int( vPtCtrlLoc.size()) ; ++p) - vPtCtrlLoc[p].ToLoc( vSurfBez[nSurfInd].frYMainDim) ; + vPtCtrlLoc[p].ToLoc( vSurfBez[nSurfInd].frYMainDim) ; vSurfBez[nSurfInd].bbSurfY.Add( vPtCtrlLoc) ; - } - ++ nSurfInd ; - } - } + } + +#ifdef TEST + //debug + if ( nGrid == 0) + vGeo.push_back( vSurfBez[nSurfInd].sBez.Clone()) ; + //debug +#endif + + ++nSurfInd ; + } + +#ifdef TEST + if ( false) { + fill( vCol.begin(), vCol.end(), Color( 255, 128, 0)) ; + SaveGeoObj( vGeo, vCol, "D:/Temp/VirtualMilling/5axisAdvanced/finalApprox.nge", 2) ; + } +#endif // scorro tutti gli spilloni interessati int j = 0 ; @@ -2173,7 +2123,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt vInterv.emplace_back( vDexel[k].dMin, vDexel[k].dMax) ; if ( vDexel.size() != 0) { - IntersLineBezierSurfSet( r, q, vSurfBez, vInters, vSurfInters, vtLs[0], vInterv) ; + IntersLineBezierSurfSet( r, q, vSurfBez, vInters, vSurfInters, vtLs, vInterv) ; if ( vInters.size() > 2) { SortGroupInters( vInters, vStartEnds, Z_AX) ; if ( bForward && vStartEnds.size() > 1) { @@ -2293,141 +2243,131 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt //---------------------------------------------------------------------------- bool -VolZmap::CompCyl_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, +VolZmap::CompCyl_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, double dHeight, double dRadius, int nToolNum, int n5AxisType) { - // tolgo il volume spazzato dal tool durante il movimento - return Comp_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, dHeight, dRadius, dRadius, nToolNum, n5AxisType) ; + // tolgo il volume spazzato dal tool durante il movimento + return Comp_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, dHeight, dRadius, dRadius, nToolNum, n5AxisType) ; } //---------------------------------------------------------------------------- bool -VolZmap::Cyl_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, double dHeightCorr, int n5AxisType) +VolZmap::Cyl_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, double dHeightCorr, int n5AxisType) { - // tolgo il volume dei cilindri all'inizio e alla fine del tratto e poi uso delle bilineari per approssimare il volume spazzato + // tolgo il volume dei cilindri all'inizio e alla fine del tratto e poi uso delle bilineari per approssimare il volume spazzato - // Controllo utensile - if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) - return false ; - // recupero le info del tool - Tool& CurrTool = m_vTool[m_nCurrTool] ; - double dHeight = CurrTool.GetHeigth() - dHeightCorr ; - double dRadius = CurrTool.GetRadius() ; + // Controllo utensile + if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) + return false ; + // recupero le info del tool + Tool& CurrTool = m_vTool[m_nCurrTool] ; + double dHeight = CurrTool.GetHeigth() - dHeightCorr ; + double dRadius = CurrTool.GetRadius() ; - return CompCyl_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, dHeight, dRadius, nToolNum, n5AxisType) ; + return CompCyl_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, dHeight, dRadius, nToolNum, n5AxisType) ; } //---------------------------------------------------------------------------- bool -VolZmap::CylBall_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType) +VolZmap::CylBall_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, int n5AxisType) { - // Controllo utensile - if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) - return false ; - Tool& CurrTool = m_vTool[m_nCurrTool] ; - double dHeight = CurrTool.GetHeigth() - CurrTool.GetTipRadius() ; - double dRadius = CurrTool.GetRadius() ; - CompCyl_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, dHeight, dRadius, nToolNum, n5AxisType) ; + // Controllo utensile + if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) + return false ; + Tool& CurrTool = m_vTool[m_nCurrTool] ; + double dHeight = CurrTool.GetHeigth() - CurrTool.GetTipRadius() ; + double dRadius = CurrTool.GetRadius() ; + CompCyl_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, dHeight, dRadius, nToolNum, n5AxisType) ; - // devo poi togliere la sfera tip iniziale, la sfera tip finale e il cilindro del volume spazzato - Point3d ptTipS = ptS.front() - vtLs.front() * ( CurrTool.GetHeigth() ) ; - Point3d ptTipE = ptE.back() - vtLe.back() * ( CurrTool.GetHeigth() ) ; - CompBall_Milling( nGrid, ptTipS, ptTipE, CurrTool.GetRadius(), CurrTool.GetToolNum()) ; - return true ; + // devo poi togliere la sfera tip iniziale, la sfera tip finale e il cilindro del volume spazzato + Point3d ptTipS = ptS - vtLs * ( CurrTool.GetHeigth()) ; + Point3d ptTipE = ptE - vtLe * ( CurrTool.GetHeigth()) ; + CompBall_Milling( nGrid, ptTipS, ptTipE, CurrTool.GetRadius(), CurrTool.GetToolNum()) ; + return true ; } //---------------------------------------------------------------------------- bool -VolZmap::CompConus_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, double dHei, double dMaxRad, double dMinRad, +VolZmap::CompConus_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, double dHei, double dMaxRad, double dMinRad, bool bTapB, bool bTapT, const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum, int n5AxisType) { - // come per le altre funzioni che lavorano con i coni, se il cono è inverso ( che va allargandosi andando verso il fondo del tool), allora i vtL passati sono invertiti rispetto a quelli - // reali del tool e i punti ptS e ptE sono invertiti( così come dMaxRad e dMinRad) + // come per le altre funzioni che lavorano con i coni, se il cono è inverso ( che va allargandosi andando verso il fondo del tool), allora i vtL passati sono invertiti rispetto a quelli + // reali del tool e i punti ptS e ptE sono invertiti( così come dMaxRad e dMinRad) - // al momento i bool bTapB e bTapT vengono ignorati e di default si crea un volume chiuso con anche le superfici superiore e inferiore. + // al momento i bool bTapB e bTapT vengono ignorati e di default si crea un volume chiuso con anche le superfici superiore e inferiore. - // Controllo utensile - if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) - return false ; + // Controllo utensile + if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) + return false ; - // tolgo il valume spazzato dal tool durante il movimento - return Comp_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, dHei, dMaxRad, dMinRad, nToolNum, n5AxisType) ; + // tolgo il valume spazzato dal tool durante il movimento + return Comp_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, dHei, dMaxRad, dMinRad, nToolNum, n5AxisType) ; } //---------------------------------------------------------------------------- bool -VolZmap::Conus_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType) +VolZmap::Conus_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, int n5AxisType) { - // Controllo utensile - if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) - return false ; - // recupero le info del tool - Tool& CurrTool = m_vTool[m_nCurrTool] ; - double dHeight = CurrTool.GetHeigth() ; - double dRadius = CurrTool.GetRadius() ; - double dTipRadius = CurrTool.GetTipRadius() ; + // Controllo utensile + if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) + return false ; + // recupero le info del tool + Tool& CurrTool = m_vTool[m_nCurrTool] ; + double dHeight = CurrTool.GetHeigth() ; + double dRadius = CurrTool.GetRadius() ; + double dTipRadius = CurrTool.GetTipRadius() ; - double dStemHeigth = dHeight - CurrTool.GetTipHeigth() ; + double dStemHeigth = dHeight - CurrTool.GetTipHeigth() ; - // elimino la parte del volume spazzato dalla parte cilindrica del tool - Cyl_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, nToolNum, CurrTool.GetTipHeigth(), n5AxisType) ; + // elimino la parte del volume spazzato dalla parte cilindrica del tool + Cyl_5AxisMilling( nGrid, ptS, ptE, vtLs, vtLe, nToolNum, CurrTool.GetTipHeigth(), n5AxisType) ; - // elimino la parte spazzata dalla punta conica del tool - if ( CurrTool.GetTipRadius() < dRadius) { - // Trapano - PNTVECTOR ptSConus( ptS.size()) ; - PNTVECTOR ptEConus( ptE.size()) ; - for ( int i = 0 ; i < int( ptS.size()); ++i) { - ptSConus[i] = ptS[i] - dStemHeigth * vtLs[i] ; - ptEConus[i] = ptE[i] - dStemHeigth * vtLe[i] ; - } - CompConus_5AxisMilling( nGrid, ptSConus, ptEConus, vtLs, vtLe, dHeight, - dRadius, dTipRadius, true, false, V_NULL, V_NULL, CurrTool.GetToolNum(), n5AxisType) ; - } - else { - double dHeight = CurrTool.GetHeigth() ; - PNTVECTOR ptSInvertedConus( ptS.size()) ; - PNTVECTOR ptEInvertedConus( ptS.size()) ; - VCT3DVECTOR vNewVtLs( vtLs.size()) ; - VCT3DVECTOR vNewVtLe( vtLe.size()) ; - for ( int i = 0 ; i < int( ptS.size()); ++i) { - ptSInvertedConus[i] = ptS[i] - dHeight * vtLs[i] ; - ptEInvertedConus[i] = ptE[i] - dHeight * vtLe[i] ; - vNewVtLs[i] = - vtLs[i] ; - vNewVtLe[i] = - vtLe[i] ; - } - CompConus_5AxisMilling( nGrid, ptSInvertedConus, ptEInvertedConus, vNewVtLs, vNewVtLe, dHeight, - dTipRadius, dRadius, false, true, V_NULL, V_NULL, CurrTool.GetToolNum(), n5AxisType) ; - } + // elimino la parte spazzata dalla punta conica del tool + if ( CurrTool.GetTipRadius() < dRadius) { + // Trapano + Point3d ptSConus = ptS - dStemHeigth * vtLs ; + Point3d ptEConus = ptE - dStemHeigth * vtLe ; + CompConus_5AxisMilling( nGrid, ptSConus, ptEConus, vtLs, vtLe, dHeight, + dRadius, dTipRadius, true, false, V_NULL, V_NULL, CurrTool.GetToolNum(), n5AxisType) ; + } + else { + double dHeight = CurrTool.GetHeigth() ; + Point3d ptSInvertedConus = ptS - dHeight * vtLs ; + Point3d ptEInvertedConus = ptE - dHeight * vtLe ; + Vector3d vNewVtLs = - vtLs ; + Vector3d vNewVtLe = - vtLe ; + CompConus_5AxisMilling( nGrid, ptSInvertedConus, ptEInvertedConus, vNewVtLs, vNewVtLe, dHeight, + dTipRadius, dRadius, false, true, V_NULL, V_NULL, CurrTool.GetToolNum(), n5AxisType) ; + } - return true ; + return true ; } //---------------------------------------------------------------------------- bool -VolZmap::SelectGeneralMotion( int nGrid, const PNTVECTOR& ptPs, const PNTVECTOR& ptPe, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int n5AxisType) +VolZmap::SelectGeneralMotion( int nGrid, const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtLs, const Vector3d& vtLe, int n5AxisType) { - // Controllo utensile - if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) - return false ; - Tool& CurrTool = m_vTool[m_nCurrTool] ; + // Controllo utensile + if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) + return false ; + Tool& CurrTool = m_vTool[m_nCurrTool] ; - switch ( CurrTool.GetType()) { - case Tool::GEN : - return GenTool_5AxisMilling( nGrid, ptPs, ptPe, vtLs, vtLe, CurrTool.GetToolNum(), n5AxisType) ; - case Tool::CYLMILL : - return Cyl_5AxisMilling( nGrid, ptPs, ptPe, vtLs, vtLe, CurrTool.GetToolNum(), 0, n5AxisType) ; - case Tool::BALLMILL : - return CylBall_5AxisMilling( nGrid, ptPs, ptPe, vtLs, vtLe, CurrTool.GetToolNum(), n5AxisType) ; - case Tool::CONEMILL : - return Conus_5AxisMilling( nGrid, ptPs, ptPe, vtLs, vtLe, CurrTool.GetToolNum(), n5AxisType) ; - case Tool::MORTISER : - return false ; // in realtà potremmo accettare un moto con un angolo solo along - case Tool::CHISEL : - return false ; - } + switch ( CurrTool.GetType()) { + case Tool::GEN : + return GenTool_5AxisMilling( nGrid, ptPs, ptPe, vtLs, vtLe, CurrTool.GetToolNum(), n5AxisType) ; + case Tool::CYLMILL : + return Cyl_5AxisMilling( nGrid, ptPs, ptPe, vtLs, vtLe, CurrTool.GetToolNum(), 0, n5AxisType) ; + case Tool::BALLMILL : + return CylBall_5AxisMilling( nGrid, ptPs, ptPe, vtLs, vtLe, CurrTool.GetToolNum(), n5AxisType) ; + case Tool::CONEMILL : + return Conus_5AxisMilling( nGrid, ptPs, ptPe, vtLs, vtLe, CurrTool.GetToolNum(), n5AxisType) ; + case Tool::MORTISER : + return false ; // in realtà potremmo accettare un moto con un angolo solo along + case Tool::CHISEL : + return false ; + } - return false ; + return false ; } //---------------------------------------------------------------------------- @@ -2536,79 +2476,50 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co else if ( bAlong) n5AxisType = Move5Axis::NO_BASE_INTERS ; - vector ptLs( nStepCnt) ; - vector ptLe( nStepCnt) ; - vector vtLs( nStepCnt) ; - vector vtLe( nStepCnt) ; + Point3d ptLs[N_MAPS] ; + Point3d ptLe[N_MAPS] ; + Vector3d vtLs[N_MAPS] ; + Vector3d vtLe[N_MAPS] ; - // calcolo gli step (anticipo un poco gli inizi intermedi) - for ( int i = 0 ; i < nStepCnt ; ++ i) { - double dCoeffS = max( ( i - 0.05) / nStepCnt, 0.) ; - double dCoeffE = min( ( i + 1.) / nStepCnt, 1.) ; - Point3d ptSti = Media( ptPs, ptPe, dCoeffS) ; - Vector3d vtDSi = Media( vtDs, vtDe, dCoeffS) ; vtDSi.Normalize() ; - Point3d ptEni = Media( ptPs, ptPe, dCoeffE) ; - Vector3d vtDEi = Media( vtDs, vtDe, dCoeffE) ; vtDEi.Normalize() ; + // calcolo gli step (anticipo un poco gli inizi intermedi) + for ( int i = 0 ; i < nStepCnt ; ++i) { + double dCoeffS = max(( i - 0.05) / nStepCnt, 0.) ; + double dCoeffE = min(( i + 1.) / nStepCnt, 1.) ; + Point3d ptSti = Media( ptPs, ptPe, dCoeffS) ; + Vector3d vtDSi = Media( vtDs, vtDe, dCoeffS) ; vtDSi.Normalize() ; + Point3d ptEni = Media( ptPs, ptPe, dCoeffE) ; + Vector3d vtDEi = Media( vtDs, vtDe, dCoeffE) ; vtDEi.Normalize() ; - InitializePointsAndVectors( ptSti, ptEni, vtDSi, vtDEi, ptLs[i], ptLe[i], vtLs[i], vtLe[i]) ; - } + InitializePointsAndVectors( ptSti, ptEni, vtDSi, vtDEi, ptLs, ptLe, vtLs, vtLe); - // Standarda è multithread - constexpr bool MULTITHREAD = false ; - if ( MULTITHREAD) { + // Standard è multithread + constexpr bool MULTITHREAD = true; + if ( MULTITHREAD) { + // Ciclo sulle mappe + vector> vRes( m_nMapNum) ; - // Ciclo sulle mappe - vector< future> vRes( m_nMapNum) ; + for ( int j = 0 ; j < m_nMapNum ; ++j) { + vRes[j] = async(launch::async, &VolZmap::SelectGeneralMotion, this, j, cref(ptLs[j]), cref(ptLe[j]), cref(vtLs[j]), cref(vtLe[j]), n5AxisType) ; + } - vector ptLs_j( m_nMapNum) ; - vector ptLe_j( m_nMapNum) ; - vector vtLs_j( m_nMapNum) ; - vector vtLe_j( m_nMapNum) ; - for ( int j = 0 ; j < m_nMapNum ; ++j) { - ptLs_j[j].resize( nStepCnt) ; - ptLe_j[j].resize( nStepCnt) ; - vtLs_j[j].resize( nStepCnt) ; - vtLe_j[j].resize( nStepCnt) ; - for ( int k = 0 ; k < nStepCnt ; ++k) { - ptLs_j[j][k] = ptLs[k][j] ; - ptLe_j[j][k] = ptLe[k][j] ; - vtLs_j[j][k] = vtLs[k][j] ; - vtLe_j[j][k] = vtLe[k][j] ; - } - } + int nTerminated = 0; + while ( nTerminated < m_nMapNum) { + for ( int j = 0 ; j < m_nMapNum ; ++j) { + if ( vRes[j].valid() && vRes[j].wait_for(chrono::nanoseconds{ 1 }) == future_status::ready) { + bOk = vRes[j].get() && bOk ; + ++nTerminated ; + } + } + } + } - for ( int j = 0 ; j < m_nMapNum ; ++ j) { - vRes[j] = async( launch::async, &VolZmap::SelectGeneralMotion, this, j, cref( ptLs_j[j]), cref( ptLe_j[j]), - cref( vtLs_j[j]), cref( vtLe_j[j]), n5AxisType) ; - } - - int nTerminated = 0 ; - while ( nTerminated < m_nMapNum) { - for ( int j = 0 ; j < m_nMapNum ; ++ j) { - if ( vRes[j].valid() && vRes[j].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) { - bOk = vRes[j].get() && bOk ; - ++ nTerminated ; - } - } - } - } - - // !!!! NON MULTITHREAD : SOLO PER DEBUG !!!! - else { - // Ciclo sulle mappe - for ( int j = 0 ; j < m_nMapNum ; ++j) { - PNTVECTOR ptLs_j( nStepCnt) ; - PNTVECTOR ptLe_j( nStepCnt) ; - VCT3DVECTOR vtLs_j( nStepCnt) ; - VCT3DVECTOR vtLe_j( nStepCnt) ; - for ( int k = 0 ; k < nStepCnt ; ++k) { - ptLs_j[k] = ptLs[k][j] ; - ptLe_j[k] = ptLe[k][j] ; - vtLs_j[k] = vtLs[k][j] ; - vtLe_j[k] = vtLe[k][j] ; - } - bOk = SelectGeneralMotion( j, ptLs_j, ptLe_j, vtLs_j,vtLe_j, n5AxisType) && bOk ; - } + // !!!! NON MULTITHREAD : SOLO PER DEBUG !!!! + else { + // Ciclo sulle mappe + for ( int j = 0; j < m_nMapNum; ++j) { + bOk = SelectGeneralMotion(j, ptLs[j], ptLe[j], vtLs[j], vtLe[j], n5AxisType) && bOk ; + } + } } return bOk ;