From 29c00caf4abf2626db1ceca280a5f2e0ff3141fb Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Thu, 14 Sep 2023 17:25:04 +0200 Subject: [PATCH] EgtGeomKernel : - razionalizzazione di alcune funzioni di Zmap per taglio spilloni. --- VolZmap.cpp | 2 +- VolZmapVolume.cpp | 484 +++++++++++++++++++++++++--------------------- 2 files changed, 266 insertions(+), 220 deletions(-) diff --git a/VolZmap.cpp b/VolZmap.cpp index 428d534..481095d 100644 --- a/VolZmap.cpp +++ b/VolZmap.cpp @@ -208,7 +208,7 @@ VolZmap::Dump( string& sOut, bool bMM, const char* szNewLine) const } sOut += szNewLine ; // passo - sOut += "Step=" + ToString( GetInUiUnits( m_dStep, bMM), 3) + szNewLine ; + sOut += "Step=" + ToString( GetInUiUnits( m_dStep, bMM), 6) + szNewLine ; // dimensioni if ( m_nMapNum == 1) sOut += "Dim=" + ToString( m_nDim[0]) + diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 5b665e7..7b83bec 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -18,8 +18,8 @@ #include "CurveArc.h" #include "VolZmap.h" #include "GeoConst.h" -#include "/EgtDev/Include/EgtNumUtils.h" #include "/EgtDev/Include/EGkStringUtils3d.h" +#include "/EgtDev/Include/EgtNumUtils.h" #include "/EgtDev/Include/EgtPerfCounter.h" #include @@ -600,7 +600,15 @@ VolZmap::MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const Vector3d vtLs[N_MAPS] ; Vector3d vtALs[N_MAPS] ; InitializePointsAndVectors( ptPs, ptPe, vtD, vtA, ptLs, ptLe, vtLs, vtALs) ; - // Ciclo sulle mappe + // Ciclo sulle mappe (scommentare solo per DEBUG) + //{ + // bool bOk = true ; + // for ( int i = 0 ; i < m_nMapNum ; ++ i) { + // bOk = SelectMotion( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) && bOk ; + // } + // return true ; + //} + // Ciclo sulle mappe vector< future> vRes ; vRes.resize( m_nMapNum) ; for ( int i = 0 ; i < m_nMapNum ; ++ i) { @@ -3222,13 +3230,13 @@ VolZmap::GenTool_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, con const ICurveLine* pLine = GetCurveLine( pCurve) ; Point3d ptStart = pLine->GetStart() ; Point3d ptEnd = pLine->GetEnd() ; - int nNormNum = pLine->GetTempProp(); - Vector3d vtNormSt, vtNormEn; + int nNormNum = pLine->GetTempProp() ; + Vector3d vtNormSt, vtNormEn ; if ( nNormNum != 0) { vtNormSt = vArcNorm[nNormNum - 1] ; vtNormEn = vArcNorm[nNormNum] ; - vtNormSt.ToLoc(frNormFrame); - vtNormEn.ToLoc(frNormFrame); + vtNormSt.ToLoc( frNormFrame) ; + vtNormEn.ToLoc( frNormFrame) ; } // Ne determino l'altezza dHeight = abs( ptStart.y - ptEnd.y) ; @@ -3258,21 +3266,21 @@ VolZmap::GenTool_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, con if ( dRadius > 10 * EPS_SMALL) CompCyl_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius, bTapB, bTapT, CurrTool.GetToolNum()) ; } - // Se X crescente, è un cono con vettore equiverso a quello dell'utensile + // se altrimenti X decrescente, è un cono con vettore equiverso a quello dell'utensile else if ( ptStart.x > ptEnd.x) { double dMaxRad = ptStart.x ; double dMinRad = ptEnd.x ; CompConus_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad, bTapB, bTapT, vtNormSt, vtNormEn, CurrTool.GetToolNum()) ; } - // Se X decrescente, è un cono con vettore opposto a quello dell'utensile - else if ( ptStart.x < ptEnd.x) { + // altrimenti X crescente, è un cono con vettore opposto a quello dell'utensile + else { double dMaxRad = ptEnd.x ; double dMinRad = ptStart.x ; Point3d ptIn = ptI - vtToolDir * dHeight ; Point3d ptFn = ptIn + vtMove ; - vtNormEn.z *= -1 ; - vtNormSt.z *= -1 ; + vtNormEn.z = -vtNormEn.z ; + vtNormSt.z = -vtNormSt.z ; CompConus_Milling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad, bTapT, bTapB, vtNormEn, vtNormSt, CurrTool.GetToolNum()) ; } @@ -4287,7 +4295,23 @@ VolZmap::CompCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, } return true ; } - + +//---------------------------------------------------------------------------- +static Vector3d +AdjustConeNormal( const Point3d& ptInt, const Vector3d& vtN, const Point3d& ptV, const Vector3d& vtToolDir, + double dMinRad, double dDeltaR, const Vector3d& vtArcNormMinR, const Vector3d& vtArcNormMaxR) +{ + if ( AreSameOrOppositeVectorEpsilon( vtN, vtToolDir, 0.1 * EPS_SMALL)) + return vtN ; + Vector3d vtL = ( ptInt - ptV) - (( ptInt - ptV) * vtToolDir) * vtToolDir ; + double dL = vtL.Len() ; + vtL /= dL ; + Vector3d vtOriginalN = ( ( dDeltaR - dL + dMinRad) / dDeltaR) * vtArcNormMinR + ((dL - dMinRad) / dDeltaR) * vtArcNormMaxR ; + Vector3d vtNewN = - vtOriginalN.z * vtToolDir - vtOriginalN.x * vtL ; + vtNewN.Normalize() ; + return vtNewN ; +} + //---------------------------------------------------------------------------- bool VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, @@ -4303,8 +4327,10 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c double dDeltaR = dMaxRad - dMinRad ; // Studio simmetrie - Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ; - Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ; + Point3d ptI = ptS ; + Point3d ptF = ptE ; + if ( vtToolDir * ( ptE - ptS) <= 0) + swap( ptI, ptF) ; double dL = ( dMaxRad * dHei) / dDeltaR ; double dl = dL - dHei ; @@ -4366,7 +4392,8 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c Point3d ptFacet135( 0, 0, dLenZ) ; Point3d ptFacet246( dLenX + dDeltaX, dLenY + dDeltaY, - dLenZ - dDeltaZ) ; - Vector3d vtUmv = vtMove ; vtUmv.Normalize() ; + // Necessità ricalcolo normali (perchè variabili per approx curve) + bool bRecalNorm = ( ! vtArcNormMaxR.IsSmall() && ! vtArcNormMinR.IsSmall()) ; if ( dRatio * dTan <= 1) { @@ -4381,27 +4408,9 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c // Cono iniziale ConusFrame.ChangeOrig( ptV) ; if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bTapB, bTapT, ptInt1, vtN1, ptInt2, vtN2)) { - if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { - if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) { - Vector3d vtL1 = ptInt1 - ptV ; - vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ; - double dL1 = vtL1.Len() ; - vtL1 /= dL1 ; - Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ((dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR; - vtOriginalN1.Normalize() ; - vtN1 = - vtOriginalN1.z * vtToolDir - vtOriginalN1.x * vtL1 ; - vtN1.Normalize() ; - } - if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtToolDir, 0.1 * EPS_SMALL)) { - Vector3d vtL2 = ptInt2 - ptV ; - vtL2 -= ( vtL2 * vtToolDir) * vtToolDir ; - double dL2 = vtL2.Len() ; - vtL2 /= dL2 ; - Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN2.Normalize() ; - vtN2 = - vtOriginalN2.z * vtToolDir - vtOriginalN2.x * vtL2 ; - vtN2.Normalize() ; - } + if ( bRecalNorm) { + vtN1 = AdjustConeNormal( ptInt1, vtN1, ptV, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ; + vtN2 = AdjustConeNormal( ptInt2, vtN2, ptV, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ; } SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ; } @@ -4409,191 +4418,246 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c // Cono finale ConusFrame.ChangeOrig( ptV + vtMove) ; if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bTapB, bTapT, ptInt1, vtN1, ptInt2, vtN2)) { - if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { - if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) { - Vector3d vtL1 = ptInt1 - ptV - vtMove ; - vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ; - double dL1 = vtL1.Len() ; - vtL1 /= dL1 ; - Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN1.Normalize() ; - vtN1 = - vtOriginalN1.z * vtToolDir - vtOriginalN1.x * vtL1 ; - vtN1.Normalize() ; - } - if ( ! AreSameOrOppositeVectorEpsilon(vtN2, vtToolDir, 0.1 * EPS_SMALL)) { - Vector3d vtL2 = ptInt2 - ptV - vtMove ; - vtL2 -= (vtL2 * vtToolDir) * vtToolDir; - double dL2 = vtL2.Len() ; - vtL2 /= dL2 ; - Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN2.Normalize() ; - vtN2 = - vtOriginalN2.z * vtToolDir - vtOriginalN2.x * vtL2 ; - vtN2.Normalize() ; - } + if ( bRecalNorm) { + vtN1 = AdjustConeNormal( ptInt1, vtN1, ptV + vtMove, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ; + vtN2 = AdjustConeNormal( ptInt2, vtN2, ptV + vtMove, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ; } SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ; } // Solido interno - Point3d ptPoly = ptC ; - Vector3d vtPoly = Z_AX ; + Point3d ptPoly = GetToLoc( ptC, PolyFrame) ; + Vector3d vtPoly = GetToLoc( Z_AX, PolyFrame) ; - ptPoly.ToLoc( PolyFrame) ; - vtPoly.ToLoc( PolyFrame) ; + // Intervallo di intersezione (infinito) e normali (nulle) + bool bValid = true ; + double dPar1 = -INFINITO ; + double dPar2 = +INFINITO ; + vtN1 = V_NULL ; + vtN2 = V_NULL ; - Point3d ptPoly1 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtNs) / ( vtPoly * vtNs)) * vtPoly ; - Point3d ptPoly2 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtNd) / ( vtPoly * vtNd)) * vtPoly ; - Point3d ptPoly3 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtIF) / ( vtPoly * vtIF)) * vtPoly ; - Point3d ptPoly4 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtIF) / ( vtPoly * vtIF)) * vtPoly ; - Point3d ptPoly5 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtUD) / ( vtPoly * vtUD)) * vtPoly ; - Point3d ptPoly6 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtUD) / ( vtPoly * vtUD)) * vtPoly ; - - int nIntNum = 0 ; - - // Intersezione con la prima faccia - if ( abs( vtPoly * vtNs) > COS_ORTO_ANG_ZERO) { - if ( dLenY * ptPoly1.x >= dLenX * ptPoly1.y && - dLenY * ( ptPoly1.x - dDeltaX) <= dLenX * ( ptPoly1.y - dDeltaY) && - dDeltaX * ptPoly1.y >= dDeltaY * ptPoly1.x && - dDeltaX * ( ptPoly1.y - dLenY) <= dDeltaY * ( ptPoly1.x - dLenX)) { - ptInt1 = ptPoly1 ; - vtN1 = - vtNs ; - if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { - Vector3d vtRadial( 0, dMinRad * dCos, dMinRad * dSin) ; - vtRadial.Normalize() ; - Vector3d vtOrigMaxR = - vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ; - Vector3d vtOrigMinR = - vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ; - vtOrigMaxR.Normalize() ; - vtOrigMinR.Normalize() ; - vtN1 = ( ( dDeltaZ - ptInt1.z + dLenZ) / dDeltaZ) * vtOrigMinR + ( ( ptInt1.z - dLenZ) / dDeltaZ) * vtOrigMaxR ; - vtN1.Normalize() ; + // Verifica con facce iniziale e finale + if ( bValid) { + // Distanza con segno del punto di riferimento del dexel dal piano delle facce iniziale e finale + double dDistI = ( ptPoly - ptFacet135) * -vtIF ; + double dDistF = ( ptPoly - ptFacet246) * vtIF ; + // Se dexel non parallelo alle facce + if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) { + // posizione parametrica delle intersezioni + double dParI = -dDistI / ( vtPoly * -vtIF) ; + double dParF = -dDistF / ( vtPoly * vtIF) ; + // se intervallo tra intersezioni praticamente nullo + if ( abs( dParI - dParF) < EPS_ZERO) + bValid = false ; + // altrimenti + else { + if ( dParI < dParF) { + dPar1 = dParI ; + vtN1 = vtIF ; + dPar2 = dParF ; + vtN2 = -vtIF ; + } + else { + dPar1 = dParF ; + vtN1 = -vtIF ; + dPar2 = dParI ; + vtN2 = vtIF ; + } } - ++ nIntNum ; + } + // altrimenti praticamente parallelo + else { + // se esterno ad almeno uno invalida tutto + if ( dDistI > 0 || dDistF > 0) + bValid = false ; + // altrimenti non cambia niente } } - // Intersezione con la seconda faccia - if ( abs( vtPoly * vtNd) > COS_ORTO_ANG_ZERO) { - if ( dLenY * ptPoly2.x >= dLenX * ptPoly2.y && - dLenY * ( ptPoly2.x - dDeltaX) <= dLenX * ( ptPoly2.y - dDeltaY) && - dDeltaX * ptPoly2.y >= dDeltaY * ptPoly2.x && - dDeltaX * ( ptPoly2.y - dLenY) <= dDeltaY * ( ptPoly2.x - dLenX)) { - if ( nIntNum == 0) { - ptInt1 = ptPoly2 ; - vtN1 = - vtNd ; - if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { - Vector3d vtRadial( 0, dMinRad * dCos, - dMinRad * dSin) ; + // Verifica con facce sopra e sotto + if ( bValid) { + // Distanza con segno del punto di riferimento del dexel dal piano delle facce sopra e sotto + double dDistU = ( ptPoly - ptFacet246) * -vtUD ; + double dDistD = ( ptPoly - ptFacet135) * vtUD ; + // Se dexel non parallelo alle facce + if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) { + // posizione parametrica delle intersezioni + double dParU = -dDistU / ( vtPoly * -vtUD) ; + double dParD = -dDistD / ( vtPoly * vtUD) ; + // se intervallo tra intersezioni praticamente nullo + if ( abs( dParU - dParD) < EPS_ZERO) + bValid = false ; + // altrimenti + else { + if ( dParU < dParD) { + if ( dParD < dPar1 + EPS_ZERO || dParU > dPar2 - EPS_ZERO) + bValid = false ; + else { + if ( dParU > dPar1) { + dPar1 = dParU ; + vtN1 = vtUD ; + } + if ( dParD < dPar2) { + dPar2 = dParD ; + vtN2 = -vtUD ; + } + } + } + else { + if ( dParU < dPar1 + EPS_ZERO || dParD > dPar2 - EPS_ZERO) + bValid = false ; + else { + if ( dParD > dPar1) { + dPar1 = dParD ; + vtN1 = -vtUD ; + } + if ( dParU < dPar2) { + dPar2 = dParU ; + vtN2 = vtUD ; + } + } + } + } + } + // altrimenti praticamente parallelo + else { + // se esterno ad almeno uno invalida tutto + if ( dDistU > 0 || dDistD > 0) + bValid = false ; + // altrimenti non cambia niente + } + } + + // Taglio con la faccia sinistra + if ( bValid) { + // Distanza con segno del punto di riferimento del dexel dal piano della faccia sinistra + double dDistS = ( ptPoly - ptFacet135) * vtNs ; + // Se dexel non parallelo alla faccia + if ( abs( vtPoly * vtNs) > COS_ORTO_ANG_ZERO) { + // posizione parametrica della intersezione + double dParS = -dDistS / ( vtPoly * vtNs) ; + // verifico limitazioni su inizio e fine dell'intervallo + int nLimit = 0 ; + // se limita inizio + if ( vtPoly * vtNs < 0) { + // se oltre la fine, invalida tutto + if ( dParS > dPar2 - EPS_ZERO) + bValid = false ; + // se altrimenti solo oltre inizio, riduce + else if ( dParS >= dPar1) { + dPar1 = dParS ; + nLimit = 1 ; + } + } + // altrimenti limita fine + else { + // se prima dell'inizio, invalida tutto + if ( dParS < dPar1 + EPS_ZERO) + bValid = false ; + // se altrimenti solo prima della fine, riduce + else if ( dParS <= dPar2) { + dPar2 = dParS ; + nLimit = 2 ; + } + } + // se limita, devo aggiornare la normale + if ( nLimit != 0) { + Vector3d vtNewN = -vtNs ; + if ( bRecalNorm) { + Vector3d vtRadial( 0, dMinRad * dCos, dMinRad * dSin) ; vtRadial.Normalize() ; Vector3d vtOrigMaxR = - vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ; Vector3d vtOrigMinR = - vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ; vtOrigMaxR.Normalize() ; vtOrigMinR.Normalize() ; - vtN1 = ( ( dDeltaZ - abs( ptInt1.z) + dLenZ) / dDeltaZ) * vtOrigMinR + ( ( abs( ptInt1.z) - dLenZ) / dDeltaZ) * vtOrigMaxR ; - vtN1.Normalize() ; + Point3d ptInt = ptPoly + dParS * vtPoly ; + vtNewN = ( ( dDeltaZ - ptInt.z + dLenZ) / dDeltaZ) * vtOrigMinR + ( ( ptInt.z - dLenZ) / dDeltaZ) * vtOrigMaxR ; + vtNewN.Normalize() ; } - ++ nIntNum ; - } - else if ( ( ptInt1 - ptPoly2).SqLen() > SQ_EPS_SMALL) { - ptInt2 = ptPoly2 ; - vtN2 = - vtNd ; - if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { + if ( nLimit == 1) + vtN1 = vtNewN ; + else + vtN2 = vtNewN ; + } + } + // altrimenti praticamente parallelo + else { + // se esterno invalida tutto + if ( dDistS > 0) + bValid = false ; + // altrimenti non cambia niente + } + } + + // Taglio con la faccia destra + if ( bValid) { + // Distanza con segno del punto di riferimento del dexel dal piano della faccia destra + double dDistD = ( ptPoly - ptFacet246) * vtNd ; + // Se dexel non parallelo alla faccia + if ( abs( vtPoly * vtNd) > COS_ORTO_ANG_ZERO) { + // posizione parametrica della intersezione + double dParD = -dDistD / ( vtPoly * vtNd) ; + // verifico limitazioni su inizio e fine dell'intervallo + int nLimit = 0 ; + // se limita inizio + if ( vtPoly * vtNd < 0) { + // se oltre la fine, invalida tutto + if ( dParD > dPar2 - EPS_ZERO) + bValid = false ; + // se altrimenti solo oltre inizio, riduce + else if ( dParD >= dPar1) { + dPar1 = dParD ; + nLimit = 1 ; + } + } + // altrimenti limita fine + else { + // se prima dell'inizio, invalida tutto + if ( dParD < dPar1 + EPS_ZERO) + bValid = false ; + // se altrimenti solo prima della fine, riduce + else if ( dParD <= dPar2) { + dPar2 = dParD ; + nLimit = 2 ; + } + } + // se limita, devo aggiornare la normale + if ( nLimit != 0) { + Vector3d vtNewN = -vtNd ; + if ( bRecalNorm) { Vector3d vtRadial( 0, dMinRad * dCos, -dMinRad * dSin) ; vtRadial.Normalize() ; - Vector3d vtOrigMaxR = -vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ; - Vector3d vtOrigMinR = -vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ; + Vector3d vtOrigMaxR = - vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ; + Vector3d vtOrigMinR = - vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ; vtOrigMaxR.Normalize() ; vtOrigMinR.Normalize() ; - vtN2 = ( ( dDeltaZ - abs( ptInt2.z) + dLenZ) / dDeltaZ) * vtOrigMinR + ( ( abs( ptInt2.z) - dLenZ) / dDeltaZ) * vtOrigMaxR ; - vtN2.Normalize() ; + Point3d ptInt = ptPoly + dParD * vtPoly ; + vtNewN = ( ( dDeltaZ - abs( ptInt.z) + dLenZ) / dDeltaZ) * vtOrigMinR + ( ( abs( ptInt.z) - dLenZ) / dDeltaZ) * vtOrigMaxR ; + vtNewN.Normalize() ; } - ++ nIntNum ; + if ( nLimit == 1) + vtN1 = vtNewN ; + else + vtN2 = vtNewN ; } } - } - // Intersezione con la terza faccia - if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) { - if ( nIntNum < 2 && - ptPoly3.x >= 0 && ptPoly3.x <= dDeltaX && - dDeltaX * abs( ptPoly3.z) < dDeltaX * dLenZ + dDeltaZ * ptPoly3.x) { - - if ( nIntNum == 0) { - ptInt1 = ptPoly3 ; - vtN1 = vtIF ; - ++ nIntNum ; - } - else if ( ( ptInt1 - ptPoly3).SqLen() > SQ_EPS_SMALL) { - ptInt2 = ptPoly3 ; - vtN2 = vtIF ; - ++ nIntNum ; - } + // altrimenti praticamente parallelo + else { + // se esterno invalida tutto + if ( dDistD > 0) + bValid = false ; + // altrimenti non cambia niente } } - // Intersezione con la quarta faccia - if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) { - if ( nIntNum < 2 && - ptPoly4.x >= dLenX && ptPoly4.x <= dLenX + dDeltaX && - dDeltaX * abs( ptPoly4.z) < dDeltaX * dLenZ + dDeltaZ * ( ptPoly4.x - dLenX)) { - - if ( nIntNum == 0) { - ptInt1 = ptPoly4 ; - vtN1 = - vtIF ; - ++ nIntNum ; - } - else if ( ( ptInt1 - ptPoly4).SqLen() > SQ_EPS_SMALL) { - ptInt2 = ptPoly4 ; - vtN2 = - vtIF ; - ++ nIntNum ; - } - } - } - - // Intersezione con la quinta faccia - if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) { - if ( nIntNum < 2 && - ptPoly5.y >= 0 && ptPoly5.y <= dLenY && - abs( ptPoly5.z) <= dLenZ) { - - if ( nIntNum == 0) { - ptInt1 = ptPoly5 ; - vtN1 = - vtUD ; - ++ nIntNum ; - } - else if ( ( ptInt1 - ptPoly5).SqLen() > SQ_EPS_SMALL) { - ptInt2 = ptPoly5 ; - vtN2 = - vtUD ; - ++ nIntNum ; - } - } - } - - // Intersezione con la sesta faccia - if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) { - if ( nIntNum < 2 && - ptPoly6.y >= dDeltaY && ptPoly6.y <= dLenY + dDeltaY && - abs( ptPoly6.z) <= dLenZ + dDeltaZ) { - - if ( nIntNum == 0) { - ptInt1 = ptPoly6; - vtN1 = vtUD ; - ++ nIntNum ; - } - else if ( ( ptInt1 - ptPoly6).SqLen() > SQ_EPS_SMALL) { - ptInt2 = ptPoly6; - vtN2 = vtUD ; - ++ nIntNum ; - } - } - } - // Se il poliedro è attraversato taglio - if ( nIntNum == 2) { - - // Riporto le intersezioni nel sistema griglia - ptInt1.ToGlob( PolyFrame) ; + // Se rimasto qualcosa lo sottraggo al dexel + if ( bValid) { + // Punti di intersezione e normali nel sistema griglia + ptInt1 = ptC + dPar1 * Z_AX ; vtN1.ToGlob( PolyFrame) ; - ptInt2.ToGlob( PolyFrame) ; + ptInt2 = ptC + dPar2 * Z_AX ; vtN2.ToGlob( PolyFrame) ; - + // Eseguo sottrazione SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ; } @@ -4631,27 +4695,9 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c // Cono ConusFrame.ChangeOrig( ptV) ; if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bTapB, true, ptInt1, vtN1, ptInt2, vtN2)) { - if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { - if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) { - Vector3d vtL1 = ptInt1 - ptV ; - vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ; - double dL1 = vtL1.Len() ; - vtL1 /= dL1 ; - Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN1.Normalize() ; - vtN1 = - vtOriginalN1.z * vtToolDir - vtOriginalN1.x * vtL1 ; - vtN1.Normalize() ; - } - if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtToolDir, 0.1 * EPS_SMALL)) { - Vector3d vtL2 = ptInt2 - ptV ; - vtL2 -= ( vtL2 * vtToolDir) * vtToolDir ; - double dL2 = vtL2.Len() ; - vtL2 /= dL2 ; - Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN2.Normalize() ; - vtN2 = - vtOriginalN2.z * vtToolDir - vtOriginalN2.x * vtL2 ; - vtN2.Normalize() ; - } + if ( bRecalNorm) { + vtN1 = AdjustConeNormal( ptInt1, vtN1, ptV, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ; + vtN2 = AdjustConeNormal( ptInt2, vtN2, ptV, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ; } SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ; } @@ -4876,7 +4922,7 @@ VolZmap::TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, con // I punti e i vettori devono essere nel sistema di riferimento opportuno // Controllo sull'ammissibilità del numero di griglia - if ( nGrid < 0 || nGrid > 2) + if ( nGrid < 0 || nGrid > 2) return false ; // BBox dello Zmap @@ -4939,10 +4985,10 @@ VolZmap::TestParaBBox( int nGrid, const Point3d& ptS, const Point3d& ptE, const return false ; // Limiti su indici - nStI = ( dMinX < EPS_SMALL ? 0 : static_cast ( dMinX / m_dStep)) ; - nEnI = ( dMaxX > dMaxXValue - EPS_SMALL ? nMaxNx - 1 : static_cast ( dMaxX / m_dStep)) ; - nStJ = ( dMinY < EPS_SMALL ? 0 : static_cast ( dMinY / m_dStep)) ; - nEnJ = ( dMaxY > dMaxYValue - EPS_SMALL ? nMaxNy - 1 : static_cast ( dMaxY / m_dStep)) ; - + nStI = ( dMinX < EPS_SMALL ? 0 : int( dMinX / m_dStep)) ; + nEnI = ( dMaxX > dMaxXValue - EPS_SMALL ? nMaxNx - 1 : int( dMaxX / m_dStep)) ; + nStJ = ( dMinY < EPS_SMALL ? 0 : int( dMinY / m_dStep)) ; + nEnJ = ( dMaxY > dMaxYValue - EPS_SMALL ? nMaxNy - 1 : int ( dMaxY / m_dStep)) ; + return true ; }