From 2aca943de44dcb250bb0f883ca0febdf07d31500 Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Thu, 26 Mar 2026 12:42:05 +0100 Subject: [PATCH] EgtGeomKernel : - estrapolata funzione per l'intersezione tra superficie di bezier 3x1 con una linea. --- IntersLineSurfBez.cpp | 376 +++++++++++++++++++++++++++++++++++++++--- SurfBezier.h | 2 +- 2 files changed, 358 insertions(+), 20 deletions(-) diff --git a/IntersLineSurfBez.cpp b/IntersLineSurfBez.cpp index 7daf922..c6bd541 100644 --- a/IntersLineSurfBez.cpp +++ b/IntersLineSurfBez.cpp @@ -72,14 +72,28 @@ static void UpdateInfoIntersLineSurfBz( const Point3d& ptL, const Vector3d& vtDir, int nILT, int nT, const Point3d& ptSP, const Point3d& ptIBz, double dCos, const Point3d& ptSP2, const Point3d& ptIBz2, double dCos2, ILSBIVECTOR& vInfo) { + int nType = LSBT_NONE ; + if ( dCos > EPS_ZERO) + nType = LSBT_IN ; + else if ( dCos < EPS_ZERO) + nType = LSBT_OUT ; + else + nType = LSBT_TOUCH ; + if ( nILT == ILTA_IN || nILT == ILTA_EDGE || nILT == ILTA_VERT || nILT == ILTA_NO_TRIA) { double dU = ( ptIBz - ptL) * vtDir ; - vInfo.emplace_back( nILT, dU, nT, dCos, ptIBz, ptSP) ; + vInfo.emplace_back( nType, dU, nT, dCos, ptIBz, ptSP) ; } else if ( nILT == ILTA_SEGM || nILT == ILTA_SEGM_ON_EDGE) { double dU = ( ptIBz - ptL) * vtDir ; double dU2 = ( ptIBz2 - ptL) * vtDir ; - vInfo.emplace_back( nILT, dU, dU2, nT, dCos2, ptIBz, ptIBz2, ptSP, ptSP2) ; + int nType2 = LSBT_NONE ; + if ( dCos2 > EPS_ZERO) + nType2 = LSBT_IN ; + else if ( dCos2 < EPS_ZERO) + nType2 = LSBT_OUT ; + vInfo.emplace_back( nType, dU, 0, nT, dCos, ptIBz, P_INVALID, ptSP, P_INVALID) ; + vInfo.emplace_back( nType2, dU2, 0, nT, dCos2, ptIBz2, P_INVALID, ptSP2, P_INVALID) ; } } @@ -93,9 +107,7 @@ OrderInfoIntersLineSurfBz( ILSBIVECTOR& vInfo) // ordino il vettore delle intersezioni secondo il senso crescente del parametro di linea sort( vInfo.begin(), vInfo.end(), []( const IntLinSbzInfo& a, const IntLinSbzInfo& b) - { double dUa = ( ( a.nILTA == ILTA_SEGM || a.nILTA == ILTA_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ; - double dUb = ( ( b.nILTA == ILTA_SEGM || b.nILTA == ILTA_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ; - return ( dUa < dUb) ; }) ; + { return ( a.dU < b.dU) ; }) ; } //---------------------------------------------------------------------------- @@ -181,19 +193,9 @@ FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters) // ciclo sulle intersezioni for ( const auto& Info : vInfo) { // se intersezione puntuale - if ( Info.nILTA == ILTA_VERT || Info.nILTA == ILTA_EDGE || Info.nILTA == ILTA_IN) { - int nFlag = LSBT_TOUCH ; - if ( Info.dCosDN > EPS_ZERO) - nFlag = LSBT_OUT ; - else if ( Info.dCosDN < -EPS_ZERO) - nFlag = LSBT_IN ; - vInters.emplace_back( nFlag, Info.dU) ; - } - // se altrimenti intersezione con coincidenza - else if ( Info.nILTA == ILTA_SEGM || Info.nILTA == ILTA_SEGM_ON_EDGE) { - vInters.emplace_back( LSBT_TG_INI, Info.dU) ; - vInters.emplace_back( LSBT_TG_FIN, Info.dU2) ; - } + vInters.emplace_back( Info.nILSB, Info.dU) ; + // se intersezione sovrapposta + // da sviluppare } // elimino intersezioni ripetute for ( size_t j = 1 ; j < vInters.size() ; ) { @@ -239,7 +241,343 @@ FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters) } //---------------------------------------------------------------------------- -// Intersezione di una linea con una superficie di Bezier +// Intersezione di una linea con una superficie di Bezier di grado 3x1 monopatch +//---------------------------------------------------------------------------- +bool +IntersLineSurfBzCubicLinear( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfBezier* pSurfBz, + ILSBIVECTOR& vInfo, bool bFinite) +{ + int nDegU, nDegV, nSpanU, nSpanV ; + bool bRat, bTrimmed ; + pSurfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ; + + // funzione pensata per funzionare solo con una monopatch di grado 3x1 + if ( nDegU != 3 || nDegV != 1 || nSpanU > 1 || nSpanV > 1 || bRat) + return false ; + + int nInters = int( vInfo.size()) ; + + Point3d r = ptL ; + Vector3d q = vtL ; + bool bNeedToRotX = AreSameVectorApprox( q, X_AX) ; + bool bNeedToRotY = AreSameVectorApprox( q, Y_AX) ; + bool bNeedToRot = bNeedToRotX || bNeedToRotY ; + Frame3d frRot ; + if ( bNeedToRotX) + frRot.Set( ORIG, X_AX) ; + if ( bNeedToRotY) + frRot.Set( ORIG, Y_AX) ; + if ( bNeedToRot) { + r.ToLoc( frRot) ; + q.ToLoc( frRot) ; + } + + PNTVECTOR vPntCtrl = pSurfBz->GetAllControlPoints() ; + + if ( bNeedToRot) { + for ( Point3d& pt: vPntCtrl) + pt.ToLoc( frRot) ; + } + + 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 ; + + Vector3d a3 = -A + 3 * B - 3 * C + D ; + Vector3d a2 = 3 * A - 6 * B + 3 * C ; + Vector3d a1 = -3 * A + 3 * B ; + Vector3d a0 = A ; + + Vector3d b3 = -E + 3 * F - 3 * G + H ; + Vector3d b2 = 3 * E - 6 * F + 3 * G ; + Vector3d b1 = -3 * E + 3 * F ; + Vector3d 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) ; + bool bFound = false ; + 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 ptIBez, ptIBez2 ; + Vector3d vtN ; + pSurfBz->GetPointNrmD1D2(dU, dV, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez, vtN) ; + Point3d ptSP( dU, dV, 0), ptSP2 ; + double dCos = vtN * vtL, dCos2 = 0 ; + int nType = ILTA_NO_TRIA ; + UpdateInfoIntersLineSurfBz( ptL, vtL, nType, -1, ptSP, ptIBez, dCos, ptSP2, ptIBez2, dCos2, vInfo) ; + bFound = true ; + } + } + } + } + + //// se tutti i coefficienti sono zero allora potrei avere una linea che giace sulla superficie + //// per trovare i punti di inizio e fine sovrapposizione trovo i punti a minima distanza tra la linea e gli edge della superficie + //if ( ! bFound && abs( vdCoeff[0]) < EPS_ZERO && abs( vdCoeff[1]) < EPS_ZERO && abs( vdCoeff[2]) < EPS_ZERO) { + // ICRVCOMPOPOVECTOR vCrvEdge( 4) ; + // vCrvEdge[0].Set(pSurfBz->GetCurveOnU( 0)) ; + // vCrvEdge[1].Set(pSurfBz->GetCurveOnV( 1)) ; + // vCrvEdge[2].Set(pSurfBz->GetCurveOnU( 1)) ; + // vCrvEdge[3].Set(pSurfBz->GetCurveOnV( 0)) ; + // double dAngTolDeg = 5 ; + // for ( int i = 0 ; i < 4 ; ++i) { + // PolyLine plApprox ; vCrvEdge[0]->ApproxWithLines( EPS_SMALL, dAngTolDeg, ICurve::ApprLineType::APL_STD, plApprox) ; + // //CurveComposite cCC ; + // //cCC.FromPolyLine( plApprox) ; + // int nClosestLine = -1 ; + // double dMinDist = INFINITO ; + // Point3d pt ; plApprox.GetFirstPoint( pt) ; + // Point3d ptClosest ; + // int c = 0 ; + // int nTot = plApprox.GetPointNbr() ; + // for ( int j = 0 ; j < nTot ; ++j) { + // DistPointLine dpl( pt, ptL, vtL, dLen, bFinite) ; + // double dDist = INFINITO ; + // dpl.GetDist( dDist) ; + // if ( dDist < dMinDist) { + // nClosestLine = c ; + // dMinDist = dDist ; + // } + // plApprox.GetNextPoint( pt) ; + // ++ c ; + // } + + // Point3d ptInt1, ptInt2 ; + // if ( nClosestLine < nTot - 1 && nClosestLine > 0) { + // // tra i due tratti dell'approssimazione che arrivano al punto selezionato come più vicino, devo trovare quale si avvicina di più + // Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ; + // Point3d ptEnd ; + // for ( int z = 1 ; z < nClosestLine - 1 ; ++z) + // plApprox.GetNextPoint( ptStart) ; + // plApprox.GetNextPoint( ptEnd) ; + // // linea precedente al punto + // Vector3d vtLinePre = ptEnd - ptStart ; + // double dLenPre = vtLinePre.Len() ; + // DistLineLine dllPre( ptStart, vtLinePre, dLenPre, ptL, vtL,dLen) ; + // double dDistPre = INFINITO ; + // dllPre.GetDist( dDistPre) ; + // // linea che inzia con quel punto + // ptStart = ptEnd ; + // plApprox.GetNextPoint( ptEnd) ; + // Vector3d vtLineCurr = ptEnd - ptStart ; + // double dLenCurr = vtLineCurr.Len() ; + // DistLineLine dllCurr( ptStart, vtLineCurr, dLenCurr, ptL, vtL,dLen) ; + // double dDistCurr = INFINITO ; + // dllCurr.GetDist( dDistCurr) ; + + // if ( dDistPre < dDistCurr) + // dllPre.GetMinDistPoints( ptInt1, ptInt2) ; + // else + // dllCurr.GetMinDistPoints( ptInt1, ptInt2) ; + // } + // else if ( nClosestLine == 0) { + // // il punto più vicino è sulla prima linea + // Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ; + // Point3d ptEnd ; plApprox.GetNextPoint( ptEnd) ; + // Vector3d vtLineCurr = ptEnd - ptStart ; + // double dLenCurr = vtLineCurr.Len() ; + // DistLineLine dllCurr( ptStart, vtLineCurr, dLenCurr, ptL, vtL,dLen) ; + // dllCurr.GetMinDistPoints( ptInt1, ptInt2) ; + // } + // else if ( nClosestLine == nTot- 1) { + // // il punto più vicino è sull'ultima linea + // Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ; + // Point3d ptEnd ; + // for ( int z = 1 ; z < nClosestLine - 1 ; ++z) + // plApprox.GetNextPoint( ptStart) ; + // plApprox.GetNextPoint( ptEnd) ; + // Vector3d vtLinePre = ptEnd - ptStart ; + // double dLenPre = vtLinePre.Len() ; + // DistLineLine dllCurr( ptStart, vtLinePre, dLenPre, ptL, vtL,dLen) ; + // dllCurr.GetMinDistPoints( ptInt1, ptInt2) ; + // } + // + // double dU1 = 0, dV1 = 0, dU2 = 0, dV2 = 0 ; + // // se ho trovato due punti vuol dire che la linea coincide con un edge e ho trovato tutto quello che serve + // if ( ! AreSamePointExact( ptInt2, ORIG)) { + // if ( i == 0) { + // //dV1 = 0 ; dV2 = 0 ; + // vCrvEdge[0]->GetParamAtPoint( ptInt1, dU1) ; + // vCrvEdge[0]->GetParamAtPoint( ptInt2, dU2) ; + // } + // else if ( i == 1) { + // //dU1 = 1 ; dU2 = 1 ; + // vCrvEdge[1]->GetParamAtPoint( ptInt1, dV1) ; + // vCrvEdge[1]->GetParamAtPoint( ptInt2, dV2) ; + // } + // else if ( i == 2){ + // //dV1 = 1 ; dV2 = 1 ; + // vCrvEdge[2]->GetParamAtPoint( ptInt1, dU1) ; + // vCrvEdge[2]->GetParamAtPoint( ptInt2, dU2) ; + // } + // else if ( i == 3){ + // //dU1 = 0 ; dU2 = 0 ; + // vCrvEdge[3]->GetParamAtPoint( ptInt1, dV1) ; + // vCrvEdge[3]->GetParamAtPoint( ptInt2, dV2) ; + // } + // Point3d ptIBez1, ptIBez2 ; + // Vector3d vtN1, vtN2 ; + // pSurfBz->GetPointNrmD1D2(dU1, dV1, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez1, vtN1) ; + // pSurfBz->GetPointNrmD1D2(dU2, dV2, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez2, vtN2) ; + // Point3d ptSP1( dU1, dV1, 0) ; + // double dCos1 = vtN1 * vtL ; + // Point3d ptSP2( dU2, dV2, 0) ; + // double dCos2 = vtN2 * vtL ; + // // se avevo già trovato un punto singolo che coincide col primo punto di questa intersezione sovrapposta, allora cancello l'intersezione singola che + // // avevo salvato e aggiungo quella sovrapposto che ho trovato ora + // if ( bFound) { + // int nNewTot = int(vInfo.size()) ; + // int nNewInters = nNewTot - nInters ; + // bool bAlreadyFound = false ; + // for ( int i = 0 ; i < nNewInters ; ++i) { + // bAlreadyFound = AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP1) || AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP2) ; + // if ( bAlreadyFound) { + // vInfo.erase( vInfo.begin() + nNewTot - i) ; + // break ; + // } + // } + // } + // UpdateInfoIntersLineSurfBz( ptL, vtL, ILTA_NO_TRIA, -1, ptSP1, ptIBez1, dCos1, ptSP2, ptIBez2, dCos2, vInfo) ; + // bFound = true ; + // break ; + // } + // // se ho trovato un punto a distanza zero dalla linea allora ho trovato l'intersezione + // else if ( dMinDist < EPS_SMALL) { + // if ( i == 0) { + // //dV1 = 0 ; + // vCrvEdge[0]->GetParamAtPoint( ptInt1, dU1) ; + // } + // else if ( i == 1) { + // //dU1 = 1 ; + // vCrvEdge[1]->GetParamAtPoint( ptInt1, dV1) ; + // } + // else if ( i == 2) { + // //dV1 = 1 ; + // vCrvEdge[2]->GetParamAtPoint( ptInt1, dU1) ; + // } + // else if ( i == 3) { + // //dU1 = 0 ; + // vCrvEdge[3]->GetParamAtPoint( ptInt1, dV1) ; + // } + // Point3d ptSP1( dU1, dV1, 0), ptSP2 ; + // // se avevo trovato già altri punti controllo di non essere esattamente su una diagonale ( e quindi avere un'intersezione con ogni edge, ma due sono doppie) + // if ( bFound) { + // int nNewTot = int(vInfo.size()) ; + // int nNewInters = nNewTot - nInters ; + // bool bAlreadyFound = false ; + // for ( int i = 0 ; i < nNewInters ; ++i) + // bAlreadyFound = AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP1) ; + // if ( bAlreadyFound) + // continue ; + // } + + // Point3d ptIBez1, ptIBez2 ; + // Vector3d vtN1, vtN2 ; + // pSurfBz->GetPointNrmD1D2(dU1, dV1, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez1, vtN1) ; + // double dCos1 = vtN1 * vtL, dCos2 = 0 ; + // UpdateInfoIntersLineSurfBz( ptL, vtL, ILTA_NO_TRIA, -1, ptSP1, ptIBez1, dCos1, ptSP2, ptIBez2, dCos2, vInfo) ; + // bFound = true ; + // } + // } + //} + + // se la superficie è trimmed verifico che i punti trovati siano all'interno del parametrico trimmato + if ( bTrimmed && bFound) { + int nNewTot = int(vInfo.size()) ; + int nNewInters = nNewTot - nInters ; + const ISurfFlatRegion* pFRTrim = pSurfBz->GetTrimRegion() ; + for ( int i = 0 ; i < nNewInters ; ++i) { + Point3d ptTest = vInfo[nNewTot - i].ptUV * SBZ_TREG_COEFF ; + bool bInside = false ; + double dDist = INFINITO ; + IsPointInsideSurfFr( ptTest, pFRTrim, dDist, bInside) ; + if ( ! bInside) + vInfo.erase( vInfo.begin() + nNewTot - i) ; + } + } + + return true ; +} + +//---------------------------------------------------------------------------- +// Intersezione di una linea con una superficie di Bezier bilineare monopatch //---------------------------------------------------------------------------- bool IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfBezier* pSurfBz, diff --git a/SurfBezier.h b/SurfBezier.h index cdc473a..88a7883 100644 --- a/SurfBezier.h +++ b/SurfBezier.h @@ -148,7 +148,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW bool CreateByPointCurve( const Point3d& pt, const ICurve* pCurve) override ; bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) override ; bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3) override ; - PNTVECTOR GetAllControlPoints( void) const ; + PNTVECTOR GetAllControlPoints( void) const override ; bool GetAllPatchesIsocurves( bool bUorV, ICURVEPOVECTOR& vCrv) const ; bool CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const BIPNTVECTOR& vCrv) ; bool RemoveCollapsedSpans( void) override ;