EgtGeomKernel :

- uniformazione delle funzioni per l'approssimazione curve con bezier.

CurveAux.cpp

@@ -513,8 +513,13 @@ CurveToBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot)
 
 //----------------------------------------------------------------------------
 ICurveBezier*
-LineToBezierCurve( const ICurveLine* pCrvLine, int nDeg, bool bMakeRatOrNot)
+LineToBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot)
 {
+   // verifico sia una linea
+   const CurveLine* pCrvLine = GetBasicCurveLine( pCrv) ;
+   if ( pCrvLine == nullptr)
+      return nullptr ;
+
    PtrOwner<ICurveBezier> 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( nDeg, true) ;
@@ -526,14 +531,14 @@ LineToBezierCurve( const ICurveLine* pCrvLine, int nDeg, bool bMakeRatOrNot)
 
 //----------------------------------------------------------------------------
 ICurve*
-ArcToBezierCurve( const ICurveArc* pArc, int nDeg, bool bMakeRatOrNot)
+ArcToBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot)
 {
    // una spirale non può essere forzata al grado 2
 
-  //// verifico sia un arco
-  // const CurveArc* pArc = GetBasicCurveArc( pCrv) ;
-  // if ( pArc == nullptr)
-  //    return nullptr ;
+  // 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) {
@@ -584,8 +589,13 @@ ArcToBezierCurve( const ICurveArc* pArc, int nDeg, bool bMakeRatOrNot)
 
 //----------------------------------------------------------------------------
 ICurve*
-CompositeToBezierCurve( const ICurveComposite* pCC, int nDeg, bool bMakeRatOrNot)
+CompositeToBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot)
 {
+   // verifico sia una composita
+   const CurveComposite* pCC = GetBasicCurveComposite( pCrv) ;
+   if ( pCC == nullptr)
+      return nullptr ;
+
    // converto tutte le curve in bezier razionali di grado 2
    PtrOwner<ICurveComposite> pCCBezier( CreateCurveComposite()) ;
    for ( int i = 0 ; i < int( pCC->GetCurveCount()) ; ++i) {
@@ -620,10 +630,15 @@ CompositeToBezierCurve( const ICurveComposite* pCC, int nDeg, bool bMakeRatOrNot
 
 //----------------------------------------------------------------------------
 ICurve*
-EditBezierCurve( const ICurveBezier* pCrvBezier, int nDeg, bool bMakeRatOrNot, double dTol)
+EditBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot, double dTol)
 { 
    // se nDeg == -1 allora viene mantenuto il grado della curva originale
 
+   // verifico sia una bezier
+   const CurveBezier* pCrvBezier = GetBasicCurveBezier( pCrv) ;
+   if ( pCrvBezier == nullptr)
+      return nullptr ;
+
    if( nDeg == 2 ||  nDeg == 1)
       return nullptr ;
 
@@ -889,8 +904,13 @@ BezierDecreaseDegree(const ICurveBezier* pCrvBezier, double dTol)
 
 //----------------------------------------------------------------------------
 ICurve*
-ApproxBezierWithCubics(const ICurveBezier* pCrvBezier, double dTol)
+ApproxBezierWithCubics(const ICurve* pCrv, double dTol)
 {
+   // verifico sia una bezier
+   const CurveBezier* pCrvBezier = GetBasicCurveBezier( pCrv) ;
+   if ( pCrvBezier == nullptr)
+      return nullptr ;
+
    // cerco di stimare quanti cambi di concavità ho
    // tiro una linea tra il primo punto di controllo e l'ultimo e poi scorro gli altri punti di controllo
    // controllando quante volte salto da un lato all'altro della linea
@@ -1012,8 +1032,13 @@ ApproxBezierWithCubics(const ICurveBezier* pCrvBezier, double dTol)
 
 //----------------------------------------------------------------------------
 ICurveBezier*
-ApproxCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez)
+ApproxCurveBezierWithSingleCubic( const ICurve* pCrv)
 {
+   // verifico sia una bezier
+   const CurveBezier* pCrvBez = GetBasicCurveBezier( pCrv) ;
+   if ( pCrvBez == nullptr)
+      return nullptr ;
+
    Point3d ptStart, ptEnd ;
    pCrvBez->GetStartPoint( ptStart) ;
    pCrvBez->GetEndPoint( ptEnd) ;
@@ -1042,8 +1067,13 @@ ApproxCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez)
 
 //----------------------------------------------------------------------------
 ICurveBezier*
-ApproxArcCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez, const Point3d& ptCen)
+ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen)
 {
+   // verifico sia una bezier
+   const CurveBezier* pCrvBez = GetBasicCurveBezier( pCrv) ;
+   if ( pCrvBez == nullptr)
+      return nullptr ;
+
    // converto una curva di bezier che definisce un arco perfetto di circonferenza
    // dato il centro( della circonferenza), inizio e fine
    // N.B. : per archi con angolo al centro < 90 
@@ -1086,7 +1116,9 @@ ApproxArcCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez, const Point3d&
 ICurve*
 ApproxCurveWithBezier( const ICurve*, double dTol)
 {
-   // interpolazione di punti con una curva bezier
+   // campiono punti lungo la curva e poi li interpolo
+
+   // oppure faccio la fat curve e poi calcolo una bezier che stia all'interno di quella regione
 
    PtrOwner<ICurveComposite> pCC( CreateBasicCurveComposite()) ;
    return Release( pCC) ;
@@ -1262,7 +1294,7 @@ CurveToNoArcsCurve( const ICurve* pCrv)
       return nullptr ;
   // se arco, devo trasformarlo in curva di Bezier (semplice o composta)
    if ( pCrv->GetType() == CRV_ARC) {
-      return ArcToBezierCurve( pCrv) ;
+      return ArcToBezierCurve( GetCurveArc(pCrv)) ;
    }
   // se curva composita, devo trasformarla in composita senza archi
    else if ( pCrv->GetType() == CRV_COMPO) {

CurveAux.h

@@ -33,5 +33,5 @@ bool CurveGetArea( const ICurve& crvC, Plane3d& plPlane, double& dArea) ;
 bool CurveDump( const ICurve& crvC, std::string& sOut, bool bMM, const char* szNewLine) ;
 bool CopyExtrusion( const ICurve* pSouCrv, ICurve* pDestCrv) ;
 bool CopyThickness( const ICurve* pSouCrv, ICurve* pDestCrv) ;
-ICurveBezier* ApproxCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez) ;
+ICurveBezier* ApproxCurveBezierWithSingleCubic( const ICurve* pCrv) ;
 Voronoi* GetCurveVoronoi( const ICurve& crvC) ;