diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index ff0b9f9..fd6dd50 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -5042,12 +5042,21 @@ VolZmap::IntersLineCircCrown( const Point3d& ptLineP, const Vector3d& vtLineDir, if ( ! vtPlaneN.Normalize() || ! plMyPlane.Set( ptCen, vtPlaneN)) return 0 ; + // Quadrati dei raggi + double dSqMinRad = dMinRad * dMinRad ; + double dSqMaxRad = dMaxRad * dMaxRad ; + + // Se la corona circolare defenera in un disco (dMinRad < EPS), forzo dSqSafeMinRad a - 1 + // in modo da tagliare i dexel giacenti sul suo asse di simmetria. + if ( dMinRad < EPS_SMALL) + dSqMinRad = - 1 ; + // Intersezione retta piano int nIntType = IntersLinePlane( ptLineP, vtLineDir, 1000, plMyPlane, ptInt, false) ; if ( nIntType == ILPT_YES /* || nIntType == ILPT_START || nIntType == ILPT_END*/) { // Se il punto d'intersezione sta nella corona double dSqIntCenDist = ( ptInt - ptCen) * ( ptInt - ptCen) ; - if ( dSqIntCenDist > dMinRad * dMinRad && dSqIntCenDist > dMaxRad * dMaxRad) { + if ( dSqIntCenDist > dSqMinRad && dSqIntCenDist > dSqMaxRad) { vtN = - vtAx ; return 1 ; } @@ -5117,6 +5126,10 @@ VolZmap::IntersLineCylinderCuttedByPlanes( const Point3d& ptLineP, const Vector3 const vector& vPlanesVec, Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) const { + // Se il raggio non è sufficientemente grande, non devo fare alcunché. + if ( dRad < EPS_SMALL) + return 0 ; + // Definisco il sistema di riferimento S; se non è possibile, c'è un errore. Frame3d frFrameS ; if ( ! frFrameS.Set( ptBaseCen, vtAx)) @@ -5213,6 +5226,10 @@ VolZmap::IntersLineCircSweptSurfCuttedByPlanes( const Point3d& ptLineP, const Ve const vector& vPlanesVec, Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) const { + // Se il raggio non è sufficientemente grande, non devo fare alcunché. + if ( dRad < EPS_SMALL) + return 0 ; + // Studio delle simmetrie Point3d ptMyCen = ptCen ; Vector3d vtMySweptVec = vtSweptVec ; @@ -5457,6 +5474,164 @@ VolZmap::IntersLineSphereCuttedByPlanes( const Point3d& ptLineP, const Vector3d& return nSol ; } +// Filtro per le intersezioni + +typedef vector> DexelSurfIntersVector ; + +//---------------------------------------------------------------------------- +bool +IntersectionsFilter( const Vector3d& vtDexDir, const DexelSurfIntersVector& vOrigineIntersVec, DexelSurfIntersVector& vFilteredIntersVec) +{ + // Tolleranze + double dDotEps = EPS_ZERO ; + double dLenEps = EPS_SMALL ; + + // Separo gli ingressi dalle uscite. + DexelSurfIntersVector vEntrancesVec, vExitsVec, vIndefVec ; + for ( int n = 0 ; n < int( vOrigineIntersVec.size()) ; ++ n) { + if ( vOrigineIntersVec[n].second * vtDexDir < - dDotEps) { + vEntrancesVec.emplace_back( vOrigineIntersVec[n]) ; + } + else if ( vOrigineIntersVec[n].second * vtDexDir > dDotEps) { + vExitsVec.emplace_back( vOrigineIntersVec[n]) ; + } + else { + vIndefVec.emplace_back( vOrigineIntersVec[n]) ; + } + } + + // Riordino le entrate e le uscite in funzione del parametro lungo la retta in corrispondenza del quale occorrono. + sort( vEntrancesVec.begin(), vEntrancesVec.end(), [] ( pair Int1, pair Int2) + { return Int1.first < Int2.first ; }) ; + sort( vExitsVec.begin(), vExitsVec.end(), [] ( pair Int1, pair Int2) + { return Int1.first < Int2.first ; }) ; + + // Modo 1 + for ( int n = 0 ; n < int( vEntrancesVec.size()) ; ++ n) { + for ( int m = 0 ; m < int( vExitsVec.size()) ; ++ m) { + if ( vExitsVec[m].first > vEntrancesVec[n].first) { + if ( n == 0 || ( int( vFilteredIntersVec.size()) > 0 && vEntrancesVec[n].first > vFilteredIntersVec.back().first)) { + vFilteredIntersVec.emplace_back( vEntrancesVec[n]) ; + vFilteredIntersVec.emplace_back( vExitsVec[m]) ; + break ; + } + } + } + } + + // Modo 2 + + // Media delle entrate + double dEntrancesAvarage = 0 ; + for ( int n = 0 ; n < int( vEntrancesVec.size()) ; ++ n) { + dEntrancesAvarage += vEntrancesVec[n].first ; + } + dEntrancesAvarage /= int( vEntrancesVec.size()) ; + // Deviazione standard delle entrate + double dEntrancesStdDev = 0 ; + for ( int n = 0 ; n < int( vEntrancesVec.size()) ; ++ n) { + dEntrancesStdDev += ( vEntrancesVec[n].first - dEntrancesAvarage) * ( vEntrancesVec[n].first - dEntrancesAvarage) ; + } + dEntrancesStdDev = sqrt( dEntrancesStdDev / int( vEntrancesVec.size())) ; + + // Media delle uscite + double dExitsAvarage = 0 ; + for ( int n = 0 ; n < int( vExitsVec.size()) ; ++ n) { + dExitsAvarage += vExitsVec[n].first ; + } + dExitsAvarage /= int( vExitsVec.size()) ; + // Deviazione standard delle uscite + double dExitsStdDev = 0 ; + for ( int n = 0 ; n < int( vExitsVec.size()) ; ++ n) { + dExitsStdDev += ( vExitsVec[n].first - dExitsAvarage) * ( vExitsVec[n].first - dExitsAvarage) ; + } + dExitsStdDev = sqrt( dExitsStdDev / int( vExitsVec.size())) ; + + // Caso di un solo gruppo per le entrate + if ( dEntrancesStdDev < dLenEps) { + // Caso di un solo gruppo per le uscite + if ( dExitsStdDev < dLenEps) { + if ( vExitsVec.back().first > vEntrancesVec[0].first) { + vFilteredIntersVec.emplace_back( vEntrancesVec[0]) ; + vFilteredIntersVec.emplace_back( vExitsVec.back()) ; + } + } + // Caso di due gruppi per le uscite + else { + // Cerco ultima uscita del primo gruppo + int n ; + for ( n = int( vExitsVec.size()) - 1 ; n >= 0 ; -- n) { + if ( vExitsVec[n].first < dExitsAvarage) + break ; + } + // Aggiungo ingressi e uscite filtrati. + if ( vExitsVec[n].first > vEntrancesVec[0].first) { + vFilteredIntersVec.emplace_back( vEntrancesVec[0]) ; + vFilteredIntersVec.emplace_back( vExitsVec[n]) ; + } + else if ( vExitsVec.back().first > vEntrancesVec[0].first) { + vFilteredIntersVec.emplace_back( vEntrancesVec[0]) ; + vFilteredIntersVec.emplace_back( vExitsVec.back()) ; + } + } + } + // Caso di due gruppi per le entrate + else { + // Cerco prima entrata del secondo gruppo + int n ; + for ( n = 0 ; n < int( vEntrancesVec.size()) ; ++ n) { + if ( vEntrancesVec[n].first > dEntrancesAvarage) + break ; + } + // Caso di un solo gruppo per le uscite + if ( dExitsStdDev < dLenEps) { + // Aggiungo ingressi e uscite filtrati. + if ( vExitsVec.back().first > vEntrancesVec[n].first) { + vFilteredIntersVec.emplace_back( vEntrancesVec[n]) ; + vFilteredIntersVec.emplace_back( vExitsVec.back()) ; + } + else if ( vExitsVec.back().first > vEntrancesVec[0].first) { + vFilteredIntersVec.emplace_back( vEntrancesVec[0]) ; + vFilteredIntersVec.emplace_back( vExitsVec.back()) ; + } + } + // Caso di due gruppi per le uscite + else { + // Cerco ultima uscita del primo gruppo + int m ; + for ( m = int( vExitsVec.size()) - 1 ; m >= 0 ; -- m) { + if ( vExitsVec[m].first < dExitsAvarage) + break ; + } + // Aggiungo ingressi e uscite ai filtri. + if ( vExitsVec[m].first > vEntrancesVec[0].first) { + if ( vExitsVec[m].first > vEntrancesVec[n].first) { + vFilteredIntersVec.emplace_back( vEntrancesVec[0]) ; + vFilteredIntersVec.emplace_back( vExitsVec.back()) ; + } + else if ( vExitsVec.back().first > vEntrancesVec[n].first) { + vFilteredIntersVec.emplace_back( vEntrancesVec[0]) ; + vFilteredIntersVec.emplace_back( vExitsVec[m]) ; + vFilteredIntersVec.emplace_back( vEntrancesVec[n]) ; + vFilteredIntersVec.emplace_back( vExitsVec.back()) ; + } + else { + vFilteredIntersVec.emplace_back( vEntrancesVec[0]) ; + vFilteredIntersVec.emplace_back( vExitsVec[m]) ; + } + } + else { + if ( vExitsVec.back().first > vEntrancesVec[n].first) { + vFilteredIntersVec.emplace_back( vEntrancesVec[n]) ; + vFilteredIntersVec.emplace_back( vExitsVec.back()) ; + } + } + } + } + + return true ; +} + // Corona circolare //---------------------------------------------------------------------------- bool @@ -5475,6 +5650,11 @@ VolZmap::SurfCircCrown_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& double dSqSafeMinRad = dMinRad * dMinRad + 2 * dMinRad * EPS_SMALL ; double dSqSafeMaxRad = dMaxRad * dMaxRad - 2 * dMaxRad * EPS_SMALL ; + // Se la corona circolare defenera in un disco (dMinRad < EPS), forzo dSqSafeMinRad a - 1 + // in modo da tagliare i dexel giacenti sul suo asse di simmetria. + if ( dMinRad < EPS_SMALL) + dSqSafeMinRad = - 1 ; + Point3d ptSXY( ptS.x, ptS.y, 0) ; // Ciclo sui dexel. @@ -5495,6 +5675,7 @@ VolZmap::SurfCircCrown_ZDrilling( int nGrid, const Point3d& ptS, const Point3d& vtMinN.z = - 1 ; vtMaxN.z = - 1 ; } + SubtractIntervals( nGrid, i, j, dMinZ, dMaxZ, vtMinN, vtMaxN) ; } } } @@ -5525,7 +5706,7 @@ VolZmap::SurfCircCrown_Drilling( int nGrid, const Point3d& ptS, const Point3d& p Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -5543,7 +5724,8 @@ VolZmap::SurfCircCrown_Drilling( int nGrid, const Point3d& ptS, const Point3d& p } } - // Intersezione con cilindro interno + // Intersezione con cilindro interno in caso di corona circolare propria (la funzione esegue + // l'intersezione solo se il cilindro ha un raggio sensibilmente maggiore di zero) nIntNum = IntersLineCylinderCuttedByPlanes( ptC, Z_AX, ptS, vtAx, dMinRad, dMotProjOnAx, true, vEmptyPlaneVec, ptInt1, vtN1, ptInt2, vtN2) ; if ( nIntNum >= 1) { @@ -5573,17 +5755,14 @@ VolZmap::SurfCircCrown_Drilling( int nGrid, const Point3d& ptS, const Point3d& p vParAndNormIntersVec.back().second = vtN1 ; } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -5595,52 +5774,7 @@ VolZmap::SurfCircCrown_Drilling( int nGrid, const Point3d& ptS, const Point3d& p bool VolZmap::SurfCircCrown_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx, double dMaxRad, double dMinRad) { - return SurfCircCrown_Milling( nGrid, ptS, ptE, vtAx, dMaxRad, dMinRad) ; - // Verifica sull'interferenza utensile Zmap - //int nStartI, nStartJ, nEndI, nEndJ ; - //if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, dMaxRad, dMinRad, 1, nStartI, nStartJ, nEndI, nEndJ)) - // return true ; - // - //Vector3d vtDisp = ptE - ptS ; - // - //// Se il movimento è in direzione opposta a quella ove la corona può tagliare, non devo fare nulla. - //if ( vtAx.z * vtDisp.z < EPS_ZERO) - // return true ; - // - //// Sistema di riferimento piano del moto - //Point3d ptSXY( ptS.x, ptS.y, 0) ; - //Vector3d vtV1( vtDisp.x, vtDisp.y, 0) ; - //double dDispLenXY = vtV1.Len() ; - //vtV1 /= dDispLenXY ; - //Vector3d vtV2 = Z_Ax ^ vtV1 ; - // - //// Ciclo sui dexel. - //for ( int i = nStartI ; i <= nEndI ; ++ i) { - // for ( int j = nStartJ ; j <= nEndJ ; ++ j) { - - // Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - // Vector3d vtR = ptC - ptSXY ; - // double dR1 = vtR * vtV1 ; - // double dR2 = vtR * vtV2 ; - // double dCircMin1 = sqrt( max( d)) ; - // double dSqLenR = vtR * vtR ; - // if ( dSqLenR > dSqSafeMinRad && dSqLenR < dSqSafeMaxRad) { - // double dMinZ = min( ptS.z, ptE.z) ; - // double dMaxZ = max( ptS.z, ptE.z) ; - // Vector3d vtMinN, vtMaxN ; - // if ( ptE.z < ptS.z) { - // vtMinN.z = 1 ; - // vtMaxN.z = 1 ; - // } - // else { - // vtMinN.z = - 1 ; - // vtMaxN.z = - 1 ; - // } - // } - // } - //} - // - //return true ; + return SurfCircCrown_Milling( nGrid, ptS, ptE, vtAx, dMaxRad, dMinRad) ; } //---------------------------------------------------------------------------- @@ -5667,7 +5801,7 @@ VolZmap::SurfCircCrown_Milling( int nGrid, const Point3d& ptS, const Point3d& pt Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -5686,7 +5820,8 @@ VolZmap::SurfCircCrown_Milling( int nGrid, const Point3d& ptS, const Point3d& pt } } - // Intersezione con cilindro ellittico interno + // Intersezione con cilindro interno in caso di corona circolare propria (la funzione esegue + // l'intersezione solo se il cilindro ha un raggio sensibilmente maggiore di zero) nIntNum = IntersLineCircSweptSurfCuttedByPlanes( ptC, Z_AX, ptS, vtAx, dMinRad, vtDisp, true, vEmptyPlaneVec, ptInt1, vtN1, ptInt2, vtN2) ; if ( nIntNum >= 1) { @@ -5716,17 +5851,14 @@ VolZmap::SurfCircCrown_Milling( int nGrid, const Point3d& ptS, const Point3d& pt vParAndNormIntersVec.back().second = vtN1 ; } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -5868,7 +6000,7 @@ VolZmap::SurfCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0.) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -5946,17 +6078,14 @@ VolZmap::SurfCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, vParAndNormIntersVec.back().second = vtN1 ; } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -6105,7 +6234,7 @@ VolZmap::SurfConus_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -6165,17 +6294,14 @@ VolZmap::SurfConus_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, } } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -6189,67 +6315,6 @@ VolZmap::SurfConus_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, bool bOuterCutter, const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR) { return SurfConus_Milling( nGrid, ptS, ptE, vtAx, dHei, dMaxRad, dMinRad, bOuterCutter, true, true, vtArcNormMaxR, vtArcNormMinR) ; - - //int nStartI, nStartJ, nEndI, nEndJ ; - //if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) - // return true ; - // - //// Descrizione del moto - //Point3d ptSXY( ptS.x, ptS.y, 0) ; - //Vector3d vtDisp = ptE - ptS ; - //double dDispLong = vtDisp * vtToolDir ; - //Vector3d vtDispXY( vtDisp.x, vtDisp.y, 0) ; // = vtDisp - dDispLong * vtToolDir; - //double dDispOrt = vtDispXY.Len(); - //vtDispXY /= dDispOrt ; - //double dDeltaHei = dMinRad * dHei / ( dMaxRad - dMinRad) ; - //double dTanAlpha = dMaxRad / ( dHei + dDeltaHei) ; - //double dCosTheta = ( dTanAlpha * vtDisp * vtToolDir) / ( vtDisp * vtDispXY) ; - //bool bElevation = dDispLong > 0 ; - //bool bLimPassed = dCosTheta > 1 ; - - //// Ciclo sui punti - //for ( int i = nStartI ; i <= nEndI ; ++ i) { - // for ( int j = nStartJ ; j <= nEndJ ; ++ j) { - // - // Point3d ptC( ( i + 0.5) * m_dSetp, ( j + 0.5) * m_dStep, 0) ; - // Vector3d vtPosXY = ptC - ptSXY ; - // double dLongXY = vtPosXY * vtDispXY ; - // double dOrtXY = sqrt( max( vtPosXY.SqLen() - dLongXY * dLongXY, 0)) ; - // - // if ( bElevation) { - // if ( bLimPassed) { - // ; - // } - // else { - // double dSqMinRad = dMinRad * dMinRad ; - // double dSqMaxRad = dMaxRad * dMaxRad ; - // double dSqRadDist = dLongXY * dLongXY + dOrtXY * dOrtXY ; - // double dCurCos = dLongXY / sqrt( dSqRadDist) ; - // if ( dSqRadDist > dSqMinRad && dSqRadDist < dSqMaxRad && dCurCos > dCosTheta) { - // ; - // } - // else if ( dSqRadDist > dSqMaxRad && abs( dOrtXY) < dMaxRad) { - // if ( dLongXY - dCosTheta * dMaxRad < dDispOrt) { - // - // } - // else { - // - // } - // } - // } - // } - // else { - // if ( bLimPassed) { - // ; - // } - // else { - // ; - // } - // } - // } - //} - - return true ; } //---------------------------------------------------------------------------- @@ -6316,7 +6381,7 @@ VolZmap::SurfConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -6376,17 +6441,14 @@ VolZmap::SurfConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c } } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), []( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI + 1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI + 1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI + 1].second) ; - } + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -6427,7 +6489,7 @@ VolZmap::SurfConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -6505,17 +6567,14 @@ VolZmap::SurfConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c vParAndNormIntersVec.back().second = vtN1 ; } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -6584,7 +6643,7 @@ VolZmap::SurfSphericalShellPart_Milling( int nGrid, const Point3d& ptS, const Po Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -6644,17 +6703,14 @@ VolZmap::SurfSphericalShellPart_Milling( int nGrid, const Point3d& ptS, const Po } } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -6698,7 +6754,7 @@ VolZmap::SurfSphericalShellPart_Milling( int nGrid, const Point3d& ptS, const Po Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -6774,17 +6830,14 @@ VolZmap::SurfSphericalShellPart_Milling( int nGrid, const Point3d& ptS, const Po } } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -6833,7 +6886,7 @@ VolZmap::SurfSphericalShellPart_Milling( int nGrid, const Point3d& ptS, const Po Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -6907,17 +6960,14 @@ VolZmap::SurfSphericalShellPart_Milling( int nGrid, const Point3d& ptS, const Po } } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -6975,7 +7025,7 @@ VolZmap::SurfSphericalShell_Milling( int nGrid, const Point3d& ptS, const Point3 Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -7021,17 +7071,14 @@ VolZmap::SurfSphericalShell_Milling( int nGrid, const Point3d& ptS, const Point3 } } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } } @@ -7072,7 +7119,7 @@ VolZmap::SurfSphericalShell_Milling( int nGrid, const Point3d& ptS, const Point3 Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - vector> vParAndNormIntersVec ; + DexelSurfIntersVector vParAndNormIntersVec ; Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; @@ -7132,17 +7179,14 @@ VolZmap::SurfSphericalShell_Milling( int nGrid, const Point3d& ptS, const Point3 } } - // Riordino le intersezioni in funzione del parametro lungo la retta in corrispondenza del quale occorrono. - sort( vParAndNormIntersVec.begin(), vParAndNormIntersVec.end(), [] ( pair Int1, pair Int2) - { return Int1.first < Int2.first ; }) ; - - // Sottraggo gli intervalli - double dMyEps = EPS_ZERO ; - for ( int nI = 0 ; nI < int( vParAndNormIntersVec.size()) - 1 ; ++ nI) { - if ( vParAndNormIntersVec[nI].second.z < - dMyEps && vParAndNormIntersVec[nI+1].second.z > dMyEps) { - SubtractIntervals( nGrid, i, j, vParAndNormIntersVec[nI].first, vParAndNormIntersVec[nI+1].first, - vParAndNormIntersVec[nI].second, vParAndNormIntersVec[nI+1].second) ; - } + // Filtro le intersezioni trovate. + DexelSurfIntersVector vFilteredIntersVec ; + IntersectionsFilter( Z_AX, vParAndNormIntersVec, vFilteredIntersVec) ; + + // Sottraggo gli intervalli. + for ( int n = 0 ; n < int( vFilteredIntersVec.size()) ; n += 2) { + SubtractIntervals( nGrid, i, j, vFilteredIntersVec[n].first, vFilteredIntersVec[n+1].first, + vFilteredIntersVec[n].second, vFilteredIntersVec[n+1].second) ; } } }