Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Modifiche ad asportazioni avanzate vm

Browse Source
This commit is contained in:
LorenzoM
2021-09-01 17:32:41 +02:00
parent ade2d97804
commit b9548a4d33
1 changed files with 285 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmapVolume.cpp
+285 -241
View File
@@ -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<Plane3d>& 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<Plane3d>& 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> Int2)
{ return Int1.first < Int2.first ; }) ;
sort( vExitsVec.begin(), vExitsVec.end(), [] ( pair<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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<pair<double, Vector3d>> 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<double, Vector3d> Int1, pair<double, Vector3d> 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) ;
}
}
}