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

EgtGeomKernel :

Browse Source 
- corretto un bug nel taglio spilloni.
This commit is contained in:
Daniele Bariletti
2025-10-07 17:03:07 +02:00
parent c339fced5c
commit 433f486091
1 changed files with 156 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmapVolume.cpp
+156 -172
View File
@@ -1332,7 +1332,7 @@ struct SurfBezForInters {
//----------------------------------------------------------------------------
static bool
IntersLineBezierSurfSet( const Point3d& ptLineStart, const Vector3d& vtLineDir,
const vector<SurfBezForInters>& vSurfBez, PNTVEC3DVECTOR& vInters, INTVECTOR& vSurfInters,
const vector<SurfBezForInters>& vSurfBez, const BBox3d& bbVol, PNTVEC3DVECTOR& vInters, INTVECTOR& vSurfInters,
const Vector3d& vtN, DBLDBLVECTOR& vInterv)
{
Point3d r = ptLineStart ;
@@ -1350,185 +1350,165 @@ IntersLineBezierSurfSet( const Point3d& ptLineStart, const Vector3d& vtLineDir,
r.ToLoc( frRot) ;
q.ToLoc( frRot) ;
}
// salvo un vettore di flag per tenere traccia delle superfici con cui ho trovato delle intersezioni
BOOLVECTOR vbAlreadyCalc( vSurfBez.size()) ;
fill( vbAlreadyCalc.begin(), vbAlreadyCalc.end(), false) ;
bool bCalcAll = false ;
// calcolo se un intevallo sul dexel interseca il box dell'intero volume spazzato
bool bIntersVol = false ;
for ( int k = 0 ; k < int(vInterv.size()) && ! bIntersVol; ++k) {
INTDBLVECTOR vIntersDash ;
IntersLineBox( r + q* vInterv[k].first, r + q * vInterv[k].second, bbVol, vIntersDash, true) ;
bIntersVol = vIntersDash.size() > 0 ;
}
// se non sono stati passati gli intervalli allora vuol dire che lo spillone interseca
if ( vInterv.size() == 0)
bIntersVol = true ;
Reiterate :
INTVECTOR vIntersCalc ; // debug
if( bIntersVol) {
// interseco con le bezier
for ( int s = 0 ; s < int( vSurfBez.size()) ; ++s) {
// se ho già trovato l'intersezione con questa superficie vado avanti
// interseco con le bezier
for ( int s = 0 ; s < int( vSurfBez.size()) ; ++s) {
// se ho già trovato l'intersezione con questa superficie vado avanti
if ( vbAlreadyCalc[s])
continue ;
const SurfBezForInters& srf = vSurfBez[s] ;
BBox3d bbox = srf.bbSurfOriented;
bool bNotValid = false ;
Point3d rLoc = r ;
Vector3d qLoc = q ;
if ( ! bNeedToRot) {
rLoc.ToLoc( srf.frBox) ;
qLoc.ToLoc( srf.frBox) ;
}
else {
rLoc.LocToLoc( frRot, srf.frBox) ;
qLoc.LocToLoc( frRot, srf.frBox) ;
}
INTDBLVECTOR vIntBoxBox ;
bool bCalcInters = false ;
// vettore degli intervalli che intersecano il box della superficie
INTVECTOR vIntervInters ;
// verifico se uno degli intervalli sul voxel interseca il box
if ( vInterv.size() > 0 && ! bCalcAll) {
for ( int k = 0 ; k < int( vInterv.size()) ; ++k) {
INTDBLVECTOR vIntersDash ;
IntersLineBox( rLoc + qLoc * vInterv[k].first, rLoc + qLoc * vInterv[k].second, bbox, vIntersDash, true) ;
bool bInters = vIntersDash.size() > 0 ;
bCalcInters = bCalcInters || bInters ;
if ( bInters)
vIntervInters.push_back( k) ;
}
}
// oppure verifico se il voxel interseca la box
else {
INTDBLVECTOR vIntersDash ;
bCalcInters = IntersLineBox( rLoc, qLoc, 0, bbox, vIntersDash, false) ;
}
// verifico che lo spillone faccia interferenza con il box della superficie
if ( bCalcInters) {
vbAlreadyCalc[s] = true ;
// se la linea è parallela all'asse X o Y allora ruoto tutto di 45 gradi rispetto a Z
Vector3d a3, a2, a1, a0, b3, b2, b1, b0 ;
const SurfBezForInters& srf = vSurfBez[s] ;
BBox3d bbox = srf.bbSurfOriented;
bool bNotValid = false ;
Point3d rLoc = r ;
Vector3d qLoc = q ;
if ( ! bNeedToRot) {
a3 = srf.a3 ;
a2 = srf.a2 ;
a1 = srf.a1 ;
a0 = srf.a0 ;
b3 = srf.b3 ;
b2 = srf.b2 ;
b1 = srf.b1 ;
b0 = srf.b0 ;
rLoc.ToLoc( srf.frBox) ;
qLoc.ToLoc( srf.frBox) ;
}
else {
SurfBezier sBezRot = srf.sBez ;
sBezRot.ToLoc( frRot) ;
PNTVECTOR vPntCtrl = sBezRot.GetAllControlPoints() ;
Vector3d A = vPntCtrl[4] - vPntCtrl[0] ;
Vector3d B = vPntCtrl[5] - vPntCtrl[1] ;
Vector3d C = vPntCtrl[6] - vPntCtrl[2] ;
Vector3d D = vPntCtrl[7] - vPntCtrl[3] ;
Vector3d E = vPntCtrl[0] - ORIG ;
Vector3d F = vPntCtrl[1] - ORIG ;
Vector3d G = vPntCtrl[2] - ORIG ;
Vector3d H = vPntCtrl[3] - ORIG ;
a3 = -A + 3*B - 3*C + D ;
a2 = 3*A - 6*B + 3*C ;
a1 = -3*A +3*B ;
a0 = A ;
b3 = -E + 3*F - 3*G + H ;
b2 = 3*E - 6*F + 3*G ;
b1 = -3*E + 3*F ;
b0 = E ;
rLoc.LocToLoc( frRot, srf.frBox) ;
qLoc.LocToLoc( frRot, srf.frBox) ;
}
DBLVECTOR vdCoeff, vdRoots ;
// coefficienti dal grado più basso al grado più alto
vdCoeff = { // c0
q.x*q.z*a0.y*b0.z - q.x*q.y*a0.z*b0.z // 3
- r.z*q.x*q.z*a0.y + r.z*q.x*q.y*a0.z + // 3
q.y*q.z*a0.z*b0.z - q.z*q.z*a0.y*b0.x // 4
- r.x*q.y*q.z*a0.z + r.x*q.z*q.z*a0.y + // 4
q.z*q.z*a0.x*b0.y - q.y*q.z*a0.x*b0.z - q.x*q.z*a0.z*b0.y + q.x*q.y*a0.z*b0.z // 5
- r.y*q.z*q.z*a0.x + r.z*q.y*q.z*a0.x + r.y*q.x*q.z*a0.z - r.z*q.x*q.y*a0.z, // 5
bool bCalcInters = false ;
// verifico se il voxel interseca la box
INTDBLVECTOR vIntersDash ;
IntersLineBox(rLoc, qLoc, 0, bbox, vIntersDash, false) ;
bCalcInters = vIntersDash.size() > 0 ;
// c1
q.x*q.z*(a1.y*b0.z + a0.y*b1.z) - q.x*q.y*(a1.z*b0.z + a0.z*b1.z) // 3
- r.z*q.x*q.z*a1.y + r.z*q.x*q.y*a1.z + // 3
q.y*q.z*(a1.z*b0.x + a0.z*b1.x) - q.z*q.z*(a1.y*b0.x + a0.y*b1.x) // 4
- r.x*q.y*q.z*a1.z + r.x*q.z*q.z*a1.y + // 4
q.z*q.z*(a1.x*b0.y + a0.x*b1.y) - q.y*q.z*(a1.x*b0.z + a0.x*b1.z) // 5
- q.x*q.z*(a1.z*b0.y + a0.z*b1.y) + q.x*q.y*(a1.z*b0.z + a0.z*b1.z) // 5
- r.y*q.z*q.z*a1.x + r.z*q.y*q.z*a1.x + r.y*q.x*q.z*a1.z - r.z*q.x*q.y*a1.z, // 5
// c2
q.x*q.z*(a2.y*b0.z + a1.y*b1.z + a0.y*b2.z) - q.x*q.y*(a2.z*b0.z + a1.z*b1.z + a0.z*b2.z) // 3
- r.z*q.x*q.z*a2.y + r.z*q.x*q.y*a2.z + // 3
q.y*q.z*(a2.z*b0.x + a1.z*b1.x + a0.z*b2.x) - q.z*q.z*(a2.y*b0.x + a1.y*b1.x + a0.y*b2.x) // 4
- r.x*q.y*q.z*a2.z + r.x*q.z*q.z*a2.y + // 4
q.z*q.z*(a2.x*b0.y + a1.x*b1.y + a0.x*b2.y) - q.y*q.z*(a2.x*b0.z + a1.x*b1.z + a0.x*b2.z) // 5
- q.x*q.z*(a2.z*b0.y + a1.z*b1.y + a0.z*b2.y) + q.x*q.y*(a2.z*b0.z + a1.z*b1.z + a0.z*b2.z)// 5
- r.y*q.z*q.z*a2.x + r.z*q.y*q.z*a2.x + r.y*q.x*q.z*a2.z - r.z*q.x*q.y*a2.z, // 5
// verifico che lo spillone faccia interferenza con il box della superficie
if ( bCalcInters) {
// c3
q.x*q.z*(a3.y*b0.z + a2.y*b1.z + a1.y*b2.z + a0.y*b3.z) - q.x*q.y*(a3.z*b0.z + a2.z*b1.z + a1.z*b2.z + a0.z*b3.z) // 3
- r.z*q.x*q.z*a3.y + r.z*q.x*q.y*a3.z + // 3
q.y*q.z*(a3.z*b0.x + a2.z*b1.x + a1.z*b2.x + a0.z*b3.x) - q.z*q.z*(a3.y*b0.x + a2.y*b1.x + a1.y*b2.x + a0.y*b3.x) // 4
- r.x*q.y*q.z*a3.z + r.x*q.z*q.z*a3.y + // 4
q.z*q.z*(a3.x*b0.y + a2.x*b1.y + a1.x*b2.y + a0.x*b3.y) - q.y*q.z*(a3.x*b0.z + a2.x*b1.z + a1.x*b2.z + a0.x*b3.z) // 5
- q.x*q.z*(a3.z*b0.y + a2.z*b1.y + a1.z*b2.y + a0.z*b3.y) + q.x*q.y*(a3.z*b0.z + a2.z*b1.z + a1.z*b2.z + a0.z*b3.z)// 5
- r.y*q.z*q.z*a3.x + r.z*q.y*q.z*a3.x + r.y*q.x*q.z*a3.z - r.z*q.x*q.y*a3.z, // 5
// c4
q.x*q.z*(a3.y*b1.z + a2.y*b2.z + a1.y*b3.z) - q.x*q.y*(a3.z*b1.z + a2.z*b2.z + a1.z*b3.z) + // 3
q.y*q.z*(a3.z*b1.x + a2.z*b2.x + a1.z*b3.x) - q.z*q.z*(a3.y*b1.x + a2.y*b2.x + a1.y*b3.x) + // 4
q.z*q.z*(a3.x*b1.y + a2.x*b2.y + a1.x*b3.y) - q.y*q.z*(a3.x*b1.z + a2.x*b2.z + a1.x*b3.z) // 5
- q.x*q.z*(a3.z*b1.y + a2.z*b2.y + a1.z*b3.y) + q.x*q.y*(a3.z*b1.z + a2.z*b2.z + a1.z*b3.z), // 5
vIntersCalc.push_back( s) ; // debug
// se la linea è parallela all'asse X o Y allora ruoto tutto di 45 gradi rispetto a Z
Vector3d a3, a2, a1, a0, b3, b2, b1, b0 ;
if ( ! bNeedToRot) {
a3 = srf.a3 ;
a2 = srf.a2 ;
a1 = srf.a1 ;
a0 = srf.a0 ;
b3 = srf.b3 ;
b2 = srf.b2 ;
b1 = srf.b1 ;
b0 = srf.b0 ;
}
else {
SurfBezier sBezRot = srf.sBez ;
sBezRot.ToLoc( frRot) ;
PNTVECTOR vPntCtrl = sBezRot.GetAllControlPoints() ;
// c5
q.x*q.z*(a3.y*b2.z + a2.y*b3.z) - q.x*q.y*(a3.z*b2.z + a2.z*b3.z) + // 3
q.y*q.z*(a3.z*b2.x + a2.z*b3.x) - q.z*q.z*(a3.y*b2.x + a2.y*b3.x) + // 4
q.z*q.z*(a3.x*b2.y + a2.x*b3.y) - q.y*q.z*(a3.x*b2.z + a2.x*b3.z) // 5
- q.x*q.z*(a3.z*b2.y + a2.z*b3.y) + q.x*q.y*(a3.z*b2.z + a2.z*b3.z), // 5
Vector3d A = vPntCtrl[4] - vPntCtrl[0] ;
Vector3d B = vPntCtrl[5] - vPntCtrl[1] ;
Vector3d C = vPntCtrl[6] - vPntCtrl[2] ;
Vector3d D = vPntCtrl[7] - vPntCtrl[3] ;
Vector3d E = vPntCtrl[0] - ORIG ;
Vector3d F = vPntCtrl[1] - ORIG ;
Vector3d G = vPntCtrl[2] - ORIG ;
Vector3d H = vPntCtrl[3] - ORIG ;
// c6
q.x*q.z*a3.y*b3.z - q.x*q.y*a3.z*b3.z + // 3
q.y*q.z*a3.z*b3.x - q.z*q.z*a3.y*b3.x + // 4
q.z*q.z*a3.x*b3.y - q.y*q.z*a3.x*b3.z - q.x*q.z*a3.z*b3.y + q.x*q.y*a3.z*b3.z} ; // 5
int nRoots = PolynomialRoots( 6, vdCoeff, vdRoots) ;
for ( int w = 0 ; w < nRoots ; ++w) {
double dU = 0, dV = 0 ;
if ( vdRoots[w] > 0 - EPS_ZERO && vdRoots[w] < 1 + EPS_ZERO) {
dU = vdRoots[w] ;
// verifico che non sia una soluzione con molteplicità > 1
bool bAlreadyFound = false ;
for ( int k = w - 1 ; k >= 0 && ! bAlreadyFound ; --k)
bAlreadyFound = ( abs( dU - vdRoots[k]) < EPS_PARAM) ;
if ( ! bAlreadyFound) {
Vector3d vAlpha = a3 * pow(dU, 3) + a2 * pow( dU, 2) + a1 * dU + a0 ;
Vector3d vBeta = b3 * pow(dU, 3) + b2 * pow( dU, 2) + b1 * dU + b0 ;
double dDen = ( vAlpha.x * q.z - vAlpha.z * q.x) ;
if ( abs( dDen) > EPS_ZERO)
dV = ( ( vBeta.z - r.z) * q.x - ( vBeta.x - r.x ) * q.z) / dDen ;
else {
// se la prima equazione risulta un x/0 allora uso la seconda equazione per trovare il secondo parametro
double dDen2 = ( vAlpha.y * q.z - vAlpha.z * q.y) ;
dV = ( ( vBeta.z - r.z) * q.y - ( vBeta.y - r.y ) * q.z) / dDen2 ;
}
if ( dV > - EPS_ZERO && dV < 1 + EPS_ZERO) {
Point3d ptBez ;
Vector3d vtN ;
srf.sBez.GetPointNrmD1D2(dU, dV, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptBez, vtN) ;
vtN *= -1 ;
UpdateMaxMin( ptBez, vtN, vInters) ;
vSurfInters.push_back( s) ;
a3 = -A + 3*B - 3*C + D ;
a2 = 3*A - 6*B + 3*C ;
a1 = -3*A +3*B ;
a0 = A ;
// se ho trovato un'intersezione all'interno dell'intervallo, esistente sullo spillone e che si interseca con il box, allora devo ricontrollare
// anche le superfici i cui box non facevano intersezione con l'intervallo
if ( vIntervInters.size() > 0 && ! bNeedToRot && ! bCalcAll) {
for (int i : vIntervInters) {
if (vInterv[i].first < ptBez.z && ptBez.z < vInterv[i].second) {
bCalcAll = true ;
goto Reiterate ;
}
}
b3 = -E + 3*F - 3*G + H ;
b2 = 3*E - 6*F + 3*G ;
b1 = -3*E + 3*F ;
b0 = E ;
}
DBLVECTOR vdCoeff, vdRoots ;
// coefficienti dal grado più basso al grado più alto
vdCoeff = { // c0
q.x*q.z*a0.y*b0.z - q.x*q.y*a0.z*b0.z // 3
- r.z*q.x*q.z*a0.y + r.z*q.x*q.y*a0.z + // 3
q.y*q.z*a0.z*b0.z - q.z*q.z*a0.y*b0.x // 4
- r.x*q.y*q.z*a0.z + r.x*q.z*q.z*a0.y + // 4
q.z*q.z*a0.x*b0.y - q.y*q.z*a0.x*b0.z - q.x*q.z*a0.z*b0.y + q.x*q.y*a0.z*b0.z // 5
- r.y*q.z*q.z*a0.x + r.z*q.y*q.z*a0.x + r.y*q.x*q.z*a0.z - r.z*q.x*q.y*a0.z, // 5
// c1
q.x*q.z*(a1.y*b0.z + a0.y*b1.z) - q.x*q.y*(a1.z*b0.z + a0.z*b1.z) // 3
- r.z*q.x*q.z*a1.y + r.z*q.x*q.y*a1.z + // 3
q.y*q.z*(a1.z*b0.x + a0.z*b1.x) - q.z*q.z*(a1.y*b0.x + a0.y*b1.x) // 4
- r.x*q.y*q.z*a1.z + r.x*q.z*q.z*a1.y + // 4
q.z*q.z*(a1.x*b0.y + a0.x*b1.y) - q.y*q.z*(a1.x*b0.z + a0.x*b1.z) // 5
- q.x*q.z*(a1.z*b0.y + a0.z*b1.y) + q.x*q.y*(a1.z*b0.z + a0.z*b1.z) // 5
- r.y*q.z*q.z*a1.x + r.z*q.y*q.z*a1.x + r.y*q.x*q.z*a1.z - r.z*q.x*q.y*a1.z, // 5
// c2
q.x*q.z*(a2.y*b0.z + a1.y*b1.z + a0.y*b2.z) - q.x*q.y*(a2.z*b0.z + a1.z*b1.z + a0.z*b2.z) // 3
- r.z*q.x*q.z*a2.y + r.z*q.x*q.y*a2.z + // 3
q.y*q.z*(a2.z*b0.x + a1.z*b1.x + a0.z*b2.x) - q.z*q.z*(a2.y*b0.x + a1.y*b1.x + a0.y*b2.x) // 4
- r.x*q.y*q.z*a2.z + r.x*q.z*q.z*a2.y + // 4
q.z*q.z*(a2.x*b0.y + a1.x*b1.y + a0.x*b2.y) - q.y*q.z*(a2.x*b0.z + a1.x*b1.z + a0.x*b2.z) // 5
- q.x*q.z*(a2.z*b0.y + a1.z*b1.y + a0.z*b2.y) + q.x*q.y*(a2.z*b0.z + a1.z*b1.z + a0.z*b2.z)// 5
- r.y*q.z*q.z*a2.x + r.z*q.y*q.z*a2.x + r.y*q.x*q.z*a2.z - r.z*q.x*q.y*a2.z, // 5
// c3
q.x*q.z*(a3.y*b0.z + a2.y*b1.z + a1.y*b2.z + a0.y*b3.z) - q.x*q.y*(a3.z*b0.z + a2.z*b1.z + a1.z*b2.z + a0.z*b3.z) // 3
- r.z*q.x*q.z*a3.y + r.z*q.x*q.y*a3.z + // 3
q.y*q.z*(a3.z*b0.x + a2.z*b1.x + a1.z*b2.x + a0.z*b3.x) - q.z*q.z*(a3.y*b0.x + a2.y*b1.x + a1.y*b2.x + a0.y*b3.x) // 4
- r.x*q.y*q.z*a3.z + r.x*q.z*q.z*a3.y + // 4
q.z*q.z*(a3.x*b0.y + a2.x*b1.y + a1.x*b2.y + a0.x*b3.y) - q.y*q.z*(a3.x*b0.z + a2.x*b1.z + a1.x*b2.z + a0.x*b3.z) // 5
- q.x*q.z*(a3.z*b0.y + a2.z*b1.y + a1.z*b2.y + a0.z*b3.y) + q.x*q.y*(a3.z*b0.z + a2.z*b1.z + a1.z*b2.z + a0.z*b3.z)// 5
- r.y*q.z*q.z*a3.x + r.z*q.y*q.z*a3.x + r.y*q.x*q.z*a3.z - r.z*q.x*q.y*a3.z, // 5
// c4
q.x*q.z*(a3.y*b1.z + a2.y*b2.z + a1.y*b3.z) - q.x*q.y*(a3.z*b1.z + a2.z*b2.z + a1.z*b3.z) + // 3
q.y*q.z*(a3.z*b1.x + a2.z*b2.x + a1.z*b3.x) - q.z*q.z*(a3.y*b1.x + a2.y*b2.x + a1.y*b3.x) + // 4
q.z*q.z*(a3.x*b1.y + a2.x*b2.y + a1.x*b3.y) - q.y*q.z*(a3.x*b1.z + a2.x*b2.z + a1.x*b3.z) // 5
- q.x*q.z*(a3.z*b1.y + a2.z*b2.y + a1.z*b3.y) + q.x*q.y*(a3.z*b1.z + a2.z*b2.z + a1.z*b3.z), // 5
// c5
q.x*q.z*(a3.y*b2.z + a2.y*b3.z) - q.x*q.y*(a3.z*b2.z + a2.z*b3.z) + // 3
q.y*q.z*(a3.z*b2.x + a2.z*b3.x) - q.z*q.z*(a3.y*b2.x + a2.y*b3.x) + // 4
q.z*q.z*(a3.x*b2.y + a2.x*b3.y) - q.y*q.z*(a3.x*b2.z + a2.x*b3.z) // 5
- q.x*q.z*(a3.z*b2.y + a2.z*b3.y) + q.x*q.y*(a3.z*b2.z + a2.z*b3.z), // 5
// c6
q.x*q.z*a3.y*b3.z - q.x*q.y*a3.z*b3.z + // 3
q.y*q.z*a3.z*b3.x - q.z*q.z*a3.y*b3.x + // 4
q.z*q.z*a3.x*b3.y - q.y*q.z*a3.x*b3.z - q.x*q.z*a3.z*b3.y + q.x*q.y*a3.z*b3.z} ; // 5
int nRoots = PolynomialRoots( 6, vdCoeff, vdRoots) ;
for ( int w = 0 ; w < nRoots ; ++w) {
double dU = 0, dV = 0 ;
if ( vdRoots[w] > 0 - EPS_ZERO && vdRoots[w] < 1 + EPS_ZERO) {
dU = vdRoots[w] ;
// verifico che non sia una soluzione con molteplicità > 1
bool bAlreadyFound = false ;
for ( int k = w - 1 ; k >= 0 && ! bAlreadyFound ; --k)
bAlreadyFound = ( abs( dU - vdRoots[k]) < EPS_PARAM) ;
if ( ! bAlreadyFound) {
Vector3d vAlpha = a3 * pow(dU, 3) + a2 * pow( dU, 2) + a1 * dU + a0 ;
Vector3d vBeta = b3 * pow(dU, 3) + b2 * pow( dU, 2) + b1 * dU + b0 ;
double dDen = ( vAlpha.x * q.z - vAlpha.z * q.x) ;
if ( abs( dDen) > EPS_ZERO)
dV = ( ( vBeta.z - r.z) * q.x - ( vBeta.x - r.x ) * q.z) / dDen ;
else {
// se la prima equazione risulta un x/0 allora uso la seconda equazione per trovare il secondo parametro
double dDen2 = ( vAlpha.y * q.z - vAlpha.z * q.y) ;
dV = ( ( vBeta.z - r.z) * q.y - ( vBeta.y - r.y ) * q.z) / dDen2 ;
}
if ( dV > - EPS_ZERO && dV < 1 + EPS_ZERO) {
Point3d ptBez ;
Vector3d vtN ;
srf.sBez.GetPointNrmD1D2(dU, dV, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptBez, vtN) ;
vtN *= -1 ;
UpdateMaxMin( ptBez, vtN, vInters) ;
vSurfInters.push_back( s) ;
}
}
}
@@ -1581,6 +1561,8 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
int nSurfInd = 0 ;
vector<SurfBezForInters> vSurfBez( nTotSurf) ;
// box dell'intero volume spazzato, nel riferimento globale
BBox3d bbVol = GetCylMoveRotBBox( ptS, ptE, vtLs, vtLe, dMaxRad, dHeight) ;
double dSide = 0 ;
// punti di riferimento sul tool
@@ -2001,8 +1983,9 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
} ;
vector<IntervalsToSubtract> vIntervalsToSubtr ;
#ifdef TEST
//debug
if (nStepCounter >= 153) {
if (nStepCounter >= 153 && false) {
if (nGrid == 2)
int d = 0;
if (nStepCounter == 153) {
@@ -2016,6 +1999,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
}
//debug
#endif
for ( int i = nStartI ; i <= nEndI ; ++ i) {
nLastForwardJ = -1 ;
@@ -2038,7 +2022,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
vInterv.emplace_back( vDexel[k].dMin, vDexel[k].dMax) ;
if ( vDexel.size() != 0) {
IntersLineBezierSurfSet( r, q, vSurfBez, vInters, vSurfInters, vtLs, vInterv) ;
IntersLineBezierSurfSet( r, q, vSurfBez, bbVol, vInters, vSurfInters, vtLs, vInterv) ;
if ( vInters.size() > 2) {
SortGroupInters( vInters, vStartEnds, Z_AX) ;
@@ -2062,7 +2046,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
INTVECTOR vSurfX ;
INTINTVECTOR vStartEndsX ;
bool bXInclude = false ;
IntersLineBezierSurfSet( ptLineStart, vtLineStart, vSurfBez, vIntersX, vSurfX, V_NULL, vEmpty) ;
IntersLineBezierSurfSet( ptLineStart, vtLineStart, vSurfBez, bbVol, vIntersX, vSurfX, V_NULL, vEmpty) ;
if ( vIntersX.size() > 1) {
SortGroupInters( vIntersX, vStartEndsX, X_AX) ;
if ( vStartEndsX.size() != 0)
@@ -2076,7 +2060,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
INTVECTOR vSurfY ;
INTINTVECTOR vStartEndsY ;
bool bYInclude = false ;
IntersLineBezierSurfSet( ptLineStart, vtLineStart, vSurfBez, vIntersY, vSurfY, V_NULL, vEmpty) ;
IntersLineBezierSurfSet( ptLineStart, vtLineStart, vSurfBez, bbVol, vIntersY, vSurfY, V_NULL, vEmpty) ;
if ( vIntersY.size() > 1) {
SortGroupInters( vIntersY, vStartEndsY, Y_AX) ;
if ( vStartEndsY.size() != 0)