EgtGeomKernel :

- piccola correzione.

CAvSilhouetteSurfTm.cpp

@@ -1019,7 +1019,7 @@ CAvParSilhouettesSurfTm::Prepare( void)
    m_dDimZ = b3All.GetDimZ() ;
 
   // set utensile corrente per calcolo delle collisioni
-   double dExtraXY = m_dRad + m_dOffsR ;
+   double dExtraXY = m_dRad ;
    if ( m_dSideAng < EPS_ANG_SMALL)
       m_cavTstm.SetStdTool( m_dDimZ + m_dOffsR, m_dRad + m_dOffsR, m_dCornRad + m_dOffsR) ;
    else {
@@ -1037,7 +1037,7 @@ CAvParSilhouettesSurfTm::Prepare( void)
 
       double dStemRad = m_dRad + dDeltaRad ;
       double dTipRad = m_dRad ;
-      dExtraXY = dStemRad + m_dOffsR ;
+      dExtraXY = dStemRad ;
       m_cavTstm.SetAdvTool( m_dDimZ + m_dOffsR, dStemRad + m_dOffsR, m_dMaxMat, dTipRad + m_dOffsR, m_dCornRad + m_dOffsR) ;
    }
 

Color.cpp

@@ -127,7 +127,7 @@ GetHSVFromColor( const Color& cCol)
    hsv.dSat = dDelta / dMax ;
    if ( cCol.GetRed() >= dMax)                                        // tra giallo e magenta
        hsv.dHue = ( cCol.GetGreen() - cCol.GetBlue()) / dDelta ;
-   else if ( cCol.GetGreen() >= dMax)                                  // tra ciano e giallo
+   else if( cCol.GetGreen() >= dMax)                                  // tra ciano e giallo
        hsv.dHue = 2.0 + ( cCol.GetBlue() - cCol.GetRed()) / dDelta ;
    else                                                               // tra magenta e ciano
        hsv.dHue = 4.0 + ( cCol.GetRed() - cCol.GetGreen()) / dDelta ;

CurveArc.cpp

@@ -1294,7 +1294,7 @@ CurveArc::Invert( void)
 
 //----------------------------------------------------------------------------
 bool
-CurveArc::SimpleOffset( double dDist, int nType, double dMaxAngExt)
+CurveArc::SimpleOffset( double dDist, int nType)
 {
   // la curva deve essere validata
    if ( m_nStatus != OK)
@@ -1329,7 +1329,7 @@ CurveArc::SimpleOffset( double dDist, int nType, double dMaxAngExt)
 
 //----------------------------------------------------------------------------
 bool
-CurveArc::MyExtendedOffset( double dDist, bool bAll)
+CurveArc::MyExtendedOffset( double dDist, bool bAll, int nType)
 {
   // bAll == true fa accettare raggi nulli ==> da usare solo internamente 
   // quando si è sicuri di aumentare subito il raggio o di cancellare

CurveArc.h

@@ -116,7 +116,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
               { return ApproxWithArcs( dLinTol, dAngTolDeg, PA) ; }
       ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
       bool Invert( void) override ;
-      bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) override ;
+      bool SimpleOffset( double dDist, int nType = OFF_FILLET) override ;
       bool ModifyStart( const Point3d& ptNewStart) override ;
       bool ModifyEnd( const Point3d& ptNewEnd) override ;
       bool SetExtrusion( const Vector3d& vtExtr) override
@@ -178,8 +178,8 @@ class CurveArc : public ICurveArc, public IGeoObjRW
       bool ChangeDeltaN( double dNewDeltaN) override ;
       bool ChangeAngCenter( double dNewAngCenDeg) override ;
       bool ChangeStartPoint( double dU) override ;
-      bool ExtendedOffset( double dDist) override
-              { return MyExtendedOffset( dDist, false) ; }
+      bool ExtendedOffset( double dDist, int nType = OFF_FILLET) override
+              { return MyExtendedOffset( dDist, false, nType) ; }
       bool ToExplementary( void) override ;
       bool Flip( void) override ;
 
@@ -200,7 +200,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
                      { if ( ! CopyFrom( caSrc))
                           LOG_ERROR( GetEGkLogger(), "CurveArc : copy error")
                        return *this ; }
-      bool MyExtendedOffset( double dDist, bool bAll) ;
+      bool MyExtendedOffset( double dDist, bool bAll, int nType = OFF_FILLET) ;
       bool MyCalcPointParamPosiz( const Point3d& ptP, double& dU, int& nPos, double dLinTol) const ;
       Voronoi* GetVoronoiObject( void) const ;
       void ResetVoronoiObject( void) const ;

CurveAux.cpp

@@ -25,14 +25,12 @@
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EGkCurveByInterp.h"
-#define EIGEN_NO_IO
 #include "/EgtDev/Extern/Eigen/Dense"
 
 using namespace std ;
 
 static bool FindSpan( double dU, int nDeg, const DBLVECTOR& vKnots, int& nSpan) ;
-static bool CalcBasisFunc( double dU, int nSpan, int nDeg, const DBLVECTOR& vKnots, DBLVECTOR& vBasis) ;
+static bool CalcBasisFunc( double dU, int nDeg, const DBLVECTOR& vKnots, DBLVECTOR& vBasis) ;
 
 //----------------------------------------------------------------------------
 bool
@@ -515,9 +513,10 @@ 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 che esista la linea
+   // verifico sia una linea
+   const CurveLine* pCrvLine = GetBasicCurveLine( pCrv) ;
    if ( pCrvLine == nullptr)
       return nullptr ;
 
@@ -532,11 +531,12 @@ 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 che esista l'arco
+  // verifico sia un arco
+   const CurveArc* pArc = GetBasicCurveArc( pCrv) ;
    if ( pArc == nullptr)
       return nullptr ;
 
@@ -546,15 +546,8 @@ ArcToBezierCurve( const ICurveArc* pArc, int nDeg, bool bMakeRatOrNot)
       PtrOwner<ICurveBezier> pCrvBez( CreateBasicCurveBezier()) ;
       if ( IsNull( pCrvBez)  ||  ! pCrvBez->FromArc( *pArc))
          return nullptr ;
-      if ( ! bMakeRatOrNot) {
-          Point3d ptCen = pArc->GetCenter() ;
-          Vector3d vtN = pArc->GetNormVersor() ;
-          pCrvBez.Set( ApproxArcCurveBezierWithSingleCubic( pCrvBez, ptCen, vtN)) ;
-      }
-      if ( IsNull( pCrvBez))
-          return nullptr ;
       // aumento il grado della curva come richiesto
-      while ( pCrvBez->GetDegree() < nDeg)
+      while( pCrvBez->GetDegree() < nDeg)
          pCrvBez.Set( BezierIncreaseDegree( pCrvBez)) ;
      // restituisco la curva
       return Release( pCrvBez) ;
@@ -567,18 +560,20 @@ ArcToBezierCurve( const ICurveArc* pArc, int nDeg, bool bMakeRatOrNot)
          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 = *GetBasicCurveArc( pArc) ;
+         CurveArc cArc = *GetBasicCurveArc(pArc->Clone()) ;
         // lo limito alla parte di interesse
-         cArc.TrimStartEndAtParam( double( i) / nParts, double( i + 1) / nParts) ;
+         cArc.TrimStartEndAtParam( i / double( nParts), ( i + 1) / double( nParts)) ;
         // creo la curva di Bezier equivalente
          PtrOwner<ICurveBezier> pCrvBez( CreateBasicCurveBezier()) ;
          if ( IsNull( pCrvBez)  ||  ! pCrvBez->FromArc( cArc))
             return nullptr ;
          // aumento il grado della curva come richiesto
-         while ( pCrvBez->GetDegree() < nDeg)
+         while( pCrvBez->GetDegree() < nDeg)
             pCrvBez.Set( BezierIncreaseDegree( pCrvBez)) ;
         // aggiungo la curva di Bezier a quella composita
          if ( ! pCrvCompo->AddCurve( Release( pCrvBez)))
@@ -594,13 +589,14 @@ 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 che esista la curva
+   // verifico sia una composita
+   const CurveComposite* pCC = GetBasicCurveComposite( pCrv) ;
    if ( pCC == nullptr)
       return nullptr ;
 
-  // converto tutte le curve in bezier razionali di grado 2
+   // converto tutte le curve in bezier razionali di grado 2
    PtrOwner<ICurveComposite> pCCBezier( CreateCurveComposite()) ;
    for ( int i = 0 ; i < int( pCC->GetCurveCount()) ; ++i) {
       PtrOwner<ICurve> pCrvNew ;
@@ -609,7 +605,7 @@ CompositeToBezierCurve( const ICurveComposite* pCC, int nDeg, bool bMakeRatOrNot
          ICurve* pCrvBezier = ArcToBezierCurve( crArc) ;
          if ( pCrvBezier == nullptr)
             return nullptr ;
-        // se la curva è di grado superiore al secondo allora devo ricondurla al secondo grado
+         // 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) {
@@ -634,32 +630,34 @@ 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
+   // verifico sia una bezier
+   const CurveBezier* pCrvBezier = GetBasicCurveBezier( pCrv) ;
    if ( pCrvBezier == nullptr)
       return nullptr ;
 
-   if ( nDeg == 2  ||  nDeg == 1)
+   if( nDeg == 2 ||  nDeg == 1)
       return nullptr ;
 
    PtrOwner<ICurveBezier> pCrvNew( pCrvBezier->Clone()) ;
    int nDegCurr = pCrvNew->GetDegree() ;
    bool bRat = pCrvNew->IsRational() ;
    int nDegWanted = nDeg == -1 ? nDegCurr : nDeg ;
-   if ( ! bMakeRatOrNot) {
-      if ( ! pCrvNew->MakeNonRational( dTol)) {
+   if( ! bMakeRatOrNot) {
+      if( ! pCrvNew->MakeNonRational( dTol)) {
          // se ho fallito la conversione diretta in curva non razionale allora la spezzo in bezier cubiche
          PtrOwner<ICurveComposite> pBezCubics( CreateCurveComposite()) ;
          pBezCubics->AddCurve( ApproxBezierWithCubics(pCrvBezier, dTol)) ;
-         if ( IsNull( pBezCubics))
+         if( IsNull( pBezCubics))
             return nullptr ;
          // adatto ogni sottocurva cubica
          PtrOwner<ICurveComposite> pCCEdited( CreateCurveComposite()) ;
+         
          for ( int i = 0 ; i < pBezCubics->GetCurveCount() ; ++i) {
-            if ( ! pCCEdited->AddCurve( EditBezierCurve( GetCurveBezier( pBezCubics->GetCurve( i)), nDegWanted, bMakeRatOrNot, dTol)) )
+            if( ! pCCEdited->AddCurve( EditBezierCurve( GetCurveBezier( pBezCubics->GetCurve( i)), nDegWanted, bMakeRatOrNot, dTol)) )
                return nullptr ;
          }
          return Release( pCCEdited) ;
@@ -678,7 +676,7 @@ EditBezierCurve( const ICurveBezier* pCrvBezier, int nDeg, bool bMakeRatOrNot, d
    else if ( nDegCurr > nDegWanted) {
       while ( nDegCurr > nDegWanted) {
          ICurveBezier* pCrvDec = BezierDecreaseDegree( pCrvNew, dTol) ;
-         if ( pCrvDec == nullptr  ||  ! pCrvDec->IsValid()) {
+         if( pCrvDec == nullptr  ||  ! pCrvDec->IsValid()) {
             // se ho fallito la riduzione di grado entro la tolleranza richiesta allora la spezzo in bezier cubiche prima di adattare
             PtrOwner<ICurveComposite> pBezCubics( CreateCurveComposite()) ;
             pBezCubics->AddCurve( ApproxBezierWithCubics(pCrvBezier, dTol)) ;
@@ -687,7 +685,7 @@ EditBezierCurve( const ICurveBezier* pCrvBezier, int nDeg, bool bMakeRatOrNot, d
             // adatto ogni sottocurva cubica
             PtrOwner<ICurveComposite> pCCEdited( CreateCurveComposite()) ;
             for ( int i = 0 ; i < pBezCubics->GetCurveCount() ; ++i) {
-               if ( ! pCCEdited->AddCurve( EditBezierCurve( GetCurveBezier( pBezCubics->GetCurve( i)), nDeg, bMakeRatOrNot, dTol)) )
+               if( ! pCCEdited->AddCurve( EditBezierCurve( GetCurveBezier( pBezCubics->GetCurve( i)), nDeg, bMakeRatOrNot, dTol)) )
                   return nullptr ;
             }
             return Release( pCCEdited) ;
@@ -704,22 +702,20 @@ EditBezierCurve( const ICurveBezier* pCrvBezier, int nDeg, bool bMakeRatOrNot, d
 
 //----------------------------------------------------------------------------
 ICurveBezier*
-BezierIncreaseDegree( const ICurveBezier* pCrvBezier)
+BezierIncreaseDegree(const ICurveBezier* pCrvBezier)
 {
    if ( pCrvBezier == nullptr)
       return nullptr ;
-  // creo la versione con grado aumentato
+   // creo la versione con grado aumentato
    PtrOwner<ICurveBezier> pNewBezier( CreateCurveBezier()) ;
-   if ( IsNull( pNewBezier))
-      return nullptr ;
-   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
+   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) {
+   if ( bRat ) {
       dWprev = pCrvBezier->GetControlWeight( 0) ;
       pNewBezier->SetControlPoint( 0, ptCtrlPrev, dWprev) ;
    }
@@ -728,26 +724,26 @@ BezierIncreaseDegree( const ICurveBezier* pCrvBezier)
    // ciclo sui punti di controllo intermedi per calcolare quelli nuovi
    Point3d ptCtrlCurr ;
    double dWcurr ;
-   for ( int i = 1 ; i < nDeg ; ++i) {
-      ptCtrlCurr = pCrvBezier->GetControlPoint( i) ;
-      double dAlpha = double( i) / nDeg ;
+   for ( double i = 1 ; i < nDeg ; ++i) {
+      ptCtrlCurr = pCrvBezier->GetControlPoint( int( i)) ;
+      double dAlpha = i / nDeg ;
       if ( bRat) {
-         dWcurr = pCrvBezier->GetControlWeight( i) ;
+         dWcurr = pCrvBezier->GetControlWeight( int( i)) ;
          double dWnew = dAlpha * dWprev + ( 1 - dAlpha) * dWcurr ;
          Point3d ptNew = dAlpha * ptCtrlPrev * dWprev + ( 1 - dAlpha) * ptCtrlCurr * dWcurr;
          ptNew /= dWnew ;
-         pNewBezier->SetControlPoint( i, ptNew, dWnew) ;
+         pNewBezier->SetControlPoint( int( i), ptNew, dWnew) ;
          dWprev = dWcurr ;
       }
       else {
          Point3d ptNew = dAlpha * ptCtrlPrev + ( 1 - dAlpha) * ptCtrlCurr ;
-         pNewBezier->SetControlPoint( i, ptNew) ;
+         pNewBezier->SetControlPoint( int( i), ptNew) ;
       }
       ptCtrlPrev = ptCtrlCurr ;
    }
    // salvo l'ultimo punto
    ptCtrlCurr = pCrvBezier->GetControlPoint( nDeg - 1) ;
-   if ( bRat) {
+   if ( bRat ) {
       dWcurr = pCrvBezier->GetControlWeight( nDeg - 1) ;
       pNewBezier->SetControlPoint( nDeg, ptCtrlCurr, dWcurr) ;
    }
@@ -899,7 +895,7 @@ BezierDecreaseDegree(const ICurveBezier* pCrvBezier, double dTol)
    }
    // se l'approssimazione dà un errore troppo alto allora annullo tutto
    // ricalcolo l'errore a mano, per avere un valore più attendibile
-   CalcApproxError( pCrvBezier, pNewBezier, dErr) ;
+   CalcBezierApproxError( pCrvBezier, pNewBezier, dErr) ;
    if ( dErr > dTol)
       return nullptr ;
    
@@ -935,8 +931,10 @@ ApproxBezierWithCubics(const ICurve* pCrv, double dTol)
       Vector3d vtStartDir, vtEndDir ;
       pCrvBezier->GetPointD1D2( 0, ICurve::FROM_MINUS, ptStart, &vtStartDir) ;
       pCrvBezier->GetPointD1D2( 1, ICurve::FROM_PLUS, ptEnd, &vtEndDir) ;
-      vtStartDir.Rotate( vtN, 90) ;
-      vtEndDir.Rotate( vtN, 90) ;
+      Plane3d plPLane ;
+      plPLane.Set( ptStart, ptCtrl, ptEnd) ;
+      vtStartDir.Rotate( plPLane.GetVersN(), 90) ;
+      vtEndDir.Rotate( plPLane.GetVersN(), 90) ;
       Point3d ptAux1 = ptStart + vtStartDir ;
       Point3d ptAux2 = ptEnd + vtEndDir ;
       PtrOwner<CurveLine> pCL1( CreateBasicCurveLine()) ;
@@ -951,7 +949,7 @@ ApproxBezierWithCubics(const ICurve* pCrv, double dTol)
          double dDist2 = Dist( ptEnd, ptCen) ;
          if ( abs(dDist1 - dDist2) < EPS_SMALL ) {
             CurveArc cArc ;
-            cArc.SetC2PN( ptCen, ptStart, ptEnd, vtN) ;
+            cArc.SetC2PN( ptCen, ptStart, ptEnd, plPLane.GetVersN()) ;
             // controllo se il raggio della circonferenza risultante coincide con quello calcolato prima
             // impongo inoltre che l'angolo al centro sia minore di 90 gradi
             if ( abs( cArc.GetRadius() - dDist1) < EPS_SMALL  &&  cArc.GetAngCenter() < 90 + EPS_SMALL)
@@ -995,7 +993,7 @@ ApproxBezierWithCubics(const ICurve* pCrv, double dTol)
       if ( ! bIsArc)
          pCrvCubic.Set( ApproxCurveBezierWithSingleCubic( pCrvPart)) ;
       else {
-         pCrvCubic.Set( ApproxArcCurveBezierWithSingleCubic( pCrvPart, ptCen, vtN)) ;
+         pCrvCubic.Set( ApproxArcCurveBezierWithSingleCubic( pCrvPart, ptCen)) ;
          if ( IsNull( pCrvCubic)) {
             // se fallisce allora riprovo usando più di una bezier
             bIsArc = false ;
@@ -1005,7 +1003,7 @@ ApproxBezierWithCubics(const ICurve* pCrv, double dTol)
             pCrvCubic.Set( ApproxCurveBezierWithSingleCubic( pCrvPart)) ;
          }
       }
-      CalcApproxError( pCrvPart, pCrvCubic, dErr) ;
+      CalcBezierApproxError( pCrvPart, pCrvCubic, dErr) ;
       if ( dErr > dTol  &&  ! bOneIsEnough)
          nParts += 2 ;
       else {
@@ -1069,21 +1067,12 @@ ApproxCurveBezierWithSingleCubic( const ICurve* pCrv)
 
 //----------------------------------------------------------------------------
 ICurveBezier*
-ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen, const Vector3d& vtN)
+ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen)
 {
-    // verifico sia una bezier
-    const CurveBezier* pCrvBez = GetBasicCurveBezier( pCrv) ;
-    if ( pCrvBez == nullptr)
-        return nullptr ;
-
-   // mi metto nel frame della curva ( lavoro nel piano XY)
-    Point3d ptStart = pCrvBez->GetControlPoint( 0) ;
-    Point3d ptEnd = pCrvBez->GetControlPoint( 2) ;
-    Frame3d frCrv; frCrv.Set( ptStart, vtN) ;
-    ptStart = ORIG ;
-    ptEnd.ToLoc( frCrv) ;
-    Point3d ptCenLoc = ptCen ;
-    ptCenLoc.ToLoc( frCrv) ;
+   // 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
@@ -1093,7 +1082,9 @@ ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen, c
    bool bRat = pCrvBez->IsRational() ;
    if ( nDeg != 2  ||  ! bRat)
       return nullptr ;
-   
+
+   Point3d ptStart = pCrvBez->GetControlPoint( 0) ;
+   Point3d ptEnd = pCrvBez->GetControlPoint( 2) ;
    if ( AreSamePointEpsilon( ptStart, ptEnd, EPS_SMALL * 50))
       return nullptr ;
    nDeg = 3 ;
@@ -1103,13 +1094,13 @@ ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen, c
    pCrvCubic->SetControlPoint( 3, ptEnd) ;
    // from the article of Aleksas Riškus "Approximation of a cubic bezier curve by circular arcs and vice versa"
    // with corrections from "Hans Muller's Flex Blog", page "More About Approximating Circular Arcs With a Cubic Bezier Path"
-   double ax = ptStart.x - ptCenLoc.x ;
-   double ay = ptStart.y - ptCenLoc.y ;
-   double bx = ptEnd.x - ptCenLoc.x ;
-   double by = ptEnd.y - ptCenLoc.y ;
-   double q1 = ax * ax + ay * ay ;
+   double ax = ptStart.x - ptCen.x ;
+   double ay = ptStart.y - ptCen.y ;
+   double bx = ptEnd.x - ptCen.x ;
+   double by = ptEnd.y - ptCen.y ;
+   double q1 = pow( ax, 2) + pow( ay, 2) ;
    double q2 = q1 + ax * bx + ay * by ;
-   double k2 = 4. / 3 * ( sqrt( 2 * q1 * q2) - q2) / ( ax * by  - ay * bx) ;
+   double k2 = 4./3 * ( sqrt( 2 * q1 * q2) - q2) / ( ax * by  - ay * bx) ;
    Point3d ptCtrl1, ptCtrl2 ;
    ptCtrl1.x = ptStart.x - k2 * ay ;
    ptCtrl1.y = ptStart.y + k2 * ax ;
@@ -1118,108 +1109,45 @@ ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen, c
    pCrvCubic->SetControlPoint( 1, ptCtrl1) ;
    pCrvCubic->SetControlPoint( 2, ptCtrl2) ;
 
-   // ritorno nel frame originale
-   pCrvCubic->ToGlob( frCrv) ;
-
    return Release( pCrvCubic) ;
 }
 
 //----------------------------------------------------------------------------
-static bool
-FindSpan( double dU, int nDeg, const DBLVECTOR& vKnots, int& nSpan)
+ICurve*
+ApproxCurveWithBezier( const ICurve*, double dTol)
 {
-   if ( dU < 0)
-      return false ;
-   else if ( dU < EPS_ZERO) {
-      nSpan = nDeg - 1 ;
-      return true ;
-   }
-   // trovo a quale span appartiene il parametro dU
-   int nKnots = int( vKnots.size()) ;
-   if ( abs( dU - vKnots[nKnots-1]) < EPS_SMALL) {
-      nSpan = nKnots - 1 - nDeg ;
-      return true ;
-   }
-   int nLow = nDeg - 1 ;
-   int nHigh = nKnots - 1 ;
-   int nMid = ( nLow + nHigh) / 2 ;
-   while ( dU < vKnots[nMid] || dU >= vKnots[nMid + 1] ) {
-      if ( dU < vKnots[nMid])
-         nHigh = nMid ;
-      else
-         nLow = nMid ;
-      nMid = ( nLow + nHigh) / 2 ;
-      if ( nMid == nDeg - 1)
-         break ;
-   }
-   nSpan = nMid ;
-   return true ;
-}
+   // campiono punti lungo la curva e poi li interpolo
 
-//----------------------------------------------------------------------------
-static bool
-CalcBasisFunc( double dU, int nSpan, int nDeg, const DBLVECTOR& vKnots, DBLVECTOR& vBasis)
-{
-   // mi aspetto che il vettore vBasis sia di lunghezza  nDeg + 1
-   if ( vBasis.size() != nDeg + 1)
-      return false ;
+   // oppure faccio la fat curve e poi calcolo una bezier che stia all'interno di quella regione
 
-   vBasis[0] = 1 ;
-   DBLVECTOR vLeft ; vLeft.resize( nDeg + 1) ;
-   DBLVECTOR vRight ; vRight.resize( nDeg + 1) ;
-   for ( int j = 1 ; j <= nDeg ; ++j) {
-      vLeft[j] = dU - vKnots[nSpan + 1 -j] ;
-      vRight[j] = vKnots[nSpan + j] - dU ;
-      double dSaved = 0 ;
-      for ( int r = 0 ; r < j ; ++r) {
-         double dSum = vRight[r+1] + vLeft[j-r] ;
-         double dTemp = 0 ;
-         if ( dSum > EPS_ZERO)
-            dTemp = vBasis[r] / dSum ;
-         vBasis[r] = dSaved + vRight[r+1] * dTemp ;
-         dSaved = vLeft[j-r] * dTemp ;
-      }
-      vBasis[j] = dSaved ;
-   }
-   return true ;
+   PtrOwner<ICurveComposite> pCC( CreateBasicCurveComposite()) ;
+   return Release( pCC) ;
 }
 
 //----------------------------------------------------------------------------
 ICurve*
-InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart, int nEnd, int nDeg, const DBLVECTOR& vLen, double dLenTot)
+InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dTol)
 {
    PtrOwner<ICurve> pCrvInt ;
+   // pag 364 del Piegl
+   // scelgo il parametro associato ad ogni punto in modo che rispecchi la distanza tra i punti
 
-   int nPoints = nEnd - nStart + 1 ;
-
-   if ( nPoints < 2)
+   int nPoints = vPnt.size() ;
+   if ( nPoints < 4)
       return nullptr ;
-   else if ( nPoints == 2) {
-      // se ho solo due punti restituisco una linea
-      CurveLine cl ; cl.Set( vPnt[nStart], vPnt[nEnd]) ;
-      pCrvInt.Set( LineToBezierCurve( &cl, nDeg, false)) ;
-      if ( ! IsNull( pCrvInt)  &&  pCrvInt->IsValid())
-         return Release( pCrvInt) ;
-      else
-         return nullptr ;
+   int nDeg = 3 ;
+   DBLVECTOR vLen ;
+   double dLenTot = 0 ;
+   for ( int i = 0 ; i < int( nPoints -1) ; ++i) {
+      double dLen = Dist(vPnt[i], vPnt[i+1]) ;
+      vLen.push_back( dLen) ;
+      dLenTot += dLen ;
    }
-   else if (nPoints == 3) {
-      // se ho solo tre punti uso un altro algoritmo
-      CurveByInterp cbi ;
-      for ( int i = nStart ; i <= nEnd ; ++i)
-         cbi.AddPoint( vPnt[i]) ;
-      pCrvInt.Set( cbi.GetCurve( CurveByInterp::AKIMA_CORNER, CurveByInterp::CUBIC_BEZIERS)) ;
-      if ( ! IsNull( pCrvInt)  &&  pCrvInt->IsValid())
-         return Release( pCrvInt) ;
-      else
-         return nullptr ;
-   }
-
    DBLVECTOR vPntParam ;
    vPntParam.resize( nPoints) ;
    vPntParam[0] = 0 ;
    vPntParam.back() = 1 ;
-   for ( int i = 1 ; i < nPoints - 1 ; ++i)
+   for ( int i = 1 ; i < int( nPoints - 1) ; ++i)
       vPntParam[i] = vPntParam[i-1] + vLen[i-1] / dLenTot ;
 
    DBLVECTOR vKnots ;
@@ -1231,7 +1159,7 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
 
    for ( int i = nDeg ; i < nPoints - 1 ; ++i) {
       double dKnot = 0 ;
-      for ( int j = i + 1 ; j < i + nDeg + 1 ; ++j)
+      for ( int j = i ; j < i + nDeg ; ++j)
          dKnot += vPntParam[j - nDeg] ;
       dKnot /= nDeg ;
       vKnots[i] = dKnot ;
@@ -1240,26 +1168,21 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
    Eigen::MatrixXd mA( nPoints, nPoints) ;
    mA.fill( 0) ;
    for ( int i = 0 ; i < nPoints ; ++i) {
+      int nSpan = 0 ; FindSpan(vPntParam[i], nDeg, vKnots, nSpan) ;
       if ( i == 0)
          mA.row(0).col(0) << 1 ;
       else if ( i == nPoints - 1)
-         mA.row(i).col(nPoints - 1) << 1 ;
+            mA.row(i).col(nPoints - 1) << 1 ;
       else {
-         int nSpan = 0 ; FindSpan( vPntParam[i], nDeg, vKnots, nSpan) ;
          DBLVECTOR vBasis ; vBasis.resize( nDeg + 1) ;
-         CalcBasisFunc( vPntParam[i], nSpan, nDeg, vKnots, vBasis) ;
-         for ( int j = nSpan - nDeg + 1 ; j <= nSpan + 1 ; ++j)
-            mA.row(i).col(j) << vBasis[j - nSpan + nDeg - 1] ;
+         CalcBasisFunc( vPntParam[i], nDeg, vKnots, vBasis) ;
+         for( int j = nSpan - nDeg ; j < nSpan ; ++j)
+            mA.row(i).col(j) << vBasis[j - nSpan + nDeg] ;
       }
    }
 
    int nDim = 3 ;
    Eigen::MatrixXd mb ; mb.resize( nPoints, nDim) ;
-   for ( int i = 0 ; i < nPoints ; ++i) {
-         mb.row(i).col(0) << vPnt[nStart + i].x ;
-         mb.row(i).col(1) << vPnt[nStart + i].y ;
-         mb.row(i).col(2) << vPnt[nStart + i].z ;
-   }
    Eigen::MatrixXd mX = mA.fullPivLu().solve(mb) ;
 
    PNTVECTOR vPntCtrl ;
@@ -1273,140 +1196,76 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
 
    pCrvInt.Set( NurbsToBezierCurve( cNurbs)) ;
 
-   if ( ! IsNull(pCrvInt)  &&  pCrvInt->IsValid())
-      return Release( pCrvInt) ;
-   else
-      return nullptr ;
+   return Release( pCrvInt) ;
 }
 
 //----------------------------------------------------------------------------
-ICurve*
-InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMaxLen)
+static bool
+FindSpan( double dU, int nDeg, const DBLVECTOR& vKnots, int& nSpan)
 {
-   PolyLine pl ; pl.FromPointVector( vPnt) ;
-   PtrOwner<ICurveComposite> pCrvOri( CreateCurveComposite()) ;
-   pCrvOri->FromPolyLine( pl) ;
-
-   PtrOwner<ICurveComposite> pCrvInt( CreateCurveComposite()) ;
-   // pag 364 del Piegl
-   // scelgo il parametro associato ad ogni punto in modo che rispecchi la distanza tra i punti
-   double dErr = INFINITO ;
-   int nItCount = 0 ;
-   while ( dErr > dLinTol  &&  nItCount < 10) {
-      pCrvInt->Clear() ;
-      int nPoints = int( vPnt.size()) ;
-      int nDeg = 3 ;
-      if ( nPoints < 2)
-         return nullptr ;
-      else if ( nPoints == 2) {
-         // se ho solo due punti restituisco una linea
-         CurveLine cl ; cl.Set( vPnt[0], vPnt[1]) ;
-         pCrvInt->AddCurve( LineToBezierCurve( &cl, nDeg, false)) ;
-         if ( ! IsNull( pCrvInt)  &&  pCrvInt->IsValid())
-            return Release( pCrvInt) ;
-         else
-            return nullptr ;
-      }
-      else if ( nPoints == 3) {
-         // se ho solo tre punti uso un altro algoritmo
-         CurveByInterp cbi ;
-         for ( int i = 0 ; i < int( vPnt.size()) ; ++i)
-            cbi.AddPoint( vPnt[i]) ;
-         pCrvInt->AddCurve( cbi.GetCurve( CurveByInterp::AKIMA_CORNER, CurveByInterp::CUBIC_BEZIERS)) ;
-         if ( ! IsNull( pCrvInt)  &&  pCrvInt->IsValid())
-            return Release( pCrvInt) ;
-         else
-            return nullptr ;
-      }
-
-      // scorro il vettore di punti passato in input e interpolo separatamente gruppi di punti se incontro
-      // tratti più lunghi della distanza dMaxLen
-      int nStart = 0, nEnd = 0 ;
-      bool bOk = true ;
-      bool bFoundLine = false ;
-      while ( nStart < nPoints - 1  &&  bOk) {
-         bFoundLine = false ;
-         nEnd = 0 ;
-         DBLVECTOR vLen ;
-         double dLenTot = 0 ;
-         for ( int i = nStart ; i < nPoints - 1 ; ++i) {
-            double dLen = Dist( vPnt[i], vPnt[i+1]) ;
-            if ( dLen < dMaxLen) {
-               vLen.push_back( dLen) ;
-               dLenTot += dLen ;
-            }
-            else {
-               nEnd = i ;
-               bFoundLine = true ;
-               break ;
-            }
-         }
-
-         if ( vLen.size() != 0) {
-            if ( nEnd == 0)
-               nEnd = nPoints - 1 ;
-            pCrvInt->AddCurve( InterpolatePointSetWithBezierNoIntermedLines( vPnt, nStart, nEnd, nDeg, vLen, dLenTot)) ;
-         }
-
-         if ( bFoundLine) {
-            CurveLine cl ; cl.Set( vPnt[nEnd], vPnt[nEnd+1]) ;
-            pCrvInt->AddCurve( LineToBezierCurve( &cl, nDeg, false)) ;
-            ++ nEnd ;
-         }
-         bOk = pCrvInt->IsValid() ;
-         nStart = nEnd ;
-      }
-
-      CalcApproxError( pCrvOri, pCrvInt, dErr) ;
-      if ( dErr > dLinTol  &&  dMaxLen > 200 * EPS_SMALL)
-         dMaxLen /= 2 ;
-
-      ++ nItCount ;
+   if ( dU < 0)
+      return false ;
+   else if ( dU < EPS_ZERO) {
+      nSpan = nDeg ;
+      return true ;
    }
-
-   if ( ! IsNull( pCrvInt)  &&  pCrvInt->IsValid()  &&  dErr < dLinTol)
-      return Release( pCrvInt) ;
-   else
-      return nullptr ;
-}
-
-//----------------------------------------------------------------------------
-ICurve*
-ApproxCurveWithBezier( const ICurve* pCrv , double dTol, int nType)
-{
-   PolyLine plApprox ;
-   double dAngTolFine = 2 ;
-   pCrv->ApproxWithLines( dTol, dAngTolFine, ICurve::APL_STD, plApprox) ;
-
-   PNTVECTOR vPnt ;
-   Point3d pt ; plApprox.GetFirstPoint( pt) ;
-   do {
-      vPnt.push_back( pt) ;
-   } while ( plApprox.GetNextPoint( pt)) ;
-
-   // campiono punti lungo la curva e poi li interpolo
-
-   PtrOwner<ICurve> pCC( InterpolatePointSetWithBezier( vPnt, dTol, 100)) ;
-   if ( ! IsNull( pCC)  &&  pCC->IsValid())
-         return Release( pCC) ;
+   // trovo a quale span appartiene il parametro dU
+   int nKnots = int( vKnots.size()) ;
+   if ( abs( dU - vKnots[nKnots-1]) < EPS_SMALL) {
+      nSpan = nKnots - 1 ;
+      return true ;
+   }
+   int nLow = nDeg ;
+   int nHigh = nKnots ;
+   int nMid = ( nLow + nHigh) / 2 ;
+   while ( dU < vKnots[nMid] || dU > vKnots[nMid + 1] ) {
+      if ( dU < vKnots[nMid])
+         nHigh = nMid ;
       else
-         return nullptr ;
+         nLow = nMid ;
+      nMid = ( nLow + nHigh) / 2 ;
+      if( nMid == nDeg)
+         break ;
+   }
+   nSpan = nMid ;
+   return true ;
 }
 
 //----------------------------------------------------------------------------
-ICurve*
-ApproxPointSetWithBezier( const ICurve* pCrv, double dTol)
+static bool
+CalcBasisFunc( double dU, int nDeg, const DBLVECTOR& vKnots, DBLVECTOR& vBasis)
 {
-   // campiono punti lungo la curva e poi li interpolo
+   // mi aspetto che il vettore vBasis sia di lunghezza  nDeg + 1
+   if ( vBasis.size() != nDeg + 1)
+      return false ;
 
-   PtrOwner<ICurveComposite> pCC( CreateBasicCurveComposite()) ;
-   return Release( pCC) ;
+   int nSpan = 0 ;
+   FindSpan( dU, nDeg, vKnots, nSpan) ;
+
+   vBasis[0] = 1 ;
+   DBLVECTOR vLeft ; vLeft.resize( nDeg + 1) ;
+   DBLVECTOR vRight ; vRight.resize( nDeg + 1) ;
+   for ( int j = 1 ; j <= nDeg ; ++j) {
+      vLeft[j] = dU - vKnots[nSpan + 1 -j] ;
+      vRight[j] = vKnots[nSpan + j] - dU ;
+      double dSaved = 0 ;
+      for ( int r = 0 ; r < j ; ++r) {
+         double dTemp = vBasis[r] / ( vRight[r+1] + vLeft[j-r]) ;
+         vBasis[r] = dSaved + vRight[r+1] * dTemp ;
+         dSaved = vLeft[j-r] * dTemp ;
+      }
+      vBasis[j] = dSaved ;
+   }
+   return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-CalcApproxError( const ICurve* pCrvOri, const ICurve* pCrvNew, double& dErr, int nPoints)
+CalcBezierApproxError( const ICurveBezier* pCrvOri, const ICurveBezier* pCrvNew, double& dErr, int nPoints)
 {
+   if ( pCrvOri->GetType() != CRV_BEZIER  ||  pCrvNew->GetType() != CRV_BEZIER)
+      return false ;
+
    // controllo l'errore effettivo campionando più finemente
    double dLenOri = 0 ; pCrvOri->GetLength( dLenOri) ;
    double dLenNew = 0 ; pCrvNew->GetLength( dLenNew) ;
@@ -1435,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( GetCurveArc( pCrv)) ;
+      return ArcToBezierCurve( GetCurveArc(pCrv)) ;
    }
   // se curva composita, devo trasformarla in composita senza archi
    else if ( pCrv->GetType() == CRV_COMPO) {

CurveBezier.cpp

@@ -93,11 +93,8 @@ CurveBezier::Init( int nDeg, bool bIsRational)
 bool
 CurveBezier::SetControlPoint( int nInd, const Point3d& ptCtrl)
 {
-  // verifico validità indice e punto
-   if ( m_nStatus != OK  ||  m_bRat  ||  nInd < 0  ||  nInd > m_nDeg  ||  ! ptCtrl.IsValid())
-      return false ;
-
-   if ( abs( ptCtrl.x) > INFINITO  ||  abs( ptCtrl.y) > INFINITO  ||  abs( ptCtrl.z) > INFINITO)
+  // verifico validità indice
+   if ( m_nStatus != OK  ||  m_bRat  ||  nInd < 0  ||  nInd > m_nDeg)
       return false ;
 
   // assegno il valore
@@ -126,11 +123,8 @@ CurveBezier::SetControlPoint( int nInd, const Point3d& ptCtrl, double dW)
    if ( m_nStatus != OK  ||  ! m_bRat  ||  nInd < 0  ||  nInd > m_nDeg)
       return false ;
 
-  // verifico che il punto sia valido e il peso non sia nullo o negativo
-   if ( ! ptCtrl.IsValid()  ||  dW < EPS_SMALL  ||  ! isfinite( dW)  ||  dW > INFINITO)
-      return false ;
-
-   if ( abs( ptCtrl.x) > INFINITO  ||  abs( ptCtrl.y) > INFINITO  ||  abs( ptCtrl.z) > INFINITO)
+  // verifico che il peso non sia nullo o negativo
+   if ( dW < EPS_SMALL)
       return false ;
 
   // assegno il valore e il peso
@@ -157,7 +151,7 @@ CurveBezier::SetControlWeight( int nInd, double dW)
       return false ;
 
    // verifico che il peso non sia nullo o negativo
-   if ( dW < EPS_SMALL  ||  ! isfinite( dW)  ||  dW > INFINITO)
+   if ( dW < EPS_SMALL)
       return false ;
 
    // assegno il valore e il peso
@@ -273,7 +267,7 @@ CurveBezier::FromArc( const ICurveArc& crArc)
 bool
 CurveBezier::FromLine( const ICurveLine& crLine)
 {
-   if ( m_nStatus != OK  ||  ! crLine.IsValid())
+   if ( ! crLine.IsValid())
       return false ;
    double dWeight = 1 ;
    int nCount = 0 ;
@@ -373,11 +367,8 @@ CurveBezier::CopyFrom( const CurveBezier& cbSrc)
 {
    if ( &cbSrc == this)
       return true ;
-   if ( ! cbSrc.IsValid())
-      return false ;
    if ( ! Init( cbSrc.m_nDeg, cbSrc.m_bRat))
       return false ;
-   m_dParSing = cbSrc.m_dParSing ;
    m_vPtCtrl = cbSrc.m_vPtCtrl ;
    if ( cbSrc.m_bRat)
       m_vWeCtrl = cbSrc.m_vWeCtrl ;
@@ -525,21 +516,21 @@ bool
 CurveBezier::Validate( void)
 {
    if ( m_nStatus == TO_VERIFY) {
-         for ( const auto& ptP : m_vPtCtrl) {
-            if ( ! ptP.IsValid()) {
-               m_nStatus = ERR ;
-               break ;
-            }
+      for ( const auto& ptP : m_vPtCtrl) {
+         if ( ! ptP.IsValid()) {
+            m_nStatus = ERR ;
+            break ;
          }
       }
+   }
    if ( m_nStatus == TO_VERIFY) {
-         for ( const auto& dWe : m_vWeCtrl) {
-            if ( ! isfinite( dWe)) {
-               m_nStatus = ERR ;
-               break ;
-            }
+      for ( const auto& dWe : m_vWeCtrl) {
+         if ( ! isfinite( dWe)) {
+            m_nStatus = ERR ;
+            break ;
          }
       }
+   }
    if ( m_nStatus == TO_VERIFY)
       m_nStatus = ( ( m_nDeg >= 1  &&  m_vPtCtrl.size() >= 2) ? OK : ERR) ;
 
@@ -1666,10 +1657,6 @@ CurveBezier::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAngTo
 ICurve*
 CurveBezier::CopyParamRange( double dUStart, double dUEnd) const
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return nullptr ;
-
   // i parametri start ed end devono essere compresi nel dominio parametrico della curva
    if ( dUStart < - EPS_PARAM  ||  dUStart > 1 + EPS_PARAM  ||
         dUEnd < - EPS_PARAM  ||  dUEnd > 1 + EPS_PARAM)
@@ -1812,10 +1799,6 @@ CurveBezier::TrimEndAtParam( double dUTrim)
 bool
 CurveBezier::TrimStartEndAtParam( double dUStartTrim, double dUEndTrim)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
   // i parametri start ed end devono essere compresi nel dominio parametrico della curva
    if ( dUStartTrim < - EPS_PARAM  ||  dUStartTrim > 1 + EPS_PARAM  ||
         dUEndTrim < - EPS_PARAM  ||  dUEndTrim > 1 + EPS_PARAM)
@@ -1825,19 +1808,19 @@ CurveBezier::TrimStartEndAtParam( double dUStartTrim, double dUEndTrim)
       return false ;
    // se razionale devo trovare il punto di trim iniziale per ricalcolare il parametro di trim
    Point3d ptStart ;
-   if ( m_bRat)
+   if( m_bRat)
       GetPointD1D2( dUStartTrim, ptStart) ;
   // trim finale
    if ( ! TrimEndAtParam( dUEndTrim))
       return false ;
   // trim iniziale con il parametro opportunamente ricalcolato
    double dNewUStartTrim ;
-   if ( m_bRat)
+   if( m_bRat)
       GetParamAtPoint( ptStart, dNewUStartTrim) ;
    else
       dNewUStartTrim = dUStartTrim / dUEndTrim ;
    //trim iniziale
-   if ( ! TrimStartAtParam( dNewUStartTrim))
+   if( ! TrimStartAtParam( dNewUStartTrim))
       return false ;
 
    return true ;
@@ -1847,10 +1830,6 @@ CurveBezier::TrimStartEndAtParam( double dUStartTrim, double dUEndTrim)
 bool
 CurveBezier::TrimStartAtLen( double dLenTrim)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
   // lunghezze negative vengono considerate nulle
    dLenTrim = max( dLenTrim, 0.) ;
 
@@ -1860,7 +1839,7 @@ CurveBezier::TrimStartAtLen( double dLenTrim)
       return false ;
 
   // utilizzo il trim sui parametri
-   if ( ! TrimStartAtParam( dUTrim))
+   if( ! TrimStartAtParam( dUTrim))
       return false ;
 
    return true ;
@@ -1870,10 +1849,6 @@ CurveBezier::TrimStartAtLen( double dLenTrim)
 bool
 CurveBezier::TrimEndAtLen( double dLenTrim)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
   // lunghezze negative vengono considerate nulle
    dLenTrim = max( dLenTrim, 0.) ;
 
@@ -1883,7 +1858,7 @@ CurveBezier::TrimEndAtLen( double dLenTrim)
       return false ;
 
   // utilizzo il trim sui parametri
-   if ( ! TrimEndAtParam( dUTrim))
+   if( ! TrimEndAtParam( dUTrim))
       return false ;
 
    return true ;
@@ -1893,10 +1868,6 @@ CurveBezier::TrimEndAtLen( double dLenTrim)
 bool
 CurveBezier::ExtendStartByLen( double dLenExt)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
   // la lunghezza deve essere positiva
    if ( dLenExt < - EPS_ZERO)
       return false ;
@@ -1948,10 +1919,6 @@ CurveBezier::ExtendStartByLen( double dLenExt)
 bool
 CurveBezier::ExtendEndByLen( double dLenExt)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
   // la lunghezza deve essere positiva
    if ( dLenExt < - EPS_ZERO)
       return false ;
@@ -2291,10 +2258,6 @@ CurveBezier::ResetVoronoiObject() const
 bool
 CurveBezier::MakeRational( void)
 { 
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-   
    if ( m_bRat)
       return true ;
    // creo il vettore dei pesi e li setto tutti a 1
@@ -2309,23 +2272,19 @@ CurveBezier::MakeRational( void)
 bool
 CurveBezier::MakeRationalStandardForm( void)
 { 
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-   
    if ( ! m_bRat)
       return false ;
-   double dW0 = m_vWeCtrl.front() ;
+   double dW0 = m_vWeCtrl[0] ;
    double dWn = m_vWeCtrl.back() ;
-   if ( dW0 > 1 - EPS_ZERO  &&  dWn > 1 - EPS_ZERO)
+   if( dW0 > 1- EPS_ZERO  &&  dWn > 1 - EPS_ZERO)
       return true ;
-   if ( dW0 < EPS_ZERO  ||  dWn < EPS_ZERO)
+   if( dW0 < EPS_ZERO  ||  dWn < EPS_ZERO)
       return false ;
 
-  // formula del Farin
+   // formula del Farin
    double dCoeff = pow( dW0 / dWn, 1. / m_nDeg) ;
    for ( int i = 0 ; i < m_nDeg + 1 ; ++i)
-      m_vWeCtrl[i] *= Pow( dCoeff, i) / dW0 ;
+      m_vWeCtrl[i] *= pow( dCoeff, i) / dW0 ;
 
    return true ;
 }
@@ -2334,17 +2293,13 @@ CurveBezier::MakeRationalStandardForm( void)
 bool
 CurveBezier::MakeNonRational( double dTol)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-   
-   if ( ! m_bRat)
+   if( ! m_bRat)
       return true ;
 
    // controllo se i pesi sono tutti == 1 allora è una finta razionale e mi basta fare una copia dei punti di controllo
    bool bIsActualRat = false ;
    for ( int i = 0 ; i < m_nDeg ; ++i) {
-      if ( abs( m_vWeCtrl[i] - 1) > EPS_SMALL) {
+      if ( abs(m_vWeCtrl[i] - 1) > EPS_SMALL) {
          bIsActualRat = true ;
          break ;
       }
@@ -2352,44 +2307,15 @@ CurveBezier::MakeNonRational( double dTol)
 
    bool bOk = true ;
    if ( ! bIsActualRat) {
-      // semplicemente tolgo il booleano della razionalità e i punti restano gli stessi
-      m_bRat = false ;
+      PtrOwner<CurveBezier> pNewBez( CreateBasicCurveBezier()) ;
+      for ( int p = 0 ; p < m_nDeg ; ++p) {
+         Point3d pt = GetControlPoint( p) ;
+         pNewBez->SetControlPoint( p, pt) ;
+      }
    }
    else {
       // provo ad approssimare la curva di bezier con una controparte non razionale
       int nDeg = m_nDeg ;
-      // se ho una curva razionale di grado 2 verifico se è un arco, in quel caso la converto in una curva di grado 3 non razionale con la funzione dedicata
-      if ( nDeg == 2  &&  m_bRat) {
-         // prendo due punti sulla curva e calcolo l'intersezione dei due assi dei segmenti formati da pt2-pt0 e pt3-pt1
-         Point3d pt0 ; GetStartPoint( pt0) ;
-         Point3d pt1 ; GetPointD1D2( 0.3, pt1) ;
-         Point3d pt2 ; GetPointD1D2( 0.6, pt2) ;
-         Point3d pt3 ; GetEndPoint( pt3) ;
-
-         Vector3d vtDir1 = pt2 - pt0 ;
-         Vector3d vtDir2 = pt3 - pt1 ;
-         Vector3d vtN = vtDir2 ^ vtDir1 ;
-
-         CurveLine cl1 ; cl1.Set( pt1, pt1 + (vtDir1 ^ vtN) * 5) ;
-         CurveLine cl2 ; cl1.Set( pt2, pt2 + (vtDir2 ^ vtN) * 5) ;
-         IntersLineLine ill( cl1, cl2, false) ;
-         IntCrvCrvInfo iccInfo ; ill.GetIntCrvCrvInfo( iccInfo) ;
-         Point3d ptCen = iccInfo.IciA[0].ptI ;
-         
-         // se sia l'inizio che la fine della curva distano uguale dal punto di intersezione tra i due assi trovati allora la curva è un arco di circonferenza
-         if ( abs(Dist( pt0, ptCen) - Dist( pt3, ptCen)) < EPS_SMALL) {
-            PtrOwner<ICurveBezier> pNew ( ApproxArcCurveBezierWithSingleCubic( this, ptCen, vtN)) ;
-
-            if ( IsNull( pNew)  ||  ! pNew->IsValid())
-               return false ;
-            Init( 3, false) ;
-            for ( int i = 0 ; i < 3 ; ++i)
-               SetControlPoint( i, pNew->GetControlPoint(i)) ;
-
-            return true ;
-         }
-      }
-
       // punto di rientro in caso fallisca il primo tentativo
       retry :
          nDeg += 2 ;
@@ -2397,8 +2323,8 @@ CurveBezier::MakeNonRational( double dTol)
          pNewBez->Init( nDeg, false) ;
          PNTVECTOR vPntCtrl ;
          PNTVECTOR vPntSampling ;
-         for ( int p = 0 ; p < nDeg + 1 ; ++p) {
-            Point3d pt ; GetPointD1D2( double( p) / nDeg, pt) ;
+         for ( int p = 0 ; p < nDeg + 1; ++p) {
+            Point3d pt ; GetPointD1D2( double(p) / nDeg, pt) ;
             pNewBez->SetControlPoint( p, pt) ;
             vPntCtrl.push_back( pt) ;
          }
@@ -2408,11 +2334,11 @@ CurveBezier::MakeNonRational( double dTol)
          while ( dErr > dTol  &&  c < 100) {
             double dErrMax = 0 ;
             // calcolo le differenze tra i punti di sampling sulla nuova curva e quelli sulla curva originale
-            for ( int p = 0 ; p < nDeg + 1 ; ++p) {
-               Point3d pt ; pNewBez->GetPointD1D2( double( p) / nDeg, pt) ;
+            for ( int p = 0 ; p < nDeg + 1; ++p) {
+               Point3d pt ; pNewBez->GetPointD1D2( double(p) / nDeg, pt) ;
                Vector3d vDiff = vPntSampling[p] - pt ;
                double dErrLoc = vDiff.Len() ;
-               if ( dErrLoc > dErrMax)
+               if( dErrLoc > dErrMax)
                   dErrMax = dErrLoc ;
                // aggiorno il vettore dei punti di controllo della nuova curva
                vPntCtrl[p] += vDiff ;
@@ -2425,17 +2351,17 @@ CurveBezier::MakeNonRational( double dTol)
          }
 
          // calcolo l'errore di approssimazione sulla curva
-         CalcApproxError( this, pNewBez, dErr) ;
+         CalcBezierApproxError( this, pNewBez, dErr) ;
          bOk = dErr < dTol ;
-         if ( bOk) {
+         if( bOk) {
             // aggiorno la curva di bezier originale con quella approssimata
             Init( nDeg, false) ;
-            for ( int i = 0 ; i < nDeg + 1 ; ++i) {
+            for( int i = 0 ; i < nDeg + 1 ; ++i) {
                SetControlPoint( i, pNewBez->GetControlPoint( i)) ;
                SetControlWeight( i, pNewBez->GetControlWeight( i)) ;
             }
          }
-         else if ( nDeg < m_nDeg + 4)
+         else if( nDeg < m_nDeg + 4)
             goto retry ;
    }
 
@@ -2446,17 +2372,13 @@ CurveBezier::MakeNonRational( double dTol)
 bool
 CurveBezier::IsALine( void) const
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-   
    Point3d ptStart ; GetStartPoint( ptStart) ;
    Point3d ptEnd ; GetEndPoint( ptEnd) ;
    for ( int i = 1 ; i < m_nDeg ; ++i) {
       Point3d ptCtrl = GetControlPoint( i) ;
       DistPointLine dpl( ptCtrl, ptStart, ptEnd) ;
       double dDist = 0 ; dpl.GetDist( dDist) ;
-      if ( dDist > EPS_SMALL)
+      if( dDist > EPS_SMALL)
          return false ;
    }
    return true ;
@@ -2466,10 +2388,6 @@ CurveBezier::IsALine( void) const
 PNTVECTOR
 CurveBezier::GetAllControlPoints( void) const
 {
-   PNTVECTOR vPntCtrl ;
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return vPntCtrl ;
-   
-   return m_vPtCtrl ;
+   PNTVECTOR vPntCtrl = m_vPtCtrl ;
+   return vPntCtrl ;
 }

CurveBezier.h

@@ -116,7 +116,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
               { return ApproxWithArcs( dLinTol, dAngTolDeg, PA) ; }
       ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
       bool Invert( void) override ;
-      bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) override
+      bool SimpleOffset( double dDist, int nType = OFF_FILLET) override
               { return false ; }  // l'offset di crvBezier non è crvBezier tranne in casi molto particolari
       bool ModifyStart( const Point3d& ptNewStart) override ;
       bool ModifyEnd( const Point3d& ptNewEnd) override ;

CurveByInterp.cpp

@@ -55,7 +55,7 @@ CurveByInterp::GetCurve( int nMethod, int nType)
       if ( ! CalcBesselTangents())
          return nullptr ;
    }
-   else if ( nType != CUBIC_BEZIERS_LONG) {
+   else {
       if ( ! CalcAkimaTangents( nMethod == AKIMA_CORNER))
          return nullptr ;
    }
@@ -103,16 +103,6 @@ CurveByInterp::GetCurve( int nMethod, int nType)
       return ::Release( pCrvCompo) ;
    }
 
-   // se richieste curve di Bezier cubiche (ottenute da interpolazione con Nurbs)
-   if ( nType == CUBIC_BEZIERS_LONG) {
-       // creo la curva composita
-       PtrOwner<ICurve> pCrv ;
-       pCrv.Set( InterpolatePointSetWithBezier( m_vPnt, 50 * EPS_SMALL, 50)) ;
-       if ( IsNull(pCrv)  ||  ! pCrv->IsValid())
-          return nullptr ;
-       return Release( pCrv) ;
-   }
-
    return nullptr ;
 }
 

CurveComposite.cpp

@@ -381,10 +381,9 @@ CurveComposite::FromPolyLine( const PolyLine& PL)
       return false ;
 
   // ciclo di inserimento dei segmenti che uniscono i punti
-   double dParIni, dParFin ;
    Point3d ptIni, ptFin ;
-   PL.GetFirstUPoint( &dParIni, &ptIni) ;
-   while ( PL.GetNextUPoint( &dParFin, &ptFin)) {
+   PL.GetFirstPoint( ptIni) ;
+   while ( PL.GetNextPoint( ptFin)) {
      // se i punti della coppia coincidono, passo alla coppia successiva
       if ( AreSamePointApprox( ptIni, ptFin))
          continue ;
@@ -395,14 +394,10 @@ CurveComposite::FromPolyLine( const PolyLine& PL)
      // assegno i punti estremi
       if ( ! pCrvLine->Set( ptIni, ptFin))
          return false ;
-     // assegno i parametri degli estremi
-      pCrvLine->SetTempParam( dParIni, 0) ;
-      pCrvLine->SetTempParam( dParFin, 1) ;
      // aggiungo la retta alla curva composita
       if ( ! AddSimpleCurve( Release( pCrvLine)))
          return false ;
      // aggiorno dati prossimo punto iniziale
-      dParIni = dParFin ;
       ptIni = ptFin ;
    }
 
@@ -889,21 +884,14 @@ CurveComposite::Validate( void)
 
 //----------------------------------------------------------------------------
 bool
-CurveComposite::TestClosure( double dLinTol)
+CurveComposite::TestClosure( void)
 {
-  // se non valida o vuota, esco subito
-   if ( m_nStatus != OK  ||  m_CrvSmplS.empty())
-      return true ;
-  // se non è chiusa entro la tolleranza, esco subito
-   Point3d ptStart, ptEnd ;
-   if ( ! m_CrvSmplS.front()->GetStartPoint( ptStart)  ||
-        ! m_CrvSmplS.back()->GetEndPoint( ptEnd)  ||
-        ! AreSamePointEpsilon( ptStart, ptEnd, dLinTol))
-      return true ;
-  // se singola retta, esco subito
-   if ( m_CrvSmplS.size() == 1  &&  m_CrvSmplS.front()->GetType() == CRV_LINE)
+  // se non è chiusa, esco subito
+   if ( ! IsClosed())
       return true ;
   // verifico ed eventualmente aggiusto coincidenza punti estremi
+   Point3d ptStart ; m_CrvSmplS.front()->GetStartPoint( ptStart) ;
+   Point3d ptEnd ; m_CrvSmplS.back()->GetEndPoint( ptEnd) ;
    // se distanza superiore al limite ridotto forzo i punti a coincidere
    if ( ! AreSamePointEpsilon( ptStart, ptEnd, EPS_CONNECT)) {
      // se un solo arco
@@ -1714,7 +1702,7 @@ CurveComposite::Invert( void)
 
 //----------------------------------------------------------------------------
 bool
-CurveComposite::SimpleOffset( double dDist, int nType, double dMaxAngExt)
+CurveComposite::SimpleOffset( double dDist, int nType)
 {
   // se distanza di offset nulla, non devo fare alcunché
    if ( abs( dDist) < EPS_SMALL)
@@ -1736,7 +1724,7 @@ CurveComposite::SimpleOffset( double dDist, int nType, double dMaxAngExt)
    }
 
   // eseguo l'offset nel piano XY
-   bool bOk = SimpleOffsetXY( dDist, nType, dMaxAngExt) ;
+   bool bOk = SimpleOffsetXY( dDist, nType) ;
 
   // riporto la curva nel riferimento originale
    if ( bNeedRef)
@@ -3053,7 +3041,7 @@ CurveComposite::ArcsToBezierCurves( void)
      // se arco, devo trasformare in una o più curve di Bezier
       if ( (*Iter)->GetType() == CRV_ARC) {
         // eseguo trasformazione
-         PtrOwner<ICurve> pNewCrv( ArcToBezierCurve( GetCurveArc( *Iter))) ;
+         PtrOwner<ICurve> pNewCrv( ArcToBezierCurve( (*Iter))) ;
          if ( IsNull( pNewCrv))
             return false ;
         // se risultato è singola curva

CurveComposite.h

@@ -113,7 +113,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) const override ;
       ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
       bool Invert( void) override ;
-      bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) override ;
+      bool SimpleOffset( double dDist, int nType = OFF_FILLET) override ;
       bool ModifyStart( const Point3d& ptNewStart) override ;
       bool ModifyEnd( const Point3d& ptNewEnd) override ;
       bool SetExtrusion( const Vector3d& vtExtr) override
@@ -198,17 +198,17 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
                        return *this ; }
       bool RelocateFrom( CurveComposite& ccSrc) ;
       bool GetApproxLength( double& dLen) const ;
-      bool TestClosure( double dLinTol = EPS_SMALL) ;
       Voronoi* GetVoronoiObject( void) const ;
       void ResetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveComposite& ccSrc) ;
       bool Validate( void) ;
+      bool TestClosure( void) ;
       bool AddCurveByRelocate( CurveComposite& ccSrc, bool bEndOrStart = true, double dLinTol = EPS_SMALL) ;
       bool AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart = true, double dLinTol = EPS_SMALL) ;
       bool GetIndSCurveAndLocPar( double dU, Side nS, int& nSCrv, double& dLocU) const ;
-      bool SimpleOffsetXY( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) ;
+      bool SimpleOffsetXY( double dDist, int nType = OFF_FILLET) ;
       bool IsOneCircle( Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const ;      
       bool CalcVoronoiObject( void) const ;
 

CurveCompositeOffset.cpp

@@ -19,7 +19,6 @@
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkIntersCurves.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;
@@ -31,14 +30,14 @@ static const int TP_IS_VERT_LINE = 1 ;
 static bool IsVerticalLine( const ICurve* pCrv, double* pdLenZ) ;
 static bool VerifyAndAdjustSamePoint( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAux) ;
 static bool VerifyAndAdjustInternalAngle( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAux) ;
-static bool VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nType, double dMaxAngExt,
+static bool VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nType,
                                           CurveComposite& ccAux) ;
 static bool AddFirstLastVerticalLines( CurveComposite& ccOffs, double dLenVertFirst, double dLenVertLast) ;
 static bool MediaInternalAngleDeltaZ( CurveComposite& ccOffs) ;
 
 //----------------------------------------------------------------------------
 bool
-CurveComposite::SimpleOffsetXY( double dDist, int nType, double dMaxAngExt)
+CurveComposite::SimpleOffsetXY( double dDist, int nType)
 {
   // creo una copia formata solo da rette e archi che giacciono nel piano XY (VtExtr è Z+)
    CurveComposite ccCopy ;
@@ -99,7 +98,7 @@ CurveComposite::SimpleOffsetXY( double dDist, int nType, double dMaxAngExt)
       CurveComposite ccTemp ;
       if ( VerifyAndAdjustSamePoint( pCrvPrev, pCrv2, ccTemp)  ||
            VerifyAndAdjustInternalAngle( pCrvPrev, pCrv2, ccTemp)  ||
-           VerifyAndAdjustExternalAngle( pCrvPrev, pCrv2, dDist, nType, dMaxAngExt, ccTemp)) {
+           VerifyAndAdjustExternalAngle( pCrvPrev, pCrv2, dDist, nType, ccTemp)) {
          if ( ccTemp.GetCurveCount() > 0  &&  ! ccOffs.AddCurveByRelocate( ccTemp))
             return false ;
       }
@@ -123,7 +122,7 @@ CurveComposite::SimpleOffsetXY( double dDist, int nType, double dMaxAngExt)
       CurveComposite ccTemp ;
       if ( VerifyAndAdjustSamePoint( pCrvPrev, pCrvNext, ccTemp)  ||
            VerifyAndAdjustInternalAngle( pCrvPrev, pCrvNext, ccTemp)  ||
-           VerifyAndAdjustExternalAngle( pCrvPrev, pCrvNext, dDist, nType, dMaxAngExt, ccTemp)) {
+           VerifyAndAdjustExternalAngle( pCrvPrev, pCrvNext, dDist, nType, ccTemp)) {
          int nCrvCount = ccTemp.GetCurveCount() ;
          if ( nCrvCount > 0  &&  ! ccOffs.AddCurveByRelocate( ccTemp))
             return false ;
@@ -175,7 +174,7 @@ bool
 VerifyAndAdjustSamePoint( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAux)
 {
   // verifica dei puntatori
-   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr)
+   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr  ||  &ccAux == nullptr)
       return false ;
 
   // pulisco la curva ausiliaria
@@ -219,7 +218,7 @@ bool
 VerifyAndAdjustInternalAngle( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAux)
 {
   // verifica dei puntatori
-   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr)
+   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr  ||  &ccAux == nullptr)
       return false ;
 
   // pulisco la curva ausiliaria
@@ -260,11 +259,11 @@ VerifyAndAdjustInternalAngle( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAu
 
 //----------------------------------------------------------------------------
 bool
-VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nType, double dMaxAngExt,
+VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nType,
                               CurveComposite& ccAux)
 {
   // verifica dei puntatori
-   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr)
+   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr  ||  &ccAux == nullptr)
       return false ;
 
   // pulisco la curva ausiliaria
@@ -273,9 +272,6 @@ VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nT
   // elimino dal tipo le parti estranee all'angolo esterno
    nType &= ( ICurve::OFF_FILLET | ICurve::OFF_CHAMFER | ICurve::OFF_EXTEND) ;
 
-  // porto il massimo angolo per tipo Extend in limiti accettabili (90° - 150°)
-   dMaxAngExt = Clamp( dMaxAngExt, ANG_RIGHT, 1.667 * ANG_RIGHT) ;
-
   // calcolo direzioni tangenti sull'estremo in comune
    Vector3d vtDir1, vtDir2 ;
    if ( ! pCrv1->GetEndDir( vtDir1)  ||  ! pCrv2->GetStartDir( vtDir2))
@@ -323,8 +319,8 @@ VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nT
           ( dDist > 0  &&  dAngDeg < 0)))
       return false ;
 
-  // se l'angolo esterno supera il limite, offset extend diventa offset chamfer
-   if ( nType == ICurve::OFF_EXTEND  &&  abs( dAngDeg) > dMaxAngExt + EPS_ANG_SMALL)
+  // se l'angolo esterno supera il retto, offset extend diventa offset chamfer
+   if ( nType == ICurve::OFF_EXTEND  &&  abs( dAngDeg) > ANG_RIGHT + EPS_ANG_SMALL)
       nType = ICurve::OFF_CHAMFER ;
 
   // se angolo esterno molto piccolo, semplifico tutto

CurveLine.cpp

@@ -577,7 +577,7 @@ CurveLine::Invert( void)
 
 //----------------------------------------------------------------------------
 bool
-CurveLine::SimpleOffset( double dDist, int nType, double dMaxAngExt)
+CurveLine::SimpleOffset( double dDist, int nType)
 {
   // verifico lo stato
    if ( m_nStatus != OK)

CurveLine.h

@@ -117,7 +117,7 @@ class CurveLine : public ICurveLine, public IGeoObjRW
               { return ApproxWithArcs( dLinTol, dAngTolDeg, PA) ; }
       ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
       bool Invert( void) override ;
-      bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) override ;
+      bool SimpleOffset( double dDist, int nType = OFF_FILLET) override ;
       bool ModifyStart( const Point3d& ptNewStart) override ;
       bool ModifyEnd( const Point3d& ptNewEnd) override ;
       bool SetExtrusion( const Vector3d& vtExtr) override

DistPointSurfBz.cpp

@@ -1,119 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025
-//----------------------------------------------------------------------------
-// File : DistPointSurfBz.cpp     Data : 29.10.25        Versione : 2.7j3
-// Contenuto : Implementazione della classe distanza Punto da superficie Bezier.
-//
-//
-//
-// Modifiche : 29.10.25 DB Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#include "stdafx.h"
-#include "SurfTriMesh.h"
-#include "SurfBezier.h"
-#include "/EgtDev/Include/EGkDistPointTria.h"
-#include "/EgtDev/Include/EGkDistPointSurfTm.h"
-#include "/EgtDev/Include/EGkDistPointSurfBz.h"
-#include "/EgtDev/Include/EGkIntersLineTria.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-DistPointSurfBz::DistPointSurfBz( const Point3d& ptP, const ISurfBezier& pSrfBz)
-   : m_dDist( -1), m_bIsInside( false)
-{
-  // Bezier non valida 
-   if ( &pSrfBz == nullptr  ||  ! pSrfBz.IsValid())
-      return ;
-  // Calcolo la distanza
-   Calculate( ptP, pSrfBz) ;
-}
-
-//----------------------------------------------------------------------------
-void 
-DistPointSurfBz::Calculate( const Point3d& ptP, const ISurfBezier& srfBz)
-{
-  // Inizializzo distanza non calcolata
-   m_dDist = - 1. ;
-
-  // Controllo se la superficie è chiusa
-   m_bIsSurfClosed = srfBz.IsClosed() ;
-
-  // Lavoro con l'oggetto superficie trimesh di base
-   const ISurfTriMesh* pStmRef = srfBz.GetAuxSurfRefined() ;
-   if ( pStmRef == nullptr)
-      return ;
-
-   DistPointSurfTm dpst( ptP, *pStmRef) ;
-
-  //recupero il punto a distanza minima sulla trimesh e lo raffino, prima di restituire distanza e punto minimo
-   Point3d ptMinTm ; dpst.GetMinDistPoint( ptMinTm) ;
-   int nT ; dpst.GetMinDistTriaIndex( nT) ;
-  //salvo il punto corrispondente nel parametrico
-   srfBz.UnprojectPointFromStm( nT, ptMinTm, m_ptParam)  ;
-  // salvo il punto a minima distanza sulla superficie e la normale alla superficie in quel punto
-   srfBz.GetPointNrmD1D2( m_ptParam.x, m_ptParam.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, m_ptMinDistPoint, m_vtN)  ;
-
-  // salvo la distanza minima
-   m_dDist = Dist( ptP, m_ptMinDistPoint) ;
-  // se il punto è sulla superficie
-   if ( m_dDist < EPS_SMALL) {
-      m_bIsInside = false ;
-      return ;
-   }
-   else {
-      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * m_vtN < - EPS_SMALL) ;
-      return ;
-   }
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfBz::GetDist( double& dDist) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   dDist = m_dDist ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-DistPointSurfBz::GetMinDistPoint( Point3d& ptMinDistPoint) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   ptMinDistPoint = m_ptMinDistPoint ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-DistPointSurfBz::GetParamPoint( Point3d& ptParamPoint) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   ptParamPoint = m_ptParam ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-DistPointSurfBz::GetNorm( Vector3d& vtN) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   vtN = m_vtN ;
-   return true ;
-}

DistPointSurfTm.cpp

@@ -94,8 +94,6 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
 {
   // Inizializzo distanza non calcolata
    m_dDist = - 1. ;
-  // Vettore di indici dei triangoli più vicini inizialmente vuoto
-   m_vnMinDistTriaIndex.clear() ;
   // Controllo se la superficie è chiusa
    m_bIsSurfClosed = tmSurf.IsClosed() ;
 
@@ -186,10 +184,6 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
    if ( nMinDistTriaIndex == SVT_NULL)
       return ;
 
-  // Inizializzo il vettore dei triangoli a minima distanza
-   for ( auto& Tria : vTria)
-      m_vnMinDistTriaIndex.emplace_back( Tria.first) ;
-
   // salvo la distanza minima
    m_dDist = dMinDist ;
   // salvo il punto a distanza minima
@@ -285,18 +279,6 @@ DistPointSurfTm::GetMinDistTriaIndex( int& nMinDistIndex) const
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-DistPointSurfTm::GetMinDistTriaIndices( INTVECTOR& vMinDistTriaIndex) const
-{
-  // Distanza non valida
-   if ( m_dDist < - EPS_ZERO)
-      return false ;
-  // Distanza valida
-   vMinDistTriaIndex = m_vnMinDistTriaIndex ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 int
 GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf)

EGkDllMain.cpp

@@ -159,20 +159,11 @@ InitFontManager( const string& sNfeFontDir, const string& sDefaultFont)
 {
   // recupero il font manager
    FontManager& fntMgr = FontManager::GetFontManager() ;
+
   // lo inizializzo
    fntMgr.Init( sNfeFontDir, sDefaultFont) ;
 }
 
-//-----------------------------------------------------------------------------
-void
-SetDefaultFont( const string& sDefaultFont)
-{
-  // recupero il font manager
-   FontManager& fntMgr = FontManager::GetFontManager() ;
-  // imposto il dato
-   fntMgr.SetDefaultFont( sDefaultFont) ;
-}
-
 //-----------------------------------------------------------------------------
 const string&
 GetNfeFontDir( void)
@@ -194,11 +185,11 @@ GetDefaultFont( void)
 }
 
 //-----------------------------------------------------------------------------
-static psfProcEvents s_pFunProcEvents = nullptr ;
+static pfProcEvents s_pFunProcEvents = nullptr ;
 
 //-----------------------------------------------------------------------------
 bool
-SetEGkProcessEvents( psfProcEvents pFun)
+SetEGkProcessEvents( pfProcEvents pFun)
 {
    s_pFunProcEvents = pFun ;
    return ( pFun != nullptr) ;

EgtGeomKernel.vcxproj

@@ -116,7 +116,7 @@
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <EnablePREfast>false</EnablePREfast>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -151,7 +151,7 @@ copy $(TargetPath) \EgtProg\DllD32</Command>
       <MinimalRebuild>false</MinimalRebuild>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
       <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
     </ClCompile>
     <Link>
@@ -199,7 +199,7 @@ copy $(TargetPath) \EgtProg\DllD64</Command>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <WholeProgramOptimization>false</WholeProgramOptimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -245,7 +245,7 @@ copy $(TargetPath) \EgtProg\Dll32</Command>
       <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
       <WholeProgramOptimization>false</WholeProgramOptimization>
       <DebugInformationFormat>None</DebugInformationFormat>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
       <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
       <IntelJCCErratum>true</IntelJCCErratum>
     </ClCompile>
@@ -310,9 +310,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="CurveByApprox.cpp" />
     <ClCompile Include="CurveByInterp.cpp" />
     <ClCompile Include="CurveCompositeOffset.cpp" />
-    <ClCompile Include="DistPointSurfBz.cpp" />
     <ClCompile Include="DistPointSurfFr.cpp" />
-    <ClCompile Include="IntersCurvePlane.cpp" />
     <ClCompile Include="IntersCurveSurfTm.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
@@ -322,8 +320,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="IntersLineVolZmap.cpp" />
     <ClCompile Include="IntersPlaneVolZmap.cpp" />
     <ClCompile Include="IntersLineSurfBez.cpp" />
-    <ClCompile Include="Trimming.cpp" />
-    <ClCompile Include="MultiGeomDB.cpp" />
     <ClCompile Include="SurfTriMeshOffset.cpp" />
     <ClCompile Include="VolZmapOffset.cpp" />
     <ClCompile Include="PolygonElevation.cpp" />
@@ -344,7 +340,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkIntersLineVolZmap.h" />
     <ClInclude Include="..\Include\EGkIntersPlaneBox.h" />
     <ClInclude Include="..\Include\EGkIntersPlaneVolZmap.h" />
-    <ClInclude Include="..\Include\EGkMultiGeomDB.h" />
     <ClInclude Include="..\Include\EGkPolygonElevation.h" />
     <ClInclude Include="..\Include\EGkQuaternion.h" />
     <ClInclude Include="..\Include\EGkRotationMinimizingFrame.h" />

EgtGeomKernel.vcxproj.filters

@@ -55,9 +55,6 @@
     <Filter Include="File di origine\GeoCollisionDetection">
       <UniqueIdentifier>{865b76ee-b10d-41fc-861c-b48ce52fa277}</UniqueIdentifier>
     </Filter>
-    <Filter Include="File di origine\GeoStriping">
-      <UniqueIdentifier>{54901321-08f6-4428-80c7-a1f859136a32}</UniqueIdentifier>
-    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Vector3d.cpp">
@@ -555,18 +552,6 @@
     <ClCompile Include="SurfTriMeshOffset.cpp">
       <Filter>File di origine\GeoOffset</Filter>
     </ClCompile>
-    <ClCompile Include="MultiGeomDB.cpp">
-      <Filter>File di origine\Gdb</Filter>
-    </ClCompile>
-    <ClCompile Include="DistPointSurfBz.cpp">
-      <Filter>File di origine\GeoDist</Filter>
-    </ClCompile>
-    <ClCompile Include="IntersCurvePlane.cpp">
-      <Filter>File di origine\GeoInters</Filter>
-    </ClCompile>
-    <ClCompile Include="Trimming.cpp">
-      <Filter>File di origine\GeoStriping</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="stdafx.h">
@@ -1250,9 +1235,6 @@
     <ClInclude Include="..\Include\EGkSurfTriMeshAux.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
-    <ClInclude Include="..\Include\EGkMultiGeomDB.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtGeomKernel.rc">

ExtDimension.cpp

@@ -1087,7 +1087,7 @@ ExtDimension::Update( void) const
          if ( m_nType == DT_RADIAL)
             sVal = "R " + sVal ;
          else if ( m_nType == DT_DIAMETRAL)
-            sVal = reinterpret_cast<const char *>( u8"\u00D8") + sVal ;
+            sVal = u8"\u00D8 " + sVal ;
          ReplaceString( m_sCalcText, IS_MEASURE, sVal) ;
       }
      // punto di inserimento del testo

FontManager.h

@@ -29,8 +29,6 @@ class FontManager
 
    public :
       bool Init( const std::string& sNfeFontDir, const std::string& sDefaultFont) ;
-      bool SetDefaultFont( const std::string& sDefaultFont)
-               { m_sDefaultFont = sDefaultFont ; return true ; }
       bool SetCurrFont( const std::string& sFont, int nWeight, bool bItalic,
                         double dHeight, double dRatio, double dAddAdvance) ;
       const std::string& GetNfeFontDir( void) const
@@ -56,7 +54,7 @@ class FontManager
       OsFont      m_OsFont ;
 
    private :
-      FontManager( void) : m_bCurrNfeFont( false)  {}
+      FontManager( void) {}
       FontManager( FontManager const& copy) = delete ;
       FontManager& operator=( FontManager const& copy) = delete ;
 } ;

GdbGeo.cpp

@@ -336,7 +336,7 @@ GdbGeo::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoe
         // curva originale
          ICurve* pCrv = GetCurve( m_pGeoObj) ;
         // trasformo in curva di Bezier (semplice o composta)
-         ICurve* pCrvNew = ArcToBezierCurve( GetCurveArc( pCrv)) ;
+         ICurve* pCrvNew = ArcToBezierCurve( pCrv) ;
          if ( pCrvNew == nullptr)
             return false ;
         // assegno alla nuova curva estrusione e spessore di quella originale
@@ -389,7 +389,7 @@ GdbGeo::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDi
       if ( ! pArc->IsPlane()  ||
            ! AreSameOrOppositeVectorExact( pArc->GetNormVersor(), vtNorm)) {
         // trasformo in curva di Bezier (semplice o composta)
-         ICurve* pCrvNew = ArcToBezierCurve( GetCurveArc( m_pGeoObj)) ;
+         ICurve* pCrvNew = ArcToBezierCurve( GetCurve( m_pGeoObj)) ;
          if ( pCrvNew == nullptr)
             return false ;
         // assegno alla nuova curva estrusione e spessore di quella originale

GdbObj.cpp

@@ -101,20 +101,6 @@ GdbObj::CopyFrom( const GdbObj* pSou)
    return ( CopyAttribsFrom( pSou) && CopyTextureDataFrom( pSou) && CopyUserObjFrom( pSou)) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-GdbObj::CopyStippleDataFrom( const GdbObj* pSou)
-{
-  // se l'oggetto sorgente non esiste
-   if ( pSou == nullptr)
-      return false ;
-  // copio stipple
-   m_nStpFactor = pSou->m_nStpFactor ;
-   m_nStpPattern = pSou->m_nStpPattern ;
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 GdbObj::CopyAttribsFrom( const GdbObj* pSou)

GdbObj.h

@@ -57,7 +57,6 @@ class GdbObj
       GdbObj( void) ;
       bool CopyFrom( const GdbObj* pSou) ;
       bool CopyAttribsFrom( const GdbObj* pSou) ;
-      bool CopyStippleDataFrom( const GdbObj* pSou) ;
       bool CopyTextureDataFrom( const GdbObj* pSou) ;
       bool CopyUserObjFrom( const GdbObj* pSou) ;
 

GeoObjFactory.h

@@ -28,6 +28,41 @@
 #define GEOOBJ_NGEIDTOTYPE( nNgeId)       GeoObjFactory::NgeIdToType( nNgeId)
 #define GEOOBJ_CREATE( nKey)              GeoObjFactory::Create( nKey)
 
+//----------------------------------------------------------------------------
+template <class T> 
+class GeoObjRegister
+{
+   public :
+      static bool DoRegister( int nKey, int nNgeId)
+         {  if ( ! GeoObjFactory::Register( nKey, NgeAscKeyW[nNgeId], nNgeId, Create))
+               return false ;
+            GetTypePrivate() = nKey ;
+            GetKeyPrivate() = NgeAscKeyW[nNgeId] ;
+            GetNgeIdPrivate() = nNgeId ;
+            return true ; }
+      static IGeoObj* Create( void) 
+         {  return new( std::nothrow) T ; }
+      static int GetType( void) 
+         { return GetTypePrivate() ; }
+      static const std::string& GetKey( void) 
+         { return GetKeyPrivate() ; }
+      static int GetNgeId( void) 
+         { return GetNgeIdPrivate() ; }
+
+   private :
+      GeoObjRegister( void)  {}
+      ~GeoObjRegister( void) {}
+      static int& GetTypePrivate( void) 
+         { static int  s_nType ;
+           return s_nType ; }
+      static std::string& GetKeyPrivate( void) 
+         { static std::string  s_sKey ;
+           return s_sKey ; }
+      static int& GetNgeIdPrivate( void) 
+         { static int  s_nNgeId ;
+           return s_nNgeId ; }
+} ;
+
 //----------------------------------------------------------------------------
 class GeoObjFactory
 {
@@ -82,38 +117,3 @@ class GeoObjFactory
          {  static CreatorMap s_CreatorMap ;
             return s_CreatorMap ; }
 } ;
-
-//----------------------------------------------------------------------------
-template <class T> 
-class GeoObjRegister
-{
-   public :
-      static bool DoRegister( int nKey, int nNgeId)
-         {  if ( ! GeoObjFactory::Register( nKey, NgeAscKeyW[nNgeId], nNgeId, Create))
-               return false ;
-            GetTypePrivate() = nKey ;
-            GetKeyPrivate() = NgeAscKeyW[nNgeId] ;
-            GetNgeIdPrivate() = nNgeId ;
-            return true ; }
-      static IGeoObj* Create( void) 
-         {  return new( std::nothrow) T ; }
-      static int GetType( void) 
-         { return GetTypePrivate() ; }
-      static const std::string& GetKey( void) 
-         { return GetKeyPrivate() ; }
-      static int GetNgeId( void) 
-         { return GetNgeIdPrivate() ; }
-
-   private :
-      GeoObjRegister( void)  {}
-      ~GeoObjRegister( void) {}
-      static int& GetTypePrivate( void) 
-         { static int  s_nType ;
-           return s_nType ; }
-      static std::string& GetKeyPrivate( void) 
-         { static std::string  s_sKey ;
-           return s_sKey ; }
-      static int& GetNgeIdPrivate( void) 
-         { static int  s_nNgeId ;
-           return s_nNgeId ; }
-} ;

GeomDB.cpp

@@ -38,22 +38,20 @@ using namespace std ;
 class LockAddErase
 {
    public :
-      LockAddErase( atomic_flag& bAddEraseOn, bool bUse = true)
-         : m_bAddEraseOn( bAddEraseOn), m_bUse( bUse)
+      LockAddErase(std::atomic_flag& bAddEraseOn, bool bUse = true): m_bAddEraseOn( bAddEraseOn), m_bUse( bUse)
          {  if ( ! m_bUse) return ;
-            while ( m_bAddEraseOn.test_and_set( memory_order_acquire)) {
-               m_bAddEraseOn.wait( true, memory_order_relaxed) ;
+            while ( m_bAddEraseOn.test_and_set()) {
+               this_thread::sleep_for( chrono::nanoseconds{ 1}) ;
             }
          } ;
 
       ~LockAddErase( void)
          {  if ( ! m_bUse) return ;
-            m_bAddEraseOn.clear( memory_order_release) ;
-            m_bAddEraseOn.notify_one() ;
+            m_bAddEraseOn.clear() ;
          } ;
 
    private :
-      atomic_flag& m_bAddEraseOn ;
+      std::atomic_flag& m_bAddEraseOn ;
       bool m_bUse ;
 } ;
 
@@ -613,7 +611,7 @@ GeomDB::GetGdbObj( int nId) const
   // radice
    else if ( nId == GDB_ID_ROOT)
       return &m_GrpRadix ;
-  // un nodo qualunque
+  // un nodo qualubque
    else
       return m_IdManager.FindObj( nId) ;
 }
@@ -660,7 +658,7 @@ GeomDB::InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bLo
           return false ;
    }
   // inserisco come figlio, in testa alla lista del padre
-   else if ( nSonBeforeAfter == GDB_FIRST_SON) {
+   else if ( nSonBeforeAfter == GDB_FIRST_SON){
       GdbGroup* pGroup = ::GetGdbGroup( pGRef) ;
       if ( pGroup == nullptr)
          return false ;
@@ -879,7 +877,7 @@ GeomDB::GetFirstNameInGroup( int nGroupId, const string& sName) const
      // se ha il nome o la parte iniziale di nome cercato
       string sObjName ;
       if ( pGdbO->GetName( sObjName)  &&  
-           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.rfind( sToFind, 0) == 0)))
+           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.find( sToFind) == 0)))
          return ( pGdbO->m_nId) ;
      // passo al successivo
       pGdbO = pGdbO->GetNext() ;
@@ -907,7 +905,7 @@ GeomDB::GetNextName( int nId, const string& sName) const
      // se ha il nome o la parte iniziale di nome cercato
       string sObjName ;
       if ( pGdbNext->GetName( sObjName)  &&  
-           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.rfind( sToFind, 0) == 0)))
+           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.find( sToFind) == 0)))
          return ( pGdbNext->m_nId) ;
      // passo al successivo
       pGdbNext = pGdbNext->GetNext() ;
@@ -935,7 +933,7 @@ GeomDB::GetLastNameInGroup( int nGroupId, const string& sName) const
      // se ha il nome o la parte iniziale di nome cercato
       string sObjName ;
       if ( pGdbO->GetName( sObjName)  &&  
-           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.rfind( sToFind, 0) == 0)))
+           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.find( sToFind) == 0)))
          return ( pGdbO->m_nId) ;
      // passo al precedente
       pGdbO = pGdbO->GetPrev() ;
@@ -963,7 +961,7 @@ GeomDB::GetPrevName( int nId, const string& sName) const
      // se ha il nome o la parte iniziale di nome cercato
       string sObjName ;
       if ( pGdbPrev->GetName( sObjName)  &&  
-           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.rfind( sToFind, 0) == 0)))
+           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.find( sToFind) == 0)))
          return ( pGdbPrev->m_nId) ;
      // passo al precedente
       pGdbPrev = pGdbPrev->GetPrev() ;

GeomDB.h

@@ -29,10 +29,6 @@ class GeomDB : public IGeomDB
    friend class GdbObj ;
    friend class GdbGroup ;
    friend class GdbGeo ;
-   friend int CopyGeoObj( const GeomDB* pSouGDB, int nSouId, GeomDB* pDstGDB, int nDestId, int nRefId, int nSonBeforeAfter, bool bGlob) ;
-   friend int CopyGroupObj( const GeomDB* pSouGDB, int nSouId, GeomDB* pDstGDB, int nDestId, int nRefId, int nSonBeforeAfter, bool bGlob) ;
-   friend int DuplicateGeoObj( const GeomDB* pSouGDB, int nSouId, GeomDB* pDstGDB, int nDestId, int nRefId) ;
-   friend int DuplicateGroupObj( const GeomDB* pSouGDB, int nSouId, GeomDB* pDstGDB, int nDestId, int nRefId, bool bSkipTemp) ;
 
    public :
       ~GeomDB( void) override ;

IntersCurveCurve.cpp

@@ -291,24 +291,6 @@ IntersCurveCurve::GetIntersCount( void)
    return m_nIntersCount ;
 }
 
-//----------------------------------------------------------------------------
-int
-IntersCurveCurve::GetInters3DCount( void)
-{
-   int nCount = 0 ;
-   for( int i = 0 ; i < m_nIntersCount ; ++i) {
-      if( ! m_Info[i].bOverlap  ||  ( m_Info[i].bOverlap  &&  m_Info[i].bCBOverEq)) {
-         if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[0].ptI.z) < EPS_SMALL)
-            ++nCount ;
-      }
-      else {
-         if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[1].ptI.z) < EPS_SMALL)
-            ++nCount ;
-      }
-   }
-   return nCount ;
-}
-
 //----------------------------------------------------------------------------
 int
 IntersCurveCurve::GetCrossIntersCount( void)
@@ -358,30 +340,6 @@ IntersCurveCurve::GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo)
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-IntersCurveCurve::GetInt3DCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo)
-{
-   if ( nInd < 0  ||  nInd >= GetInters3DCount())
-      return false ;
-   int nCount = - 1 ;
-   for( int i = 0 ; i < m_nIntersCount ; ++i) {
-      if( ! m_Info[i].bOverlap  ||  ( m_Info[i].bOverlap  &&  m_Info[i].bCBOverEq)) {
-         if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[0].ptI.z) < EPS_SMALL)
-            ++nCount ;
-      }
-      else {
-         if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[1].ptI.z) < EPS_SMALL)
-            ++nCount ;
-      }
-      if( nCount == nInd) {
-         aInfo = m_Info[nInd] ;
-         return true ;
-      }
-   }
-   return false ;
-}
-
 //----------------------------------------------------------------------------
 bool
 IntersCurveCurve::GetIntersPointNearTo( int nCrv, const Point3d& ptNear, Point3d& ptI)

IntersCurvePlane.cpp

@@ -1,451 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025
-//----------------------------------------------------------------------------
-// File : IntersCurvePlane.cpp      Data : 07.11.25          Versione : 2.7k1
-// Contenuto : Implementazione della classe intersezione curva-piano.
-//
-//
-//
-// Modifiche : 07.11.25 DB Creazione modulo.
-//             
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "GeoConst.h"
-#include "CurveLine.h"
-#include "CurveComposite.h"
-#include "IntersLineLine.h"
-#include "IntersLineArc.h"
-#include "IntersArcArc.h"
-#include "IntersCrvCompoCrvCompo.h"
-#include "/EgtDev/Include/EGkIntersCurves.h"
-#include "/EgtDev/Include/EGkIntersLinePlane.h"
-#include "/EgtDev/Include/EGkIntersCurvePlane.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
-#include "/EgtDev/Include/EGkPlane3d.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
-#include <algorithm>
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-IntersCurvePlane::IntersCurvePlane( const ICurve& Curve, const Point3d& ptOrig, const Vector3d& vtN)
-{
-  // Le intersezioni sono calcolate nel piano XY locale.
-  // Il flag bAreSegments vale solo per intersezione tra due linee e riguarda entrambe.
-
-  // inizializzazioni
-   m_nIntersCount = 0 ;
-   m_pCurve = &Curve ;
-   m_plPlane.Set( ptOrig, vtN) ;
-
-  // puntatore alla curva usata nei calcoli (originali o temporanee)
-   const ICurve*    pCalcCrv ; 
-  // per eventuale esplosione temporanea delle curve
-   PtrOwner<ICurve> pTmpCrv ;
-
-   // se curva è arco da approssimare oppure è curva di Bezier
-   if ( m_pCurve->GetType() == CRV_ARC  ||  m_pCurve->GetType() == CRV_BEZIER  ||  m_pCurve->GetType() ==  CRV_COMPO) {
-      // approssimo con rette
-      PolyLine PL ;
-      if ( ! m_pCurve->ApproxWithLines( EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
-         return ;
-      pTmpCrv.Set( CreateBasicCurveComposite()) ;
-      if ( IsNull( pTmpCrv))
-         return ;
-      if ( ! GetBasicCurveComposite( pTmpCrv)->FromPolyLine( PL))
-         return ;
-      pCalcCrv = pTmpCrv ;
-   }
-   else
-      pCalcCrv = m_pCurve ;
-
-   m_Info.clear() ;
-   if ( pCalcCrv->GetType() == CRV_LINE) {
-      CalcIntersLinePlane( m_plPlane, *pCalcCrv) ;
-   }
-   else if ( pCalcCrv->GetType() == CRV_COMPO){
-      for ( int i = 0 ; i < GetBasicCurveComposite( pCalcCrv)->GetCurveCount(); ++i) {
-         const ICurve& subCurve = *GetBasicCurveComposite( pCalcCrv)->GetCurve( i) ;
-         CalcIntersLinePlane( m_plPlane, subCurve, i) ;
-      }
-      OrderAndCompleteIntersections() ;
-   }
-
-  // per curve approssimate, sistemo...
-   AdjustIntersParams( pCalcCrv !=  m_pCurve) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IntersCurvePlane::CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Curve, int nCrv)
-{
-   if ( Curve.GetType() != CRV_LINE)
-      return false ;
-   Point3d ptStart ; Curve.GetStartPoint( ptStart) ;
-   Point3d ptEnd ; Curve.GetEndPoint( ptEnd) ;
-   Point3d ptInt ;
-   double dLen = 0 ; Curve.GetLength( dLen) ;
-   int nIntersType = IntersLinePlane( ptStart, ptEnd, m_plPlane, ptInt, true) ;
-   // intersezione con attraversamento
-   if ( nIntersType == ILPT_YES) {
-      IntCrvPlnInfo icpi ;
-      icpi.Ici[0].ptI = ptInt ;
-      icpi.Ici[0].dU = Dist( ptInt, ptStart) / dLen + nCrv ;
-      Vector3d vtPos = ptStart - m_plPlane.GetPoint() ;
-      icpi.Ici[0].nPrevTy = vtPos * m_plPlane.GetVersN() > 0 ? ICPT_OUT : ICPT_IN ;
-      icpi.Ici[0].nNextTy = icpi.Ici[0].nPrevTy == ICPT_IN ? ICPT_OUT : ICPT_IN ;
-      m_Info.push_back( icpi) ;
-   }
-   // intersezione con tocco
-   else if ( nIntersType == ILPT_START  ||  nIntersType == ILPT_END) {
-      IntCrvPlnInfo icpi ;
-      icpi.Ici[0].ptI = ptInt ;
-      icpi.Ici[0].dU = nIntersType == ILPT_START ? 0 : 1 + nCrv ;
-      
-      if ( nIntersType == ILPT_START) {
-         Vector3d vtPos = ptEnd - m_plPlane.GetPoint() ;
-         icpi.Ici[0].nNextTy = vtPos * m_plPlane.GetVersN() > 0 ? ICPT_OUT : ICPT_IN ;
-         icpi.Ici[0].nPrevTy = ICPT_NULL ;
-      }
-      else {
-         Vector3d vtPos = ptStart - m_plPlane.GetPoint() ;
-         icpi.Ici[0].nPrevTy = vtPos * m_plPlane.GetVersN() > 0 ? ICPT_OUT : ICPT_IN ;
-         icpi.Ici[0].nNextTy = ICPT_NULL ;
-      }
-      m_Info.push_back( icpi) ;
-   }
-   // intersezione con sovrapposizione
-   else if ( nIntersType == ILPT_INPLANE) {
-      IntCrvPlnInfo icpi ;
-      icpi.bOverlap = true ;
-      icpi.Ici[0].ptI = ptStart ;
-      icpi.Ici[0].dU = 0 + nCrv;
-      icpi.Ici[1].ptI = ptEnd ;
-      icpi.Ici[1].dU = 1 + nCrv ;
-      icpi.Ici[0].nPrevTy = ICPT_NULL ;
-      icpi.Ici[0].nNextTy = ICPT_ON ;
-      icpi.Ici[1].nPrevTy = ICPT_ON ;
-      icpi.Ici[1].nNextTy = ICPT_NULL ;
-      m_Info.push_back( icpi) ;
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-void
-IntersCurvePlane::OrderAndCompleteIntersections()
-{
-   if ( m_Info.size() < 2)
-      return ;
-   // cancello le interesezioni puntuali adiacenti a tratti di sovrapposizione
-   // riempio le info PrevTy e NexyTy
-   sort( m_Info.begin(), m_Info.end(), []( IntCrvPlnInfo& icpA, IntCrvPlnInfo& icpB) { return icpA.Ici[0].dU < icpA.Ici[0].dU ;}) ;
-   for ( int curr = m_Info.size() - 1 ; curr > - 1 ; --curr) {
-      int prev = curr == 0 ? m_Info.size() - 1 : curr - 1 ;
-      int next = curr == m_Info.size() - 1 ? 0 : curr + 1 ;
-      bool bErasedCurr = false ;
-      // solo le intersezioni di sovrapposizione o puntuali sullo start o end delle curve possono avere il PrevTy o NextTy non definito
-      if ( ! m_Info[curr].bOverlap) {
-         if ( m_Info[curr].Ici[0].nPrevTy ==  ICPT_NULL) {
-            if ( ! m_Info[prev].bOverlap) {
-               m_Info[curr].Ici[0].nPrevTy = m_Info[prev].Ici[0].nNextTy ;
-               // se ho due puntuali che coincidono cancello il successivo tra i due ( corrente)
-               if ( AreSamePointApprox( m_Info[curr].Ici[0].ptI, m_Info[prev].Ici[0].ptI)) {
-                  m_Info.erase(m_Info.begin() + curr) ;
-                  bErasedCurr = true ;
-               }
-            }
-            // se ho un'intersezione puntuale che in realtà è la fine di un tratto di sovrapposizione, la cancello
-            else {
-               m_Info[prev].Ici[1].nNextTy = m_Info[curr].Ici[0].nNextTy ;
-               m_Info.erase(m_Info.begin() + curr) ;
-               bErasedCurr = true ;
-            }
-         }
-         if ( ! bErasedCurr  &&  m_Info[curr].Ici[0].nNextTy ==  ICPT_NULL){
-            if ( ! m_Info[prev].bOverlap)
-               m_Info[curr].Ici[0].nNextTy = m_Info[next].Ici[0].nPrevTy ;
-            // se ho un'intersezione puntuale che in realtà è la fine di un tratto di sovrapposizione, la cancello
-            else {
-               m_Info[next].Ici[0].nPrevTy = m_Info[curr].Ici[0].nPrevTy ;
-               m_Info.erase(m_Info.begin() + curr) ;
-            }
-         }
-      }
-      else {
-         if ( m_Info[curr].Ici[0].nPrevTy ==  ICPT_NULL) {
-            if ( ! m_Info[prev].bOverlap)
-              m_Info[curr].Ici[0].nPrevTy = m_Info[prev].Ici[0].nNextTy ;
-            else
-              m_Info[curr].Ici[0].nPrevTy = m_Info[prev].Ici[1].nNextTy ;
-         }
-         if ( m_Info[curr].Ici[1].nNextTy ==  ICPT_NULL) {
-            if ( ! m_Info[next].bOverlap)
-              m_Info[curr].Ici[0].nNextTy = m_Info[prev].Ici[0].nPrevTy ;
-            else
-              m_Info[curr].Ici[0].nNextTy = m_Info[prev].Ici[1].nPrevTy ;
-         }
-      }
-   }
-   m_nIntersCount = m_Info.size() ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IntersCurvePlane::IsArcToApprox( const ICurve& Curve)
-{
-  // recupero l'arco
-   const CurveArc* pArc = GetBasicCurveArc( &Curve) ;
-   if ( pArc == nullptr)
-      return false ;
-  // verifico se non è nel piano XY o ha più di un giro al centro
-   return ( ( ! pArc->GetNormVersor().IsZplus()  &&  ! pArc->GetNormVersor().IsZminus())  ||
-            abs( pArc->GetAngCenter()) > ANG_FULL + EPS_ANG_ZERO) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IntersCurvePlane::AdjustIntersParams( bool bAdjCrv)
-{
-  // se non ci sono intersezioni, non va fatto alcunché
-   if ( m_Info.empty())
-      return true ;
-  // se le curve originali non sono state approssimate, non va fatto alcunché
-   if ( ! bAdjCrv)
-      return true ;
-  // procedo ad aggiustare
-   for ( auto& aInfo : m_Info) {
-     // se curve originali approssimate, devo ricalcolare i parametri dei punti di intersezione
-      if ( bAdjCrv) {
-        if ( ! m_pCurve->GetParamAtPoint( aInfo.Ici[0].ptI, aInfo.Ici[0].dU, 10 * EPS_SMALL))
-           return false ;
-        if ( aInfo.bOverlap  &&  ! m_pCurve->GetParamAtPoint( aInfo.Ici[1].ptI, aInfo.Ici[1].dU, 10 * EPS_SMALL))
-           return false ;
-      }
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-int
-IntersCurvePlane::GetIntersCount( void)
-{
-   return m_nIntersCount ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IntersCurvePlane::GetIntersPointNearTo( const Point3d& ptNear, Point3d& ptI, double& dParam)
-{
-   if ( m_nIntersCount == 0)
-      return false ;
-
-  // ricerca del punto più vicino tra le intersezioni singole
-   bool bFound = false ;
-   double dMinSqDist = SQ_INFINITO ;
-   for ( int i = 0 ; i < m_nIntersCount ; ++ i) {
-     // se è un'intersezione singola
-      if ( ! m_Info[i].bOverlap) {
-        // faccio la verifica sul punto
-         Point3d ptP = m_Info[i].Ici[0].ptI ;
-         double dSqDist = SqDist( ptNear, ptP) ;
-         if ( dSqDist < dMinSqDist) {
-            dMinSqDist = dSqDist ;
-            ptI = ptP ;
-            dParam = m_Info[i].Ici[0].dU ;
-            bFound = true ;
-         }
-      }
-     // altrimenti
-      else {
-        // recupero il tratto di sovrapposizione
-         double dUStartTrim, dUEndTrim ;
-         dUStartTrim = m_Info[i].Ici[0].dU ;
-         dUEndTrim = m_Info[i].Ici[1].dU ;
-         PtrOwner<ICurve> pCrv( m_pCurve->CopyParamRange( dUStartTrim, dUEndTrim)) ;
-         if ( IsNull( pCrv))
-            continue ;
-        // cerco il punto
-         int nFlag ;
-         Point3d ptP ;
-         if ( DistPointCurve( ptNear, *pCrv).GetMinDistPoint( 0.5, ptP, nFlag)) {
-           // faccio la verifica
-            double dSqDist = SqDist( ptNear, ptP) ;
-            if ( dSqDist < dMinSqDist) {
-               dMinSqDist = dSqDist ;
-               ptI = ptP ;
-               m_pCurve->GetParamAtPoint( ptP, dParam) ;
-               bFound = true ;
-            }
-         }
-      }
-   }
-
-   return bFound ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IntersCurvePlane::GetCurveClassification( double dLenMin, CRVPLNCVECTOR& ccClass)
-{
-  // pulisco vettore classificazioni
-   ccClass.clear() ;
-
-  // verifico definizione della curva
-   if ( m_pCurve == nullptr)
-      return false ;
-
-   // se esiste almeno una intersezione
-   if ( m_nIntersCount >= 1)
-      return CalcCurveClassification( m_pCurve, m_Info, dLenMin, ccClass) ;
-   // altrimenti la curva è completamente interna oppure completamente esterna
-   else
-      return CalcCurveInOrOut( m_pCurve, ccClass) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IntersCurvePlane::CalcCurveClassification( const ICurve* pCurve, const ICPIVECTOR& Info, double dLenMin, CRVPLNCVECTOR& ccClass)
-{
-  // numero intersezioni
-   int nNumInters = int( Info.size()) ;
-   if ( nNumInters < 1)
-      return false ;
-  // recupero il dominio parametrico della curva in esame
-   double dStartPar, dEndPar ;
-   if ( pCurve == nullptr  ||  ! pCurve->GetDomain( dStartPar, dEndPar))
-      return false ;
-  // limito lunghezza minima
-   dLenMin = max( dLenMin, EPS_ZERO) ;
-  // elimino intersezioni senza attraversamento che giacciono in intervalli di sovrapposizione
-   ICPIVECTOR InfoCorr ;
-   InfoCorr.reserve( Info.size()) ;
-   for ( size_t i = 0 ; i < Info.size() ; ++ i) {
-     // se intersezione puntuale senza attraversamento
-      if ( ! Info[i].bOverlap  &&  Info[i].Ici[0].nPrevTy == Info[i].Ici[0].nNextTy) {
-        // confronto con le intersezioni con sovrapposizione
-         bool bToSkip = false ;
-         for ( size_t j = 0 ; j < Info.size() ; ++ j) {
-           // se coincide o puntuale
-            if ( j == i  ||  ! Info[j].bOverlap)
-               continue ;
-           // determino l'intervallo parametrico tenendo conto di eventuale avvolgimento attorno all'inizio
-            double dU1 = Info[j].Ici[0].dU ;
-            double dU2 = Info[j].Ici[1].dU ;
-            if ( dU2 < dU1  &&  pCurve->IsClosed())
-               dU2 += dEndPar ;
-           // se cade nell'intervallo è da saltare
-            if ( Info[i].Ici[0].dU >= dU1  &&  Info[i].Ici[0].dU <= dU2) {
-               bToSkip = true ;
-               break ;
-            }
-         }
-         if ( bToSkip)
-            continue ;
-      }
-     // salvo dati intersezione
-      InfoCorr.emplace_back( Info[i]) ;
-   }
-  // aggiorno numero di intersezioni da considerare
-   nNumInters = int( InfoCorr.size()) ;
-  // recupero la classificazione all'inizio della curva
-   int nLastTy = ICCT_NULL ;
-   double dCurrPar = dStartPar ;
-   double dCurrLen = 0 ;
-   double dEndLen ; pCurve->GetLength( dEndLen) ;
-   // se è chiusa, recupero come finisce
-   if ( pCurve->IsClosed()) {
-      if ( ! InfoCorr[nNumInters-1].bOverlap)
-         nLastTy = InfoCorr[nNumInters-1].Ici[0].nNextTy ;
-      else {
-         nLastTy = InfoCorr[nNumInters-1].Ici[1].nNextTy ;
-        // se attraversa il punto di giunzione (parametro di fine minore di quello di inizio)
-         if ( InfoCorr[nNumInters-1].Ici[1].dU < InfoCorr[nNumInters-1].Ici[0].dU) {
-            dCurrPar = InfoCorr[nNumInters-1].Ici[1].dU ;
-            double dTmpLen ; pCurve->GetLengthAtParam( dCurrPar, dTmpLen) ;
-            dCurrLen = dTmpLen - dEndLen ;
-            dEndPar = dCurrPar ;
-            dEndLen = dTmpLen ;
-         }
-      }
-   }
-  // costruisco il vettore delle classificazioni
-   for ( int i = 0 ; i < nNumInters ; ++ i) {
-     // se è definito un tratto precedente
-      double dLenU ; pCurve->GetLengthAtParam( InfoCorr[i].Ici[0].dU, dLenU) ;
-      if ( InfoCorr[i].Ici[0].dU > dCurrPar + EPS_PARAM  &&  dLenU - dCurrLen > dLenMin) {
-        // verifico che la definizione sul tratto sia omogenea e valida
-         int nPrevTy = InfoCorr[i].Ici[0].nPrevTy ;
-         if ( ( nLastTy != ICCT_NULL  &&  nPrevTy != nLastTy)  ||
-              nPrevTy == ICCT_NULL  ||  nPrevTy == ICCT_ON)
-            return false ;
-        // assegno i dati
-         CrvPlaneClass segClass ;
-         segClass.dParS = dCurrPar ;
-         segClass.dParE = InfoCorr[i].Ici[0].dU ;
-         segClass.nClass = (( nPrevTy == ICCT_IN) ? CRVC_IN : CRVC_OUT) ;
-         ccClass.push_back( segClass) ;
-        // salvo dati correnti
-         dCurrPar = InfoCorr[i].Ici[0].dU ;
-         dCurrLen = dLenU ;
-         nLastTy = InfoCorr[i].Ici[0].nNextTy ;
-      }
-     // altrimenti, salvo il tipo
-      else
-         nLastTy = InfoCorr[i].Ici[0].nNextTy ;
-     // se è definito un tratto in sovrapposizione
-      if ( InfoCorr[i].bOverlap) {
-        // assegno i dati
-         CrvPlaneClass segClass ;
-         segClass.dParS = dCurrPar ;
-         segClass.dParE = InfoCorr[i].Ici[1].dU ;
-         segClass.nClass = CRVPLN_ON ;
-         ccClass.push_back( segClass) ;
-        // salvo dati correnti
-         dCurrPar = InfoCorr[i].Ici[1].dU ;
-         dCurrLen = dLenU ;
-         nLastTy = InfoCorr[i].Ici[1].nNextTy ;
-      }
-   }
-  // eventuale tratto finale rimasto
-   if ( dCurrPar < dEndPar - EPS_PARAM  &&  dEndLen - dCurrLen > dLenMin) {
-     // verifico che la definizione sul tratto sia valida
-      if ( nLastTy == ICCT_NULL  ||  nLastTy == ICCT_ON)
-         return false ;
-     // assegno i dati
-      CrvPlaneClass segClass ;
-      segClass.dParS = dCurrPar ;
-      segClass.dParE = dEndPar ;
-      segClass.nClass = (( nLastTy == ICCT_IN) ? CRVC_IN : CRVC_OUT) ;
-      ccClass.push_back( segClass) ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IntersCurvePlane::CalcCurveInOrOut( const ICurve* pCurve, CRVPLNCVECTOR& ccClass)
-{
-   // controllo di non avere intersezioni
-   int nNumInters = int( m_Info.size()) ;
-   if ( nNumInters > 0)
-      return false ;
-
-   // se non ho intersezioni tra curva e piano devo solo capire da che parte del piano sta la curva
-   CrvPlaneClass cpClass ;
-   double dStartPar, dEndPar ;
-   if ( pCurve == nullptr  ||  ! pCurve->GetDomain( dStartPar, dEndPar))
-      return false ;
-   Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
-   Vector3d vtCrv = ptStart - m_plPlane.GetPoint() ;
-   CrvPlaneClass segClass ;
-   segClass.dParS = dStartPar ;
-   segClass.dParE = dEndPar ;
-   segClass.nClass = ( (vtCrv * m_plPlane.GetVersN() < 0) ? CRVC_IN : CRVC_OUT) ;
-   ccClass.push_back( segClass) ;
-   return true ;
-}

IntersLineBox.cpp

@@ -113,7 +113,7 @@ IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double dLen, const BBox3
    double dU1, dU2 ;
    bool bInters = IntersLineBox( ptL, vtL, b3Box.GetMin(), b3Box.GetMax(), dU1, dU2) ;
 
-  // Se non c'è intersezione
+  // Se non c'è intersezione
    if ( ! bInters  ||  ( bFinite  &&  ( dU1 > dLen + EPS_SMALL  ||  dU2 < -EPS_SMALL)))
       return true ;
 
@@ -144,14 +144,8 @@ IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double dLen, const BBox3
          else if ( dU2 < EPS_SMALL)
             vInters.emplace_back( ILBT_OUT, 0) ;
          else {
-            if ( dU1 < - EPS_SMALL)
-               vInters.emplace_back( ILBT_TG_INSIDE, 0.) ;
-            else
-               vInters.emplace_back( ILBT_TG_INI, Clamp( dU1, 0., dLen)) ;
-            if ( dU2 > dLen + EPS_SMALL)
-               vInters.emplace_back( ILBT_TG_INSIDE, dLen) ;
-            else
-               vInters.emplace_back( ILBT_TG_FIN, Clamp( dU2, 0., dLen)) ;
+            vInters.emplace_back( ILBT_TG_INI, Clamp( dU1, 0., dLen)) ;
+            vInters.emplace_back( ILBT_TG_FIN, Clamp( dU2, 0., dLen)) ;
          }
       }
       return true ;
@@ -168,14 +162,8 @@ IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double dLen, const BBox3
       else if ( dU2 < EPS_SMALL)
          vInters.emplace_back( ILBT_OUT, 0) ;
       else {
-         if ( dU1 < - EPS_SMALL)
-            vInters.emplace_back( ILBT_INSIDE, 0.) ;
-         else
-            vInters.emplace_back( ILBT_IN, Clamp( dU1, 0., dLen)) ;
-         if ( dU2 > dLen + EPS_SMALL)
-            vInters.emplace_back( ILBT_INSIDE, dLen) ;
-         else
-            vInters.emplace_back( ILBT_OUT, Clamp( dU2, 0., dLen)) ;
+         vInters.emplace_back( ILBT_IN, Clamp( dU1, 0., dLen)) ;
+         vInters.emplace_back( ILBT_OUT, Clamp( dU2, 0., dLen)) ;
       }
    }
    return true ;

IntersLineLine.cpp

@@ -14,7 +14,6 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "IntersLineLine.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include <algorithm>
 
 using namespace std ;
@@ -157,92 +156,35 @@ IntersLineLine::IntersFiniteLines( const CurveLine& Line1, const CurveLine& Line
    double dCrossXY = CrossXY( vtDir1, vtDir2) ;
   // flag per linee parallele
    bool bParallel = ( abs( dCrossXY) < SIN_EPS_ANG_ZERO * ( dLen1XY * dLen2XY)) ;
-     // flag per segmenti che si allontanano significativamente
+  // flag per segmenti che si allontanano significativamente
    bool bFarEnds = ( nS1Side != 0  ||  nE1Side != 0  ||  nS2Side != 0  ||  nE2Side != 0) ;
-   
-   // analisi casi speciali di quasi parallelismo
-   // segmento sovrapposto all'altro
-   double dDist1, dDist2 ;
-   if( nS1Side == 0 ||  nE1Side == 0  ||  nS1Side == nE1Side) {
-      dDist1 = CrossXY( ptS1 - ptS2, vtDir2) ;
-      dDist2 = CrossXY( ptE1 - ptS2, vtDir2) ;
-      if( abs( dDist1 - dDist2) < EPS_SMALL * dLen2XY) {
-         bParallel = true ;
-         bFarEnds = ! ( (nS1Side == 0  &&  nE1Side == 0)  ||  (nS2Side == 0  &&  nE2Side == 0)) ;
-      }
-   }
-   else if( nS2Side == 0  ||  nE2Side == 0  ||  nS2Side == nE2Side) {
-      dDist1 = CrossXY( ptS2 - ptS1, vtDir1) ;
-      dDist2 = CrossXY( ptE2 - ptS1, vtDir1) ;
-      if( abs( dDist1 - dDist2) < EPS_SMALL * dLen1XY){
-         bParallel = true ;
-         bFarEnds = ! ( (nS1Side == 0  &&  nE1Side == 0)  ||  (nS2Side == 0  &&  nE2Side == 0)) ;
-      }
-   }
-   // estremità sovrapposte di poco
-   if ( ! bParallel  &&  abs( dCrossXY) < ( 0.1 * DEGTORAD) * ( dLen1XY * dLen2XY)) {
-      if (( nS1Side == 0  &&  nS2Side == 0  &&  ! AreSamePointXYEpsilon( ptS1, ptS2, 2 * EPS_SMALL))  ||
-          ( nS1Side == 0  &&  nE2Side == 0  &&  ! AreSamePointXYEpsilon( ptS1, ptE2, 2 * EPS_SMALL))  ||
-          ( nE1Side == 0  &&  nS2Side == 0  &&  ! AreSamePointXYEpsilon( ptE1, ptS2, 2 * EPS_SMALL))  ||
-          ( nE1Side == 0  &&  nE2Side == 0  &&  ! AreSamePointXYEpsilon( ptE1, ptE2, 2 * EPS_SMALL))) {
-         bParallel = true ;
-         bFarEnds = false ;
-      }
-   }
 
   // se non sono paralleli e si allontanano tra loro abbastanza
    if ( ! bParallel  &&  bFarEnds) {
      // posizioni parametriche dell'intersezione sulle linee
       m_Info.IciA[0].dU = CrossXY( ( ptS2 - ptS1), vtDir2) / dCrossXY ;
       m_Info.IciB[0].dU = CrossXY( ( ptS2 - ptS1), vtDir1) / dCrossXY ;
-      // verifica posizione intersezione su prima linea
+     // verifica posizione intersezione su prima linea
       int nPos1 = ICurve::PP_NULL ;     // fuori
-      if ( nS1Side == 0 ||  nE1Side == 0) {
-         if( nS1Side == 0) {
-            nPos1 = ICurve::PP_START ;
-            m_Info.IciA[0].dU = 0 ;
-            m_Info.IciB[0].dU = vtDir2 * ( ptS1 - ptS2) / Pow( vtDir2.Len(), 2) ;
-         }
-         else {
-            nPos1 = ICurve::PP_END ;
-            m_Info.IciA[0].dU = 1 ;
-            m_Info.IciB[0].dU = vtDir2 * ( ptE1 - ptS2) / Pow( vtDir2.Len(), 2) ;
-         }
-      }
-      else {
-         if ( abs( m_Info.IciA[0].dU * dLen1XY) < EPS_SMALL)
-            nPos1 = ICurve::PP_START ;     // vicino a inizio
-         else if ( abs(( 1 - m_Info.IciA[0].dU) * dLen1XY) < EPS_SMALL)
-            nPos1 = ICurve::PP_END ;       // vicino a fine
-         else if ( m_Info.IciA[0].dU > 0  &&  m_Info.IciA[0].dU < 1)
-            nPos1 = ICurve::PP_MID ;       // nell'interno
-         else
-            return ;
-      }
+      if ( abs( m_Info.IciA[0].dU * dLen1XY) < EPS_SMALL)
+         nPos1 = ICurve::PP_START ;     // vicino a inizio
+      else if ( abs(( 1 - m_Info.IciA[0].dU) * dLen1XY) < EPS_SMALL)
+         nPos1 = ICurve::PP_END ;       // vicino a fine
+      else if ( m_Info.IciA[0].dU > 0  &&  m_Info.IciA[0].dU < 1)
+         nPos1 = ICurve::PP_MID ;       // nell'interno
+      else
+         return ;
      // verifica posizione intersezione su seconda linea
       int nPos2 = ICurve::PP_NULL ;     // fuori
-      if ( nS2Side == 0 ||  nE2Side == 0) {
-         if( nS2Side == 0) {
-            nPos2 = ICurve::PP_START ;
-            m_Info.IciB[0].dU = 0 ;
-            m_Info.IciA[0].dU = vtDir1 * (ptS2 - ptS1) / Pow( vtDir1.Len(), 2) ;
-         }
-         else {
-            nPos2 = ICurve::PP_END ;
-            m_Info.IciB[0].dU = 1 ;
-            m_Info.IciA[0].dU = vtDir1 * (ptE2 - ptS1) / Pow( vtDir1.Len(), 2) ;
-         }
-      }
-      else {
-         if ( abs( m_Info.IciB[0].dU * dLen2XY) < EPS_SMALL)
-            nPos2 = ICurve::PP_START ;     // vicino a inizio
-         else if ( abs(( 1 - m_Info.IciB[0].dU) * dLen2XY) < EPS_SMALL)
-            nPos2 = ICurve::PP_END ;       // vicino a fine
-         else if ( m_Info.IciB[0].dU > 0  &&  m_Info.IciB[0].dU < 1)
-            nPos2 = ICurve::PP_MID ;       // nell'interno
-         else
-            return ;
-      }     // limito i parametri a stare sui segmenti (0...1)
+      if ( abs( m_Info.IciB[0].dU * dLen2XY) < EPS_SMALL)
+         nPos2 = ICurve::PP_START ;     // vicino a inizio
+      else if ( abs(( 1 - m_Info.IciB[0].dU) * dLen2XY) < EPS_SMALL)
+         nPos2 = ICurve::PP_END ;       // vicino a fine
+      else if ( m_Info.IciB[0].dU > 0  &&  m_Info.IciB[0].dU < 1)
+         nPos2 = ICurve::PP_MID ;       // nell'interno
+      else
+         return ;
+     // limito i parametri a stare sui segmenti (0...1)
       m_Info.IciA[0].dU = min( max( m_Info.IciA[0].dU, 0.), 1.) ;
       m_Info.IciB[0].dU = min( max( m_Info.IciB[0].dU, 0.), 1.) ;
      // calcolo i punti sulle due linee (possono differire in Z)

IntersLineSurfBez.cpp

@@ -14,17 +14,11 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CurveLine.h"
-#include "CurveBezier.h"
-#include "CurveComposite.h"
-#include "SurfFlatRegion.h"
 #include "/EgtDev/Include/EGkDistPointLine.h"
-#include "/EgtDev/Include/EGkDistLineLine.h"
-#include "/EgtDev/Include/EGkDistPointSurfFr.h"
 #include "/EgtDev/Include/EGkIntersLineTria.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
 #include "/EgtDev/Include/EGkIntersLineSurfBez.h"
 #include "/EgtDev/Include/EGkSurfBezier.h"
-#include "/EgtDev/Include/ENkPolynomialRoots.h"
 
 using namespace std ;
 
@@ -34,6 +28,7 @@ RefineIntersNewton( const Point3d& ptL, const Vector3d& vtL, double dLen, bool b
                     const ISurfBezier* pSurfBz, Point3d& ptSP, Point3d& ptIBz)
 {
   // la funzione raffina la posisione del punto ptSP, minimizzando la distanza dalla retta e restituisce il punto di intersezione ptIBz
+   pSurfBz->GetPointD1D2( ptSP.x / SBZ_TREG_COEFF, ptSP.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
   // usando un algoritmo di newton cerco di avvicinarmi il più possibile alla retta
    DistPointLine dpl( ptIBz, ptL, vtL, dLen, bFinite) ;
    double dDistNew = 0, dDistPre = 0 ;
@@ -47,18 +42,18 @@ RefineIntersNewton( const Point3d& ptL, const Vector3d& vtL, double dLen, bool b
    while ( dDistNew > EPS_SMALL  &&  nCount < 100) {
       dDistPre = dDistNew ;
       Point3d ptIBzNew1 ;
-      pSurfBz->GetPointD1D2( ( ptSP.x + dh), ptSP.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew1) ;
+      pSurfBz->GetPointD1D2( ( ptSP.x + dh)  / SBZ_TREG_COEFF, ptSP.y  / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew1) ;
       DistPointLine dplNewU( ptIBzNew1, ptL, vtL, dLen, bFinite) ;
       dplNewU.GetDist( dDistNew) ;
       double dfdU = ( dDistNew - dDistPre) / dh ;
       Point3d ptIBzNew2 ;
-      pSurfBz->GetPointD1D2( ptSP.x, ( ptSP.y + dh), ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew2) ;
+      pSurfBz->GetPointD1D2( ptSP.x  / SBZ_TREG_COEFF, ( ptSP.y + dh) / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew2) ;
       DistPointLine dplNewV( ptIBzNew2, ptL, vtL, dLen, bFinite) ;
       dplNewV.GetDist( dDistNew) ;
       double dfdV = ( dDistNew - dDistPre) / dh ;
      // mi avvicino cercando di annullare la distanza in un colpo solo
       double dr = - dDistPre / ( dfdU + dfdV) ;
-      pSurfBz->GetPointD1D2(( ptSP.x + dr * dfdU), ( ptSP.y + dr * dfdV), ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
+      pSurfBz->GetPointD1D2(( ptSP.x + dr * dfdU) / SBZ_TREG_COEFF, ( ptSP.y + dr * dfdV) / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
       DistPointLine dplNew( ptIBz, ptL, vtL, dLen, bFinite) ;
       dplNew.GetDist( dDistNew) ;
       ++ nCount ;
@@ -72,11 +67,11 @@ 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)
 {
-   if ( nILT == ILTA_IN  ||  nILT == ILTA_EDGE  ||  nILT == ILTA_VERT  ||  nILT == ILTA_NO_TRIA) {
+   if ( nILT == ILTT_IN  ||  nILT == ILTT_EDGE  ||  nILT == ILTT_VERT) {
       double dU = ( ptIBz - ptL) * vtDir ;
       vInfo.emplace_back( nILT, dU, nT, dCos, ptIBz, ptSP) ;
    }
-   else if ( nILT == ILTA_SEGM  ||  nILT == ILTA_SEGM_ON_EDGE) {
+   else if ( nILT == ILTT_SEGM  ||  nILT == ILTT_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) ;
@@ -93,8 +88,8 @@ 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) ;
+      {  double dUa = ( ( a.nILTT == ILTT_SEGM  ||  a.nILTT == ILTT_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
+   double dUb = ( ( b.nILTT == ILTT_SEGM  ||  b.nILTT == ILTT_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
    return ( dUa < dUb) ; }) ;
 }
 
@@ -142,16 +137,16 @@ IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
          pSurfTm->GetTriangle( InfoTm.nT, nVert) ;
          double dU0, dV0 ;
          pSurfTm->GetVertexParam( nVert[0], dU0, dV0) ;
-         ptSP = ptSP + Point3d( dU0, dV0, 0) ;
+         ptSP = ptSP + Point3d(dU0, dV0, 0) ;
          if ( ! RefineIntersNewton( ptL,vtL, dLen, bFinite, pSurfBz, ptSP, ptIBz))
             return false ;
       }
       Vector3d vtN ;
-      pSurfBz->GetPointNrmD1D2(ptSP.x, ptSP.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz, vtN) ;
+      pSurfBz->GetPointNrmD1D2(ptSP.x / SBZ_TREG_COEFF, ptSP.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz, vtN) ;
       double dCos = vtN * vtL ;
       double dCos2 = 0 ;
       // eventualmente ripeto tutto per ptI2 ( se ho un'intersezione con sovrapposizione)
-      if ( InfoTm.nILTT == ILTA_SEGM || InfoTm.nILTT == ILTA_SEGM_ON_EDGE ) {
+      if ( InfoTm.nILTT == ILTT_SEGM || InfoTm.nILTT == ILTT_SEGM_ON_EDGE ) {
          pSurfBz->UnprojectPointFromStm( InfoTm.nT, InfoTm.ptI2, ptSP2, InfoTm.nILTT) ;
          if ( ! RefineIntersNewton(ptL, vtL, dLen, bFinite, pSurfBz, ptSP2, ptIBz2) ) {
             int nVert[3] ;
@@ -162,7 +157,7 @@ IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
             if ( ! RefineIntersNewton( ptL,vtL, dLen, bFinite, pSurfBz, ptSP, ptIBz))
                return false ;
          }
-         pSurfBz->GetPointNrmD1D2( ptSP2.x, ptSP2.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz2, vtN) ;
+         pSurfBz->GetPointNrmD1D2( ptSP2.x / SBZ_TREG_COEFF, ptSP2.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz2, vtN) ;
          dCos2 = vtN * vtL ;
       }
       UpdateInfoIntersLineSurfBz( ptL, vtL, InfoTm.nILTT, InfoTm.nT, ptSP, ptIBz, dCos, ptSP2, ptIBz2, dCos2, vInfo) ;
@@ -181,7 +176,7 @@ 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) {
+      if ( Info.nILTT == ILTT_VERT  ||  Info.nILTT == ILTT_EDGE  ||  Info.nILTT == ILTT_IN) {
          int nFlag = LSBT_TOUCH ;
          if ( Info.dCosDN > EPS_ZERO)
             nFlag = LSBT_OUT ;
@@ -190,7 +185,7 @@ FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters)
          vInters.emplace_back( nFlag, Info.dU) ;
       }
       // se altrimenti intersezione con coincidenza
-      else if ( Info.nILTA == ILTA_SEGM  ||  Info.nILTA == ILTA_SEGM_ON_EDGE) {
+      else if ( Info.nILTT == ILTT_SEGM  ||  Info.nILTT == ILTT_SEGM_ON_EDGE) {
          vInters.emplace_back( LSBT_TG_INI, Info.dU) ;
          vInters.emplace_back( LSBT_TG_FIN, Info.dU2) ;
       }
@@ -237,255 +232,3 @@ FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters)
    }
    return true ;
 }
-
-//----------------------------------------------------------------------------
-//  Intersezione di una linea con una superficie di Bezier
-//----------------------------------------------------------------------------
-bool
-IntersLineSurfBzBilinear( 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 bilineare
-   if ( nDegU > 1 || nDegV > 1 ||  nSpanU > 1  || nSpanV > 1 || bRat)
-      return false ;
-
-   int nInters = int( vInfo.size()) ;
-
-   PNTVECTOR vPntCtrl ;
-   for ( int p = 0 ; p < 4 ; ++p) {
-      bool bOk = false ;
-      vPntCtrl.push_back( pSurfBz->GetControlPoint( p, &bOk)) ;
-   }
-
-   Vector3d a = vPntCtrl[3] - vPntCtrl[1] + ( vPntCtrl[0] - vPntCtrl[2]) ;
-   Vector3d b = vPntCtrl[1] - vPntCtrl[0] ;
-   Vector3d c = vPntCtrl[2] - vPntCtrl[0] ;
-   Vector3d d =  vPntCtrl[0] - ORIG ;
-
-   double A1 =  a.x * vtL.z - a.z * vtL.x ;
-   double B1 =  b.x * vtL.z - b.z * vtL.x ;
-   double C1 =  c.x * vtL.z - c.z * vtL.x ;
-   double A2 =  a.y * vtL.z - a.z * vtL.y ;
-   double B2 =  b.y * vtL.z - b.z * vtL.y ;
-   double C2 =  c.y * vtL.z - c.z * vtL.y ;
-
-   double D1 = ( d.x - ptL.x) * vtL.z - ( d.z - ptL.z) * vtL.x ;
-   double D2 = ( d.y - ptL.y) * vtL.z - ( d.z - ptL.z) * vtL.y ;
-
-   DBLVECTOR vdCoeff, vdRoots ;
-   vdCoeff = { (B2 * D1 - B1 * D2), ( A2 * D1 - A1 * D2 + B2 * C1 - B1 * C2), ( A2 * C1 - A1 * C2)} ;
-   int nRoots = PolynomialRoots( 2, vdCoeff, vdRoots) ;
-   bool bFound = false ;
-   for ( int w = 0 ; w < nRoots ; ++w) {
-      if ( vdRoots[w] > 0 - EPS_ZERO && vdRoots[w] < 1 + EPS_ZERO ) {
-         double dU = 0, dV = 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( dV - vdRoots[k]) < EPS_PARAM ;
-         if ( ! bAlreadyFound) {
-            dU = (dV * (C1 - C2) + ( D1 - D2)) / ( dV * ( A2 - A1) + ( B2 - B1)) ;
-            if ( dU > - EPS_ZERO  &&  dU < 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 ;
-               UpdateInfoIntersLineSurfBz( ptL, vtL, ILTA_NO_TRIA, -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 ;
-}

IntersLineSurfStd.cpp

@@ -1662,7 +1662,7 @@ LineTorus( const Point3d& ptLine, const Vector3d& vtLine,
   // Riordino le soluzioni
    for ( int ni = 0 ; ni < int( vdPar.size()) - 1 ; ++ ni) {
       for ( int nj = ni ; nj < int( vdPar.size()) ; ++ nj) {
-         if ( vdPar[ni] > vdPar[nj]) {
+         if( vdPar[ni] > vdPar[nj]) {
             swap( vdPar[ni], vdPar[nj]) ;
          }
       }

IntersLineSurfTm.cpp

@@ -23,20 +23,20 @@ using namespace std ;
 //----------------------------------------------------------------------------
 static void
 UpdateInfoIntersLineSurfTm( const Point3d& ptL, const Vector3d& vtDir, double dLen,
-                            int nStm, int nT, const Triangle3d& Tria, ILSIVECTOR& vInfo, bool bFinite)
+                            int nT, const Triangle3d& Tria, ILSIVECTOR& vInfo, bool bFinite)
 {
    Point3d ptInt, ptInt2 ;
    int nRes = IntersLineTria( ptL, vtDir, dLen, Tria, ptInt, ptInt2, bFinite) ;
    if ( nRes == ILTT_IN  ||  nRes == ILTT_EDGE  ||  nRes == ILTT_VERT) {
       double dU = ( ptInt - ptL) * vtDir ;
       double dCosDN = vtDir * Tria.GetN() ;
-      vInfo.emplace_back( nRes, dU, nStm, nT, dCosDN, ptInt) ;
+      vInfo.emplace_back( nRes, dU, nT, dCosDN, ptInt) ;
    }
    else if ( nRes == ILTT_SEGM  ||  nRes == ILTT_SEGM_ON_EDGE) {
       double dU = ( ptInt - ptL) * vtDir ;
       double dU2 = ( ptInt2 - ptL) * vtDir ;
       double dCosDN = vtDir * Tria.GetN() ;
-      vInfo.emplace_back( nRes, dU, dU2, nStm, nT, dCosDN, ptInt, ptInt2) ;
+      vInfo.emplace_back( nRes, dU, dU2, nT, dCosDN, ptInt, ptInt2) ;
    }
 }
 
@@ -48,7 +48,7 @@ OrderInfoIntersLineSurfTm( ILSIVECTOR& vInfo)
    if ( vInfo.empty())
       return ;
   // ordino il vettore delle intersezioni secondo il senso crescente del parametro di linea
-   sort( vInfo.begin(), vInfo.end(),
+   sort( vInfo.begin(), vInfo.end(), 
             []( const IntLinStmInfo& a, const IntLinStmInfo& b)
                {  double dUa = ( ( a.nILTT == ILTT_SEGM  ||  a.nILTT == ILTT_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
                   double dUb = ( ( b.nILTT == ILTT_SEGM  ||  b.nILTT == ILTT_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
@@ -108,7 +108,7 @@ IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
                Triangle3d Tria ;
                Stm.GetTriangle( nT, Tria) ;
               // aggiorno info con intersezione
-               UpdateInfoIntersLineSurfTm( ptL, vtDir, dLen, 0, nT, Tria, vInfo, bFinite) ;
+               UpdateInfoIntersLineSurfTm( ptL, vtDir, dLen, nT, Tria, vInfo, bFinite) ;
             }
          }
       }
@@ -124,23 +124,19 @@ IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
 //  Intersezione di molte linee parallele con una superficie TriMesh
 //----------------------------------------------------------------------------
 IntersParLinesSurfTm::IntersParLinesSurfTm( const Frame3d& frLines, const ISurfTriMesh& Stm)
-   : m_bOk( false), m_frLines( frLines), m_vpSTm( {&Stm})
+   : m_bOk( false), m_frLines( frLines), m_pSTm( &Stm)
 {
   // verifico esistenza superficie
-   if ( m_vpSTm[0] == nullptr  ||  ! m_vpSTm[0]->IsValid())
+   if ( m_pSTm == nullptr  ||  ! m_pSTm->IsValid())
       return ;
 
-  // aggiorno il vettore degli indici di base per mappare i triangoli con le rispettivi superfici
-  // ( in questo caso la superficie è unica, quindi ho solo due elementi)
-   m_vBaseInd = { 0, m_vpSTm[0]->GetTriangleCount()} ;
-
-  // creo HashGrid 2d ed eventualmente attivo la griglia
+  // creo HashGrid 2d
    const int LIM_HG_TRIA = 127 ;
-   m_HGrids.SetActivationGrid( m_vBaseInd.back() > LIM_HG_TRIA) ;
+   m_HGrids.SetActivationGrid( m_pSTm->GetTriangleCount() > LIM_HG_TRIA) ;
 
-  // riempio HashGrid
+  // riempio HashGrid 
    Triangle3d Tria ;
-   int nT = m_vpSTm[0]->GetFirstTriangle( Tria) ;
+   int nT = Stm.GetFirstTriangle( Tria) ;
    while ( nT != SVT_NULL) {
      // calcolo il BBox del triangolo nel riferimento scelto
       Tria.ToLoc( m_frLines) ;
@@ -149,55 +145,10 @@ IntersParLinesSurfTm::IntersParLinesSurfTm( const Frame3d& frLines, const ISurfT
       b3Tria.Add( Tria.GetP( 1)) ;
       b3Tria.Add( Tria.GetP( 2)) ;
      // inserisco nella griglia
-      if ( ! m_HGrids.Add( nT, b3Tria))  // ( 0 + nT, Tria)
+      if ( ! m_HGrids.Add( nT, b3Tria))
          return ;
-     // passo al prossimo triangolo
-      nT = m_vpSTm[0]->GetNextTriangle( nT, Tria) ;
-   }
-  // aggiorno
-   m_bOk = m_HGrids.Update() ;
-}
-
-//----------------------------------------------------------------------------
-//  Intersezione di molte linee parallele con un vettore di superfici TriMesh
-//----------------------------------------------------------------------------
-IntersParLinesSurfTm::IntersParLinesSurfTm( const Frame3d& frLines, const CISURFTMPVECTOR& vStm)
-   : m_bOk( false), m_frLines( frLines), m_vpSTm( vStm), m_vBaseInd( {0})
-{
-  // verifico esistenza superfici
-   if ( m_vpSTm.empty())
-      return ;
-   for ( const ISurfTriMesh* pStm : m_vpSTm) {
-      if ( pStm == nullptr  ||  ! pStm->IsValid())
-         return ;
-   }
-
-  // aggiorno il vettore degli indici di base per mappare i triangoli con le rispettivi superfici
-  // NB. dal costruttore è già inizializzato a {0}
-   for ( int i = 0 ; i < int( m_vpSTm.size()) ; ++ i)
-      m_vBaseInd.emplace_back( m_vBaseInd.back() + m_vpSTm[i]->GetTriangleCount()) ;
-
-  // creo HashGrid 2d ed eventualmente attivo la griglia
-   const int LIM_HG_TRIA = 256 ;
-   m_HGrids.SetActivationGrid( m_vBaseInd.back() > LIM_HG_TRIA) ;
-
-  // riempio HashGrid
-   for ( int i = 0 ; i < int( m_vpSTm.size()) ; ++ i) {
-      Triangle3d Tria ;
-      int nT = m_vpSTm[i]->GetFirstTriangle( Tria) ;
-      while ( nT != SVT_NULL) {
-        // calcolo il BBox del triangolo nel riferimento scelto
-         Tria.ToLoc( m_frLines) ;
-         BBox3d b3Tria ;
-         b3Tria.Add( Tria.GetP( 0)) ;
-         b3Tria.Add( Tria.GetP( 1)) ;
-         b3Tria.Add( Tria.GetP( 2)) ;
-        // inserisco nella griglia ( aggiungo shift per indice del triangolo)
-         if ( ! m_HGrids.Add( m_vBaseInd[i] + nT, b3Tria))
-            return ;
-        // passo al prossimo triangolo
-         nT = m_vpSTm[i]->GetNextTriangle( nT, Tria) ;
-      }
+     // passo al prossimo triangolo 
+      nT = Stm.GetNextTriangle( nT, Tria) ;
    }
   // aggiorno
    m_bOk = m_HGrids.Update() ;
@@ -211,7 +162,7 @@ IntersParLinesSurfTm::GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vI
    if ( &vInfo == nullptr)
       return false ;
    vInfo.clear() ;
-  // verifico validità
+  // verifico validità
    if ( ! m_bOk)
       return false ;
 
@@ -223,22 +174,15 @@ IntersParLinesSurfTm::GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vI
    Point3d ptLL = ptL ;
    ptLL.ToGlob( m_frLines) ;
 
-  // recupero indici triangoli che intersecano box in 2d
+  // recupero indici triangoli che intersecano box in 2d 
    INTVECTOR vnIds ;
    if ( m_HGrids.Find( b3Line, vnIds)) {
       for ( int i = 0 ; i < int( vnIds.size()) ; ++ i) {
-        // recupero la superficie
-         int nInd = vnIds[i] ;
-         int nSurf = GetSurfInd( nInd) ;
-         if ( nSurf == -1)
-            return false ;
-        // recupero il triangolo
-         int nT = nInd - m_vBaseInd[nSurf] ;
+         int nT = vnIds[i] ;
          Triangle3d Tria ;
-         if ( ! m_vpSTm[nSurf]->GetTriangle( nT, Tria))
-            return false ;
+         m_pSTm->GetTriangle( nT, Tria) ;
         // aggiorno info con intersezione
-         UpdateInfoIntersLineSurfTm( ptLL, m_frLines.VersZ(), dLen, nSurf, nT, Tria, vInfo, bFinite) ;
+         UpdateInfoIntersLineSurfTm( ptLL, m_frLines.VersZ(), dLen, nT, Tria, vInfo, bFinite) ;
       }
    }
 
@@ -248,35 +192,6 @@ IntersParLinesSurfTm::GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vI
    return true ;
 }
 
-//----------------------------------------------------------------------------
-int
-IntersParLinesSurfTm::GetSurfInd( int nT) const
-{
-  // verifico la presenza di almeno un intervallo
-   if ( m_vBaseInd.size() < 2)
-      return -1 ;
-  // se la superficie è unica, allora non devo cercarla
-   if ( int( m_vBaseInd.size()) == 2)
-      return 0 ;
-  // ricerca binaria dell'intervallo contenente la posizione del triangolo
-   int nS = 0 ;
-   int nE = int( m_vBaseInd.size()) - 1 ;
-   while ( true) {
-      if ( nT < m_vBaseInd[nS]  ||  nT >= m_vBaseInd[nE])
-         return -1 ;
-      if ( nE - nS == 1)
-         return nS ;
-      int nM = ( nS + nE) / 2 ;
-      if ( nT == m_vBaseInd[nM])
-         return nM ;
-      if ( nT < m_vBaseInd[nM])
-         nE = nM ;
-      else
-         nS = nM ;
-   }
-   return -1 ;
-}
-
 //----------------------------------------------------------------------------
 bool
 FilterLineSurfTmInters( const ILSIVECTOR& vInfo, INTDBLVECTOR& vInters)
@@ -302,7 +217,7 @@ FilterLineSurfTmInters( const ILSIVECTOR& vInfo, INTDBLVECTOR& vInters)
    for ( size_t j = 1 ; j < vInters.size() ; ) {
      // intersezione precedente
       size_t i = j - 1 ;
-     // se hanno lo stesso parametro
+     // se hanno lo stesso parametro 
       if ( abs( vInters[i].second - vInters[j].second) < EPS_SMALL) {
         // se sono entrambe entranti o uscenti, elimino la seconda
          if ( ( vInters[i].first == LST_IN  &&  vInters[j].first == LST_IN)  ||

IntersPlaneVolZmap.cpp

@@ -19,7 +19,7 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-//  Intersezione di un piano con la superficie di un solido VolZmap
+//  Intersezione di unpiano con la superficie di un solido VolZmap
 //----------------------------------------------------------------------------
 bool
 IntersPlaneVolZmap( const Plane3d& plPlane, const IVolZmap& Vzm, ICURVEPOVECTOR& vpLoop)
@@ -28,6 +28,9 @@ IntersPlaneVolZmap( const Plane3d& plPlane, const IVolZmap& Vzm, ICURVEPOVECTOR&
    const VolZmap* pVzm = GetBasicVolZmap( &Vzm) ;
    if ( pVzm == nullptr)
       return false ;
+  // verifico parametro di ritorno
+   if ( &vpLoop == nullptr)
+      return false ;
 
   // eseguo intersezione
    return pVzm->GetPlaneIntersection( plPlane, vpLoop) ;

MultiGeomDB.cpp

@@ -1,258 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025-2025
-//----------------------------------------------------------------------------
-// File : MultiGeomDB.cpp       Data : 08.10.25          Versione : 2.7j1
-// Contenuto : Implementazione delle funzioni tra due GeomDB.
-//
-//
-//
-// Modifiche : 08.10.25 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "GeomDB.h"
-#include "/EgtDev/Include/EGkMultiGeomDB.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-static int
-CopyGeoObj( const GeomDB* pSouGDB, int nSouId, GeomDB* pDstGDB, int nDestId, int nRefId, int nSonBeforeAfter, bool bGlob)
-{
-  // recupero l'oggetto da copiare dal GeomDB sorgente
-   PtrOwner<IGeoObj> pGObj( pSouGDB->GetGeoObj( nSouId)->Clone()) ;
-   if ( IsNull( pGObj))
-      return GDB_ID_NULL ;
-  // se in globale
-   if ( bGlob) {
-     // recupero il riferimento del sorgente
-      Frame3d frSou ;
-      if ( ! pSouGDB->GetGlobFrame( nSouId, frSou))
-         return GDB_ID_NULL ;
-     // recupero il riferimento del gruppo destinazione
-      Frame3d frDest ;
-      int nDestParentId = ( IS_GDB_SON( nSonBeforeAfter) ? nRefId : pDstGDB->GetParentId( nRefId)) ;
-      if ( ! pDstGDB->GetGroupGlobFrame( nDestParentId, frDest))
-         return GDB_ID_NULL ;
-     // porto la copia da riferimento sorgente a quello destinazione
-      pGObj->LocToLoc( frSou, frDest) ;
-   }
-  // lo inserisco nel GeomDB destinazione
-   int nNewId = pDstGDB->InsertGeoObj( nDestId, nRefId, nSonBeforeAfter, Release( pGObj)) ;
-   if ( nNewId == GDB_ID_NULL)
-      return GDB_ID_NULL ;
-  // copio le caratteristiche non geometriche
-   const GdbObj* pSouGdbObj = pSouGDB->GetGdbObj( nSouId) ;
-   GdbObj* pDstGdbObj = pDstGDB->GetGdbObj( nNewId) ;
-   if ( pSouGDB == nullptr  ||  pDstGdbObj == nullptr  ||
-        ! pDstGdbObj->CopyAttribsFrom( pSouGdbObj)  ||
-        ! pDstGdbObj->CopyTextureDataFrom( pSouGdbObj)  ||
-        ! pDstGdbObj->CopyStippleDataFrom( pSouGdbObj)  ||
-        ! pDstGdbObj->CopyUserObjFrom( pSouGdbObj)) {
-      pDstGDB->Erase( nNewId) ;
-      return GDB_ID_NULL ;
-   }
-
-   return nNewId ;
-}
-
-//----------------------------------------------------------------------------
-static int
-CopyGroupObj( const GeomDB* pSouGDB, int nSouId, GeomDB* pDstGDB, int nDestId, int nRefId, int nSonBeforeAfter, bool bGlob)
-{
-  // recupero il riferimento del gruppo
-   Frame3d frFrame = *( pSouGDB->GetGroupFrame( nSouId)) ;
-  // se in globale
-   if ( bGlob) {
-     // recupero il riferimento del gruppo in globale
-      if ( ! pSouGDB->GetGroupGlobFrame( nSouId, frFrame))
-         return GDB_ID_NULL ;
-     // recupero il riferimento del gruppo destinazione
-      Frame3d frDest ;
-      int nDestParentId = ( IS_GDB_SON( nSonBeforeAfter) ? nRefId : pDstGDB->GetParentId( nRefId)) ;
-      if ( ! pDstGDB->GetGroupGlobFrame( nDestParentId, frDest))
-         return GDB_ID_NULL ;
-     // porto la copia da riferimento sorgente a quello destinazione
-      frFrame.ToLoc( frDest) ;
-   }
-  // inserisco un nuovo gruppo nel GeomDB destinazione
-   int nNewId = pDstGDB->InsertGroup( nDestId, nRefId, nSonBeforeAfter, frFrame) ;
-   if ( nNewId == GDB_ID_NULL)
-      return GDB_ID_NULL ;
-  // copio le caratteristiche non geometriche
-   const GdbObj* pSouGdbObj = pSouGDB->GetGdbObj( nSouId) ;
-   GdbObj* pDstGdbObj = pDstGDB->GetGdbObj( nNewId) ;
-   if ( pSouGDB == nullptr  ||  pDstGdbObj == nullptr  ||
-        ! pDstGdbObj->CopyAttribsFrom( pSouGdbObj)  ||
-        ! pDstGdbObj->CopyTextureDataFrom( pSouGdbObj)  ||
-        ! pDstGdbObj->CopyStippleDataFrom( pSouGdbObj)  ||
-        ! pDstGdbObj->CopyUserObjFrom( pSouGdbObj)) {
-      pDstGDB->Erase( nNewId) ;
-      return GDB_ID_NULL ;
-   }
-  // copio gli eventuali figli
-   int nSonSouId = pSouGDB->GetFirstInGroup( nSouId) ;
-   while ( nSonSouId != GDB_ID_NULL) {
-     // nuovo identificativo oggetto destinazione
-      int nSonNewId = GDB_ID_NULL ;
-     // recupero il tipo di oggetto sorgente
-      int nSonSouType = pSouGDB->GetGdbType( nSonSouId) ;
-     // se l'oggetto da copiare è geometrico
-      if ( nSonSouType == GDB_TY_GEO)
-         nSonNewId = CopyGeoObj( pSouGDB, nSonSouId, pDstGDB, GDB_ID_NULL, nNewId, GDB_LAST_SON, false) ;
-     // se altrimenti è un gruppo
-      else if ( nSonSouType == GDB_TY_GROUP)
-         nSonNewId = CopyGroupObj( pSouGDB, nSonSouId, pDstGDB, GDB_ID_NULL, nNewId, GDB_LAST_SON, false) ;
-     // se copia non riuscita, esco con errore
-      if ( nSonNewId == GDB_ID_NULL)
-         return GDB_ID_NULL ;
-     // passo al figlio successivo
-      nSonSouId = pSouGDB->GetNext( nSonSouId) ;
-   }
-
-   return nNewId ;
-}
-
-//----------------------------------------------------------------------------
-static int
-Copy( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter, bool bGlob)
-{
-  // adatto e verifico i GeomDB
-   const GeomDB* pSouGDB = static_cast<GeomDB*>( pSouGeomDB) ;
-   GeomDB* pDstGDB = static_cast<GeomDB*>( pDestGeomDB) ;
-   if ( pSouGDB == nullptr  ||  pDstGDB == nullptr)
-      return GDB_ID_NULL ;
-  // il sorgente non può essere il gruppo radice
-   if ( nSouId == GDB_ID_ROOT)
-      return GDB_ID_NULL ;
-  // nuovo identificativo oggetto destinazione
-   int nNewId = GDB_ID_NULL ;
-  // recupero il tipo di oggetto sorgente
-   int nSouType = pSouGDB->GetGdbType( nSouId) ;
-  // se l'oggetto da copiare è geometrico
-   if ( nSouType == GDB_TY_GEO) {
-      nNewId = CopyGeoObj( pSouGDB, nSouId, pDstGDB, nDestId, nRefId, nSonBeforeAfter, bGlob) ;
-   }
-  // se altrimenti è un gruppo
-   else if ( nSouType == GDB_TY_GROUP) {
-      nNewId = CopyGroupObj(  pSouGDB, nSouId, pDstGDB, nDestId, nRefId, nSonBeforeAfter, bGlob) ;
-   }
-
-   return nNewId ;
-}
-
-//----------------------------------------------------------------------------
-int
-Copy( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter)
-{
-   return Copy( pSouGeomDB, nSouId, pDestGeomDB, nDestId, nRefId, nSonBeforeAfter, false) ;
-}
-
-//----------------------------------------------------------------------------
-int
-CopyGlob( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter)
-{
-   return Copy( pSouGeomDB, nSouId, pDestGeomDB, nDestId, nRefId, nSonBeforeAfter, true) ;
-}
-
-//----------------------------------------------------------------------------
-static int
-DuplicateGeoObj( const GeomDB* pSouGDB, int nSouId, GeomDB* pDstGDB, int nDestId, int nRefId)
-{
-  // recupero l'oggetto da copiare dal GeomDB sorgente
-   PtrOwner<IGeoObj> pGObj( pSouGDB->GetGeoObj( nSouId)->Clone()) ;
-   if ( IsNull( pGObj))
-      return GDB_ID_NULL ;
-  // lo inserisco nel GeomDB destinazione
-   int nNewId = pDstGDB->InsertGeoObj( nDestId, nRefId, GDB_LAST_SON, Release( pGObj)) ;
-   if ( nNewId != nDestId) {
-      pDstGDB->Erase( nNewId) ;
-      return GDB_ID_NULL ;
-   }
-  // copio le caratteristiche non geometriche
-   const GdbObj* pSouGdbObj = pSouGDB->GetGdbObj( nSouId) ;
-   GdbObj* pDstGdbObj = pDstGDB->GetGdbObj( nNewId) ;
-   if ( pSouGDB == nullptr  ||  pDstGdbObj == nullptr  ||
-        ! pDstGdbObj->CopyAttribsFrom( pSouGdbObj)  ||
-        ! pDstGdbObj->CopyTextureDataFrom( pSouGdbObj)  ||
-        ! pDstGdbObj->CopyStippleDataFrom( pSouGdbObj)  ||
-        ! pDstGdbObj->CopyUserObjFrom( pSouGdbObj)) {
-      pDstGDB->Erase( nNewId) ;
-      return GDB_ID_NULL ;
-   }
-
-   return nNewId ;
-}
-
-//----------------------------------------------------------------------------
-static int
-DuplicateGroupObj( const GeomDB* pSouGDB, int nSouId, GeomDB* pDstGDB, int nDestId, int nRefId, bool bSkipTemp)
-{
-   int nNewId = GDB_ID_ROOT ;
-   if ( nSouId != GDB_ID_ROOT) {
-     // recupero il riferimento del gruppo
-      Frame3d frFrame = *( pSouGDB->GetGroupFrame( nSouId)) ;
-     // inserisco un nuovo gruppo nel GeomDB destinazione
-      nNewId = pDstGDB->InsertGroup( nDestId, nRefId, GDB_LAST_SON, frFrame) ;
-      if ( nNewId != nSouId) {
-         pDstGDB->Erase( nNewId) ;
-         return GDB_ID_NULL ;
-      }
-     // copio le caratteristiche non geometriche
-      const GdbObj* pSouGdbObj = pSouGDB->GetGdbObj( nSouId) ;
-      GdbObj* pDstGdbObj = pDstGDB->GetGdbObj( nNewId) ;
-      if ( pSouGDB == nullptr  ||  pDstGdbObj == nullptr  ||
-           ! pDstGdbObj->CopyAttribsFrom( pSouGdbObj)  ||
-           ! pDstGdbObj->CopyTextureDataFrom( pSouGdbObj)  ||
-           ! pDstGdbObj->CopyStippleDataFrom( pSouGdbObj)  ||
-           ! pDstGdbObj->CopyUserObjFrom( pSouGdbObj)) {
-         pDstGDB->Erase( nNewId) ;
-         return GDB_ID_NULL ;
-      }
-   }
-  // copio gli eventuali figli
-   int nSonSouId = pSouGDB->GetFirstInGroup( nSouId) ;
-   while ( nSonSouId != GDB_ID_NULL) {
-     // verifico se non richiesto di saltare i temporanei oppure non lo è
-      int nLevel ;
-      if ( ! bSkipTemp  ||  ! pSouGDB->GetLevel( nSonSouId, nLevel)  ||  nLevel != GDB_LV_TEMP) {
-        // nuovo identificativo oggetto destinazione
-         int nSonNewId = GDB_ID_NULL ;
-        // recupero il tipo di oggetto sorgente
-         int nSonSouType = pSouGDB->GetGdbType( nSonSouId) ;
-        // se l'oggetto da copiare è geometrico
-         if ( nSonSouType == GDB_TY_GEO)
-            nSonNewId = DuplicateGeoObj( pSouGDB, nSonSouId, pDstGDB, nSonSouId, nNewId) ;
-        // se altrimenti è un gruppo
-         else if ( nSonSouType == GDB_TY_GROUP)
-            nSonNewId = DuplicateGroupObj( pSouGDB, nSonSouId, pDstGDB, nSonSouId, nNewId, bSkipTemp) ;
-        // se copia non riuscita, esco con errore
-         if ( nSonNewId != nSonSouId)
-            return GDB_ID_NULL ;
-      }
-     // passo al figlio successivo
-      nSonSouId = pSouGDB->GetNext( nSonSouId) ;
-   }
-
-   return nNewId ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DuplicateGeomDB( IGeomDB* pSouGeomDB, IGeomDB* pDestGeomDB, bool bSkipTemp)
-{
-  // adatto e verifico i GeomDB
-   const GeomDB* pSouGDB = static_cast<GeomDB*>( pSouGeomDB) ;
-   GeomDB* pDstGDB = static_cast<GeomDB*>( pDestGeomDB) ;
-   if ( pSouGDB == nullptr  ||  pDstGDB == nullptr)
-      return false ;
-  // verifico che la destinazione sia vuota
-   if ( pDstGDB->GetFirstInGroup( GDB_ID_ROOT) != GDB_ID_NULL)
-      return false ;
-  // eseguo la copia di tutto (se richiesto salto gli oggetti temporanei)
-   return ( DuplicateGroupObj( pSouGDB, GDB_ID_ROOT, pDstGDB, GDB_ID_ROOT, GDB_ID_ROOT, bSkipTemp) != GDB_ID_NULL) ;
-}

NgeReader.cpp

@@ -17,7 +17,6 @@
 #include "NgeKeyW.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
-#include "/EgtDev/Extern/zlib/Include/zlib.h"
 
 using namespace std ;
 
@@ -35,12 +34,8 @@ NgeReader::Init( const string& sFileIn)
       break ;
    case NGE_BINARY :
       m_bBinary = true ;
-      m_InFile = gzopen_w( stringtoW( sFileIn), "rb") ;
-      if ( m_InFile == nullptr)
-         return false ;
-      const int DIM_BUFFER = 65536 ;
-      gzbuffer( m_InFile, DIM_BUFFER) ;
-      return true ;
+      m_InFile.open( stringtoW( sFileIn), ios::in | ios::binary, _SH_DENYWR) ;
+      return ( ! m_InFile.fail()) ;
       break ;
    }
    return false ;
@@ -51,12 +46,10 @@ bool
 NgeReader::Close( void) 
 {
    if ( m_bBinary) {
-      if ( m_InFile != nullptr) {
-         bool bOk = ( gzclose( m_InFile) == Z_OK) ;
-         m_InFile = nullptr ;
-         return bOk ;
-      }
-      return true ;
+      bool bOk = ( m_InFile.good()  &&  m_InFile.is_open()) ;
+      if ( m_InFile.is_open())
+         m_InFile.close() ;
+      return bOk ;
    }
    else
       return m_Scan.Terminate() ;
@@ -66,24 +59,31 @@ NgeReader::Close( void)
 int
 NgeReader::NgeType( const string& sFile)
 {
-  // apertura file
-   gzFile_s* InFile = gzopen_w( stringtoW( sFile), "rb") ;
-   if ( InFile == nullptr)
+  // apertura del file di ingresso
+   ifstream InFile ;
+   InFile.open( stringtoW( sFile), ios::in | ios::binary) ;
+   if ( InFile.fail())
       return NGE_ERROR ;
-  // lettura dei primi caratteri
-   char szBuff[9] = "\0\0\0\0\0\0\0\0" ;
-   int nLen = gzread( InFile, &szBuff, 8) ;
-   if ( gzclose( InFile) != Z_OK  ||  nLen == Z_ERRNO)
-      return NGE_ERROR ;
-  // se binario
-   if ( szBuff[0] == '\x0F'  &&  szBuff[1] == '\x0F')
-      return NGE_BINARY ;
-  // se testo
-   string sBuff{ szBuff} ;
-   if ( sBuff.find( "START") != string::npos)
+
+  // lettura dei primi 31 byte
+   char cBuff[32] ;
+   InFile.read( cBuff, 31) ;
+   cBuff[InFile.gcount()] = '\0' ;
+
+  // chiusura del file
+   InFile.close() ;
+
+  // verifico se file compresso (gz)
+   if ( cBuff[0] == '\x1F'  &&  cBuff[1] == '\x8B')
       return NGE_ASCII ;
-  // altrimenti errore
-   return NGE_ERROR ;
+
+  // verifico se iniziano con "START"
+   string sBuff = cBuff ;
+   size_t nPos = sBuff.find( "START") ;
+   if ( nPos != string::npos  &&  nPos < 10)
+      return NGE_ASCII ;
+   else
+      return NGE_BINARY ;
 }
 
 //----------------------------------------------------------------------------
@@ -91,7 +91,7 @@ int
 NgeReader::GetCurrPos( void)
 {
    if ( m_bBinary)
-      return int( gztell( m_InFile)) ;
+      return int( m_InFile.tellg()) ;
    else
       return m_Scan.GetCurrLineNbr() ;
 }
@@ -131,9 +131,10 @@ bool
 NgeReader::ReadUchar( unsigned char& ucVal, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
-      return ( gzread( m_InFile, &ucVal, sizeof( ucVal)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &ucVal, sizeof( ucVal)) ;
+      return m_InFile.good() ;
    }
    else {
      // recupero il token
@@ -153,9 +154,10 @@ bool
 NgeReader::ReadBool( bool& bVal, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
-      return ( gzread( m_InFile, &bVal, sizeof( bVal)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &bVal, sizeof( bVal)) ;
+      return m_InFile.good() ;
    }
    else {
      // recupero il token
@@ -171,9 +173,10 @@ bool
 NgeReader::ReadInt( int& nVal, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
-      return ( gzread( m_InFile, &nVal, sizeof( nVal)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &nVal, sizeof( nVal)) ;
+      return m_InFile.good() ;
    }
    else {
      // recupero il token
@@ -200,9 +203,10 @@ bool
 NgeReader::ReadDouble( double& dVal, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
-      return ( gzread( m_InFile, &dVal, sizeof( dVal)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &dVal, sizeof( dVal)) ;
+      return m_InFile.good() ;
    }
    else {
      // recupero il token
@@ -218,9 +222,10 @@ bool
 NgeReader::ReadVector( Vector3d& vtV, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
-      return ( gzread( m_InFile, &vtV.v, sizeof( vtV.v)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &vtV.v, sizeof( vtV.v)) ;
+      return m_InFile.good() ;
    }
    else {
      // recupero il token
@@ -236,9 +241,10 @@ bool
 NgeReader::ReadPoint( Point3d& ptP, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
-      return ( gzread( m_InFile, &ptP.v, sizeof( ptP.v)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &ptP.v, sizeof( ptP.v)) ;
+      return m_InFile.good() ;
    }
    else {
      // recupero il token
@@ -254,10 +260,11 @@ bool
 NgeReader::ReadPointW( Point3d& ptP, double& dW, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
-      return ( gzread( m_InFile, &ptP.v, sizeof( ptP.v)) != Z_ERRNO  &&
-               gzread( m_InFile, &dW, sizeof( dW)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &ptP.v, sizeof( ptP.v)) ;
+      m_InFile.read( (char*) &dW, sizeof( dW)) ;
+      return m_InFile.good() ;
    }
    else {
      // recupero il token
@@ -273,13 +280,17 @@ bool
 NgeReader::ReadFrame( Frame3d& frF, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
-      Point3d ptOrig ; Vector3d vtDirX, vtDirY, vtDirZ ;
-      if ( gzread( m_InFile, &ptOrig.v, sizeof( ptOrig.v)) == Z_ERRNO  ||
-           gzread( m_InFile, &vtDirX.v, sizeof( vtDirX.v)) == Z_ERRNO  ||
-           gzread( m_InFile, &vtDirY.v, sizeof( vtDirY.v)) == Z_ERRNO  ||
-           gzread( m_InFile, &vtDirZ.v, sizeof( vtDirZ.v)) == Z_ERRNO)
+      Point3d ptOrig ;
+      m_InFile.read( (char*) &ptOrig.v, sizeof( ptOrig.v)) ;
+      Vector3d vtDirX ;
+      m_InFile.read( (char*) &vtDirX.v, sizeof( vtDirX.v)) ;
+      Vector3d vtDirY ;
+      m_InFile.read( (char*) &vtDirY.v, sizeof( vtDirY.v)) ;
+      Vector3d vtDirZ ;
+      m_InFile.read( (char*) &vtDirZ.v, sizeof( vtDirZ.v)) ;
+      if ( ! m_InFile.good())
          return false ;
       return frF.Set( ptOrig, vtDirX, vtDirY, vtDirZ) ;
    }
@@ -297,20 +308,18 @@ bool
 NgeReader::ReadString( string& sVal, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
-         return false ;
       const int MAX_STR_DIM = 65535 ;
-      int nDim ;
-      if ( gzread( m_InFile, &nDim, sizeof( nDim)) == Z_ERRNO  ||  nDim > MAX_STR_DIM)
+      if ( ! m_InFile.is_open())
+         return false ;
+      int nDim ;
+      m_InFile.read( (char*) &nDim, sizeof( nDim)) ;
+      if ( nDim > MAX_STR_DIM  ||  ! m_InFile.good())
          return false ;
-      if ( nDim == 0) {
-         sVal = "" ;
-         return true ;
-      }
       char* szBuff = new( nothrow) char[ nDim + 1] ;
       if ( szBuff == nullptr)
          return false ;
-      if ( gzread( m_InFile, szBuff, nDim) == Z_ERRNO) {
+      m_InFile.read( szBuff, nDim) ;
+      if ( ! m_InFile.good()) {
          delete[] szBuff ;
          return false ;
       }
@@ -339,11 +348,12 @@ NgeReader::ReadKey( int& nKey)
       return true ;
    }
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
      // leggo il dato
       int nVal ;
-      if ( gzread( m_InFile, &nVal, sizeof( nVal)) == Z_ERRNO)
+      m_InFile.read( (char*) &nVal, sizeof( nVal)) ;
+      if ( ! m_InFile.good())
          return false ;
      // ricavo l'indice
       for ( int i = 0 ; i <= NGE_LAST_ID ; ++ i) {
@@ -376,10 +386,11 @@ bool
 NgeReader::ReadCol( Color& cCol, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
          return false ;
       unsigned char ucCol[4] ;
-      if ( gzread( m_InFile, &ucCol, sizeof( ucCol)) == Z_ERRNO)
+      m_InFile.read( (char*) &ucCol, sizeof( ucCol)) ;
+      if ( ! m_InFile.good())
          return false ;
       cCol.Set( ucCol[0], ucCol[1], ucCol[2], ucCol[3]) ;
       return true ;

NgeReader.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2025
+//  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : NgeReader.h          Data : 29.12.25           Versione : 2.7l6
+// File : NgeReader.h          Data : 14.04.14           Versione : 1.5d5
 // Contenuto : Dichiarazione della classe NgeReader.
 //
 //
@@ -18,16 +18,14 @@
 #include "/EgtDev/Include/EGkColor.h"
 #include "/EgtDev/Include/EGnScanner.h"
 #include "/EgtDev/Include/EgtStringBase.h"
-
-struct gzFile_s ;
+#include <fstream>
 
 //----------------------------------------------------------------------------
 class NgeReader
 {
    public :
       NgeReader( void)
-            : m_bBinary( false), m_InFile( nullptr), m_iPosStart( std::string::npos),
-              m_bUngetKey( false), m_nLastKey(), m_nFileVer() {}
+            : m_iPosStart( std::string::npos), m_bUngetKey( false), m_nFileVer() {}
       ~NgeReader( void)
             { Close() ; }
       bool Init( const std::string& sFileIn) ;
@@ -62,7 +60,7 @@ class NgeReader
    private :
       bool                   m_bBinary ;
       // per file binari
-      gzFile_s*              m_InFile ;
+      std::ifstream          m_InFile ;
       // per file ASCII
       Scanner                m_Scan ;
       std::string::size_type m_iPosStart ;

NgeWriter.cpp

@@ -23,23 +23,23 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-static bool
-WriteStringOutTxt( gzFile OutFile, const char* szVal, const char* szSep, bool bEndL)
+inline bool
+WriteStringOutTxt( gzFile OutTxtFile, const char* szVal, const char* szSep, bool bEndL)
 {
   // verifico apertura file
-   if ( OutFile == nullptr)
+   if ( OutTxtFile == nullptr)
       return false ;
   // scrivo stringa
-   if ( gzputs( OutFile, szVal) == Z_ERRNO)
+   if ( gzputs( OutTxtFile, szVal) == Z_ERRNO)
       return false ;
   // se fornito, scrivo separatore
    if ( szSep != nullptr  &&  szSep[0] != '\0') {
-      if ( gzputs( OutFile, szSep) == Z_ERRNO)
+      if ( gzputs( OutTxtFile, szSep) == Z_ERRNO)
          return false ;
    }
   // se richiesto, scrivo fine linea
    if ( bEndL) {
-      if ( gzputs( OutFile, "\r\n") == Z_ERRNO)
+      if ( gzputs( OutTxtFile, "\r\n") == Z_ERRNO)
          return false ;
    }
    return true ;
@@ -50,22 +50,27 @@ bool
 NgeWriter::Init( const string& sFileOut, int nFlag) 
 {
   // salvo tipo file
-   m_bBinary = ( nFlag == GDB_SV_BIN  ||  nFlag == GDB_SV_CMPBIN) ;
+   m_bBinary = ( nFlag == GDB_SV_BIN) ;
 
   // apertura del file di uscita
-   if ( nFlag == GDB_SV_TXT  ||  nFlag == GDB_SV_BIN) {
-      m_OutFile = gzopen_w( stringtoW( sFileOut), "wbT") ;
-      return ( m_OutFile != nullptr) ;
+   if ( m_bBinary) {
+      ios_base::openmode nMode = ios::out | ( m_bBinary ? ios::binary : 0) ;
+      int nProt = _SH_DENYWR ;
+      m_OutBinFile.open( stringtoW( sFileOut), nMode, nProt) ;
+      return m_OutBinFile.good() ;
    }
-   else {     // GDB_SV_CMPTXT  o  GDB_SV_CMPBIN
-      m_OutFile = gzopen_w( stringtoW( sFileOut), "wb") ;
-      if ( m_OutFile == nullptr)
+   else {
+      if ( nFlag == GDB_SV_TXT)
+         m_OutTxtFile = gzopen_w( stringtoW( sFileOut), "wbT") ;
+      else       // GDB_SV_CMPTXT
+         m_OutTxtFile = gzopen_w( stringtoW( sFileOut), "wb") ;
+      if ( m_OutTxtFile == nullptr)
          return false ;
       const int DIM_BUFFER = 65536 ;
-      if ( gzbuffer( m_OutFile, DIM_BUFFER) != Z_OK)
+      if ( gzbuffer( m_OutTxtFile, DIM_BUFFER) != Z_OK)
          return false ;
       const int COMPR_LEVEL = 3 ;    // 0 = no compression ... 9 = max compression
-      if ( gzsetparams( m_OutFile, COMPR_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK)
+      if ( gzsetparams( m_OutTxtFile, COMPR_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK)
          return false ;
       return true ;
    }
@@ -75,12 +80,20 @@ NgeWriter::Init( const string& sFileOut, int nFlag)
 bool
 NgeWriter::Close( void) 
 {
-   if ( m_OutFile != nullptr) {
-      bool bOk = ( gzclose( m_OutFile) == Z_OK) ;
-      m_OutFile = nullptr ;
+   if ( m_bBinary) {
+      bool bOk = ( m_OutBinFile.good()  &&  m_OutBinFile.is_open()) ;
+      if ( m_OutBinFile.is_open())
+         m_OutBinFile.close() ;
       return bOk ;
    }
-   return true ;
+   else {
+      if ( m_OutTxtFile != nullptr) {
+         bool bOk = ( gzclose( m_OutTxtFile) == Z_OK) ;
+         m_OutTxtFile = nullptr ;
+         return bOk ;
+      }
+      return true ;
+   }
 }
 
 //----------------------------------------------------------------------------
@@ -88,12 +101,13 @@ bool
 NgeWriter::WriteUchar( unsigned char ucVal, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      return ( gzwrite( m_OutFile, &ucVal, sizeof( ucVal)) > 0) ;
+      m_OutBinFile.write( (char*) &ucVal, sizeof( ucVal)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, ToString( ucVal).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( ucVal).c_str(), szSep, bEndL) ;
    }
 }
 
@@ -102,12 +116,13 @@ bool
 NgeWriter::WriteBool( bool bVal, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      return ( gzwrite( m_OutFile, &bVal, sizeof( bVal)) > 0) ;
+      m_OutBinFile.write( (char*) &bVal, sizeof( bVal)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, ToString( bVal).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( bVal).c_str(), szSep, bEndL) ;
    }
 }
 
@@ -116,12 +131,13 @@ bool
 NgeWriter::WriteInt( int nVal, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      return ( gzwrite( m_OutFile, &nVal, sizeof( nVal)) > 0) ;
+      m_OutBinFile.write( (char*) &nVal, sizeof( nVal)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, ToString( nVal).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( nVal).c_str(), szSep, bEndL) ;
    }
 }
 
@@ -130,12 +146,13 @@ bool
 NgeWriter::WriteDouble( double dVal, const char* szSep, bool bEndL, int nPrec)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      return ( gzwrite( m_OutFile, &dVal, sizeof( dVal)) > 0) ;     
+      m_OutBinFile.write( (char*) &dVal, sizeof( dVal)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, ToString( dVal, nPrec).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( dVal, nPrec).c_str(), szSep, bEndL) ;
    }
 }
 
@@ -144,14 +161,15 @@ bool
 NgeWriter::WriteString( const string& sVal, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      int nDim = ssize( sVal) ;
-      return ( gzwrite( m_OutFile, &nDim, sizeof( nDim)) > 0  &&
-               ( nDim == 0  ||  gzwrite( m_OutFile, sVal.c_str(), sVal.size()) > 0)) ;
+      int nDim = int( sVal.size()) ; 
+      m_OutBinFile.write( (char*) &nDim, sizeof( nDim)) ;
+      m_OutBinFile.write( sVal.c_str(), sVal.size()) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, sVal.c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, sVal.c_str(), szSep, bEndL) ;
    }
 }
 
@@ -160,12 +178,13 @@ bool
 NgeWriter::WriteVector( const Vector3d& vtV, const char* szSep, bool bEndL, int nPrec)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      return ( gzwrite( m_OutFile, &vtV.v, sizeof( vtV.v)) > 0) ;
+      m_OutBinFile.write( (char*) &vtV.v, sizeof( vtV.v)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, ToString( vtV, nPrec).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( vtV, nPrec).c_str(), szSep, bEndL) ;
    }
 }
 
@@ -174,12 +193,13 @@ bool
 NgeWriter::WritePoint( const Point3d& ptP, const char* szSep, bool bEndL, int nPrec)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      return ( gzwrite( m_OutFile, &ptP.v, sizeof( ptP.v)) > 0) ;
+      m_OutBinFile.write( (char*) &ptP.v, sizeof( ptP.v)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, ToString( ptP, nPrec).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( ptP, nPrec).c_str(), szSep, bEndL) ;
    }
 }
 
@@ -188,13 +208,14 @@ bool
 NgeWriter::WritePointW( const Point3d& ptP, double dW, const char* szSep, bool bEndL, int nPrecP, int nPrecW)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      return ( gzwrite( m_OutFile, &ptP.v, sizeof( ptP.v)) > 0  &&
-               gzwrite( m_OutFile, &dW, sizeof( dW)) > 0) ;
+      m_OutBinFile.write( (char*) &ptP.v, sizeof( ptP.v)) ;
+      m_OutBinFile.write( (char*) &dW, sizeof( dW)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, ToString( ptP, dW, nPrecP, nPrecW).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( ptP, dW, nPrecP, nPrecW).c_str(), szSep, bEndL) ;
    }
 }
 
@@ -203,15 +224,16 @@ bool
 NgeWriter::WriteFrame( const Frame3d& frF, const char* szSep, bool bEndL, int nPrecP, int nPrecV)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      return ( gzwrite( m_OutFile, &frF.Orig().v, sizeof( frF.Orig().v)) > 0  &&
-               gzwrite( m_OutFile, &frF.VersX().v, sizeof( frF.VersX().v)) > 0  &&
-               gzwrite( m_OutFile, &frF.VersY().v, sizeof( frF.VersY().v)) > 0  &&
-               gzwrite( m_OutFile, &frF.VersZ().v, sizeof( frF.VersZ().v)) > 0) ;
+      m_OutBinFile.write( (char*) &frF.Orig().v, sizeof( frF.Orig().v)) ;
+      m_OutBinFile.write( (char*) &frF.VersX().v, sizeof( frF.VersX().v)) ;
+      m_OutBinFile.write( (char*) &frF.VersY().v, sizeof( frF.VersY().v)) ;
+      m_OutBinFile.write( (char*) &frF.VersZ().v, sizeof( frF.VersZ().v)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, ToString( frF, nPrecP, nPrecV).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( frF, nPrecP, nPrecV).c_str(), szSep, bEndL) ;
    }
 }
 
@@ -223,12 +245,13 @@ NgeWriter::WriteKey( int nKey)
       return false ;
 
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
-      return ( gzwrite( m_OutFile, &NgeBinKeyW[nKey], sizeof( int)) > 0) ;
+      m_OutBinFile.write( (char*) &NgeBinKeyW[nKey], sizeof( int)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, NgeAscKeyW[nKey].c_str(), nullptr, true) ;
+      return WriteStringOutTxt( m_OutTxtFile, NgeAscKeyW[nKey].c_str(), nullptr, true) ;
    }
 }
 
@@ -237,17 +260,18 @@ bool
 NgeWriter::WriteCol( const Color& cCol, const char* szSep, bool bEndL)
 {
    if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
          return false ;
       unsigned char ucCol[4] ;
       ucCol[0] = cCol.GetIntRed() ;
       ucCol[1] = cCol.GetIntGreen() ;
       ucCol[2] = cCol.GetIntBlue() ;
       ucCol[3] = cCol.GetIntAlpha() ;
-      return ( gzwrite( m_OutFile, ucCol, sizeof( ucCol)) > 0) ;
+      m_OutBinFile.write( (char*) ucCol, sizeof( ucCol)) ;
+      return m_OutBinFile.good() ;
    }
    else {
-      return WriteStringOutTxt( m_OutFile, ToString( cCol).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( cCol).c_str(), szSep, bEndL) ;
    }
 }
 
@@ -255,11 +279,9 @@ NgeWriter::WriteCol( const Color& cCol, const char* szSep, bool bEndL)
 bool
 NgeWriter::WriteRemark( const string& sVal)
 {
-   if ( m_bBinary) {
+   if ( m_bBinary)
       return true ;
-   }
-   else {
-      return ( WriteStringOutTxt( m_OutFile, "//", nullptr, false)  &&
-               WriteStringOutTxt( m_OutFile, sVal.c_str(), nullptr, true)) ;
-   }
+   else
+      return ( WriteStringOutTxt( m_OutTxtFile, "//", nullptr, false)  &&
+               WriteStringOutTxt( m_OutTxtFile, sVal.c_str(), nullptr, true)) ;
 }

NgeWriter.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2025
+//  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : NgeWriter.h          Data : 29.12.25           Versione : 2.7l6
+// File : NgeWriter.h          Data : 12.04.14           Versione : 1.5d5
 // Contenuto : Dichiarazione della classe NgeWriter.
 //
 //
@@ -16,6 +16,7 @@
 #include "NgeConst.h"
 #include "/EgtDev/Include/EGkPoint3d.h"
 #include "/EgtDev/Include/EGkColor.h"
+#include <fstream>
 
 struct gzFile_s ;
 
@@ -23,7 +24,7 @@ struct gzFile_s ;
 class NgeWriter
 {
    public :
-      NgeWriter( void) : m_bBinary( false), m_OutFile( nullptr) {}
+      NgeWriter( void) : m_bBinary( false), m_OutTxtFile( nullptr) {}
       ~NgeWriter( void)
             { Close() ; }
       bool Init( const std::string& sFileOut, int nFlag) ;
@@ -43,6 +44,9 @@ class NgeWriter
       bool WriteRemark( const std::string& sVal /* bEndL = true*/) ;
 
    private :
-      bool      m_bBinary ;
-      gzFile_s* m_OutFile ;
+      bool          m_bBinary ;
+      // per file binari
+      std::ofstream m_OutBinFile ;
+      // per file ASCII
+      gzFile_s*     m_OutTxtFile ;
 } ;

OffsetCurve.cpp

@@ -243,11 +243,11 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
       if ( IsNull( pCrv1))
          return false ;
       pCrv1->SetTempProp( nInd1) ;
-      if ( ! pCrv1->SimpleOffset( dDist)) {
+      if ( ! pCrv1->SimpleOffset( dDist, ICurve::OFF_FILLET)) {
          CurveArc* pArc = GetBasicCurveArc( pCrv1) ;
          if ( pArc == nullptr)
             return false ;
-         if ( pArc->MyExtendedOffset( dDist, true))
+         if ( pArc->MyExtendedOffset( dDist, true, ICurve::OFF_FILLET))
             pCrv1->SetTempProp( - nInd1) ;
       }       
       // curve successive
@@ -255,11 +255,11 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
       while ( ! IsNull( pCrv2)) {
         // eseguo semplice offset
          pCrv2->SetTempProp( nInd1 + 1) ;
-         if ( ! pCrv2->SimpleOffset( dDist)) {
+         if ( ! pCrv2->SimpleOffset( dDist, ICurve::OFF_FILLET)) {
             CurveArc* pArc = GetBasicCurveArc( pCrv2) ;
             if ( pArc == nullptr)
                return false ;
-            if ( pArc->MyExtendedOffset( dDist, true))
+            if ( pArc->MyExtendedOffset( dDist, true, ICurve::OFF_FILLET))
                pCrv2->SetTempProp( - ( nInd1 + 1)) ;
          }
         // verifico relazione con la curva precedente e aggiungo eventuali curve intermedie

PointsPCA.cpp

@@ -14,7 +14,6 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "PointsPCA.h"
-#define EIGEN_NO_IO
 #include "/EgtDev/Extern/Eigen/Dense"
 
 

PolyLine.cpp

@@ -18,8 +18,6 @@
 #include "PolygonPlane.h"
 #include "PointsPCA.h"
 #include "GeoConst.h"
-#include "CurveComposite.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkPlane3d.h"
 #include "/EgtDev/Include/EGkDistPointLine.h"
@@ -775,7 +773,7 @@ DouglasPeuckerSimplification( const PNTUVECTOR& vPtU, const double dSqTol, const
 
 //----------------------------------------------------------------------------
 bool
-PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd)
+PolyLine::RemoveAlignedPoints( double dToler)
 {
   // se non ci sono almeno 3 punti, esco subito
    if ( m_lUPoints.size() < 3)
@@ -798,7 +796,7 @@ PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd)
       vInd.push_back( 0) ;
       if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, int( vPtU.size()) - 1, vInd))
          return false ;
-      vInd.push_back( int( vPtU.size()) - 1) ;
+      vInd.push_back( vPtU.size() - 1) ;
    }
   // altrimenti chiusa
    else {
@@ -819,15 +817,15 @@ PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd)
       vInd.push_back( nMaxInd) ;
       if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, nMaxInd, int( vPtU.size()) - 1, vInd))
          return false ;
-      vInd.push_back( int( vPtU.size()) - 1) ;
+      vInd.push_back( vPtU.size() - 1) ;
    }
 
   // ordino in senso crescente
    sort( vInd.begin(), vInd.end()) ;
 
-  // se richiesto e chiusa e almeno 4 punti rimasti, controllo allineamento dell'inizio con precedente e successivo rimasti
-   if ( bStartEnd  &&  IsClosed()  &&  vInd.size() >= 4) {
-      if ( DistPointLine( vPtU[vInd[0]].first, vPtU[vInd[1]].first, vPtU[vInd[int(vInd.size())-2]].first).IsEpsilon( dToler)) {
+  // se chiusa e almeno 4 punti rimasti, controllo allineamento dell'inizio con precedente e successivo rimasti
+   if ( IsClosed()  &&  vInd.size() >= 4) {
+      if ( DistPointLine( vPtU[vInd[0]].first, vPtU[vInd[1]].first, vPtU[vInd[vInd.size()-2]].first).IsEpsilon( dToler)) {
          vInd.erase( vInd.begin()) ;
          vInd.back() = vInd.front() ;
       }
@@ -1447,7 +1445,7 @@ IsPointInsidePolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler
    }
   // Determino tangente di riferimento
    Vector3d vtTang ;
-  // se minima distanza nell'estremo iniziale del segmento
+   // se minima distanza nell'estremo iniziale del segmento
    if ( AreSamePointApprox( ptMinDist, prev( itMinDistEnd)->first)) {
      // direzione del segmento
       Vector3d vtCurrTg = itMinDistEnd->first - prev( itMinDistEnd)->first ;
@@ -1463,7 +1461,7 @@ IsPointInsidePolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler
       vtTang = vtPrevTg + vtCurrTg ;
       vtTang.Normalize() ;
    }
-  // se altrimenti minima distanza nell'estremo finale del segmento
+   // se altrimenti minima distanza nell'estremo finale del segmento
    else if ( AreSamePointApprox( ptMinDist, itMinDistEnd->first)) {
      // direzione del segmento
       Vector3d vtCurrTg = itMinDistEnd->first - prev( itMinDistEnd)->first ;
@@ -1479,7 +1477,7 @@ IsPointInsidePolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler
       vtTang = vtCurrTg + vtNextTg ;
       vtTang.Normalize() ;
    }
-  // altrimenti minima distanza con l'interno
+   // altrimenti minima distanza con l'interno
    else {
       vtTang = itMinDistEnd->first - prev( itMinDistEnd)->first ;
    }
@@ -1531,10 +1529,6 @@ ChangePolyLineStart( PolyLine& plPoly, const Point3d& ptNewStart, double dToler)
       return false ;
   // Riferimento alla lista dei punti
    PNTULIST& LoopList = const_cast<PolyLine&>( plPoly).GetUPointList() ;
-  // Se il punto inziale è già quello, non faccio nulla
-   if ( AreSamePointEpsilon( LoopList.begin()->first, ptNewStart, dToler))
-      return true ;
-
   // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
    double dMinSqDist = SQ_INFINITO ;
    auto itMinDistEnd = LoopList.end() ;
@@ -1618,9 +1612,8 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
    int nPnt2 = PL2.GetPointNbr() ;
    if ( nPnt1 == 0 || nPnt2 == 0)
       return false ;
- 
-  // indica la presenza di punti interni in comune tra le due polylines
-   bCommonInternalPoints = false ;
+
+   bCommonInternalPoints = false ;   // indica la presenza di punti interni in comune tra le due polylines
 
    vPnt1.reserve( PL1.GetPointNbr()) ;
    Point3d ptP1 ;
@@ -1664,7 +1657,7 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
          nMinJ = nLastJ ;
 
      // verifica se è un punto interno in comune con l'altra polyline  
-      if ( i < nTotP1 - 1  &&  dDist < EPS_SMALL  &&  abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
+      if ( i < nTotP1 - 1  &&  dDist < EPS_SMALL  && abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
          bCommonInternalPoints = true ;
 
       vPnt1[i].second = nMinJ ;
@@ -1694,328 +1687,12 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
       if ( nMinI < nLastI)
          nMinI = nLastI ;
 
-      if ( j < nTotP2 - 1  &&  dDist < EPS_SMALL &&  abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
+      if ( j < nTotP2 - 1  &&  dDist < EPS_SMALL && abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
          bCommonInternalPoints = true ;
 
       vPnt2[j].second = nMinI ;
       nLastI = nMinI ;
    }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-MatchPolyLinesAddingPoints( const PolyLine& PL1, const PolyLine& PL2, int nType, PNTIVECTOR& vPnt1, PNTIVECTOR& vPnt2)
-{
-  // prima trovo le associazioni senza aggiunte di punti
-   Point3d ptP2 ;
-   CurveComposite cc1, cc2 ;
-   cc1.FromPolyLine( PL1) ;
-   cc2.FromPolyLine( PL2) ;
-   int nPnt1 = PL1.GetPointNbr() ;
-   int nPnt2 = PL2.GetPointNbr() ;
-   vector<POINTU> vMatch2 ;
-   PL2.GetFirstPoint( ptP2) ;
-   while ( PL2.GetNextPoint( ptP2, true)) {
-      DistPointCurve dpc( ptP2, cc1, false) ;
-      int nFlag = 0 ;
-      double dParam ; dpc.GetParamAtMinDistPoint( 0, dParam, nFlag) ;
-      Point3d ptJoint ; dpc.GetMinDistPoint( 0, ptJoint, nFlag) ;
-      vMatch2.emplace_back( ptJoint, dParam) ;
-   }
-
-   int nAtStart2 = 0 ;  // match ripetuti dalla curva U0 allo start della curva U1
-   int nAtEnd2 = 0 ;
-   Point3d ptP1 ; PL1.GetFirstPoint( ptP1) ;
-   int c = 0 ;
-   int nRep1 = 0 ;  // match interni consecutivi uguali di punti della curva U0 con punti della curva U1
-   int nRep2 = 0 ;
-   double dLastParamMatch = 0 ;
-   Point3d ptLastPointMatch = ptP1 ;
-   BOOLVECTOR vbRep1( nPnt1) ;
-   INTVECTOR vnAddedOrNextIsRep1 ;  // 0 non Rep, 1 Rep, 2 Next is Rep ;
-   DBLVECTOR vdSplit1 ;
-   DBLVECTOR vdMatch1 ;
-   fill( vbRep1.begin(), vbRep1.end(), false) ;
-   while ( PL1.GetNextPoint( ptP1, true)) {
-      // devo salvarmi se matcho più punti con lo start o l'end della curva totale
-      DistPointCurve dpc( ptP1, cc2, false) ;
-      int nFlag = 0 ;
-      double dParam ; dpc.GetParamAtMinDistPoint( 0, dParam, nFlag) ;
-      Point3d ptJoint ; dpc.GetMinDistPoint( 0, ptJoint, nFlag) ;
-      vdMatch1.push_back( dParam) ;
-      if ( dParam < EPS_SMALL ) {
-         ++nAtStart2 ;
-         vbRep1[c] = true ;
-         ++c ;
-         continue ;
-      }
-      else if ( dParam > nPnt2 - EPS_SMALL ) {
-         vbRep1[c] = nAtEnd2 == 0 ? false : true ;
-         vbRep1.back() = true ;
-         ++ nAtEnd2 ;
-         ++c ;
-         continue ;
-      }
-      if ( dParam <= dLastParamMatch  ||  AreSamePointApprox( ptJoint, ptLastPointMatch)) {
-         dParam = dLastParamMatch ;
-         vbRep1[c] = true ;
-         ++ nRep1 ;
-         ++c ;
-         continue ;
-      }
-      else {
-         dLastParamMatch = dParam ;
-         ptLastPointMatch = ptJoint ;
-         // se sono già troppo vicino ad un split esistente allora non faccio nulla
-         if ( abs(dParam - round( dParam)) < 100 * EPS_PARAM) {
-            ++c ;
-            continue ;
-         }
-         vdSplit1.push_back( dParam) ;
-         // verifico se ho un match per questo punto
-         // in tal caso vuol dire che sto creando una ripetizione nRep1
-         int nCase = 0 ;
-         for ( int j = 0 ; j < int( vMatch2.size()) ; ++j) {
-            if ( abs(vMatch2[j].second - (c + 1)) < EPS_SMALL) {
-               // devo però verificare che non ci sia un match successivo, perché in quel caso non ho una ripetizione
-               bool bFoundMatch = false ;
-               for ( int z = int( vMatch2[j].second) ; z < int( vdMatch1.size()) ; ++z) {
-                  if ( abs( vdMatch1[z] - ( j + 1 )) < EPS_SMALL ) {
-                     bFoundMatch = true ;
-                     break ;
-                  }
-               }
-
-               if ( ! bFoundMatch) {
-                  ++ nRep2 ;
-                  // capisco se il punto è rep o se lo è il suo successivo
-                  if ( j + 1 < dParam)
-                     nCase = 1 ;
-                  else
-                     nCase = 2 ;
-               }
-               break ;
-            }
-         }
-         vnAddedOrNextIsRep1.push_back( nCase) ;
-      }
-      ++c ;
-   }
-   int nAtStart1 = 0 ;
-   int nAtEnd1 = 0 ;
-   PL2.GetFirstPoint( ptP2) ;
-   c = 0 ;
-   dLastParamMatch = 0 ;
-   ptLastPointMatch = ptP2 ;
-   INTVECTOR vnAddedOrNextIsRep2 ;  // 0 non Rep, 1 Rep, 2 Next is Rep ;
-   DBLVECTOR vdSplit2 ;
-   BOOLVECTOR vbRep2( nPnt2) ;
-   fill( vbRep2.begin(), vbRep2.end(), false) ;
-   while ( PL2.GetNextPoint( ptP2, true)) {
-      DistPointCurve dpc( ptP2, cc1, false) ;
-      int nFlag = 0 ;
-      double dParam ; dpc.GetParamAtMinDistPoint( 0, dParam, nFlag) ;
-      Point3d ptJoint ; dpc.GetMinDistPoint( 0, ptJoint, nFlag) ;
-      if ( dParam < EPS_SMALL ) {
-         ++nAtStart1 ;
-         vbRep2[c] = true ;
-         ++c ;
-         continue ;
-      }
-      else if ( dParam > nPnt1 - EPS_SMALL ) {
-         vbRep2[c] = ( nAtEnd1 == 0 ? false : true) ;
-         vbRep2.back() = true ;
-         ++ nAtEnd1 ;
-         ++c ;
-         continue ;
-      }
-      if ( dParam <= dLastParamMatch  ||  AreSamePointApprox( ptJoint, ptLastPointMatch)) {
-         dParam = dLastParamMatch ;
-         vbRep2[c] = true ;
-         ++ nRep2 ;
-         ++c ;
-         continue ;
-      }
-      else {
-         dLastParamMatch = dParam ;
-         ptLastPointMatch = ptJoint ;
-        // se sono troppo vicino ad uno split esistente allora non faccio nulla
-         if ( abs( dParam - round( dParam)) < 100 * EPS_PARAM) {
-            ++c ;
-            continue ;
-         }
-         vdSplit2.push_back( dParam) ;
-        // verifico se ho un match per questo punto
-        // in tal caso vuol dire che sto creando una ripetizione nRep0
-         int nCase = 0 ;
-         for ( int j = 0 ; j < int( vdMatch1.size()) ; ++j) {
-            if ( abs( vdMatch1[j] - (c + 1)) < EPS_SMALL) {
-              // devo però verificare che non ci sia un match successivo, perché in quel caso non ho una ripetizione
-               bool bFoundMatch = false ;
-               for ( int z = int( vdMatch1[j]) ; z < int( vMatch2.size()) ; ++z) {
-                  if ( abs( vMatch2[z].second - ( j + 1 )) < EPS_SMALL) {
-                     bFoundMatch = true ;
-                     break ;
-                  }
-               }
-
-               if ( ! bFoundMatch) {
-                  ++nRep1 ;
-                 // capisco se il punto è rep o se lo è il suo successivo
-                  if ( j + 1 < dParam)
-                     nCase = 1 ;
-                  else
-                     nCase = 2 ;
-               }
-               break ;
-            }
-         }
-         vnAddedOrNextIsRep2.push_back( nCase) ;
-      }
-      ++c ;
-   }
-
-  // applico effettivamente gli split e aggiungo gli elementi ai vettori vbRep
-   int nUnit = 0 ;
-   if ( ! vdSplit1.empty())
-      nUnit = int( vdSplit1.back()) ;
-   for ( int z = int( vdSplit1.size()) - 1 ; z >= 0 ; --z) {
-      double dSplit = vdSplit1[z] ;
-      int nSplit = int( dSplit) ;
-     // se sto cercando di fare uno split sulla stessa curva che ho già splittato al passaggio precedente allora devo
-     // riscalare
-      if ( nSplit == nUnit  &&  z < int( vdSplit1.size()) - 1) {
-         dSplit = nSplit + ( dSplit - nSplit) / ( vdSplit1[z+1] - nSplit) ;
-      }
-      nUnit = nSplit ;
-      cc2.AddJoint( dSplit) ;
-      switch ( vnAddedOrNextIsRep1[z]) {
-      case 0 :
-         if ( vbRep2[nSplit])
-            ++ nRep2 ;
-        // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo
-         vbRep2.insert( vbRep2.begin() + nSplit, vbRep2[nSplit]) ;
-         break ;
-      case 1 :
-         vbRep2.insert( vbRep2.begin() + nSplit, true) ;
-         break ;
-      case 2 :
-         if ( vbRep2[nSplit])
-            --nRep2 ;
-         else
-            vbRep2[nSplit] = true ;
-         vbRep2.insert( vbRep2.begin() + nSplit, false) ;
-         break ;
-      }
-   }
-   if ( ! vdSplit2.empty())
-      nUnit = int( vdSplit2.back()) ;
-   for ( int z = int( vdSplit2.size()) - 1 ; z >= 0 ; --z) {
-      double dSplit = vdSplit2[z] ;
-      int nSplit = int( dSplit) ;
-     // se sto cercando di fare uno split sulla stessa curva che ho già splittato al passaggio precedente allora devo
-     // riscalare
-      if ( nSplit == nUnit  &&  z < int( vdSplit2.size()) - 1) {
-         dSplit = nSplit + ( dSplit - nSplit) / (vdSplit2[z+1] - nSplit) ;
-      }
-      nUnit = nSplit ;
-      cc1.AddJoint( dSplit) ;
-      switch ( vnAddedOrNextIsRep2[z]) {
-      case 0 :
-         if ( vbRep1[nSplit])
-            ++ nRep1 ;
-        // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo
-         vbRep1.insert( vbRep1.begin() + nSplit, vbRep1[nSplit]) ;
-         break ;
-      case 1 :
-         vbRep1.insert( vbRep1.begin() + nSplit, true) ;
-         break ;
-      case 2 :
-         if ( vbRep1[nSplit])
-            -- nRep1 ;
-         else
-            vbRep1[nSplit] = true ;
-         vbRep1.insert( vbRep1.begin() + nSplit, false) ;
-         break ;
-      }
-   }
-
-   nPnt1 = cc1.GetCurveCount() ;
-   nPnt2 = cc2.GetCurveCount() ;
-   //aggiusto i vettori delle ripetizioni in modo in modo che non arrivino mai ad essere contemporaneamente true
-   int nAddedSpan = 0 ;
-   int nCrv1 = 0 ;
-   int nCrv2 = 0 ;
-   while ( nAddedSpan < nPnt1 + nAtStart1 + nAtEnd1 + nRep2) {
-      if ( nCrv1 >= nPnt1)
-         nCrv1 = nPnt1 - 1 ;
-      if ( nCrv2 >= nPnt2)
-         nCrv2 = nPnt2 - 1 ;
-      bool bRep1 = vbRep1[nCrv1] ;
-      bool bRep2 = vbRep2[nCrv2] ;
-      if ( bRep1  &&  bRep2) {
-         vbRep1[nCrv1] = false ;
-         bRep1 = false ;
-         vbRep2[nCrv2] = false ;
-         bRep2 = false ;
-         -- nRep1 ;
-         -- nRep2 ;
-      }
-      if ( ! bRep1  ||  nCrv2 == nPnt2 - 1)
-         ++ nCrv2 ;
-      if ( ! bRep2  ||  nCrv1 == nPnt1 - 1)
-         ++ nCrv1 ;
-      ++ nAddedSpan ;
-   }
-  // se non sono arrivato all'ultima curva su U0 o U1 vuol dire che ho creato delle ripetizioni che non ho contato prima
-   if ( nCrv2 < nPnt2) {
-      nRep2 += nPnt2 - nCrv2 ;
-      for ( int z = int( vbRep2.size()) - 1 ; z >= nCrv2 ; --z)
-         vbRep2[z] = true ;
-   }
-   if ( nCrv1 < nPnt1) {
-      nRep1 += nPnt1 - nCrv1 ;
-      for ( int z = int( vbRep1.size()) - 1 ; z >= nCrv1 ; --z)
-         vbRep1[z] = true ;
-   }
-
-  // trovo il numero di span che dovrà avere la superficie
-  // ( numero di sottocurve che compongono la U0 + tutte le ripetizioni dei match di punti della curva U1 con i punti di U0)
-   int nPnt = nPnt1 + nAtStart1 + nAtEnd1 + nRep2 ;
-
-   if ( nPnt != nPnt2 + nAtStart2 + nAtEnd2 + nRep1)
-      LOG_DBG_ERR( GetEGkLogger(), "There could be an error in the creation of a ruled surface in mode RLT_B_MINDIST_PLUS") ;
-
-  // aggiungo i punti di controllo scorrendo in contemporanea le due curve
-   nAddedSpan = 0 ;
-   nCrv1 = 0 ;
-   nCrv2 = 0 ;
-   bool bLast1 = false ;
-   bool bLast2 = false ;
-   while ( nAddedSpan < nPnt) {
-      if ( nCrv1 >= nPnt1) {
-         nCrv1 = nPnt1 - 1 ;
-         bLast1 = true ;
-      }
-      if ( nCrv2 >= nPnt2) {
-         nCrv2 = nPnt2 - 1 ;
-         bLast2 = true ;
-      }
-      bool bRep1 = vbRep1[nCrv1] ;
-      bool bRep2 = vbRep2[nCrv2] ;
-      const ICurve* pSubCrv1 = cc1.GetCurve( nCrv1) ;
-      Point3d ptStart1 ; pSubCrv1->GetStartPoint( ptStart1) ;
-      vPnt1.emplace_back( ptStart1, nAddedSpan) ;
-      const ICurve* pSubCrv2 = cc2.GetCurve( nCrv2) ;
-      Point3d ptStart2 ; pSubCrv2->GetStartPoint( ptStart2) ;
-      vPnt2.emplace_back( ptStart2, nAddedSpan) ;
-      if ( ! bRep2)
-         ++ nCrv1 ;
-      if ( ! bRep1)
-         ++ nCrv2 ;
-      ++ nAddedSpan ;
-   }
 
    return true ;
-}
+}

ProjectCurveSurf.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2023-2026
+//  EgalTech 2023-2023
 //----------------------------------------------------------------------------
-// File : ProjectCurveSurfTm.cpp    Data : 03.01.26        Versione : 3.1a1
+// File : ProjectCurveSurfTm.cpp    Data : 16.11.23        Versione : 2.5kh3
 // Contenuto : Implementazione funzioni proiezione curve su superficie Trimesh.
 //
 //
@@ -40,13 +40,6 @@ const int P5AX_CONC = 3 ;              // in angolo concavo
 const int P5AX_BEFORE_CONC = 4 ;       // adiacente ad angolo concavo
 const int P5AX_AFTER_CONC = 5 ;        // adiacente ad angolo concavo
 
-//----------------------------------------------------------------------------
-static double
-GetSurfBezierTol( double dLinTol)
-{
-   return max( dLinTol / 10, EPS_SMALL) ;
-}
-
 //----------------------------------------------------------------------------
 static bool
 PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext, double dSqTol)
@@ -59,77 +52,6 @@ PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext,
    return true ;
 }
 
-//----------------------------------------------------------------------------
-static bool
-AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
-{
-   for ( int i = 1 ; i < ssize( vPt5ax) ; ++ i) {
-     // precedente
-      int j = i - 1 ;
-     // se normali tra corrente e precedente oltre limite e punti abbastanza lontani
-      if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER  &&
-           SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
-        // intersezione tra le due facce
-         Plane3d plPlane1 ; plPlane1.Set( vPt5ax[j].ptP, vPt5ax[j].vtDir1) ;
-         Plane3d plPlane2 ; plPlane2.Set( vPt5ax[i].ptP, vPt5ax[i].vtDir1) ;
-         Point3d ptEdge ; Vector3d vtEdge ;
-         if ( IntersPlanePlane( plPlane1, plPlane2, ptEdge, vtEdge) == IPPT_YES) {
-            Plane3d plPlane3 ; plPlane3.Set(vPt5ax[i].ptP, (vPt5ax[i].ptP - vPt5ax[j].ptP) ^ ( vPt5ax[i].vtDir1 + vPt5ax[j].vtDir1)) ;
-            Point3d ptInt ;
-            if ( IntersLinePlane( ptEdge, vtEdge, 1, plPlane3, ptInt, false) == ILPT_YES) {
-              // verifico se spigolo convesso o concavo
-               bool bConvex ;
-               if ( ! AreSamePointApprox( ptInt, vPt5ax[j].ptP))
-                  bConvex = ( ( vPt5ax[j].vtDir1 ^ ( ptInt - vPt5ax[j].ptP)) * vtEdge > 0) ;
-               else
-                  bConvex = (( vPt5ax[i].vtDir1 ^ ( ptInt - vPt5ax[i].ptP)) * vtEdge < 0) ;
-              // se convesso, metto due punti con direzione appena prima e appena dopo
-               if ( bConvex) {
-                  Vector3d vtLine1 = ptInt - vPt5ax[j].ptP ; double dLen1 = vtLine1.Len() ;
-                  Vector3d vtLine2 = vPt5ax[i].ptP - ptInt ; double dLen2 = vtLine2.Len() ;
-                  if ( dLen1 > 2 * EPS_SMALL) {
-                     Point5ax Pt5ax ;
-                     Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
-                     Pt5ax.vtDir1 = vPt5ax[j].vtDir1 ;
-                     Pt5ax.vtDir2 = vPt5ax[j].vtDir2 ;
-                     Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
-                     Pt5ax.nFlag = P5AX_CVEX ;
-                     vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
-                     ++ i ;
-                  }
-                  else
-                     vPt5ax[j].nFlag = P5AX_CVEX ;
-                  if ( dLen2 > 2 * EPS_SMALL) {
-                     Point5ax Pt5ax ;
-                     Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
-                     Pt5ax.vtDir1 = vPt5ax[i].vtDir1 ;
-                     Pt5ax.vtDir2 = vPt5ax[i].vtDir2 ;
-                     Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
-                     Pt5ax.nFlag = P5AX_CVEX ;
-                     vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
-                     ++ i ;
-                  }
-                  else
-                     vPt5ax[i].nFlag = P5AX_CVEX ;
-               }
-              // altrimenti concavo, aggiungo un solo punto con la direzione media
-               else {
-                  Point5ax Pt5ax ;
-                  Pt5ax.ptP = ptInt ;
-                  Pt5ax.vtDir1 = Media( vPt5ax[i].vtDir1, vPt5ax[j].vtDir1) ; Pt5ax.vtDir1.Normalize() ;
-                  Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ; Pt5ax.vtDir2.Normalize() ;
-                  Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
-                  Pt5ax.nFlag = P5AX_CONC ;
-                  vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
-                  ++ i ;
-               }
-            }
-         }
-      }
-   }
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 static bool
 RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen, bool bTestDir)
@@ -141,7 +63,7 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
    double dCosAngLim = 1 - dSqTol / ( 2 * LENREF * LENREF) ;
   // Cerco gli angoli interni e marco opportunamente i punti nelle vicinanze fino ai limiti prima e dopo
    int nInd = 0 ;
-   while ( nInd  < ssize( vPt5ax)) {
+   while ( nInd  < int( vPt5ax.size())) {
       if ( vPt5ax[nInd].nFlag == P5AX_CONC) {
         // analizzo i punti appena precedenti
          int nIpv = nInd - 1 ;
@@ -157,7 +79,7 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
          }
         // analizzo i punti appena successivi
          int nInx = nInd + 1 ;
-         while ( nInx < ssize( vPt5ax)) {
+         while ( nInx < int( vPt5ax.size())) {
             double dSqLen = SqDist( vPt5ax[nInd].ptP, vPt5ax[nInx].ptP) ;
             if ( dSqLen < dSqMaxLen)
                vPt5ax[nInx].nFlag = P5AX_TO_DELETE ;
@@ -175,7 +97,7 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
    int nPrec = 0 ;
    int nCurr = 1 ;
    int nNext = 2 ;
-   while ( nNext < ssize( vPt5ax)) {
+   while ( nNext < int( vPt5ax.size())) {
       bool bRemove = false ;
      // lunghezza del segmento che unisce gli adiacenti
       double dSqLen = SqDist( vPt5ax[nPrec].ptP, vPt5ax[nNext].ptP) ;
@@ -232,124 +154,7 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
    return true ;
 }
 
-//----------------------------------------------------------------------------
-static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, double dPar, Point5ax& Pt5ax)
-{
-  // punto sulle supefici a minima distanza
-   int nSurfMin = -1 ;
-   int nTriaMin ;
-   Point3d ptMin ;
-   double dMinDist ;
-   for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
-     // punto sulla superficie a minima distanza
-      DistPointSurfTm dPS( ptP, *vpStm[i]) ;
-      double dDist ;
-      if ( dPS.GetDist( dDist)  &&  ( nSurfMin == -1  ||  dDist < dMinDist)) {
-         nSurfMin = i ;
-         dPS.GetMinDistPoint( ptMin) ;
-         dPS.GetMinDistTriaIndex ( nTriaMin) ;
-         dMinDist = dDist ;
-      }
-   }
-
-  // se trovato
-   if ( nSurfMin >= 0) {
-     // assegno il punto
-      Point3d ptInt = ptMin ;
-     // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
-      Triangle3dEx trTria ;
-      if ( ! vpStm[nSurfMin]->GetTriangle( nTriaMin, trTria))
-         return false ;
-      Vector3d vtN ;
-      if ( ! CalcNormal( ptMin, trTria, vtN))
-         vtN = trTria.GetN() ;
-     // assegno valori al punto 5assi
-      Pt5ax.ptP = ptInt ;
-      Pt5ax.vtDir1 = vtN ;
-      Pt5ax.vtDir2 = vtN ;
-      Pt5ax.dPar = dPar ;
-      Pt5ax.nFlag = P5AX_STD ;
-     // ritorno con successo
-      return true ;
-   }
-
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
-{
-  // sistemazioni per tipo di superficie
-   CISRFTMPVECTOR vpSurfTm ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
-      const SurfTriMesh* pSurfTm = nullptr ;
-      switch ( vpSurf[i]->GetType()) {
-      case SRF_TRIMESH :
-         pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
-         break ;
-      case SRF_BEZIER :
-       { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-         SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
-         SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-       } break ;
-      case SRF_FLATRGN :
-         pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
-         break ;
-      default :
-         break ;
-      }
-      if ( pSurfTm == nullptr)
-         return false ;
-      vpSurfTm.emplace_back( pSurfTm) ;
-   }
-
-  // controllo le tolleranze
-   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
-   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
-
-  // approssimo la curva con una polilinea entro la tolleranza
-   PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
-      return false ;
-   const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
-   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
-      return false ;
-
-  // Pulisco e riservo spazio nel vettore dei punti risultanti
-   vPt5ax.clear() ;
-   vPt5ax.reserve( PL.GetPointNbr()) ;
-
-  // proietto i punti della polilinea sulla superficie secondo la direzione di minima distanza
-   double dPar ;
-   Point3d ptP ;
-   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
-   while ( bFound) {
-     // se trovo proiezione, la salvo
-      Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, dPar, Pt5ax))
-         vPt5ax.emplace_back( Pt5ax) ;
-     // passo al successivo
-      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
-   }
-
-  // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
-
-  // rimozione punti in eccesso rispetto alle tolleranze
-   RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-// --- vettore di oggetti intersezione massiva rette parallele SurfTM --------
-typedef std::vector<IntersParLinesSurfTm*> INTPARLINESTMPVECTOR ;
+typedef std::vector<IntersParLinesSurfTm*> INTPARLINESTMPVECTOR ;   // vettore di oggetti intersezione massiva rette parallele SurfTM
 
 //----------------------------------------------------------------------------
 static bool
@@ -360,11 +165,11 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const Frame
    Point3d ptL = GetToLoc( ptP, frRefLine) ;
    int nInd = -1 ;
    IntLinStmInfo IntRes ;
-   for ( int i = 0 ; i < ssize( vpIntPLSTM) ; ++ i) {
+   for ( int i = 0 ; i < int( vpIntPLSTM.size()) ; ++ i) {
       ILSIVECTOR vIntRes ;
       if ( vpIntPLSTM[i]->GetInters( ptL, 1, vIntRes, false)) {
         // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
-         int nI = ssize( vIntRes) - 1 ;
+         int nI = int( vIntRes.size()) - 1 ;
          while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
             --nI ;
         // se trovata
@@ -418,18 +223,15 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vect
 {
   // sistemazioni per tipo di superficie
    CISRFTMPVECTOR vpSurfTm ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
+   for ( int i = 0 ; i < int( vpSurf.size()) ; ++ i) {
       const SurfTriMesh* pSurfTm = nullptr ;
       switch ( vpSurf[i]->GetType()) {
       case SRF_TRIMESH :
          pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
          break ;
       case SRF_BEZIER :
-       { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-         SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
-         SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-       } break ;
+         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurf() ;
+         break ;
       case SRF_FLATRGN :
          pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
          break ;
@@ -444,11 +246,9 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vect
   // controllo le tolleranze
    dLinTol = max( dLinTol, LIN_TOL_MIN) ;
    dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
-
-  // approssimo la curva con una polilinea entro la tolleranza
+  // approssimo la curva con una polilinea alla massima risoluzione
    PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
+   if ( ! crCrv.ApproxWithLines( EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
       return false ;
    const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
    if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
@@ -459,10 +259,10 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vect
    if ( ! frRefLine.Set( ORIG, vtDir))
       return false ;
    INTPARLINESTMPVECTOR vpIntPLSTM ; vpIntPLSTM.reserve( vpSurfTm.size()) ;
-   for ( int i = 0 ; i < ssize( vpSurfTm) ; ++ i) {
+   for ( int i = 0 ; i < int( vpSurfTm.size()) ; ++ i) {
       IntersParLinesSurfTm* pIntPLSTM = new IntersParLinesSurfTm( frRefLine, *vpSurfTm[i]) ;
       if ( pIntPLSTM == nullptr) {
-         for ( int j = 0 ; j < ssize( vpIntPLSTM) ; ++ j)
+         for ( int j = 0 ; j < int( vpIntPLSTM.size()) ; ++ j)
             delete vpIntPLSTM[j] ;
          return false ;
       }
@@ -487,12 +287,72 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vect
    }
 
   // Libero oggetti per calcolo massivo
-   for ( int i = 0 ; i < ssize( vpIntPLSTM) ; ++ i)
+   for ( int i = 0 ; i < int( vpIntPLSTM.size()) ; ++ i)
       delete vpIntPLSTM[i] ;
 
   // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
+   if ( bSharpEdges) {
+      for ( int i = 1 ; i < int( vPt5ax.size()) ; ++ i) {
+        // precedente
+         int j = i - 1 ;
+        // se normali tra corrente e precedente oltre limite e punti abbastanza lontani
+         if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER  &&
+              SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
+           // intersezione tra le due facce
+            Plane3d plPlane1 ; plPlane1.Set( vPt5ax[j].ptP, vPt5ax[j].vtDir1) ;
+            Plane3d plPlane2 ; plPlane2.Set( vPt5ax[i].ptP, vPt5ax[i].vtDir1) ;
+            Point3d ptEdge ; Vector3d vtEdge ;
+            if ( IntersPlanePlane( plPlane1, plPlane2, ptEdge, vtEdge) == IPPT_YES) {
+               Plane3d plPlane3 ; plPlane3.Set( vPt5ax[i].ptP, ( vPt5ax[i].ptP - vPt5ax[j].ptP) ^ vtDir) ;
+               Point3d ptInt ;
+               if ( IntersLinePlane( ptEdge, vtEdge, 1, plPlane3, ptInt, false) == ILPT_YES) {
+                 // verifico se spigolo convesso o concavo
+                  bool bConvex ;
+                  if ( ! AreSamePointApprox( ptInt, vPt5ax[j].ptP))
+                     bConvex = ( ( vPt5ax[j].vtDir1 ^ ( ptInt - vPt5ax[j].ptP)) * vtEdge > 0) ;
+                  else
+                     bConvex = (( vPt5ax[i].vtDir1 ^ ( ptInt - vPt5ax[i].ptP)) * vtEdge < 0) ;
+                 // se convesso, metto due punti con direzione appena prima e appena dopo
+                  if ( bConvex) {
+                     Vector3d vtLine1 = ptInt - vPt5ax[j].ptP ; double dLen1 = vtLine1.Len() ;
+                     Vector3d vtLine2 = vPt5ax[i].ptP - ptInt ; double dLen2 = vtLine2.Len() ;
+                     if ( dLen1 > 2 * EPS_SMALL) {
+                        Point5ax Pt5ax ;
+                        Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
+                        Pt5ax.vtDir1 = vPt5ax[j].vtDir1 ;
+                        Pt5ax.vtDir2 = vtDir ;
+                        Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
+                        Pt5ax.nFlag = P5AX_CVEX ;
+                        vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
+                        ++ i ;
+                     }
+                     if ( dLen2 > 2 * EPS_SMALL) {
+                        Point5ax Pt5ax ;
+                        Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
+                        Pt5ax.vtDir1 = vPt5ax[i].vtDir1 ;
+                        Pt5ax.vtDir2 = vtDir ;
+                        Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
+                        Pt5ax.nFlag = P5AX_CVEX ;
+                        vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
+                        ++ i ;
+                     }
+                  }
+                 // altrimenti concavo, aggiungo un solo punto con la direzione media
+                  else {
+                     Point5ax Pt5ax ;
+                     Pt5ax.ptP = ptInt ;
+                     Pt5ax.vtDir1 = Media( vPt5ax[i].vtDir1, vPt5ax[j].vtDir1) ;
+                     Pt5ax.vtDir2 = vtDir ;
+                     Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
+                     Pt5ax.nFlag = P5AX_CONC ;
+                     vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
+                     ++ i ;
+                  }
+               }
+            }
+         }
+      }
+   }
 
   // rimozione punti in eccesso rispetto alle tolleranze
    RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
@@ -514,11 +374,11 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const IGeoP
      // conservo l'intersezione più alta
       int nInd = -1 ;
       IntLinStmInfo IntRes ;
-      for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
+      for ( int i = 0 ; i < int( vpStm.size()) ; ++ i) {
          ILSIVECTOR vIntRes ;
          if ( IntersLineSurfTm( ptP, vtLine, dLineLen, *vpStm[i], vIntRes, false)) {
            // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
-            int nI = ssize( vIntRes) - 1 ;
+            int nI = int( vIntRes.size()) - 1 ;
             while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
                --nI ;
            // se trovata
@@ -573,18 +433,15 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeo
 {
   // sistemazioni per tipo di superficie
    CISRFTMPVECTOR vpSurfTm ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
+   for ( int i = 0 ; i < int( vpSurf.size()) ; ++ i) {
       const SurfTriMesh* pSurfTm = nullptr ;
       switch ( vpSurf[i]->GetType()) {
       case SRF_TRIMESH :
          pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
          break ;
       case SRF_BEZIER :
-       { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-         SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
-         SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-       } break ;
+         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurf() ;
+         break ;
       case SRF_FLATRGN :
          pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
          break ;
@@ -600,10 +457,9 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeo
    dLinTol = max( dLinTol, LIN_TOL_MIN) ;
    dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
 
-  // approssimo la curva con una polilinea entro la tolleranza
+  // approssimo la curva con una polilinea entro la metà della tolleranza
    PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
       return false ;
    const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
    if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
@@ -627,8 +483,25 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeo
    }
 
   // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
+   if ( bSharpEdges) {
+      for ( int i = 1 ; i < int( vPt5ax.size()) ; ++ i) {
+        // precedente
+         int j = i - 1 ;
+        // se normali tra corrente e precedente oltre limite e punti abbastanza lontani
+         if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER  &&
+              SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
+           // punto medio
+            Point3d ptMid = Media( vPt5ax[i].ptP, vPt5ax[j].ptP) ;
+            double dMid = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
+           // se trovo proiezione, la salvo
+            Point5ax Pt5ax ; 
+            if ( ProjectPointOnSurf( ptMid, vpSurfTm, gpRef, dMid, Pt5ax)) {
+               vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
+               -- i ;
+            }
+         }
+      }
+   }
 
   // rimozione punti in eccesso rispetto alle tolleranze
    RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
@@ -653,11 +526,11 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const ICurv
         // conservo l'intersezione più alta
          int nInd = -1 ;
          IntLinStmInfo IntRes ;
-         for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
+         for ( int i = 0 ; i < int( vpStm.size()) ; ++ i) {
             ILSIVECTOR vIntRes ;
             if ( IntersLineSurfTm( ptP, vtLine, dLineLen, *vpStm[i], vIntRes, false)) {
               // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
-               int nI = ssize( vIntRes) - 1 ;
+               int nI = int( vIntRes.size()) - 1 ;
                while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
                   --nI ;
               // se trovata
@@ -713,18 +586,15 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICur
 {
   // Sistemazioni per tipo di superficie
    CISRFTMPVECTOR vpSurfTm ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
+   for ( int i = 0 ; i < int( vpSurf.size()) ; ++ i) {
       const SurfTriMesh* pSurfTm = nullptr ;
       switch ( vpSurf[i]->GetType()) {
       case SRF_TRIMESH :
          pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
          break ;
       case SRF_BEZIER :
-       { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-         SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
-         SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-       } break ;
+         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurf() ;
+         break ;
       case SRF_FLATRGN :
          pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
          break ;
@@ -740,10 +610,9 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICur
    dLinTol = max( dLinTol, LIN_TOL_MIN) ;
    dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
 
-  // Approssimo la curva con una polilinea entro la tolleranza
+  // Approssimo la curva con una polilinea alla massima risoluzione
    PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
+   if ( ! crCrv.ApproxWithLines( EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
       return false ;
    const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
    if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
@@ -767,8 +636,68 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICur
    }
 
   // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
+   if ( bSharpEdges) {
+      for ( int i = 1 ; i < int( vPt5ax.size()) ; ++ i) {
+        // precedente
+         int j = i - 1 ;
+        // se normali tra corrente e precedente oltre limite e punti abbastanza lontani
+         if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER  &&
+              SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
+           // intersezione tra le due facce
+            Plane3d plPlane1 ; plPlane1.Set( vPt5ax[j].ptP, vPt5ax[j].vtDir1) ;
+            Plane3d plPlane2 ; plPlane2.Set( vPt5ax[i].ptP, vPt5ax[i].vtDir1) ;
+            Point3d ptEdge ; Vector3d vtEdge ;
+            if ( IntersPlanePlane( plPlane1, plPlane2, ptEdge, vtEdge) == IPPT_YES) {
+               Plane3d plPlane3 ; plPlane3.Set( vPt5ax[i].ptP, vPt5ax[i].vtDir2 ^ vPt5ax[j].vtDir2) ;
+               Point3d ptInt ;
+               if ( IntersLinePlane( ptEdge, vtEdge, 1, plPlane3, ptInt, false) == ILPT_YES) {
+                 // verifico se spigolo convesso o concavo
+                  bool bConvex ;
+                  if ( ! AreSamePointApprox( ptInt, vPt5ax[j].ptP))
+                     bConvex = ( ( vPt5ax[j].vtDir1 ^ ( ptInt - vPt5ax[j].ptP)) * vtEdge > 0) ;
+                  else
+                     bConvex = (( vPt5ax[i].vtDir1 ^ ( ptInt - vPt5ax[i].ptP)) * vtEdge < 0) ;
+                 // se convesso, metto due punti con direzione appena prima e appena dopo
+                  if ( bConvex) {
+                     Vector3d vtLine1 = ptInt - vPt5ax[j].ptP ; double dLen1 = vtLine1.Len() ;
+                     Vector3d vtLine2 = vPt5ax[i].ptP - ptInt ; double dLen2 = vtLine2.Len() ;
+                     if ( dLen1 > 2 * EPS_SMALL) {
+                        Point5ax Pt5ax ;
+                        Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
+                        Pt5ax.vtDir1 = vPt5ax[j].vtDir1 ;
+                        Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ;
+                        Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
+                        Pt5ax.nFlag = P5AX_CVEX ;
+                        vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
+                        ++ i ;
+                     }
+                     if ( dLen2 > 2 * EPS_SMALL) {
+                        Point5ax Pt5ax ;
+                        Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
+                        Pt5ax.vtDir1 = vPt5ax[i].vtDir1 ;
+                        Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ;
+                        Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
+                        Pt5ax.nFlag = P5AX_CVEX ;
+                        vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
+                        ++ i ;
+                     }
+                  }
+                 // altrimenti concavo, aggiungo un solo punto con la direzione media
+                  else {
+                     Point5ax Pt5ax ;
+                     Pt5ax.ptP = ptInt ;
+                     Pt5ax.vtDir1 = Media( vPt5ax[i].vtDir1, vPt5ax[j].vtDir1) ;
+                     Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ;
+                     Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
+                     Pt5ax.nFlag = P5AX_CONC ;
+                     vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
+                     ++ i ;
+                  }
+               }
+            }
+         }
+      }
+   }
 
   // rimozione punti in eccesso rispetto alle tolleranze
    RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
@@ -802,11 +731,11 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const SurfT
      // intersezione della retta con le superfici (conservo l'intersezione più alta)
       int nInd = -1 ;
       IntLinStmInfo IntRes ;
-      for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
+      for ( int i = 0 ; i < int( vpStm.size()) ; ++ i) {
          ILSIVECTOR vIntRes ;
          if ( IntersLineSurfTm( ptP, vtLine, dLineLen, *vpStm[i], vIntRes, false)) {
            // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
-            int nI = ssize( vIntRes) - 1 ;
+            int nI = int( vIntRes.size()) - 1 ;
             while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
                --nI ;
            // se trovata
@@ -868,18 +797,15 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISur
 {
   // sistemazioni per tipo di superficie
    CISRFTMPVECTOR vpSurfTm ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
+   for ( int i = 0 ; i < int( vpSurf.size()) ; ++ i) {
       const SurfTriMesh* pSurfTm = nullptr ;
       switch ( vpSurf[i]->GetType()) {
       case SRF_TRIMESH :
          pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
          break ;
       case SRF_BEZIER :
-       { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-         SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
-         SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-       } break ;
+         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurf() ;
+         break ;
       case SRF_FLATRGN :
          pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
          break ;
@@ -898,11 +824,8 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISur
       pRefTm = GetBasicSurfTriMesh( &sfRef) ;
       break ;
    case SRF_BEZIER :
-    { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-      SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-      pRefTm = GetBasicSurfBezier(  &sfRef)->GetAuxSurfRefined() ;
-      SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-    } break ;
+      pRefTm = GetBasicSurfBezier( &sfRef)->GetAuxSurf() ;
+      break ;
    case SRF_FLATRGN :
       pRefTm = GetBasicSurfFlatRegion( &sfRef)->GetAuxSurf() ;
       break ;
@@ -916,10 +839,9 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISur
    dLinTol = max( dLinTol, LIN_TOL_MIN) ;
    dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
 
-  // approssimo la curva con una polilinea entro la tolleranza
+  // approssimo la curva con una polilinea entro la metà della tolleranza
    PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
       return false ;
    const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
    if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
@@ -943,8 +865,25 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISur
    }
 
   // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
+   if ( bSharpEdges) {
+      for ( int i = 1 ; i < int( vPt5ax.size()) ; ++ i) {
+        // precedente
+         int j = i - 1 ;
+        // se normali tra corrente e precedente oltre limite e punti abbastanza lontani
+         if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER  &&
+              SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
+           // punto medio
+            Point3d ptMid = Media( vPt5ax[i].ptP, vPt5ax[j].ptP) ;
+            double dMid = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
+           // se trovo proiezione, la salvo
+            Point5ax Pt5ax ; 
+            if ( ProjectPointOnSurf( ptMid, vpSurfTm, *pRefTm, dMid, Pt5ax)) {
+               vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
+               -- i ;
+            }
+         }
+      }
+   }
 
   // rimozione punti in eccesso rispetto alle tolleranze
    RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;

SbzFromCurves.cpp

@@ -78,7 +78,7 @@ GetSurfBezierByRegion( const CICURVEPVECTOR& vpCurve, double dLinTol)
    for ( int i = 0 ; i < int( vnPLIndMat.size()) ; ++i) {
       for ( int j = 0 ; j < int( vnPLIndMat[i].size()) ; ++j){
          vPLOrd.push_back(vPL[vnPLIndMat[i][j]]) ;
-         if ( vbInvert[vnPLIndMat[i][j]])
+         if( vbInvert[vnPLIndMat[i][j]])
             vPLOrd.back().Invert() ;
       }
    }
@@ -221,7 +221,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
       const ICurveComposite* pCC = GetCurveComposite( pGuide) ;
       for ( int i = 0 ; i < pCC->GetCurveCount()  &&  bGuideIsPolyLine ; ++i) {
          const ICurve* pCrv = pCC->GetCurve( i) ;
-         if ( pCrv->GetType() != CRV_LINE) {
+         if( pCrv->GetType() != CRV_LINE) {
             if ( pCrv->GetType() == CRV_BEZIER) {
                const ICurveBezier* pCrvBez = GetCurveBezier( pCrv) ;
                bGuideIsPolyLine = pCrvBez->IsALine() ;
@@ -249,7 +249,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
    int nSpanV = 0 ;
    PtrOwner<ICurveComposite> pCrvV( CreateCurveComposite()) ;
    if ( bGuideIsPolyLine ) {
-      if ( pGuide->GetType() == CRV_LINE)
+      if( pGuide->GetType() == CRV_LINE)
          nSpanV = 1 ;
       else if ( pGuide->GetType() == CRV_COMPO)
          nSpanV = GetCurveComposite( pGuide)->GetCurveCount() ;
@@ -260,7 +260,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
          pCrvV->AddCurve( CurveToBezierCurve( pGuide, 3, false)) ;
       else {
          const ICurveBezier* pGuideBez = GetCurveBezier( pGuide) ;
-         if ( ! pGuideBez->IsRational())
+         if( ! pGuideBez->IsRational())
             pCrvV->AddCurve( pGuide->Clone()) ;
          else
             pCrvV->AddCurve( EditBezierCurve( pGuideBez, 3, false)) ;
@@ -297,7 +297,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
       ICRVCOMPOPOVECTOR vCC ;
       INTMATRIX mRep ; mRep.resize( nSpanU * nDegU + 1) ;
       int nMaxSpanV = nSpanV ;
-      for ( int i = 0 ; i < nSpanU ; ++i) {
+      for( int i = 0 ; i < nSpanU ; ++i) {
          const ICurveBezier* pSubCrv = GetCurveBezier( pCrvU->GetCurve( i)) ;
          for ( int j = i==0 ? 0 : 1 ; j < nDegU + 1 ; ++j ) {
             Point3d ptCtrl = pSubCrv->GetControlPoint( j) ;
@@ -327,7 +327,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
                for ( int w = 0 ; w < int( vCC.size()) ; ++w) {
                   const ICurveComposite* pCCOther =  vCC[w] ;
                   int nPropCheck = -1 ; pCCOther->GetCurveTempProp( z, nPropCheck) ;
-                  if ( nPropCheck != 0)
+                  if( nPropCheck != 0)
                      mRep[w][z] = 1 ;
                }
             }
@@ -337,11 +337,11 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
       // conto in quante colonne di mRep la somma degli elementi è != 0
       // questo numero va aggiunto all'attuale nSpanV
       int nSpanPlus = 0 ;
-      for ( int z = 0 ; z < nMaxSpanV ; ++z) {
+      for( int z = 0 ; z < nMaxSpanV ; ++z) {
          int nPosTot = 0 ;
          for ( int k = 0 ; k < int( mRep.size()) ; ++k )
             nPosTot += mRep[k][z] ;
-         if ( nPosTot != 0)
+         if( nPosTot != 0)
             nSpanPlus += 1 ;
       }
       nMaxSpanV = max( nMaxSpanV, nSpanV + nSpanPlus) ;
@@ -349,14 +349,14 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
 
       pSurfBez->Init( nDegU,nDegV, nSpanU, nSpanV, bRat) ;
       //// aggiungo i punti di controllo alla superficie
-      //for ( int i = 0 ; i < nSpanU ; ++i) {
+      //for( int i = 0 ; i < nSpanU ; ++i) {
       //   for ( int j = i==0 ? 0 : 1 ; j < nDegU + 1 ; ++j ) {
       //      const ICurveComposite* pOffsetCrv = vCC[i*nDegU + j] ;
       //      for ( int z = 0 ; z < pOffsetCrv->GetCurveCount() ; ++z) {
       //         const ICurveLine* pCL = GetCurveLine( pOffsetCrv->GetCurve( z)) ;
-      //         if ( pCL == nullptr)
+      //         if( pCL == nullptr)
       //            return nullptr ;
-      //         if ( z == 0) {
+      //         if( z == 0) {
       //            Point3d ptSubStart ; pCL->GetStartPoint( ptSubStart) ;
       //            pSurfBez->SetControlPoint( i * nDegU + j, 0, ptSubStart) ;
       //         }
@@ -367,13 +367,13 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
       //}
 
       //// aggiungo i punti di controllo alla superficie  /// DA CORREGGERE L'AGGIUNTA DEI PUNTI DI CONTROLLO 
-      //for ( int  i = 0 ; i < int( vCC.size()) ; ++i) {
+      //for( int  i = 0 ; i < int( vCC.size()) ; ++i) {
       //   const ICurveComposite* pOffsetCrv = vCC[i] ;
       //   for ( int z = 0 ; z < pOffsetCrv->GetCurveCount() ; ++z) {
       //      const ICurveLine* pCL = GetCurveLine( pOffsetCrv->GetCurve( z)) ;
-      //      if ( pCL == nullptr)
+      //      if( pCL == nullptr)
       //         return nullptr ;
-      //      if ( z == 0) {
+      //      if( z == 0) {
       //         Point3d ptSubStart ; pCL->GetStartPoint( ptSubStart) ;
       //         pSurfBez->SetControlPoint( i * nDegU + j, 0, ptSubStart) ;
       //      }
@@ -422,7 +422,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
       //frStart.Set( ptStart, -vtStart, vtStart ^ vtNorm) ;
       //// porto la sezione nel sistema di riferimento del piano in cui giace
       //pCrvU->ToLoc( frStart) ;
-      //for ( int i = 0 ; i < nSpanU ; ++i) {
+      //for( int i = 0 ; i < nSpanU ; ++i) {
       //   const ICurveBezier* pSubCrv = GetCurveBezier( pCrvU->GetCurve( i)) ;
       //   for ( int j = i==0 ? 0 : 1 ; j < nDegU + 1 ; ++j ) {
       //      Point3d ptCtrl = pSubCrv->GetControlPoint( j) ;
@@ -458,7 +458,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
       //      // aggiungo i punti di controllo alla superficie
       //      for ( int z = 0 ; z < nSpanV ; ++z) {
       //         const ICurveBezier* pCrvBez = GetCurveBezier( pCrvV->GetCurve( z)) ;
-      //         if ( pCrvBez == nullptr)
+      //         if( pCrvBez == nullptr)
       //            return nullptr ;
       //         for ( int k = z == 0 ? 0 : 1 ; k < nDegV ; ++k) {
       //            Point3d ptCtrl = pCrvBez->GetControlPoint( k) ;
@@ -572,7 +572,7 @@ GetSurfBezierSwept3d( const ICurve* pSect, const ICurve* pGuide, const Vector3d&
       pCrvU->AddCurve( CurveToBezierCurve( pSect, 3, false)) ;
    else {
       const ICurveBezier* pSectBez = GetCurveBezier( pSect) ;
-      if ( ! pSectBez->IsRational())
+      if( ! pSectBez->IsRational())
          pCrvU->AddCurve( pSect->Clone()) ;    ///// questa curva potrebbe non essere di grado 3!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
       else
          pCrvU->AddCurve( EditBezierCurve( pSectBez, 3, false)) ;
@@ -709,7 +709,7 @@ GetSurfBezierRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, dou
    // se la curva è già una bezier singola la tengo, sennò la converto
    PtrOwner<ICurveComposite> pCC1( CreateCurveComposite()) ;
    if ( pCurve1->GetType() != CRV_BEZIER)
-      pCC1->AddCurve( CurveToBezierCurve( pCurve1, 3, false)) ;
+      pCC1->AddCurve( CurveToBezierCurve( pCurve1, true, false)) ;
    else
       pCC1->AddCurve( pCurve1->Clone()) ;
    if ( IsNull( pCC1)  ||  ! pCC1->IsValid())
@@ -718,7 +718,7 @@ GetSurfBezierRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, dou
    // se la curva è già una bezier singola la tengo, sennò la converto
    PtrOwner<ICurveComposite> pCC2( CreateCurveComposite()) ;
    if ( pCurve2->GetType() != CRV_BEZIER)
-      pCC2->AddCurve( CurveToBezierCurve( pCurve2, 3, false)) ;
+      pCC2->AddCurve( CurveToBezierCurve( pCurve2, true, false)) ;
    else
       pCC2->AddCurve( pCurve2->Clone()) ;
    if ( IsNull( pCC2)  ||  ! pCC2->IsValid())
@@ -733,55 +733,18 @@ GetSurfBezierRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, dou
    return Release( pSbz) ;
 }
 
-//-------------------------------------------------------------------------------
-ISurfBezier*
-GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const ICURVEPOVECTOR& vCrv, const ICURVEPOVECTOR& vNewCrv,
-                          const INTVECTOR& vShown, const INTINTVECTOR& vNewOrEdited, double dLinTol)
-{
-   // verifica parametri
-   if ( pCurve1 == nullptr  ||  pCurve2 == nullptr)
-      return nullptr ;
-
-   // dLinTol servirà quando ci sarà la funzione ApproxWithCurveBezier
-   // se la curva è già una bezier singola la tengo, sennò la converto
-   PtrOwner<ICurveComposite> pCC1( CreateCurveComposite()) ;
-   if ( pCurve1->GetType() != CRV_BEZIER)
-      pCC1->AddCurve( CurveToBezierCurve( pCurve1, 3, false)) ;
-   else
-      pCC1->AddCurve( pCurve1->Clone()) ;
-   if ( IsNull( pCC1)  ||  ! pCC1->IsValid())
-      return nullptr ;
-
-   // se la curva è già una bezier singola la tengo, sennò la converto
-   PtrOwner<ICurveComposite> pCC2( CreateCurveComposite()) ;
-   if ( pCurve2->GetType() != CRV_BEZIER)
-      pCC2->AddCurve( CurveToBezierCurve( pCurve2, 3, false)) ;
-   else
-      pCC2->AddCurve( pCurve2->Clone()) ;
-   if ( IsNull( pCC2)  ||  ! pCC2->IsValid())
-      return nullptr ;
-
-   // creo e setto la superficie trimesh
-   PtrOwner<SurfBezier> pSbz( CreateBasicSurfBezier()) ;
-   if ( IsNull( pSbz)  ||  ! pSbz->CreateByIsoParamSet( pCC1, pCC2, vCrv, vNewCrv, vShown, vNewOrEdited))
-      return nullptr ;
-
-   // restituisco la superficie
-   return Release( pSbz) ;
-}
-
 //-------------------------------------------------------------------------------
 ISurfBezier*
 GetSurfBezierSkinned( const CICURVEPVECTOR& vCrv, double dLinTol)
 {
    // verifico che le curve siano valide
    for ( int i = 0 ; i < int( vCrv.size()) ; ++i) {
-      if ( vCrv[i] == nullptr  ||  ! vCrv[i]->IsValid())
+      if( vCrv[i] == nullptr  ||  ! vCrv[i]->IsValid())
          return nullptr ;
    }
 
    // se ho solo due curve allora faccio la rigata
-   if ( vCrv.size() == 2)
+   if( vCrv.size() == 2)
       return GetSurfBezierRuled( vCrv[0], vCrv[1], ISurfBezier::RLT_B_MINDIST_PLUS, dLinTol) ;
 
    //trasformo le curve in curve di bezier, pareggio il numero di sottocurve e il grado
@@ -789,7 +752,7 @@ GetSurfBezierSkinned( const CICURVEPVECTOR& vCrv, double dLinTol)
    // dLinTol servirà quando ci sarà la funzione ApproxWithCurveBezier
    // se la curva è già una bezier singola la tengo, sennò la converto
    ICURVEPOVECTOR vCrvBez ;
-   for ( int c = 0 ; c < int( vCrv.size()) ; ++c){
+   for( int c = 0 ; c < int( vCrv.size()) ; ++c){
       PtrOwner<ICurveComposite> pCC( CreateCurveComposite()) ;
       if ( vCrv[c]->GetType() != CRV_BEZIER )
          pCC->AddCurve( CurveToBezierCurve( vCrv[c])) ;

StmFromCurves.cpp

@@ -73,7 +73,7 @@ GetSurfTriMeshByRegion( const CICURVEPVECTOR& vpCurve, double dLinTol)
       return nullptr ;
    for ( int i = 0 ; i < int( vnPLIndMat.size()) ; ++i) {
       for ( int j = 0 ; j < int( vnPLIndMat[i].size()) ; ++j){
-         if ( vbInvert[vnPLIndMat[i][j]])
+         if( vbInvert[vnPLIndMat[i][j]])
             vPL[vnPLIndMat[i][j]].Invert() ;
       }
    }
@@ -165,7 +165,7 @@ GetSurfTriMeshByRegionExtrusion( const CICURVEPVECTOR& vpCurve, const Vector3d&
    if ( ! CalcRegionPolyLines( vPL, vtN, vnPLIndMat, vbInvert))
       return nullptr ;
    for ( int i = 0 ; i < int( vPL.size()) ; ++i) {
-      if ( vbInvert[i])
+      if( vbInvert[i])
          vPL[i].Invert() ;
    }
   // verifico la direzione di estrusione

SubtractProjectedFacesOnStmFace.cpp

@@ -302,7 +302,7 @@ SetTmpPropByOverlap( ICurveComposite* pCrvCheck, const int nInd, const ICurveCom
      // ultimo tratto di curva della Composita iniziale
       PtrOwner<CurveComposite> pCrvB( GetBasicCurveComposite( pCrvCheck->CopyParamRange( nInd + 1, pCrvCheck->GetCurveCount()))) ;
       if ( ! IsNull( pCrvB)  &&  pCrvB->GetCurveCount() > 0  &&  pCrvB->IsValid())
-         if ( ! pCrvToReturn->AddCurve( Release( pCrvB))) {
+         if( ! pCrvToReturn->AddCurve( Release( pCrvB))) {
             nStat = 2 ;
             return true ;
          }

SurfAux.cpp

@@ -37,12 +37,12 @@ NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
       bool bIsRational = snData.bRat ;
       // vettore dei nodi
       DBLVECTOR vU ;
-      int nKnot = ssize( snData.vU) ;
+      int nKnot = (int) snData.vU.size() ;
       for ( int k = 0 ; k < nKnot ; ++k ) {
          double dKnot = snData.vU[k] ;
          vU.push_back( dKnot) ;
       }
-      for ( int j = 0 ; j < snData.nCPV ; ++j) {
+      for( int j = 0 ; j < snData.nCPV ; ++j) {
          CNurbsData nuCurve ;
          nuCurve.bPeriodic = true ;
          nuCurve.bRat = snData.bRat ;
@@ -66,16 +66,12 @@ NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
          if ( NurbsCurveCanonicalize( nuCurve)) {  // se NurbsCurveCanonicalize ha restituito false (la curva potrebbe esserre un punto di polo) allora non modifico i punti e il vettore dei nodi della superficie
             if ( snData.mCP.size() != nuCurve.vCP.size() ) {
                snData.mCP.resize( nuCurve.vCP.size()) ;
-               if ( snData.bRat)
+               if( snData.bRat)
                   snData.mW.resize( nuCurve.vW.size()) ;
             }
-            for ( int i = 0 ; i < ssize( nuCurve.vCP) ; ++i) {
-               if ( snData.mCP[i].empty())
-                  snData.mCP[i].resize( snData.nCPV) ;
+            for ( int i = 0 ; i < snData.nCPU ; ++i) {
                snData.mCP[i][j] = nuCurve.vCP[i] ;
-               if ( snData.bRat) {
-                  if ( snData.mW[i].empty())
-                     snData.mW[i].resize( snData.nCPV) ;
+               if( snData.bRat) {
                   snData.mW[i][j] = nuCurve.vW[i] ;
                   snData.mCP[i][j] *= nuCurve.vW[i] ;
                }
@@ -84,18 +80,18 @@ NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
          }
       }
       snData.bPeriodicU = false ;
-      snData.nCPU = ssize( snData.mCP) ;
+      snData.nCPU = int( snData.mCP.size()) ;
    }
    if ( snData.bPeriodicV  ||  ! snData.bClampedV) {
       bool bIsRational = snData.bRat ;
       // vettore dei nodi
       DBLVECTOR vV ;
-      int nKnot = ssize( snData.vV) ;
+      int nKnot = (int) snData.vV.size() ;
       for ( int k = 0 ; k < nKnot ; ++k ) {
          double dKnot = snData.vV[k] ;
          vV.push_back( dKnot) ;
       }
-      for ( int i = 0 ; i < snData.nCPU ; ++i) {
+      for( int i = 0 ; i < snData.nCPU ; ++i) {
          CNurbsData nuCurve ;
          nuCurve.bPeriodic = true ;
          nuCurve.bRat = snData.bRat ;
@@ -136,7 +132,7 @@ NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
          }
       }
       snData.bPeriodicV = false ;
-      snData.nCPV = ssize( snData.mCP[0]) ;
+      snData.nCPV = int( snData.mCP[0].size()) ;
    }
    return true ;
 }

SurfBezier.h

@@ -20,9 +20,18 @@
 #include "SurfTriMesh.h"
 #include "SurfFlatRegion.h"
 #include "/EgtDev/Include/EGkSurfBezier.h"
-#include "/EgtDev/Include/EGkIntersLineTria.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
 
+class Tree ;
+
+struct PairHashIntInt {
+   std::size_t operator()(const std::pair<int, int>& key) const {
+      std::size_t h1 = std::hash<int>{}(key.first);
+      std::size_t h2 = std::hash<int>{}(key.second);
+      return h1 ^ (h2 << 1);  // Combine hashes
+   }
+};
+
 //----------------------------------------------------------------------------
 class SurfBezier : public ISurfBezier, public IGeoObjRW
 {
@@ -72,10 +81,10 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool GetVolume( double& dVolume) const override
                { if ( &dVolume == nullptr)
                     return false ;
-                 if ( m_pSTM == nullptr)
+                 if( m_pSTM == nullptr)
                     GetAuxSurf() ;
                  dVolume = 0 ;
-                 if ( m_pSTM != nullptr)
+                 if( m_pSTM != nullptr)
                     m_pSTM->GetVolume( dVolume) ;
                  return true ; }
       bool GetCentroid( Point3d& ptCen) const override ;
@@ -116,17 +125,18 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const override ;
       const SurfTriMesh* GetAuxSurf( void) const override ;
       const SurfTriMesh* GetAuxSurfRefined( void) const override ;
-      SurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL, bool bUpdateEdges = false) const override ;
+      SurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL) const override ;
       // funzione per ottenere la suddivisione dello spazio parametrico nelle celle utilizzate per la triangolazione.
       bool GetLeaves( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const override ;
       bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const override ;
       // funzioni che servono per ricavare l'immagine nel parametrico di un punto appartenente alla trimesh ausiliaria della superficie di Bezier
-      bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL = IntLineTriaType::ILTT_IN) const override ;
+      // a nIL si può passare 5 come valore di default
+      bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL = 5) const override ;
       bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL, const Point3d& ptIPrev, bool* bTroughEdge = nullptr) const override ;
       // restituisce il corrispettivo parametrico di un punto qualunque della trimesh associata alla superficie
       // ptIPrev è un punto addizionale che precede o segue il punto pt3D nel caso in cui il punto faccia parte di una curva 3d sulla superficie
       // pPlCut è il piano di taglio su cui dovrebbe giacere il punto raffinato
-      bool UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d& ptIPrev = P_INVALID, bool* bTroughEdge = nullptr, const Plane3d* plCut = nullptr) const override ;
+      bool UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d& ptIPrev, bool* bTroughEdge = nullptr, const Plane3d* plCut = nullptr) const override ;
       // pPlCut è il piano di taglio su cui giace la curva
       bool UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& vpCC, const Plane3d* pPlCut) const override ;
       // funzione per tagliare una superficie di bezier con un piano ( cancello la parte dal lato positivo della normale del piano).
@@ -136,10 +146,8 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool IncreaseUV( double& dU, double dx, bool bUOrV, double* dUVCopy = nullptr, bool bModifyOrig = true) const override ;
       bool IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bModifyOrig) const override ;
       // funzione che restituisce gli edge della superficie o in forma di linea spezzata o in forma di curva di Bezier
-      // restituisce un vettore con i loop della superficie ( più di uno solo se è trimmata con un parametrico con buchi o più di un chunk)
-      bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier) const override ;
-      // restituisce il singolo edge della superficie non trimmata
-      ICurveComposite* GetSingleEdge3D( bool bLineOrBezier, int nEdge) const override ;
+      // se la superficie è trimmata restituisce i loop dello spazio parametrico in forma di linee spezzate
+      bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const override ;  // se la superficie non è trimmata restituisce un vettore di 4 elementi. Se la superficie è chiusa lungo un parametro i lati algi estremi di quel parametro saranno null.
       bool IsPlanar( void) const override ;
       bool CreateByFlatContour( const PolyLine& PL) override ;
       bool CreateByRegion( const POLYLINEVECTOR& vPL) override ;
@@ -149,10 +157,6 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) override ;
       bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3) override ;
       PNTVECTOR GetAllControlPoints( void) const ;
-      bool GetAllPatchesIsocurves( bool bUorV, ICURVEPOVECTOR& vCrv) const ;
-      bool CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const ICURVEPOVECTOR& vCrv, const ICURVEPOVECTOR& vNewCrv, const INTVECTOR& vShown ,const INTINTVECTOR& vNewOrEdited) ;
-      bool RemoveCollapsedSpans() override ;
-      bool SwapParameters() ;
 
    public :                      // IGeoObjRW
       int  GetNgeId( void) const override ;
@@ -206,6 +210,8 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       // funzione che proietta nello spazio parametrico un trim derivante da un taglio con un piano, categorizzandolo come aperto o chiuso ( nel parametrico)
       bool AddCurveCompoToCuts( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVECTOR& vpCCClosed, double dToler = EPS_SMALL, const Plane3d* pPlCut = nullptr) const ;
       ISurfFlatRegion* CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVECTOR& vpCCClosed) const ;
+      // restituisce il singolo edge della superficie non trimmata
+      ICurveComposite* GetSingleEdge3D( bool bLineOrBezier, int nEdge) const ;
       // funzione che calcola se gli edge sono collassati in poli
       bool CalcPoles( void) const ;
       bool FindMatchByParam( const PolyLine& pl0, const PolyLine& pl1, INTVECTOR& vMatch, int& nLong) const ;
@@ -224,8 +230,8 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       int             m_nSpanV ;           // numero di pezze in V
       bool            m_bRat ;             // flag di razionale/polinomiale
       bool            m_bTrimmed ;         // flag per presenza regione di trim
-      mutable bool    m_bClosedU ;         // flag che indica se la superficie è chiusa lungo il parametro U ( gli edge a V=0 e V=1 coincidono)
-      mutable bool    m_bClosedV ;         // flag che indica se la superficie è chiusa lungo il parametro V ( gli edge a U=0 e U=1 coincidono)
+      mutable bool    m_bClosedU ;         // flag che indica se la superficie è chiusa lungo il parametro U
+      mutable bool    m_bClosedV ;         // flag che indica se la superficie è chiusa lungo il parametro V
       mutable BOOLVECTOR m_vbPole ;        // vettore di flag che indicano se i lati sono collassati in dei poli
       PNTVECTOR       m_vPtCtrl ;          // vettore dei punti di controllo
       DBLVECTOR       m_vWeCtrl ;          // vettore dei pesi di controllo

SurfFlatRegion.cpp

@@ -56,7 +56,6 @@ SurfFlatRegion::Clear( void)
    for ( auto& pLoop : m_vpLoop)
       delete pLoop ;
    m_vpLoop.clear() ;
-   m_vExtInd.clear() ;
 
    m_nTempProp[0] = 0 ;
    m_nTempProp[1] = 0 ;
@@ -828,7 +827,7 @@ SurfFlatRegion::ConvertArcsToBezierCurves( void)
   // ciclo sui loop
    for ( auto& pLoop : m_vpLoop) {
       if ( pLoop->GetType() == CRV_ARC) {
-         ICurve* pCrvNew = ArcToBezierCurve( GetCurveArc(pLoop)) ;
+         ICurve* pCrvNew = ArcToBezierCurve( pLoop) ;
          if ( pCrvNew == nullptr)
             return false ;
          delete pLoop ;

SurfTriMesh.cpp

@@ -517,9 +517,9 @@ SurfTriMesh::GetVertexParam( int nId, double& dU, double& dV) const
   // verifico esistenza del vertice
    if ( nId < 0  ||  nId >= GetVertexSize()  ||  m_vVert[nId].nIdTria == SVT_DEL)
       return false ;
-  // recupero i dati (verso l'esterno sempre in 0..1..2..3..)
-   dU = m_vVert[nId].dU / PREC_SCALE_COEFF ;
-   dV = m_vVert[nId].dV / PREC_SCALE_COEFF ;
+  // recupero i dati
+   dU = m_vVert[nId].dU ;
+   dV = m_vVert[nId].dV ;
    return true ;
 }
 
@@ -870,21 +870,15 @@ SurfTriMesh::GetTriangleSmoothNormal( int nT, int nV, Vector3d& vtN) const
    if ( nPos == -1)
       return false ;
 
-  // medio le normali, finchè non incontro degli spigoli
-   double dAngW = 1 ;
-   GetTriangleVertexAngle( nT, nV, dAngW) ;
-   vtN = dAngW * m_vTria[nT].vtN ;
+  // medio le normali, finch� non incontro degli spigoli
+   vtN = m_vTria[nT].vtN ;
    // parto dal triangolo e vado in direzione positiva
    int nLim = nPos ;
    for ( int i = NextIndAroundVertex( nPos, nTria, bCirc) ;
          i != nPos && i < int( vT.size()) ;
          i = NextIndAroundVertex( i, nTria, bCirc)) {
-      if ( m_vTria[nT].vtN * m_vTria[vT[i]].vtN >= m_dCosSmAng) {
-         int nK ; double dAngW = 1 ;
-         if ( FindVertexInTria( m_vTria[nT].nIdVert[nV], vT[i], nK)  &&
-              GetTriangleVertexAngle( vT[i], nK, dAngW))
-            vtN += dAngW * m_vTria[vT[i]].vtN ;
-      }
+      if ( m_vTria[vT[nPos]].vtN * m_vTria[vT[i]].vtN >= m_dCosSmAng)
+         vtN += m_vTria[vT[i]].vtN ;
       else
          break ;
       nLim = i ;
@@ -893,12 +887,8 @@ SurfTriMesh::GetTriangleSmoothNormal( int nT, int nV, Vector3d& vtN) const
    for ( int i = PrevIndAroundVertex( nPos, nTria, bCirc) ;
          i != nLim && i >= 0 ;
          i = PrevIndAroundVertex( i, nTria, bCirc)) {
-      if ( m_vTria[nT].vtN * m_vTria[vT[i]].vtN >= m_dCosSmAng) {
-         int nK ; double dAngW = 1 ;
-         if ( FindVertexInTria( m_vTria[nT].nIdVert[nV], vT[i], nK)  &&
-              GetTriangleVertexAngle( vT[i], nK, dAngW))
-            vtN += dAngW * m_vTria[vT[i]].vtN ;
-      }
+      if ( m_vTria[vT[nPos]].vtN * m_vTria[vT[i]].vtN >= m_dCosSmAng)
+         vtN += m_vTria[vT[i]].vtN ;
       else
          break ;
    }
@@ -907,23 +897,6 @@ SurfTriMesh::GetTriangleSmoothNormal( int nT, int nV, Vector3d& vtN) const
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-SurfTriMesh::GetTriangleVertexAngle( int nT, int nV, double& dAng) const 
-{
-  // verifico esistenza del triangolo e validità vertice
-   if ( nT < 0  ||  nT >= GetTriangleSize()  ||  m_vTria[nT].nIdVert[0] == SVT_DEL  ||  nV < 0  ||  nV > 2)
-      return false ;
-  // determino i vettori dei due lati che partono dal vertice
-   Point3d ptVert = m_vVert[ m_vTria[nT].nIdVert[nV]].ptP ;
-   Point3d ptPrev = m_vVert[ m_vTria[nT].nIdVert[Prev( nV)]].ptP ;
-   Point3d ptNext = m_vVert[ m_vTria[nT].nIdVert[Next( nV)]].ptP ;
-   Vector3d vtPrev = ptPrev - ptVert ;
-   Vector3d vtNext = ptNext - ptVert ;
-  // determino l'angolo tra i due lati
-   return vtPrev.GetAngle( vtNext, dAng) ;
-}
-
 //----------------------------------------------------------------------------
 SurfTriMesh*
 SurfTriMesh::CloneTriangle( int nT) const
@@ -1367,8 +1340,6 @@ SurfTriMesh::GetTitle( void) const
 bool
 SurfTriMesh::Dump( string& sOut, bool bMM, const char* szNewLine) const
 {
-  // visualizzazione spigoli
-   sOut += "ShowEdges=" + ToString( GetShowEdges()) + szNewLine ;
   // area
    double dArea ;
    GetArea( dArea) ;
@@ -3666,18 +3637,6 @@ SurfTriMesh::Invert( void)
    for ( int i = 0 ; i < GetTriangleSize() ; ++ i)
       InvertTriangle( i) ;
 
-  // se bordi della sfaccettatura validi
-   if ( m_bFacEdged) {
-      for ( int nE = 0 ; nE < GetEdgeCount() ; ++ nE) {
-        // inversione dei vertici nel vettore delle sfaccettature
-         swap( m_vFacEdge[nE].nIdVert[0], m_vFacEdge[nE].nIdVert[1]) ;
-        // inversione delle adiacenze nel vettore delle sfaccettature
-         swap( m_vFacEdge[nE].nIdFacAdj[0], m_vFacEdge[nE].nIdFacAdj[1]) ;
-        // inversione dell'angolo interno
-         m_vFacEdge[nE].dIntAng *= -1. ;
-      }
-   }
-
    return true ;
 }
 
@@ -4541,21 +4500,3 @@ SurfTriMesh::AdjustTopologyFromZMap( void)
 
    return true ;
 }
-
-//----------------------------------------------------------------------------
-bool
-SurfTriMesh::GetTriaFromFace( int nF, int& nT) const
-{
-  // la superficie deve essere validata
-   if ( m_nStatus != OK)
-      return false ;
-  // verifico stato sfaccettatura
-   if ( ! VerifyFaceting())
-      return false ;
-  // l'indice della faccia deve essere nei limiti
-   if ( nF < 0  ||  nF >= int( m_vFacet.size()))
-      return false ;
-  // recupero la normale di un triangolo della faccetta
-   nT = m_vFacet[nF] ;
-   return true ;
-}

SurfTriMesh.h

@@ -322,8 +322,6 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       bool GetEdge( int nInd, int& nV1, int& nV2, int& nFl, int& nFr, double& dAng) const override ;
       bool GetEdge( int nInd, Point3d& ptP1, Point3d& ptP2, double& dAng) const override ;
       bool GetEdges( ICURVEPOVECTOR& vpCurve) const override ;
-      bool GetCurvature( int nV,
-                         double& dMinK, Vector3d& vtMinK, double& dMaxK, Vector3d& vtMaxK, bool& bPlanar, Vector3d& vtNorm) const override ;
       bool Cut( const Plane3d& plPlane, bool bSaveOnEq) override ;
       bool GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq) override ;
       bool Add( const ISurfTriMesh& Other) override ;
@@ -380,7 +378,6 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       bool SetTempInt( int nId, int nTempInt) const ;
       bool AddTriaFromZMap( const TRIA3DEXVECTOR& vTria, PointGrid3d& VertGrid, double dVertexTol = 2 * EPS_SMALL) ;
       bool AdjustTopologyFromZMap( void) ;
-      bool GetTriaFromFace( int nF, int& nT) const ;
 
    private :
       typedef std::vector<StmVert>    VERTVECTOR ;
@@ -414,7 +411,6 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       int  NextIndAroundVertex( int nInd, int nSize, bool bCirc) const ;
       int  PrevIndAroundVertex( int nInd, int nSize, bool bCirc) const ;
       bool GetTriangleSmoothNormal( int nT, int nV, Vector3d& vtN) const ;
-      bool GetTriangleVertexAngle( int nT, int nV, double& dAng) const ;
       bool MarchAlongLoop( int nT, int nV, int nTimeStamp, PolyLine& PL) const ;
       bool MarchOneTria( int& nT, int& nV, int nTimeStamp, PolyLine& PL, bool& bEnd) const ;
       bool VerifyPolylinesForTwoCurves( const PolyLine&  PL1, const PolyLine&  PL2) const ;

SurfTriMeshBooleans.cpp

@@ -41,7 +41,7 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-const double BOOLEAN_SCALE = PREC_SCALE_COEFF ;
+const double BOOLEAN_SCALE = 1024 ;
 
 //----------------------------------------------------------------------------
 bool

SurfTriMeshCuts.cpp

@@ -26,7 +26,7 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-const double CUT_SCALE = PREC_SCALE_COEFF ;
+const double CUT_SCALE = 1024 ;
 
 //----------------------------------------------------------------------------
 bool

SurfTriMeshFaceting.cpp

@@ -21,8 +21,6 @@
 #include <array>
 #include <set>
 #include <unordered_map>
-#define EIGEN_NO_IO
-#include "/EgtDev/Extern/Eigen/Dense"
 
 using namespace std ;
 
@@ -56,7 +54,7 @@ SurfTriMesh::UpdateFaceting( void)
    bool bOk = true ;
    for ( int j = 0 ; j < int( vOldFacet.size()) ; ++ j) {
       int i = vOldFacet[j] ;
-     // salto triangoli inesistenti o già assegnati
+     // salto triangoli inesistenti o già assegnati
       if ( i >= int( m_vTria.size())  ||
            m_vTria[i].nIdVert[0] == SVT_DEL  ||
            m_vTria[i].nIdFacet != SVT_NULL)
@@ -71,7 +69,7 @@ SurfTriMesh::UpdateFaceting( void)
 
   // ricostruisco le altre sfaccettature
    for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i) {
-     // salto triangoli cancellati o già assegnati
+     // salto triangoli cancellati o già assegnati
       if ( m_vTria[i].nIdVert[0] == SVT_DEL  ||
            m_vTria[i].nIdFacet != SVT_NULL)
          continue ;
@@ -105,7 +103,7 @@ SurfTriMesh::UpdateOneFace( int nFacet, int nT)
   // set di triangoli da aggiornare
    set<int> stTria ;
    stTria.insert( nT) ;
-  // finchè set non vuoto
+  // finchè set non vuoto
    bool bOk = true ;
    while ( ! stTria.empty()) {
      // tolgo un triangolo dal set
@@ -423,7 +421,7 @@ SurfTriMesh::GetFacetLoops( int nF, POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongFacetLoop( nF, nT, 1, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // se il lato 0 è di contorno
+        // se il lato 0 è di contorno
          else if ( nAdjF[0] != nF) {
            // ho trovato l'inizio di un loop
             vPL.emplace_back() ;
@@ -435,7 +433,7 @@ SurfTriMesh::GetFacetLoops( int nF, POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongFacetLoop( nF, nT, 1, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // se il lato 1 è di contorno
+        // se il lato 1 è di contorno
          else if ( nAdjF[1] != nF) {
            // ho trovato l'inizio di un loop
             vPL.emplace_back() ;
@@ -447,7 +445,7 @@ SurfTriMesh::GetFacetLoops( int nF, POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongFacetLoop( nF, nT, 2, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // se il lato 2 è di contorno
+        // se il lato 2 è di contorno
          else if ( nAdjF[2] != nF) {
            // ho trovato l'inizio di un loop
             vPL.emplace_back() ;
@@ -459,7 +457,7 @@ SurfTriMesh::GetFacetLoops( int nF, POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongFacetLoop( nF, nT, 0, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // altrimenti non c'è contorno
+        // altrimenti non c'è contorno
          else {
            // marco il triangolo come verificato
             m_vTria[nT].nTemp = m_nTimeStamp ;
@@ -478,7 +476,7 @@ SurfTriMesh::GetFacetLoops( int nF, POLYLINEVECTOR& vPL) const
          return false ;
      // se loop esterno
       if ( vtN * plPlane.GetVersN() > 0) {
-        // se non c'è ancora loop esterno in prima posizione
+        // se non c'è ancora loop esterno in prima posizione
          if ( ! bOutFirst) {
            // lo sposto in prima posizione
             if ( i != 0)
@@ -519,7 +517,7 @@ SurfTriMesh::MarchOneFacetTria( int nF, int& nT, int& nV, int nTimeStamp,
   // verifico appartenga alla stessa faccia
    if ( m_vTria[nAdjT].nIdFacet != nF)
       return false ;
-  // recupero il suo lato di adiacenza (e verifico non abbia più adiacenze con il triangolo di partenza)
+  // recupero il suo lato di adiacenza (e verifico non abbia più adiacenze con il triangolo di partenza)
    int nAdjS = SVT_NULL ;
    for ( int i = 0 ; i < 3 ; ++ i) {
       if ( m_vTria[nAdjT].nIdAdjac[i] == nT) {
@@ -533,11 +531,11 @@ SurfTriMesh::MarchOneFacetTria( int nF, int& nT, int& nV, int nTimeStamp,
       return false ;
   // vertice di fine adiacenza e indice del successivo lato
    int nAdjV = Next( nAdjS) ;
-  // verifico se il lato successivo è un bordo
+  // verifico se il lato successivo è un bordo
    int nNextT = m_vTria[nAdjT].nIdAdjac[nAdjV] ;
    int nNextF = ( nNextT != SVT_NULL ? m_vTria[nNextT].nIdFacet : SVT_NULL) ;
    if ( nNextF != nF) {
-     // se già recuperato
+     // se già recuperato
       if ( m_vTria[nAdjT].nTemp == nTimeStamp) {
          bEnd = true ;
          return true ;
@@ -595,7 +593,7 @@ SurfTriMesh::GetFacetsContact( int nF1, int nF2, bool& bAdjac, Point3d& ptP1, Po
   // verifico esistenza seconda faccia
    if ( nF2 < 0  ||  nF2 >= int( m_vFacet.size()))
       return false ;
-  // verifico se c'è un contatto con la seconda faccia e recupero i punti estremi della eventuale linea di contatto
+  // verifico se c'è un contatto con la seconda faccia e recupero i punti estremi della eventuale linea di contatto
    bAdjac = false ;
    for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
       double dUs, dUe ;
@@ -608,7 +606,7 @@ SurfTriMesh::GetFacetsContact( int nF1, int nF2, bool& bAdjac, Point3d& ptP1, Po
                ptP2 = ptPe ;
             }
             else {
-              // parametri del segmento già definito
+              // parametri del segmento già definito
                Vector3d vtT ;
                double dLen ;
                DirDist( ptP1, ptP2, vtT, dLen) ;
@@ -648,7 +646,7 @@ SurfTriMesh::GetFacetCenter( int nF, Point3d& ptCen, Vector3d& vtN) const
    POLYLINEVECTOR vPL ;
    if ( ! GetFacetLoops( nF, vPL)  ||  vPL.empty())
       return false ;
-  // calcolo il centro del loop esterno (è il primo)
+  // calcolo il centro del loop esterno (è il primo)
    PolygonPlane PolyPlane ;
    Point3d  ptP ;
    for ( bool bFound = vPL[0].GetFirstPoint( ptP) ; bFound ; bFound = vPL[0].GetNextPoint( ptP))
@@ -732,7 +730,7 @@ SurfTriMesh::CloneFacet( int nF) const
      // ciclo sui tre vertici
       int nIdV[3] ;
       for ( int j = 0 ; j < 3 ; ++ j) {
-        // verifico se vertice già presente
+        // verifico se vertice già presente
          const auto it = PntMap.find( m_vTria[nT].nIdVert[j]) ;
          if ( it == PntMap.end()) {
            // aggiungo il vertice
@@ -775,7 +773,7 @@ SurfTriMesh::RemoveFacet( int nF)
    if ( ! DoCompacting())
       return false ;
 
-  // dichiaro necessità ricalcolo della grafica e di hashgrids3d
+  // dichiaro necessità ricalcolo della grafica e di hashgrids3d
    m_OGrMgr.Reset() ;
    ResetHashGrids3d() ;
 
@@ -880,7 +878,7 @@ SurfTriMesh::UpdateFacetEdging( void)
    m_bFacEdged = false ;
    m_vFacEdge.clear() ;
 
-  // verifico validità sfaccettatura
+  // verifico validità sfaccettatura
    if ( ! VerifyFaceting())
       return false ;
 
@@ -959,7 +957,7 @@ SurfTriMesh::GetEdge( int nInd, int& nV1, int& nV2, int& nFl, int& nFr, double&
   // verifico stato bordi sfaccettatura
    if ( ! VerifyFacetEdging())
       return false ;
-  // verifico la validità dell'indice
+  // verifico la validità dell'indice
    if ( nInd < 0  ||  nInd > int( m_vFacEdge.size()))
       return SVT_NULL ;
   // recupero i dati
@@ -982,7 +980,7 @@ SurfTriMesh::GetEdge( int nInd, Point3d& ptP1, Point3d& ptP2, double& dAng) cons
   // verifico stato bordi sfaccettatura
    if ( ! VerifyFacetEdging())
       return false ;
-  // verifico la validità dell'indice
+  // verifico la validità dell'indice
    if ( nInd < 0  ||  nInd > int( m_vFacEdge.size()))
       return SVT_NULL ;
   // recupero i dati
@@ -1017,149 +1015,3 @@ SurfTriMesh::GetEdges( ICURVEPOVECTOR& vpCurve) const
    }
    return true ;
 }
-
-//-----------------------------------------------------------------------------
-// Funzione per il calcolo della curvatura massima e minima in un vertice della superficie TriMesh
-//    dMinK : curvatura minima
-//    vtMinK : versore direzione curvatura minima
-//    dMaxK : curvatura massima
-//    vtMaxK : versore direzione curvatura massima
-//    bPlanar : Flag per indicare le superficie localmente piana
-//    vtNorm : versore normale del piano tangente alla supericie nel vertice
-bool
-SurfTriMesh::GetCurvature( int nV,
-                           double& dMinK, Vector3d& vtMinK, double& dMaxK, Vector3d& vtMaxK, bool& bPlanar, Vector3d& vtNorm) const
-{
-  // Controllo la validità della TriMesh e del Vertice
-   if ( ! IsValid())
-      return false ;
-   Point3d ptCurr ;
-   if ( ! GetVertex( nV, ptCurr))
-      return false ;
-   bPlanar = false ;
-
-  // Recupero tutti i vertici attorno al vertice corrente ( se presenza di lato libero, allora errore)
-   INTVECTOR vT ;
-   bool bCirc ;
-   if ( ! GetAllTriaAroundVertex( nV, vT, bCirc)  ||  ! bCirc)
-      return false ;
-
-  // Calcolo la normale del vertice pesata mediante angolo sotteso e distanza baricentrica
-  // ["Estimation Normal Vector of Triangular Mesh Vertex by Angle and Centroid Weights"]
-  // Controllo anche di non essere in presenza di uno spigolo vivo
-   INTSET setIndTriaNeightbors ;
-   bool bFirstTria = true ;
-   Vector3d vtNFirstTria = V_NULL ;
-   for ( const int& nT : vT) {
-     // Recupero il triangolo corrente
-      Triangle3d Tria ;
-      int nIdVert[3] ;
-      if ( ! GetTriangle( nT, Tria)  ||  ! GetTriangle( nT, nIdVert))
-         return false ;
-     // Se il triangolo ha area troppo piccola, lo scarto
-      if ( Tria.GetArea() < EPS_SMALL)
-         continue ;
-     // Se primo triangolo salvo la sua normale di riferimento per successivi confronti
-      if ( bFirstTria) {
-         vtNFirstTria = Tria.GetN() ;
-         bFirstTria = false ;
-      }
-      else {
-        // Se spigolo vivo, la curvatura non può esistere
-         if ( Tria.GetN() * vtNFirstTria < m_dCosSmAng - EPS_SMALL)
-            return false ;
-      }
-     // Recupero le direzioni delle semirette per l'angolo al vertice corrente
-      Vector3d vtDir0 = V_NULL, vtDir1 = V_NULL ;
-      for ( int i = 0 ; i < 3 ; ++ i) {
-         if ( AreSamePointApprox( Tria.GetP( i), ptCurr)) {
-            vtDir0 = Tria.GetP( ( i + 1) % 3) - Tria.GetP( i) ;
-            vtDir0.Normalize() ;
-            vtDir1 = Tria.GetP( ( i + 2) % 3) - Tria.GetP( i) ;
-            vtDir1.Normalize() ;
-            break ;
-         }
-      }
-      for ( int i = 0 ; i < 3 ; ++ i) {
-         if ( nV == nIdVert[i]) {
-            setIndTriaNeightbors.insert( nIdVert[( i + 1) % 3]) ;
-            setIndTriaNeightbors.insert( nIdVert[( i + 2) % 3]) ;
-            break ;
-         }
-      }
-     // Calcolo l'angolo sotteso
-      double dCosTheta = max( -1., min( 1., ( vtDir0 * vtDir1))) ;
-      double dTheta = acos( dCosTheta) ;
-     // Calcolo la distanza baricentrica
-      double dSqBarDist = max( EPS_SMALL, ( ptCurr - Tria.GetCentroid()).SqLen()) ;
-     // Aggiorno il contributo della normale al vertice
-      vtNorm += ( ( dTheta / dSqBarDist) * Tria.GetN()) ;
-   }
-   vtNorm.Normalize() ;
-
-  // [ESTIMATING CURVATURE ON TRIANGULAR MESHES, cap. 2.1. Fitting Methods,
-  //  par. 2.1.2. Quadric Fitting]
-  // [https://people.eecs.berkeley.edu/~jrs/meshpapers/GatzkeGrimm.pdf]
-
-  // Definisco il piano tangente al vertice corrente
-   Plane3d plTan ;
-   if ( ! plTan.Set( ptCurr, vtNorm))
-      return false ;
-
-  // Proietto i punti Neightbors(1) sul piano tangete ( senza ripeterli)
-   BIPNTVECTOR vPtPtProj ; vPtPtProj.reserve( setIndTriaNeightbors.size()) ;
-   for ( auto nIter = setIndTriaNeightbors.begin() ; nIter != setIndTriaNeightbors.end() ; ++ nIter) {
-      Point3d ptNeightbors ;
-      if ( ! GetVertex( *nIter, ptNeightbors))
-         return false ;
-      vPtPtProj.emplace_back( make_pair( ptNeightbors, ProjectPointOnPlane( ptNeightbors, plTan))) ;
-   }
-
-  // Recupero due versori perpendicolari nel piano definito
-   Vector3d vtTan1 = V_NULL ;
-   if ( abs( vtNorm.x) < 1./64.  &&  abs( vtNorm.y) < 1./64.)
-      vtTan1 = Y_AX ^ vtNorm ;
-   else
-      vtTan1 = Z_AX ^ vtNorm ;
-   vtTan1.Normalize() ;
-   Vector3d vtTan2 = vtNorm ^ vtTan1 ;
-   vtTan2.Normalize() ;
-
-  // Sistema da risolvere mediante minimi quadrati : z(u,v) = Au^2 + Buv + Cv^2
-  // Questo sistema è molto più semplice e robusto rispetto a z(u,v) = Au^2 + Buv + Cv^2 + Du + Ev + F
-  // per il fatto che ora le coordinate sono in locale al piano tangente alla superficie ( mettendo
-  // quindi a 0 i coefficienti del primo ordine e il termine noto F)
-  // Definizione della matrice A(Nx3)
-   const int nPts = int( vPtPtProj.size()) ;
-   Eigen::MatrixXd mat_A( nPts, 3) ;
-   Eigen::VectorXd vec_b( nPts) ;
-   for ( int i = 0 ; i < nPts ; ++ i) {
-      Vector3d vtEdgeProj = vPtPtProj[i].second - ptCurr ;
-      Vector3d vtEdge = ( vPtPtProj[i].first - vPtPtProj[i].second) ;
-      double dU = vtEdgeProj * vtTan1 ;
-      double dV = vtEdgeProj * vtTan2 ;
-      double dW = vtEdge * vtNorm ;
-      mat_A( i, 0) = dU * dU ;
-      mat_A( i, 1) = dU * dV ;
-      mat_A( i, 2) = dV * dV ;
-      vec_b( i) = dW ;
-   }
-  // Risoluzione del sistema
-   Eigen::VectorXd vec_x = mat_A.colPivHouseholderQr().solve( vec_b) ;
-
-  // Costruzione della matrice hessiana
-   Eigen::Matrix2d mat_H {{ 2. * vec_x( 0), vec_x( 1)},
-                          { vec_x( 1), 2. * vec_x( 2)}} ;
-
-  // Calcolo gli autovalori ( quindi le curvature principali) e restituisco i risultati
-   Eigen::SelfAdjointEigenSolver<Eigen::Matrix2d> Solver( mat_H) ;
-   dMinK = Solver.eigenvalues()( 0) ;
-   dMaxK = Solver.eigenvalues()( 1) ;
-   Eigen::Vector2d dir_Min = Solver.eigenvectors().col( 0) ;
-   Eigen::Vector2d dir_Max = Solver.eigenvectors().col( 1) ;
-   vtMinK = dir_Min( 0) * vtTan1 + dir_Min( 1) * vtTan2 ;
-   vtMaxK = dir_Max( 0) * vtTan1 + dir_Max( 1) * vtTan2 ;
-   bPlanar = ( abs( dMinK) < EPS_SMALL && abs( dMaxK) < EPS_SMALL) ;
-
-   return true ;
-}

SurfTriMeshOffset.cpp

@@ -9,33 +9,13 @@
 // Modifiche : 10.06.25 RE Creazione modulo.
 //             10.06.25 RE Offset di superfici chiuse.
 //             04.07.25 RE Thickening Offset di superfici generiche.
-//             10.12.25 RE Creazione superfici Shell.
 //
 //----------------------------------------------------------------------------
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "VolZmap.h"
-#include "SurfTriMesh.h"
-#include "/EgtDev/Include/EGkDistPointSurfTm.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
-#include "/EgtDev/Include/EGkDistPointTria.h"
-#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
-#include "/EgtDev/Include/EGkStmFromCurves.h"
-#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
-#include <future>
-
-#define DEBUG 0
-#if DEBUG
-   #include "/EgtDev/Include/EGnStringUtils.h"
-   #include "/EgtDev/Include/EGkGeoObjSave.h"
-   #include "/EgtDev/Include/EGkGeoPoint3d.h"
-   #include "/EgtDev/Include/EGkGeoVector3d.h"
-   #include "/EgtDev/Include/EGkStmStandard.h"
-   #include "/EgtDev/Include/EgtPerfCounter.h"
-   std::vector<IGeoObj*> VT ;
-   std::vector<Color> VC ;
-#endif
+#include "\EgtDev\Include\EGkSurfTriMeshAux.h"
 
 using namespace std ;
 
@@ -65,255 +45,6 @@ SumStm( const CISURFTMPVECTOR& vStm)
    return ( Release( pStmAdd)) ;
 }
 
-//----------------------------------------------------------------------------
-// Funzioni per la distanza tra punto e superficie TriMesh in parallelo
-//----------------------------------------------------------------------------
-static bool
-BoundingBoxDifference( const BBox3d& boxA, const BBox3d& boxB, BOXVECTOR& vBoxDiff)
-{
-  // svuoto il risultato
-   vBoxDiff.clear() ;
-  // se box A vuoto, risultato vuoto
-   if ( boxA.IsEmpty())
-      return false ;
-  // se box B vuoto o i box non si intersecano, risultato è ancora A
-   BBox3d boxInt ;
-   if ( boxB.IsSmall()  ||  ! boxA.FindIntersection( boxB, boxInt)) {
-      vBoxDiff.emplace_back( boxA) ;
-      return true ;
-   }
-  // recupero i punti estremi dei box A e Intersezione
-   Point3d ptMinA, ptMaxA ; boxA.GetMinMax( ptMinA, ptMaxA) ;
-   Point3d ptMinInt, ptMaxInt ; boxInt.GetMinMax( ptMinInt, ptMaxInt) ;
-  // sotto
-   if ( ptMinInt.z - ptMinA.z > EPS_SMALL) {
-      BBox3d boxD( ptMinA, Point3d( ptMaxA.x, ptMaxA.y, ptMinInt.z)) ;
-      vBoxDiff.emplace_back( boxD) ;
-   }
-  // sopra
-   if ( ptMaxA.z - ptMaxInt.z > EPS_SMALL) {
-      BBox3d boxD( Point3d( ptMinA.x, ptMinA.y, ptMaxInt.z), ptMaxA) ;
-      vBoxDiff.emplace_back( boxD) ;
-   }
-  // davanti
-   if ( ptMinInt.y - ptMinA.y > EPS_SMALL) {
-      BBox3d boxD( Point3d( ptMinA.x, ptMinA.y, ptMinInt.z), Point3d( ptMaxA.x, ptMinInt.y, ptMaxInt.z)) ;
-      vBoxDiff.emplace_back( boxD) ;
-   }
-  // dietro
-   if ( ptMaxA.y - ptMaxInt.y > EPS_SMALL) {
-      BBox3d boxD( Point3d( ptMinA.x, ptMaxInt.y, ptMinInt.z), Point3d( ptMaxA.x, ptMaxA.y, ptMaxInt.z)) ;
-      vBoxDiff.emplace_back( boxD) ;
-   }
-  // sinistra
-   if ( ptMinInt.x - ptMinA.x > EPS_SMALL) {
-      BBox3d boxD( Point3d( ptMinA.x, ptMinInt.y, ptMinInt.z), Point3d( ptMinInt.x, ptMaxInt.y, ptMaxInt.z)) ;
-      vBoxDiff.emplace_back( boxD) ;
-   }
-  // destra
-   if ( ptMaxA.y - ptMaxInt.y > EPS_SMALL) {
-      BBox3d boxD( Point3d( ptMaxInt.x, ptMinInt.y, ptMinInt.z), Point3d( ptMaxA.x, ptMaxInt.y, ptMaxInt.z)) ;
-      vBoxDiff.emplace_back( boxD) ;
-   }
-  // risultato
-   return ( ! vBoxDiff.empty()) ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-DistPointSurfTmMultiThread( const Point3d& ptP, const SurfTriMesh& SurfTm, double& dDist,
-                            bool& bIsInside, INTVECTOR& vIndClosestTria)
-{
-  // verifico che la supercicie sia valida
-   if ( ! SurfTm.IsValid())
-      return false ;
-
-  // inizializzo distanza non calcolata
-   dDist = - 1. ;
-  // vettore di indici dei triangoli più vicini inizialmente vuoto
-   vIndClosestTria.clear() ;
-  // vettore dei flag temporanei inizialmente tutto a 0
-   INTVECTOR vIntFlags( SurfTm.GetTriangleCount(), 0) ;
-
-  // recupero e verifico il box locale della superficie
-   BBox3d b3Stm = SurfTm.GetAllTriaBox() ;
-   if ( b3Stm.IsEmpty())
-      return false ;
-
-  // cerco triangoli in box centrati sul punto dato di ampiezza crescente ed escludendo le parti già verificate.
-  // termino quando non trovo più triangoli che possano soddisfare la richiesta. 
-   Point3d ptMin, ptMax ; b3Stm.GetMinMax( ptMin, ptMax) ;
-   double dDeltaLen = max( min( min( b3Stm.GetDimX(), b3Stm.GetDimY()), b3Stm.GetDimZ()) / 40., 20.) ;
-   double dBoxHalfLenX = max( max( ptMin.x - ptP.x, ptP.x - ptMax.x), 0.) + dDeltaLen ;
-   double dBoxHalfLenY = max( max( ptMin.y - ptP.y, ptP.y - ptMax.y), 0.) + dDeltaLen ;
-   double dBoxHalfLenZ = max( max( ptMin.z - ptP.z, ptP.z - ptMax.z), 0.) + dDeltaLen ;
-  // considero anche il box precedente per poter analizzare solo il volume differenza tra i due
-   BBox3d boxPPrev( ptP) ;
-   BBox3d boxP( ptP, dBoxHalfLenX, dBoxHalfLenY, dBoxHalfLenZ) ;
-  // variabili distanza minima, indice del triangolo di distanza minima, punto di distanza minima 
-   double dMinDist = DBL_MAX ;
-   int nMinDistTriaIndex = SVT_NULL ;
-   Point3d ptMinDistPoint ;
-  // finché non si verifica la condizione di terminazione ingrandisco il box.
-   bool bContinue = true ;
-
-  // creazione del vettore dei triangoli più vicini a ptP
-   vector<pair<int, Triangle3d>> vTria ; // <indice triangolo, Triangolo>
-   while ( bContinue) {
-     // calcolo il box differenza con il precedente per non esplorare parti già considerate
-      BOXVECTOR vBox ;
-      BoundingBoxDifference( boxP, boxPPrev, vBox) ;
-     // Ciclo sui box differenza
-      bool bCollide = false ;
-      for ( const auto& b3Box : vBox) {
-        // interseco il box con quello della superficie e ne verifico la distanza minima dal punto
-         BBox3d b3Int ;
-         if ( ! b3Box.FindIntersection( b3Stm, b3Int)  ||  b3Int.DistFromPoint( ptP) > dMinDist)
-            continue ;
-        // ricerca sui triangoli nel box
-         bCollide = true ;
-         INTVECTOR vnIds ;
-         if ( SurfTm.GetAllTriaOverlapBox( b3Int, vnIds)) {
-           // ciclo sui triangoli del sotto-box corrente
-            for ( auto nT : vnIds) {
-               Triangle3d trCurTria ;
-               if ( vIntFlags[nT] == 0  &&  SurfTm.GetTriangle( nT, trCurTria)) {
-                  vIntFlags[nT] = 1 ;
-                  DistPointTriangle distPT( ptP, trCurTria) ;
-                  double dCurrDist ;
-                 // se la distanza del triangolo è valida e minore di quella attuale aggiorno
-                  if ( distPT.GetDist( dCurrDist)) {
-                    // se distanze uguali...
-                     if ( abs( dCurrDist - dMinDist) < EPS_SMALL)
-                       // aggiungo il triangolo
-                        vTria.emplace_back( make_pair( nT, trCurTria)) ;
-                    // se minore...
-                     else if ( dCurrDist < dMinDist) {
-                       // pulisco il vettore
-                        vTria.clear() ;
-                        dMinDist = dCurrDist ;
-                        nMinDistTriaIndex = nT ;
-                        distPT.GetMinDistPoint( ptMinDistPoint) ;
-                       // aggiungo il triangolo
-                        vTria.emplace_back( make_pair( nT, trCurTria)) ;
-                     }
-                  }
-               }
-            }
-         }
-      }
-     // se si verifica la condizione di terminazione arresto il ciclo altrimenti aggiorno i box 
-      if ( ! bCollide  ||  dMinDist < EPS_SMALL)
-         bContinue = false ;
-      else {
-         boxPPrev = boxP ;
-         boxP.Expand( dDeltaLen) ;
-      }
-   }
-  // se non ho trovato nessun triangolo, errore
-   if ( nMinDistTriaIndex == SVT_NULL)
-    return false ;
-
-  // riempio il vettore dei triangoli a minima distanza
-   for ( auto& Tria : vTria)
-    vIndClosestTria.emplace_back( Tria.first) ;
-  // salvo la distanza
-   dDist = dMinDist ;
-
-  // determino il Side
-   if ( dDist < EPS_SMALL) {
-      bIsInside = false ;
-      return true ;
-   }
-  // se ho solo un triangolo
-   else if ( int( vTria.size()) == 1) {
-      bIsInside = ( ( ptP - ptMinDistPoint) * vTria.back().second.GetN() < - EPS_SMALL) ;
-      return true ;
-   }
-
-  // controllo se tutti i triangoli a minima distanza forniscono la stessa informazione
-  // ( il punto potrebbe essere esterno a tutti, interno a tutti o indefinito )
-   bool bInside = false ;
-   bool bOutside = false ;
-   for ( int i = 0 ; i < int( vTria.size()) ; ++ i) {
-      if ( ( ptP - vTria[i].second.GetP( 0)) * vTria[i].second.GetN() < - EPS_SMALL)
-         bInside = true ;
-      else
-         bOutside = true ;
-   }
-
-   bIsInside = false ;
-   if ( bOutside == bInside) {
-      Point3d ptBar_tot ;
-      for ( const auto& Tria : vTria)
-         ptBar_tot += Tria.second.GetCentroid() ;
-      for ( const auto& Tria : vTria) {
-         Point3d ptInters1, ptInters2 ;
-         int nType = IntersLineTria( ptP, ptBar_tot, Tria.second, ptInters1, ptInters2) ;
-         if ( nType == ILTT_IN) {
-            DistPointTriangle( ptP, Tria.second).GetMinDistPoint( ptMinDistPoint) ;
-            bIsInside = ( ( ptP - ptMinDistPoint) * Tria.second.GetN() < - EPS_SMALL) ;
-            nMinDistTriaIndex = Tria.first ;
-            break ;
-         }
-      }
-   }
-   else
-      bIsInside = bInside ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-ClassifyTrianglesMultiThread( const TRIA3DEXVECTOR& vTria, int nIndS, int nIndE,
-                              const SurfTriMesh& SurfTm, double dOffs, double dPrec,
-                              bool bSaveInside, BOOLVECTOR& vbSafe)
-{
-  // verifico che la superficie sia valida
-   if ( ! SurfTm.IsValid())
-      return false ;
-  // verifico la validità degli indici
-   if ( nIndS < 0  ||  nIndE >= int( vTria.size()))
-      return false ;
-  // verifico la dimensione dei vettori
-   if ( vTria.size() != vbSafe.size())
-      return false ;
-
-  // scorro gli indici dei triangoli da classificare
-   for ( int k = nIndS ; k <= nIndE ; ++ k) {
-     // recupero il triangolo corrente
-      const Triangle3dEx& Tria = vTria[k] ;
-     // preparo gli elementi di classificazione
-      DBLVECTOR vDists ; vDists.resize( 3) ;
-      INTMATRIX matIndClosestTria ; matIndClosestTria.resize( 3) ;
-     // verifico che i suoi punti siano distanti almeno |dOffs| - dTol dalla superficie
-      vbSafe[k] = true ;
-      for ( int i = 0 ; vbSafe[k] && i < 3 ; ++ i) {
-         bool bIsInside = false ;
-         DistPointSurfTmMultiThread( Tria.GetP( i), SurfTm, vDists[i], bIsInside, matIndClosestTria[i]) ;
-         vbSafe[k] = ( ( vDists[i] > abs( dOffs) - 0.25 * dPrec) &&
-                       ( vDists[i] < abs( dOffs) + 0.25 * dPrec) &&
-                       ( bIsInside == bSaveInside)) ;
-      }
-     // se tutti sufficientemente distanti
-      if ( vbSafe[k]) {
-        // i triangoli a minima distanza devono avere normale simile
-         bool bPerp = true ;
-         for ( int i = 0 ; bPerp && i < 3 ; ++ i) {
-            for ( int j = 0 ; bPerp && j < int( matIndClosestTria[i].size()) ; ++ j) {
-               Triangle3d TriaCloser ;
-               SurfTm.GetTriangle( matIndClosestTria[i][j], TriaCloser) ;
-               bPerp = ( abs( Tria.GetN() * TriaCloser.GetN()) < cos( 30. * DEGTORAD)) ;
-            }
-         }
-         vbSafe[k] = ( ! bPerp) ;
-      }
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 // Funzione che crea l'Offset di una superficie TriMesh
 //----------------------------------------------------------------------------
@@ -342,146 +73,20 @@ CreateSurfTriMeshesOffset( const CISURFTMPVECTOR& vStm, double dOffs, double dPr
    if ( vStm.empty())
       return nullptr ;
   // controllo sul valore di tolleranza lineare
-   double dMyPrec = max( dPrec, 100. * EPS_SMALL) ;
+   double dMyPrec = max( dPrec, 100 * EPS_SMALL) ;
   // --- NB. ( Il valore di Offset deve essere maggiore di 10 * EPS_SMALL in valore assoluto)
   // Nel caso sia minore, restituisco semplicemente la somma delle superfici
   // ( questo valore serve per rimanere coerente con l'Offset delle curve)
-   if ( abs( dOffs) < 10. * EPS_SMALL)
+   if ( abs( dOffs) < 10 * EPS_SMALL)
       return SumStm( vStm) ;
 
   // creo lo Zmap associato alle superfici TriMesh
-   VolZmap myVolZmap ;
-   if ( ! myVolZmap.CreateFromTriMeshOffset( vStm, dOffs, dMyPrec, nType))
-      return nullptr ;
-   if ( ! myVolZmap.IsValid())
+   PtrOwner<IVolZmap> pVolZmap( CreateVolZmap()) ;
+   if ( IsNull( pVolZmap)  ||  ! pVolZmap->CreateFromTriMeshOffset( vStm, dOffs, dMyPrec, nType))
       return nullptr ;
 
-  // recupero le superfici aperte
-   CISURFTMPVECTOR vStmOpen ;
-   for ( const ISurfTriMesh* pStm : vStm) {
-      if ( pStm != nullptr  &&  pStm->IsValid()  &&  ! pStm->IsClosed())
-         vStmOpen.emplace_back( pStm) ;
-   }
-
-  // --- se non ho superfici aperte
-   if ( vStmOpen.empty()) {
-     // restituisco la superficie TriMesh di Offset
-      return ( myVolZmap.GetSurfTriMesh()) ;
-   }
-
-  // --- se ho delle superfici chiuse
-   TRIA3DEXVECTOR vAllTria, vTriaOffs ;
-   for ( int nB = 0 ; nB < myVolZmap.GetBlockCount() ; ++ nB) {
-      TRIA3DEXVECTOR vTria, vTriaSafe ;
-      myVolZmap.GetBlockTriangles( nB, vTria) ;
-      #if DEBUG
-         TRIA3DVECTOR vTriaUnsafe ;
-      #endif
-      for ( int nT = 0 ; nT < int( vTria.size()) ; ++ nT) {
-         Triangle3dEx& Tria = vTria[nT] ;
-         BBox3d BBoxTria ;
-         Tria.GetLocalBBox( BBoxTria) ;
-        // azzero flag di colore
-         vAllTria.push_back( Tria) ;
-      }
-   }
-  // classifico i triangoli
-   PtrOwner<const SurfTriMesh> pStmBasic( nullptr) ;
-   if ( int( vStmOpen.size() == 1))
-      pStmBasic.Set( GetBasicSurfTriMesh( CloneSurfTriMesh( vStmOpen[0]))) ;
-   else {
-      StmFromTriangleSoup AllOpenStmSoup ; AllOpenStmSoup.Start() ;
-      for ( const ISurfTriMesh* pStmOpen : vStmOpen) {
-         if ( pStmOpen != nullptr  &&  pStmOpen->IsValid()) {
-            for ( int nT = 0 ; nT < pStmOpen->GetTriangleCount() ; ++ nT) {
-               Triangle3d Tria ;
-               if ( pStmOpen->GetTriangle( nT, Tria))
-                  AllOpenStmSoup.AddTriangle( Tria) ;
-            }
-         }
-      }
-      AllOpenStmSoup.End() ;
-      pStmBasic.Set( GetBasicSurfTriMesh( AllOpenStmSoup.GetSurf())) ;
-   }
-   if ( pStmBasic == nullptr)
-      return nullptr ;
-   BBox3d b3Stm = pStmBasic->GetAllTriaBox() ;
-   if ( b3Stm.IsEmpty())
-      return nullptr ;
-  // numero di triangoli da analizzare
-   int nTriaCnt = int( vAllTria.size()) ;
-  // definisco un vettore di Flag per i triangoli già visitati
-   INTVECTOR vIntFlags( pStmBasic->GetTriangleCount()) ;
-  // numero massimo di thread concorrenti
-   int nThreadMax = thread::hardware_concurrency() ;
-   bool bOk = true ;
-   BOOLVECTOR vbSafeTria( vAllTria.size(), true) ;
-   if ( nThreadMax <= 1  ||  nTriaCnt < 50)
-      ClassifyTrianglesMultiThread( vAllTria, 0, nTriaCnt - 1, *pStmBasic, abs( dOffs), dPrec, ( dOffs < 0.), vbSafeTria) ;
-   else {
-      const int MAX_PARTS = 32 ;
-      INTINTVECTOR vFstLst( MAX_PARTS) ;
-     // calcolo le parti del vettore
-      int nPartCnt = min( nThreadMax, MAX_PARTS) ;
-      int nPartDim = nTriaCnt / nPartCnt + 1 ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i) {
-         vFstLst[i].first = i * nPartDim ;
-         vFstLst[i].second = min( ( i + 1) * nPartDim, nTriaCnt) - 1 ;
-      }
-     // processo le parti
-      future<bool> vRes[MAX_PARTS] ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i) {
-         vRes[i] = async( launch::async, &ClassifyTrianglesMultiThread, cref( vAllTria), vFstLst[i].first,
-                          vFstLst[i].second, cref( *pStmBasic), abs( dOffs), dPrec, ( dOffs < 0.), ref( vbSafeTria)) ;
-      }
-     // attendo i risultati
-      int nFin = 0 ;
-      while ( nFin < nPartCnt) {
-         for ( int i = 0 ; i < nPartCnt ; ++ i) {
-            if ( vRes[i].valid()  &&  vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
-               bOk = vRes[i].get() && bOk ;
-               ++ nFin ;
-            }
-         }
-      }
-   }
-   if ( ! bOk)
-      return nullptr ;
-   TRIA3DEXVECTOR vTriaSafe ; vTriaSafe.reserve( vAllTria.size()) ;
-   #if DEBUG
-      TRIA3DEXVECTOR vTriaUnSafe ; vTriaUnSafe.reserve( vAllTria.size()) ;
-   #endif
-   for ( int i = 0 ; i < int( vAllTria.size()) ; ++ i) {
-      if ( vbSafeTria[i])
-         vTriaSafe.emplace_back( vAllTria[i]) ;
-      #if DEBUG
-         if ( ! vbSafeTria[i])
-            vTriaUnSafe.emplace_back( vAllTria[i]) ;
-      #endif
-   }
-
-  // definisco la superficie con i soli triangoli validi
-   StmFromTriangleSoup TriaSoup ; TriaSoup.Start() ;
-   for ( const Triangle3d& SafeTria : vTriaSafe)
-      TriaSoup.AddTriangle( SafeTria) ;
-   TriaSoup.End() ;
-   PtrOwner<ISurfTriMesh> pStmOffs( TriaSoup.GetSurf()) ;
-   if ( IsNull( pStmOffs)  ||  ! pStmOffs->IsValid()  ||  pStmOffs->GetTriangleCount() == 0)
-      return nullptr ;
-
-   #if DEBUG
-      StmFromTriangleSoup _invalidSoup ; _invalidSoup.Start() ;
-      for ( const Triangle3d& _unsafeTria : vTriaUnSafe)
-         _invalidSoup.AddTriangle( _unsafeTria) ;
-      _invalidSoup.End() ;
-      VT.emplace_back( pStmOffs->Clone()) ;
-      VC.emplace_back( LIME) ;
-      VT.emplace_back( _invalidSoup.GetSurf()) ;
-      VC.emplace_back( RED) ;
-      SaveGeoObj( VT, VC, "C:\\Temp\\TriangleSelection.nge") ;
-   #endif
-
-   return ( Release( pStmOffs)) ;
+  // restituisco la superficie TriMesh
+   return ( pVolZmap->GetSurfTriMesh()) ;
 }
 
 //----------------------------------------------------------------------------
@@ -502,290 +107,10 @@ CreateSurfTriMeshesThickeningOffset( const CISURFTMPVECTOR& vStm, double dOffs,
       return SumStm( vStm) ;
 
   // creo lo Zmap associato alle superfici TriMesh
-   VolZmap OneVolZmap ;
-   if ( ! OneVolZmap.CreateFromTriMeshThickeningOffset( vStm, dOffs, dMyPrec, nType))
-      return nullptr ;
-   if ( ! OneVolZmap.IsValid())
+   PtrOwner<IVolZmap> pVolZmap( CreateVolZmap()) ;
+   if ( IsNull( pVolZmap)  ||  ! pVolZmap->CreateFromTriMeshThickeningOffset( vStm, dOffs, dMyPrec, nType))
       return nullptr ;
 
   // restituisco la superficie TriMesh
-   return ( OneVolZmap.GetSurfTriMesh()) ;
-}
-
-//----------------------------------------------------------------------------
-// Funzione per creare la Superficie TriMesh Shell da una Trimesh aperta
-//----------------------------------------------------------------------------
-ISurfTriMesh*
-CreateSurfTriMeshShell( const ISurfTriMesh* pStm, double dThick, double dPrec)
-{
-  // verifico che la superficie sia valida ed aperta
-   if ( pStm == nullptr  ||  ! pStm->IsValid()  ||  pStm->IsClosed())
-      return nullptr ;
-  // lo spessore deve essere sempre positivo, il verso è sempre dato dalla normale dei triangoli
-   dThick = - max( 10. * EPS_SMALL, abs( dThick)) ;
-
-  // creo il suo Offset ( salvandomi lo Zmap per l'orientamento)
-   #if DEBUG
-      PerformanceCounter PC ; PC.Start() ;
-   #endif
-   VolZmap myVolZMap ;
-   if ( ! myVolZMap.CreateFromTriMeshOffset( { pStm}, dThick, dPrec))
-      return nullptr ;
-   if ( ! myVolZMap.IsValid())
-      return nullptr ;
-   #if DEBUG
-      LOG_INFO( GetEGkLogger(), ( string{ "Tria Time : "} + ToString( PC.Stop())).c_str()) ;
-      VT.clear() ; VC.clear() ;
-      VT.emplace_back( myVolZMap.Clone()) ;
-      VC.emplace_back( BLACK) ;
-      VT.emplace_back( pStm->Clone()) ;
-      VC.emplace_back( YELLOW) ;
-      SaveGeoObj( VT, VC, "C:\\Temp\\VolZMapOffs.nge") ;
-   #endif
-
-   #if DEBUG
-      VT.clear() ; VC.clear() ;
-      PC.Start() ;
-   #endif
-
-  // recupero i triangoli dallo ZMap creato
-   TRIA3DEXVECTOR vAllTria, vTriaOffs ;
-   for ( int nB = 0 ; nB < myVolZMap.GetBlockCount() ; ++ nB) {
-      TRIA3DEXVECTOR vTria, vTriaSafe ;
-      myVolZMap.GetBlockTriangles( nB, vTria) ;
-      #if DEBUG
-         TRIA3DVECTOR vTriaUnsafe ;
-      #endif
-      for ( int nT = 0 ; nT < int( vTria.size()) ; ++ nT) {
-         Triangle3dEx& Tria = vTria[nT] ;
-         BBox3d BBoxTria ;
-         Tria.GetLocalBBox( BBoxTria) ;
-        // azzero flag di colore
-         vAllTria.push_back( Tria) ;
-      }
-   }
-  // classifico i triangoli
-   const SurfTriMesh* pStmBasic = GetBasicSurfTriMesh( pStm) ;
-   if ( pStmBasic == nullptr)
-      return nullptr ;
-   BBox3d b3Stm = pStmBasic->GetAllTriaBox() ;
-   if ( b3Stm.IsEmpty())
-      return nullptr ;
-  // numero di triangoli da analizzare
-   int nTriaCnt = int( vAllTria.size()) ;
-  // definisco un vettore di Flag per i triangoli già visitati
-   INTVECTOR vIntFlags( pStmBasic->GetTriangleCount()) ;
-  // numero massimo di thread concorrenti
-   int nThreadMax = thread::hardware_concurrency() ;
-   bool bOk = true ;
-   BOOLVECTOR vbSafeTria( vAllTria.size(), true) ;
-   if ( nThreadMax <= 1  ||  nTriaCnt < 50)
-      ClassifyTrianglesMultiThread( vAllTria, 0, nTriaCnt - 1, *pStmBasic, dThick, dPrec, true, vbSafeTria) ;
-   else {
-      const int MAX_PARTS = 32 ;
-      INTINTVECTOR vFstLst( MAX_PARTS) ;
-     // calcolo le parti del vettore
-      int nPartCnt = min( nThreadMax, MAX_PARTS) ;
-      int nPartDim = nTriaCnt / nPartCnt + 1 ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i) {
-         vFstLst[i].first = i * nPartDim ;
-         vFstLst[i].second = min( ( i + 1) * nPartDim, nTriaCnt) - 1 ;
-      }
-     // processo le parti
-      future<bool> vRes[MAX_PARTS] ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i) {
-         vRes[i] = async( launch::async, &ClassifyTrianglesMultiThread, cref( vAllTria), vFstLst[i].first,
-                          vFstLst[i].second, cref( *pStmBasic), dThick, dPrec, true, ref( vbSafeTria)) ;
-      }
-     // attendo i risultati
-      int nFin = 0 ;
-      while ( nFin < nPartCnt) {
-         for ( int i = 0 ; i < nPartCnt ; ++ i) {
-            if ( vRes[i].valid()  &&  vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
-               bOk = vRes[i].get() && bOk ;
-               ++ nFin ;
-            }
-         }
-      }
-   }
-   if ( ! bOk)
-      return nullptr ;
-   TRIA3DEXVECTOR vTriaSafe ; vTriaSafe.reserve( vAllTria.size()) ;
-   #if DEBUG
-      TRIA3DEXVECTOR vTriaUnSafe ; vTriaUnSafe.reserve( vAllTria.size()) ;
-   #endif
-   for ( int i = 0 ; i < int( vAllTria.size()) ; ++ i) {
-      if ( vbSafeTria[i])
-         vTriaSafe.emplace_back( vAllTria[i]) ;
-      #if DEBUG
-         if ( ! vbSafeTria[i])
-            vTriaUnSafe.emplace_back( vAllTria[i]) ;
-      #endif
-   }
-
-  // definisco la superficie con i soli triangoli validi
-   StmFromTriangleSoup TriaSoup ; TriaSoup.Start() ;
-   for ( const Triangle3d& SafeTria : vTriaSafe)
-      TriaSoup.AddTriangle( SafeTria) ;
-   TriaSoup.End() ;
-   PtrOwner<ISurfTriMesh> pStmOffs( TriaSoup.GetSurf()) ;
-   if ( IsNull( pStmOffs)  ||  ! pStmOffs->IsValid()  ||  pStmOffs->GetTriangleCount() == 0)
-      return nullptr ;
-
-   #if DEBUG
-      LOG_INFO( GetEGkLogger(), ( string{ "Tria Time ( exceed Approx) : "} + ToString( PC.Stop())).c_str()) ;
-      StmFromTriangleSoup _invalidSoup ; _invalidSoup.Start() ;
-      for ( const Triangle3d& _unsafeTria : vTriaUnSafe)
-         _invalidSoup.AddTriangle( _unsafeTria) ;
-      _invalidSoup.End() ;
-      VT.emplace_back( pStmOffs->Clone()) ;
-      VC.emplace_back( LIME) ;
-      VT.emplace_back( _invalidSoup.GetSurf()) ;
-      VC.emplace_back( RED) ;
-      SaveGeoObj( VT, VC, "C:\\Temp\\TriangleSelection.nge") ;
-      VT.clear() ; VC.clear() ;
-      PC.Start() ;
-   #endif
-
-  // recupero i loops della superficie originaria e del suo Offset orientato ( non devono essere diminuiti)
-   POLYLINEVECTOR vPL, vPLOffs ;
-   if ( ! pStm->GetLoops( vPL)  ||  ! pStmOffs->GetLoops( vPLOffs))
-      return nullptr ;
-
-  // trasformo ogni loop in curve composite ( devono essere chiuse)
-   ICRVCOMPOPOVECTOR vCompoLoops ; vCompoLoops.reserve( vPL.size()) ;
-   for ( const PolyLine& PL : vPL) {
-      if ( PL.IsClosed()) {
-         if ( ! vCompoLoops.emplace_back( CreateCurveComposite())  ||
-              ! vCompoLoops.back()->FromPolyLine( PL)  ||
-              ! vCompoLoops.back()->IsValid())
-            return nullptr ;
-      }
-   }
-   ICRVCOMPOPOVECTOR vCompoOffsLoops ; vCompoOffsLoops.reserve( vPLOffs.size()) ;
-   for ( const PolyLine& PLOffs : vPLOffs) {
-      if ( PLOffs.IsClosed()) {
-         if ( ! vCompoOffsLoops.emplace_back( CreateCurveComposite())  ||
-              ! vCompoOffsLoops.back()->FromPolyLine( PLOffs)  ||
-              ! vCompoOffsLoops.back()->IsValid())
-            return nullptr ;
-      }
-   }
-
-   #if DEBUG
-      VT.emplace_back( pStmOffs->Clone()) ;
-      VC.emplace_back( YELLOW) ;
-      for ( ICurveComposite* pCompo : vCompoLoops) {
-         VT.emplace_back( pCompo->Clone()) ;
-         VC.emplace_back( AQUA) ;
-      }
-      for ( ICurveComposite* pCompoOffs : vCompoOffsLoops) {
-         VT.emplace_back( pCompoOffs->Clone()) ;
-         VC.emplace_back( ORANGE) ;
-      }
-      SaveGeoObj( VT, VC, "C:\\Temp\\myCurve.nge") ;
-      VT.clear() ; VC.clear() ;
-   #endif
-
-  // per ogni curva della superficie originale cerco la sua associata
-  // NB. per la creazione della superficie ruled la prima curva è quellla che determina il verso
-  //     dei triangoli associati. Per un corretto ed automatico orientamento della superficie
-  //     la prima curva deve essere sempre definita dalla superficie originale ed invertita ( le
-  //     curve nella rigata devono seguire lo stesso orientamento
-   ISURFTMPOVECTOR vStmRuled ; vStmRuled.reserve( vCompoLoops.size()) ;
-   BOOLVECTOR vIndMatched( vCompoOffsLoops.size(), false) ;
-   for ( ICurveComposite* pCompoLoop : vCompoLoops) {
-     // sposto il punto iniziale della curva nel tratto più lungo
-      double dMaxLen = - INFINITO ;
-      int nIndCrv = 0 ;
-      for ( int nCrv = 0 ; nCrv < pCompoLoop->GetCurveCount() ; ++ nCrv) {
-         const ICurve* pCurve = pCompoLoop->GetCurve( nCrv) ;
-         if ( pCurve != nullptr  &&  pCurve->IsValid()) {
-            double dCurrLen = 0. ;
-            pCurve->GetLength( dCurrLen) ;
-            if ( dCurrLen > dMaxLen) {
-               dMaxLen = dCurrLen ;
-               nIndCrv = nCrv ;
-            }
-         }
-      }
-      pCompoLoop->ChangeStartPoint( nIndCrv + 0.5) ;
-      Point3d ptStart ; pCompoLoop->GetStartPoint( ptStart) ;
-     // dalle altre curve derivanti dalla superficie di Offset cerco quella più vicina al punto inziale
-      double dMinSqDist = INFINITO ;
-      int nIndOffsCrv = -1 ;
-      Point3d ptMinDist ;
-      for ( int nOffsCrv = 0 ; nOffsCrv < int( vCompoOffsLoops.size()) ; ++ nOffsCrv) {
-         if ( vIndMatched[nOffsCrv])
-            continue ;
-        // recupero la curva e calcolo la distanza
-         const ICurveComposite* pCompoOffsLoop = vCompoOffsLoops[nOffsCrv] ;
-         int nFlag = 0 ;
-         Point3d ptCurrMinDist ;
-         if ( DistPointCurve( ptStart, *pCompoOffsLoop).GetMinDistPoint( 0., ptCurrMinDist, nFlag)) {
-            double dCurrSqDist = SqDist( ptStart, ptCurrMinDist) ;
-            if ( dCurrSqDist < dMinSqDist) {
-               dMinSqDist = dCurrSqDist ;
-               nIndOffsCrv = nOffsCrv ;
-               ptMinDist = ptCurrMinDist ;
-            }
-         }
-      }
-      if ( nIndOffsCrv == -1)
-         return nullptr ;
-      vIndMatched[ nIndOffsCrv] = true ;
-     // associo le due curve
-      ICurveComposite* pCompoOffsLoop = vCompoOffsLoops[nIndOffsCrv] ;
-      double dParMinDist = 0. ;
-      pCompoOffsLoop->GetParamAtPoint( ptMinDist, dParMinDist, 10. * EPS_SMALL) ;
-      pCompoOffsLoop->ChangeStartPoint( dParMinDist) ;
-
-      #if DEBUG
-         Color _cCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
-         VT.emplace_back( pCompoLoop->Clone()) ;
-         VC.emplace_back( _cCol) ;
-         VT.emplace_back( pCompoOffsLoop->Clone()) ;
-         VC.emplace_back( _cCol) ;
-      #endif
-
-     // creo la superficie tra queste due curve e la oriento in modo da definire un volume
-      pCompoLoop->Invert() ;
-      PtrOwner<ISurfTriMesh> pStmRuled( GetSurfTriMeshRuled( pCompoLoop, pCompoOffsLoop, ISurfTriMesh::RuledType::RLT_MINDIST)) ;
-      if ( IsNull( pStmRuled)  ||  ! pStmRuled->IsValid()  ||
-           ! vStmRuled.emplace_back( Release( pStmRuled)))
-         return nullptr ;
-
-      #if DEBUG
-         LOG_INFO( GetEGkLogger(), ( string{ "Strip generation : "} + ToString( PC.Stop())).c_str()) ;
-         VT.emplace_back( vStmRuled.back()->Clone()) ;
-         VC.emplace_back( _cCol) ;
-         _cCol.SetAlpha( .5) ;
-      #endif
-   }
-
-   #if DEBUG
-      SaveGeoObj( VT, VC, "C:\\Temp\\Strips.nge") ;
-      PC.Start() ;
-   #endif
-
-  // compongo la superficie finale
-   PtrOwner<ISurfTriMesh> pStmOrig( CloneSurfTriMesh( pStm)) ;
-   if ( IsNull( pStmOrig)  ||  ! pStmOrig->IsValid())
-      return nullptr ;
-   PtrOwner<ISurfTriMesh> pStmRef( Release( pStmOrig)) ;
-   if ( IsNull( pStmRef)  ||  ! pStmRef->IsValid())
-      return nullptr ;
-   for ( int nStrip = 0 ; nStrip < int( vStmRuled.size()) ; ++ nStrip) {
-      if ( ! pStmRef->DoSewing( *vStmRuled[nStrip]))
-         return nullptr ;
-   }
-   if ( ! pStmRef->DoSewing( *pStmOffs))
-      return nullptr ;
-   pStmRef->Repair() ;
-
-   #if DEBUG
-      LOG_INFO( GetEGkLogger(), ( string{ "Sewing : "} + ToString( PC.Stop())).c_str()) ;
-   #endif
-
-   return ( ( ! IsNull( pStmRef)  &&  pStmRef->IsValid()) ? Release( pStmRef) : nullptr) ;
+   return ( pVolZmap->GetSurfTriMesh()) ;
 }

Tree.h

@@ -28,7 +28,7 @@ struct PairHashInt64 {
       size_t h2 = std::hash<int64_t>{}(key.second) ;
       return h1 ^ (h2 << 1);  // Combine hashes
    }
-} ;
+};
 
 //----------------------------------------------------------------------------
 struct Inters {
@@ -42,13 +42,13 @@ struct Inters {
    // se ho più intersezioni che entrano in un lato le riordino considerando che percorro i lati in senso antiorario a partire da ptTR
    bool operator < ( Inters& b)
    {
-     // trovo in che ordine stanno i due start, tenendo conto anche della possibilità che siano vertici
+      // trovo in che ordine stanno i due start, tenendo conto anche della possibilità che siano vertici
       INTVECTOR vEdges = { 7, 0, 4, 1, 5, 2, 6, 3} ;
       const auto iter1 = find( vEdges.begin(), vEdges.end(), nIn) ;
       int nPos1 = std::distance( vEdges.begin(), iter1) ;
       const auto iter2 = find( vEdges.begin(), vEdges.end(), b.nIn) ;
       int nPos2 = std::distance( vEdges.begin(), iter2) ;
-     // se sono loop interni li ordino in modo decrescente rispetto all'area
+      // se sono loop interni li ordino in modo decrescente rispetto all'area
       bool bEqIn = ( nIn == b.nIn) ;
       double dAreaA = 0 , dAreaB = 0 ;
       if ( bEqIn  &&  nIn == -1) {
@@ -63,7 +63,7 @@ struct Inters {
          pl.Close() ;
          pl.GetAreaXY( dAreaB) ;
       }
-     // se nIn è un vertice sistemo il valore
+      // se nIn è un vertice sistemo il valore
       int nEdgeIn = nIn ;
       if ( nIn > 3)
          nEdgeIn = nIn - 4 ;
@@ -75,13 +75,13 @@ struct Inters {
                ( bEqIn  &&  nEdgeIn == 3  &&  vpt[0].y < b.vpt[0].y)) ;
    }
 
-   static bool FirstEncounter( Inters& a, Inters& b)
+   static bool FirstEncounter ( Inters& a, Inters& b)
    {
-     // riordino in base al lato toccato, o dall'uscita o  dall'ingresso, che viene prima.
-     // ottengo l'ordine che avrei percorrendo il bordo da ptTR e considerando i loop che incontro, indipendentemente se li incontro nel punto di uscita o ingresso
-     // nell'intersezione salvo se il taglio è stato ordinato guardando l'ingresso o l'uscita
+      // riordino in base al lato toccato, o dall'uscita o  dall'ingresso, che viene prima.
+      // ottengo l'ordine che avrei percorrendo il bordo da ptTR e considerando i loop che incontro, indipendentemente se li incontro nel punto di uscita o ingresso
+      // nell'intersezione salvo se il taglio è stato ordinato guardando l'ingresso o l'uscita
       INTVECTOR vEdges = { 7, 0, 4, 1, 5, 2, 6, 3} ;
-     // trovo i lati di ingresso e uscita
+      // trovo i lati di ingresso e uscita
       const auto iter1 = find( vEdges.begin(), vEdges.end(), a.nIn) ;
       int nPos1 = std::distance( vEdges.begin(), iter1) ;
       const auto iter2 = find( vEdges.begin(), vEdges.end(), a.nOut) ;
@@ -92,13 +92,13 @@ struct Inters {
       int nPos4 = std::distance( vEdges.begin(), iter4) ;
       int nFirstA = 0 ;
       int nFirstB = 0 ;
-     // salvo l'indice del primo punto dell'intersezione che ho incontrato scorrendo il bordo da ptTR
-     // salvo il lato che viene prima confrontando ingresso e uscita
+      // salvo l'indice del primo punto dell'intersezione che ho incontrato scorrendo il bordo da ptTR
+      // salvo il lato che viene prima confrontando ingresso e uscita
       if ( nPos2 < nPos1) {
          nPos1 = nPos2 ;
          nFirstA = int( a.vpt.size()) - 1 ;
       }
-     // se ingresso e uscita sono sullo stesso lato allora confronto le coordinate per capire se viene prima l'ingresso o l'uscita
+      // se ingresso e uscita sono sullo stesso lato allora confronto le coordinate per capire se viene prima l'ingresso o l'uscita
       else if ( nPos2 == nPos1 ) {
          if ( nPos1 == 0 )
             nFirstA = a.vpt[0].x > a.vpt.back().x ? 0 : ( int( a.vpt.size()) - 1) ;
@@ -125,11 +125,11 @@ struct Inters {
       }
       a.bSortedbyStart = nFirstA == 0 ;
       b.bSortedbyStart = nFirstB == 0 ;
-     // se sono diversi ritorno il confronto
+      // se sono diversi ritorno il confronto
       if ( nPos1 != nPos3)
          return nPos1 < nPos3 ;
-     // se sono uguali devo valutare il punto di intersezione
-      return ( nPos1 == 0  &&  a.vpt[nFirstA].x > b.vpt[nFirstB].x)  ||
+      // se sono uguali devo valutare il punto di intersezione
+       return ( nPos1 == 0  &&  a.vpt[nFirstA].x > b.vpt[nFirstB].x)  ||
               ( nPos1 == 1  &&  a.vpt[nFirstA].y > b.vpt[nFirstB].y)  ||
               ( nPos1 == 2  &&  a.vpt[nFirstA].x < b.vpt[nFirstB].x)  ||
               ( nPos1 == 3  &&  a.vpt[nFirstA].y < b.vpt[nFirstB].y) ;
@@ -160,24 +160,20 @@ class Cell
    //                 |                 |
    //                 |_________________|
    //   Edge 5 ( SW)     Edge 2 (Bottom)     Edge 6 ( SE)
-   public:
-   enum Collapsed { TO_VERIFY = -1,        // da verificare
-                    NO_COLLAPSE = 0,       // non ho coppie di lati collassati
-                    VERT_EDGES = 1,        // coppia di lati verticali(1-3) sono collassati
-                    HORIZ_EDGES  = 2} ;    // coppia di lati verticali(0-2) sono collassati
-
    public :
       ~Cell( void) {}
       Cell( void)
-         : m_nId( -1), m_nTop( -2), m_nBottom( -2), m_nLeft( -2), m_nRight( -2), m_nParent( -2), m_nDepth( 0),
-           m_dSplit( 0), m_nChild1( -2), m_nChild2( -2), m_nFlag( -1), m_bLabelled( false), m_nRightEdgeIn( -1),
-           m_bOnLeftEdge( false), m_bOnTopEdge( false), m_nVertToErase( -1), m_nCollapsed( -1), m_ptPbl( ORIG),
-           m_ptPtr( SBZ_TREG_COEFF, SBZ_TREG_COEFF, 0), m_bProcessed( false), m_bSplitVert( true) {}
+         : m_nId( -1),m_nTop ( -2), m_nBottom( -2), m_nLeft( -2), m_nRight ( -2), m_nParent( -2), m_nDepth( 0),
+           m_nChild1( -2), m_nChild2( -2), m_nFlag( -1), m_bLabelled( false), m_nRightEdgeIn( -1), m_bOnLeftEdge( false), m_bOnTopEdge( false), m_nVertToErase( -1),
+           m_ptPbl( ORIG), m_ptPtr( SBZ_TREG_COEFF, SBZ_TREG_COEFF, 0), m_bProcessed( false), m_bSplitVert( true)
+         {
+            Point3d ptTr ( 1 * SBZ_TREG_COEFF, 1 * SBZ_TREG_COEFF) ;
+            m_ptPtr = ptTr ;
+         }
       Cell( const Point3d& ptBL, const Point3d& ptTR) 
-         : m_nId( -1), m_nTop( -2), m_nBottom( -2), m_nLeft( -2), m_nRight( -2), m_nParent( -2), m_nDepth( 0),
-           m_dSplit( 0), m_nChild1( -2), m_nChild2( -2), m_nFlag( -1), m_bLabelled( 0), m_nRightEdgeIn( -1),
-           m_bOnLeftEdge( false), m_bOnTopEdge( false), m_nVertToErase( -1), m_nCollapsed( -1), m_ptPbl( ptBL),
-           m_ptPtr( ptTR), m_bProcessed( false), m_bSplitVert( true) {}
+         : m_nId( -1),m_nTop ( -2), m_nBottom( -2), m_nLeft( -2), m_nRight ( -2), m_nParent( -2), m_nDepth( 0),
+           m_nChild1( -2), m_nChild2( -2), m_nFlag( -1), m_bLabelled( 0), m_nRightEdgeIn( -1), m_bOnLeftEdge( false), m_bOnTopEdge( false), m_nVertToErase( -1),
+           m_ptPbl( ptBL), m_ptPtr( ptTR), m_bProcessed( false), m_bSplitVert( true) {}
       bool IsSame( const Cell& cOtherCell) const
               { return ( m_nId == cOtherCell.m_nId) ; }
       void SetBottomLeft( const Point3d& ptBL)
@@ -196,11 +192,9 @@ class Cell
               { return Point3d( m_ptPbl.x, m_ptPtr.y) ; }
       Point3d GetBottomRight( void) const
               { return Point3d( m_ptPtr.x, m_ptPbl.y); }
-      Point3d GetCenter( void) const
-              { return ( m_ptPbl + m_ptPtr) / 2 ; }
       double GetSplitValue( void) const
               { return m_dSplit ; }
-      bool IsSplitVert( void) const                 // se true la cella verrebbe splittata verticalmente, altrimenti orizzontalmente
+      bool IsSplitVert( void) const                 // se true la cella verrebbe splittata verticalmente, sennò orizzontalmente
               { return m_bSplitVert ; }
       bool IsLeaf( void) const                      // flag che indica se la cella ha figli o se è una foglia
               { return ( m_nChild1 == -2  &&  m_nChild2 == -2) ; }
@@ -237,7 +231,6 @@ class Cell
       int                  m_nVertToErase ;     // vertice da eliminare dal poligono della cella, in caso di lato sovrapposto ad un lato di polo
                                                 // contati in senso CCW a partire dal bottom left
       INTVECTOR            m_vnPolyId ;         // indici dei poligoni associati a questa cella nel vettore m_vPolygons del Tree
-      int                  m_nCollapsed ;       // flag che indica se la coppia di lati verticali (1) o orizzontali(2) sono collassati
 
    private :
       Point3d          m_ptPbl ;            // punto bottom left
@@ -252,43 +245,41 @@ class Tree
    public :
       ~Tree( void) ;
       Tree( void) ;
-      Tree( const Point3d ptBl, const Point3d ptTr) ;    // da usare solo nel caso in cui si voglia aggiungere tagli ad un'unica cella e del risultato ottenere il contorno 
-      bool SetSurf( const SurfBezier* pSrfBz, const Point3d& ptMin = ORIG, const Point3d& ptMax = ORIG) ;
-      bool GetIndependentTrees( BIPNTVECTOR& vTrees) ;       // calcolo la suddivisione della superficie solo sulle singole bbox dei loop di trim ( unendo quelli vicini)
-      bool BuildTree( double dLinTol = LIN_TOL_STD,
-                      double dSideMin = 1,                   // è la minima lunghezza del lato di una cella
-                      double dSideMax = INFINITO) ;          // è la massima dimensione di un triangolo della trimesh
-      bool GetPolygons( POLYLINEMATRIX& vvPolygons, POLYLINEMATRIX& vvPolygons3d, std::vector<ICRVCOMPOPOVECTOR>& vCCEdges3D, ICRVCOMPOPOVECTOR& vCCLoops, bool bUpdateEdges) ;
+      //Tree ( const SurfBezier* pSrfBz, bool bSplitPatches = true, const Point3d& ptMin = ORIG, const Point3d& ptMax = ORIG) ;
+      Tree( const Point3d ptBl, const Point3d ptTr) ; // creatore da usare solo nel caso in cui si voglia aggiungere tagli ad un'unica cella e del risultato ottenere il contorno 
+      bool SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches = true, const Point3d& ptMin = ORIG, const Point3d& ptMax = ORIG) ;
+      bool GetIndependentTrees( BIPNTVECTOR& vTrees) ;                             // calcolo la suddivisione della superficie solo sulle singole bbox dei loop di trim ( unendo quelli vicini)
+      bool BuildTree( double dLinTol = LIN_TOL_STD, double dSideMin = 1, double dSideMax = INFINITO) ; // dSideMax è il massimo per la dimensione maggiore di un triangolo della trimesh
+                                                                                                       // dSideMin è lunghezza minima del lato di una cella nello spazio reale
+      bool BuildTree_test( double dLinTol = LIN_TOL_STD, double dSideMin = 1, double dSideMax = INFINITO) ;
+      bool GetPolygons( POLYLINEMATRIX& vvPolygons, POLYLINEMATRIX& vvPolygons3d, std::vector<ICRVCOMPOPOVECTOR>& vCCEdges3D, ICRVCOMPOPOVECTOR& vCCLoops) ;
       bool GetPolygonsBasic( POLYLINEVECTOR& vPolygons, POLYLINEVECTOR& vPolygonsCorrected, POLYLINEVECTOR& vPolygons3d) ; // restituisce il poligono corrispondente ad ogni cella foglia dell'albero
                                                                                                                            // ad ogni poligono sono stati aggiunti tutti i vertici dei vicini posizionati sui suoi lati
                                                                                                                            // ad alcuni poligoni potrebbero venire tolti dei punti per evitare errori dovuti ad eventuali poli sui bordi del parametrico
-      bool GetLeaves( std::vector<Cell>& vLeaves) const ;         // restituisce gli indici delle foglie nell'albero
-      bool GetEdges3D( std::vector<ICRVCOMPOPOVECTOR>& mCCEdge, POLYLINEVECTOR& vPolygons) ;  // restituisce gli edge 3D come polyline
-      bool GetSplitLoops( ICRVCOMPOPOVECTOR& vCCLoopSplit) const  // restituisce i loop splitatti ai confini delle celle
-             { for ( int i = 0 ; i < int( m_vCCLoop2D.size()); ++i)
-                  vCCLoopSplit.emplace_back( m_vCCLoop2D[i]->Clone()) ;
-               return true ; }
+      bool GetLeaves ( std::vector<Cell>& vLeaves) const ;  // restituisce gli indici delle foglie nell'albero
+      bool GetEdges3D ( std::vector<ICRVCOMPOPOVECTOR>& mCCEdge, POLYLINEVECTOR& vPolygons) ;  // restituisce gli edge 3D come polyline
+      bool GetSplitLoops( ICRVCOMPOPOVECTOR& vCCLoopSplit) const // funzione che restituisce i loop splitatti ai confini delle celle
+             { for ( int i = 0 ; i < int( m_vCCLoop2D.size()); ++i) vCCLoopSplit.emplace_back( m_vCCLoop2D[i]->Clone()) ; return true ; };
+      void SetTestMode( void) { m_bTestMode = true ;} ;        // attivando la test mode, per la costruzione dell'albero viene usata la funzione BuiltTree_test e viene corretta di conseguenza la FindCell
       // funzioni da usare per ricostruire tagli che vanno aggiunti allo spazio parametrico
       bool AddCutsToRoot( POLYLINEVECTOR& vCuts) ;          // aggiunge i tagli al tree
       bool CreateCellContour( POLYLINEMATRIX& vPolygons) ;  // crea il nuovo contorno esterno, tenendo conto dei tagli
-      bool IsClosedU( void) const                                 // restituisce flag di chiusara in U
-             { return m_bClosedU ; }
-      bool IsClosedV( void) const                                 // restituisce flag di chiusara in V
-             { return m_bClosedV ; }
-      BOOLVECTOR GetPoles( void)                                  // restituisce i flag che indicano se i lati sono collassati in dei poli
-             { return m_vbPole ; }
+      bool IsClosedU( void) const { return m_bClosedU ;} ;        // funzione che riferisce se la superficie è chiusa lungo il parametro U
+      bool IsClosedV( void) const { return m_bClosedV ;} ;        // funzione che riferisce se la superficie è chiusa lungo il parametro V
+      std::vector<bool> GetPoles( void) { return m_vbPole ;} ; // funzione che restituisce i flag che indicano se i lati sono collassati in dei poli
 
    private :
       bool Split( int nId, double dSplitValue) ;                              // funzione di split di una cella al parametro indicato nella direzione data da bVert
       bool Split( int nId) ;                                                  // funzione di split di una cella dell'albero a metà nella direzione data da bVert
-      int  GetHeightLeaves( int nId, INTVECTOR& vnLeaves, int d = 0) const ;  // altezza del subtree a partire dal nodo nId
-      int  GetDepth( int nId, int nRef) const ;                               // livello del nodo nId
-      void GetTopNeigh( int nId, INTVECTOR& vTopNeighs, DBLDBL ddInt = DBLDBL(0,0)) const ;               // restituisce le celle foglie che sono adiacenti al lato top  ( la coppia di double è per dare un intervallo diverso su cui limitare i vicini)
-      void GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs, DBLDBL ddInt = DBLDBL(0,0)) const ;         // restituisce le celle foglie che sono adiacenti al lato bottom
-      void GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs, DBLDBL ddInt = DBLDBL(0,0)) const ;             // restituisce le celle foglie che sono adiacenti al lato left
-      void GetRightNeigh( int nId, INTVECTOR& vRightNeighs, DBLDBL ddInt = DBLDBL(0,0)) const ;           // restituisce le celle foglie che sono adiacenti al lato right
+      void Balance( void) ;                                                       // creo rami in modo che tutte tutte le foglie abbiano come adiacenti foglie ad una profondità di +- 1
+      int GetHeightLeaves( int nId, INTVECTOR& vnLeaves, int d = 0) const ;  // altezza del subtree a partire dal nodo nId
+      int GetDepth( int nId, int nRef) const ;                               // livello del nodo nId
+      void GetTopNeigh( int nId, INTVECTOR& vTopNeighs) const ;               // restituisce le celle foglie che sono adiacenti al lato top
+      void GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs) const ;         // restituisce le celle foglie che sono adiacenti al lato bottom
+      void GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs) const ;             // restituisce le celle foglie che sono adiacenti al lato left
+      void GetRightNeigh( int nId, INTVECTOR& vRightNeighs) const ;           // restituisce le celle foglie che sono adiacenti al lato right
       void GetRootNeigh( int nEdge, INTVECTOR& vNeigh) ;                      // restituisce le foglie dell'albero che sono adiacenti al lato nEdge, numerato a partire dal top ( 0) in senso antiorario 
-      void ResetTree( void) ;                                                 // resetto m_bProcessed a false per tutti i nodi dell'albero
+      void ResetTree( void) ;                                                // resetto m_bProcessed a false per tutti i nodi dell'albero
       INTVECTOR FindCell( const Point3d& ptToAssign, const CurveLine& cl, bool bRecurs = false) const ;   // dato un punto, trova la cella foglia a cui appartiene
       INTVECTOR FindCell( const Point3d& ptToAssign, const CurveLine& cl, INTVECTOR vCells, bool bRecurs = false) const ;   // dato un punto, trova la cella foglia a cui appartiene
       bool TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons) ;               // tracing dei loop e labelling delle celle
@@ -313,27 +304,31 @@ class Tree
       bool UpdateSplitLoop( ICurveComposite* pCC, Point3d& pt) ;
       bool VerifyLoopOrientation( ICURVEPLIST& vpCrv, BOOLVECTOR& vbOrientation) const ;  // verifico l'orientazione ( CCW o CW) delle polyline in base a come sono contenute le une nelle altre
       bool AdjustLoop( PolyLine& pl, POLYLINEVECTOR& vPl, BOOLVECTOR& vbOrientation) const ;
-      bool GetPoint(double dU, double dV, Point3d& ptP) const ;
-      bool SavePoint( double dU, double dV, const Point3d& ptP) ;
+      bool GetPoint(double dU, double dV, Point3d& pt) const ;
+      bool SavePoint( double dU, double dV, Point3d& pt) ;
+
 
    private :
       const SurfBezier*           m_pSrfBz ;           // superficie di bezier
+      DBLVECTOR                   m_vDim ;             // distanze tra i vertici della superficie di bezier in 3d in ordine antiorario a partire da ptP00
       bool                        m_bTrimmed ;         // superficie trimmata
-      std::unordered_map<int,int>       m_mChunk ;     // mappa in cui vengono salvati chunk di appartenza per ogni loop di trim
-      std::vector<std::tuple<PolyLine,bool>> m_vPlApprox ;  // vettore contenente le approssimazioni dei loop  // il bool indica se la curva è CCW
+      std::unordered_map<int,int>      m_mChunk ;           // mappa in cui vengono salvati chunk di appartenza per ogni loop di trim
+      std::vector<std::tuple<PolyLine,bool>> m_vPlApprox ;       // vettore contenente le approssimazioni dei loop  // il bool indica se la curva è CCW
       bool                        m_bBilinear ;        // superficie bilineare
       bool                        m_bMulti ;           // superficie multi-patch
       bool                        m_bClosedU ;         // superficie chiusa lungo il parametro U
       bool                        m_bClosedV ;         // superficie chiusa lungo il parametro V
       BOOLVECTOR                  m_vbPole ;           // vettore che indica se i vari lati sono collassati in poli ( indici riferiti all'ordine degli edge)
+      bool                        m_bSplitPatches ;    // flag che indica se le patches sono state divise prima della creazione dell'albero
       int                         m_nDegU ;            // grado della superficie nel parametro U
       int                         m_nDegV ;            // grado della superficie nel parametro V
       int                         m_nSpanU ;           // numero di span lungo il parametro U
       int                         m_nSpanV ;           // numero di span lungo il parametro V
-      std::unordered_map<int,Cell>     m_mTree ;       // mappa che contiene tutti i nodi e le foglie dell'albero. -2 è puntatore Null e -1 è root
-      mutable std::unordered_map<std::pair<int64_t,int64_t>,Point3d,PairHashInt64>     m_mPt3d ;    // mappa che contiene tutti i punti 3d della superficie calcolati (la chiave sono le coordinate, moltiplicate per 2^24 e trasformate in int)
+      std::unordered_map<int,Cell>     m_mTree ;            // mappa che contiene tutti i nodi e le foglie dell'albero. -2 è puntatore Null e -1 è root
+      mutable std::unordered_map<std::pair<int64_t, int64_t>,Point3d, PairHashInt64>     m_mPt3d ;    // mappa che contiene tutti i punti 3d della superficie calcolati (la chiave sono le coordinate, moltiplicate per 2^24 e trasformate in int)
       INTVECTOR                   m_vnLeaves ;         // vettore delle foglie
       INTVECTOR                   m_vnParents ;        // vettore delle celle ottenute dalla divisione preliminare in singole patch
+      bool                        m_bTestMode ;        // bool che indica se la test mode è attiva
       ICRVCOMPOPOVECTOR           m_vCCLoop2D ;        // vettore che contiene le CurveCompo che rappresentano i loop di trim tenendo conto della divisione in celle
       std::vector<std::pair<BIPNTVECTOR, ChainCurves>>    m_vCEdge2D ;        // vettore che le chain che rappresentano ciò che resta degli edge originali, tenendo conto dei trim.
 } ;

VolZmap.cpp

@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 //  EgalTech 2015-2016
 //----------------------------------------------------------------------------
 // File : VolZmap.cpp         Data : 22.01.15           Versione : 1.6a4
@@ -133,7 +133,6 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc)
    m_nFracLin[0] = vzmSrc.m_nFracLin[0] ;
    m_nFracLin[1] = vzmSrc.m_nFracLin[1] ;
    m_nFracLin[2] = vzmSrc.m_nFracLin[2] ;
-   m_nDexVoxRatio = vzmSrc.m_nDexVoxRatio ;
    m_nConnectedCompoCount = vzmSrc.m_nConnectedCompoCount ;
    
    m_MapFrame = vzmSrc.m_MapFrame ;
@@ -209,10 +208,6 @@ VolZmap::Dump( string& sOut, bool bMM, const char* szNewLine) const
 {
   // tipo
    sOut += "Type=" + string( m_nMapNum == 1 ? "dexel" : "tridexel") + szNewLine ;
-  // visualizzazione spigoli
-   sOut += "ShowEdges=" + ToString( GetShowEdges()) + szNewLine ;
-  // dexel per voxel (DexToVoxRatio)
-   sOut += "DexVoxRat=" + ToString( m_nDexVoxRatio) + szNewLine ;
   // forma
    switch ( m_nShape) {
    default : sOut += "Shape=generic" ; break ;
@@ -234,6 +229,8 @@ VolZmap::Dump( string& sOut, bool bMM, const char* szNewLine) const
   // numero di blocchi
    sOut += "Blocks=" + ToString( m_nNumBlock) + " (" + ToString( m_nFracLin[0]) + "x" +
            ToString( m_nFracLin[1]) + "x" + ToString( m_nFracLin[2]) + ")" + szNewLine ;
+  // dexel per voxel (DexToVoxRatio)
+   sOut += "DexVoxRat=" + ToString( m_nDexVoxRatio) + szNewLine ;
 
    return true ;
 }
@@ -507,15 +504,11 @@ VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
          }
         // passo al punto successivo
          dX += m_dStep ;
-         if ( m_nMapNum == N_MAPS)
-            dX = min( dX, m_dMaxZ[1]) ;
       }
      // passo alla riga successiva
       dY += m_dStep ;
-      if ( m_nMapNum == N_MAPS)
-         dY = min( dY, m_dMaxZ[2]) ;
    }
-
+//
    return true ;
 }
 
@@ -555,13 +548,9 @@ VolZmap::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
          }
         // passo al punto successivo
          dX += m_dStep ;
-         if ( m_nMapNum == N_MAPS)
-            dX = min( dX, m_dMaxZ[1]) ;
       }
      // passo alla riga successiva
       dY += m_dStep ;
-      if ( m_nMapNum == N_MAPS)
-         dY = min( dY, m_dMaxZ[2]) ;
    }
 
    return true ;
@@ -574,10 +563,10 @@ VolZmap::GetPartLocalBBox( int nPart, BBox3d& b3Loc, int nFlag) const
   // Verifico lo stato.
    if ( m_nStatus != OK)
       return false ;
-  // Se una sola mappa o il numero di componenti è indefinito, vi è un errore.
+  // Se una sola mappa o il numero di componenti è indefinito, vi è un errore.
    if ( m_nMapNum == 1  ||  m_nConnectedCompoCount == - 1)
       return false ;
-  // Se la componente richiesta non esiste, vi è un errore.
+  // Se la componente richiesta non esiste, vi è un errore.
    if ( nPart < 0  ||  nPart > m_nConnectedCompoCount - 1)
       return false ;
   // Calcolo Bounding-box
@@ -625,10 +614,10 @@ VolZmap::GetPartBBox( int nPart, const Frame3d& frRef, BBox3d& b3Ref, int nFlag)
   // Verifico lo stato.
    if ( m_nStatus != OK)
       return false ;
-  // Se una sola mappa o il numero di componenti è indefinito, vi è un errore.
+  // Se una sola mappa o il numero di componenti è indefinito, vi è un errore.
    if  ( m_nMapNum == 1  ||  m_nConnectedCompoCount == - 1)
       return false ;
-  // Se la componente richiesta non esiste, vi è un errore.
+  // Se la componente richiesta non esiste, vi è un errore.
    if ( nPart < 0  ||  nPart > m_nConnectedCompoCount - 1)
       return false ;
   // Calcolo Bounding-box
@@ -700,7 +689,7 @@ VolZmap::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, doub
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dell'asse di rotazione
+  // verifico validità dell'asse di rotazione
    if ( vtAx.IsSmall())
       return false ;
 
@@ -733,7 +722,7 @@ VolZmap::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del piano di specchiatura
+  // verifico validità del piano di specchiatura
    if ( vtNorm.IsSmall())
       return false ;
 
@@ -747,7 +736,7 @@ VolZmap::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtD
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei parametri
+  // verifico validità dei parametri
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
@@ -761,11 +750,11 @@ VolZmap::ToGlob( const Frame3d& frRef)
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
@@ -784,11 +773,11 @@ VolZmap::ToLoc( const Frame3d& frRef)
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
@@ -807,11 +796,11 @@ VolZmap::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei frame
+  // verifico validità dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
 
-  // se i due riferimenti coincidono, non devo fare alcunché
+  // se i due riferimenti coincidono, non devo fare alcunché
    if ( AreSameFrame( frOri, frDest))
       return true ;
 
@@ -827,10 +816,10 @@ VolZmap::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
 int
 VolZmap::GetPartCount( void) const
 {
-  // Se mono-dexel la connessione è incalcolabile.
+  // Se mono-dexel la connessione è incalcolabile.
    if ( m_nMapNum == 1)
       return - 1 ;
-  // Se il numero delle componenti è indefinito 
+  // Se il numero delle componenti è indefinito 
   // lo ricalcolo e restituisco il risultato.
    if ( m_nConnectedCompoCount == - 1) {
       const_cast<VolZmap*>(this)->CheckMapConnection() ;
@@ -881,7 +870,7 @@ VolZmap::CheckMapConnection( void)
                IntervalsToProcessStackVec.resize( nThreadMax) ;
               // Mi espando dal primo intervallo mettendo gli intervalli che intersecano nei vari thread 
                FirstExpansionFromZ( nThreadMax, NewInt, IntervalsToProcessStackVec) ;
-              // Lancio in parallelo più ricerche
+              // Lancio in parallelo più ricerche
                int nActiveThread = 0 ;
                vector<future<bool>> vRes ;
                vRes.resize( nThreadMax) ;
@@ -902,7 +891,7 @@ VolZmap::CheckMapConnection( void)
                   }
                }
             }
-           // Se l'intervallo non attraversa un nodo o ha già 
+           // Se l'intervallo non attraversa un nodo o ha già 
            // un indice assegnato salto questa iterazione.
             else 
                continue ;
@@ -946,7 +935,7 @@ VolZmap::ExpandFromXInterval( IntContainer& IntCont)
          double dZmin = m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].dMin ;
          double dZmax = m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].dMax ;
         // Se i segmenti si incrociano e il nuovo trovato non
-        // ha già un indice assegnato, assegno l'indice e
+        // ha già un indice assegnato, assegno l'indice e
         // aggiungo l'intervallo trovato allo stack.
          if ( dZmin - 2 * EPS_SMALL < dZ  &&
               dZmax + 2 * EPS_SMALL > dZ  && 
@@ -966,7 +955,7 @@ VolZmap::ExpandFromXInterval( IntContainer& IntCont)
          double dYmin = m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].dMin ;
          double dYmax = m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].dMax ;
         // Se i segmenti si incrociano e il nuovo trovato non
-        // ha già un indice assegnato, assegno l'indice e
+        // ha già un indice assegnato, assegno l'indice e
         // aggiungo l'intervallo trovato allo stack.
          if ( dYmin - 2 * EPS_SMALL < dY  &&
               dYmax + 2 * EPS_SMALL > dY  && 
@@ -1017,7 +1006,7 @@ VolZmap::ExpandFromYInterval( IntContainer& IntCont)
          double dZmin = m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].dMin ;
          double dZmax = m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].dMax ;
         // Se i segmenti si incrociano e il nuovo trovato non
-        // ha già un indice assegnato, assegno l'indice e
+        // ha già un indice assegnato, assegno l'indice e
         // aggiungo l'intervallo trovato allo stack.
          if ( dZmin - 2 * EPS_SMALL < dZ  &&
               dZmax + 2 * EPS_SMALL > dZ  && 
@@ -1037,7 +1026,7 @@ VolZmap::ExpandFromYInterval( IntContainer& IntCont)
          double dXmin = m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].dMin ;
          double dXmax = m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].dMax ;
         // Se i segmenti si incrociano e il nuovo trovato non
-        // ha già un indice assegnato, assegno l'indice e
+        // ha già un indice assegnato, assegno l'indice e
         // aggiungo l'intervallo trovato allo stack.
          if ( dXmin - 2 * EPS_SMALL < dX  &&
               dXmax + 2 * EPS_SMALL > dX  && 
@@ -1088,7 +1077,7 @@ VolZmap::ExpandFromZInterval( IntContainer& IntCont)
          double dXmin = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMin ;
          double dXmax = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMax ;
          // Se i segmenti si incrociano e il nuovo trovato non
-         // ha già un indice assegnato, assegno l'indice e
+         // ha già un indice assegnato, assegno l'indice e
         // aggiungo l'intervallo trovato allo stack.
          if ( dXmin - 2 * EPS_SMALL < dX  &&
               dXmax + 2 * EPS_SMALL > dX  && 
@@ -1108,7 +1097,7 @@ VolZmap::ExpandFromZInterval( IntContainer& IntCont)
          double dYmin = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMin ;
          double dYmax = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMax ;
          // Se i segmenti si incrociano e il nuovo trovato non
-         // ha già un indice assegnato, assegno l'indice e
+         // ha già un indice assegnato, assegno l'indice e
         // aggiungo l'intervallo trovato allo stack.
          if ( dYmin - 2 * EPS_SMALL < dY  &&
               dYmax + 2 * EPS_SMALL > dY  &&
@@ -1157,7 +1146,7 @@ VolZmap::FirstExpansionFromZ( int nNumThread, IntervalIndexes IntSt, IntContaine
          double dXmin = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMin ;
          double dXmax = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMax ;
         // Se i segmenti si incrociano e il nuovo trovato non
-        // ha già un indice assegnato, assegno l'indice e
+        // ha già un indice assegnato, assegno l'indice e
         // aggiungo l'intervallo trovato allo stack.
          if ( dXmin - 2 * EPS_SMALL < dX  &&
               dXmax + 2 * EPS_SMALL > dX  &&
@@ -1178,7 +1167,7 @@ VolZmap::FirstExpansionFromZ( int nNumThread, IntervalIndexes IntSt, IntContaine
          double dYmin = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMin ;
          double dYmax = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMax ;
         // Se i segmenti si incrociano e il nuovo trovato non
-        // ha già un indice assegnato, assegno l'indice e
+        // ha già un indice assegnato, assegno l'indice e
         // aggiungo l'intervallo trovato allo stack.
          if ( dYmin - 2 * EPS_SMALL < dY  &&
               dYmax + 2 * EPS_SMALL > dY  &&
@@ -1225,13 +1214,13 @@ VolZmap::ClonePart( int nPart) const
   // verifico lo stato
    if ( m_nStatus != OK)
       return nullptr ;
-  // Se è definita una sola griglia non sono definibili le parti,  errore
+  // Se è definita una sola griglia non sono definibili le parti,  errore
    if ( m_nMapNum == 1)
       return nullptr ;
-  // Se è richiesta una componente fuori intervallo, errore
+  // Se è richiesta una componente fuori intervallo, errore
    if ( nPart < 0  ||  nPart >= m_nConnectedCompoCount)
       return nullptr ;
-  // Se il numero di componenti è indefinito, lo ricalcolo.
+  // Se il numero di componenti è indefinito, lo ricalcolo.
    if ( m_nConnectedCompoCount == - 1)
       const_cast<VolZmap*>(this)->CheckMapConnection() ;
   // Se non vi sono componenti, errore
@@ -1302,7 +1291,7 @@ VolZmap::ClonePart( int nPart) const
       pVolume->m_Values[nMap].resize( pVolume->m_nDim[nMap]) ;
    }
 
-  // Se almeno una griglia è nulla, non ha senso Zmap
+  // Se almeno una griglia è nulla, non ha senso Zmap
    if ( pVolume->m_nDim[0] == 0  ||
         pVolume->m_nDim[1] == 0  ||
         pVolume->m_nDim[2] == 0)
@@ -1354,8 +1343,8 @@ VolZmap::ClonePart( int nPart) const
    dNewOy = nMinIndJ[0] * m_dStep ;
    dNewOz = nMinIndJ[1] * m_dStep ;
    
-  // Porto i dexel nel nuovo sistema di riferimento e le quote estreme Z. Non c'è bisogno di trasformare le normali,
-  // infatti i sistemi di riferimento in gioco differiscono al più per una traslazione.
+  // Porto i dexel nel nuovo sistema di riferimento e le quote estreme Z. Non c'è bisogno di trasformare le normali,
+  // infatti i sistemi di riferimento in gioco differiscono al più per una traslazione.
    for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
      // Quote estreme Z
       switch ( nMap) {
@@ -1418,10 +1407,10 @@ VolZmap::RemovePart( int nPart)
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // Se è definita una sola griglia non sono definibili le parti, errore
+  // Se è definita una sola griglia non sono definibili le parti, errore
    if ( m_nMapNum == 1)
       return false ;
-  // Se il numero di componenti è indefinito, lo ricalcolo
+  // Se il numero di componenti è indefinito, lo ricalcolo
    if ( m_nConnectedCompoCount == - 1)
       CheckMapConnection() ;
   // Se non vi sono componenti, abbiamo finito
@@ -1463,7 +1452,7 @@ VolZmap::GetPartMinDistFromPoint( const Point3d& ptP) const
   // Verifico lo stato e che siano definibili le componenti connesse
    if ( m_nStatus != OK  ||  m_nMapNum == 1)
       return - 1 ;
-  // Se il numero di componenti è indefinito, lo ricalcolo
+  // Se il numero di componenti è indefinito, lo ricalcolo
    if ( m_nConnectedCompoCount == -1)
       const_cast<VolZmap*>( this)->CheckMapConnection() ;
   // Se non vi sono componenti, abbiamo finito
@@ -1496,7 +1485,7 @@ VolZmap::GetPartMinDistFromPoint( const Point3d& ptP) const
                swap( ptEn.y, ptEn.z) ;
                swap( ptEn.x, ptEn.z) ;
             }
-           // Calcolo la distanza del punto dal segmento corrente. Se è minore della minima distanza aggiorno quest'ultima
+           // Calcolo la distanza del punto dal segmento corrente. Se è minore della minima distanza aggiorno quest'ultima
            // e la corrispondente componente connessa di minima distanza con la distanza e la componente connessa correnti.
             double dDist ;
             DistPointLine DistCalc( ptPL, ptSt, ptEn) ;
@@ -1688,197 +1677,107 @@ VolZmap::SubtractSurfTm( const ISurfTriMesh* pStm)
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
+VolZmap::MakeUniform( double dToler)
 {
-  // Controllo validità dello Zmap
+  // controllo validità dello Zmap
    if ( ! IsValid())
       return false ;
+  // la tolleranza deve essere minore dello step
+   dToler = min( dToler, 0.95 * m_dStep) ;
 
-  // creo lo ZMap per i riferimenti degli intervalli sulle griglie
-   PtrOwner<VolZmap> pZMapCopy( CloneBasicVolZmap( this)) ;
-   if ( IsNull( pZMapCopy)  ||  ! pZMapCopy->IsValid())
+  // creo lo Zmpa che andrà a sostituire il corrente
+   PtrOwner<VolZmap> pOldVolZmap( CloneBasicVolZmap( this)) ;
+   if ( IsNull( pOldVolZmap))
       return false ;
 
-  // creo uno ZMap per gli intervalli da aggiungere o da rimuovere
-   PtrOwner<VolZmap> pZMapExtra( CreateBasicVolZmap()) ;
-   if ( IsNull( pZMapExtra)  ||
-        ! pZMapExtra->CreateEmpty( m_MapFrame.Orig(), m_dMaxZ[1] - m_dMinZ[1],
-                                   m_dMaxZ[2] - m_dMinZ[2], m_dMaxZ[0] - m_dMinZ[0],
-                                   m_dStep, IsTriDexel()))
-      return false ;
-
-  // Dovendo effettuare estensioni, allargo gli ingobri nelle direzioni principali
-   m_dMinZ[0] -= dToler ;
-   m_dMinZ[1] -= dToler ;
-   m_dMinZ[2] -= dToler ;
-   m_dMaxZ[0] += dToler ;
-   m_dMaxZ[1] += dToler ;
-   m_dMaxZ[2] += dToler ;
-
-  // NB. Tutti i parametri sono sempre presi dalla Copia dello ZMap corrente
-  // Ciclo sulle griglie
-   for ( int nGrid = 0 ; nGrid < pZMapCopy->m_nMapNum ; ++ nGrid) {
-     // Ciclo sul numero di dexel presenti nella Copia
-      for ( int nDex = 0 ; nDex < int( pZMapCopy->m_Values[nGrid].size()) ; ++ nDex) {
-        // Se il dexel corrente non ha sotto-intervalli passo al successivo
-         if ( pZMapCopy->m_Values[nGrid][nDex].empty())
-            continue ;
-        // Indici del dexel
-         int nI = nDex % m_nNx[nGrid] ;
-         int nJ = nDex / m_nNx[nGrid] ;
-        // Recupero il numero di intervalli presenti nel Dexel corrente
-         int nIntervals = int( pZMapCopy->m_Values[nGrid][nDex].size()) ;
-        // Scorro gli intervalli presenti
-         for ( int nInfo = 0 ; nInfo < int( pZMapCopy->m_Values[nGrid][nDex].size()) ; ++ nInfo) {
-           // Recupero l'intervallo corrente
-            Data& Interval = pZMapCopy->m_Values[nGrid][nDex][nInfo] ;
-           // --- Se richiesta prima estensione
-            if ( bIsExtensionFirst) {
-              // *** Estremo inferiore -> Intervallo : [ dMin - dToler, dMin + dToler ]
-              // Aggiungo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
-               AddIntervals( nGrid, nI, nJ, Interval.dMin - dToler, Interval.dMin + dToler,
-                             Interval.vtMinN, Interval.vtMinN, nToolNum, true) ;
-              // Se si sono uniti degli intervalli, potrei dover aggiungere degli spilloni nelle altre due direzioni
-               if ( IsTriDexel()  &&  nIntervals != int( m_Values[nGrid][nDex].size())) {
-                 // Aggiorno gli intervalli correnti ( dato che il corrente si è unito al precedente)
-                 // ( lascio invariato lo ZMapCopy)
-                  nIntervals = int( m_Values[nGrid][nDex].size()) ;
-                  pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
-                                                       pZMapCopy->m_Values[nGrid][nDex][nInfo-1].dMax,
-                                                       Interval.dMin, dToler, true,
-                                                       nToolNum, V_INVALID, V_INVALID) ;
-               }
-              // *** Estremo superiore -> Intervallo : [ dMax - dToler, dMax + dToler ]
-              // Aggiungo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
-               AddIntervals( nGrid, nI, nJ, Interval.dMax - dToler, Interval.dMax + dToler,
-                             Interval.vtMaxN, Interval.vtMaxN, nToolNum, true) ;
-              // Se si sono uniti degli intervalli, potrei dover aggiungere degli spilloni nelle altre due direzioni
-               if ( IsTriDexel()  &&  nIntervals != int( m_Values[nGrid][nDex].size())) {
-                 // Aggiorno gli intervalli correnti ( dato che il corrente si è unito al successivo)
-                 // ( lascio invariato lo ZMapCopy)
-                  nIntervals = int( m_Values[nGrid][nDex].size()) ;
-                  pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
-                                                       Interval.dMax,
-                                                       pZMapCopy->m_Values[nGrid][nDex][nInfo+1].dMin, dToler, true,
-                                                       nToolNum, V_INVALID, V_INVALID) ;
-               }
-            }
-           // --- Se richiesta prima restrizione
-            else {
-              // *** Estremo inferiore -> Intervallo : [ dMin - dToler, dMin + dToler ]
-              // Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
-               SubtractIntervals( nGrid, nI, nJ, Interval.dMin - dToler, Interval.dMin + dToler,
-                                  Interval.vtMinN, Interval.vtMinN, nToolNum, true) ;
-              // Se l'intervallo si è annullato, potrei dover sottrarre degli spilloni nelle altre due direzioni
-               if ( IsTriDexel()  &&  nIntervals != int( m_Values[nGrid][nDex].size())) {
-                 // Aggiorno gli intervalli correnti ( lascio invariato lo ZMapCopy)
-                  nIntervals = int( m_Values[nGrid][nDex].size()) ;
-                  pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
-                                                       Interval.dMin,
-                                                       Interval.dMax, dToler, true,
-                                                       Tool::UNDEF, V_INVALID, V_INVALID) ;
-               }
-              // *** Estremo superiore -> Intervallo : [ dMax - dToler, dMax + dToler ]
-              // Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
-               SubtractIntervals( nGrid, nI, nJ, Interval.dMax - dToler, Interval.dMax + dToler,
-                                  Interval.vtMaxN, Interval.vtMaxN, nToolNum, true) ;
-              // Se l'intervallo si è annullato, potrei dover sottrarre degli spilloni nelle altre due direzioni
-               if ( IsTriDexel()  &&  nIntervals != int( m_Values[nGrid][nDex].size())) {
-                 // Aggiorno gli intervalli correnti ( lascio invariato lo ZMapCopy)
-                  nIntervals = int( m_Values[nGrid][nDex].size()) ;
-                  pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
-                                                       Interval.dMin,
-                                                       Interval.dMax, dToler, true,
-                                                       Tool::UNDEF, V_INVALID, V_INVALID) ;
-               }
-            }
-         }
-      }
-   }
-
-  // Ciclo sulle griglie ( uso lo Zmap Corrente, lascio invariato pZMapCopy)
+  // ciclo sulle griglie
    for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
-     // Ciclo sul numero di dexel presenti
+     // salvo lo Zmap prima di modificare gli spilloni
+      PtrOwner<VolZmap> pVolZMapCurrGrid( CloneBasicVolZmap( this)) ;
+      if ( IsNull( pVolZMapCurrGrid))
+      return false ;
+     // ciclo sul numero di dexel presenti
       for ( int nDex = 0 ; nDex < int( m_Values[nGrid].size()) ; ++ nDex) {
-        // Se l'intervallo è vuoto, non faccio nulla
-         if ( m_Values[nGrid][nDex].empty())
+        // se il dexel corrente non ha sotto-intervalli passo al successivo
+         if ( int( m_Values[nGrid][nDex].size()) == 0)
             continue ;
-        // Per ogni intervallo ricavato fino ad ora, restringo della tolleranza
-         for ( int nInfo = 0 ; nInfo < int( m_Values[nGrid][nDex].size()) ; ++ nInfo) {
-           // --- Se richiesta prima estensione
-            if ( bIsExtensionFirst) {
-               m_Values[nGrid][nDex][nInfo].dMin += dToler ;
-               m_Values[nGrid][nDex][nInfo].dMax -= dToler ;
-            }
-           // --- Se richiesta prima restrizione
-            else {
-               m_Values[nGrid][nDex][nInfo].dMin -= dToler ;
-               m_Values[nGrid][nDex][nInfo].dMax += dToler ;
-            }
-           // Definisco il colore
-            for ( int nOrigInfo = 0 ; nOrigInfo < int( pZMapCopy->m_Values[nGrid][nDex].size()) ; ++ nOrigInfo) {
-               if ( pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].dMin - m_Values[nGrid][nDex][nInfo].dMin < EPS_SMALL)
-                  m_Values[nGrid][nDex][nInfo].nToolMin = pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].nToolMin ;
-               if ( pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].dMax - m_Values[nGrid][nDex][nInfo].dMax < EPS_SMALL)
-                  m_Values[nGrid][nDex][nInfo].nToolMax = pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].nToolMax ;
-            }
-         }
-      }
-   }
-
-  // Gestisco le parti Extra ricavate
-  // Ciclo sulle griglie ( uso lo ZmapExtra, lascio invariato pZMapCopy)
-   for ( int nGrid = 0 ; nGrid < pZMapExtra->m_nMapNum ; ++ nGrid) {
-     // Ciclo sul numero di dexel presenti
-      for ( int nDex = 0 ; nDex < int( pZMapExtra->m_Values[nGrid].size()) ; ++ nDex) {
-        // Se l'intervallo è vuoto, non faccio nulla
-         if ( pZMapExtra->m_Values[nGrid][nDex].empty())
-            continue ;
-        // Indici del dexel
+        // indici del dexel
          int nI = nDex % m_nNx[nGrid] ;
          int nJ = nDex / m_nNx[nGrid] ;
-        // Per ogni intervallo ricavato fino ad ora...
-         for ( int nInfo = 0 ; nInfo < int( pZMapExtra->m_Values[nGrid][nDex].size()) ; ++ nInfo) {
-            double dMin = pZMapExtra->m_Values[nGrid][nDex][nInfo].dMin ;
-            double dMax = pZMapExtra->m_Values[nGrid][nDex][nInfo].dMax ;
-            Vector3d vtNMin = pZMapExtra->m_Values[nGrid][nDex][nInfo].vtMinN ;
-            Vector3d vtNMax = pZMapExtra->m_Values[nGrid][nDex][nInfo].vtMaxN ;
-           // --- Se richiesta prima estensione
-            if ( bIsExtensionFirst) {
-              // ... aggiungo i contributi
-                AddIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, true) ;
+        // salvo le informazioni dei sotto-intervalli del dexel corrente
+         vector<Data> vInfo ;
+         for ( int nExtr = 0 ; nExtr < int( m_Values[nGrid][nDex].size()) ; ++ nExtr)
+            vInfo.push_back( m_Values[nGrid][nDex][nExtr]) ;
+        // per ogni sotto-intervallo, estendo a destra e a sinistra della tolleranza
+         int nSub_intervals = int( vInfo.size()) ;
+        // scorro gli intervalli
+         for ( int nInfo = 0 ; nInfo < int( pVolZMapCurrGrid->m_Values[nGrid][nDex].size()) ; ++ nInfo) {
+           // estremo inferiore
+            if ( vInfo[nInfo].dMin - dToler > m_dMinZ[nGrid]) {
+               AddIntervals( nGrid, nI, nJ,
+                             vInfo[nInfo].dMin - dToler,
+                             vInfo[nInfo].dMin + dToler,
+                             vInfo[nInfo].vtMinN, vInfo[nInfo].vtMinN, vInfo[nInfo].nToolMin,
+                             true) ;
+              // se si sono uniti degli intervalli, potrei dover aggiungere degli spilloni nelle altre due
+              // direzioni nel voxel corrispondente
+               if ( IsTriDexel()  &&  dToler > 0.5 * m_dStep - EPS_SMALL  &&
+                    nSub_intervals != int( m_Values[nGrid][nDex].size())) {
+                  nSub_intervals = int( m_Values[nGrid][nDex].size()) ; // aggiorno gli intervalli correnti
+                 // l'intervallo corrente si è unito con il precedente...
+                  AddMissingIntervalsInVoxel( pOldVolZmap, nGrid, nI, nJ, vInfo[nInfo].dMin, dToler,
+                                              vInfo[nInfo].vtMinN, vInfo[nInfo].vtMinN,
+                                              vInfo[nInfo].nToolMin) ;
+               }
             }
-           // --- Se richiesta prima restrizione
-            else {
-              // ... sottraggo i contributi
-               SubtractIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, true) ;
+           // estremo superiore
+            if ( vInfo[nInfo].dMax + dToler < m_dMaxZ[nGrid]) {
+               AddIntervals( nGrid, nI, nJ,
+                             vInfo[nInfo].dMax - dToler,
+                             vInfo[nInfo].dMax + dToler,
+                             vInfo[nInfo].vtMaxN, vInfo[nInfo].vtMaxN, vInfo[nInfo].nToolMax,
+                             true) ;
+               if ( IsTriDexel()  &&  dToler > 0.5 * m_dStep - EPS_SMALL  &&
+                    nSub_intervals != int( m_Values[nGrid][nDex].size())) {
+                  nSub_intervals = int( m_Values[nGrid][nDex].size()) ; // aggiorno gli intervalli correnti
+                  AddMissingIntervalsInVoxel( pOldVolZmap, nGrid, nI, nJ, vInfo[nInfo].dMax, dToler,
+                                              vInfo[nInfo].vtMaxN, vInfo[nInfo].vtMaxN,
+                                              vInfo[nInfo].nToolMax) ;
+               }
+            }
+         }
+        // per ogni sotto-intervallo ricavato fino ad ora, restringo della tolleranza
+        // ( NB. avendo aggiunto intervalli, il dexel può modificare la sua struttura interna )
+         for ( int nInfo = 0 ; nInfo < int( m_Values[nGrid][nDex].size()) ; ++ nInfo) {
+           // ( NB. la rimozione di un intervallo ora va definita per intervalli a destra e a sinistra,
+           // altrimenti rimuovo parti in eccesso )
+            if ( ! pVolZMapCurrGrid->m_Values[nGrid][nDex].empty()) {
+               if ( nInfo != 0  ||
+                    pVolZMapCurrGrid->m_Values[nGrid][nDex][0].dMin - dToler > m_dMinZ[nGrid])
+                  m_Values[nGrid][nDex][nInfo].dMin += dToler ;
+               if ( nInfo != int( m_Values[nGrid][nDex].size()) - 1  ||
+                    pVolZMapCurrGrid->m_Values[nGrid][nDex].back().dMax + dToler < m_dMaxZ[nGrid])
+                  m_Values[nGrid][nDex][nInfo].dMax -= dToler ;
             }
          }
       }
    }
 
-  // Restringo gli ingombri espensi in precedenza
-   m_dMinZ[0] += dToler ;
-   m_dMinZ[1] += dToler ;
-   m_dMinZ[2] += dToler ;
-   m_dMaxZ[0] -= dToler ;
-   m_dMaxZ[1] -= dToler ;
-   m_dMaxZ[2] -= dToler ;
-
    return true ;
 }
 
+
 //----------------------------------------------------------------------------
 bool
 VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
 {
-  // Controllo sulla validità della griglia
+  // Controllo sulla validità della griglia
    if ( nGrid < 0  ||  nGrid > 2)
       return false ;
-  // Controllo sulla validità del dexel
+  // Controllo sulla validità del dexel
    if ( nDex <= - 1  ||  nDex >= int( m_Values[nGrid].size()))
       return false ;
-  // Controllo sulla validità dell'intervallo
+  // Controllo sulla validità dell'intervallo
    if ( nInt <= - 1  ||  nInt >= int( m_Values[nGrid][nDex].size()))
       return false ;
 
@@ -2030,6 +1929,8 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
 bool
 VolZmap::IsMapPartABox( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, double& dMinZ, double& dMaxZ)
 {
+   if ( ! m_bIsBox)
+      return true ;
    dMinZ = m_dMaxZ[nMap] ;
    dMaxZ = m_dMinZ[nMap] ;
    for ( int i = nInfI ; i < nSupI ; ++ i) {
@@ -2058,8 +1959,7 @@ VolZmap::IsMapPartABox( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, do
 bool 
 VolZmap::IsBox( void)
 {
-  // Se non tridexel, non posso stabilire con il metodo seguente se è un box
-  // Verifico solo che gli spilloni di una mappa o sono nulli o hanno gli stessi estremi
+  // Se non tridexel, non posso stabilire con il metodo seguente se è un box
    if ( m_nMapNum == 1)
       return false ;
   // Numero massimo di thread per il calcolo parallelo.
@@ -2068,16 +1968,13 @@ VolZmap::IsBox( void)
    if ( nThreadMax == 1) {
       for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
          double dMinZ, dMaxZ ;
-         if ( ! IsMapPartABox( nMap, 0, m_nNx[nMap], 0, m_nNy[nMap], dMinZ, dMaxZ)) {
-            m_bIsBox = false ;
+         if ( ! IsMapPartABox( nMap, 0, m_nNx[nMap], 0, m_nNy[nMap], dMinZ, dMaxZ))
             return false ;
-         }
       }
-      m_bIsBox = true ;
       return true ;
    }
 
-  // Caso di più thread
+  // Caso di più thread
    m_bIsBox = true ;
    for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
       vector< future<bool>> vRes ;
@@ -2122,16 +2019,15 @@ VolZmap::IsBox( void)
             }
          }
       }
-      // Se uno dei thread trova che la sua porzione non è un box, non lo può essere il solido intero.
+      // Se uno dei thread trova che la sua porzione non è un box, non lo può essere il solido intero.
       if ( ! m_bIsBox)
          return false ;
       // Controllo che gli estremi Z siano uguali.
       for ( int nT = 1 ; nT < nThreadMax ; ++ nT) {
-         if ( abs( vMinZ[nT] - vMinZ[0]) > EPS_SMALL  ||
-              abs( vMaxZ[nT] - vMaxZ[0]) > EPS_SMALL) {
-            m_bIsBox = false ;
+         if ( abs( vMinZ[nT] - vMinZ[0]) > EPS_SMALL)
+            return false ;
+         if ( abs( vMaxZ[nT] - vMaxZ[0]) > EPS_SMALL)
             return false ;
-         }
       }
    }
 
@@ -2159,7 +2055,7 @@ VolZmap::Cut( const Plane3d& plPlane)
       }
      // Ciclo sui dexel della mappa
       for ( int nD = 0 ; nD < int( m_Values[nMap].size()) ; ++ nD) {
-        // Se spillone già vuoto, passo al successivo
+        // Se spillone già vuoto, passo al successivo
          if ( m_Values[nMap][nD].empty())
             continue ;
         // Indici di spillone
@@ -2175,20 +2071,20 @@ VolZmap::Cut( const Plane3d& plPlane)
          double dEnDist = DistPointPlane( ptEn, plMyPlane) ;
         // Se entrambi sotto il piano
          if ( dStDist < EPS_SMALL  &&  dEnDist < EPS_SMALL)
-           // Non devo fare alcunché
+           // Non devo fare alcunché
             ;
         // se altrimenti entrambi gli estremi sono oltre il piano
          else if ( dStDist > -EPS_SMALL  &&  dEnDist > -EPS_SMALL) {
            // Si elimina tutto
             SubtractIntervals( nMap, nI, nJ, dMin, dMax, V_NULL, V_NULL, 1) ;
          }
-        // se altrimenti è da tenere il punto iniziale
+        // se altrimenti è da tenere il punto iniziale
          else if ( dStDist < 0) {
            // Si elimina la parte tra intersezione e punto finale
             double dInt = dMin + ( dMax - dMin) * abs( dStDist) / ( abs( dStDist) + abs( dEnDist)) ;
             SubtractIntervals( nMap, nI, nJ, dInt, dMax, plMyPlane.GetVersN(), V_NULL, 1) ;
          }
-        // se altrimenti è da tenere il punto finale
+        // se altrimenti è da tenere il punto finale
          else if (dEnDist < 0) {
            // Si elimina la parte tra punto iniziale e intersezione
             double dInt = dMin + ( dMax - dMin) * abs( dStDist) / ( abs( dStDist) + abs( dEnDist)) ;
@@ -2278,7 +2174,7 @@ VolZmap::Compact( void)
       }
    }
 
-  // Se non vi è materiale
+  // Se non vi è materiale
    if ( ! bNotEmptyGrid) {
       m_nStatus = TO_VERIFY ;
       m_nNumBlock = 0 ;
@@ -2300,8 +2196,8 @@ VolZmap::Compact( void)
    double dNewOy = nMinJ[0] * m_dStep ;
    double dNewOz = nMinJ[1] * m_dStep ;
    
-  // Porto i dexel nel nuovo sistema di riferimento e le quote estreme Z. Non c'è bisogno di trasformare le normali,
-  // infatti i sistemi di riferimento in gioco differiscono al più per una traslazione.
+  // Porto i dexel nel nuovo sistema di riferimento e le quote estreme Z. Non c'è bisogno di trasformare le normali,
+  // infatti i sistemi di riferimento in gioco differiscono al più per una traslazione.
    for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
      // Quote estreme Z
       switch ( nMap) {

VolZmap.h

@@ -16,6 +16,7 @@
 #include "ObjGraphicsMgr.h"
 #include "GeoObjRW.h"
 #include "Tool.h"
+#include "SurfBezier.h"
 #include "/EgtDev/Include/EGkVolZmap.h"
 #include "/EgtDev/Include/EGkIntersLineVolZmap.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
@@ -30,6 +31,8 @@ typedef std::vector<PNTVEC3D>        PNTVEC3DVECTOR ;  // vettore di intersezion
 
 // ------------------------- FORWARD -------------------------------------------------------------
 class IntersParLinesSurfTm ;
+class BBox3d ;
+class Frame3d ;
 
 // ------------------------- STRUTTURE -----------------------------------------------------------
 struct AppliedVector {
@@ -38,6 +41,55 @@ struct AppliedVector {
    int nPropIndex ;
 } ;
 
+struct MachInfo {
+   int n5AxisType ;
+   int nSub ;
+   int nStepCnt ;
+   double dSide ;
+   Vector3d vtDirTipStartEx ;
+   Vector3d vtDirTipEndEx ;
+   Vector3d vtDirTopStartEx ;
+   Vector3d vtDirTopEndEx ;
+   VCT3DVECTOR vvtTipStartAux ;
+   VCT3DVECTOR vvtTipEndAux ;
+   VCT3DVECTOR vvtTopStartAux ;
+   VCT3DVECTOR vvtTopEndAux ;
+   Vector3d vtDirTip ;
+   Vector3d vtDirTop ;
+   MachInfo( int n5AxisType_, int nSub_, int nStepCnt_, double dSide_, Vector3d vtDirTipStartEx_, Vector3d vtDirTipEndEx_, Vector3d vtDirTopStartEx_, Vector3d vtDirTopEndEx_,
+             VCT3DVECTOR vvtTipStartAux_, VCT3DVECTOR vvtTipEndAux_, VCT3DVECTOR vvtTopStartAux_, VCT3DVECTOR vvtTopEndAux_, Vector3d vtDirTip_, Vector3d vtDirTop_) :
+             n5AxisType( n5AxisType_), nSub( nSub_), nStepCnt( nStepCnt_), dSide( dSide_), vtDirTipStartEx( vtDirTipStartEx_), vtDirTipEndEx( vtDirTipEndEx_), vtDirTopStartEx( vtDirTopStartEx_), vtDirTopEndEx( vtDirTopEndEx_),
+             vvtTipStartAux( vvtTipStartAux_), vvtTipEndAux( vvtTipEndAux_), vvtTopStartAux( vvtTopStartAux_), vvtTopEndAux( vvtTopEndAux_), vtDirTip( vtDirTip_), vtDirTop( vtDirTop_) {}
+};
+
+struct ToolInfo {
+   double dHeight ;
+   double dMaxRad ;
+   double dMinRad ;
+   double dTan ;
+   double dMaxH ;
+   double dMinH ;
+   double dMaxRadApprox ;
+   double dMinRadApprox ;
+   BBox3d bbStartCyl ;
+   BBox3d bbEndCyl ;
+   Frame3d frToolStart ;
+   Frame3d frToolEnd ;
+   //Vector3d vtDirTip ;
+   //Vector3d vtDirTop ;
+   ToolInfo( double dHeight_, double dMaxRad_, double dMinRad_, double dTan_, double dMaxH_, double dMinH_, double dMaxRadApprox_, double dMinRadApprox_,
+             BBox3d bbStartCyl_, BBox3d bbEndCyl_, Frame3d frToolStart_, Frame3d frToolEnd_) :
+             dHeight ( dHeight_), dMaxRad( dMaxRad_), dMinRad( dMinRad_), dTan( dTan_), dMaxH( dMaxH_), dMinH( dMinH_), dMaxRadApprox( dMaxRadApprox_), dMinRadApprox( dMinRadApprox_),
+             bbStartCyl( bbStartCyl_), bbEndCyl( bbEndCyl_), frToolStart( frToolStart_), frToolEnd( frToolEnd_) {}
+};
+
+struct SurfBezForInters {
+   SurfBezier sBez ;
+   BBox3d bbSurf ;
+   double A1, A2, B1, B2, C1, C2 ;
+   Vector3d d ;
+};
+
 //----------------------------------------------------------------------------
 class VolZmap : public IVolZmap, public IGeoObjRW
 {
@@ -85,7 +137,9 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) override ;
       bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) override ;
       bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) override ;
-      bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0) override ;
+      bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0.) override ;
+      bool CreateFromTriMeshOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol, int nType = STMOFF_FILLET) override ;
+      bool CreateFromTriMeshThickeningOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol, int nType = STMOFF_FILLET) override ;
       int  GetBlockCount( void) const override ;
       int  GetBlockUpdatingCounter( int nBlock) const override ;
       bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const override ;
@@ -99,7 +153,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
               { return m_nDexVoxRatio ; }   
       bool ChangeResolution( int nDexVoxRatio) override ;
       void SetShowEdges( bool bShow) override
-              { m_bShowEdges = bShow ;  // qui è necessario far ricreare la grafica
+              { m_bShowEdges = bShow ;  // qui � necessario far ricreare la grafica
                 m_OGrMgr.Clear() ; }
       bool GetShowEdges( void) const override
               { return m_bShowEdges ; }
@@ -151,8 +205,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       int  GetPartMinDistFromPoint( const Point3d& ptP) const override ;
       bool AddSurfTm( const ISurfTriMesh* pStm) override ;
       bool SubtractSurfTm( const ISurfTriMesh* pStm) override ;
-      bool MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum) override ;
-      bool Offset( double dOffs, int nType) override ;
+      bool MakeUniform( double dToler) override ;
 
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
@@ -173,8 +226,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                     return *this ; }
       bool GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const ;
       bool GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) const ;
-      bool CreateFromTriMeshOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol, int nType = STMOFF_FILLET) ;
-      bool CreateFromTriMeshThickeningOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol, int nType = STMOFF_FILLET) ;
 
    private :
       enum CubeType { VOX_EXTERN = 1,
@@ -260,16 +311,15 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool AddIntervals( int nGrid, int nI, int nJ,
                          double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
                          int nToolNum, bool bSkipSwap = false) ;
-      bool UniformIntervalsInVoxel( int nGrid, int nI, int nJ, double dZMin, double dZMax,
-                                    double dToler, bool bAdd, int nToolNum, const Vector3d& vtToolMin,
-                                    const Vector3d& vtToolMax) ;
-      bool ManageSubIntervalInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, int nK, double& dMin, double& dMax,
-                                     Vector3d& vtMin, Vector3d& vtMax) ;
+      bool AddMissingIntervalsInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, double dZ, double dToler,
+                                       Vector3d vtToolMin, Vector3d vtToolMax, int nToolNum) ;
+      bool AddSubIntervalInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, int nK, double& dMin, double& dMax,
+                                  Vector3d& vtMin, Vector3d& vtMax) ;
      // Spostamenti utensile
       bool MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtD, const Vector3d& vtA) ;
       bool MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
                                      const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) ;
-      bool SelectGeneralMotion( int nGrid, const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtLs, const Vector3d& vtLe, int n5AxisType) ;
+      bool SelectGeneralMotion( int nGrid, const PNTVECTOR& ptPs, const PNTVECTOR& ptPe, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int n5AxisType) ;
       bool SelectMotion( int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtL, const Vector3d& vtAL) ;
       bool InitializePointsAndVectors( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtDs, const Vector3d& vtAs,
                                        Point3d ptLs[3], Point3d ptLe[3], Vector3d vtLs[3], Vector3d vtALs[3]) ;
@@ -308,10 +358,10 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool GenTool_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
       bool GenTool_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
      // lavorazioni a 5 assi
-      bool GenTool_5AxisMilling(int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, int n5AxisType = ACROSS) ;
-      bool Cyl_5AxisMilling(int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, double dHeightCorr = 0, int n5AxisType = ACROSS) ;
-      bool CylBall_5AxisMilling(int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, int n5AxisType = ACROSS) ;
-      bool Conus_5AxisMilling(int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe, int nToolNum, int n5AxisType = ACROSS) ;
+      bool GenTool_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType = VolZmap::Move5Axis::ACROSS) ;
+      bool Cyl_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, double dHeightCorr = 0, int n5AxisType = VolZmap::Move5Axis::ACROSS) ;
+      bool CylBall_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType = VolZmap::Move5Axis::ACROSS) ;
+      bool Conus_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType = VolZmap::Move5Axis::ACROSS) ;
 
     // COMPONENTI
      // Asse di simmetria diretto come l'asse Z 
@@ -347,13 +397,13 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool CompPar_Milling( int nGrid, double dLenX, double dLenY, double dLenZ,
                             const Point3d& ptS, const Point3d& ptE,
                             const Vector3d& vtToolDir, const Vector3d& vtAux, int nToolNum) ;   //  E' in realtà  MillingPerp
-      // lavorazioni a 5 assi
-      bool Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe,
+     // lavorazioni a 5 assi
+      bool Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe,
                               double dHeight, double dMaxRad, double dMinRad, int nToolNum, int n5AxisType) ;
-      bool CompCyl_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtLs, const Vector3d& vtLe,
-                                 double dHeight, double dRadius, int nToolNum, int n5AxisType) ;
-      bool CompConus_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDirS, const Vector3d& vtToolDirE, double dHei, double dMaxRad, double dMinRad,
-                                   bool bTapB, bool bTapT, const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum, int n5AxisType) ;
+      bool CompCyl_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe,
+                                 double dHeight, double dRadius, int nToolNum,int n5AxisType) ;
+      bool CompConus_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtToolDirS, const VCT3DVECTOR& vtToolDirE, double dHei, double dMaxRad, double dMinRad,
+                                   bool bTapB, bool bTapT,const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum, int n5AxisType) ;
 
      // Generica traslazione sfera
       bool CompBall_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, double dRad, int nToolNum) ;
@@ -399,6 +449,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool IntersLineTruncatedPyramid( const Point3d& ptLineSt, const Vector3d& vtLineDir,
                                        const Frame3d& frTruncPyramFrame, double dSegMin, double dSegMax, double dHeight,
                                        Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) const ;
+      bool IntersToolLine( const Point3d& ptLineStart, const Vector3d& vtLineDir, const MachInfo& mi, const ToolInfo& ti,
+                           const std::vector<SurfBezForInters>& vSurfBez,PNTVEC3DVECTOR& vInters, INTVECTOR& vSurfInters) const ;
       bool TestIntersPlaneZmapBBox( const Plane3d& plPlane) const ;
      // Voxel: esistenza e passaggio da N a ijk per i voxel
       bool IsValidVoxel( int nN) const ;
@@ -462,54 +514,52 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool SubtractMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
                             const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM) ;
      // Funzioni per Offset di superfici
-      bool InitVolZMapOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol) ;
-      bool InitVolZMapThickeningOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol) ;
+      bool InitVolZMapOffs( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol) ;
+      bool InitVolZMapThickeningOffs( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol) ;
       bool UpdateVolZMapByOpenSurfFilletOffset( const ISurfTriMesh* Surf, double dOffs, double dTol) ;
-      bool UpdateVolZMapByOpenSurfSharpedOffset( const ISurfTriMesh* Surf, int nType, double dOffs, double dTol) ;
       bool UpdateVolZMapByClosedSurfFilletOffset( const ISurfTriMesh* Surf, double dOffs, double dTol) ;
-      bool UpdateVolZMapByClosedSurfSharpedOffset( const ISurfTriMesh* Surf, int nType, double dOffs, double dTol) ;
       bool UpdateVolZMapBySurfThickeningFilletOffset( const ISurfTriMesh* Surf, double dOffs, double dTol) ;
-      bool UpdateVolZMapBySurfThickeningSharpedOffset( const ISurfTriMesh* Surf, int nType, double dOffs, double dTol) ;
-      bool CreateOffsetSphereOnVertex( const Point3d& ptV, double dOffs, int nGrid, int nVertexType = 0) ;
-      bool CreateOffsetCylinderOnEdge( const Point3d& ptP1, const Point3d& ptP2, double dOffs, int nGrid, int nVertexType = 0) ;
-      bool CreateFatOffsetExtrusionFace( const ISurfTriMesh* Surf, double dOffs, bool bThickle, int nTool = 0) ;
-      bool CreateOrientedOffsetExtrusionFace( const ISurfTriMesh* Surf, double dOffs) ;
+      bool CreateOffsSphereOnVertex( const Point3d& ptV, double dOffs, int nGrid, int nVertexType = 0) ;
+      bool CreateOffsCylinderOnEdge( const Point3d& ptP1, const Point3d& ptP2, double dOffs, int nGrid, int nVertexType = 0) ;
       bool SubtractIntervalsForOffset( int nGrid, int nI, int nJ,
                                        double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax, 
                                        int nToolNum, bool bSkipSwap = false) ;
       bool AddIntervalsForOffset( int nGrid, int nI, int nJ,
                                   double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
-                                  int nToolMin, int nToolMax, bool bSkipSwap = false) ;
-      bool CutByPlaneForOffset( const Plane3d& plCut) ;
-      bool AddSurfTmForOffset( const ISurfTriMesh* pStm, int nTool) ;
-      bool AddMapPartForOffset( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
-                                const ISurfTriMesh& Surf, int nTool, IntersParLinesSurfTm& intPLSTM) ;
-     // Funzioni per Offset di Zmap
-      bool OffsetFillet( double dOffs) ;
-      bool OffsetSharped( double dOffs, int nType) ;
+                                  int nToolNum, bool bSkipSwap = false) ;
+   public :
+      // ------------------------- ENUM ----------------------------------------------------------------
+      enum MillingPhase {
+         COUNT_START_VOL = 0 ,
+         ONLY_LATERAL_SURF = 1 ,
+         COUNT_END_VOL = 2 ,
+         COUNT_START_END = 3
+      } ;
+
+      enum Move5Axis{
+         ALONG_CONVEX = 0 ,
+         ALONG_CONCAVE = 1 ,
+         ACROSS = 2 ,
+         NO_BASE_INTERS = 3
+      } ;
+
+      enum CuttingSurface {
+         NONE = -1,
+         TOOL = 0 ,
+         BZ = 1 ,
+         LATERAL = 2
+      } ;
 
    private :
-      enum Move5Axis {
-            ALONG_CONVEX = 0 ,
-            ALONG_CONCAVE = 1 ,
-            ACROSS = 2 ,
-            NO_BASE_INTERS = 3} ;
-      enum Status {
-            ERR = 0,
-            OK = 1,
-            TO_VERIFY = 2} ;
-      enum Shape {
-            GENERIC = 0,
-            BOX = 1,
-            EXTRUSION = 2,
-            OFFSET = 3} ;
+      enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
+      enum Shape { GENERIC = 0, BOX = 1, EXTRUSION = 2, OFFSET = 3} ;
       static const int N_MAPS = 3 ;
       static const int N_VOXBLOCK = 32 ;
 
    private :
       ObjGraphicsMgr m_OGrMgr ;             // gestore grafica dell'oggetto
       Status         m_nStatus ;            // stato
-      int            m_nTempProp[2] ;       // vettore proprietà temporanee
+      int            m_nTempProp[2] ;       // vettore propriet� temporanee
       double         m_dTempParam[2] ;      // vettore parametri temporanei
       bool           m_bShowEdges ;         // flag di visualizzazione spigoli vivi
       Frame3d        m_MapFrame ;           // riferimento intrinseco dello Zmap
@@ -543,8 +593,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       mutable BOOLVECTOR m_BlockToUpdate ;
       mutable INTVECTOR  m_BlockUpdatingCounter ;
 
-      int m_nConnectedCompoCount ;          // Se == - 1 il numero di componenti non è noto
-                                            // Se >= 0 è il numero di componenti connesse
+      int m_nConnectedCompoCount ;          // Se == - 1 il numero di componenti non � noto
+                                            // Se >= 0 � il numero di componenti connesse
               
       mutable std::vector<VoxelContainer>  m_InterBlockVox ;
       mutable SharpTriaMatrix              m_InterBlockOriginalSharpTria ;
@@ -567,12 +617,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       double                              m_dToolAngTolDeg ;
 } ;
 
-// Offset
-enum {
-   VOLZMAP_OFFS_FILLET = 0,
-   VOLZMAP_OFFS_CHANFER = 1,
-   VOLZMAP_OFFS_EXTENDED = 2
-} ;
 
 //-----------------------------------------------------------------------------
 inline VolZmap* CreateBasicVolZmap( void)

VolZmapCalculus.cpp

@@ -2294,7 +2294,7 @@ VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
          vtN1.Normalize() ;
       }
      // altrimenti piano inferiore
-      else if ( nBasInt == 1) {
+      else if( nBasInt == 1)  {
         // Punto di intersezione
          ptInt2 = ptP + vdRoots[0] * vtV ;
         // Normale alla superficie del cono verso l'interno
@@ -3080,18 +3080,17 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
          return false ;
      // Se c'è intersezione valuto tutti i voxel interni
       if ( TestIntersPlaneBox( plPlaneLoc, b3BlockBox)) {    
+        // Ciclo sui voxel del blocco.    
         // Triangoli smooth
-        // ciclo sui voxel del blocco.    
-         for ( int nV = 0 ; nV < ssize( m_BlockSmoothTria[nB]) ; ++ nV) {
+         for ( int nV = 0 ; nV < int( m_BlockSmoothTria[nB].size()) ; ++ nV) {
            // Box del voxel
             BBox3d b3Vox ;
             GetVoxelBox( m_BlockSmoothTria[nB][nV].i, m_BlockSmoothTria[nB][nV].j, m_BlockSmoothTria[nB][nV].k, b3Vox) ;
-           // Se non c'è intersezione col voxel, passo al successivo.
+            // Se non c'è intersezione col voxel, passo al successivo.
             if ( ! TestIntersPlaneBox( plPlaneLoc, b3Vox))
                continue ; 
-           // ciclo sui triangoli del voxel
-            for ( int nT = 0 ; nT < ssize( m_BlockSmoothTria[nB][nV].vTria) ; ++ nT) {
-               const Triangle3d& trTria = m_BlockSmoothTria[nB][nV].vTria[nT] ;
+            for ( int nT = 0 ; nT < int( m_BlockSmoothTria[nB][nV].vTria.size()) ; ++ nT) {
+               Triangle3d trTria = m_BlockSmoothTria[nB][nV].vTria[nT] ;
                Point3d ptSt, ptEn ;
                int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
                if ( nIntersType == IPTT_EDGE  ||  nIntersType == IPTT_YES) {
@@ -3103,18 +3102,18 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
             }
          }
         // Triangoli sharp interni al blocco    
-        // ciclo sui voxel del blocco.    
-         for ( int nV = 0 ; nV < ssize( m_BlockSharpTria[nB]) ; ++ nV) {
+         for ( int nV = 0 ; nV < int( m_BlockSharpTria[nB].size()) ; ++ nV) {
            // Box del voxel     
             BBox3d b3Vox ;
             GetVoxelBox( m_BlockSharpTria[nB][nV].i, m_BlockSharpTria[nB][nV].j, m_BlockSharpTria[nB][nV].k, b3Vox) ;
+           // Se non c'è intersezione col voxel, passo al successivo.
            // Ciclo sulle componenti connesse
-            for ( int nC = 0 ; nC < ssize( m_BlockSharpTria[nB][nV].vCompoTria) ; ++ nC) {
-               for ( int nT = 0 ; nT < ssize( m_BlockSharpTria[nB][nV].vCompoTria[nC]) ; ++ nT) {
-                  const Triangle3d& trTria = m_BlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
+            for ( int nC = 0 ; nC < int( m_BlockSharpTria[nB][nV].vCompoTria.size()) ; ++ nC) {
+               for ( int nT = 0 ; nT < int( m_BlockSharpTria[nB][nV].vCompoTria[nC].size()) ; ++ nT) {
+                  Triangle3d trTria = m_BlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
                   Point3d ptSt, ptEn ;
-                  int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
-                  if ( nIntersType == IPTT_EDGE  ||  nIntersType == IPTT_YES) {
+                  int nIntersType = IntersPlaneTria(plPlane, trTria, ptSt, ptEn) ;
+                  if (nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
                     // Costruisco il tratto di curva
                      CurveLine cvLine ;
                      if ( cvLine.Set(ptSt, ptEn))
@@ -3124,10 +3123,10 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
             }
          }
         // Triangoli grandi del blocco
-         for ( int nT = 0 ; nT < ssize( m_BlockBigTria[nB]) ; ++ nT) {
-            const Triangle3d& trTria = m_BlockBigTria[nB][nT] ;
+         for ( int nT = 0 ; nT < int( m_BlockBigTria[nB].size()) ; ++ nT) {
+            Triangle3d trTria = m_BlockBigTria[nB][nT] ;
             Point3d ptSt, ptEn ;
-            int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
+            int nIntersType = IntersPlaneTria(plPlane, trTria, ptSt, ptEn) ;
             if ( nIntersType == IPTT_EDGE  ||  nIntersType == IPTT_YES) {
                // Costruisco il tratto di curva
                CurveLine cvLine ;
@@ -3137,11 +3136,11 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
          }
       }
      // In ogni caso valuto i triangoli sharp fra blocchi
-      for ( int nV = 0 ; nV < ssize( m_InterBlockSharpTria[nB]) ; ++ nV) {
+      for ( int nV = 0 ; nV < int( m_InterBlockSharpTria[nB].size()) ; ++ nV) {
         // Ciclo sulle componenti connesse
-         for ( int nC = 0 ; nC < ssize( m_InterBlockSharpTria[nB][nV].vCompoTria) ; ++ nC) {
-            for ( int nT = 0 ; nT < ssize( m_InterBlockSharpTria[nB][nV].vCompoTria[nC]) ; ++ nT) {
-               const Triangle3d& trTria = m_InterBlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
+         for ( int nC = 0 ; nC < int( m_InterBlockSharpTria[nB][nV].vCompoTria.size()) ; ++ nC) {
+            for ( int nT = 0 ; nT < int( m_InterBlockSharpTria[nB][nV].vCompoTria[nC].size()) ; ++ nT) {
+               Triangle3d trTria = m_InterBlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
                Point3d ptSt, ptEn ;
                int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
                if ( nIntersType == IPTT_EDGE  ||  nIntersType == IPTT_YES) {
@@ -3157,9 +3156,9 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
    
   // Creo i loop
    ChainCurves LoopCreator ;
-   LoopCreator.Init( false, EPS_SMALL, ssize( vLine)) ;
+   LoopCreator.Init( false, EPS_SMALL, int( vLine.size())) ;
   // Carico le curve per concatenarle
-   for ( int nCv = 0 ; nCv < ssize( vLine) ; ++ nCv) {
+   for ( int nCv = 0 ; nCv < int( vLine.size()) ; ++ nCv) {
       Point3d ptSt = vLine[nCv].GetStart() ;
       Point3d ptEn = vLine[nCv].GetEnd() ;
       Vector3d vtDir; vLine[nCv].GetStartDir(vtDir) ;
@@ -3177,7 +3176,6 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
          if ( ! pLoop->AddCurve( vLine[i - 1], true, 10 * EPS_SMALL))
             return false ;
       }
-      pLoop->TestClosure( 10 * EPS_SMALL) ;
       pLoop->SetExtrusion( plPlane.GetVersN()) ;
       pLoop->MergeCurves( 10 * EPS_SMALL, ANG_TOL_STD_DEG) ;
       // Inserisco la curva composita nella raccolta da ritornare

VolZmapCreation.cpp

@@ -505,8 +505,6 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
         nSupJ < 0  ||  nSupJ > m_nNy[nMap])
       return false ;
 
-   double dCosSmall = sin( EPS_ANG_SMALL * DEGTORAD) ;
-
    // Determinazione e ridimensionamento dei dexel interni alla trimesh
    for ( int i = nInfI ; i < nSupI ; ++ i) {
       for ( int j = nInfJ ; j < nSupJ ; ++ j) {
@@ -554,7 +552,7 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
                double dCos = IntersectionResults[k].dCosDN ;
 
                // entro nella superficie trimesh
-               if ( dCos < - dCosSmall) {
+               if ( dCos < - EPS_SMALL) {
 
                   ptIn = IntersectionResults[k].ptI ;
 
@@ -567,7 +565,7 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
                }
 
                // esco dalla superficie trimesh
-               else if ( dCos > dCosSmall  &&  bInside) {
+               else if ( dCos > EPS_SMALL  &&  bInside) {
 
                   Point3d ptOut = IntersectionResults[k].ptI ;
 
@@ -806,9 +804,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
   // quindi espandiamo il bounding box per ovviare al problema.
    if ( dExtraBox > EPS_ZERO)
       SurfBBox.Expand( dExtraBox) ;
-   else
-      dExtraBox = 0 ;
-    
+
   // Determino i punti estremi del bounding box
    Point3d ptMapOrig, ptMapEnd ; 
    SurfBBox.GetMinMax( ptMapOrig, ptMapEnd) ;
@@ -874,69 +870,58 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
      // Oggetto per calcolo massivo intersezioni
       IntersParLinesSurfTm intPLSTM( frMapFrame, Surf) ;
 
-     // Standarda è multithread
-      constexpr bool MULTITHREAD = true ;
-      if ( MULTITHREAD) {
-
-         // Numero massimo di thread
-         int nThreadMax = max( 1, int( thread::hardware_concurrency()) - 1) ;
-         vector< future<bool>> vRes ;
-         vRes.resize( nThreadMax) ;
-         if ( m_nNx[nG] > m_nNy[nG]) {
-            int nDexNum = m_nNx[nG] / nThreadMax ;
-            int nRemainder = m_nNx[nG] % nThreadMax ;
-            int nInfI = 0 ;
-            int nSupI = 0 ;
-            for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
-               nInfI = nSupI ;
-               nSupI = nInfI + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
-               vRes[nThread] = async( launch::async, &VolZmap::CreateMapPart, this, nG,
-                                      nInfI, nSupI, 0, m_nNy[nG], ref( vtLen), ref( ptMapOrig), ref( Surf), ref( intPLSTM)) ;
-            }
-         }
-         else {
-            int nDexNum = m_nNy[nG] / nThreadMax ;
-            int nRemainder = m_nNy[nG] % nThreadMax ;
-            int nInfJ = 0 ;
-            int nSupJ = 0 ;
-            for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
-               nInfJ = nSupJ ;
-               nSupJ = nInfJ + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
-               vRes[nThread] = async( launch::async, &VolZmap::CreateMapPart, this, nG,
-                                      0, m_nNx[nG], nInfJ, nSupJ, ref( vtLen), ref( ptMapOrig), ref( Surf),ref( intPLSTM)) ;
-            }
-         }
-       
-         // Ciclo per attendere che tutti gli async abbiano terminato.
-         int nTerminated = 0 ;
-         while ( nTerminated < nThreadMax) {
-            for ( int nL = 0 ; nL < nThreadMax ; ++ nL) {
-               // Async terminato
-               if ( vRes[nL].valid()  &&  vRes[nL].wait_for( chrono::microseconds{ 1}) == future_status::ready) {
-                  ++ nTerminated ;
-                  bCompleted = bCompleted  &&  vRes[nL].get() ;
-               }
-            }
+      // Numero massimo di thread
+      int nThreadMax = max( 1, int( thread::hardware_concurrency()) - 1) ;
+      vector< future<bool>> vRes ;
+      vRes.resize( nThreadMax) ;
+      if ( m_nNx[nG] > m_nNy[nG]) {
+         int nDexNum = m_nNx[nG] / nThreadMax ;
+         int nRemainder = m_nNx[nG] % nThreadMax ;
+         int nInfI = 0 ;
+         int nSupI = 0 ;
+         for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
+            nInfI = nSupI ;
+            nSupI = nInfI + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
+            vRes[nThread] = async( launch::async, &VolZmap::CreateMapPart, this, nG,
+                                   nInfI, nSupI, 0, m_nNy[nG], ref( vtLen), ref( ptMapOrig), ref( Surf), ref( intPLSTM)) ;
          }
       }
-
-     // !!!! NON MULTITHREAD : SOLO PER DEBUG !!!!
       else {
-         CreateMapPart( nG, 0, m_nNx[nG], 0, m_nNy[nG], vtLen, ptMapOrig, Surf, intPLSTM) ;
+         int nDexNum = m_nNy[nG] / nThreadMax ;
+         int nRemainder = m_nNy[nG] % nThreadMax ;
+         int nInfJ = 0 ;
+         int nSupJ = 0 ;
+         for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
+            nInfJ = nSupJ ;
+            nSupJ = nInfJ + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
+            vRes[nThread] = async( launch::async, &VolZmap::CreateMapPart, this, nG,
+                                   0, m_nNx[nG], nInfJ, nSupJ, ref( vtLen), ref( ptMapOrig), ref( Surf),ref( intPLSTM)) ;
+         }
+      }
+       
+      // Ciclo per attendere che tutti gli async abbiano terminato.
+      int nTerminated = 0 ;
+      while ( nTerminated < nThreadMax) {
+         for ( int nL = 0 ; nL < nThreadMax ; ++ nL) {
+            // Async terminato
+            if ( vRes[nL].valid()  &&  vRes[nL].wait_for( chrono::microseconds{ 1}) == future_status::ready) {
+               ++ nTerminated ;
+               bCompleted = bCompleted  &&  vRes[nL].get() ;
+            }
+         }
       }
    }
 
   // Assegno il minimo e massimo valore di Z della mappa
-   m_dMinZ[0] = dExtraBox ;
-   m_dMaxZ[0] = vtLen.z - dExtraBox ;
-   m_dMinZ[1] = ( bTriDex ? dExtraBox : 0) ;
-   m_dMaxZ[1] = ( bTriDex ? vtLen.x - dExtraBox : 0) ;
-   m_dMinZ[2] = ( bTriDex ? dExtraBox : 0) ;  
-   m_dMaxZ[2] = ( bTriDex ? vtLen.y - dExtraBox : 0) ;
+   m_dMinZ[0] = 0 ;
+   m_dMaxZ[0] = vtLen.z ;
+   m_dMinZ[1] = 0 ;
+   m_dMaxZ[1] = ( bTriDex ? vtLen.x : 0) ;
+   m_dMinZ[2] = 0 ;  
+   m_dMaxZ[2] = ( bTriDex ? vtLen.y : 0) ;
 
   // Tipologia
-  // Con espansione non va considerato box (calcolo trimesh va in crash)
-   m_nShape = ( dExtraBox <= EPS_ZERO && IsBox() ? BOX : GENERIC) ;
+   m_nShape = ( dExtraBox > EPS_ZERO && IsBox() ? BOX : GENERIC) ;
 
   // Aggiornamento dello stato
    m_nStatus = OK ;

VolZmapGraphics.cpp

@@ -24,7 +24,6 @@
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkChainCurves.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
-#define EIGEN_NO_IO
 #include "/EgtDev/Extern/Eigen/Core"
 #include "/EgtDev/Extern/Eigen/SVD"
 #include <thread>
@@ -951,41 +950,25 @@ VolZmap::UpdateTripleMapGraphics( void) const
       }
    }
 
-  // Standard è multithread
-   constexpr bool MULTITHREAD = true ;
-   if ( MULTITHREAD) {
-
-     // Calcolo i triangoli sui blocchi
-      int nBlockUpdated = 0 ;
-      vector< future<bool>> vRes ;
-      vRes.resize( m_nNumBlock) ;
-      for ( int i = 0 ; i < m_nNumBlock ; ++ i) {
-        // Se il blocco deve essere processato
-         if ( m_BlockToUpdate[i]) {
-           // processo ...
-            ++ nBlockUpdated ;
-            vRes[i] = async( launch::async, &VolZmap::ExtMarchingCubes, this, i, ref( vVoxContainerVec[i])) ;
-         }
-      }
-      bool bOk = true ;
-      int nTerminated = 0 ;
-      while ( nTerminated < nBlockUpdated) {
-         for ( int i = 0 ; i < m_nNumBlock ; ++ i) {
-            if ( m_BlockToUpdate[i]  &&  vRes[i].valid()  &&  vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
-               bOk = vRes[i].get()  &&  bOk ;
-               ++ nTerminated ;
-            }
-         }
+  // Calcolo i triangoli sui blocchi
+   int nBlockUpdated = 0 ;
+   vector< future<bool>> vRes ;
+   vRes.resize( m_nNumBlock) ;
+   for ( int i = 0 ; i < m_nNumBlock ; ++ i) {
+     // Se il blocco deve essere processato
+      if ( m_BlockToUpdate[i]) {
+        // processo ...
+         ++ nBlockUpdated ;
+         vRes[i] = async( launch::async, &VolZmap::ExtMarchingCubes, this, i, ref( vVoxContainerVec[i])) ;
       }
    }
-   else {
-     // Calcolo i triangoli sui blocchi
-      bool bOk = true ;
+   bool bOk = true ;
+   int nTerminated = 0 ;
+   while ( nTerminated < nBlockUpdated) {
       for ( int i = 0 ; i < m_nNumBlock ; ++ i) {
-        // Se il blocco deve essere processato
-         if ( m_BlockToUpdate[i]) {
-           // processo ...
-            bOk = ExtMarchingCubes( i, vVoxContainerVec[i]) && bOk ;
+         if ( m_BlockToUpdate[i]  &&  vRes[i].valid()  &&  vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
+            bOk = vRes[i].get()  &&  bOk ;
+            ++ nTerminated ;
          }
       }
    }

Voronoi.cpp

@@ -21,7 +21,6 @@
 #include "Voronoi.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkChainCurves.h"
-#include "/EgtDev/Extern/vroni/Include/vroni_object.h"
 
 using namespace std ;
 

Voronoi.h

@@ -19,17 +19,17 @@
 #include "/EgtDev/Include/EGkCurveBezier.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
+#include "/EgtDev/Extern/vroni/Include/vroni_object.h"
 
 //----------------------------------------------------------------------------
-static constexpr bool USE_VORONOI = true ;
-static constexpr int VORONOI_STD_BOUND = 3 ;
-static constexpr double VRONI_OFFS_TOL = 1e-9 ;
-static constexpr double VRONI_JUNCTION_OPEN = 1.0 ;
-static constexpr double VRONI_JUNCTION_CLOSED = 2.0 ;
+static const bool USE_VORONOI = true ;
+static const int VORONOI_STD_BOUND = 3 ;
+static const double VRONI_OFFS_TOL = 1e-9 ;
+static const double VRONI_JUNCTION_OPEN = 1.0 ;
+static const double VRONI_JUNCTION_CLOSED = 2.0 ;
 
 //-------------------------- Forward Definitions -------------------------------
 class ISurfFlatRegion ;
-class vroniObject ;
 
 //----------------------------------------------------------------------------
 class Voronoi