From b083dabc6be6683ba43efb3b92567f30db2f0888 Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Wed, 24 Sep 2025 09:35:52 +0200 Subject: [PATCH 1/9] EgtGeomKernel : - correzione piccolo errore --- VolZmapVolume.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 5a86031..3558439 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -863,6 +863,8 @@ GetCylMoveRotBBox( const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV Vector3d vtDirTop = ptP2 - ptP1 ; Vector3d vtDirTip = ptP2T - ptP1T ; + vtDirTop.Normalize() ; + vtDirTip.Normalize() ; // determino i punti laterali del top e del bottom(tip), nella posizione di partenza Vector3d vtAuxTopS = vtV1 ^ vtDirTop ; From 40b6da6b449ee4c1efe9b27ef0ba54af914ea94d Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Wed, 24 Sep 2025 09:46:02 +0200 Subject: [PATCH 2/9] EgtGeomKernel : - correzione selezione caso VM5assi. --- VolZmapVolume.cpp | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 3558439..16af3bd 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -2438,7 +2438,7 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) { // Flag per impostare vecchia (approssimativa) o nuova modalità di calcolo - constexpr bool OLD_LINEAR = true ; + constexpr bool OLD_LINEAR = false ; // Deve essere definito l'utensile corrente if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) @@ -2535,8 +2535,12 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co else n5AxisType = Move5Axis::NO_BASE_INTERS ; } - else if ( bAlong) - n5AxisType = Move5Axis::NO_BASE_INTERS ; + else if (bAlong) { + if (bAlongInters) + n5AxisType = Move5Axis::ACROSS; + else + n5AxisType = Move5Axis::NO_BASE_INTERS; + } vector ptLs( nStepCnt) ; vector ptLe( nStepCnt) ; From 098bdd00767a8f6a3157f6a0bc92b74c7deada4c Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Wed, 24 Sep 2025 10:29:57 +0200 Subject: [PATCH 3/9] 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 ; From 7c90dbabea89f1fd768561f93c6b8b3593017bc9 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Wed, 24 Sep 2025 10:38:35 +0200 Subject: [PATCH 4/9] EgtGeomKernel 2.7i6 : - ricompilazione con cambio versione (e abilitato multithread in MillingGeneralMotionStep). --- EgtGeomKernel.rc | Bin 11710 -> 11710 bytes VolZmapVolume.cpp | 4 ++-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index 8ec656243508a6bcdce61d6a2045e43141596bd8..2d29c2b3858c71711c2eabe1643d0e60cd010592 100644 GIT binary patch delta 94 zcmdlNy)SyhFE&QA&A-_cnHkL{D{|{@_Trkr0u;H;XNwSVW8B;$>;>dw2zN+>g;Df- LFmBFL4&ed-XmlGI delta 94 zcmdlNy)SyhFE&Qg&A-_cnHfzdD{|{@_Trkr0u;H;XNwSVW8B;$>;>dw2zN+>g;Df- LFmBFL4&ed-X4V@L diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 16af3bd..bb167e9 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -2559,8 +2559,8 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co InitializePointsAndVectors( ptSti, ptEni, vtDSi, vtDEi, ptLs[i], ptLe[i], vtLs[i], vtLe[i]) ; } - // Standarda è multithread - constexpr bool MULTITHREAD = false ; + // Standard è multithread + constexpr bool MULTITHREAD = true ; if ( MULTITHREAD) { // Ciclo sulle mappe From 61fc8145280a41f9e0986e5f97b690fa0d108eff Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Wed, 24 Sep 2025 17:19:37 +0200 Subject: [PATCH 5/9] EgtGeomKernel : - piccola modifica per migliorare ricerca di inizio con stringa (starts_with). --- GeomDB.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/GeomDB.cpp b/GeomDB.cpp index 565299e..2edf165 100644 --- a/GeomDB.cpp +++ b/GeomDB.cpp @@ -877,7 +877,7 @@ GeomDB::GetFirstNameInGroup( int nGroupId, const string& sName) const // se ha il nome o la parte iniziale di nome cercato string sObjName ; if ( pGdbO->GetName( sObjName) && - (( ! bWild && sObjName == sToFind) || ( bWild && sObjName.find( sToFind) == 0))) + (( ! bWild && sObjName == sToFind) || ( bWild && sObjName.rfind( sToFind, 0) == 0))) return ( pGdbO->m_nId) ; // passo al successivo pGdbO = pGdbO->GetNext() ; @@ -905,7 +905,7 @@ GeomDB::GetNextName( int nId, const string& sName) const // se ha il nome o la parte iniziale di nome cercato string sObjName ; if ( pGdbNext->GetName( sObjName) && - (( ! bWild && sObjName == sToFind) || ( bWild && sObjName.find( sToFind) == 0))) + (( ! bWild && sObjName == sToFind) || ( bWild && sObjName.rfind( sToFind, 0) == 0))) return ( pGdbNext->m_nId) ; // passo al successivo pGdbNext = pGdbNext->GetNext() ; @@ -933,7 +933,7 @@ GeomDB::GetLastNameInGroup( int nGroupId, const string& sName) const // se ha il nome o la parte iniziale di nome cercato string sObjName ; if ( pGdbO->GetName( sObjName) && - (( ! bWild && sObjName == sToFind) || ( bWild && sObjName.find( sToFind) == 0))) + (( ! bWild && sObjName == sToFind) || ( bWild && sObjName.rfind( sToFind, 0) == 0))) return ( pGdbO->m_nId) ; // passo al precedente pGdbO = pGdbO->GetPrev() ; @@ -961,7 +961,7 @@ GeomDB::GetPrevName( int nId, const string& sName) const // se ha il nome o la parte iniziale di nome cercato string sObjName ; if ( pGdbPrev->GetName( sObjName) && - (( ! bWild && sObjName == sToFind) || ( bWild && sObjName.find( sToFind) == 0))) + (( ! bWild && sObjName == sToFind) || ( bWild && sObjName.rfind( sToFind, 0) == 0))) return ( pGdbPrev->m_nId) ; // passo al precedente pGdbPrev = pGdbPrev->GetPrev() ; From 563697f84083f19837d14e6cdeb07400f4168f1e Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Fri, 26 Sep 2025 10:47:06 +0200 Subject: [PATCH 6/9] EgtGeomKernel : - correzione al box del volume spazzato VM 5assi - modificata gestione conversione curve a bezier. --- CurveAux.cpp | 51 ++++++++++++++++--------- VolZmapVolume.cpp | 96 +++++------------------------------------------ 2 files changed, 43 insertions(+), 104 deletions(-) diff --git a/CurveAux.cpp b/CurveAux.cpp index 938a5e3..ce190e1 100644 --- a/CurveAux.cpp +++ b/CurveAux.cpp @@ -544,6 +544,13 @@ ArcToBezierCurve( const ICurveArc* pArc, int nDeg, bool bMakeRatOrNot) PtrOwner pCrvBez( CreateBasicCurveBezier()) ; if ( IsNull( pCrvBez) || ! pCrvBez->FromArc( *pArc)) return nullptr ; + if ( ! bMakeRatOrNot) { + Point3d ptCen = pArc->GetCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; + pCrvBez.Set( ApproxArcCurveBezierWithSingleCubic( pCrvBez, ptCen, vtN)) ; + } + if ( IsNull( pCrvBez)) + return nullptr ; // aumento il grado della curva come richiesto while ( pCrvBez->GetDegree() < nDeg) pCrvBez.Set( BezierIncreaseDegree( pCrvBez)) ; @@ -926,10 +933,8 @@ ApproxBezierWithCubics(const ICurve* pCrv, double dTol) Vector3d vtStartDir, vtEndDir ; pCrvBezier->GetPointD1D2( 0, ICurve::FROM_MINUS, ptStart, &vtStartDir) ; pCrvBezier->GetPointD1D2( 1, ICurve::FROM_PLUS, ptEnd, &vtEndDir) ; - Plane3d plPLane ; - plPLane.Set( ptStart, ptCtrl, ptEnd) ; - vtStartDir.Rotate( plPLane.GetVersN(), 90) ; - vtEndDir.Rotate( plPLane.GetVersN(), 90) ; + vtStartDir.Rotate( vtN, 90) ; + vtEndDir.Rotate( vtN, 90) ; Point3d ptAux1 = ptStart + vtStartDir ; Point3d ptAux2 = ptEnd + vtEndDir ; PtrOwner pCL1( CreateBasicCurveLine()) ; @@ -944,7 +949,7 @@ ApproxBezierWithCubics(const ICurve* pCrv, double dTol) double dDist2 = Dist( ptEnd, ptCen) ; if ( abs(dDist1 - dDist2) < EPS_SMALL ) { CurveArc cArc ; - cArc.SetC2PN( ptCen, ptStart, ptEnd, plPLane.GetVersN()) ; + cArc.SetC2PN( ptCen, ptStart, ptEnd, vtN) ; // controllo se il raggio della circonferenza risultante coincide con quello calcolato prima // impongo inoltre che l'angolo al centro sia minore di 90 gradi if ( abs( cArc.GetRadius() - dDist1) < EPS_SMALL && cArc.GetAngCenter() < 90 + EPS_SMALL) @@ -988,7 +993,7 @@ ApproxBezierWithCubics(const ICurve* pCrv, double dTol) if ( ! bIsArc) pCrvCubic.Set( ApproxCurveBezierWithSingleCubic( pCrvPart)) ; else { - pCrvCubic.Set( ApproxArcCurveBezierWithSingleCubic( pCrvPart, ptCen)) ; + pCrvCubic.Set( ApproxArcCurveBezierWithSingleCubic( pCrvPart, ptCen, vtN)) ; if ( IsNull( pCrvCubic)) { // se fallisce allora riprovo usando più di una bezier bIsArc = false ; @@ -1062,12 +1067,21 @@ ApproxCurveBezierWithSingleCubic( const ICurve* pCrv) //---------------------------------------------------------------------------- ICurveBezier* -ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen) +ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen, const Vector3d& vtN) { - // verifico sia una bezier - const CurveBezier* pCrvBez = GetBasicCurveBezier( pCrv) ; - if ( pCrvBez == nullptr) - return nullptr ; + // verifico sia una bezier + const CurveBezier* pCrvBez = GetBasicCurveBezier( pCrv) ; + if ( pCrvBez == nullptr) + return nullptr ; + + // mi metto nel frame della curva ( lavoro nel piano XY) + Point3d ptStart = pCrvBez->GetControlPoint( 0) ; + Point3d ptEnd = pCrvBez->GetControlPoint( 2) ; + Frame3d frCrv; frCrv.Set( ptStart, vtN) ; + ptStart = ORIG ; + ptEnd.ToLoc( frCrv) ; + Point3d ptCenLoc = ptCen ; + ptCenLoc.ToLoc( frCrv) ; // converto una curva di bezier che definisce un arco perfetto di circonferenza // dato il centro( della circonferenza), inizio e fine @@ -1077,9 +1091,7 @@ ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen) bool bRat = pCrvBez->IsRational() ; if ( nDeg != 2 || ! bRat) return nullptr ; - - Point3d ptStart = pCrvBez->GetControlPoint( 0) ; - Point3d ptEnd = pCrvBez->GetControlPoint( 2) ; + if ( AreSamePointEpsilon( ptStart, ptEnd, EPS_SMALL * 50)) return nullptr ; nDeg = 3 ; @@ -1089,10 +1101,10 @@ ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen) pCrvCubic->SetControlPoint( 3, ptEnd) ; // from the article of Aleksas Riškus "Approximation of a cubic bezier curve by circular arcs and vice versa" // with corrections from "Hans Muller's Flex Blog", page "More About Approximating Circular Arcs With a Cubic Bezier Path" - double ax = ptStart.x - ptCen.x ; - double ay = ptStart.y - ptCen.y ; - double bx = ptEnd.x - ptCen.x ; - double by = ptEnd.y - ptCen.y ; + double ax = ptStart.x - ptCenLoc.x ; + double ay = ptStart.y - ptCenLoc.y ; + double bx = ptEnd.x - ptCenLoc.x ; + double by = ptEnd.y - ptCenLoc.y ; double q1 = ax * ax + ay * ay ; double q2 = q1 + ax * bx + ay * by ; double k2 = 4. / 3 * ( sqrt( 2 * q1 * q2) - q2) / ( ax * by - ay * bx) ; @@ -1104,6 +1116,9 @@ ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen) pCrvCubic->SetControlPoint( 1, ptCtrl1) ; pCrvCubic->SetControlPoint( 2, ptCtrl2) ; + // ritorno nel frame originale + pCrvCubic->ToGlob( frCrv) ; + return Release( pCrvCubic) ; } diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 412a668..20d1825 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -857,66 +857,16 @@ GetCylMoveBBox( const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, d 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 ; + // costruisco gli archi che definiscono il top e bottom del tool di partenza nel loro riferimento e li porto nel frame + BBox3d bbStart = GetCylMoveBBox( ptP1, ptP1, vtV1, dRad, dH) ; + BBox3d bbEnd = GetCylMoveBBox( ptP2, ptP2, vtV2, dRad, dH) ; + + // sommo i due box e li restituisco + BBox3d bbVol ; + bbVol.Add( bbStart) ; + bbVol.Add( bbEnd) ; - Vector3d vtDirTop = ptP2 - ptP1 ; - Vector3d vtDirTip = ptP2T - ptP1T ; - vtDirTop.Normalize() ; - vtDirTip.Normalize() ; - - // 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 anche i punti estremi iniziali e finali dei cilindri - Point3d ptTopEnd, ptBottomEnd, ptTopStart, ptBottomStart ; - ptTopEnd = ptP2 + vtDirTop * dRad ; - ptBottomEnd = ptP2T + vtDirTip * dRad ; - ptTopStart = ptP1 - vtDirTop * dRad ; - ptBottomStart = ptP1T - vtDirTip * dRad ; - - // 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) ; - b3Box.Add( ptTopEnd) ; - b3Box.Add( ptBottomEnd) ; - b3Box.Add( ptTopStart) ; - b3Box.Add( ptBottomStart) ; - - // Restituisco il box calcolato - return b3Box ; + return bbVol ; } //---------------------------------------------------------------------------- @@ -1599,10 +1549,6 @@ Reiterate : return true ; } -#if true - #define TEST -#endif - //---------------------------------------------------------------------------- bool VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, @@ -1999,11 +1945,6 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c } } -#ifdef TEST - vector vGeo ; - vector vCol( nTotSurf) ; -#endif - // 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) ; @@ -2070,23 +2011,6 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c vSurfBez[nSurfInd].bbSurfY.Add( vPtCtrlLoc) ; } -#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 ; int nLastForwardJ = -1 ; @@ -2499,7 +2423,7 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co InitializePointsAndVectors( ptSti, ptEni, vtDSi, vtDEi, ptLs, ptLe, vtLs, vtLe); // Standard è multithread - constexpr bool MULTITHREAD = true; + constexpr bool MULTITHREAD = true ; if ( MULTITHREAD) { // Ciclo sulle mappe vector> vRes( m_nMapNum) ; From 137289e843defe72c338589acc462787532f718c Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Fri, 26 Sep 2025 11:00:20 +0200 Subject: [PATCH 7/9] EgtGeomKernel : - correzione del merge. --- VolZmapVolume.cpp | 134 ++++++++++------------------------------------ 1 file changed, 27 insertions(+), 107 deletions(-) diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index ac69c50..915532e 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -2010,6 +2010,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c vPtCtrlLoc[p].ToLoc( vSurfBez[nSurfInd].frYMainDim) ; vSurfBez[nSurfInd].bbSurfY.Add( vPtCtrlLoc) ; } + } // scorro tutti gli spilloni interessati int j = 0 ; @@ -2406,131 +2407,50 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co n5AxisType = Move5Axis::NO_BASE_INTERS; } -<<<<<<< HEAD - Point3d ptLs[N_MAPS] ; - Point3d ptLe[N_MAPS] ; - Vector3d vtLs[N_MAPS] ; - Vector3d vtLe[N_MAPS] ; + 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() ; - - InitializePointsAndVectors( ptSti, ptEni, vtDSi, vtDEi, ptLs, ptLe, vtLs, vtLe); - - // Standard è multithread - constexpr bool MULTITHREAD = true ; - if ( MULTITHREAD) { - // Ciclo sulle mappe - vector> 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) ; - } - - 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) { - bOk = SelectGeneralMotion(j, ptLs[j], ptLe[j], vtLs[j], vtLe[j], n5AxisType) && bOk ; - } - } -======= - vector ptLs( nStepCnt) ; - vector ptLe( nStepCnt) ; - vector vtLs( nStepCnt) ; - vector vtLe( nStepCnt) ; - - // 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.) ; + 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) ; - // Standard è multithread - constexpr bool MULTITHREAD = true ; - 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) ; - // Standard è multithread - constexpr bool MULTITHREAD = true ; - if ( MULTITHREAD) { - // Ciclo sulle mappe - vector> vRes( m_nMapNum) ; - - 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] ; + 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) ; } - } - 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 ; + 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] ; + // !!!! 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 ; } - bOk = SelectGeneralMotion( j, ptLs_j, ptLe_j, vtLs_j,vtLe_j, n5AxisType) && bOk ; } ->>>>>>> master } return bOk ; From 4cf4a99107f98d01cc3d49695027a604cb055cb3 Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Fri, 26 Sep 2025 12:10:18 +0200 Subject: [PATCH 8/9] EgtGeomKernel : - puliza codice. --- VolZmapVolume.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 915532e..73740ee 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -26,7 +26,6 @@ #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 @@ -2400,11 +2399,11 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co else n5AxisType = Move5Axis::NO_BASE_INTERS ; } - else if (bAlong) { - if (bAlongInters) - n5AxisType = Move5Axis::ACROSS; + else if ( bAlong) { + if ( bAlongInters) + n5AxisType = Move5Axis::ACROSS ; else - n5AxisType = Move5Axis::NO_BASE_INTERS; + n5AxisType = Move5Axis::NO_BASE_INTERS ; } Point3d ptLs[N_MAPS] ; @@ -2424,7 +2423,7 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co InitializePointsAndVectors( ptSti, ptEni, vtDSi, vtDEi, ptLs, ptLe, vtLs, vtLe) ; // Standard è multithread - constexpr bool MULTITHREAD = true ; + constexpr bool MULTITHREAD = false ; if ( MULTITHREAD) { // Ciclo sulle mappe vector> vRes( m_nMapNum) ; From 00b6f8583af0aac25643e28a76ca40ce1a8cb98d Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Fri, 26 Sep 2025 12:48:48 +0200 Subject: [PATCH 9/9] EgtGeomKernel : - piccola correzione. --- VolZmapVolume.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 73740ee..b306385 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -2009,6 +2009,8 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c vPtCtrlLoc[p].ToLoc( vSurfBez[nSurfInd].frYMainDim) ; vSurfBez[nSurfInd].bbSurfY.Add( vPtCtrlLoc) ; } + + ++ nSurfInd ; } // scorro tutti gli spilloni interessati @@ -2423,7 +2425,7 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co InitializePointsAndVectors( ptSti, ptEni, vtDSi, vtDEi, ptLs, ptLe, vtLs, vtLe) ; // Standard è multithread - constexpr bool MULTITHREAD = false ; + constexpr bool MULTITHREAD = true ; if ( MULTITHREAD) { // Ciclo sulle mappe vector> vRes( m_nMapNum) ;