//---------------------------------------------------------------------------- // EgalTech 2013-2013 //---------------------------------------------------------------------------- // File : CurveAux.cpp Data : 22.11.13 Versione : 1.3a1 // Contenuto : Implementazione di alcune funzioni di utilità per le curve. // // // // Modifiche : 22.11.13 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "CurveAux.h" #include "GeoConst.h" #include "CurveLine.h" #include "CurveArc.h" #include "CurveBezier.h" #include "CurveComposite.h" #include "Voronoi.h" #include "/EgtDev/Include/EGkDistPointCurve.h" #include "/EgtDev/Include/EGkStringUtils3d.h" #include "/EgtDev/Include/EGkUiUnits.h" #include "/EgtDev/Include/EgtPointerOwner.h" using namespace std ; //---------------------------------------------------------------------------- bool IsClosed( const ICurve& crvC) { Point3d ptStart, ptEnd ; return ( crvC.GetStartPoint( ptStart) && crvC.GetEndPoint( ptEnd) && AreSamePointApprox( ptStart, ptEnd)) ; } //---------------------------------------------------------------------------- bool IsValidParam( const ICurve& crvC, double dPar, ICurve::Side nSide) { // recupero l'intervallo di validità del parametro double dStart, dEnd ; if ( ! crvC.GetDomain( dStart, dEnd)) return false ; // il parametro deve stare nei limiti if ( dPar < dStart - EPS_PARAM || dPar > dEnd + EPS_PARAM) return false ; // se curva chiusa non sono necessari altri controlli if ( crvC.IsClosed()) return true ; // per curve aperte non posso studiare la curva prima dell'inizio e dopo la fine if ( ( dPar < dStart + EPS_PARAM && nSide == ICurve::FROM_MINUS) || ( dPar > dEnd - EPS_PARAM && nSide == ICurve::FROM_PLUS)) return false ; return true ; } //---------------------------------------------------------------------------- bool IsStartParam( const ICurve& crvC, double dPar) { // recupero l'intervallo di validità del parametro double dStart, dEnd ; if ( ! crvC.GetDomain( dStart, dEnd)) return false ; // se il parametro non è nell'intorno dell'inizio if ( abs( dPar - dStart) > EPS_PARAM) return false ; return true ; } //---------------------------------------------------------------------------- bool IsEndParam( const ICurve& crvC, double dPar) { // recupero l'intervallo di validità del parametro double dStart, dEnd ; if ( ! crvC.GetDomain( dStart, dEnd)) return false ; // se il parametro non è nell'intorno della fine if ( abs( dPar - dEnd) > EPS_PARAM) return false ; return true ; } //---------------------------------------------------------------------------- bool GetNearestExtremityToPoint( const Point3d& ptP, const ICurve& Curve, bool& bStart) { // recupero punto iniziale Point3d ptStart ; if ( ! Curve.GetStartPoint( ptStart)) return false ; // recupero punto finale Point3d ptEnd ; if ( ! Curve.GetEndPoint( ptEnd)) return false ; // se curva aperta if ( ! AreSamePointApprox( ptStart, ptEnd)) { // è il più vicino tra inizio e fine bStart = ( SqDist( ptP, ptStart) <= SqDist( ptP, ptEnd)) ; return true ; } // altrimenti curva chiusa, devo proiettare il punto sulla curva e misurare la distanza su di essa DistPointCurve distPC( ptP, Curve) ; int nFlag ; double dLen, dU, dULen ; if ( Curve.GetLength( dLen) && distPC.GetParamAtMinDistPoint( 0, dU, nFlag) && Curve.GetLengthAtParam( dU, dULen)) { bStart = ( dULen <= ( dLen - dULen)) ; return true ; } else return false ; } //---------------------------------------------------------------------------- bool MoveParamToAvoidTg( double& dU, ICurve::Side nSide, const ICurve& Curve) { // verifico che il parametro sia accettabile if ( ! Curve.IsValidParam( dU, nSide)) return false ; // determino un incremento piccolo ma valido del parametro U double dDeltaU = 1000 * EPS_PARAM ; Point3d ptPos ; Vector3d vtDer1 ; if ( Curve.GetPointD1D2( dU, nSide, ptPos, &vtDer1)) { double dDer1 = vtDer1.LenXY() ; if ( dDer1 > EPS_ZERO) dDeltaU = 2 * EPS_SMALL / dDer1 ; } // cerco di spostarmi per evitare eventuali problemi di tangenza if ( nSide == ICurve::FROM_MINUS) { double dUm = dU - dDeltaU ; if ( ! Curve.IsValidParam( dUm, nSide)) { if ( Curve.IsClosed()) { double dStart, dEnd ; Curve.GetDomain( dStart, dEnd) ; dUm = ( dEnd - dStart) - dDeltaU ; } else dUm = dU ; } dU = dUm ; return true ; } else { // nSide == ICurve::FROM_PLUS double dUm = dU + dDeltaU ; if ( ! Curve.IsValidParam( dUm, nSide)) { if ( Curve.IsClosed()) { double dStart, dEnd ; Curve.GetDomain( dStart, dEnd) ; dUm = dStart + dDeltaU ; } else dUm = dU ; } dU = dUm ; return true ; } } //---------------------------------------------------------------------------- bool GetTang( const ICurve& crvC, double dU, ICurve::Side nS, Vector3d& vtTang) { Point3d ptPos ; return GetPointTang( crvC, dU, nS, ptPos, vtTang) ; } //---------------------------------------------------------------------------- bool GetPointTang( const ICurve& crvC, double dU, ICurve::Side nS, Point3d& ptPos, Vector3d& vtTang) { if ( ! crvC.GetPointD1D2( dU, nS, ptPos, &vtTang)) return false ; if ( vtTang.Normalize( EPS_ZERO)) return true ; // nel caso la derivata prima sia nulla, utilizziamo la seconda Vector3d vtDummy ; if ( ! crvC.GetPointD1D2( dU, nS, ptPos, &vtDummy, &vtTang)) return false ; double dUmod = dU + ( nS == ICurve::FROM_MINUS ? -1 : +1) * 100 * EPS_PARAM ; Point3d ptDummy ; // se anche la derivata seconda è nulla, provo a spostarmi di poco if ( ! vtTang.Normalize( EPS_ZERO)) { if ( ! crvC.GetPointD1D2( dUmod, nS, ptDummy, &vtDummy, &vtTang)) return false ; if ( ! vtTang.Normalize( EPS_ZERO)) return false ; } // per il verso, lo confrontiamo con quello della derivata prima un poco discosta Vector3d vtD1near ; if ( ! crvC.GetPointD1D2( dUmod, nS, ptDummy, &vtD1near)) return false ; if ( ( vtTang * vtD1near) < 0) vtTang.Invert() ; return true ; } //---------------------------------------------------------------------------- bool GetPointDiffGeom( const ICurve& crvC, double dU, ICurve::Side nS, CrvPointDiffGeom& oDiffG) { // calcolo punto e derivate Point3d ptPos ; Vector3d vtDer1, vtDer2 ; if ( ! crvC.GetPointD1D2( dU, nS, ptPos, &vtDer1, &vtDer2)) return false ; // assegno parametro e posizione oDiffG.dU = dU ; oDiffG.ptP = ptPos ; // se esiste la derivata prima non nulla double dSqLenD1 = vtDer1.SqLen() ; if ( vtDer1.Normalize()) { oDiffG.vtT = vtDer1 ; // del vettore deriv2^ tengo la sola componente perpendicolare al vettore tangente oDiffG.vtN = vtDer2 - ( vtDer2 * vtDer1) * vtDer1 ; if ( oDiffG.vtN.Normalize()) { oDiffG.dCurv = ( vtDer1 ^ vtDer2).Len() / dSqLenD1 ; oDiffG.nStatus = CrvPointDiffGeom::NCRV ; } else { oDiffG.dCurv = 0 ; oDiffG.nStatus = CrvPointDiffGeom::TANG ; } } // se esiste almeno derivata seconda non nulla, definisce la tangente else if ( vtDer2.Normalize()) { oDiffG.vtT = vtDer2 ; oDiffG.vtN.Set( 0, 0, 0) ; oDiffG.dCurv = 0 ; // per il verso, lo confrontiamo con quello della derivata prima un poco discosta Point3d ptDummy ; Vector3d vtD1near ; dU += ( nS == ICurve::FROM_MINUS ? -1 : +1) * 100 * EPS_PARAM ; if ( crvC.GetPointD1D2( dU, nS, ptDummy, &vtD1near)) { if ( ( oDiffG.vtT * vtD1near) < 0) oDiffG.vtT.Invert() ; oDiffG.nStatus = CrvPointDiffGeom::TANG ; } else { oDiffG.vtT.Set( 0, 0, 0) ; oDiffG.nStatus = CrvPointDiffGeom::POS ; } } // altrimenti non sono definite la tangente e la normale else { oDiffG.vtT.Set( 0, 0, 0) ; oDiffG.vtN.Set( 0, 0, 0) ; oDiffG.dCurv = 0 ; oDiffG.nStatus = CrvPointDiffGeom::POS ; } return true ; } //---------------------------------------------------------------------------- bool ImproveCurveParamAtPoint( double& dU, const Point3d& ptP, const ICurve* pCrv) { // Da usare quando il parametro è già molto vicino a quello esatto // calcolo il punto della curva in corrispondenza al parametro Point3d ptQ ; Vector3d vtD ; if ( ! pCrv->GetPointD1D2( dU, ICurve::FROM_MINUS, ptQ, &vtD)) return false ; // se sono uguali, è già tutto ok if ( AreSamePointExact( ptP, ptQ)) return true ; // se derivata nulla, non posso migliorare if ( vtD.IsZero()) return false ; // incremento parametro su linea tangente (uso la derivata) double dDeltaU = ( ptP - ptQ) * vtD / vtD.SqLen() ; // se migliorato, tengo nuovo valore Point3d ptR ; if ( pCrv->GetPointD1D2( dU + dDeltaU, ICurve::FROM_MINUS, ptR) && ( ptP - ptR).SqLen() < ( ptP - ptQ).SqLen()) dU += dDeltaU ; return true ; } //---------------------------------------------------------------------------- bool CurveGetAreaXY( const ICurve& crvC, double& dArea) { // verifico sia chiusa if ( ! crvC.IsClosed()) return false ; // approssimo la curva con una polilinea PolyLine PL ; crvC.ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL_INT, PL) ; // calcolo l'area double dAreaXY = 0 ; PL.GetAreaXY( dAreaXY) ; // restituisco il valore if ( &dArea != nullptr) dArea = dAreaXY ; return true ; } //---------------------------------------------------------------------------- bool CurveGetArea( const ICurve& crvC, Plane3d& plPlane, double& dArea) { // verifico sia chiusa if ( ! crvC.IsClosed()) return false ; // approssimo la curva con una polilinea PolyLine PL ; crvC.ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL_INT, PL) ; // calcolo l'area Plane3d plMyPlane ; double dMyArea = 0 ; if ( ! PL.IsClosedAndFlat( plMyPlane, dMyArea, 50 * EPS_SMALL)) return false ; // restituisco i valori if ( &plPlane != nullptr) plPlane = plMyPlane ; if ( &dArea != nullptr) dArea = dMyArea ; return true ; } //---------------------------------------------------------------------------- bool CurveDump( const ICurve& crvC, string& sOut, bool bMM, const char* szNewLine) { // verifico validità curva if ( ! crvC.IsValid()) return false ; // punti iniziale e finale Point3d ptPS ; crvC.GetStartPoint( ptPS) ; sOut += "PS(" + ToString( GetInUiUnits( ptPS, bMM), 3) + ")" + szNewLine ; Point3d ptPE ; crvC.GetEndPoint( ptPE) ; sOut += "PE(" + ToString( GetInUiUnits( ptPE, bMM), 3) + ")" + szNewLine ; // direzioni iniziale e finale Vector3d vtDirS ; crvC.GetStartDir( vtDirS) ; sOut += "VS(" + ToString( vtDirS, 3) + ")" + szNewLine ; Vector3d vtDirE ; crvC.GetEndDir( vtDirE) ; sOut += "VE(" + ToString( vtDirE, 3) + ")" + szNewLine ; // eventuali direzione di estrusione e spessore Vector3d vtExtr ; crvC.GetExtrusion( vtExtr) ; if ( ! vtExtr.IsSmall()) { double dThick ; crvC.GetThickness( dThick) ; sOut += "Extr(" + ToString( vtExtr, 3) + ") Th=" + ToString( GetInUiUnits( dThick, bMM), 3) + szNewLine ; } // lunghezza double dLen = 0 ; crvC.GetLength( dLen) ; sOut += "Len=" + ToString( GetInUiUnits( dLen, bMM), 3) + szNewLine ; // altri dati per curva chiusa double dAreaXY ; if ( CurveGetAreaXY( crvC, dAreaXY)) { bool bCCW = ( dAreaXY > 0) ; double dAreaUi = GetAreaInUiUnits( abs( dAreaXY), bMM) ; int nDec = ( dAreaUi > 100 ? 1 : ( dAreaUi > 0.1 ? 3 : 6)) ; sOut += string( "Closed") + ( bCCW ? " CCW" : " CW") + " AreaXY=" + ToString( dAreaUi, nDec) + szNewLine ; } return true ; } //---------------------------------------------------------------------------- bool CopyExtrusion( const ICurve* pSouCrv, ICurve* pDestCrv) { // verifico puntatori if ( pSouCrv == nullptr || pDestCrv == nullptr) return false ; // eseguo copia Vector3d vtExtr ; pSouCrv->GetExtrusion( vtExtr) ; pDestCrv->SetExtrusion( vtExtr) ; return true ; } //---------------------------------------------------------------------------- bool CopyThickness( const ICurve* pSouCrv, ICurve* pDestCrv) { // verifico puntatori if ( pSouCrv == nullptr || pDestCrv == nullptr) return false ; // eseguo copia double dThick = 0 ; pSouCrv->GetThickness( dThick) ; pDestCrv->SetThickness( dThick) ; return true ; } //---------------------------------------------------------------------------- ICurveBezier* LineToBezierCurve( const ICurveLine* pCrvLine) { PtrOwner pCrvBezier( CreateCurveBezier()) ; // rendo tutte le curve di grado 2 e razionali così posso convertire anche archi e avere tutte curve dello stesso grado e razionali pCrvBezier->Init( 2, true) ; pCrvBezier->FromLine( *pCrvLine) ; return Release( pCrvBezier) ; } //---------------------------------------------------------------------------- ICurve* ArcToBezierCurve( const ICurve* pCrv, bool bDeg3OrDeg2) { // verifico sia un arco const CurveArc* pArc = GetBasicCurveArc( pCrv) ; if ( pArc == nullptr) return nullptr ; // se angolo al centro sotto il limite, basta una curva if ( ( abs( pArc->GetAngCenter()) < BEZARC_ANG_CEN_MAX + EPS_ANG_SMALL && abs( pArc->GetDeltaN()) < EPS_ZERO && ! bDeg3OrDeg2) || ( abs( pArc->GetAngCenter()) < BEZARC_ANG_CEN_MAX + EPS_ANG_SMALL && bDeg3OrDeg2)) { // creo la curva di Bezier equivalente all'arco PtrOwner pCrvBez( CreateBasicCurveBezier()) ; if ( IsNull( pCrvBez) || ! pCrvBez->FromArc( *pArc)) return nullptr ; // restituisco la curva return Release( pCrvBez) ; } // altrimenti curva composita di Bezier else { // creo la curva composita PtrOwner pCrvCompo( CreateBasicCurveComposite()) ; if ( IsNull( pCrvCompo)) return nullptr ; // inserisco nella CC le curve di Bezier equivalenti alle parti dell'arco int nParts = (int) ceil( abs( pArc->GetAngCenter()) / ( BEZARC_ANG_CEN_MAX + EPS_ANG_SMALL)) ; if ( ! bDeg3OrDeg2 && abs( pArc->GetDeltaN()) > EPS_ZERO) nParts *= 2 ; nParts = max( nParts, 2) ; for ( int i = 0 ; i < nParts ; ++ i) { // copio l'arco originale CurveArc cArc = *pArc ; // lo limito alla parte di interesse cArc.TrimStartEndAtParam( i / double( nParts), ( i + 1) / double( nParts)) ; // creo la curva di Bezier equivalente PtrOwner pCrvBez( CreateBasicCurveBezier()) ; if ( IsNull( pCrvBez) || ! pCrvBez->FromArc( cArc)) return nullptr ; // aggiungo la curva di Bezier a quella composita if ( ! pCrvCompo->AddCurve( Release( pCrvBez))) return nullptr ; } // copio estrusione e spessore CopyExtrusion( pArc, pCrvCompo) ; CopyThickness( pArc, pCrvCompo) ; // restituisco la curva return Release( pCrvCompo) ; } } //---------------------------------------------------------------------------- ICurve* CompositeToBezierCurve( const ICurveComposite* pCC) { // converto tutte le curve in bezier razionali di grado 2 PtrOwner pCCBezier( CreateCurveComposite()) ; for ( int i = 0 ; i < int( pCC->GetCurveCount()) ; ++i) { PtrOwner pCrvNew ; if ( pCC->GetCurve(i)->GetType() == CRV_ARC) { const CurveArc* crArc = GetBasicCurveArc( pCC->GetCurve(i)) ; ICurve* pCrvBezier = ArcToBezierCurve( crArc) ; if ( pCrvBezier == nullptr) return nullptr ; // se la curva è di grado superiore al secondo allora devo ricondurla al secondo grado pCrvNew.Set( pCrvBezier) ; } else if ( pCC->GetCurve(i)->GetType() == CRV_LINE) { const CurveLine* crLine = GetBasicCurveLine( pCC->GetCurve(i)) ; ICurve* pCrvBezier = LineToBezierCurve( crLine) ; if ( pCrvBezier == nullptr) return nullptr ; pCrvNew.Set( pCrvBezier) ; } else if ( pCC->GetCurve(i)->GetType() == CRV_BEZIER ) { const CurveBezier* crvBezier = GetBasicCurveBezier( pCC->GetCurve(i)) ; ICurve* pCrvBezier = BezierToBasicBezierCurve( crvBezier) ; if ( pCrvBezier == nullptr) return nullptr ; pCrvNew.Set( pCrvBezier) ; } pCCBezier->AddCurve( Release( pCrvNew)) ; } return Release( pCCBezier) ; } //---------------------------------------------------------------------------- ICurve* BezierToBasicBezierCurve( const ICurveBezier* pCrvBezier) { // resta da calcolare un errore sull'approssimazione oppure usare la tecnica di spezzare la curva originale in sottocurve e approssimarle con bezier cubiche // per ridurre molto l'errore // dovrei restituire una bezier di grado 2, razionale per poter essere uniforme con le altre curve trasmorate in bezier PtrOwner pCrvNew( pCrvBezier->Clone()) ; int nDeg = pCrvBezier->GetDegree() ; bool bRat = pCrvBezier->IsRational() ; // se la curva è già nella forma giusta la restituisco if ( nDeg == 2 && bRat) return Release( pCrvNew) ; // sennò la riduco di grado fino al 2 PtrOwner pBasicBezier ( CreateCurveBezier()) ; pBasicBezier->Init( 2, true) ; double dW = 1 ; if ( nDeg == 1) { Point3d ptStart = pCrvBezier->GetControlPoint( 0) ; Point3d ptEnd = pCrvBezier->GetControlPoint( 1) ; pBasicBezier->SetControlPoint( 0, ptStart, dW) ; pBasicBezier->SetControlPoint( 1, 0.5 * (ptStart + ptEnd), dW) ; pBasicBezier->SetControlPoint( 2, ptEnd, dW) ; return Release( pBasicBezier) ; } while ( nDeg > 2 ) { pCrvNew.Set( BezierDecreaseDegree( pCrvNew, 1)) ; if ( IsNull( pCrvNew) || ! pCrvNew->IsValid()) return nullptr ; -- nDeg ; } for ( int i = 0 ; i < 3 ; ++i) { Point3d ptCopy = pCrvNew->GetControlPoint( i) ; if ( bRat) dW = pCrvNew->GetControlWeight( i) ; pBasicBezier->SetControlPoint( i, ptCopy, dW) ; } return Release( pBasicBezier) ; } ICurveBezier* BezierIncreaseDegree(const ICurveBezier* pCrvBezier) { if ( pCrvBezier == nullptr) return nullptr ; // creo la versione con grado aumentato PtrOwner pNewBezier( CreateCurveBezier()) ; int nDeg = pCrvBezier->GetDegree() + 1; bool bRat = pCrvBezier->IsRational(); pNewBezier->Init( nDeg , bRat) ; // prev e curr sono riferiti alla curva di partenza // salvo il primo punto Point3d ptCtrlPrev = pCrvBezier->GetControlPoint( 0) ; double dWprev = 1 ; if ( bRat ) { dWprev = pCrvBezier->GetControlWeight( 0) ; pNewBezier->SetControlPoint( 0, ptCtrlPrev, dWprev) ; } else pNewBezier->SetControlPoint( 0, ptCtrlPrev) ; // ciclo sui punti di controllo intermedi per calcolare quelli nuovi Point3d ptCtrlCurr ; double dWcurr ; for ( double i = 1 ; i < nDeg ; ++i) { ptCtrlCurr = pCrvBezier->GetControlPoint( int( i)) ; Point3d ptNew = ( i / nDeg) * ptCtrlPrev + ( 1 - i / ( nDeg)) * ptCtrlCurr ; if ( bRat) { dWcurr = pCrvBezier->GetControlWeight( int( i)) ; double dWnew = ( i / nDeg) * dWprev + ( 1 - i / ( nDeg)) * dWcurr ; pNewBezier->SetControlPoint( int( i), ptNew, dWnew) ; dWprev = dWnew ; } else pNewBezier->SetControlPoint( int( i), ptNew) ; ptCtrlPrev = ptCtrlCurr ; } // salvo l'ultimo punto ptCtrlCurr = pCrvBezier->GetControlPoint( nDeg - 1) ; if ( bRat ) { dWcurr = pCrvBezier->GetControlWeight( nDeg - 1) ; pNewBezier->SetControlPoint( nDeg, ptCtrlCurr, dWcurr) ; } else pNewBezier->SetControlPoint( nDeg, ptCtrlCurr) ; return Release( pNewBezier) ; } ICurveBezier* BezierDecreaseDegree(const ICurveBezier* pCrvBezier, double dTol) { if ( pCrvBezier == nullptr) return nullptr ; PtrOwner pNewBezier( CreateCurveBezier()) ; int nDeg = pCrvBezier->GetDegree() - 1 ; if ( nDeg == 0) return nullptr ; bool bRat = pCrvBezier->IsRational() ; pNewBezier->Init( nDeg, bRat) ; // prev e curr sono riferiti alla nuova curva //salvo il primo punto Point3d ptCtrlPrev = pCrvBezier->GetControlPoint( 0) ; double dWprev = 1 ; if ( bRat ) { dWprev = pCrvBezier->GetControlWeight( 0) ; pNewBezier->SetControlPoint( 0, ptCtrlPrev, dWprev) ; } else pNewBezier->SetControlPoint( 0, ptCtrlPrev) ; // ciclo sui punti intermedi per trovare i nuovi punti di controllo // equazioni da NURBS book Point3d ptCtrlCurr ; double dWcurr ; int r = int (nDeg / 2) ; // prima metà for ( double i = 1 ; i < r ; ++i) { double dAlpha = i / ( nDeg + 1) ; // old è riferito alla curva originale Point3d ptOld = pCrvBezier->GetControlPoint( int( i)) ; ptCtrlCurr = ( ptOld + (- dAlpha * ptCtrlPrev)) / ( 1 - dAlpha) ; if ( bRat) { double dWold = pCrvBezier->GetControlWeight( int( i)) ; dWcurr = ( dWold + (- dAlpha * dWprev)) / ( 1 - dAlpha) ; pNewBezier->SetControlPoint( int( i), ptCtrlCurr, dWcurr) ; dWprev = dWcurr ; } else pNewBezier->SetControlPoint( int( i), ptCtrlCurr) ; ptCtrlPrev = ptCtrlCurr ; } // risolvo il punto di mezzo per il caso nDeg pari if ( ( nDeg + 1) % 2 == 0) { // pari double dAlpha = r / ( nDeg + 1.) ; Point3d ptOld = pCrvBezier->GetControlPoint( r) ; ptCtrlCurr = ( ptOld + (- dAlpha * ptCtrlPrev)) / ( 1 - dAlpha) ; if ( bRat) { double dWold = pCrvBezier->GetControlWeight( r) ; dWcurr = ( dWold + (- dAlpha * dWprev)) / ( 1 - dAlpha) ; pNewBezier->SetControlPoint( r, ptCtrlCurr, dWcurr) ; dWprev = dWcurr ; } else pNewBezier->SetControlPoint( r, ptCtrlCurr) ; } // salvo l'ultimo punto ptCtrlCurr = pCrvBezier->GetControlPoint( nDeg + 1) ; if ( bRat ) { dWcurr = pCrvBezier->GetControlWeight( nDeg + 1) ; pNewBezier->SetControlPoint( nDeg, ptCtrlCurr, dWcurr) ; } else pNewBezier->SetControlPoint( nDeg, ptCtrlCurr) ; ptCtrlPrev = ptCtrlCurr ; if ( bRat) dWprev = dWcurr ; // seconda metà for ( double i = nDeg - 1 ; i > r ; --i) { double dAlpha = ( i + 1) / ( nDeg + 1) ; Point3d ptOld = pCrvBezier->GetControlPoint( int( i) + 1) ; ptCtrlCurr = ( ptOld + ( - ( 1 - dAlpha) * ptCtrlPrev)) / dAlpha ; if ( bRat) { double dWold = pCrvBezier->GetControlWeight( int( i) + 1) ; dWcurr = ( dWold - ( ( 1 - dAlpha) * dWprev)) / dAlpha ; pNewBezier->SetControlPoint( int( i), ptCtrlCurr, dWcurr) ; dWprev = dWcurr ; } else pNewBezier->SetControlPoint( int( i), ptCtrlCurr) ; ptCtrlPrev = ptCtrlCurr ; } // risolvo il punto di mezzo per il caso nDeg dispari // calcolo anche l'errore di approssimazione double dErr = 0 ; if ( (nDeg + 1) % 2 != 0) { // dispari // puntdo di sinistra double dAlpha = r / ( nDeg + 1.) ; ptCtrlPrev = pNewBezier->GetControlPoint( r - 1) ; Point3d ptOld = pCrvBezier->GetControlPoint( r) ; Point3d ptL = ( ptOld + ( - dAlpha * ptCtrlPrev)) / ( 1 - dAlpha) ; double dWL = 1 ; if ( bRat) { dWprev = pNewBezier->GetControlWeight( r - 1) ; double dWold =pCrvBezier->GetControlWeight( r) ; dWL = ( dWold - ( dAlpha * dWprev)) / ( 1 - dAlpha) ; } // punto di destra dAlpha = ( r + 1.) / ( nDeg + 1.) ; ptCtrlPrev = pNewBezier->GetControlPoint( r + 1) ; ptOld = pCrvBezier->GetControlPoint( r + 1) ; double dWR = 1 ; if ( bRat) { dWprev = pNewBezier->GetControlWeight( r + 1) ; double dWold =pCrvBezier->GetControlWeight( r + 1) ; dWR = ( dWold - ( ( 1 - dAlpha) * dWprev)) / dAlpha ; } Point3d ptR = ( ptOld + ( - ( 1 - dAlpha) * ptCtrlPrev)) / dAlpha ; // calcolo il punto di mezzo e lo aggiungo Point3d ptNew = ( ptL + ptR) / 2 ; double dWnew = ( dWL + dWR) / 2 ; if ( bRat) pNewBezier->SetControlPoint( r, ptNew, dWnew) ; else pNewBezier->SetControlPoint( r, ptNew) ; dErr = Dist( ptL, ptR) ; } else { ptCtrlCurr = pNewBezier->GetControlPoint( r + 1) ; ptCtrlPrev = pNewBezier->GetControlPoint( r) ; Point3d ptOld = pCrvBezier->GetControlPoint( r + 1) ; dErr = Dist( ptOld, 0.5 * ( ptCtrlPrev + ptCtrlCurr)) ; } //// se l'approssimazione dà un errore troppo alto allora annullo tutto // da controllare //if ( dErr > dTol) // return nullptr ; return Release( pNewBezier) ; } //---------------------------------------------------------------------------- ICurve* CurveToNoArcsCurve( const ICurve* pCrv) { // verifico validità curva if ( pCrv == nullptr) return nullptr ; // se arco, devo trasformarlo in curva di Bezier (semplice o composta) if ( pCrv->GetType() == CRV_ARC) { return ArcToBezierCurve( pCrv) ; } // se curva composita, devo trasformarla in composita senza archi else if ( pCrv->GetType() == CRV_COMPO) { PtrOwner pCopyCC( GetBasicCurveComposite( pCrv->Clone())) ; if ( IsNull( pCopyCC) || ! pCopyCC->ArcsToBezierCurves()) return nullptr ; return Release( pCopyCC) ; } // altrimenti devo solo copiarla else { return pCrv->Clone() ; } } //---------------------------------------------------------------------------- ICurve* CurveToArcsPerpExtrCurve( const ICurve* pCrv, double dLinTol, double dAngTolDeg) { // verifico validità curva if ( pCrv == nullptr) return nullptr ; // se arco in piano non perpendicolare ad estrusione, curva composita o curva di Bezier trasformo if ( ( pCrv->GetType() == CRV_ARC && ! GetBasicCurveArc(pCrv)->IsInPlanePerpExtr()) || pCrv->GetType() == CRV_COMPO || pCrv->GetType() == CRV_BEZIER) { // creo un poliarco PolyArc PA ; if ( ! pCrv->ApproxWithArcs( dLinTol, dAngTolDeg, PA)) return nullptr ; // creo una nuova curva composita a partire dal poliarco PtrOwner pCopyCC( CreateBasicCurveComposite()) ; if ( IsNull( pCopyCC)) return nullptr ; if ( ! pCopyCC->FromPolyArc( PA)) return nullptr ; // copio estrusione e spessore CopyExtrusion( pCrv, pCopyCC) ; CopyThickness( pCrv, pCopyCC) ; return Release( pCopyCC) ; } // altrimenti devo solo copiarla else { return pCrv->Clone() ; } } //---------------------------------------------------------------------------- bool NurbsCurveCanonicalize( CNurbsData& cnData) { // se con nodi extra if ( cnData.bExtraKnotes) { int nKnotesNbr = int( cnData.vU.size()) ; if ( nKnotesNbr < 4) return false ; cnData.bExtraKnotes = false ; for ( int i = 0 ; i < nKnotesNbr - 2 ; ++ i) cnData.vU[i] = cnData.vU[i+1] ; cnData.vU.resize( nKnotesNbr - 2) ; } // se periodica if ( cnData.bPeriodic || ! cnData.bClamped) { // se la curva è peridica verifco che effettivamente ci sia un numero di punti ripetituti uguale al grado della curva // wrap della curva su se stessa if ( cnData.bPeriodic ) { bool bRepetead = true ; for ( int i = 0 ; i < cnData.nDeg ; ++i) { if ( ! AreSamePointApprox( cnData.vCP[i], cnData.vCP.end()[-cnData.nDeg + i]) ) { bRepetead = false ; break ; } } if ( ! bRepetead){ // salvo il vettore dei nodi in caso mi accorga di avere tra le mani una curva unclamped DBLVECTOR vU = cnData.vU ; // se il primo e l'ultimo punto non coincidono allora aggiungo il primo punto in fondo al vettore dei punti di controllo if ( ! AreSamePointApprox( cnData.vCP[0], cnData.vCP.back()) ) { cnData.vCP.push_back( cnData.vCP[0]) ; if ( cnData.bRat) cnData.vW.push_back( cnData.vW[0]) ; } // se effettivamente ho dei nodi in più da togliere allora li tolgo if ( int( cnData.vU.size()) != int(cnData.vCP.size()) + cnData.nDeg - 1) { // devo poi anche togliere i nodi di troppo // presuppongo che la convenzione sia che i nodi di troppo sono alla fine del vettore dei nodi cnData.vU = DBLVECTOR( cnData.vU.begin(), cnData.vU.end() - cnData.nDeg) ; // controllo eventualmente anche i nodi extra // se ne ho due in più ne tolgo uno in cima e uno in fondo if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg + 1 ) // significa che ci sono due nodi extra, uno all'inizio e uno alla fine, da togliere cnData.vU = vector( cnData.vU.begin() + 1, cnData.vU.end() - 1) ; // se ne ho solo uno in più lo tolgo in cima else if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg) cnData.vU = vector( cnData.vU.begin() + 1, cnData.vU.end()) ; } // controllo se il vettore dei nodi ha la giusta molteplicità all'inizio e alla fine, sennò ha comunque bisogno di essere resa non periodica double dU0 = cnData.vU[0] ; double dULast = cnData.vU.back() ; bool bSame = true ; for ( int i = 1 ; i < cnData.nDeg ; ++i ) { bSame = bSame && abs(cnData.vU[i] - dU0) < EPS_SMALL ; bSame = bSame && abs(cnData.vU.end()[-( i+ 1)] - dULast) < EPS_SMALL ; } if ( bSame) { cnData.bPeriodic = false ; return true ; } else { // aggiungo i punti ripetuti ( il primo l'ho già aggiunto) for ( int i = 1 ; i < cnData.nDeg ; ++i ) { cnData.vCP.push_back( cnData.vCP[i]) ; if ( cnData.bRat) cnData.vW.push_back( cnData.vW[i]) ; } // recupero il vettore dei nodi cnData.vU = vU ; // verifico se ho nodi extra // se ne ho due in più ne tolgo uno in cima e uno in fondo if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg + 1 ) // significa che ci sono due nodi extra, uno all'inizio e uno alla fine, da togliere cnData.vU = vector( cnData.vU.begin() + 1, cnData.vU.end() - 1) ; // se ne ho solo uno in più lo tolgo in cima else if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg) cnData.vU = vector( cnData.vU.begin() + 1, cnData.vU.end()) ; } } } // qui aggiungo un controllo se la curva è collassata in un punto ( ho un polo), lascio stare bool bCollapsed = true ; Point3d ptFirst = cnData.vCP.front() ; for( int i = 1 ; i < int( cnData.vCP.size()) ; ++i) { if ( ! AreSamePointApprox( ptFirst, cnData.vCP[i])) { bCollapsed = false ; break ; } } if ( bCollapsed) return false ; // va trasformata in non-periodica (clamped) // bisogna aumentare la molteplicità dei nodi u_p-1 e u_(m-p+1) fino ad arrivare al grado della nurbs // e poi scartare nodi e punti fuori dalla regione clamped ( al di fuori della regione u_p-1 -> u_(m-p+1)) // l'agoritmo per l'inserimento dei nodi l' A5.1 del libro delle Nurbs ( Piegl e Tiller), con qualche modifica // agli indici perché uso u_p-1 e u_(m-p+1), anziché u_p e u_m-p // comincio ad aumentare la molteplictià del nodo u_m-p+1 int nCP = int( cnData.vCP.size()) ; int nU = nCP + cnData.nDeg - 1 ; int nDeg = cnData.nDeg ; PNTVECTOR vBC ; vBC.resize( nDeg + 1) ; DBLVECTOR vBW ; vBW.resize( nDeg + 1) ; // trovo il nodo di cui aumentare la molteplicità e ne calcolo la molteplicità int b = nU - nDeg - 1 + 1 ; int i = b ; while ( b > 0 && abs( cnData.vU[b] - cnData.vU[b - 1]) < EPS_ZERO) -- b ; int mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < nDeg // recupero i punti da modificare if ( ! cnData.bRat) { for ( int i = 0 ; i <= nDeg - mult ; ++ i) vBC[i] = cnData.vCP[b - nDeg + 1 + i] ; } else { for ( int i = 0 ; i <= nDeg - mult ; ++ i) { vBC[i] = cnData.vCP[b - nDeg + 1 + i] * cnData.vW[b - nDeg + 1 + i] ; vBW[i] = cnData.vW[b - nDeg + 1 + i] ; } } // salvo i punti inalterati int r = nDeg - mult ; // numero di volte che dovrò inserire il nodo cnData.vCP.resize( nCP + r) ; for ( int p = nCP - 1 ; p > b - mult ; --p) { cnData.vCP[r + p] = cnData.vCP[p] ; } if ( cnData.bRat ) { cnData.vW.resize( nCP + r) ; for ( int p = nCP - 1 ; p > b - mult ; --p) { cnData.vW[r + p] = cnData.vW[p] ; } } // procedo all'inserimento int L = 0 ; double alpha ; if ( mult < nDeg) { // inserisco il nodo r volte for ( int j = 1 ; j <= r ; ++ j) { L = b - nDeg + j ; for ( int i = 0; i <= r - j ; ++i) { alpha = (cnData.vU[b] - cnData.vU[L + i])/ ( cnData.vU[i + b + 1] - cnData.vU[L + i]) ; vBC[i] = alpha * vBC[i +1 ] + ( 1 - alpha) * vBC[i] ; if ( cnData.bRat) { vBW[i] = alpha * vBW[i + 1] + ( 1 - alpha) * vBW[i] ; } } cnData.vCP[L + 1] = vBC[0] ; cnData.vCP[b + nDeg - j - mult] = vBC[r - j] ; if ( cnData.bRat ) { cnData.vW[L + 1] = vBW[0] ; cnData.vW[b + nDeg - j - mult] = vBW[r-j] ; } } } // allungo il vettore dei nodi e sposto gli ultimi nodi cnData.vU.resize( nU + r) ; for ( int p = nU - 1 ; p > b ; --p) cnData.vU[p + r] = cnData.vU[p] ; // aggiungo i nodi nuovi for ( int p = 0 ; p < r ; ++p) cnData.vU[b + 1 + p] = cnData.vU[b] ; nU = nU + r ; nCP = nCP + r ; // aumento la molteplicità del punto u_p-1 b = nDeg - 1 ; i = b ; while ( b > 0 && abs( cnData.vU[b] - cnData.vU[b - 1]) < EPS_ZERO) -- b ; mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < cnData.nDeg // recupero i punti da modificare if ( ! cnData.bRat) { for ( int i = 0 ; i <= nDeg - mult ; ++ i) vBC[i] = cnData.vCP[i] ; } else { for ( int i = 0 ; i <= nDeg - mult ; ++ i) { vBC[i] = cnData.vCP[i] * cnData.vW[i] ; vBW[i] = cnData.vW[i] ; } } r = nDeg - mult ; // salvo i punti inalterati cnData.vCP.resize( nCP + r) ; for ( int p = nCP - 1 ; p > b - mult ; --p) { cnData.vCP[r + p] = cnData.vCP[p] ; } if ( cnData.bRat ) { cnData.vW.resize( nCP + r) ; for ( int p = nCP - 1 ; p > b - mult ; --p) { cnData.vW[r + p] = cnData.vW[p] ; } } // procedo all'inserimento L = 0 ; if ( mult < nDeg) { // inserisco il nodo r volte for ( int j = 1 ; j <= r ; ++ j) { L = b - nDeg + j ; for ( int i = 0; i <= r - j ; ++i) { alpha = (cnData.vU[b] - cnData.vU[L + i])/ ( cnData.vU[i + b + 1] - cnData.vU[L + i]) ; vBC[i] = alpha * vBC[i + 1] + ( 1 - alpha) * vBC[i] ; if ( cnData.bRat) { vBW[i] = alpha * vBW[i + 1] + ( 1 - alpha) * vBW[i] ; } } cnData.vCP[L + 1] = vBC[0] ; cnData.vCP[b + nDeg - j - mult] = vBC[r - j] ; if ( cnData.bRat ) { cnData.vW[L + 1] = vBW[0] ; cnData.vW[b + nDeg - j - mult] = vBW[r - j] ; } } } // allungo il vettore dei nodi e sposto gli ultimi nodi cnData.vU.resize(nU + r) ; for ( int p = nU - 1 ; p > b ; --p) cnData.vU[p+r] = cnData.vU[p] ; // aggiungo i nodi nuovi for ( int p = 0 ; p < r ; ++p) cnData.vU[b + 1 + p] = cnData.vU[b] ; nU = nU + r ; nCP = nCP + r ; // rendo la curva chiusa e non periodica eliminando i primi e gli ultimi nDeg punti e nodi cnData.bPeriodic = false ; nCP = nCP - 2 * ( nDeg - 1); nU = nU - 2 * ( nDeg - 1); PNTVECTOR vCP_clamped ; vCP_clamped.resize( nCP) ; DBLVECTOR vU_clamped ; vU_clamped.resize( nU) ; for ( int i = 0 ; i < nCP ; ++i) { if ( ! cnData.bRat) vCP_clamped[i] = cnData.vCP[i + nDeg - 1] ; else vCP_clamped[i] = cnData.vCP[i + nDeg - 1] / cnData.vW[i + nDeg - 1] ; } cnData.vCP = vCP_clamped ; for ( int i = 0 ; i < nU ; ++i) { vU_clamped[i] = cnData.vU[i + nDeg - 1] ; } cnData.vU = vU_clamped ; } return true ; } //---------------------------------------------------------------------------- ICurve* NurbsToBezierCurve( const CNurbsData& cnData) { // la curva Nurbs deve essere in forma canonica if ( cnData.bPeriodic || cnData.bExtraKnotes) return nullptr ; // numero dei nodi int nU = int( cnData.vCP.size()) + cnData.nDeg - 1 ; // controllo relazione nodi - punti di controllo if ( nU != int( cnData.vU.size())) return nullptr ; // numero degli intervalli int nInt = nU - 2 * cnData.nDeg + 1 ; // verifico le condizioni agli estremi sui nodi (i primi nDeg nodi e gli ultimi nDeg nodi devono essere uguali tra loro) bool bOk = true ; for ( int i = 1 ; i < cnData.nDeg ; ++ i) { if ( abs( cnData.vU[i] - cnData.vU[0]) >= EPS_ZERO) bOk = false ; } for ( int i = 1 ; i < cnData.nDeg ; ++ i) { if ( abs( cnData.vU[nU - 1 - i] - cnData.vU[nU - 1]) >= EPS_ZERO) bOk = false ; } if ( ! bOk) return nullptr ; // se 1 solo intervallo, la Nurbs è già una curva di Bezier if ( nInt == 1) { // creo la curva di Bezier PtrOwner pCrvBez( CreateBasicCurveBezier()) ; if ( IsNull( pCrvBez)) return nullptr ; // la inizializzo if ( ! pCrvBez->Init( cnData.nDeg, cnData.bRat)) return nullptr ; for ( int i = 0 ; i <= cnData.nDeg ; ++ i) { if ( ! cnData.bRat) { if ( ! pCrvBez->SetControlPoint( i, cnData.vCP[i])) return nullptr ; } else { if ( ! pCrvBez->SetControlPoint( i, cnData.vCP[i], cnData.vW[i])) return nullptr ; } } // se non è una curva ma un punto, la invalido if ( pCrvBez->IsAPoint()) pCrvBez->Init( cnData.nDeg, cnData.bRat) ; // restituisco la curva return Release( pCrvBez) ; } // altrimenti è equivalente ad una curva composita, la creo PtrOwner pCrvCompo( CreateBasicCurveComposite()) ; if ( IsNull( pCrvCompo)) return nullptr ; // vettore dei punti di controllo della curva di Bezier PNTVECTOR vBC ; vBC.resize( cnData.nDeg + 1) ; DBLVECTOR vBW ; vBW.resize( cnData.nDeg + 1) ; if ( ! cnData.bRat) { for ( int i = 0 ; i <= cnData.nDeg ; ++ i) vBC[i] = cnData.vCP[i] ; } else { for ( int i = 0 ; i <= cnData.nDeg ; ++ i) { vBC[i] = cnData.vCP[i] * cnData.vW[i] ; vBW[i] = cnData.vW[i] ; } } // primi coefficienti della successiva PNTVECTOR vNextBC ; vNextBC.resize( cnData.nDeg - 1) ; DBLVECTOR vNextBW ; vNextBW.resize( cnData.nDeg - 1) ; // ... DBLVECTOR vAlfa ; vAlfa.resize( cnData.nDeg - 1) ; int a = cnData.nDeg - 1 ; int b = cnData.nDeg ; bool bPrevRejected = false ; // ciclo while ( b < nU - 1) { int i = b ; while ( b < nU - 1 && abs( cnData.vU[b+1] - cnData.vU[b]) < EPS_ZERO) ++ b ; int mult = min( b - i + 1, cnData.nDeg) ; if ( mult < cnData.nDeg) { // numeratore di alfa double numer = cnData.vU[b] - cnData.vU[a] ; // calcola e salva gli alfa for ( int j = cnData.nDeg ; j > mult ; -- j) vAlfa[j-mult-1] = numer / ( cnData.vU[a+j] - cnData.vU[a]) ; // inserisco il nodo r volte int r = cnData.nDeg - mult ; for ( int j = 1 ; j <= r ; ++ j) { int save = r - j ; int s = mult + j ; for ( int k = cnData.nDeg ; k >= s ; -- k) vBC[k] = vAlfa[k-s] * vBC[k] + ( 1 - vAlfa[k-s]) * vBC[k-1] ; if ( cnData.bRat) { for ( int k = cnData.nDeg ; k >= s ; -- k) vBW[k] = vAlfa[k-s] * vBW[k] + ( 1 - vAlfa[k-s]) * vBW[k-1] ; } if ( b < nU - 1) { vNextBC[save] = vBC[cnData.nDeg] ; if ( cnData.bRat) vNextBW[save] = vBW[cnData.nDeg] ; } } } // costruisco la curva di Bezier e la inserisco nella curva composita PtrOwner pCrvBez( CreateBasicCurveBezier()) ; if ( IsNull( pCrvBez)) return nullptr ; // se precedente saltata if ( bPrevRejected) { // prendo l'ultimo punto della curva composita per garantire la continuità Point3d ptEnd ; if ( pCrvCompo->GetEndPoint( ptEnd)) vBC[0] = ptEnd ; } // la inizializzo if ( ! pCrvBez->Init( cnData.nDeg, cnData.bRat)) return nullptr ; if ( ! cnData.bRat) { for ( int i = 0 ; i <= cnData.nDeg ; ++ i) { if ( ! pCrvBez->SetControlPoint( i, vBC[i])) return nullptr ; } } else { for ( int i = 0 ; i <= cnData.nDeg ; ++ i) { if ( ! pCrvBez->SetControlPoint( i, vBC[i] / vBW[i], vBW[i])) return nullptr ; } } // se è una vera curva, la aggiungo alla curva composita if ( ! pCrvBez->IsAPoint()) { if ( ! pCrvCompo->AddCurve( Release( pCrvBez))) return nullptr ; bPrevRejected = false ; } // altrimenti è un punto, la cancello else { pCrvBez.Reset() ; bPrevRejected = true ; } // inizializzazioni per la prossima curva di Bezier if ( b < nU - 1) { if ( ! cnData.bRat) { for ( int i = 0 ; i < cnData.nDeg - 1 ; ++ i) vBC[i] = vNextBC[i] ; for ( int i = cnData.nDeg - mult ; i <= cnData.nDeg ; ++ i) vBC[i] = cnData.vCP[b-cnData.nDeg+i+1] ; } else { for ( int i = 0 ; i < cnData.nDeg - 1 ; ++ i) { vBC[i] = vNextBC[i] ; vBW[i] = vNextBW[i] ; } for ( int i = cnData.nDeg - mult ; i <= cnData.nDeg ; ++ i) { vBC[i] = cnData.vCP[b-cnData.nDeg+i+1] * cnData.vW[b-cnData.nDeg+i+1] ; vBW[i] = cnData.vW[b-cnData.nDeg+i+1] ; } } a = b ; ++ b ; } } // se la curva ha grado 1, manca da aggiungere l'ultimo tratto if ( cnData.nDeg == 1 ) { // costruisco la curva di Bezier e la inserisco nella curva composita PtrOwner pCrvBez( CreateBasicCurveBezier()) ; if ( ! pCrvBez->Init( cnData.nDeg, cnData.bRat)) return nullptr ; if ( ! cnData.bRat) { for ( int i = 0 ; i <= cnData.nDeg ; ++ i) { if ( ! pCrvBez->SetControlPoint( i, vBC[i])) return nullptr ; } } else { for ( int i = 0 ; i <= cnData.nDeg ; ++ i) { if ( ! pCrvBez->SetControlPoint( i, vBC[i] / vBW[i], vBW[i])) return nullptr ; } } if ( ! pCrvBez->IsAPoint()) { if ( ! pCrvCompo->AddCurve( Release( pCrvBez))) return nullptr ; } } // restituisco la curva composita return Release( pCrvCompo) ; } //---------------------------------------------------------------------------- ICurve* FlattenCurve( const ICurve& crCrv, double dToler, double dAngToler, int nFlag) { // Determino il piano medio della curva e verifico se scostamento accettabile Plane3d plMid ; if ( ! crCrv.IsFlat( plMid, ( nFlag == FLTCRV_USE_EXTR), dToler)) return nullptr ; // Recupero estrusione rispetto alla normale al piano medio Vector3d vtExtr ; crCrv.GetExtrusion( vtExtr) ; if ( nFlag == FLTCRV_USE_EXTR) plMid.Set( plMid.GetPoint(), vtExtr) ; // Determino il suo centro geometrico Point3d ptCen ; if ( ! crCrv.GetCentroid( ptCen)) return nullptr ; // Verifico se curva già piatta PolyLine PL ; if ( ! crCrv.ApproxWithLines( LIN_TOL_FINE, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL_INT, PL)) return nullptr ; bool bFlat = true ; Plane3d plFlat ; plFlat.Set( ptCen, plMid.GetVersN()) ; Point3d ptP ; bool bPoint = PL.GetFirstPoint( ptP) ; while ( bPoint && bFlat) { if ( DistPointPlane( ptP, plFlat) > 0.1 * EPS_SMALL) bFlat = false ; bPoint = PL.GetNextPoint( ptP) ; } // Se curva già piatta, la copio ed esco if ( bFlat) { PtrOwner pCrv( crCrv.Clone()) ; if ( IsNull( pCrv)) return nullptr ; // assegno estrusione if ( nFlag != FLTCRV_SET_EXTR) pCrv->SetExtrusion( vtExtr) ; else { if ( vtExtr * plMid.GetVersN() >= 0) pCrv->SetExtrusion( plMid.GetVersN()) ; else pCrv->SetExtrusion( - plMid.GetVersN()) ; } // restituisco la copia della curva return Release( pCrv) ; } // altrimenti la appiattisco else { // mi assicuro che la curva non contenga archi PtrOwner pCrv( CurveToNoArcsCurve( &crCrv)) ; if ( IsNull( pCrv)) return nullptr ; // calcolo un riferimento con piano XY coincidente con il piano di proiezione Frame3d frRef ; if ( ! frRef.Set( ptCen, plMid.GetVersN())) return nullptr ; // eseguo scalatura con fattori X e Y unitari e fattore Z nullo if ( ! pCrv->Scale( frRef, 1, 1, 0)) return nullptr ; // assegno estrusione if ( nFlag != FLTCRV_SET_EXTR) pCrv->SetExtrusion( vtExtr) ; else { if ( vtExtr * plMid.GetVersN() >= 0) pCrv->SetExtrusion( plMid.GetVersN()) ; else pCrv->SetExtrusion( - plMid.GetVersN()) ; } // restituisco la nuova curva return Release( pCrv) ; } } //---------------------------------------------------------------------------- ICurve* ProjectCurveOnPlane( const ICurve& crCrv, const Plane3d& plPlane) { // determino se curva piana e suo eventuale piano Plane3d plCrv ; if ( crCrv.IsFlat( plCrv, false, EPS_SMALL / 2)) { // se il piano della curva è parallelo a quello di proiezione if ( AreSameOrOppositeVectorExact( plCrv.GetVersN(), plPlane.GetVersN())) { // copio la curva PtrOwner pCrv( crCrv.Clone()) ; if ( IsNull( pCrv)) return nullptr ; // se non coincidenti, basta eseguire una traslazione Point3d ptOC = ORIG + plCrv.GetDist() * plCrv.GetVersN() ; Point3d ptOP = ORIG + plPlane.GetDist() * plPlane.GetVersN() ; if ( ! AreSamePointApprox( ptOC, ptOP)) pCrv->Translate( ptOP - ptOC) ; // restituisco la nuova curva return Release( pCrv) ; } } // mi assicuro che la curva non contenga archi PtrOwner pCrv( CurveToNoArcsCurve( &crCrv)) ; if ( IsNull( pCrv)) return nullptr ; // calcolo un riferimento con piano XY coincidente con il piano di proiezione Frame3d frRef ; if ( ! frRef.Set( ORIG + plPlane.GetDist() * plPlane.GetVersN(), plPlane.GetVersN())) return nullptr ; // eseguo scalatura con fattori X e Y unitari e fattore Z nullo if ( ! pCrv->Scale( frRef, 1, 1, 0)) return nullptr ; // restituisco la nuova curva return Release( pCrv) ; } //---------------------------------------------------------------------------- bool AdjustCurveSlope( ICurveComposite* pCrv, double dNini, double dNfin) { // verifico curva if ( pCrv == nullptr) return false ; // determino versore estrusione Vector3d vtN ; if ( ! pCrv->GetExtrusion( vtN) || vtN.IsSmall()) vtN = Z_AX ; // assegno la corretta pendenza int i = 0 ; double dCurrLen = 0 ; double dLen ; pCrv->GetLength( dLen) ; const ICurve* pSCrv = pCrv->GetFirstCurve() ; while ( pSCrv != nullptr) { double dCrvLen ; pSCrv->GetLength( dCrvLen) ; double dCoeff = dCurrLen / dLen ; double dCurrN = dNini * ( 1.0 - dCoeff) + dNfin * dCoeff ; Point3d ptJoin ; pSCrv->GetStartPoint( ptJoin) ; pCrv->ModifyJoint( i, ptJoin + vtN * ( dCurrN - ( ptJoin - ORIG) * vtN)) ; // passo al successivo dCurrLen += dCrvLen ; pSCrv = pCrv->GetNextCurve() ; ++ i ; } Point3d ptFin ; pCrv->GetEndPoint( ptFin) ; ptFin += vtN * ( dNfin - ( ptFin - ORIG) * vtN) ; pCrv->ModifyEnd( ptFin) ; return true ; } //---------------------------------------------------------------------------- Voronoi* GetCurveVoronoi( const ICurve& crvC) { switch ( crvC.GetType()) { case CRV_LINE : return GetBasicCurveLine( &crvC)->GetVoronoiObject() ; case CRV_ARC : return GetBasicCurveArc( &crvC)->GetVoronoiObject() ; case CRV_BEZIER : return GetBasicCurveBezier( &crvC)->GetVoronoiObject() ; case CRV_COMPO : return GetBasicCurveComposite( &crvC)->GetVoronoiObject() ; } return nullptr ; } //---------------------------------------------------------------------------- bool CalcCurveVoronoiDiagram( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nBound) { Voronoi* pVoronoiObj = GetCurveVoronoi( crvC) ; if ( pVoronoiObj == nullptr) return false ; return pVoronoiObj->CalcVoronoiDiagram( vCrvs, nBound) ; } //---------------------------------------------------------------------------- bool CalcCurveMedialAxis( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nSide) { Voronoi* pVoronoiObj = GetCurveVoronoi( crvC) ; if ( pVoronoiObj == nullptr) return false ; return pVoronoiObj->CalcMedialAxis( vCrvs, nSide) ; } //---------------------------------------------------------------------------- bool CalcCurveFatCurve( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dRadius, bool bSquareEnds, bool bSquareMids) { Voronoi* pVoronoiObj = GetCurveVoronoi( crvC) ; if ( pVoronoiObj == nullptr) return false ; return pVoronoiObj->CalcFatCurve( vCrvs, dRadius, bSquareEnds, bSquareMids) ; } //---------------------------------------------------------------------------- void ResetCurveVoronoi( const ICurve& crvC) { switch ( crvC.GetType()) { case CRV_LINE : GetBasicCurveLine( &crvC)->ResetVoronoiObject() ; break ; case CRV_ARC : GetBasicCurveArc( &crvC)->ResetVoronoiObject() ; break ; case CRV_BEZIER : GetBasicCurveBezier( &crvC)->ResetVoronoiObject() ; break ; case CRV_COMPO : GetBasicCurveComposite( &crvC)->ResetVoronoiObject() ; break ; } }