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

EgtGeomKernel :

Browse Source 
- VM 5 assi con bilineari, riorganizzato.
This commit is contained in:
Daniele Bariletti
2025-08-25 16:53:44 +02:00
parent 6a4b4feff5
commit dbb751a441
2 changed files with 180 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmapVolume.cpp
+180 -184
View File
@@ -1132,7 +1132,7 @@ GetAlongAcrossRotation( const Vector3d& vtDir1, const Vector3d& vtDir2, const Ve
//----------------------------------------------------------------------------
bool
VolZmap::UpdateMaxMin( Point3d& ptBez, Vector3d& vtN, PNTVEC3DVECTOR& vInters) const
UpdateMaxMin( Point3d& ptBez, Vector3d& vtN, PNTVEC3DVECTOR& vInters)
{
if ( ! AreSameVectorExact( vtN, V_NULL))
vInters.emplace_back( PNTVEC3D( ptBez, vtN)) ;
@@ -1352,14 +1352,14 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
BOXVECTOR vSurfBox( nTotSurf * nStepCnt) ;
double dSide = 0 ;
// punti per le bilineari, sulle posizioni del tool alle estremità del movimento
PNTVECTOR vPntTipStartEx ;
PNTVECTOR vPntTipEndEx ;
PNTVECTOR vPntTopStartEx ;
PNTVECTOR vPntTopEndEx ;
PNTVECTOR vPntTipStartEx2 ;
PNTVECTOR vPntTipEndEx2 ;
PNTVECTOR vPntTopStartEx2 ;
PNTVECTOR vPntTopEndEx2 ;
PNTVECTOR vPntTipStartExF ;
PNTVECTOR vPntTipEndExF ;
PNTVECTOR vPntTopStartExF ;
PNTVECTOR vPntTopEndExF ;
PNTVECTOR vPntTipStartExB ;
PNTVECTOR vPntTipEndExB ;
PNTVECTOR vPntTopStartExB ;
PNTVECTOR vPntTopEndExB ;
Vector3d vtDirTopStartEx ;
Vector3d vtDirTopEndEx ;
Vector3d vtDirTipStartEx ;
@@ -1419,15 +1419,15 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
ptBottom2e = ptP2T - vtAuxBottomE ;
// punti sul top e tip del tool che servono per costruire le bilineare di congiunzione tra step
PNTVECTOR vPntTipStart ;
PNTVECTOR vPntTipEnd ;
PNTVECTOR vPntTopStart ;
PNTVECTOR vPntTopEnd ;
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 vPntTipStart2 ;
PNTVECTOR vPntTipEnd2 ;
PNTVECTOR vPntTopStart2 ;
PNTVECTOR vPntTopEnd2 ;
PNTVECTOR vPntTipStartBack ;
PNTVECTOR vPntTipEndBack ;
PNTVECTOR vPntTopStartBack ;
PNTVECTOR vPntTopEndBack ;
if ( nSub > 1) {
// determino in che modo collegare il cilindro iniziale con quello finale
Vector3d vtTopBaseEnd = vtDirTop - ( (vtDirTop * vtLe[s]) * vtLe[s]) ;
@@ -1467,76 +1467,61 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
// aggiungo il primo punto per ognuno dei gruppi
vtTopBaseStart.Rotate( vtLs[s], 90) ;
vtTopBaseEnd.Rotate( vtLe[s], 90) ;
vPntTopStart.emplace_back( ptS[s] + vtTopBaseStart) ;
vPntTopEnd.emplace_back( ptE[s] + vtTopBaseEnd) ;
vPntTipStart.emplace_back( ptP1T + vtTipBaseStart) ;
vPntTipEnd.emplace_back( ptP2T + vtTipBaseEnd) ;
vPntTopStartFront.emplace_back( ptS[s] - vtTopBaseStart) ;
vPntTopEndFront.emplace_back( ptE[s] - vtTopBaseEnd) ;
vPntTipStartFront.emplace_back( ptP1T + vtTipBaseStart) ;
vPntTipEndFront.emplace_back( ptP2T + vtTipBaseEnd) ;
// punti addizionali per superfici bilineari
vPntTopStart2.emplace_back( ptS[s] + vtTopBaseStart) ;
vPntTopEnd2.emplace_back( ptE[s] + vtTopBaseEnd) ;
vPntTipStart2.emplace_back( ptP1T + vtTipBaseStart) ;
vPntTipEnd2.emplace_back( ptP2T + vtTipBaseEnd) ;
vPntTopStartBack.emplace_back( ptS[s] + vtTopBaseStart) ;
vPntTopEndBack.emplace_back( ptE[s] + vtTopBaseEnd) ;
vPntTipStartBack.emplace_back( ptP1T - vtTipBaseStart) ;
vPntTipEndBack.emplace_back( ptP2T - vtTipBaseEnd) ;
double dSubAng = 180. / nSub ;
// se dSide si discosta da zero allora devo usare più di una superficie per definire la parte superiore e inferiore del volume spazzata dal tool
for ( int i = 0 ; i < nSub ; ++i) {
// punti sulla base superiore dei cilindri
vPntTopStart.emplace_back( vPntTopStart.back()) ;
vPntTopStart2.emplace_back( vPntTopStart2.back()) ;
if ( dSide > 0){
vPntTopStart.back().Rotate(ptS[s], vtLs[s], dSubAng) ;
vPntTopStart2.back().Rotate(ptS[s], vtLs[s], -dSubAng) ;
}
else{
vPntTopStart.back().Rotate(ptS[s], vtLs[s], -dSubAng) ;
vPntTopStart2.back().Rotate(ptS[s], vtLs[s], dSubAng) ;
}
vPntTopEnd.emplace_back( vPntTopEnd.back()) ;
vPntTopEnd2.emplace_back( vPntTopEnd2.back()) ;
if ( dSide > 0){
vPntTopEnd.back().Rotate(ptE[s], vtLe[s], dSubAng) ;
vPntTopEnd2.back().Rotate(ptE[s], vtLe[s], -dSubAng) ;
}
else{
vPntTopEnd.back().Rotate(ptE[s], vtLe[s], -dSubAng) ;
vPntTopEnd2.back().Rotate(ptE[s], vtLe[s], dSubAng) ;
}
// 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) ;
// punti sulla base inferiore dei cilindri
vPntTipStart.emplace_back( vPntTipStart.back()) ;
vPntTipStart2.emplace_back( vPntTipStart2.back()) ;
if ( dSide > 0){
vPntTipStart.back().Rotate(ptP1T, vtLs[s], dSubAng) ;
vPntTipStart2.back().Rotate(ptP1T, vtLs[s], -dSubAng) ;
}
else{
vPntTipStart.back().Rotate(ptP1T, vtLs[s], -dSubAng) ;
vPntTipStart2.back().Rotate(ptP1T, vtLs[s], dSubAng) ;
}
vPntTipEnd.emplace_back( vPntTipEnd.back()) ;
vPntTipEnd2.emplace_back( vPntTipEnd2.back()) ;
if ( dSide > 0){
vPntTipEnd.back().Rotate(ptP2T, vtLe[s], dSubAng) ;
vPntTipEnd2.back().Rotate(ptP2T, vtLe[s], -dSubAng) ;
}
else{
vPntTipEnd.back().Rotate(ptP2T, vtLe[s], -dSubAng) ;
vPntTipEnd2.back().Rotate(ptP2T, vtLe[s], dSubAng) ;
}
vPntTipStartFront.emplace_back( vPntTipStartFront.back()) ;
vPntTipStartFront.back().Rotate(ptP1T, vtLs[s], dSubAng) ;
vPntTipStartBack.emplace_back( vPntTipStartBack.back()) ;
vPntTipStartBack.back().Rotate(ptP1T, vtLs[s], 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) {
vPntTipStartEx = vPntTipStart ;
vPntTopStartEx = vPntTopStart ;
vPntTipStartEx2 = vPntTipStart2 ;
vPntTopStartEx2 = vPntTopStart2 ;
vPntTipStartExF = vPntTipStartFront ;
vPntTopStartExF = vPntTopStartFront ;
vPntTipStartExB = vPntTipStartBack ;
vPntTopStartExB = vPntTopStartBack ;
//ptP1TEx = ptP1T ;
}
if ( s == nStepCnt - 1) {
vPntTipEndEx = vPntTipEnd ;
vPntTopEndEx = vPntTopEnd ;
vPntTipEndEx2 = vPntTipEnd2 ;
vPntTopEndEx2 = vPntTopEnd2 ;
vPntTipEndExF = vPntTipEndFront ;
vPntTopEndExF = vPntTopEndFront ;
vPntTipEndExB = vPntTipEndBack ;
vPntTopEndExB = vPntTopEndBack ;
//ptP2TEx = ptP2T ;
}
vector<PNTVECTOR> vvPtCtrl ;
@@ -1552,113 +1537,133 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
}
else {
if( n5AxisType == VolZmap::Move5Axis::NO_BASE_INTERS || n5AxisType == VolZmap::Move5Axis::ACROSS){
// superfici inferiori
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStart[i], vPntTipStart[i+1], vPntTipEnd[i], vPntTipEnd[i+1]})) ;
if ( dSide > 0) {
// superfici inferiori
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartFront[i], vPntTipStartFront[i+1], vPntTipEndFront[i], vPntTipEndFront[i+1]})) ;
// superfici superiori
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStartBack[i], vPntTopStartBack[i+1], vPntTopEndBack[i], vPntTopEndBack[i+1]})) ;
}
// superfici superiori
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStart[i], vPntTopStart[i+1], vPntTopEnd[i], vPntTopEnd[i+1]})) ;
else {
// superfici inferiori
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartBack[i+1], vPntTipStartBack[i], vPntTipEndBack[i+1], vPntTipEndBack[i]})) ;
// superfici superiori
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStartFront[i], vPntTopStartFront[i+1], vPntTopEndFront[i], vPntTopEndFront[i+1]})) ;
}
// chiudo il volume con le superici verticali all'ultimo step
if( n5AxisType == VolZmap::Move5Axis::NO_BASE_INTERS && s == nStepCnt - 1) {
for ( int i = 0 ; i < nSub ; ++i )
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartEx[i+1], vPntTipStartEx[i], vPntTopStartEx[nSub - i - 1], vPntTopStartEx[nSub - i]})) ;
for ( int i = 0 ; i < nSub ; ++i )
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipEndEx[i], vPntTipEndEx[i+1], vPntTopEndEx[nSub - i], vPntTopEndEx[nSub - i- 1]})) ;
if ( dSide > 0) {
for ( int i = 0 ; i < nSub ; ++i )
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartExF[i+1], vPntTipStartExF[i], vPntTopStartExB[nSub - i - 1], vPntTopStartExB[nSub - i]})) ;
for ( int i = 0 ; i < nSub ; ++i )
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipEndExF[i], vPntTipEndExF[i+1], vPntTopEndExB[nSub - i], vPntTopEndExB[nSub - i- 1]})) ;
}
else {
for ( int i = 0 ; i < nSub ; ++i )
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartExB[i+1], vPntTipStartExB[i], vPntTopStartExF[nSub - i - 1], vPntTopStartExF[nSub - i]})) ;
for ( int i = 0 ; i < nSub ; ++i )
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipEndExB[i+1], vPntTipEndExB[i], vPntTopEndExF[nSub - i], vPntTopEndExF[nSub - i- 1]})) ;
}
}
// aggiungo le superfici bilineari anche nell'altro verso sia per il top che per il tip
if( n5AxisType == VolZmap::Move5Axis::ACROSS) {
// inferiori
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStart2[i], vPntTipStart2[i+1], vPntTipEnd2[i], vPntTipEnd2[i+1]})) ;
if ( dSide > 0 ) {
// inferiori
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartBack[i+1], vPntTipStartBack[i], vPntTipEndBack[i+1], vPntTipEndBack[i]})) ;
// superfici superiori
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStartFront[i+1], vPntTopStartFront[i], vPntTopEndFront[i+1], vPntTopEndFront[i]})) ;
}
// superfici superiori
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStart2[i], vPntTopStart2[i+1], vPntTopEnd2[i], vPntTopEnd2[i+1]})) ;
else {
// inferiori
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartFront[i], vPntTipStartFront[i+1], vPntTipEndFront[i], vPntTipEndFront[i+1]})) ;
// superfici superiori
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStartBack[i+1], vPntTopStartBack[i], vPntTopEndBack[i+1], vPntTopEndBack[i]})) ;
}
// all'ultimo step chiudo i volumi delimitati dalle bilineari
if( s == nStepCnt - 1) {
// chiudo il volume con le superici verticali, 1o volume, interne
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartEx[i+1], vPntTipStartEx[i], vPntTopStartEx2[nSub - i - 1], vPntTopStartEx2[nSub - i]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartExF[i+1], vPntTipStartExF[i], vPntTopStartExF[i+1], vPntTopStartExF[i]})) ;
// chiudo il volume con le superici verticali, 2o volume, interne
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipEndEx2[i], vPntTipEndEx2[i+1], vPntTopEndEx[nSub - i], vPntTopEndEx[nSub - i -1]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipEndExB[i+1], vPntTipEndExB[i], vPntTopEndExB[i+1], vPntTopEndExB[i]})) ;
// chiudo il volume con le superici verticali, 1o volume, esterne
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipEndEx[i], vPntTipEndEx[i+1], vPntTopEndEx2[nSub - i], vPntTopEndEx2[nSub - i - 1]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipEndExF[i], vPntTipEndExF[i+1], vPntTopEndExF[i], vPntTopEndExF[i+1]})) ;
// chiudo il volume con le superici verticali, 2o volume, esterne
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartEx2[i+1], vPntTipStartEx2[i], vPntTopStartEx[nSub - i - 1], vPntTopStartEx[nSub - i]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartExB[i], vPntTipStartExB[i+1], vPntTopStartExB[i], vPntTopStartExB[i+1]})) ;
}
}
}
else if ( n5AxisType == VolZmap::Move5Axis::ALONG_CONVEX) {
// superfici superiori
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStart[i], vPntTopStart[i+1], vPntTopEnd[i], vPntTopEnd[i+1]})) ;
}
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStartFront[i+1], vPntTopStartFront[i], vPntTopEndFront[i+1], vPntTopEndFront[i]})) ;
// superfici superiori nell'altro verso
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStart2[i], vPntTopStart2[i+1], vPntTopEnd2[i], vPntTopEnd2[i+1]})) ;
}
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStartBack[i], vPntTopStartBack[i+1], vPntTopEndBack[i], vPntTopEndBack[i+1]})) ;
// superfici inferiori semplici
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStart.front(), vPntTipStart.back(), vPntTipEnd.front(), vPntTipEnd.back()})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartFront.front(), vPntTipStartFront.back(), vPntTipEndFront.front(), vPntTipEndFront.back()})) ;
if( s == nStepCnt - 1) {
// calcolo i punti di split dei diametri
PNTVECTOR vSplitDiamStart ;
PNTVECTOR vSplitDiamEnd ;
Vector3d vDirDiamStart = (vPntTipStartEx.back() - vPntTipStartEx.front()) / nSub ;
Vector3d vDirDiamEnd = (vPntTipEndEx.back() - vPntTipEndEx.front()) / nSub ;
Vector3d vDirDiamStart = (vPntTipStartExF.back() - vPntTipStartExF.front()) / nSub ;
Vector3d vDirDiamEnd = (vPntTipEndExF.back() - vPntTipEndExF.front()) / nSub ;
for ( int i = 0 ; i <= nSub ; ++i) {
vSplitDiamStart.push_back( vPntTipStartEx.front() + i * vDirDiamStart) ;
vSplitDiamEnd.push_back( vPntTipEndEx.front() + i * vDirDiamEnd) ;
vSplitDiamStart.push_back( vPntTipStartExF.front() + i * vDirDiamStart) ;
vSplitDiamEnd.push_back( vPntTipEndExF.front() + i * vDirDiamEnd) ;
}
// aggiungo le superfici verticali esterne
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamStart[i+1], vSplitDiamStart[i], vPntTopStartEx[nSub - i - 1], vPntTopStartEx[nSub - i]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamEnd[i], vSplitDiamEnd[i+1], vPntTopEndEx2[nSub - i], vPntTopEndEx2[nSub - i- 1]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamStart[i+1], vSplitDiamStart[i], vPntTopStartExB[nSub - i - 1], vPntTopStartExB[nSub - i]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamEnd[i], vSplitDiamEnd[i+1], vPntTopEndExF[i], vPntTopEndExF[i+1]})) ;
}
// aggiungo le superfici verticali interne
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamStart[i+1], vSplitDiamStart[i], vPntTopStartEx2[nSub - i - 1], vPntTopStartEx2[nSub - i]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamEnd[i], vSplitDiamEnd[i+1], vPntTopEndEx[nSub - i], vPntTopEndEx[nSub - i- 1]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamStart[i+1], vSplitDiamStart[i], vPntTopStartExF[i+1], vPntTopStartExF[i]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamEnd[i], vSplitDiamEnd[i+1], vPntTopEndExB[nSub - i], vPntTopEndExB[nSub - i - 1]})) ;
}
}
}
else if ( n5AxisType == VolZmap::Move5Axis::ALONG_CONCAVE) {
// superfici inferiori
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStart[i], vPntTipStart[i+1], vPntTipEnd[i], vPntTipEnd[i+1]})) ;
}
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartFront[i], vPntTipStartFront[i+1], vPntTipEndFront[i], vPntTipEndFront[i+1]})) ;
// superfici inferiori nell'altro verso
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStart2[i], vPntTipStart2[i+1], vPntTipEnd2[i], vPntTipEnd2[i+1]})) ;
}
for ( int i = 0 ; i < nSub ; ++i)
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTipStartBack[i+1], vPntTipStartBack[i], vPntTipEndBack[i+1], vPntTipEndBack[i]})) ;
// superfici superiori semplici
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStart.front(), vPntTopStart.back(), vPntTopEnd.front(), vPntTopEnd.back()})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vPntTopStartFront.back(), vPntTopStartFront.front(), vPntTopEndFront.back(), vPntTopEndFront.front()})) ;
if( s == nStepCnt - 1) {
// calcolo i punti di split dei diametri
PNTVECTOR vSplitDiamStart ;
PNTVECTOR vSplitDiamEnd ;
Vector3d vDirDiamStart = (vPntTopStartEx.back() - vPntTopStartEx.front()) / nSub ;
Vector3d vDirDiamEnd = (vPntTopEndEx.back() - vPntTopEndEx.front()) / nSub ;
Vector3d vDirDiamStart = (vPntTopStartExF.back() - vPntTopStartExF.front()) / nSub ;
Vector3d vDirDiamEnd = (vPntTopEndExF.back() - vPntTopEndExF.front()) / nSub ;
for ( int i = 0 ; i <= nSub ; ++i) {
vSplitDiamStart.push_back( vPntTopStartEx.front() + i * vDirDiamStart) ;
vSplitDiamEnd.push_back( vPntTopEndEx.front() + i * vDirDiamEnd) ;
vSplitDiamStart.push_back( vPntTopStartExF.front() + i * vDirDiamStart) ;
vSplitDiamEnd.push_back( vPntTopEndExF.front() + i * vDirDiamEnd) ;
}
// aggiungo le superfici verticali esterne
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamStart[i+1], vSplitDiamStart[i], vPntTipStartEx[nSub - i - 1], vPntTipStartEx[nSub - i]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamEnd[i], vSplitDiamEnd[i+1], vPntTipEndEx2[nSub - i], vPntTipEndEx2[nSub - i- 1]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamStart[i], vSplitDiamStart[i+1], vPntTipStartExB[nSub - i], vPntTipStartExB[nSub - i - 1]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamEnd[i+1], vSplitDiamEnd[i], vPntTipEndExF[i+1], vPntTipEndExF[i]})) ;
}
// aggiungo le superfici verticali interne
for ( int i = 0 ; i < nSub ; ++i) {
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamStart[i+1], vSplitDiamStart[i], vPntTipStartEx2[nSub - i - 1], vPntTipStartEx2[nSub - i]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamEnd[i], vSplitDiamEnd[i+1], vPntTipEndEx[nSub - i], vPntTipEndEx[nSub - i- 1]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamStart[i], vSplitDiamStart[i+1], vPntTipStartExF[i], vPntTipStartExF[i+1]})) ;
vvPtCtrl.emplace_back( PNTVECTOR({ vSplitDiamEnd[i+1], vSplitDiamEnd[i], vPntTipEndExB[nSub - i - 1], vPntTipEndExB[nSub - i]})) ;
}
}
}
@@ -1734,25 +1739,26 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
VCT3DVECTOR vvtTipEndAux( nSub + 1) ;
VCT3DVECTOR vvtTopStartAux( nSub + 1) ;
VCT3DVECTOR vvtTopEndAux( nSub + 1) ;
vvtTipStartAux.front() = vPntTipStartEx.front() - ptP1T ;
vvtTipEndAux.front() = vPntTipEndEx.front() - ptP2T ;
vvtTopStartAux.front() = vPntTopStartEx.front() - ptS.front() ;
vvtTopEndAux.front() = vPntTopEndEx.front() - ptE.back() ;
vvtTipStartAux.front() = vPntTipStartExF.front() - ptP1T ;
vvtTipEndAux.front() = vPntTipEndExF.front() - ptP2T ;
vvtTopStartAux.front() = vPntTopStartExF.front() - ptS.front() ;
vvtTopEndAux.front() = vPntTopEndExF.front() - ptE.back() ;
// il riferimento per i settori di base li prendo sempre a partire dai punti sul lato frontale della base
double dMinRadApprox = 0 ;
double dMaxRadApprox = 0 ;
for ( int i = 1 ; i <= nSub ; ++i) {
vvtTipStartAux[i] = Media( vPntTipStartEx[i-1],vPntTipStartEx[i]) - ptP1T ;
vvtTipStartAux[i] = Media( vPntTipStartExF[i-1],vPntTipStartExF[i]) - ptP1T ;
if ( i == nSub)
dMinRadApprox = vvtTipStartAux[i].Len() ;
vvtTipStartAux[i].Normalize() ;
vvtTipEndAux[i] = Media( vPntTipEndEx[i-1],vPntTipEndEx[i]) - ptP2T ;
vvtTipEndAux[i] = Media( vPntTipEndExF[i-1],vPntTipEndExF[i]) - ptP2T ;
vvtTipEndAux[i].Normalize() ;
vvtTopStartAux[i] = Media( vPntTopStartEx[i-1],vPntTopStartEx[i]) - ptS[0] ;
vvtTopStartAux[i] = Media( vPntTopStartExF[i-1],vPntTopStartExF[i]) - ptS[0] ;
if ( i == nSub)
dMaxRadApprox = vvtTopStartAux[i].Len() ;
vvtTopStartAux[i].Normalize() ;
vvtTopEndAux[i] = Media( vPntTopEndEx[i-1],vPntTopEndEx[i]) - ptE.back() ;
vvtTopEndAux[i] = Media( vPntTopEndExF[i-1],vPntTopEndExF[i]) - ptE.back() ;
vvtTopEndAux[i].Normalize() ;
}
@@ -1991,10 +1997,18 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
// verifico se l'intersezione linea-base è interna o esterna
if ( n5AxisType == VolZmap::Move5Axis::NO_BASE_INTERS) {
double dDist = 0 ;
if ( t == 0)
dDist = ( vPntInters[p] - frTool.Orig() ) * vvtTipStartAux[nSector] ;
else if( t == 1)
dDist = ( vPntInters[p] - frTool.Orig() ) * vvtTipEndAux[nSector] ;
if ( t == 0) {
if( dBottomBaseSide < 0)
dDist = ( vPntInters[p] - frTool.Orig()) * ( - vvtTipStartAux[( nSub + 1 ) - nSector]) ;
else
dDist = ( vPntInters[p] - frTool.Orig()) * vvtTipStartAux[nSector] ;
}
else if( t == 1) {
if( dBottomBaseSide < 0)
dDist = ( vPntInters[p] - frTool.Orig()) * ( - vvtTipStartAux[( nSub + 1 ) - nSector]) ;
else
dDist = ( vPntInters[p] - frTool.Orig()) * vvtTipEndAux[nSector] ;
}
if ( (dSide > 0 && t == 0) || (dSide < 0 && t == 1))
vbUpdate[p] = dDist < dMinRadApprox - EPS_SMALL ;
@@ -2003,11 +2017,9 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
}
else if ( n5AxisType == VolZmap::Move5Axis::ALONG_CONCAVE) {
double dDist = 0 ;
// per il caso ALONG_CONCAVE dovrei avere dSide < 0, quindi sulla base bottom avere i punti ausiliari nella parte posteriore del cerchio di base
if ( dBottomBaseSide > 0) {
if ( t == 0) {
// in questo caso devo prendere il vettore Aux dell'angolo supplementare e con segno opposto
dDist = ( vPntInters[p] - frTool.Orig() ) * ( -vvtTipStartAux[( nSub + 1 ) - nSector] ) ;
dDist = ( vPntInters[p] - frTool.Orig()) * vvtTipEndAux[nSector] ;
vbUpdate[p] = dDist < dMinRadApprox - EPS_SMALL ;
}
else if ( t == 1)
@@ -2017,25 +2029,16 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
if ( t == 0)
vbUpdate[p] = true ;
else if ( t == 1 ) {
dDist = (vPntInters[p] - frTool.Orig()) * vvtTipEndAux[nSector] ;
dDist = (vPntInters[p] - frTool.Orig()) * ( - vvtTipStartAux[( nSub + 1 ) - nSector]) ;
vbUpdate[p] = dDist < dMinRadApprox - EPS_SMALL ;
}
}
}
else if ( n5AxisType == VolZmap::Move5Axis::ACROSS) {
double dDist = 0 ;
// con dSide < 0 sulla base bottom/top ho i punti ausiliari nella parte posteriore/anteriore del cerchio di base
// con dSide > 0 sulla base bottom/top ho i punti ausiliari nella parte anteriore/posteriore del cerchio di base
if ( dBottomBaseSide > 0) {
if ( t == 0) {
if ( dSide < 0) {
// in questo caso devo prendere il vettore Aux dell'angolo supplementare e con segno opposto
dDist = ( vPntInters[p] - frTool.Orig() ) * ( -vvtTipStartAux[( nSub + 1 ) - nSector] ) ;
}
else {
dDist = ( vPntInters[p] - frTool.Orig() ) * vvtTipStartAux[nSector] ;
}
dDist = ( vPntInters[p] - frTool.Orig() ) * vvtTipStartAux[nSector] ;
vbUpdate[p] = dDist < dMinRadApprox - EPS_SMALL ;
}
else if ( t == 1)
@@ -2045,13 +2048,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
if ( t == 0)
vbUpdate[p] = true ;
else if ( t == 1) {
if ( dSide < 0) {
dDist = ( vPntInters[p] - frTool.Orig() ) * vvtTipStartAux[nSector] ;
}
else {
// in questo caso devo prendere il vettore Aux dell'angolo supplementare e con segno opposto
dDist = ( vPntInters[p] - frTool.Orig() ) * ( -vvtTipStartAux[( nSub + 1 ) - nSector] ) ;
}
dDist = ( vPntInters[p] - frTool.Orig() ) * ( -vvtTipStartAux[( nSub + 1 ) - nSector] ) ;
vbUpdate[p] = dDist < dMinRadApprox - EPS_SMALL ;
}
}
@@ -2068,10 +2065,18 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
// verifico se l'intersezione linea-base è interna o esterna
if ( n5AxisType == VolZmap::Move5Axis::NO_BASE_INTERS) {
double dDist = 0 ;
if ( t == 0)
dDist = ( vPntInters[p] - ( frTool.Orig() + frTool.VersZ() * dHeight)) * vvtTopStartAux[nSector] ;
else if( t == 1)
dDist = ( vPntInters[p] - ( frTool.Orig() + frTool.VersZ() * dHeight)) * vvtTopEndAux[nSector] ;
if ( t == 0) {
if( dTopBaseSide < 0)
dDist = ( vPntInters[p] - ( frTool.Orig() + frTool.VersZ() * dHeight)) * ( -vvtTopStartAux[( nSub + 1 ) - nSector]) ;
else
dDist = ( vPntInters[p] - ( frTool.Orig() + frTool.VersZ() * dHeight)) * vvtTopStartAux[nSector] ;
}
else if( t == 1) {
if( dTopBaseSide < 0)
dDist = ( vPntInters[p] - ( frTool.Orig() + frTool.VersZ() * dHeight)) * ( -vvtTopStartAux[( nSub + 1 ) - nSector]) ;
else
dDist = ( vPntInters[p] - ( frTool.Orig() + frTool.VersZ() * dHeight)) * vvtTopEndAux[nSector] ;
}
if ( (dSide < 0 && t == 0) || (dSide > 0 && t == 1))
vbUpdate[p] = dDist < dMaxRadApprox - EPS_SMALL ;
@@ -2080,31 +2085,28 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
}
else if ( n5AxisType == VolZmap::Move5Axis::ALONG_CONVEX) {
double dDist = 0 ;
// per il caso ALONG_CONVEX dovrei avere dSide > 0, quindi sulla base top avere i punti ausiliari nella parte posteriore del cerchio di base
if ( dTopBaseSide > 0) {
// in questo caso devo prendere il vettore Aux dell'angolo supplementare e con segno opposto
if ( t == 0)
dDist = ( vPntInters[p] - frTool.Orig()) * ( -vvtTopStartAux[( nSub + 1 ) - nSector]) ;
if ( t == 0) {
dDist = ( vPntInters[p] - frTool.Orig()) * vvtTopStartAux[nSector] ;
vbUpdate[p] = dDist < dMaxRadApprox - EPS_SMALL ;
}
else if( t == 1)
dDist = ( vPntInters[p] - frTool.Orig()) * ( -vvtTopEndAux[( nSub + 1 ) - nSector]) ;
vbUpdate[p] = dDist < dMaxRadApprox - EPS_SMALL ;
vbUpdate[p] = true ;
}
else {
if ( t == 0)
vbUpdate[p] = true ;
else if( t == 1) {
dDist = ( vPntInters[p] - frTool.Orig()) * ( - vvtTopStartAux[nSector]) ;
vbUpdate[p] = dDist < dMaxRadApprox - EPS_SMALL ;
}
}
else
vbUpdate[p] = true ;
}
else if ( n5AxisType == VolZmap::Move5Axis::ACROSS) {
double dDist = 0 ;
// con dSide < 0 sulla base bottom/top ho i punti ausiliari nella parte posteriore/anteriore del cerchio di base
// con dSide > 0 sulla base bottom/top ho i punti ausiliari nella parte anteriore/posteriore del cerchio di base
if ( dTopBaseSide > 0) {
if ( t == 0) {
if ( dSide < 0) {
dDist = ( vPntInters[p] - frTool.Orig()) * vvtTopStartAux[nSector] ;
}
else {
// in questo caso devo prendere il vettore Aux dell'angolo supplementare e con segno opposto
dDist = ( vPntInters[p] - frTool.Orig()) * ( -vvtTopStartAux[( nSub + 1 ) - nSector] ) ;
}
dDist = ( vPntInters[p] - frTool.Orig()) * vvtTopStartAux[nSector] ;
vbUpdate[p] = dDist < dMaxRadApprox - EPS_SMALL ;
}
else if ( t == 1)
@@ -2114,13 +2116,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& pt
if ( t == 0)
vbUpdate[p] = true ;
else if ( t == 1) {
if ( dSide < 0) {
// in questo caso devo prendere il vettore Aux dell'angolo supplementare e con segno opposto
dDist = ( vPntInters[p] - frTool.Orig()) * ( -vvtTopStartAux[( nSub + 1 ) - nSector] ) ;
}
else {
dDist = ( vPntInters[p] - frTool.Orig()) * vvtTopStartAux[nSector] ;
}
dDist = ( vPntInters[p] - frTool.Orig()) * ( -vvtTopStartAux[( nSub + 1 ) - nSector] ) ;
vbUpdate[p] = dDist < dMaxRadApprox - EPS_SMALL ;
}
}