EgtGeomKernel :

- nuova versione dell'intersezione linea-linea che richiede revisioni anche delle intersezioni arco-linea e arco-arco.

CDeClosedSurfTmClosedSurfTm.cpp

@@ -1,13 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2026
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : CDeClosedSurfTmClosedSurfTm.h    Data : 23.01.26  Versione : 3.1a3 
+// File : CDeClosedSurfTmClosedSurfTm.h    Data : 24.03.24  Versione : 2.6c2 
 // Contenuto : Implementazione funzione verifica collisione tra
 //             SurfTm e SurfTm.
 //
 // Modifiche : 13.11.20 LM Creazione modulo.
 //             24.03.24 DS Aggiunta TestSurfTmSurfTm.
-//             23.01.26 DS In TestSurfTmSurfTm aggiunto flag per collisione quando una delle due è chiusa e contiene l'altra.
 //
 //----------------------------------------------------------------------------
 
@@ -46,10 +45,10 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
    BBox3d b3BoxA, b3BoxB ;
    pSrfA->GetLocalBBox( b3BoxA) ;
    pSrfB->GetLocalBBox( b3BoxB) ;
-  // Se è necessario, espando il box di B di una costante additiva pari alla distanza di sicurezza.
+  // Se è necessario, espando il box di B di una costante additiva pari alla distanza di sicurezza.
    if ( dSafeDist > EPS_SMALL)
       b3BoxB.Expand( dSafeDist) ;
-  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
+  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
    if ( ! b3BoxA.Overlaps( b3BoxB))
       return false ;
   // Recupero i triangoli di A che interferiscono col box di B
@@ -62,13 +61,13 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
          continue ;
       BBox3d b3BoxTriaA ;
       trTriaA.GetLocalBBox( b3BoxTriaA) ;
-     // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
+     // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
       if ( dSafeDist > EPS_SMALL)
          b3BoxTriaA.Expand( dSafeDist) ;
      // Recupero i triangoli di B che interferiscono col box del triangolo di A
       INTVECTOR vNearTria ;
       pSrfB->GetAllTriaOverlapBox( b3BoxTriaA, vNearTria) ;
-     // Settare tutti i triangoli come già processati.
+     // Settare tutti i triangoli come già processati.
      // Al termine della chiamata i TempInt dei triangoli valgono 0.
       pSrfB->ResetTempInts() ;
      // Ciclo sui triangoli della superficie B che cadono nel box del triangolo corrente della Superficie A.
@@ -85,14 +84,14 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
            // Ciclo sui vertici del triangolo.
             for ( int nVB = 0 ; nVB < 3 ; ++ nVB) {
               // Se il triangolo adiacente al triangolo corrente su questo edge
-              // non è stato processato, processo il vertice e l'edge.
+              // non è stato processato, processo il vertice e l'edge.
                int nAdjTriaTempFlag ;
                if ( ! ( pSrfB->GetTempInt( nAdjTriaId[nVB], nAdjTriaTempFlag)  ||  nAdjTriaTempFlag == 0))
                   continue ;
-              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
+              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
                if ( CDeSimpleSpheTria( trTriaB.GetP( nVB), dSafeDist, trTriaA))
                   return true ;
-              // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
+              // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
                Vector3d vtEdgeV = trTriaB.GetP( ( nVB + 1) % 3) - trTriaB.GetP( nVB) ;
                double dEdgeLen = vtEdgeV.Len() ;
                vtEdgeV /= dEdgeLen ;
@@ -112,10 +111,10 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
       }
    }
   // Non ho trovato collisioni fra triangoli delle superfici.
-  // Se il BBox della prima superficie non è interno a quello della seconda e viceversa, non c'è collisione
+  // Se il BBox della prima superficie non è interno a quello della seconda e viceversa, non c'è collisione
    if ( ! b3BoxA.Encloses( b3BoxB)  &&  ! b3BoxB.Encloses( b3BoxA))
       return false ;
-  // La collisione c'è se una superficie è dentro l'altra.
+  // La collisione c'è se una superficie è dentro l'altra.
    Point3d ptPointA, ptPointB ;
    pSrfA->GetFirstVertex( ptPointA) ;
    pSrfB->GetFirstVertex( ptPointB) ;
@@ -128,7 +127,7 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
 // Verifica l'interferenza tra le due superfici : restituisce true in caso di interferenza.
 //----------------------------------------------------------------------------
 bool
-TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist, bool bTestEnclosion)
+TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist)
 {
   // Recupero le superfici base
    const SurfTriMesh* pSrfA = GetBasicSurfTriMesh( &SurfA) ;
@@ -141,10 +140,10 @@ TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double d
    BBox3d b3BoxA, b3BoxB ;
    pSrfA->GetLocalBBox( b3BoxA) ;
    pSrfB->GetLocalBBox( b3BoxB) ;
-  // Se è necessario, espando il box di B di una costante additiva pari alla distanza di sicurezza.
+  // Se è necessario, espando il box di B di una costante additiva pari alla distanza di sicurezza.
    if ( dSafeDist > EPS_SMALL)
       b3BoxB.Expand( dSafeDist) ;
-  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
+  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
    if ( ! b3BoxA.Overlaps( b3BoxB))
       return false ;
   // Recupero i triangoli di A che interferiscono col box di B
@@ -157,13 +156,13 @@ TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double d
          continue ;
       BBox3d b3BoxTriaA ;
       trTriaA.GetLocalBBox( b3BoxTriaA) ;
-     // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
+     // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
       if ( dSafeDist > EPS_SMALL)
          b3BoxTriaA.Expand( dSafeDist) ;
      // Recupero i triangoli di B che interferiscono col box del triangolo di A
       INTVECTOR vNearTria ;
       pSrfB->GetAllTriaOverlapBox( b3BoxTriaA, vNearTria) ;
-     // Settare tutti i triangoli come già processati.
+     // Settare tutti i triangoli come già processati.
      // Al termine della chiamata i TempInt dei triangoli valgono 0.
       pSrfB->ResetTempInts() ;
      // Ciclo sui triangoli della superficie B che cadono nel box del triangolo corrente della Superficie A.
@@ -180,14 +179,14 @@ TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double d
            // Ciclo sui vertici del triangolo.
             for ( int nVB = 0 ; nVB < 3 ; ++ nVB) {
               // Se il triangolo adiacente al triangolo corrente su questo edge
-              // non è stato processato, processo il vertice e l'edge.
+              // non è stato processato, processo il vertice e l'edge.
                int nAdjTriaTempFlag ;
                if ( ! ( pSrfB->GetTempInt( nAdjTriaId[nVB], nAdjTriaTempFlag)  ||  nAdjTriaTempFlag == 0))
                   continue ;
-              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
+              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
                if ( CDeSimpleSpheTria( trTriaB.GetP( nVB), dSafeDist, trTriaA))
                   return true ;
-              // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
+              // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
                Vector3d vtEdgeV = trTriaB.GetP( ( nVB + 1) % 3) - trTriaB.GetP( nVB) ;
                double dEdgeLen = vtEdgeV.Len() ;
                vtEdgeV /= dEdgeLen ;
@@ -206,25 +205,6 @@ TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double d
          pSrfB->SetTempInt( nTB, 1) ;
       }
    }
-  // Se non richiesto test di inclusione, non c'è interferenza
-   if ( ! bTestEnclosion)
-      return false ;
-  // Se la prima superficie è chiusa, verifico se include totalmente la seconda
-   if ( pSrfA->IsClosed()  &&  b3BoxA.Encloses( b3BoxB)) {
-      Point3d ptPointB ;
-      pSrfB->GetFirstVertex( ptPointB) ;
-      DistPointSurfTm DistPoinBSrfA( ptPointB, *pSrfA) ;
-      if ( DistPoinBSrfA.IsPointInside()  ||  DistPoinBSrfA.IsEpsilon( dSafeDist))
-         return true ;
-   }
-  // Se la seconda superficie è chiusa, verifico se include totalmente la prima
-   if ( pSrfB->IsClosed()  &&  b3BoxB.Encloses( b3BoxA)) {
-      Point3d ptPointA ;
-      pSrfA->GetFirstVertex( ptPointA) ;
-      DistPointSurfTm DistPoinASrfB( ptPointA, *pSrfB) ;
-      if ( DistPoinASrfB.IsPointInside()  ||  DistPoinASrfB.IsEpsilon( dSafeDist))
-         return true ;
-   }
-  // Non c'è interferenza
+  // Non c'è interferenza
    return false ;
 }

CalcDerivate.cpp

@@ -1,233 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2026
-//----------------------------------------------------------------------------
-// File : CalcDerivate.cpp   Data : 03.02.26       Versione : 1.5h1
-// Contenuto : Funzioni per calcolo derivate secondo Bessel e Akima.
-//
-//
-//
-// Modifiche : 03.02.26 DB Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "stdafx.h"
-#include "CalcDerivate.h"
-#include "/EgtDev/Include/EGkPoint3d.h"
-#include "/EgtDev/Include/EgtNumCollection.h"
-#include "/EgtDev/Include/EGkGeoCollection.h"
-
-//----------------------------------------------------------------------------
-bool
-ComputeAkimaTangents( bool bDetectCorner, const DBLVECTOR& vPar, const PNTVECTOR& vPnt, VCT3DVECTOR& vPrevDer, VCT3DVECTOR& vNextDer)
-{
-  // pulisco i vettori dei parametri e delle tangenti
-   vPrevDer.clear() ;
-   vNextDer.clear() ;
-
-  // numero di punti
-   int nSize = int( vPnt.size()) ;
-
-  // sono necessari almeno due punti
-   if ( nSize < 2)
-      return false ;
-
-  // calcolo le derivate
-   vPrevDer.reserve( nSize) ;
-   vNextDer.reserve( nSize) ;
-  // se ci sono solo 2 punti, le tangenti devono essere dirette lungo la linea che li unisce
-   if ( nSize == 2) {
-     // non esiste derivata prima del primo punto
-      vPrevDer.emplace_back( 0, 0, 0) ;
-      vNextDer.push_back( ( vPnt[1] - vPnt[0]) / ( vPar[1] - vPar[0])) ;
-      vPrevDer.push_back( vNextDer[0]) ;
-     // non esiste derivata dopo il secondo e ultimo punto
-      vNextDer.emplace_back( 0, 0, 0) ;
-      return true ;
-   }
-  // verifico se curva chiusa (primo e ultimo punto coincidono)
-   bool bClosed = AreSamePointApprox( vPnt.front(), vPnt.back()) ;
-  // calcolo le derivate
-   for ( int i = 0 ; i < nSize ; ++ i) {
-      Vector3d vtPrevDer ;
-      Vector3d vtNextDer ;
-     // primo punto
-      if ( i == 0) {
-        // se curva chiusa, come precedente uso il penultimo punto
-         if ( bClosed) {
-           // se non ci sono almeno 5 punti
-            if ( nSize < 5) {
-               if ( ! CalcCircleMidDer( vPar[nSize-2] - vPar[nSize-1], vPnt[nSize-2], vPar[i], vPnt[i],
-                                        vPar[i+1], vPnt[i+1], vtNextDer))
-                  return false ;
-               vtPrevDer = vtNextDer ;
-            }
-           // altrimenti
-            else {
-               if ( ! CalcAkimaMidDer( vPar[nSize-3] - vPar[nSize-1], vPnt[nSize-3], vPar[nSize-2] - vPar[nSize-1], vPnt[nSize-2],
-                                       vPar[i], vPnt[i], vPar[i+1], vPnt[i+1],
-                                       vPar[i+2], vPnt[i+2], bDetectCorner,
-                                       vtPrevDer, vtNextDer))
-                  return false ;
-            }
-         }
-        // altrimenti, uso arco sui primi tre punti
-         else {
-            if ( ! CalcCircleStartDer( vPar[i], vPnt[i], vPar[i+1], vPnt[i+1],
-                                       vPar[i+2], vPnt[i+2], vtNextDer))
-               return false ;
-            vtPrevDer = Vector3d( 0, 0, 0) ;
-         }
-      }
-     // ultimo punto
-      else if ( i == nSize - 1) {
-        // se curva chiusa, le tg devono coincidere con quelle del primo
-         if ( bClosed) {
-            vtPrevDer = vPrevDer[0] ;
-            vtNextDer = vNextDer[0] ;
-         }
-        // altrimenti, uso arco sugli ultimi tre punti
-         else {
-            if ( ! CalcCircleEndDer( vPar[i-2], vPnt[i-2], vPar[i-1], vPnt[i-1],
-                                       vPar[i], vPnt[i], vtPrevDer))
-               return false ;
-            vtNextDer = Vector3d( 0, 0, 0) ;
-         }
-      }
-     // punti intermedi
-      else {
-        // se secondo punto
-         if ( i == 1) {
-           // se curva aperta o non ci sono almeno 5 punti
-            if ( ! bClosed  ||  nSize < 5) {
-               if ( ! CalcCircleMidDer( vPar[i-1], vPnt[i-1], vPar[i], vPnt[i],
-                                        vPar[i+1], vPnt[i+1], vtPrevDer))
-                  return false ;
-               vtNextDer = vtPrevDer ;
-            }
-           // altrimenti
-            else {
-               if ( ! CalcAkimaMidDer( vPar[nSize-2] - vPar[nSize-1], vPnt[nSize-2], vPar[i-1], vPnt[i-1],
-                                       vPar[i], vPnt[i], vPar[i+1], vPnt[i+1],
-                                       vPar[i+2], vPnt[i+2], bDetectCorner,
-                                       vtPrevDer, vtNextDer))
-                  return false ;
-            }
-         }
-        // se penultimo punto
-         else if ( i == nSize - 2) {
-           // se curva aperta o non ci sono almeno 5 punti
-            if ( ! bClosed  ||  nSize < 5) {
-               if ( ! CalcCircleMidDer( vPar[i-1], vPnt[i-1], vPar[i], vPnt[i],
-                                        vPar[i+1], vPnt[i+1], vtPrevDer))
-                  return false ;
-               vtNextDer = vtPrevDer ;
-            }
-           // altrimenti
-            else {
-               if ( ! CalcAkimaMidDer( vPar[i-2], vPnt[i-2], vPar[i-1], vPnt[i-1],
-                                       vPar[i], vPnt[i], vPar[i+1], vPnt[i+1],
-                                       vPar[1] + vPar[i+1], vPnt[1], bDetectCorner,
-                                       vtPrevDer, vtNextDer))
-                  return false ;
-            }
-         }
-        // altrimenti
-         else {
-            if ( ! CalcAkimaMidDer( vPar[i-2], vPnt[i-2], vPar[i-1], vPnt[i-1],
-                                    vPar[i], vPnt[i], vPar[i+1], vPnt[i+1],
-                                    vPar[i+2], vPnt[i+2], bDetectCorner,
-                                    vtPrevDer, vtNextDer))
-               return false ;
-         }
-      }
-     // salvo la derivata
-      vPrevDer.push_back( vtPrevDer) ;
-      vNextDer.push_back( vtNextDer) ;
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ComputeBesselTangents( const DBLVECTOR& vPar, const PNTVECTOR& vPnt, VCT3DVECTOR& vPrevDer, VCT3DVECTOR& vNextDer)
-{
-  // pulisco i vettori dei parametri e delle tangenti
-   vPrevDer.clear() ;
-   vNextDer.clear() ;
-
-  // numero di punti
-   int nSize = int( vPnt.size()) ;
-
-  // sono necessari almeno due punti
-   if ( nSize < 2)
-      return false ;
-
-  // calcolo le derivate
-   vPrevDer.reserve( nSize) ;
-   vNextDer.reserve( nSize) ;
-  // se ci sono solo 2 punti, le tangenti devono essere dirette lungo la linea che li unisce
-   if ( nSize == 2) {
-     // non esiste derivata prima del primo punto
-      vPrevDer.emplace_back( 0, 0, 0) ;
-      vNextDer.push_back( ( vPnt[1] - vPnt[0]) / ( vPar[1] - vPar[0])) ;
-      vPrevDer.push_back( vNextDer[0]) ;
-     // non esiste derivata dopo il secondo e ultimo punto
-      vNextDer.emplace_back( 0, 0, 0) ;
-      return true ;
-   }
-  // verifico se curva chiusa (primo e ultimo punto coincidono)
-   bool bClosed = AreSamePointApprox( vPnt.front(), vPnt.back()) ;
-  // calcolo le derivate
-   for ( int i = 0 ; i < nSize ; ++ i) {
-      Vector3d vtPrevDer ;
-      Vector3d vtNextDer ;
-     // primo punto
-      if ( i == 0) {
-        // se curva chiusa, come precedente uso il penultimo punto
-         if ( bClosed) {
-            if ( ! CalcBesselMidDer( vPar[nSize-2] - vPar[nSize-1], vPnt[nSize-2], vPar[i], vPnt[i],
-                                     vPar[i+1], vPnt[i+1], vtNextDer))
-               return false ;
-            vtPrevDer = vtNextDer ;
-         }
-        // altrimenti, uso i primi tre punti
-         else {
-            if ( ! CalcBesselStartDer( vPar[i], vPnt[i], vPar[i+1], vPnt[i+1],
-                                       vPar[i+2], vPnt[i+2], vtNextDer))
-               return false ;
-            vtPrevDer = Vector3d( 0, 0, 0) ;
-         }
-      }
-     // ultimo punto
-      else if ( i == nSize - 1) {
-        // se curva chiusa, le tg devono coincidere con quelle del primo
-         if ( bClosed) {
-            vtPrevDer = vPrevDer[0] ;
-            vtNextDer = vNextDer[0] ;
-         }
-        // altrimenti, uso gli ultimi tre punti
-         else {
-            if ( ! CalcBesselEndDer( vPar[i-2], vPnt[i-2], vPar[i-1], vPnt[i-1],
-                                     vPar[i], vPnt[i], vtPrevDer))
-               return false ;
-            vtNextDer = Vector3d( 0, 0, 0) ;
-         }
-      }
-     // punti intermedi
-      else {
-         if ( ! CalcBesselMidDer( vPar[i-1], vPnt[i-1], vPar[i], vPnt[i],
-                                  vPar[i+1], vPnt[i+1], vtPrevDer))
-            return false ;
-         vtNextDer = vtPrevDer ;
-      }
-     // salvo la derivata
-      vPrevDer.push_back( vtPrevDer) ;
-      vNextDer.push_back( vtNextDer) ;
-   }
-
-   return true ;
-}

CalcDerivate.h

@@ -14,8 +14,6 @@
 #pragma once
 
 #include "/EgtDev/Include/EGkPoint3d.h"
-#include "/EgtDev/Include/EgtNumCollection.h"
-#include "/EgtDev/Include/EGkGeoCollection.h"
 
 
 //----------------------------------------------------------------------------
@@ -181,6 +179,3 @@ CalcAkimaMidDer( double dU0, const Point3d& ptP0, double dU1, const Point3d& ptP
    }
    return ( ! vtPrevDer.IsZero()  &&  ! vtNextDer.IsZero()) ;
 }
-
-bool ComputeAkimaTangents( bool bDetectCorner, const DBLVECTOR& vPar, const PNTVECTOR& vPnt, VCT3DVECTOR& vPrevDer, VCT3DVECTOR& vNextDer) ;
-bool ComputeBesselTangents( const DBLVECTOR& vPar, const PNTVECTOR& vPnt, VCT3DVECTOR& vPrevDer, VCT3DVECTOR& vNextDer) ;

CalcPocketing.cpp

@@ -722,7 +722,7 @@ AssignFeedSpiral( ICurveComposite* pCrv, const ISurfFlatRegion* pSrfRemoved, boo
 
 //----------------------------------------------------------------------------
 static bool
-AssignFeedSpiralOpt( int nOptType, const PocketParams& PockParams, ICurveComposite* pCrv )
+AssignFeedSpiralOpt( const int nOptType, const PocketParams& PockParams, ICurveComposite* pCrv )
 {
   // controllo della curva corrente
    if ( pCrv == nullptr  ||  ! pCrv->IsValid()  ||  pCrv->GetCurveCount() == 0)
@@ -732,24 +732,24 @@ AssignFeedSpiralOpt( int nOptType, const PocketParams& PockParams, ICurveComposi
    if ( ! PockParams.bCalcFeed)
       return AssignMaxFeed( pCrv, PockParams) ;
 
-   if ( PockParams.nType == POCKET_SPIRALIN  ||  PockParams.nType == POCKET_CONFORMAL_ZIGZAG  ||
-        PockParams.nType == POCKET_CONFORMAL_ONEWAY) {
-      if ( nOptType == 0) { // Spirale dall'Esterno
-         for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u) {
-            if ( u == 0) // prima circonferenza
-               pCrv->SetCurveTempParam( 0, GetMinFeed( PockParams), 0) ;
-            else // semi cerchi in tangenza
-               pCrv->SetCurveTempParam( u, GetMaxFeed( PockParams), 0) ;
+   switch ( PockParams.nType) {
+      case POCKET_SPIRALIN :
+         if ( nOptType == 0) { // Spirale dall'Esterno
+            for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u) {
+               if ( u == 0) // prima circonferenza
+                  pCrv->SetCurveTempParam( 0, GetMinFeed( PockParams), 0) ;
+               else // semi cerchi in tangenza
+                  pCrv->SetCurveTempParam( u, GetMaxFeed( PockParams), 0) ;
+            }
          }
-      }
-      else if ( nOptType == 1) { // Trapezoidi
-         for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u)
-            pCrv->SetCurveTempParam( u, GetMinFeed( PockParams), 0) ;
-      }
-   }
+         else if ( nOptType == 1) { // Trapezoidi
+            for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u)
+               pCrv->SetCurveTempParam( u, GetMinFeed( PockParams), 0) ;
+         }
+      break ;
    /* NB. Essendo la funzione CalcSpiral richiamata sia per lo SpiralIN che per lo SpiralOUT le curve sono sempre
    orientate nello stesso modo, solamente alla fine viene invertita la curva finale per la svuotatura... */
-   else {
+   case POCKET_SPIRALOUT :
       if ( nOptType == 0) { // Spiral verso l'esterno
          for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u) {
             if ( u > pCrv->GetCurveCount() - 3) // prime semi circonferenze
@@ -762,6 +762,9 @@ AssignFeedSpiralOpt( int nOptType, const PocketParams& PockParams, ICurveComposi
          for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u)
             pCrv->SetCurveTempParam( u, GetMinFeed( PockParams), 0) ;
       }
+      break ;
+   default :
+      break ;
    }
 
    return true ;
@@ -1058,9 +1061,9 @@ ExtendPath( ICurveComposite* pCompo, const ISurfFlatRegion* pSfr, const PocketPa
       bool bInside = true ;
       bool bOkOut = true ;
       if ( PockParams.SfrLimit.IsValid()) {
-         bOkOut = ( IsPointInsideSurfFr( ptFall, &PockParams.SfrLimit, dMinDist - 10. * EPS_SMALL, bInside)  &&  ! bInside) ;
+         bOkOut = ( IsPointInsideSurfFr( ptFall, &PockParams.SfrLimit, dMinDist, bInside)  &&  ! bInside) ;
          if ( bOkOut)
-            bOkOut = ( IsPointInsideSurfFr( Media( ptFall, pt), &PockParams.SfrLimit, dMinDist - 10. * EPS_SMALL, bInside)  &&  ! bInside) ;
+            bOkOut = ( IsPointInsideSurfFr( Media( ptFall, pt), &PockParams.SfrLimit, dMinDist, bInside)  &&  ! bInside) ;
       }
       if ( bOkOut)
          bOkOut = ( IsPointInsideSurfFr( ptFall, pSfr, dMinDist, bInside)  &&  ! bInside) ;
@@ -2635,87 +2638,6 @@ PreparareTrapezoidTwoBases( const ICurveComposite* pCrvCompo, const double dDiam
    return true ;
 }
 
-//----------------------------------------------------------------------------
-static bool
-IsForcedStepTrapezoid( const ICurveComposite* pCrvTrap, const PocketParams& PockParam,
-                       int nBase, int nSecondBase, bool& bForced)
-{
-   bForced = false ;
-  // se la curva non è valida, allora non può essere forzato
-   if ( pCrvTrap == nullptr  ||  ! pCrvTrap->IsValid())
-      return false ;
-
-  // scorro la curva e ricavo le TempProps
-   array<int, 4> vnProps ;
-   int nClose = 0 ;
-   for ( int i = 0 ; i < 4 ; ++ i) {
-      if ( ! pCrvTrap->GetCurveTempProp( i, vnProps[i], 0))
-         return false ;
-      if ( vnProps[i] == TEMP_PROP_CLOSE_EDGE)
-         ++ nClose ;
-   }
-
-   double dDiam = 2. * PockParam.dRad ;
-   switch ( nClose) {
-  // se trapezio tutto aperto, allora non è forzato
-   case 0 :
-      bForced = false ;
-   break ;
-  // se ho un lato chiuso, non è forzato
-   case 1 :
-      bForced = false ;
-   break ;
-  // se ho due lati chiusi
-   case 2 : {
-      if ( nBase < 0  ||  nBase > 4  ||  nSecondBase < 0  ||  nSecondBase > 4)
-         return false ;
-     // se entrambe le basi sono chiuse, è forzato
-      if ( vnProps[nBase] == TEMP_PROP_CLOSE_EDGE  &&  vnProps[nSecondBase] == TEMP_PROP_CLOSE_EDGE)
-         bForced = true ;
-     // se entrambe le basi sono aperte
-      else if ( vnProps[nBase] == TEMP_PROP_OPEN_EDGE  &&  vnProps[nSecondBase] == TEMP_PROP_OPEN_EDGE) {
-         const ICurve* pCrvOpenBase = pCrvTrap->GetCurve( nBase) ;
-         const ICurve* pCrvOpenSecondBase = pCrvTrap->GetCurve( nSecondBase) ;
-         if ( pCrvOpenBase == nullptr  ||  ! pCrvOpenBase->IsValid()  ||
-              pCrvOpenSecondBase == nullptr  ||  ! pCrvOpenSecondBase->IsValid())
-            return false ;
-         double dLenOpenBase ; pCrvOpenBase->GetLength( dLenOpenBase) ;
-         double dLenSecondOpenBase ; pCrvOpenSecondBase->GetLength( dLenSecondOpenBase) ;
-         bForced = ( dLenOpenBase < dDiam + 10. * EPS_SMALL  &&
-                     dLenSecondOpenBase < dDiam + 10. * EPS_SMALL) ;
-      }
-     // se alternate, non forzo
-      else
-         bForced = false ;
-   }
-   break ;
-  // se ho tre lati chiusi
-   case 3 : {
-     // diventa forzato se il lato aperto non è grande
-      double dLenOpen = 0. ;
-      for ( int i = 0 ; i < 4 ; ++ i) {
-         if ( vnProps[i] == TEMP_PROP_OPEN_EDGE) {
-            const ICurve* pCrvOpen = pCrvTrap->GetCurve( i) ;
-            if ( pCrvOpen == nullptr  ||  ! pCrvOpen->IsValid())
-               return false ;
-            pCrvOpen->GetLength( dLenOpen) ;
-            break ;
-         }
-      }
-      bForced = ( dLenOpen < dDiam + 10. * EPS_SMALL) ;
-   }
-   break ;
-  // se tutto chiuso, è forzato
-   case 4 :
-      bForced = true ;
-   break ;
-   default :
-      return false ;
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 static bool
 GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, ICurveComposite* pCrvTrap,
@@ -3118,12 +3040,8 @@ GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, ICurveComposite* pCrvTr
       return false ;
 
   // se parametro MaxOptSize non compatibile => non è ottimizzato
-   bool bForced = false ;
-   IsForcedStepTrapezoid( pCrvTrap, PockParams, nBase, nSecondBase, bForced) ;
-   if ( ! bForced) {
-      if ( PockParams.dMaxOptSize > EPS_SMALL  &&  dPocketSize > PockParams.dMaxOptSize)
-         pCrvTrap->Clear() ;
-   }
+   if ( PockParams.dMaxOptSize > EPS_SMALL  &&  dPocketSize > PockParams.dMaxOptSize)
+      pCrvTrap->Clear() ;
 
    return true ;
 }
@@ -3526,18 +3444,18 @@ CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Frame3d& frTrap, double
       Vector3d vtX ; pCrvPocket->GetCurve( 1)->GetStartDir( vtX) ;
       Frame3d frDim ; frDim.Set( ptOrig, Z_AX, vtX) ; frDim.Invert() ;
       BBox3d b3Dim ; pCrvPocket->GetBBox( frDim, b3Dim, BBF_EXACT) ;
-      dMaxLarg = ( vnProp[0] != TEMP_PROP_CLOSE_EDGE ? b3Dim.GetDimY() : dPocketSize) ;
+      dMaxLarg = ( vnProp[0] != 0 ? b3Dim.GetDimY() : dPocketSize) ;
    }
 
   // calcolo percorso di svuotatura 
   // se lati obliqui sono entrambi chiusi e dimensione svuotatura è maggiore di diametro fresa e minore del doppio gestione speciale
-   if ( ( bRealTrap  &&  dMaxLarg > dDiam + 10. * EPS_SMALL)  &&
+   if ( ( bRealTrap  &&  dMaxLarg > PockParams.dRad * 2 + 10 * EPS_SMALL)  &&
         ( ( ( vnProp[0] != TEMP_PROP_CLOSE_EDGE  &&  vnProp[2] != TEMP_PROP_CLOSE_EDGE)  &&
             ( vnProp[3] == TEMP_PROP_CLOSE_EDGE  &&  vnProp[1] == TEMP_PROP_CLOSE_EDGE)  &&
-            ( max( dLen0, dLen2) < 2. * dDiam + EPS_SMALL))  ||
+            ( max( dLen0, dLen2) < 2 * dDiam + EPS_SMALL))  ||
           ( ( vnProp[1] != TEMP_PROP_CLOSE_EDGE  &&  vnProp[3] != TEMP_PROP_CLOSE_EDGE)  &&
             ( vnProp[0] == TEMP_PROP_CLOSE_EDGE  &&  vnProp[2] == TEMP_PROP_CLOSE_EDGE)  &&
-            ( max( dLen0, dLen2) < 2. * dDiam + EPS_SMALL)))) {
+            ( max( dLen1, dLen3) < 2 * dDiam + EPS_SMALL)))) {
       if ( ! SpecialAdjustTrapezoidSpiralForAngles( pMCrv, ( vnProp[0] == TEMP_PROP_CLOSE_EDGE), pCrvPocket, PockParams, ptRef)) {
          pMCrv->Clear() ;
          return false ;
@@ -3690,8 +3608,14 @@ CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Frame3d& frTrap, double
 
    if ( pMCrv->GetCurveCount() == 0)
       return true ;
+
    pMCrv->ToGlob( frTrap) ;
 
+   if ( PockParams.bInvert) {
+      pMCrv->Invert() ;
+     // inverto le proprietà in modo che nProp3 sia sempre legata al punto iniziale e nProp1 a quello finale
+      swap( vnProp[1], vnProp[3]) ;
+   }
   // segno i lati aperti come temp prop della curva
    int nOpenEdges = vnProp[0] + vnProp[1] * 2 + vnProp[2] * 4 + vnProp[3] * 8 ;
    pMCrv->SetTempProp( nOpenEdges, 0) ;
@@ -3701,112 +3625,6 @@ CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Frame3d& frTrap, double
    return true ;
 }
 
-//----------------------------------------------------------------------------
-static bool
-AdjustTrapeziodLeadIn( ICurveComposite* pCrvRes, const PocketParams& PockParam,
-                       const ISurfFlatRegion* pSfrChunk)
-{
-  // recupero la TempProp
-   int nTmpProp = pCrvRes->GetTempProp( 0) ;
-  // se esiste almeno un aperto
-   if ( nTmpProp > 0) {
-     // se solo lato3 aperto
-      bool bCheckHead = ( nTmpProp != 8  &&  nTmpProp != 2) ;
-      if ( nTmpProp == 2)
-         pCrvRes->Invert() ; // entro dall'unico aperto
-      if ( bCheckHead) {
-        // recupero gli estremi della curva corrente e la inverto in base alla Testa
-         Point3d ptS ; pCrvRes->GetStartPoint( ptS) ;
-         Point3d ptE ; pCrvRes->GetEndPoint( ptE) ;
-         Point3d ptSGlob = GetToGlob( ptS, PockParam.frLocXY) ;
-         Point3d ptEGlob = GetToGlob( ptE, PockParam.frLocXY) ;
-         if ( ( PockParam.bAboveHead  &&  ptEGlob.z > ptSGlob.z)  ||
-              ( ! PockParam.bAboveHead  &&  ptEGlob.z < ptSGlob.z))
-            pCrvRes->Invert() ;
-      }
-   }
-
-  // Assegno la Feed
-      AssignFeedSpiralOpt( 1, PockParam, pCrvRes) ;
-  // Se curva da invertire, inverto
-   if ( PockParam.bInvert)
-      pCrvRes->Invert() ;
-
-  // se esiste almeno un aperto, provo ad estendere il percorso
-   if ( nTmpProp > 0) {
-     // Calcolo eventuale entrata da fuori
-      Vector3d vtRef ; pCrvRes->GetStartDir( vtRef) ;
-      vtRef.Invert() ;
-      bool bIsStartExtended = false ;
-      if ( ! ExtendPath( pCrvRes, pSfrChunk, PockParam, vtRef, false, PockParam.dRad + PockParam.dOpenMinSafe, bIsStartExtended))
-         return false ;
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-GetZigZagOptimizedCurves( const ISurfFlatRegion* pSfrChunk, const PocketParams& PockParam,
-                          ICurveComposite* pCrvRes)
-{
-  // controllo dei parametri
-   if ( pSfrChunk == nullptr  ||  ! pSfrChunk->IsValid())
-      return false ;
-   pCrvRes->Clear() ;
-
-  // ricavo la curva di bordo del chunk corrente
-   PtrOwner<ICurveComposite> pCrvBorder( ConvertCurveToComposite( pSfrChunk->GetLoop( 0, 0))) ;
-   if ( IsNull( pCrvBorder)  ||  ! pCrvBorder->IsValid())
-      return false ;
-   pCrvBorder->MergeCurves( 10. * EPS_SMALL, 10. * EPS_ANG_SMALL, true, true) ;
-   pCrvBorder->SetExtrusion( pSfrChunk->GetNormVersor()) ;
-
-   /* TRAPEZI
-     - E' richiesto che una dimensione del box della curva sia compatibile con il primo Offset, il
-       quale sarebbe una singola curva aperta
-  */
-   PtrOwner<ICurveComposite> pCrvTrap( CreateCurveComposite()) ;
-   if ( IsNull( pCrvTrap))
-      return false ;
-   Frame3d frTrap ;
-   double dPocketSize ;
-   int nBase, nSecondBase ;
-   bool bOkTrap = GetTrapezoidFromShape( pCrvBorder, pCrvTrap, frTrap, PockParam, dPocketSize, nBase, nSecondBase) ;
-   if ( bOkTrap  &&  pCrvTrap->IsValid()) {
-     // verifico se il trapezio ottenuto deve o meno rispettare il SideStep
-      bool bForcedTrap = false ;
-      IsForcedStepTrapezoid( pCrvTrap, PockParam, nBase, nSecondBase, bForcedTrap) ;
-      if ( ! bForcedTrap)
-         bOkTrap = ( dPocketSize < PockParam.dMaxOptSize + 10. * EPS_SMALL) ;
-   }
-   if ( bOkTrap  &&  pCrvTrap->IsValid()) {
-      pCrvTrap->SetExtrusion( Z_AX) ;
-      CalcTrapezoidSpiral( pCrvTrap, frTrap, dPocketSize, nBase, nSecondBase, PockParam, pCrvRes, bOkTrap) ;
-      if ( bOkTrap) {
-        // verifico che tale curva non interferisca con la regione limite
-         if ( PockParam.SfrLimit.IsValid()) {
-            double dOffsCheck = PockParam.dRad + PockParam.dRadialOffset - 50. * EPS_SMALL ; // restrittivo per sicurezza
-            PtrOwner<ISurfFlatRegion> pSfrToolShape( GetSurfFlatRegionFromFatCurve( pCrvRes->Clone(), dOffsCheck, false, false)) ;
-            bOkTrap = ( ! IsNull( pSfrToolShape)  &&  pSfrToolShape->IsValid()) ;
-            if ( bOkTrap) {
-               bOkTrap = ( pSfrToolShape->Intersect( PockParam.SfrLimit) &&
-                           ! pSfrToolShape->IsValid()) ;
-               if ( ! bOkTrap)
-                  pCrvRes->Clear() ;
-            }
-         }
-         if ( bOkTrap) {
-           AdjustTrapeziodLeadIn( pCrvRes, PockParam, pSfrChunk) ;
-          // imposto il flag di curva singola
-            pCrvRes->SetTempProp( TEMP_PROP_OPT_TRAPEZOID, 0) ;
-         }
-      }
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 static bool
 GetSpiralOptimizedCurves( const ISurfFlatRegion* pSfrChunk, const PocketParams& PockParam,
@@ -3855,7 +3673,7 @@ GetSpiralOptimizedCurves( const ISurfFlatRegion* pSfrChunk, const PocketParams&
                                 ssize( ccClass) == 1  &&  ccClass[0].nClass == CRVC_OUT) ;
                  // NB. una versione più complessa dovrebbe verificare se la sottrazione tra la
                  //     superficie dell'utensile e la regione limite non genera un'altra circonferenza...
-                 //     In questo caso la sottrazione potrebbe essere trattata come una circonferenza
+                 //     In questo caso si la sottrazione potrebbe essere trattata come una circonferenza
                  //     chiusa ed essere ancora svotata a spirale...
                }
             }
@@ -3896,14 +3714,8 @@ GetSpiralOptimizedCurves( const ISurfFlatRegion* pSfrChunk, const PocketParams&
    Frame3d frTrap ;
    double dPocketSize ;
    int nBase, nSecondBase ;
-   bool bOkTrap = GetTrapezoidFromShape( pCrvBorder, pCrvTrap, frTrap, PockParam, dPocketSize, nBase, nSecondBase) ;
-   if ( bOkTrap  &&  pCrvTrap->IsValid()) {
-     // verifico se il trapezio ottenuto deve o meno rispettare il SideStep
-      bool bForcedTrap = false ;
-      IsForcedStepTrapezoid( pCrvTrap, PockParam, nBase, nSecondBase, bForcedTrap) ;
-      if ( ! bForcedTrap)
-         bOkTrap = ( dPocketSize < PockParam.dMaxOptSize + 10. * EPS_SMALL) ;
-   }
+   bool bOkTrap = ( GetTrapezoidFromShape( pCrvBorder, pCrvTrap, frTrap, PockParam, dPocketSize, nBase, nSecondBase)  &&
+                    dPocketSize < PockParam.dMaxOptSize + 10. * EPS_SMALL) ;
    if ( bOkTrap  &&  pCrvTrap->IsValid()) {
       pCrvTrap->SetExtrusion( Z_AX) ;
       CalcTrapezoidSpiral( pCrvTrap, frTrap, dPocketSize, nBase, nSecondBase, PockParam, pCrvRes, bOkTrap) ;
@@ -3921,9 +3733,20 @@ GetSpiralOptimizedCurves( const ISurfFlatRegion* pSfrChunk, const PocketParams&
             }
          }
          if ( bOkTrap) {
-            AdjustTrapeziodLeadIn( pCrvRes, PockParam, pSfrChunk) ;
-           // imposto il flag di curva singola
-            pCrvRes->SetTempProp( TEMP_PROP_OPT_TRAPEZOID, 0) ;
+           // calcolo eventuali uscite e ingressi
+            if ( pCrvRes->GetTempProp( 0) > 0) {
+               Vector3d vtRef ; pCrvRes->GetStartDir( vtRef) ;
+               vtRef.Invert() ;
+               bool bIsStartExtended = false ;
+               if ( ! ExtendPath( pCrvRes, pSfrChunk, PockParam, vtRef, false, PockParam.dRad + PockParam.dOpenMinSafe, bIsStartExtended))
+                  return false ;
+               pCrvRes->GetEndDir( vtRef) ;
+               bool bIsEndExtended = false ;
+               if ( ! ExtendPath( pCrvRes, pSfrChunk, PockParam, vtRef, true, PockParam.dRad + PockParam.dOpenMinSafe, bIsEndExtended))
+                  return false ;
+               if ( bIsEndExtended  &&  ! bIsStartExtended)
+                  pCrvRes->Invert() ;
+            }
          }
       }
    }
@@ -3966,31 +3789,23 @@ GetPocketingOptimizedCurves( ISurfFlatRegion* pSfr, const PocketParams& PockPara
            PockParam.nType == POCKET_CONFORMAL_ZIGZAG  ||  PockParam.nType == POCKET_CONFORMAL_ONEWAY) {
         // curva da resituire
          PtrOwner<ICurveComposite> pCrvOptSpiral( CreateCurveComposite()) ;
-         if ( IsNull( pCrvOptSpiral)  ||
-              ! GetSpiralOptimizedCurves( pSfrChunk, PockParam, pCrvOptSpiral))
+         if (  IsNull( pCrvOptSpiral)  ||
+               ! GetSpiralOptimizedCurves( pSfrChunk, PockParam, pCrvOptSpiral))
             return false ;
         // se ho ricavato una curva ottimizzata
          if ( ! IsNull( pCrvOptSpiral)  &&  pCrvOptSpiral->IsValid()  &&  pCrvOptSpiral->GetCurveCount() > 0) {
-            vCrvOptCurves.emplace_back( Release( pCrvOptSpiral)) ;
-            pSfr->EraseChunk( nCurrChunk) ;
-         }
-         else
-            ++ nCurrChunk ;
-      }
-      else if ( PockParam.nType == POCKET_ZIGZAG  ||  PockParam.nType == POCKET_ONEWAY) {
-        // curva da restituire
-         PtrOwner<ICurveComposite> pCrvOptZigZag( CreateCurveComposite()) ;
-         if ( IsNull( pCrvOptZigZag)  ||
-              ! GetZigZagOptimizedCurves( pSfrChunk, PockParam, pCrvOptZigZag))
-            return false ;
-        // se ho ricavato una curva ottimizzata
-         if ( ! IsNull( pCrvOptZigZag)  &&  pCrvOptZigZag->IsValid()  &&  pCrvOptZigZag->GetCurveCount() > 0) {
-            vCrvOptCurves.emplace_back( Release( pCrvOptZigZag)) ;
+            vCrvOptCurves.emplace_back( Release( pCrvOptSpiral)) ; 
             pSfr->EraseChunk( nCurrChunk) ;
          }
          else
             ++ nCurrChunk ;
       }
+     // else if ( PockParam.nType == POCKET_ZIGZAG)
+     //    ;
+     // else if ( PockParam.nType == POCKET_ONEWAY)
+     //    ;
+     // else if ( PockParam.nType == POCKET_CONFORMAL_ONEWAY  ||  PockParam.nType == POCKET_CONFORMAL_ZIGZAG)
+     //    ;
    }
 
    return true ;
@@ -6229,7 +6044,6 @@ CalcSpiral( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, co
   // ricavo le regioni progressive
    double dOffsPrec = 0. ;
    int nCrvFirstOffs = 0 ;
-   bool bLastNotValid = false ;
    while ( nIter < MAX_ITER) {
      // Offset della regione attuale
       PtrOwner<ISurfFlatRegion> pSfrOffsVR( pSrfAct->CreateOffsetSurf( - dOffs, ICurve::OFF_FILLET)) ;
@@ -6240,7 +6054,6 @@ CalcSpiral( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, co
           pSfrOffsVR.Set( pSrfAct->CreateOffsetSurf( - dOffs + 5 * EPS_SMALL, ICurve::OFF_FILLET)) ;
           if ( IsNull( pSfrOffsVR))
              return false ;
-          bLastNotValid = true ;
       }
 
      // se primo Offset
@@ -6272,10 +6085,6 @@ CalcSpiral( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, co
             bool bInsert = true ;
             if ( ! CheckIfOffsetIsNecessary( pSrfAct, pCrvCompoBorder, dOffs, dOffsPrec, nIter, PockParams, bInsert))
                return false ;
-           // per evitare di allacciare una curva di regione non svuotata alla prima curva di Offset
-           // ( quindi avere un entrata nel pieno del grezzo) controllo di non eliminare il secondo Offset
-            if ( ! bInsert  &&  nChunks == 1  &&  bLastNotValid)
-                  bInsert = true ;
             if ( bInsert) {
                // imposto come secondo TempParam il Side di classificazione
                   pCrvCompoBorder->SetTempParam( j == 0 ? MDS_RIGHT : MDS_LEFT, 1) ;
@@ -9092,14 +8901,14 @@ CalcSpiralPocketing( const ISurfFlatRegion* pSfr, int nType, const PocketParams&
   // il tipo può essere solo SpiralIn o SpiralOut
    if ( nType != POCKET_SPIRALIN  &&  nType != POCKET_SPIRALOUT)
       return false ;
-   PtrOwner<ISurfFlatRegion> pSfrLimit( PockParams.SfrLimit.IsValid() ? PockParams.SfrLimit.Clone() : CreateSurfFlatRegion()) ;
   // calcolo il percorso di svuotatura spiral
    return ( CalcPocketing( pSfr, PockParams.dRad, PockParams.dRadialOffset, PockParams.dSideStep,
                            PockParams.dAngle, PockParams.dOpenMinSafe, nType, PockParams.bSmooth,
                            PockParams.bCalcUnclearedRegs, PockParams.bInvert, PockParams.bAvoidOpt,
                            PockParams.bAllowZigZagOneWayBorders, PockParams.bCalcFeed, PockParams.ptStart,
-                           pSfrLimit, PockParams.bAvoidOpt, PockParams.dMaxOptSize, PockParams.dLiTang,
-                           PockParams.nLiType, vCrvCompoRes)) ;
+                           PockParams.SfrLimit.IsValid() ? PockParams.SfrLimit.Clone() : CreateSurfFlatRegion(),
+                           PockParams.bAvoidOpt, PockParams.dMaxOptSize, PockParams.dLiTang, PockParams.nLiType,
+                           vCrvCompoRes)) ;
 }
 
 //----------------------------------------------------------------------------
@@ -9394,10 +9203,9 @@ SmoothExtensionLinesByIntersection( ICRVCOMPOPOVECTOR& vCrvPaths, const PocketPa
 //----------------------------------------------------------------------------
 bool
 CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double dStep, double dAngle,
-               double dOpenMinSafe, int nType, bool bSmooth, bool bCalcUnclReg, bool bInvert, bool bAvoidOpt,
-               bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec,
-               const ISurfFlatRegion* pSfrLimit, bool bAllOffs, double dMaxOptSize, double dLiTang,
-               int nLiType, ICRVCOMPOPOVECTOR& vCrvCompoRes)
+               double dOpenMinSafe, int nType, bool bSmooth, bool bCalcUnclReg, bool bInvert, bool bAvoidOpt, bool bAllowZigZagOneWayBorders,
+               bool bCalcFeed, const Point3d& ptEndPrec, const ISurfFlatRegion* pSfrLimit, bool bAllOffs,
+               double dMaxOptSize, double dLiTang, int nLiType, ICRVCOMPOPOVECTOR& vCrvCompoRes)
 {
   // controllo dei parametri
    if ( pSfr == nullptr  ||  ! pSfr->IsValid()  ||

ChainCurves.cpp

@@ -16,7 +16,6 @@
 #include "/EgtDev/Include/EGkChainCurves.h"
 #include "/EgtDev/Include/EGkGeomDB.h"
 #include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkCurveComposite.h"
 #include <algorithm>
 
 using namespace std ;

Color.cpp

@@ -45,8 +45,7 @@ static const NamedColor StdColor[] = {
    { "FUCHSIA", FUCHSIA},
    { "PURPLE", PURPLE},
    { "ORANGE", ORANGE},
-   { "BROWN", BROWN},
-   { "INVISIBLE", INVISIBLE}
+   { "BROWN", BROWN}
 } ;
 static const int NUM_STDCOLOR = ( sizeof(StdColor) / sizeof(StdColor[0]) ) ;
 

CurveAux.cpp

@@ -13,8 +13,6 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "CalcDerivate.h"
-#include "Bernstein.h"
 #include "CurveAux.h"
 #include "GeoConst.h"
 #include "CurveLine.h"
@@ -25,22 +23,12 @@
 #include "IntersLineLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EGkCurveByInterp.h"
-#include "/EgtDev/Include/EGkChainCurves.h"
 #define EIGEN_NO_IO
 #include "/EgtDev/Extern/Eigen/Dense"
 
-#define SAVEAPPROX 0
-#define SAVECURVEPASSED 0
-#define SAVELINEARAPPROX 0
-#if SAVEAPPROX  || SAVECURVEPASSED  ||  SAVELINEARAPPROX
-   static int nCrvPassed = 0 ;
-   #include "/EgtDev/Include/EGkGeoObjSave.h"
-#endif
-
 using namespace std ;
 
 static bool FindSpan( double dU, int nDeg, const DBLVECTOR& vKnots, int& nSpan) ;
@@ -534,9 +522,9 @@ LineToBezierCurve( const ICurveLine* pCrvLine, int nDeg, bool bMakeRatOrNot)
       return nullptr ;
 
    PtrOwner<ICurveBezier> pCrvBezier( CreateCurveBezier()) ;
-   pCrvBezier->Init( nDeg, false) ;
-   if ( ! pCrvBezier->FromLine( *pCrvLine))
-      return nullptr ;
+   // rendo tutte le curve di grado 2 e razionali così posso convertire anche archi e avere tutte curve dello stesso grado e razionali
+   pCrvBezier->Init( nDeg, true) ;
+   pCrvBezier->FromLine( *pCrvLine) ;
    if ( bMakeRatOrNot)
       pCrvBezier->MakeRational() ;
    return Release( pCrvBezier) ;
@@ -589,13 +577,6 @@ ArcToBezierCurve( const ICurveArc* pArc, int nDeg, bool bMakeRatOrNot)
          PtrOwner<ICurveBezier> pCrvBez( CreateBasicCurveBezier()) ;
          if ( IsNull( pCrvBez)  ||  ! pCrvBez->FromArc( cArc))
             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)
             pCrvBez.Set( BezierIncreaseDegree( pCrvBez)) ;
@@ -1154,7 +1135,7 @@ FindSpan( double dU, int nDeg, const DBLVECTOR& vKnots, int& nSpan)
       return true ;
    }
    // trovo a quale span appartiene il parametro dU
-   int nKnots = ssize( vKnots) ;
+   int nKnots = int( vKnots.size()) ;
    if ( abs( dU - vKnots[nKnots-1]) < EPS_SMALL) {
       nSpan = nKnots - 1 - nDeg ;
       return true ;
@@ -1180,7 +1161,7 @@ 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 ( ssize( vBasis) != nDeg + 1)
+   if ( vBasis.size() != nDeg + 1)
       return false ;
 
    vBasis[0] = 1 ;
@@ -1205,8 +1186,7 @@ CalcBasisFunc( double dU, int nSpan, int nDeg, const DBLVECTOR& vKnots, DBLVECTO
 
 //----------------------------------------------------------------------------
 ICurve*
-InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart, int nEnd, int nDeg, const DBLVECTOR& vLen, double dLenTot,
-                                              const Vector3d& vtStartDir = V_NULL, const Vector3d& vtEndDir = V_NULL)
+InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart, int nEnd, int nDeg, const DBLVECTOR& vLen, double dLenTot)
 {
    PtrOwner<ICurve> pCrvInt ;
 
@@ -1235,8 +1215,6 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
          return nullptr ;
    }
 
-   bool bUseStartEndDir = vtStartDir.IsValid()  &&  vtEndDir.IsValid() ;
-
    DBLVECTOR vPntParam ;
    vPntParam.resize( nPoints) ;
    vPntParam[0] = 0 ;
@@ -1245,15 +1223,13 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
       vPntParam[i] = vPntParam[i-1] + vLen[i-1] / dLenTot ;
 
    DBLVECTOR vKnots ;
-   int nKnots = bUseStartEndDir ? nPoints + nDeg - 1 + 2 : nPoints + nDeg - 1 ;
-   vKnots.resize( nKnots) ;
+   vKnots.resize( nPoints + nDeg - 1) ;
    for ( int i = 0 ; i < nDeg ; ++i) {
       vKnots[i] = 0 ;
       vKnots.end()[-i-1] = 1 ;
    }
 
-   int nKnotsToEdit = bUseStartEndDir ? nPoints + 1 : nPoints - 1 ;
-   for ( int i = nDeg ; i < nKnotsToEdit ; ++i) {
+   for ( int i = nDeg ; i < nPoints - 1 ; ++i) {
       double dKnot = 0 ;
       for ( int j = i + 1 ; j < i + nDeg + 1 ; ++j)
          dKnot += vPntParam[j - nDeg] ;
@@ -1261,14 +1237,13 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
       vKnots[i] = dKnot ;
    }
 
-   int nEq = bUseStartEndDir ? nPoints + 2 : nPoints ;
-   Eigen::MatrixXd mA( nEq, nEq) ;
+   Eigen::MatrixXd mA( nPoints, nPoints) ;
    mA.fill( 0) ;
-   for ( int i = 0 ; i < nEq ; ++i) {
+   for ( int i = 0 ; i < nPoints ; ++i) {
       if ( i == 0)
          mA.row(0).col(0) << 1 ;
-      else if ( i == nEq - 1)
-         mA.row(i).col( nEq - 1) << 1 ;
+      else if ( i == nPoints - 1)
+         mA.row(i).col(nPoints - 1) << 1 ;
       else {
          int nSpan = 0 ; FindSpan( vPntParam[i], nDeg, vKnots, nSpan) ;
          DBLVECTOR vBasis ; vBasis.resize( nDeg + 1) ;
@@ -1319,7 +1294,7 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
    int nItCount = 0 ;
    while ( dErr > dLinTol  &&  nItCount < 10) {
       pCrvInt->Clear() ;
-      int nPoints = ssize( vPnt) ;
+      int nPoints = int( vPnt.size()) ;
       int nDeg = 3 ;
       if ( nPoints < 2)
          return nullptr ;
@@ -1335,7 +1310,7 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
       else if ( nPoints == 3) {
          // se ho solo tre punti uso un altro algoritmo
          CurveByInterp cbi ;
-         for ( int i = 0 ; i < ssize( vPnt) ; ++i)
+         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())
@@ -1367,16 +1342,10 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
             }
          }
 
-         if ( ! vLen.empty()) {
+         if ( vLen.size() != 0) {
             if ( nEnd == 0)
                nEnd = nPoints - 1 ;
-            Vector3d vtStartDir = V_INVALID ; 
-            Vector3d vtEndDir = V_INVALID ;
-            //if ( nStart != 0  &&  nEnd != nPoints - 1) {
-            //   pCrvInt->GetEndDir( vtStartDir) ;
-            //   vtEndDir = 
-            //}
-            pCrvInt->AddCurve( InterpolatePointSetWithBezierNoIntermedLines( vPnt, nStart, nEnd, nDeg, vLen, dLenTot, vtStartDir, vtEndDir)) ;
+            pCrvInt->AddCurve( InterpolatePointSetWithBezierNoIntermedLines( vPnt, nStart, nEnd, nDeg, vLen, dLenTot)) ;
          }
 
          if ( bFoundLine) {
@@ -1388,7 +1357,6 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
          nStart = nEnd ;
       }
 
-      //dErr = 0 ;
       CalcApproxError( pCrvOri, pCrvInt, dErr) ;
       if ( dErr > dLinTol  &&  dMaxLen > 200 * EPS_SMALL)
          dMaxLen /= 2 ;
@@ -1402,319 +1370,43 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
       return nullptr ;
 }
 
-//----------------------------------------------------------------------------
-static bool
-ParamByLen( const PNTVECTOR& vPnt, DBLVECTOR& vParam, int nFirst, int nLast)
-{
-   int nPoints = nLast - nFirst + 1 ;
-   if ( nPoints < 2)
-      return false ;
-   if ( vParam.empty())
-      vParam.resize( nPoints) ;
-   if ( vParam[nFirst] == 0  &&  vParam[nLast] == 1)
-      return true ;
-   vParam[nFirst] = 0 ;
-   for ( int i = nFirst + 1 ; i <= nLast ; ++i) {
-      double dDist = Dist( vPnt[i], vPnt[i-1]) ;
-      vParam[i] = vParam[i- 1] + dDist ;
-   }
-   for ( int i = nFirst + 1 ; i < nLast ; ++i)
-      vParam[i] /= vParam[nLast] ;
-   vParam[nLast] = 1 ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-ICurveBezier*
-ApproxPointSetWithSingleBezier( const PNTVECTOR& vPnt, int nFirst, int nLast,
-                                const Vector3d& vtStartDir, const Vector3d& vtEndDir, const DBLVECTOR& vParam)
-{
-   // cerco di approssimare un set di punti con una sola bezier cubica non razionale
-   int nPoints = nLast - nFirst + 1 ;
-   // se ho solo quattro punti allora costruisco direttamente la curva
-   PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
-   int nDeg = 3 ;
-   bool bRat = false ;
-   pCrvBez->Init( nDeg, bRat) ;
-   const Point3d& pt0 = vPnt[nFirst] ;
-   const Point3d& pt3 = vPnt[nLast] ;
-   pCrvBez->SetControlPoint( 0, pt0) ;
-   pCrvBez->SetControlPoint( 3, pt3) ;
-   Eigen::Vector2d mA ;
-   if ( nPoints > 4) {
-      // risoluzione sistema
-      Eigen::Matrix2d mC ; mC.setZero() ;
-      Eigen::Vector2d mX ; mX.setZero() ;
-      for ( int i = nFirst ; i <= nLast ; ++i) {
-         double dU = vParam[i] ;
-         DBLVECTOR vBern(4) ;
-         GetAllBernstein( dU, 3, vBern) ;
-
-         Vector3d A1 = vtStartDir * vBern[1] ;
-         Vector3d A2 = vtEndDir * vBern[2] ;
-
-         Vector3d tmp = vPnt[i] - ( pt0 * ( vBern[0] + vBern[1])) - (( pt3 * ( vBern[2] + vBern[3])) - ORIG) ; // ORIG serve solo per trasformare l'ultimo termine in un vettore
-
-         mC(0,0) += A1 * A1 ;
-         mC(0,1) += A1 * A2 ;
-         mC(1,0) += A1 * A2 ;
-         mC(1,1) += A2 * A2 ;
-
-         mX(0) += A1 * tmp ;
-         mX(1) += A2 * tmp ;
-      }
-      mA = mC.fullPivLu().solve(mX) ;
-   }
-   // l'algoritmo è fatto in modo che alpha1 e alpha2 siano positivi ( se tutto va bene)
-   // io invece ho tenuto le tangenti con la direzione originale, quindi il primo dovrebbe essere positivo e il secondo negativo
-   if ( mA(0) < 0  ||  mA(1) > 0  ||  nPoints < 4) {
-      if ( mA(0) < 0  ||  mA(1) > 0)
-         LOG_DBG_ERR( GetEGkLogger(), "valori di alfa sballati, potrebbe essere la spaziatura dismogenea tra punti")
-      double dDistCorr = Dist( pt3, pt0) / 3 ;
-      mA(0) = dDistCorr ;
-      mA(1) = - dDistCorr ;
-   }
-
-   Point3d pt1 = pt0 + vtStartDir * mA(0) ;
-   Point3d pt2 = pt3 + vtEndDir * mA(1) ;
-   pCrvBez->SetControlPoint( 1, pt1) ;
-   pCrvBez->SetControlPoint( 2, pt2) ;
-   return Release( pCrvBez) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CalcPointSetApproxError( const PNTVECTOR& vPntOrig, const DBLVECTOR& vParam,
-                         int nFirst, int nLast, const ICurve* pCrvNew, double& dErr, int& nPointMaxErr)
-{
-   dErr = 0 ;
-   // calcolo l'errore di approssimazione
-   for ( int i = nFirst ; i <= nLast ; ++i) {
-      Point3d ptBez ; pCrvNew->GetPointD1D2( vParam[i], ICurve::Side::FROM_MINUS, ptBez) ;
-      double dErrTemp = Dist( vPntOrig[i], ptBez) ;
-      if ( dErrTemp > dErr) {
-         dErr = dErrTemp ;
-         nPointMaxErr = i ;
-      }
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 ICurve*
-FitWithBezier( const ICurve* pCrvOrig, const PNTVECTOR& vPnt, DBLVECTOR& vParam,
-               int nFirst, int nLast, const VCT3DVECTOR& vPrevDer, const VCT3DVECTOR& vNextDer, double dTol, bool bLimitSplit = false)
+ApproxCurveWithBezier( const ICurve* pCrv , double dTol, int nType)
 {
-   ParamByLen( vPnt, vParam, nFirst, nLast) ;
-   PtrOwner<ICurveComposite> pCrvFit( CreateCurveComposite()) ;
-   PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
-   double dErr = INFINITO ;
-   double dErrPrec = INFINITO ;
-   double dErrSplit = dTol * 25 ;
-   int nIter = 0 ;
-   while ( dErr > dTol  &&  nIter < 10) {
-      if ( dErr < INFINITO) {
-        // riparametrizzo i punti
-         for ( int i = nFirst + 1 ; i < nLast ; ++i) {
-           // questo potrebbe diventare un while appena capisco di quanto si aggiusta il parametro ad ogni iterazione
-            double dCorr = 1 ;
-            do {
-               Vector3d vtDer1, vtDer2 ;
-               Point3d ptBez ; pCrvBez->GetPointD1D2( vParam[i], ICurve::Side::FROM_MINUS, ptBez, &vtDer1, &vtDer2) ;
-               Vector3d vtLink = ptBez - vPnt[i] ;
-               double dNum = vtLink * vtDer1 ;
-               double dDen = vtLink * vtDer2 + vtDer1 * vtDer1 ;
-               dCorr = dDen > EPS_ZERO ? dNum / dDen : 0 ;
-               vParam[i] = vParam[i] - dCorr ;
-            } while ( abs( dCorr) > EPS_ZERO) ;
-            Clamp( vParam[i], 0., 1.) ;
-         }
-      }
-
-     // fit della curva
-      Vector3d vtStartDir, vtEndDir ;
-      if ( bLimitSplit) {
-         vtStartDir = vNextDer[nFirst / 3] ;
-         vtEndDir = vPrevDer[nLast / 3] ;
-      }
-      else {
-         vtStartDir = vNextDer[nFirst] ;
-         vtEndDir = vPrevDer[nLast] ;
-      }
-      pCrvBez.Set( ApproxPointSetWithSingleBezier( vPnt, nFirst, nLast, vtStartDir, vtEndDir, vParam)) ;
-      if ( IsNull( pCrvBez)  ||  ! pCrvBez->IsValid())
-         return nullptr ;
-#if SAVEAPPROX
-      SaveGeoObj( pCrvBez->Clone(), "D:\\Temp\\bezier\\approxWithBezier\\"+ToString(nCrvPassed) + "first_approx.nge") ;
-#endif
-
-      int nPointMaxErr = 0 ;
-      CalcPointSetApproxError( vPnt, vParam, nFirst, nLast, pCrvBez, dErr, nPointMaxErr) ;
-     // se sto unendo due punti consecutivi e l'errore è oltre quello richiesto allora restituisco un segmento che unisce i punti
-      if ( ((nLast - nFirst == 1)  ||  ( bLimitSplit  &&  nLast - nFirst == 3)) &&  dErr > dTol) {
-         CurveLine CL ; CL.Set( vPnt[nFirst], vPnt[nLast]) ;
-         pCrvBez.Set( GetCurveBezier( CurveToBezierCurve( &CL))) ;
-         dErr = 0 ;
-      }
-
-      if ( bLimitSplit  &&  nPointMaxErr % 3 != 0) {
-         nPointMaxErr = 3 * int( round( nPointMaxErr / 3.)) ;
-         if ( nPointMaxErr == nFirst)
-            nPointMaxErr += 3 ;
-         else if( nPointMaxErr == nLast)
-            nPointMaxErr -= 3 ;
-      }
-
-      ++nIter ;
-      bool bSplit = false ;
-      if ( ( nIter == 10  &&  dErr > dTol)  || dErr > dErrPrec  ||  dErrPrec - dErr < dErrPrec / 20)
-         bSplit = true ;
-      dErrPrec = dErr ;
-     // se la curva di approssimazione è ancora molto lontana dalla curva originale allora divido il set di punti in due 
-      if ( dErr > dErrSplit  ||  bSplit) {
-         if ( nLast - nFirst > 1  &&  nPointMaxErr - nFirst > 1  &&  nLast - nPointMaxErr > 1) {
-            if ( ! pCrvFit->AddCurve( FitWithBezier( pCrvOrig, vPnt, vParam, nFirst, nPointMaxErr, vPrevDer, vNextDer,dTol, bLimitSplit)) ||
-                ! pCrvFit->AddCurve( FitWithBezier( pCrvOrig, vPnt, vParam, nPointMaxErr, nLast, vPrevDer, vNextDer, dTol, bLimitSplit)))
-               return nullptr ;
-            break ;
-         }
-         else
-            return nullptr ;
-      }
-   }
-
-   if ( pCrvFit->GetCurveCount() > 0)
-      return Release( pCrvFit) ;
-   else if ( dErr < dTol  &&  ! IsNull( pCrvBez)  &&  pCrvBez->IsValid())
-      return Release( pCrvBez) ;
-   else
-      return nullptr ;
-}
-
-//----------------------------------------------------------------------------
-ICurve*
-ApproxCurveWithBezier( const ICurve* pCrv , double dTol)
-{
-
-#if SAVECURVEPASSED
-   SaveGeoObj( pCrv->Clone(), "D:\\Temp\\bezier\\approxWithBezier\\CurveDaApprossimare\\"+ToString(nCrvPassed) + ".nge") ;
-   ++nCrvPassed ;
-#endif
-
-   //// uso l'algoritmo di Schneider in Grafic Gems I
-   // mi aspetto che non ci siano angoli ( discontinuità della derivata prima) nel risultato desiderato
    PolyLine plApprox ;
-   double dAngTolFine = 1 ;
-   double dLinTolFine = 0.05 ;
-   pCrv->ApproxWithLines( dLinTolFine, dAngTolFine, ICurve::APL_STD, plApprox) ;
-
-#if SAVELINEARAPPROX
-   CurveComposite CC ; CC.FromPolyLine(plApprox) ;
-   SaveGeoObj( CC.Clone(), "D:\\Temp\\bezier\\approxWithBezier\\approssimazione_lineare.nge") ;
-#endif
+   double dAngTolFine = 2 ;
+   pCrv->ApproxWithLines( dTol, dAngTolFine, ICurve::APL_STD, plApprox) ;
 
    PNTVECTOR vPnt ;
-   PNTVECTOR vPntOverSampling ;
    Point3d pt ; plApprox.GetFirstPoint( pt) ;
    do {
-      if ( ! vPntOverSampling.empty()) {
-         vPntOverSampling.push_back( Media( vPnt.back(), pt,1./3.)) ;
-         vPntOverSampling.push_back( Media( vPnt.back(), pt,2./3.)) ;
-      }
-      vPntOverSampling.push_back( pt) ;
       vPnt.push_back( pt) ;
    } while ( plApprox.GetNextPoint( pt)) ;
 
-   // calcolo la curvatura nei vari punti per identificare zone a curvatura costante
-   DBLVECTOR vRad ( ssize( vPnt)) ;
-   for ( int i = 1 ; i < ssize( vPnt) - 1 ; ++i) {
-      Vector3d vtA = vPnt[i] - vPnt[i-1] ;
-      Vector3d vtB = vPnt[i+1] - vPnt[i-1] ;
-      double dR = ( vtA.Len() * vtB.Len() * ( vtA - vtB).Len()) / ( 2 * ( vtA ^ vtB).Len()) ;
-      vRad[i] = dR ;
-   }
-   vRad[0] = vRad[1] ;
-   vRad.back() = vRad.end()[-2] ;
-   // identifico le zone a curvatura costante // primo e ultimo punto degli intervalli non devono avere curvatura uguale agli altri perché sono di frontiera
-   INTINTVECTOR vConstCurv ;
-   double dRadPrec = vRad[0] ;
-   int nStart = 0 ;
-   int nEnd = 1 ;
-   double dRatio = 1.5 ;
-   while ( nStart < ssize( vPnt) - 1) {
-      double dRadTol = max( max( vRad[nEnd], dRadPrec) / 10 , 1.) ;
-      if ( dRadPrec > dRatio * vRad[nEnd]  ||  dRatio * dRadPrec < vRad[nEnd])
-         dRadTol = 0 ;
-      while ( nEnd < ssize( vPnt) - 1  &&  abs( vRad[nEnd] - dRadPrec) < dRadTol) {
-         dRadPrec = vRad[nEnd] ;
-         ++nEnd ;
-      }
-      vConstCurv.emplace_back( nStart * 3, nEnd * 3) ;
-      nStart = nEnd ;
-      dRadPrec = vRad[nEnd] ;
-      ++nEnd ;
-   }
-   if ( vConstCurv.empty())
-      vConstCurv.emplace_back( 0, ssize( vPnt) - 1) ;
+   // campiono punti lungo la curva e poi li interpolo
 
-   int nPoints = ssize( vPnt) ;
-   DBLVECTOR vParam( nPoints) ;
-   int nFirst = 0 ;
-   int nLast = ssize( vPnt) - 1 ;
-   ParamByLen( vPnt, vParam, nFirst, nLast) ;
+   PtrOwner<ICurve> pCC( InterpolatePointSetWithBezier( vPnt, dTol, 100)) ;
+   if ( ! IsNull( pCC)  &&  pCC->IsValid())
+         return Release( pCC) ;
+      else
+         return nullptr ;
+}
 
-   VCT3DVECTOR vPrevDer ;
-   VCT3DVECTOR vNextDer ;
-   ComputeAkimaTangents( false, vParam, vPnt, vPrevDer, vNextDer) ;
+//----------------------------------------------------------------------------
+ICurve*
+ApproxPointSetWithBezier( const ICurve* pCrv, double dTol)
+{
+   // campiono punti lungo la curva e poi li interpolo
 
-   int nOverSampling = ssize( vPntOverSampling) ;
-   vParam.resize( nOverSampling) ;
-   nFirst = 0 ;
-   nLast = nOverSampling - 1 ;
-   ParamByLen( vPntOverSampling, vParam, nFirst, nLast) ;
-
-   //normalizzo tutte le derivate
-   for ( int i = 0 ; i < ssize( vPrevDer) ; ++i) {
-      vPrevDer[i].Normalize() ;
-      vNextDer[i].Normalize() ;
-   }
-
-   // potrei verificare prima se un tratto è retto e aggiustare le tangenti del tratto precedente e successivo prima di approssimare
-   PtrOwner<ICurveComposite> pCCApproxTot( CreateCurveComposite()) ;
-   for ( INTINT iiSE : vConstCurv) {
-      nFirst = iiSE.first ;
-      nLast = iiSE.second ;
-      // riconosco se ho un tratto retto
-      int nPnt = nFirst / 3 ;
-      if ( nLast - nFirst == 3  &&  ( nPnt > 0 &&  vRad[nPnt] > dRatio * vRad[nPnt - 1])  &&  ( nPnt < ssize( vRad)  &&  vRad[nPnt]> dRatio * vRad[nPnt + 1])) {
-         CurveLine CL ; CL.Set( vPntOverSampling[nFirst], vPntOverSampling[nLast]) ;
-         PtrOwner<ICurveBezier> pCApprox( LineToBezierCurve( &CL, 3, false)) ;
-         if ( ! pCCApproxTot->AddCurve( Release( pCApprox)))
-            return nullptr ;
-      }
-      else {
-         //definisco la bezier che vado a raffinare iterativamente
-         PtrOwner<ICurve> pCApprox( FitWithBezier( pCrv, vPntOverSampling, vParam, nFirst, nLast, vPrevDer, vNextDer, dTol, true)) ;
-         if ( IsNull( pCApprox)  ||  ! pCApprox->IsValid())
-            return nullptr ;
-         if ( ! pCCApproxTot->AddCurve( Release( pCApprox)))
-            return nullptr ;
-      }
-   }
-
-   return Release( pCCApproxTot) ;
+   PtrOwner<ICurveComposite> pCC( CreateBasicCurveComposite()) ;
+   return Release( pCC) ;
 }
 
 //----------------------------------------------------------------------------
 bool
 CalcApproxError( const ICurve* pCrvOri, const ICurve* pCrvNew, double& dErr, int nPoints)
 {
-   if ( pCrvOri == nullptr  ||  ! pCrvOri->IsValid()  ||  pCrvNew == nullptr  ||  ! pCrvNew->IsValid()){
-      dErr = INFINITO ;
-      return false ;
-   }
    // controllo l'errore effettivo campionando più finemente
    double dLenOri = 0 ; pCrvOri->GetLength( dLenOri) ;
    double dLenNew = 0 ; pCrvNew->GetLength( dLenNew) ;
@@ -1796,7 +1488,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
 {
   // se con nodi extra
    if ( cnData.bExtraKnotes) {
-      int nKnotesNbr = ssize( cnData.vU) ;
+      int nKnotesNbr = int( cnData.vU.size()) ;
       if ( nKnotesNbr < 4)
          return false ;
       cnData.bExtraKnotes = false ;
@@ -1810,7 +1502,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
       bool bAlreadyChecked = false ;
      // se la curva è peridica verifco che effettivamente ci sia un numero di punti ripetituti uguale al grado della curva
      // wrap della curva su se stessa
-      if ( cnData.bPeriodic  &&  ( ssize( cnData.vU) > ssize( cnData.vCP) + cnData.nDeg - 1)) {
+      if ( cnData.bPeriodic  &&  (int(cnData.vU.size()) > int(cnData.vCP.size()) + cnData.nDeg - 1)) {
          bool bRepeated = true ;
          for ( int i = 0 ; i < cnData.nDeg ; ++i) {
             if ( ! AreSamePointApprox( cnData.vCP[i], cnData.vCP.end()[-cnData.nDeg + i]) ) {
@@ -1819,11 +1511,11 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
             }
          }
          bool bFirstAddedAtEnd = false ;
-         if ( ! bRepeated  ||  ( bRepeated  &&  AreSamePointApprox( cnData.vCP[0], cnData.vCP[cnData.nDeg]))) {
+         if ( ! bRepeated  ||  (bRepeated  && AreSamePointApprox( cnData.vCP[0],cnData.vCP[cnData.nDeg]))){
            // salvo il vettore dei nodi in caso mi accorga di avere tra le mani una curva unclamped
             DBLVECTOR vU = cnData.vU ;
            // se effettivamente ho dei nodi in più da togliere allora li tolgo ed eventualmente aggiungo punti di controllo
-            if ( ssize( cnData.vU) > ssize( cnData.vCP) + cnData.nDeg - 1 ) {
+            if ( int(cnData.vU.size()) > int(cnData.vCP.size()) + cnData.nDeg - 1 ) {
               // se il primo e l'ultimo punto non coincidono allora aggiungo il primo punto in fondo al vettore dei punti di controllo
                if ( ! AreSamePointApprox( cnData.vCP[0], cnData.vCP.back())) {
                   bFirstAddedAtEnd = true ;
@@ -1835,11 +1527,11 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
                cnData.vU = DBLVECTOR( cnData.vU.begin(), cnData.vU.end() - cnData.nDeg) ;
               // controllo eventualmente anche i nodi extra
               // se ne ho due in più ne tolgo uno in cima e uno in fondo
-               if ( ssize( cnData.vU) == ssize( cnData.vCP) + cnData.nDeg + 1) {   // significa che ci sono due nodi extra, uno all'inizio e uno alla fine, da togliere
+               if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg + 1 ) {   // significa che ci sono due nodi extra, uno all'inizio e uno alla fine, da togliere
                   cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end() - 1) ;
                }
               // se ne ho solo uno in più lo tolgo in cima
-               else if ( ssize( cnData.vU) == ssize( cnData.vCP) + cnData.nDeg) {
+               else if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg) {
                   cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end()) ;
                }
             }
@@ -1866,7 +1558,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
               // recupero il vettore dei nodi
                cnData.vU = vU ;
               // verifico se ho nodi extra
-               if ( ssize( cnData.vU) == ssize( cnData.vCP) + cnData.nDeg + 1 ) {
+               if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg + 1 ) {
                  // significa che ci sono due nodi extra:
                  // se la curva ha grado maggiore di 1 e i primi due nodi sono uguali allora tolgo quelli
                   if ( cnData.nDeg > 1 && abs(cnData.vU[1] - cnData.vU[0]) < EPS_SMALL) {
@@ -1877,7 +1569,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
                      cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end() - 1) ;
                }
               // se ne ho solo uno in più lo tolgo in cima
-               else if ( ssize( cnData.vU) == ssize( cnData.vCP) + cnData.nDeg)
+               else if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg)
                   cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end()) ;
             }
             bAlreadyChecked = true ;
@@ -1902,7 +1594,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
      // qui aggiungo un controllo se la curva è collassata in un punto ( ho un polo), lascio stare
       bool bCollapsed = true ;
       Point3d ptFirst = cnData.vCP.front() ;
-      for ( int i = 1 ; i < ssize( cnData.vCP) ; ++i) {
+      for ( int i = 1 ; i < int( cnData.vCP.size()) ; ++i) {
          if ( ! AreSamePointApprox( ptFirst, cnData.vCP[i])) {
             bCollapsed = false ;
             break ;
@@ -1919,7 +1611,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
      // agli indici perché uso u_p-1 e u_(m-p+1), anziché u_p e u_m-p
 
      // comincio ad aumentare la molteplictià del nodo u_m-p+1
-      int nCP = ssize( cnData.vCP) ;
+      int nCP = int( cnData.vCP.size()) ;
       int nU = nCP + cnData.nDeg - 1 ;
       int nDeg = cnData.nDeg ;
       PNTVECTOR vBC ;
@@ -2115,9 +1807,9 @@ NurbsToBezierCurve( const CNurbsData& cnData)
    if ( cnData.bPeriodic  ||  cnData.bExtraKnotes)
       return nullptr ;
   // numero dei nodi
-   int nU = ssize( cnData.vCP) + cnData.nDeg - 1 ;
+   int nU = int( cnData.vCP.size()) + cnData.nDeg - 1 ;
   // controllo relazione nodi - punti di controllo
-   if ( nU != ssize( cnData.vU))
+   if ( nU != int( cnData.vU.size()))
       return nullptr ;
   // numero degli intervalli
    int nInt = nU - 2 * cnData.nDeg + 1 ;
@@ -2487,7 +2179,7 @@ CalcCurvesVoronoiDiagram( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, in
    PtrOwner<Voronoi> pVoronoiObj( new( std::nothrow) Voronoi()) ;
    if ( pVoronoiObj == nullptr)
       return false ;
-   for ( int i = 0 ; i < ssize( vCrvC) ; i ++) {
+   for ( int i = 0 ; i < int( vCrvC.size()) ; i ++) {
       if ( ! pVoronoiObj->AddCurve( vCrvC[i]))
          return false ;
    }
@@ -2514,7 +2206,7 @@ CalcCurvesMedialAxis( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, int nS
    PtrOwner<Voronoi> pVoronoiObj( new( std::nothrow) Voronoi()) ;
    if ( pVoronoiObj == nullptr)
       return false ;
-   for ( int i = 0 ; i < ssize( vCrvC) ; i ++) {
+   for ( int i = 0 ; i < int( vCrvC.size()) ; i ++) {
       if ( ! pVoronoiObj->AddCurve( vCrvC[i]))
          return false ;
    }
@@ -2575,7 +2267,7 @@ bool CalcOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR& vCrvs, doubl
    PtrOwner<Voronoi> pVoronoiObj( new( std::nothrow) Voronoi()) ;
    if ( pVoronoiObj == nullptr)
       return false ;
-   for ( int i = 0 ; i < ssize( vpCrvs) ; i ++) {
+   for ( int i = 0 ; i < int( vpCrvs.size()) ; i ++) {
       if ( ! pVoronoiObj->AddCurve( vpCrvs[i]))
          return false ;
    }
@@ -2605,7 +2297,7 @@ bool CalcFatOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR& vCrvs, do
    PtrOwner<Voronoi> pVoronoiObj( new( std::nothrow) Voronoi()) ;
    if ( pVoronoiObj == nullptr)
       return false ;
-   for ( int i = 0 ; i < ssize( vpCrvs) ; i ++) {
+   for ( int i = 0 ; i < int( vpCrvs.size()) ; i ++) {
       if ( ! pVoronoiObj->AddCurve( vpCrvs[i]))
          return false ;
    }
@@ -2634,56 +2326,3 @@ ResetCurveVoronoi( const ICurve& crvC)
       break ;
    }
 }
-
-//----------------------------------------------------------------------------
-bool
-GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol, bool bAllowInvert)
-{
-   if ( ssize( vCrv) == 1)
-      return true ;
-   ChainCurves chainCrv ;
-   // modifico direttamente le curve passate in input
-   chainCrv.Init( bAllowInvert, dChainTol, ssize( vCrv)) ;
-   for ( int c = 0 ; c < ssize( vCrv) ; ++c) {
-      Point3d ptStart, ptEnd ;
-      Vector3d vtStart, vtEnd ;
-      vCrv[c]->GetStartPoint( ptStart) ;
-      vCrv[c]->GetEndPoint( ptEnd) ;
-      vCrv[c]->GetStartDir( vtStart) ;
-      vCrv[c]->GetEndDir( vtEnd) ;
-      chainCrv.AddCurve( 1 + c, ptStart, vtStart, ptEnd, vtEnd) ;
-   }
-   INTVECTOR vIds ;
-   Point3d ptStart = ORIG ;
-   while ( chainCrv.GetChainFromNear( ptStart, false, vIds)) {
-      int nFirst = vIds[0] ;
-      bool bInvert = false ;
-      if ( nFirst < 0)
-         bInvert = true ;
-      nFirst = abs( nFirst) - 1 ;
-      if ( bInvert)
-         vCrv[nFirst]->Invert() ;
-      ICurveComposite* pFirstCrv = vCrv[nFirst] ;
-      for ( int nId : vIds) {
-         bInvert = false ;
-         if ( nId < 0)
-            bInvert = true ;
-         nId = abs( nId) - 1 ;
-         if ( nId == nFirst)
-            continue ;
-         if ( bInvert)
-            vCrv[nId]->Invert() ;
-         if ( ! pFirstCrv->AddCurve( Release( vCrv[nId]), true, dChainTol))
-            return false ;
-      }
-      pFirstCrv->GetEndPoint( ptStart) ;
-   }
-   // elimino gli elementi del vettore che non contengono più curve
-   int c = ssize( vCrv) - 1 ;
-   while ( c > -1) {
-      if ( IsNull( vCrv[c]))
-         vCrv.erase( vCrv.begin() + c) ;
-      --c ;
-   }
-   return true ;
-}

CurveAux.h

@@ -35,4 +35,3 @@ bool CopyExtrusion( const ICurve* pSouCrv, ICurve* pDestCrv) ;
 bool CopyThickness( const ICurve* pSouCrv, ICurve* pDestCrv) ;
 ICurveBezier* ApproxCurveBezierWithSingleCubic( const ICurve* pCrv) ;
 Voronoi* GetCurveVoronoi( const ICurve& crvC) ;
-bool GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol, bool bAllowInvert) ;

CurveBezier.cpp

@@ -275,19 +275,20 @@ CurveBezier::FromLine( const ICurveLine& crLine)
 {
    if ( m_nStatus != OK  ||  ! crLine.IsValid())
       return false ;
+   double dWeight = 1 ;
    int nCount = 0 ;
    Point3d ptStart ; crLine.GetStartPoint( ptStart) ;
-   SetControlPoint( nCount, ptStart) ;
+   SetControlPoint( nCount, ptStart, dWeight) ;
    ++nCount ;
    double dPart = 1. / m_nDeg ;
    for ( int i = 1 ; i < m_nDeg ; ++i) {
       double dU = i * dPart ;
       Point3d ptMid ; crLine.GetPointD1D2( dU, ICurve::FROM_MINUS, ptMid) ;
-      SetControlPoint( nCount, ptMid) ;
+      SetControlPoint( nCount, ptMid, dWeight) ;
       ++nCount ;
    }
    Point3d ptEnd ; crLine.GetEndPoint( ptEnd) ;
-   SetControlPoint( nCount, ptEnd) ;
+   SetControlPoint( nCount, ptEnd, dWeight) ;
    ++nCount ;
    return true ;
 }

CurveByApprox.cpp

@@ -202,14 +202,213 @@ CurveByApprox::CalcParameterization( void)
 bool
 CurveByApprox::CalcAkimaTangents( bool bDetectCorner)
 {
-   return ComputeAkimaTangents( bDetectCorner, m_vPar, m_vPnt, m_vPrevDer, m_vNextDer) ;
+  // pulisco i vettori delle tangenti
+   m_vPrevDer.clear() ;
+   m_vNextDer.clear() ;
+
+  // numero di punti
+   int nSize = int( m_vPnt.size()) ;
+
+  // sono necessari almeno due punti
+   if ( nSize < 2)
+      return false ;
+
+  // calcolo le derivate
+   m_vPrevDer.reserve( nSize) ;
+   m_vNextDer.reserve( nSize) ;
+  // se ci sono solo 2 punti, le tangenti devono essere dirette lungo la linea che li unisce
+   if ( nSize == 2) {
+     // non esiste derivata prima del primo punto
+      m_vPrevDer.emplace_back( 0, 0, 0) ;
+      m_vNextDer.push_back( ( m_vPnt[1] - m_vPnt[0]) / ( m_vPar[1] - m_vPar[0])) ;
+      m_vPrevDer.push_back( m_vNextDer[0]) ;
+     // non esiste derivata dopo il secondo e ultimo punto
+      m_vNextDer.emplace_back( 0, 0, 0) ;
+      return true ;
+   }
+  // verifico se curva chiusa (primo e ultimo punto coincidono)
+   bool bClosed = AreSamePointApprox( m_vPnt.front(), m_vPnt.back()) ;
+  // calcolo le derivate
+   for ( int i = 0 ; i < nSize ; ++ i) {
+      Vector3d vtPrevDer ;
+      Vector3d vtNextDer ;
+     // primo punto
+      if ( i == 0) {
+        // se curva chiusa, come precedente uso il penultimo punto
+         if ( bClosed) {
+           // se non ci sono almeno 5 punti
+            if ( nSize < 5) {
+               if ( ! CalcCircleMidDer( m_vPar[nSize-2] - m_vPar[nSize-1], m_vPnt[nSize-2], m_vPar[i], m_vPnt[i],
+                                        m_vPar[i+1], m_vPnt[i+1], vtNextDer))
+                  return false ;
+               vtPrevDer = vtNextDer ;
+            }
+           // altrimenti
+            else {
+               if ( ! CalcAkimaMidDer( m_vPar[nSize-3] - m_vPar[nSize-1], m_vPnt[nSize-3], m_vPar[nSize-2] - m_vPar[nSize-1], m_vPnt[nSize-2],
+                                       m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[i+2], m_vPnt[i+2], bDetectCorner,
+                                       vtPrevDer, vtNextDer))
+                  return false ;
+            }
+         }
+        // altrimenti, uso arco sui primi tre punti
+         else {
+            if ( ! CalcCircleStartDer( m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[i+2], m_vPnt[i+2], vtNextDer))
+               return false ;
+            vtPrevDer = Vector3d( 0, 0, 0) ;
+         }
+      }
+     // ultimo punto
+      else if ( i == nSize - 1) {
+        // se curva chiusa, le tg devono coincidere con quelle del primo
+         if ( bClosed) {
+            vtPrevDer = m_vPrevDer[0] ;
+            vtNextDer = m_vNextDer[0] ;
+         }
+        // altrimenti, uso arco sugli ultimi tre punti
+         else {
+            if ( ! CalcCircleEndDer( m_vPar[i-2], m_vPnt[i-2], m_vPar[i-1], m_vPnt[i-1],
+                                       m_vPar[i], m_vPnt[i], vtPrevDer))
+               return false ;
+            vtNextDer = Vector3d( 0, 0, 0) ;
+         }
+      }
+     // punti intermedi
+      else {
+        // se secondo punto
+         if ( i == 1) {
+           // se curva aperta o non ci sono almeno 5 punti
+            if ( ! bClosed  ||  nSize < 5) {
+               if ( ! CalcCircleMidDer( m_vPar[i-1], m_vPnt[i-1], m_vPar[i], m_vPnt[i],
+                                        m_vPar[i+1], m_vPnt[i+1], vtPrevDer))
+                  return false ;
+               vtNextDer = vtPrevDer ;
+            }
+           // altrimenti
+            else {
+               if ( ! CalcAkimaMidDer( m_vPar[nSize-2] - m_vPar[nSize-1], m_vPnt[nSize-2], m_vPar[i-1], m_vPnt[i-1],
+                                       m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[i+2], m_vPnt[i+2], bDetectCorner,
+                                       vtPrevDer, vtNextDer))
+                  return false ;
+            }
+         }
+        // se penultimo punto
+         else if ( i == nSize - 2) {
+           // se curva aperta o non ci sono almeno 5 punti
+            if ( ! bClosed  ||  nSize < 5) {
+               if ( ! CalcCircleMidDer( m_vPar[i-1], m_vPnt[i-1], m_vPar[i], m_vPnt[i],
+                                        m_vPar[i+1], m_vPnt[i+1], vtPrevDer))
+                  return false ;
+               vtNextDer = vtPrevDer ;
+            }
+           // altrimenti
+            else {
+               if ( ! CalcAkimaMidDer( m_vPar[i-2], m_vPnt[i-2], m_vPar[i-1], m_vPnt[i-1],
+                                       m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[1] + m_vPar[i+1], m_vPnt[1], bDetectCorner,
+                                       vtPrevDer, vtNextDer))
+                  return false ;
+            }
+         }
+        // altrimenti
+         else {
+            if ( ! CalcAkimaMidDer( m_vPar[i-2], m_vPnt[i-2], m_vPar[i-1], m_vPnt[i-1],
+                                    m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                    m_vPar[i+2], m_vPnt[i+2], bDetectCorner,
+                                    vtPrevDer, vtNextDer))
+               return false ;
+         }
+      }
+     // salvo la derivata
+      m_vPrevDer.push_back( vtPrevDer) ;
+      m_vNextDer.push_back( vtNextDer) ;
+   }
+
+   return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
 CurveByApprox::CalcBesselTangents( void)
 {
-   return ComputeBesselTangents( m_vPar, m_vPnt, m_vPrevDer, m_vNextDer) ;
+  // pulisco i vettori delle tangenti
+   m_vPrevDer.clear() ;
+   m_vNextDer.clear() ;
+
+  // numero di punti
+   int nSize = int( m_vPnt.size()) ;
+
+  // sono necessari almeno due punti
+   if ( nSize < 2)
+      return false ;
+
+  // calcolo le derivate
+   m_vPrevDer.reserve( nSize) ;
+   m_vNextDer.reserve( nSize) ;
+  // se ci sono solo 2 punti, le tangenti devono essere dirette lungo la linea che li unisce
+   if ( nSize == 2) {
+     // non esiste derivata prima del primo punto
+      m_vPrevDer.emplace_back( 0, 0, 0) ;
+      m_vNextDer.push_back( ( m_vPnt[1] - m_vPnt[0]) / ( m_vPar[1] - m_vPar[0])) ;
+      m_vPrevDer.push_back( m_vNextDer[0]) ;
+     // non esiste derivata dopo il secondo e ultimo punto
+      m_vNextDer.emplace_back( 0, 0, 0) ;
+      return true ;
+   }
+  // verifico se curva chiusa (primo e ultimo punto coincidono)
+   bool bClosed = AreSamePointApprox( m_vPnt.front(), m_vPnt.back()) ;
+  // calcolo le derivate
+   for ( int i = 0 ; i < nSize ; ++ i) {
+      Vector3d vtPrevDer ;
+      Vector3d vtNextDer ;
+     // primo punto
+      if ( i == 0) {
+        // se curva chiusa, come precedente uso il penultimo punto
+         if ( bClosed) {
+            if ( ! CalcBesselMidDer( m_vPar[nSize-2] - m_vPar[nSize-1], m_vPnt[nSize-2], m_vPar[i], m_vPnt[i],
+                                     m_vPar[i+1], m_vPnt[i+1], vtNextDer))
+               return false ;
+            vtPrevDer = vtNextDer ;
+         }
+        // altrimenti, uso i primi tre punti
+         else {
+            if ( ! CalcBesselStartDer( m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[i+2], m_vPnt[i+2], vtNextDer))
+               return false ;
+            vtPrevDer = Vector3d( 0, 0, 0) ;
+         }
+      }
+     // ultimo punto
+      else if ( i == nSize - 1) {
+        // se curva chiusa, le tg devono coincidere con quelle del primo
+         if ( bClosed) {
+            vtPrevDer = m_vPrevDer[0] ;
+            vtNextDer = m_vNextDer[0] ;
+         }
+        // altrimenti, uso gli ultimi tre punti
+         else {
+            if ( ! CalcBesselEndDer( m_vPar[i-2], m_vPnt[i-2], m_vPar[i-1], m_vPnt[i-1],
+                                     m_vPar[i], m_vPnt[i], vtPrevDer))
+               return false ;
+            vtNextDer = Vector3d( 0, 0, 0) ;
+         }
+      }
+     // punti intermedi
+      else {
+         if ( ! CalcBesselMidDer( m_vPar[i-1], m_vPnt[i-1], m_vPar[i], m_vPnt[i],
+                                  m_vPar[i+1], m_vPnt[i+1], vtPrevDer))
+            return false ;
+         vtNextDer = vtPrevDer ;
+      }
+     // salvo la derivata
+      m_vPrevDer.push_back( vtPrevDer) ;
+      m_vNextDer.push_back( vtNextDer) ;
+   }
+
+   return true ;
 }
 
 //----------------------------------------------------------------------------

CurveByInterp.cpp

@@ -50,42 +50,12 @@ CurveByInterp::AddPoint( const Point3d& ptP)
 ICurve*
 CurveByInterp::GetCurve( int nMethod, int nType)
 {
-   // 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)) ;
-       //debug
-       pCrv.Set( InterpolatePointSetWithBezier( m_vPnt, 0.1, 100)) ;
-       if ( IsNull(pCrv)  ||  ! pCrv->IsValid())
-          return nullptr ;
-       return Release( pCrv) ;
-   }
-
-  // numero di punti
-   int nSize = int( m_vPnt.size()) ;
-
-  // sono necessari almeno due punti
-   if ( nSize < 2)
-      return nullptr ;
-
-  // calcolo le distanze tra i punti per derivarne i parametri
-   m_vPar.reserve( nSize) ;
-   double dPar = 0 ;
-   m_vPar.push_back( dPar) ;
-
-   for ( int i = 1 ; i < nSize ; ++ i) {
-      double dDist = Dist( m_vPnt[i-1], m_vPnt[i]) ;
-      dPar += dDist ;
-      m_vPar.push_back( dPar) ;
-   }
-   
-   // calcolo le tangenti
+  // calcolo le tangenti
    if ( nMethod == BESSEL) {
       if ( ! CalcBesselTangents())
          return nullptr ;
    }
-   else {
+   else if ( nType != CUBIC_BEZIERS_LONG) {
       if ( ! CalcAkimaTangents( nMethod == AKIMA_CORNER))
          return nullptr ;
    }
@@ -133,6 +103,16 @@ 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 ;
 }
 
@@ -140,12 +120,233 @@ CurveByInterp::GetCurve( int nMethod, int nType)
 bool
 CurveByInterp::CalcAkimaTangents( bool bDetectCorner)
 {
-   return ComputeAkimaTangents( bDetectCorner, m_vPar, m_vPnt, m_vPrevDer, m_vNextDer) ;
+  // pulisco i vettori dei parametri e delle tangenti
+   m_vPar.clear() ;
+   m_vPrevDer.clear() ;
+   m_vNextDer.clear() ;
+
+  // numero di punti
+   int nSize = int( m_vPnt.size()) ;
+
+  // sono necessari almeno due punti
+   if ( nSize < 2)
+      return false ;
+
+  // calcolo le distanze tra i punti per derivarne i parametri
+   m_vPar.reserve( nSize) ;
+   double dPar = 0 ;
+   m_vPar.push_back( dPar) ;
+   for ( int i = 1 ; i < nSize ; ++ i) {
+      double dDist = Dist( m_vPnt[i-1], m_vPnt[i]) ;
+      dPar += dDist ;
+      m_vPar.push_back( dPar) ;
+   }
+
+  // calcolo le derivate
+   m_vPrevDer.reserve( nSize) ;
+   m_vNextDer.reserve( nSize) ;
+  // se ci sono solo 2 punti, le tangenti devono essere dirette lungo la linea che li unisce
+   if ( nSize == 2) {
+     // non esiste derivata prima del primo punto
+      m_vPrevDer.emplace_back( 0, 0, 0) ;
+      m_vNextDer.push_back( ( m_vPnt[1] - m_vPnt[0]) / ( m_vPar[1] - m_vPar[0])) ;
+      m_vPrevDer.push_back( m_vNextDer[0]) ;
+     // non esiste derivata dopo il secondo e ultimo punto
+      m_vNextDer.emplace_back( 0, 0, 0) ;
+      return true ;
+   }
+  // verifico se curva chiusa (primo e ultimo punto coincidono)
+   bool bClosed = AreSamePointApprox( m_vPnt.front(), m_vPnt.back()) ;
+  // calcolo le derivate
+   for ( int i = 0 ; i < nSize ; ++ i) {
+      Vector3d vtPrevDer ;
+      Vector3d vtNextDer ;
+     // primo punto
+      if ( i == 0) {
+        // se curva chiusa, come precedente uso il penultimo punto
+         if ( bClosed) {
+           // se non ci sono almeno 5 punti
+            if ( nSize < 5) {
+               if ( ! CalcCircleMidDer( m_vPar[nSize-2] - m_vPar[nSize-1], m_vPnt[nSize-2], m_vPar[i], m_vPnt[i],
+                                        m_vPar[i+1], m_vPnt[i+1], vtNextDer))
+                  return false ;
+               vtPrevDer = vtNextDer ;
+            }
+           // altrimenti
+            else {
+               if ( ! CalcAkimaMidDer( m_vPar[nSize-3] - m_vPar[nSize-1], m_vPnt[nSize-3], m_vPar[nSize-2] - m_vPar[nSize-1], m_vPnt[nSize-2],
+                                       m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[i+2], m_vPnt[i+2], bDetectCorner,
+                                       vtPrevDer, vtNextDer))
+                  return false ;
+            }
+         }
+        // altrimenti, uso arco sui primi tre punti
+         else {
+            if ( ! CalcCircleStartDer( m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[i+2], m_vPnt[i+2], vtNextDer))
+               return false ;
+            vtPrevDer = Vector3d( 0, 0, 0) ;
+         }
+      }
+     // ultimo punto
+      else if ( i == nSize - 1) {
+        // se curva chiusa, le tg devono coincidere con quelle del primo
+         if ( bClosed) {
+            vtPrevDer = m_vPrevDer[0] ;
+            vtNextDer = m_vNextDer[0] ;
+         }
+        // altrimenti, uso arco sugli ultimi tre punti
+         else {
+            if ( ! CalcCircleEndDer( m_vPar[i-2], m_vPnt[i-2], m_vPar[i-1], m_vPnt[i-1],
+                                       m_vPar[i], m_vPnt[i], vtPrevDer))
+               return false ;
+            vtNextDer = Vector3d( 0, 0, 0) ;
+         }
+      }
+     // punti intermedi
+      else {
+        // se secondo punto
+         if ( i == 1) {
+           // se curva aperta o non ci sono almeno 5 punti
+            if ( ! bClosed  ||  nSize < 5) {
+               if ( ! CalcCircleMidDer( m_vPar[i-1], m_vPnt[i-1], m_vPar[i], m_vPnt[i],
+                                        m_vPar[i+1], m_vPnt[i+1], vtPrevDer))
+                  return false ;
+               vtNextDer = vtPrevDer ;
+            }
+           // altrimenti
+            else {
+               if ( ! CalcAkimaMidDer( m_vPar[nSize-2] - m_vPar[nSize-1], m_vPnt[nSize-2], m_vPar[i-1], m_vPnt[i-1],
+                                       m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[i+2], m_vPnt[i+2], bDetectCorner,
+                                       vtPrevDer, vtNextDer))
+                  return false ;
+            }
+         }
+        // se penultimo punto
+         else if ( i == nSize - 2) {
+           // se curva aperta o non ci sono almeno 5 punti
+            if ( ! bClosed  ||  nSize < 5) {
+               if ( ! CalcCircleMidDer( m_vPar[i-1], m_vPnt[i-1], m_vPar[i], m_vPnt[i],
+                                        m_vPar[i+1], m_vPnt[i+1], vtPrevDer))
+                  return false ;
+               vtNextDer = vtPrevDer ;
+            }
+           // altrimenti
+            else {
+               if ( ! CalcAkimaMidDer( m_vPar[i-2], m_vPnt[i-2], m_vPar[i-1], m_vPnt[i-1],
+                                       m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[1] + m_vPar[i+1], m_vPnt[1], bDetectCorner,
+                                       vtPrevDer, vtNextDer))
+                  return false ;
+            }
+         }
+        // altrimenti
+         else {
+            if ( ! CalcAkimaMidDer( m_vPar[i-2], m_vPnt[i-2], m_vPar[i-1], m_vPnt[i-1],
+                                    m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                    m_vPar[i+2], m_vPnt[i+2], bDetectCorner,
+                                    vtPrevDer, vtNextDer))
+               return false ;
+         }
+      }
+     // salvo la derivata
+      m_vPrevDer.push_back( vtPrevDer) ;
+      m_vNextDer.push_back( vtNextDer) ;
+   }
+
+   return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
 CurveByInterp::CalcBesselTangents( void)
 {
-   return ComputeBesselTangents( m_vPar, m_vPnt, m_vPrevDer, m_vNextDer) ;
-}
+  // pulisco i vettori dei parametri e delle tangenti
+   m_vPar.clear() ;
+   m_vPrevDer.clear() ;
+   m_vNextDer.clear() ;
+
+  // numero di punti
+   int nSize = int( m_vPnt.size()) ;
+
+  // sono necessari almeno due punti
+   if ( nSize < 2)
+      return false ;
+
+  // calcolo le distanze tra i punti per derivarne i parametri
+   m_vPar.reserve( nSize) ;
+   double dPar = 0 ;
+   m_vPar.push_back( dPar) ;
+   for ( int i = 1 ; i < nSize ; ++ i) {
+      double dDist = Dist( m_vPnt[i-1], m_vPnt[i]) ;
+      dPar += dDist ;
+      m_vPar.push_back( dPar) ;
+   }
+
+  // calcolo le derivate
+   m_vPrevDer.reserve( nSize) ;
+   m_vNextDer.reserve( nSize) ;
+  // se ci sono solo 2 punti, le tangenti devono essere dirette lungo la linea che li unisce
+   if ( nSize == 2) {
+     // non esiste derivata prima del primo punto
+      m_vPrevDer.emplace_back( 0, 0, 0) ;
+      m_vNextDer.push_back( ( m_vPnt[1] - m_vPnt[0]) / ( m_vPar[1] - m_vPar[0])) ;
+      m_vPrevDer.push_back( m_vNextDer[0]) ;
+     // non esiste derivata dopo il secondo e ultimo punto
+      m_vNextDer.emplace_back( 0, 0, 0) ;
+      return true ;
+   }
+  // verifico se curva chiusa (primo e ultimo punto coincidono)
+   bool bClosed = AreSamePointApprox( m_vPnt.front(), m_vPnt.back()) ;
+  // calcolo le derivate
+   for ( int i = 0 ; i < nSize ; ++ i) {
+      Vector3d vtPrevDer ;
+      Vector3d vtNextDer ;
+     // primo punto
+      if ( i == 0) {
+        // se curva chiusa, come precedente uso il penultimo punto
+         if ( bClosed) {
+            if ( ! CalcBesselMidDer( m_vPar[nSize-2] - m_vPar[nSize-1], m_vPnt[nSize-2], m_vPar[i], m_vPnt[i],
+                                     m_vPar[i+1], m_vPnt[i+1], vtNextDer))
+               return false ;
+            vtPrevDer = vtNextDer ;
+         }
+        // altrimenti, uso i primi tre punti
+         else {
+            if ( ! CalcBesselStartDer( m_vPar[i], m_vPnt[i], m_vPar[i+1], m_vPnt[i+1],
+                                       m_vPar[i+2], m_vPnt[i+2], vtNextDer))
+               return false ;
+            vtPrevDer = Vector3d( 0, 0, 0) ;
+         }
+      }
+     // ultimo punto
+      else if ( i == nSize - 1) {
+        // se curva chiusa, le tg devono coincidere con quelle del primo
+         if ( bClosed) {
+            vtPrevDer = m_vPrevDer[0] ;
+            vtNextDer = m_vNextDer[0] ;
+         }
+        // altrimenti, uso gli ultimi tre punti
+         else {
+            if ( ! CalcBesselEndDer( m_vPar[i-2], m_vPnt[i-2], m_vPar[i-1], m_vPnt[i-1],
+                                     m_vPar[i], m_vPnt[i], vtPrevDer))
+               return false ;
+            vtNextDer = Vector3d( 0, 0, 0) ;
+         }
+      }
+     // punti intermedi
+      else {
+         if ( ! CalcBesselMidDer( m_vPar[i-1], m_vPnt[i-1], m_vPar[i], m_vPnt[i],
+                                  m_vPar[i+1], m_vPnt[i+1], vtPrevDer))
+            return false ;
+         vtNextDer = vtPrevDer ;
+      }
+     // salvo la derivata
+      m_vPrevDer.push_back( vtPrevDer) ;
+      m_vNextDer.push_back( vtNextDer) ;
+   }
+
+   return true ;
+}

DistPointCrvAux.cpp

@@ -116,7 +116,6 @@ PolishMinDistPointCurve( const Point3d& ptP, const ICurve& cCurve,
       vtDiff = ptQ - ptP ;
      // angolo tra vettore e tangente
       dTemp = vtDer1 * vtDiff ;
-      bool bEquiverse = dTemp > 0 ;
       if ( abs( dTemp) > EPS_ZERO) 
          dSqCosA = dTemp * dTemp / ( vtDer1.SqLen() * vtDiff.SqLen()) ;
       else
@@ -124,20 +123,8 @@ PolishMinDistPointCurve( const Point3d& ptP, const ICurve& cCurve,
      // stima prossimo valore del parametro (Newton : Unext = U - F(U) / F'(U))
       dPrevPar = dPar ;
       dTemp = vtDer2 * vtDiff + vtDer1.SqLen() ;
-
-      // se il coseno tra questi due vettori è troppo grande potrei aver avuto una cattiva stima iniziale
-      // provo quindi ad aggiustare a mano, anziché usare il segno suggerito da newton, che con queste premesse potrebbe divergere
-      double dCos75 = 0.2588 ;
-      if ( abs( dTemp) > EPS_ZERO) {
-         double dDelta = ( vtDer1 * vtDiff) / dTemp ;
-         if ( dSqCosA > dCos75) {
-            if ( ( bEquiverse  &&  dDelta > 0)  ||  ( ! bEquiverse  &&  dDelta < 0))
-               dDelta *= -1 ;
-            dPar = dPrevPar + dDelta ;
-         }
-         else
-            dPar = dPrevPar - dDelta ;
-      }
+      if ( abs( dTemp) > EPS_ZERO)
+         dPar = dPrevPar - ( vtDer1 * vtDiff) / dTemp ;
      // clipping parametro
       if ( dPar < approxMin.dParMin) {
          if ( approxMin.bParMinSing  &&  ! bClampedFromSing) {

DistPointCrvBezier.cpp

@@ -26,7 +26,7 @@ DistPointCrvBezier::DistPointCrvBezier( const Point3d& ptP, const ICurveBezier&
   // distanza non calcolata
    m_dDist = - 1 ;
 
-   if ( ! CrvBez.IsValid())
+   if ( &CrvBez == nullptr  ||  ! CrvBez.IsValid())
       return ;
 
   // determino tolleranza di approssimazione in base a ingombro curva
@@ -42,17 +42,6 @@ DistPointCrvBezier::DistPointCrvBezier( const Point3d& ptP, const ICurveBezier&
    if ( ! CrvBez.ApproxWithLines( dLinTol, ANG_TOL_APPROX_DEG, ICurve::APL_STD, PL))
       return ;
 
-   int nDeg = CrvBez.GetDegree() ;
-   if ( PL.GetPointNbr() < nDeg + 1) {
-      // costruisco una polilinea con un numero di curve scelto in base al grado della curva
-      PL.Clear() ; 
-      for ( int i = 0 ; i <= nDeg + 1 ; ++i) {
-         double dU = double(i) / (nDeg + 1) ;
-         Point3d ptBez ;
-         CrvBez.GetPointD1D2( dU, ICurve::Side::FROM_MINUS, ptBez) ;
-         PL.AddUPoint( dU, ptBez) ;
-      }
-   }
   // cerco la minima distanza per la polilinea
    MDCVECTOR vApproxMin ;
    if ( ! CalcMinDistPointPolyLine( ptP, PL, dLinTol, vApproxMin))

DistPointCurve.cpp

@@ -211,13 +211,13 @@ DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int&
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide, double dTol) const
+DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide) const
 {
    if ( m_dDist < 0  ||  nInd < 0  ||  nInd >= (int) m_Info.size())
       return false ;
 
   // se distanza nulla, il punto giace sulla curva
-   if ( m_dDist <= dTol) {
+   if ( m_dDist <= EPS_SMALL) {
       nSide = MDS_ON ;
       return true ;
    }
@@ -259,7 +259,7 @@ DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide
 
   // determino il lato di giacitura del punto
    double dSide = vtRef * ( m_ptP - ptQ) ;
-   if ( abs( dSide) < dTol)
+   if ( abs( dSide) < EPS_SMALL)
       nSide = MDS_ON ;
    else if ( dSide > 0)
       nSide = MDS_LEFT ;
@@ -270,7 +270,7 @@ DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide, double dTol) const
+DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide) const
 {
    if ( m_dDist < 0  ||  m_Info.empty())
       return false ;
@@ -286,7 +286,7 @@ DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, i
       }
    }
   // mi sono ricondotto al caso precedente
-   return GetSideAtMinDistPoint( nInd, vtN, nSide, dTol) ;
+   return GetSideAtMinDistPoint( nInd, vtN, nSide) ;
 }
 
 //----------------------------------------------------------------------------

DistPointSurfBz.cpp

@@ -23,10 +23,10 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 DistPointSurfBz::DistPointSurfBz( const Point3d& ptP, const ISurfBezier& pSrfBz)
-   : m_dDist( -1), m_bIsInside( false), m_bIsSurfClosed( false)
+   : m_dDist( -1), m_bIsInside( false)
 {
   // Bezier non valida 
-   if ( ! pSrfBz.IsValid())
+   if ( &pSrfBz == nullptr  ||  ! pSrfBz.IsValid())
       return ;
   // Calcolo la distanza
    Calculate( ptP, pSrfBz) ;
@@ -37,9 +37,9 @@ void
 DistPointSurfBz::Calculate( const Point3d& ptP, const ISurfBezier& srfBz)
 {
   // Inizializzo distanza non calcolata
-   m_dDist = -1 ;
+   m_dDist = - 1. ;
 
-  // Controllo se la superficie è chiusa
+  // Controllo se la superficie è chiusa
    m_bIsSurfClosed = srfBz.IsClosed() ;
 
   // Lavoro con l'oggetto superficie trimesh di base
@@ -49,17 +49,17 @@ DistPointSurfBz::Calculate( const Point3d& ptP, const ISurfBezier& srfBz)
 
    DistPointSurfTm dpst( ptP, *pStmRef) ;
 
-  // recupero il punto a distanza minima sulla trimesh e lo raffino, prima di restituire distanza e punto minimo
+  //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
+  //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
+  // se il punto è sulla superficie
    if ( m_dDist < EPS_SMALL) {
       m_bIsInside = false ;
       return ;
@@ -96,14 +96,13 @@ DistPointSurfBz::GetMinDistPoint( Point3d& ptMinDistPoint) const
 
 //----------------------------------------------------------------------------
 bool 
-DistPointSurfBz::GetParamsAtMinDistPoint( double& dU, double& dV) const
+DistPointSurfBz::GetParamPoint( Point3d& ptParamPoint) const
 {
   // Distanza non valida
    if ( m_dDist < -EPS_ZERO)
       return false ;
   // Distanza valida
-   dU = m_ptParam.x ;
-   dV = m_ptParam.y ;
+   ptParamPoint = m_ptParam ;
    return true ;
 }
 
@@ -117,4 +116,4 @@ DistPointSurfBz::GetNorm( Vector3d& vtN) const
   // Distanza valida
    vtN = m_vtN ;
    return true ;
-}
+}

EgtGeomKernel.vcxproj

@@ -281,7 +281,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="BBox3d.cpp" />
     <ClCompile Include="BiArcs.cpp" />
     <ClCompile Include="CalcPocketing.cpp" />
-    <ClCompile Include="CalcDerivate.cpp" />
     <ClCompile Include="CAvSilhouetteSurfTm.cpp" />
     <ClCompile Include="CAvSimpleSurfFrMove.cpp" />
     <ClCompile Include="CAvToolSurfTm.cpp" />

EgtGeomKernel.vcxproj.filters

@@ -567,9 +567,6 @@
     <ClCompile Include="Trimming.cpp">
       <Filter>File di origine\GeoStriping</Filter>
     </ClCompile>
-    <ClCompile Include="CalcDerivate.cpp">
-      <Filter>File di origine\Geo</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="stdafx.h">

IntersCrvCompoCrvCompo.cpp

@@ -19,15 +19,14 @@
 #include "/EgtDev/Include/EGkAngle.h"
 #include "/EgtDev/Include/EGkHashGrids2d.h"
 #include <algorithm>
-#include <ranges>
 
 using namespace std ;
 
 //--------------------------- Local functions --------------------------------
 static bool CompatibleParamA( const IntCrvCrvInfo& Icci1, const IntCrvCrvInfo& Icci2,
-                              bool bCrvAClosed, double dCrvASpan, bool bOrderedOnB = false) ;
+                              bool bCrvAClosed, double dCrvASpan) ;
 static bool CompatibleParamB( const IntCrvCrvInfo& Icci1, const IntCrvCrvInfo& Icci2,
-                              bool bCrvBClosed, double dCrvBSpan, bool bOrderedOnB = false) ;
+                              bool bCrvBClosed, double dCrvBSpan) ;
 static void MediaParamPoints( IntCrvInfo& Ici1, IntCrvInfo& Ici2, const ICurveComposite& crvCompo) ;
 static int  GetCrvBDirAPrev( IntCrvCrvInfo& Icci) ;
 static int  GetCrvBDirANext( IntCrvCrvInfo& Icci) ;
@@ -198,7 +197,7 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
               // se coincidono U e ptInt tra A e B
                if ( abs( m_Info[i].IciA[0].dU - m_Info[j].IciB[0].dU) < EPS_SMALL  &&
                     AreSamePointXYEpsilon( m_Info[i].IciA[0].ptI, m_Info[j].IciB[0].ptI, 10 * EPS_SMALL)) {
-                 // se non è alla fine di curva chiusa 
+                 // se non è alla fine di curva chiusa 
                   if ( ! bCrvAClosed  ||  abs( m_Info[j].IciA[0].dU - dCrvBSpan) > EPS_SMALL)
                     // elimino la seconda
                      EraseOtherInfo( i, j) ;
@@ -262,9 +261,10 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
               abs( m_Info[i].IciA[0].dU - m_Info[j].IciA[0].dU) < EPS_PARAM  &&
               abs( m_Info[i].IciA[1].dU - m_Info[j].IciA[1].dU) < EPS_PARAM) {
            // cancello entrambe
-            EraseBothInfo( i, j) ;
+            EraseOtherInfo( i, j) ;
+            EraseCurrentInfo( i, j) ;
          }
-        // caso DET-(NULL) -> (NULL)-DET per prima curva
+        // caso DET-NULL -> NULL-DET per prima curva
          else if ( m_Info[j].IciA[kj].nPrevTy != ICCT_NULL  &&  m_Info[j].IciA[kj].nNextTy == ICCT_NULL  &&
               m_Info[i].IciA[ki].nPrevTy == ICCT_NULL  &&  m_Info[i].IciA[ki].nNextTy != ICCT_NULL) {
            // per la prima curva tengo i determinati
@@ -272,22 +272,16 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
             m_Info[j].IciA[kj].nNextTy = m_Info[i].IciA[ki].nNextTy ;
            // se overlap equiverso
             if ( m_Info[i].bOverlap  &&  m_Info[i].bCBOverEq) {
-              // per la seconda curva ogni sottotipo è il duale di quello della prima
+              // per la seconda curva ogni sottotipo è il duale di quello della prima
                m_Info[i].IciB[ki].nPrevTy = GetDualIcct( m_Info[i].IciA[ki].nPrevTy) ;
                m_Info[i].IciB[ki].nNextTy = GetDualIcct( m_Info[i].IciA[ki].nNextTy) ;
             }
            // se altrimenti overlap controverso
             else if ( m_Info[i].bOverlap  &&  ! m_Info[i].bCBOverEq) {
-              // per la seconda curva ogni sottotipo è come quello della prima ma in posizione invertita
+              // per la seconda curva ogni sottotipo è come quello della prima ma in posizione invertita
                m_Info[i].IciB[ki].nPrevTy = m_Info[i].IciA[ki].nNextTy ;
                m_Info[i].IciB[ki].nNextTy = m_Info[i].IciA[ki].nPrevTy ;
             }
-            else {
-               if ( m_Info[i].IciB[ki].nPrevTy  == ICCT_NULL)
-                  m_Info[i].IciB[ki].nPrevTy = m_Info[j].IciB[kj].nPrevTy ;
-               if ( m_Info[i].IciB[ki].nNextTy  == ICCT_NULL)
-                  m_Info[i].IciB[ki].nNextTy = m_Info[j].IciB[kj].nNextTy ;
-            }
            // se overlap equiverso
             if ( m_Info[j].bOverlap  &&  m_Info[j].bCBOverEq) {
                m_Info[j].IciB[kj].nPrevTy = GetDualIcct( m_Info[i].IciA[ki].nPrevTy) ;
@@ -298,13 +292,6 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
                m_Info[j].IciB[kj].nPrevTy = m_Info[i].IciA[ki].nNextTy ;
                m_Info[j].IciB[kj].nNextTy = m_Info[i].IciA[ki].nPrevTy ;
             }
-            else {
-               if ( m_Info[j].IciB[kj].nPrevTy  == ICCT_NULL)
-                  m_Info[j].IciB[kj].nPrevTy = m_Info[i].IciB[ki].nPrevTy ;
-               if ( m_Info[j].IciB[kj].nNextTy  == ICCT_NULL)
-                  m_Info[j].IciB[kj].nNextTy = m_Info[i].IciB[ki].nNextTy ;
-            }
-
            // medio parametri e punti separatamente per le due curve
             MediaParamPoints( m_Info[i].IciA[ki], m_Info[j].IciA[kj], CCompoA) ;
             MediaParamPoints( m_Info[i].IciB[ki], m_Info[j].IciB[kj], CCompoB) ;
@@ -319,7 +306,7 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
                EraseCurrentInfo( i, j) ;
             }
          }
-        // caso (NULL)-DET -> DET-(NULL) per prima curva (possibile su inizio/fine di curva chiusa)
+        // caso NULL-DET -> DET-NULL per prima curva (possibile su inizio/fine di curva chiusa)
          else if ( m_Info[j].IciA[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciA[kj].nNextTy != ICCT_NULL  &&
                    m_Info[i].IciA[ki].nPrevTy != ICCT_NULL  &&  m_Info[i].IciA[ki].nNextTy == ICCT_NULL) {
            // per la prima curva tengo i determinati
@@ -327,41 +314,28 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
             m_Info[j].IciA[kj].nPrevTy = m_Info[i].IciA[ki].nPrevTy ;
            // se overlap equiverso
             if ( m_Info[i].bOverlap  &&  m_Info[i].bCBOverEq) {
-              // per la seconda curva ogni sottotipo è il duale di quello della prima
+              // per la seconda curva ogni sottotipo è il duale di quello della prima
                m_Info[i].IciB[ki].nPrevTy = GetDualIcct( m_Info[i].IciA[ki].nPrevTy) ;
                m_Info[i].IciB[ki].nNextTy = GetDualIcct( m_Info[i].IciA[ki].nNextTy) ;
             }
            // se altrimenti overlap controverso
             else if ( m_Info[i].bOverlap  &&  ! m_Info[i].bCBOverEq) {
-              // per la seconda curva ogni sottotipo è come quello della prima ma in posizione scambiata
+              // per la seconda curva ogni sottotipo è come quello della prima ma in posizione scambiata
                m_Info[i].IciB[ki].nPrevTy = m_Info[i].IciA[ki].nNextTy ;
                m_Info[i].IciB[ki].nNextTy = m_Info[i].IciA[ki].nPrevTy ;
             }
-            else {
-               if ( m_Info[i].IciB[ki].nPrevTy  == ICCT_NULL)
-                  m_Info[i].IciB[ki].nPrevTy = m_Info[j].IciB[kj].nPrevTy ;
-               if ( m_Info[i].IciB[ki].nNextTy  == ICCT_NULL)
-                  m_Info[i].IciB[ki].nNextTy = m_Info[j].IciB[kj].nNextTy ;
-            }
            // se overlap equiverso
             if ( m_Info[j].bOverlap  &&  m_Info[j].bCBOverEq) {
-              // per la seconda curva ogni sottotipo è il duale di quello della prima
+              // per la seconda curva ogni sottotipo è il duale di quello della prima
                m_Info[j].IciB[kj].nPrevTy = GetDualIcct( m_Info[i].IciA[ki].nPrevTy) ;
                m_Info[j].IciB[kj].nNextTy = GetDualIcct( m_Info[i].IciA[ki].nNextTy) ;
             }
            // se altrimenti overlap controverso
             else if ( m_Info[i].bOverlap  &&  ! m_Info[i].bCBOverEq) {
-              // per la seconda curva ogni sottotipo è come quello della prima ma in posizione scambiata
+              // per la seconda curva ogni sottotipo è come quello della prima ma in posizione scambiata
                m_Info[j].IciB[kj].nPrevTy = m_Info[i].IciA[ki].nNextTy ;
                m_Info[j].IciB[kj].nNextTy = m_Info[i].IciA[ki].nPrevTy ;
             }
-            else {
-               if ( m_Info[j].IciB[kj].nPrevTy  == ICCT_NULL)
-                  m_Info[j].IciB[kj].nPrevTy = m_Info[i].IciB[ki].nPrevTy ;
-               if ( m_Info[j].IciB[kj].nNextTy  == ICCT_NULL)
-                  m_Info[j].IciB[kj].nNextTy = m_Info[i].IciB[ki].nNextTy ;
-            }
-
            // medio parametri e punti separatamente per le due curve
             MediaParamPoints( m_Info[i].IciA[ki], m_Info[j].IciA[kj], CCompoA) ;
             MediaParamPoints( m_Info[i].IciB[ki], m_Info[j].IciB[kj], CCompoB) ;
@@ -382,7 +356,8 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
                    m_Info[j].IciB[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciB[kj].nNextTy == ICCT_NULL  &&
                    m_Info[i].IciB[ki].nPrevTy == ICCT_NULL  &&  m_Info[i].IciB[ki].nNextTy == ICCT_NULL) {
            // cancello entrambe
-            EraseBothInfo( i, j) ;
+            EraseOtherInfo( i, j) ;
+            EraseCurrentInfo( i, j) ;
          }
         // caso NULL-DET -> NULL-DET per prima curva con NULL-NULL -> NULL-NULL su seconda curva 
          else if ( m_Info[j].IciA[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciA[kj].nNextTy != ICCT_NULL  &&
@@ -390,25 +365,18 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
                    m_Info[j].IciB[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciB[kj].nNextTy == ICCT_NULL  &&
                    m_Info[i].IciB[ki].nPrevTy == ICCT_NULL  &&  m_Info[i].IciB[ki].nNextTy == ICCT_NULL) {
            // cancello entrambe
-            EraseBothInfo( i, j) ;
+            EraseOtherInfo( i, j) ;
+            EraseCurrentInfo( i, j) ;
          }
         // caso NULL-NULL per corrente di prima curva
          else if ( m_Info[i].IciA[ki].nPrevTy == ICCT_NULL  &&  m_Info[i].IciA[ki].nNextTy == ICCT_NULL) {
-            m_Info[j].IciA[kj].nNextTy = ICCT_NULL ;
-            if ( m_Info[j].IciB[kj].nNextTy == ICCT_NULL)
-               m_Info[j].IciB[kj].nNextTy = m_Info[i].IciB[ki].nNextTy ;
-            if ( m_Info[j].IciB[kj].nPrevTy == ICCT_NULL)
-               m_Info[j].IciB[kj].nPrevTy = m_Info[i].IciB[ki].nPrevTy ;
+            m_Info[j].IciA[kj].nNextTy = m_Info[i].IciA[ki].nNextTy ;
            // cancello l'intersezione corrente (non aggiunge nulla rispetto alla precedente)
             EraseCurrentInfo( i, j) ;
          }
         // caso NULL-NULL per precedente di prima curva
          else if ( m_Info[j].IciA[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciA[kj].nNextTy == ICCT_NULL) {
-            m_Info[i].IciA[ki].nPrevTy = ICCT_NULL ;
-            if ( m_Info[i].IciB[ki].nPrevTy == ICCT_NULL)
-               m_Info[i].IciB[ki].nPrevTy = m_Info[j].IciB[kj].nPrevTy ;
-            if ( m_Info[i].IciB[ki].nNextTy == ICCT_NULL)
-               m_Info[i].IciB[ki].nNextTy = m_Info[j].IciB[kj].nNextTy ;
+            m_Info[i].IciA[0].nPrevTy = m_Info[j].IciA[0].nPrevTy ;
            // cancello l'intersezione precedente (non aggiunge nulla rispetto alla corrente)
             EraseOtherInfo( i, j) ;
          }
@@ -427,21 +395,22 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
             continue ;
       }
      // calcolo sottoindici
-      int ki = ( m_Info[i].bOverlap && ! m_Info[i].bCBOverEq ? 1 : 0) ;
-      int kj = ( m_Info[j].bOverlap && m_Info[j].bCBOverEq ? 1 : 0) ;
+      int ki = 0 ;                              // del successivo si prende sempre il primo
+      int kj = ( m_Info[j].bOverlap ? 1 : 0) ;  // del precedente si prende il secondo se overlap
      // verifico se precedente e corrente si riferiscono alla stessa intersezione (10 * EPS_SMALL)
       if ( AreSamePointXYEpsilon( m_Info[j].IciA[kj].ptI, m_Info[i].IciA[ki].ptI, 10 * EPS_SMALL) &&
            AreSamePointXYEpsilon( m_Info[j].IciB[kj].ptI, m_Info[i].IciB[ki].ptI, 10 * EPS_SMALL) &&
-           CompatibleParamA( m_Info[j], m_Info[i], bCrvAClosed, dCrvASpan, true)  &&
-           CompatibleParamB( m_Info[j], m_Info[i], bCrvBClosed, dCrvBSpan, true)) {
+           CompatibleParamA( m_Info[j], m_Info[i], bCrvAClosed, dCrvASpan)  &&
+           CompatibleParamB( m_Info[j], m_Info[i], bCrvBClosed, dCrvBSpan)) {
         // caso entrambi Overlap ma di tipo opposto e sullo stesso tratto
          if ( m_Info[i].bOverlap  &&  m_Info[j].bOverlap  &&  m_Info[i].bCBOverEq != m_Info[j].bCBOverEq  &&
               abs( m_Info[i].IciB[0].dU - m_Info[j].IciB[0].dU) < EPS_PARAM  &&
               abs( m_Info[i].IciB[1].dU - m_Info[j].IciB[1].dU) < EPS_PARAM) {
            // cancello entrambe
-            EraseBothInfo( i, j) ;
+            EraseOtherInfo( i, j) ;
+            EraseCurrentInfo( i, j) ;
          }
-        // caso DET-(NULL) -> (NULL)-DET per seconda curva
+        // caso DET-NULL -> NULL-DET per seconda curva
          else if ( m_Info[j].IciB[kj].nPrevTy != ICCT_NULL  &&  m_Info[j].IciB[kj].nNextTy == ICCT_NULL  &&
                    m_Info[i].IciB[ki].nPrevTy == ICCT_NULL  &&  m_Info[i].IciB[ki].nNextTy != ICCT_NULL) {
            // per la seconda curva tengo i determinati
@@ -449,40 +418,28 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
             m_Info[j].IciB[kj].nNextTy = m_Info[i].IciB[ki].nNextTy ;
            // se overlap equiverso
             if ( m_Info[i].bOverlap  &&  m_Info[i].bCBOverEq) {
-              // per la prima curva ogni sottotipo è il duale di quello della seconda
+              // per la prima curva ogni sottotipo è il duale di quello della seconda
                m_Info[i].IciA[ki].nPrevTy = GetDualIcct( m_Info[i].IciB[ki].nPrevTy) ;
                m_Info[i].IciA[ki].nNextTy = GetDualIcct( m_Info[i].IciB[ki].nNextTy) ;
             }
            // se altrimenti overlap controverso
             else if ( m_Info[i].bOverlap  &&  ! m_Info[i].bCBOverEq) {
-              // per la prima curva ogni sottotipo è come quello della seconda ma in posizione scambiata
+              // per la prima curva ogni sottotipo è come quello della seconda ma in posizione scambiata
                m_Info[i].IciA[ki].nPrevTy = m_Info[i].IciB[ki].nNextTy ;
                m_Info[i].IciA[ki].nNextTy = m_Info[i].IciB[ki].nPrevTy ;
             }
-            else {
-               if ( m_Info[i].IciA[ki].nPrevTy  == ICCT_NULL)
-                  m_Info[i].IciA[ki].nPrevTy = m_Info[j].IciA[kj].nPrevTy ;
-               if ( m_Info[i].IciA[ki].nNextTy  == ICCT_NULL)
-                  m_Info[i].IciA[ki].nNextTy = m_Info[j].IciA[kj].nNextTy ;
-            }
             // se overlap equiverso
             if ( m_Info[j].bOverlap  &&  m_Info[j].bCBOverEq) {
-              // per la prima curva ogni sottotipo è il duale di quello della seconda
+              // per la prima curva ogni sottotipo è il duale di quello della seconda
                m_Info[j].IciA[kj].nPrevTy = GetDualIcct( m_Info[i].IciB[ki].nPrevTy) ;
                m_Info[j].IciA[kj].nNextTy = GetDualIcct( m_Info[i].IciB[ki].nNextTy) ;
             }
            // se altrimenti overlap controverso
             else if ( m_Info[j].bOverlap  &&  ! m_Info[j].bCBOverEq) {
-              // per la prima curva ogni sottotipo è come quello della seconda ma in posizione scambiata
+              // per la prima curva ogni sottotipo è come quello della seconda ma in posizione scambiata
                m_Info[j].IciA[kj].nPrevTy = m_Info[i].IciB[ki].nNextTy ;
                m_Info[j].IciA[kj].nNextTy = m_Info[i].IciB[ki].nPrevTy ;
             }
-            else {
-               if ( m_Info[j].IciA[kj].nPrevTy  == ICCT_NULL)
-                  m_Info[j].IciA[kj].nPrevTy = m_Info[i].IciA[ki].nPrevTy ;
-               if ( m_Info[j].IciA[kj].nNextTy  == ICCT_NULL)
-                  m_Info[j].IciA[kj].nNextTy = m_Info[i].IciA[ki].nNextTy ;
-            }
            // medio parametri e punti separatamente per le due curve
             MediaParamPoints( m_Info[i].IciA[ki], m_Info[j].IciA[kj], CCompoA) ;
             MediaParamPoints( m_Info[i].IciB[ki], m_Info[j].IciB[kj], CCompoB) ;
@@ -497,7 +454,7 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
                EraseCurrentInfo( i, j) ;
             }
          }
-        // caso (NULL)-DET -> DET-(NULL) per seconda curva (possibile su inizio/fine di curva chiusa)
+        // caso NULL-DET -> DET-NULL per seconda curva (possibile su inizio/fine di curva chiusa)
          else if ( m_Info[j].IciB[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciB[kj].nNextTy != ICCT_NULL  &&
                    m_Info[i].IciB[ki].nPrevTy != ICCT_NULL  &&  m_Info[i].IciB[ki].nNextTy == ICCT_NULL) {
            // per la seconda curva tengo i determinati
@@ -505,40 +462,28 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
             m_Info[j].IciB[kj].nPrevTy = m_Info[i].IciB[ki].nPrevTy ;
            // se overlap equiverso
             if ( m_Info[i].bOverlap  &&  m_Info[i].bCBOverEq) {
-              // per la prima curva ogni sottotipo è il duale di quello della seconda
+              // per la prima curva ogni sottotipo è il duale di quello della seconda
                m_Info[i].IciA[ki].nPrevTy = GetDualIcct( m_Info[i].IciB[ki].nPrevTy) ;
                m_Info[i].IciA[ki].nNextTy = GetDualIcct( m_Info[i].IciB[ki].nNextTy) ;
             }
            // se altrimenti overlap controverso
             else if ( m_Info[i].bOverlap  &&  ! m_Info[i].bCBOverEq) {
-              // per la prima curva ogni sottotipo è come quello della seconda ma in posizione scambiata
+              // per la prima curva ogni sottotipo è come quello della seconda ma in posizione scambiata
                m_Info[i].IciA[ki].nPrevTy = m_Info[i].IciB[ki].nNextTy ;
                m_Info[i].IciA[ki].nNextTy = m_Info[i].IciB[ki].nPrevTy ;
             }
-            else {
-               if ( m_Info[i].IciA[ki].nPrevTy  == ICCT_NULL)
-                  m_Info[i].IciA[ki].nPrevTy = m_Info[j].IciA[kj].nPrevTy ;
-               if ( m_Info[i].IciA[ki].nNextTy  == ICCT_NULL)
-                  m_Info[i].IciA[ki].nNextTy = m_Info[j].IciA[kj].nNextTy ;
-            }
             // se overlap equiverso
             if ( m_Info[j].bOverlap  &&  m_Info[j].bCBOverEq) {
-              // per la prima curva ogni sottotipo è il duale di quello della seconda
+              // per la prima curva ogni sottotipo è il duale di quello della seconda
                m_Info[j].IciA[kj].nPrevTy = GetDualIcct( m_Info[i].IciB[ki].nPrevTy) ;
                m_Info[j].IciA[kj].nNextTy = GetDualIcct( m_Info[i].IciB[ki].nNextTy) ;
             }
            // se altrimenti overlap controverso
             else if ( m_Info[j].bOverlap  &&  ! m_Info[j].bCBOverEq) {
-              // per la prima curva ogni sottotipo è come quello della seconda ma in posizione scambiata
+              // per la prima curva ogni sottotipo è come quello della seconda ma in posizione scambiata
                m_Info[j].IciA[kj].nPrevTy = m_Info[i].IciB[ki].nNextTy ;
                m_Info[j].IciA[kj].nNextTy = m_Info[i].IciB[ki].nPrevTy ;
             }
-            else {
-               if ( m_Info[j].IciA[kj].nPrevTy  == ICCT_NULL)
-                  m_Info[j].IciA[kj].nPrevTy = m_Info[i].IciA[ki].nPrevTy ;
-               if ( m_Info[j].IciA[kj].nNextTy  == ICCT_NULL)
-                  m_Info[j].IciA[kj].nNextTy = m_Info[i].IciA[ki].nNextTy ;
-            }
            // medio parametri e punti separatamente per le due curve
             MediaParamPoints( m_Info[i].IciA[ki], m_Info[j].IciA[kj], CCompoA) ;
             MediaParamPoints( m_Info[i].IciB[ki], m_Info[j].IciB[kj], CCompoB) ;
@@ -559,7 +504,8 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
                    m_Info[j].IciA[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciA[kj].nNextTy == ICCT_NULL  &&
                    m_Info[i].IciA[ki].nPrevTy == ICCT_NULL  &&  m_Info[i].IciA[ki].nNextTy == ICCT_NULL) {
            // cancello entrambe
-            EraseBothInfo( i, j) ;
+            EraseOtherInfo( i, j) ;
+            EraseCurrentInfo( i, j) ;
          }
         // caso NULL-DET -> NULL-DET per seconda curva con NULL-NULL -> NULL-NULL su prima curva 
          else if ( m_Info[j].IciB[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciB[kj].nNextTy != ICCT_NULL  &&
@@ -567,25 +513,22 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
                    m_Info[j].IciA[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciA[kj].nNextTy == ICCT_NULL  &&
                    m_Info[i].IciA[ki].nPrevTy == ICCT_NULL  &&  m_Info[i].IciA[ki].nNextTy == ICCT_NULL) {
            // cancello entrambe
-            EraseBothInfo( i, j) ;
+            EraseOtherInfo( i, j) ;
+            EraseCurrentInfo( i, j) ;
          }
         // caso NULL-NULL per corrente di seconda curva
          else if ( m_Info[i].IciB[ki].nPrevTy == ICCT_NULL  &&  m_Info[i].IciB[ki].nNextTy == ICCT_NULL) {
-            m_Info[j].IciB[kj].nNextTy = ICCT_NULL ;
-            if ( m_Info[j].IciA[kj].nNextTy == ICCT_NULL)
+            m_Info[j].IciB[kj].nNextTy = m_Info[i].IciB[ki].nNextTy ;
+            if ( m_Info[i].IciA[ki].dU > m_Info[j].IciA[kj].dU + EPS_PARAM)
                m_Info[j].IciA[kj].nNextTy = m_Info[i].IciA[ki].nNextTy ;
-            if ( m_Info[j].IciA[kj].nPrevTy == ICCT_NULL)
-               m_Info[j].IciA[kj].nPrevTy = m_Info[i].IciA[ki].nPrevTy ;
            // cancello l'intersezione corrente (non aggiunge nulla rispetto alla precedente)
             EraseCurrentInfo( i, j) ;
          }
         // caso NULL-NULL per precedente di seconda curva
          else if ( m_Info[j].IciB[kj].nPrevTy == ICCT_NULL  &&  m_Info[j].IciB[kj].nNextTy == ICCT_NULL) {
-            m_Info[i].IciB[ki].nPrevTy = ICCT_NULL ;
-            if ( m_Info[i].IciA[ki].nPrevTy == ICCT_NULL)
-               m_Info[i].IciA[ki].nPrevTy = m_Info[j].IciA[kj].nPrevTy ;
-            if ( m_Info[i].IciA[ki].nNextTy == ICCT_NULL)
-               m_Info[i].IciA[ki].nNextTy = m_Info[j].IciA[kj].nNextTy ;
+            m_Info[i].IciB[0].nPrevTy = m_Info[j].IciB[0].nPrevTy ;
+            if ( m_Info[j].IciA[0].dU < m_Info[i].IciA[0].dU - EPS_PARAM)
+               m_Info[i].IciA[0].nPrevTy = m_Info[j].IciA[0].nPrevTy ;
            // cancello l'intersezione precedente (non aggiunge nulla rispetto alla corrente)
             EraseOtherInfo( i, j) ;
          }
@@ -594,16 +537,16 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
   // ripristino ordinamento su prima curva
    stable_sort( m_Info.begin(), m_Info.end(), SortGreaterA) ;
 
-  // verifico se sono rimaste delle intersezioni di tipo non definito sulla curva A e cerco di risolverle per continuità
+  // verifico se sono rimaste delle intersezioni di tipo non definito sulla curva A e cerco di risolverle per continuità
    for ( int i = 0 ; i < m_nNumInters ; ++ i) {
-     // se il tipo di accostamento per la curva A non è definito
+     // se il tipo di accostamento per la curva A non è definito
       if ( m_Info[i].IciA[0].nPrevTy == ICCT_NULL) {
          if ( i > 0  ||  ( bCrvAClosed  &&  ! bAutoInters)) {
             int j = ( i > 0 ? i - 1 : m_nNumInters - 1) ;
             m_Info[i].IciA[0].nPrevTy = ( m_Info[j].bOverlap ? m_Info[j].IciA[1].nNextTy : m_Info[j].IciA[0].nNextTy) ;
          }
       }
-     // se il tipo di allontanamento per la curva A non è definito
+     // se il tipo di allontanamento per la curva A non è definito
       int ki = ( m_Info[i].bOverlap ? 1 : 0) ;
       if ( m_Info[i].IciA[ki].nNextTy == ICCT_NULL) {
          if ( i < m_nNumInters - 1  ||  ( bCrvAClosed  &&  ! bAutoInters)) {
@@ -613,23 +556,21 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
       }
    }
 
-  // verifico se sono rimaste delle intersezioni di tipo non definito sulla curva B e cerco di risolverle per continuità
+  // verifico se sono rimaste delle intersezioni di tipo non definito sulla curva B e cerco di risolverle per continuità
    stable_sort( m_Info.begin(), m_Info.end(), SortGreaterB) ;
    for ( int i = 0 ; i < m_nNumInters ; ++ i) {
-     // se il tipo di accostamento per la curva B non è definito
-      int ki = ( m_Info[i].bOverlap && ! m_Info[i].bCBOverEq ? 1 : 0) ;
-      if ( m_Info[i].IciB[ki].nPrevTy == ICCT_NULL) {
+     // se il tipo di accostamento per la curva B non è definito
+      if ( m_Info[i].IciB[0].nPrevTy == ICCT_NULL) {
          if ( i > 0  ||  ( bCrvBClosed  &&  ! bAutoInters)) {
             int j = ( i > 0 ? i - 1 : m_nNumInters - 1) ;
-            m_Info[i].IciB[ki].nPrevTy = ( m_Info[j].bOverlap && m_Info[j].bCBOverEq ? m_Info[j].IciB[1].nNextTy : m_Info[j].IciB[0].nNextTy) ;
+            m_Info[i].IciB[0].nPrevTy = ( m_Info[j].bOverlap && ! m_Info[j].bCBOverEq ? m_Info[j].IciB[1].nNextTy : m_Info[j].IciB[0].nNextTy) ;
          }
       }
-     // se il tipo di allontanamento per la curva B non è definito
-      ki = ( m_Info[i].bOverlap && m_Info[i].bCBOverEq ? 1 : 0) ;
-      if ( m_Info[i].IciB[ki].nNextTy == ICCT_NULL) {
+     // se il tipo di allontanamento per la curva B non è definito
+      if ( m_Info[i].IciB[0].nNextTy == ICCT_NULL) {
          if ( i < m_nNumInters - 1  ||  ( bCrvBClosed  &&  ! bAutoInters)) {
             int j = ( i < m_nNumInters - 1 ? i + 1 : 0) ;
-            m_Info[i].IciB[ki].nNextTy = ( m_Info[j].bOverlap && ! m_Info[j].bCBOverEq ? m_Info[j].IciB[1].nPrevTy : m_Info[j].IciB[0].nPrevTy) ;
+            m_Info[i].IciB[0].nNextTy = ( m_Info[j].bOverlap && ! m_Info[j].bCBOverEq ? m_Info[j].IciB[1].nPrevTy : m_Info[j].IciB[0].nPrevTy) ;
          }
       }
    }
@@ -640,7 +581,7 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
    for ( int i = 0 ; i < m_nNumInters ; ++ i) {
      // in assenza di overlap
       if ( ! m_Info[i].bOverlap) {
-        // se il tipo di accostamento per la curva A non è definito
+        // se il tipo di accostamento per la curva A non è definito
          if ( m_Info[i].IciA[0].nPrevTy == ICCT_NULL) {
            // devo studiare un intorno dell'intersezione
             int nType ;
@@ -649,7 +590,7 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
               // aggiorno il tipo di accostamento della curva A alla curva B
                m_Info[i].IciA[0].nPrevTy = nType ;
          }
-        // se il tipo di accostamento per la curva B non è definito
+        // se il tipo di accostamento per la curva B non è definito
          if ( m_Info[i].IciB[0].nPrevTy == ICCT_NULL) {
            // devo studiare un intorno dell'intersezione
             int nType ;
@@ -658,7 +599,7 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
               // aggiorno il tipo di accostamento della curva B alla curva A
                m_Info[i].IciB[0].nPrevTy = nType ;
          }
-        // se il tipo di allontanamento per la curva A non è definito
+        // se il tipo di allontanamento per la curva A non è definito
          if ( m_Info[i].IciA[0].nNextTy == ICCT_NULL) {
            // devo studiare un intorno dell'intersezione
             int nType ;
@@ -667,7 +608,7 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
               // aggiorno il tipo di allontanamento della curva A dalla curva B
                m_Info[i].IciA[0].nNextTy = nType ;
          }
-        // se il tipo di allontanamento per la curva B non è definito
+        // se il tipo di allontanamento per la curva B non è definito
          if ( m_Info[i].IciB[0].nNextTy == ICCT_NULL) {
            // devo studiare un intorno dell'intersezione
             int nType ;
@@ -679,69 +620,67 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
       }
      // in presenza di overlap
       else {
-        // se il tipo di accostamento è non definito per la curva A
+        // se il tipo di accostamento è non definito per la curva A
          if ( m_Info[i].IciA[0].nPrevTy == ICCT_NULL) {
-            // devo studiare un intorno dell'intersezione
-            int nType ;
-            if ( CalcATypeFromDisk( CCompoA, m_Info[i].IciA[0].dU, ICurve::FROM_MINUS,
-                                    CCompoB, m_Info[i].IciB[0].dU, nType)) {
-               // aggiorno il tipo di accostamento della curva A alla curva B
-               m_Info[i].IciA[0].nPrevTy = nType ;
-               // aggiorno anche il corrispondente tipo sulla curva B
-               if ( m_Info[i].bCBOverEq)
-                  m_Info[i].IciB[0].nPrevTy = GetDualIcct( nType) ;
-               else
-                  m_Info[i].IciB[0].nNextTy = nType ;
-            }
-         }
-        // se il tipo di allontanamento è non definito per la curva A
-         if ( m_Info[i].IciA[1].nNextTy == ICCT_NULL) {
-            // devo studiare un intorno dell'intersezione
-            int nType ;
-            if ( CalcATypeFromDisk( CCompoA, m_Info[i].IciA[1].dU, ICurve::FROM_PLUS,
-                                    CCompoB, m_Info[i].IciB[1].dU, nType)) {
-               // aggiorno il tipo di allontanamento della curva A dalla curva B
-               m_Info[i].IciA[1].nNextTy = nType ;
-               // aggiorno anche il corrispondente tipo sulla curva B
-               if ( m_Info[i].bCBOverEq)
-                  m_Info[i].IciB[1].nNextTy = GetDualIcct( nType) ;
-               else
-                  m_Info[i].IciB[1].nPrevTy = nType ;
-            }
-         }
-      }
-   }
-
-   if ( bAutoInters) {
-      // controllo l'eventuale presenza di spike
-      for ( int i = 0 ; i < m_nNumInters ; ++ i) {
-         if ( m_Info[i].bOverlap  &&  ! m_Info[i].bCBOverEq) {
-           // se secondo tratto dello spike
+           // se autointersezione con spike
             double dDeltaU = abs( m_Info[i].IciA[0].dU - m_Info[i].IciB[0].dU) ;
-            if ( dDeltaU < EPS_PARAM  ||  ( bCrvAClosed  &&  abs( dDeltaU - dCrvASpan) < EPS_PARAM)) {
-               // è punta di spike
+            if ( bAutoInters  &&  ( dDeltaU < EPS_PARAM  ||  ( bCrvAClosed  &&  abs( dDeltaU - dCrvASpan) < EPS_PARAM))) {
+              // è punta di spike
                int nType = ICCT_SPK ;
-               // aggiorno il tipo di allontanamento della curva A dalla curva B
+              // aggiorno il tipo di allontanamento della curva A dalla curva B
                m_Info[i].IciA[0].nPrevTy = nType ;
-               // aggiorno anche il corrispondente tipo sulla curva B
+              // aggiorno anche il corrispondente tipo sulla curva B
                if ( m_Info[i].bCBOverEq)
                   m_Info[i].IciB[0].nPrevTy = GetDualIcct( nType) ;
                else
                   m_Info[i].IciB[0].nNextTy = nType ;
             }
-           // se primo tratto dello spike
-            dDeltaU = abs( m_Info[i].IciA[1].dU - m_Info[i].IciB[1].dU) ;
-            if ( dDeltaU < EPS_PARAM  ||  ( bCrvAClosed  &&  abs( dDeltaU - dCrvASpan) < EPS_PARAM)) {
-               // è punta di spike
+           // caso standard
+            else {
+              // devo studiare un intorno dell'intersezione
+               int nType ;
+               if ( CalcATypeFromDisk( CCompoA, m_Info[i].IciA[0].dU, ICurve::FROM_MINUS,
+                                       CCompoB, m_Info[i].IciB[0].dU, nType)) {
+                 // aggiorno il tipo di accostamento della curva A alla curva B
+                  m_Info[i].IciA[0].nPrevTy = nType ;
+                 // aggiorno anche il corrispondente tipo sulla curva B
+                  if ( m_Info[i].bCBOverEq)
+                     m_Info[i].IciB[0].nPrevTy = GetDualIcct( nType) ;
+                  else
+                     m_Info[i].IciB[0].nNextTy = nType ;
+               }
+            }
+         }
+        // se il tipo di allontanamento è non definito per la curva A
+         if ( m_Info[i].IciA[1].nNextTy == ICCT_NULL) {
+           // se autointersezione con spike
+            double dDeltaU = abs( m_Info[i].IciA[1].dU - m_Info[i].IciB[1].dU) ;
+            if ( bAutoInters  &&  ( dDeltaU < EPS_PARAM  ||  ( bCrvAClosed  &&  abs( dDeltaU - dCrvASpan) < EPS_PARAM))) {
+              // è punta di spike
                int nType = ICCT_SPK ;
-               // aggiorno il tipo di allontanamento della curva A dalla curva B
+              // aggiorno il tipo di allontanamento della curva A dalla curva B
                m_Info[i].IciA[1].nNextTy = nType ;
-               // aggiorno anche il corrispondente tipo sulla curva B
+              // aggiorno anche il corrispondente tipo sulla curva B
                if ( m_Info[i].bCBOverEq)
                   m_Info[i].IciB[1].nNextTy = GetDualIcct( nType) ;
                else
                   m_Info[i].IciB[1].nPrevTy = nType ;
             }
+           // caso standard
+            else {
+              // devo studiare un intorno dell'intersezione
+               int nType ;
+               if ( CalcATypeFromDisk( CCompoA, m_Info[i].IciA[1].dU, ICurve::FROM_PLUS,
+                                       CCompoB, m_Info[i].IciB[1].dU, nType)) {
+                 // aggiorno il tipo di allontanamento della curva A dalla curva B
+                  m_Info[i].IciA[1].nNextTy = nType ;
+                 // aggiorno anche il corrispondente tipo sulla curva B
+                  if ( m_Info[i].bCBOverEq)
+                     m_Info[i].IciB[1].nNextTy = GetDualIcct( nType) ;
+                  else
+                     m_Info[i].IciB[1].nPrevTy = nType ;
+               }
+            }
          }
       }
    }
@@ -754,10 +693,10 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
         // se prima curva aperta, salto alla prossima
          if ( ! CCompoA.IsClosed())
             continue ;
-        // è chiusa quindi prendo l'ultima
+        // è chiusa quindi prendo l'ultima
          j = m_nNumInters - 1 ;
       }
-     // se i due indici coincidono, c'è una sola intersezione e posso uscire
+     // se i due indici coincidono, c'è una sola intersezione e posso uscire
       if ( i == j)
           break ;
      // assegno sottoindici (considero solo intersezioni overlap)
@@ -785,7 +724,7 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
       }
    }
 
-  // se è rimasta una sola intersezione con overlap anche ad entrambi gli estremi e le curve sono chiuse
+  // se è rimasta una sola intersezione con overlap anche ad entrambi gli estremi e le curve sono chiuse
    if ( m_nNumInters == 1  &&  CCompoA.IsClosed()  &&  CCompoB.IsClosed()  &&
         m_Info[0].IciA[0].nPrevTy == ICCT_ON  &&  m_Info[0].IciA[1].nNextTy == ICCT_ON  &&
         GetCrvBDirANext( m_Info[0]) == ICCT_ON  &&  GetCrvBDirAPrev( m_Info[0]) == ICCT_ON) {
@@ -799,243 +738,10 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
       m_Info[0].IciB[1].dU = ( m_Info[0].bCBOverEq ? dEnd : dStart) ;
    }
 
-   // verifico se una curva ha tutte le info e queste info sono coerenti
-   if ( m_nNumInters > 1  &&  ! bAutoInters) {
-      bool bCoherent = true ;
-      INTVECTOR vIncoherenceWithPrev ;
-      INTVECTOR vNewOverlap ;
-      // salvo eventuali incoerenze col precedente
-      for ( int i = bCrvAClosed ? 0 : 1 ; i < m_nNumInters ; ++i) {
-         int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
-         int kj = m_Info[j].bOverlap ? 1 : 0 ;
-         if ( (m_Info[j].IciA[kj].nNextTy == ICCT_NULL  ||  m_Info[i].IciA[0].nPrevTy  == ICCT_NULL  ||  m_Info[j].IciA[kj].nNextTy != m_Info[i].IciA[0].nPrevTy) &&
-               m_Info[j].IciA[kj].nNextTy != ICCT_SPK  &&  m_Info[i].IciA[0].nPrevTy != ICCT_SPK) {
-            vIncoherenceWithPrev.push_back( i) ;
-            bCoherent = false ;
-         }
-      }
-      // incoerenze sulla curva A
-      if ( ! bCoherent) {
-         for ( int i : vIncoherenceWithPrev) {
-            int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
-            int kj = m_Info[j].bOverlap ? 1 : 0 ;
-            int nType = 0 ;
-            CalcSide( j, i, &CCompoA, &CCompoB, true, nType) ;
-            if ( nType != ICCT_ON) {
-               m_Info[i].IciA[0].nPrevTy = nType ;
-               m_Info[j].IciA[kj].nNextTy = nType ;
-            }
-            else
-               vNewOverlap.push_back( i) ;
-         }
-      }
-
-      // faccio il merge se ho trasformato delle intersezioni in overlap
-      for ( int i : views::reverse( vNewOverlap))
-         MergeNewOverlap( i, true) ;
-
-      vNewOverlap.clear() ;
-      stable_sort( m_Info.begin(), m_Info.end(), SortGreaterB) ;
-      bCoherent = true ;
-      vIncoherenceWithPrev.clear() ;
-      // salvo eventuali incoerenze col precedente
-      for ( int i = bCrvBClosed ? 0 : 1 ; i < m_nNumInters ; ++i) {
-         int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
-         int ki = m_Info[i].bOverlap && ! m_Info[i].bCBOverEq ? 1 : 0 ;
-         int kj = m_Info[j].bOverlap && m_Info[j].bCBOverEq ? 1 : 0 ;
-         if ( ( m_Info[j].IciB[kj].nNextTy == ICCT_NULL ||  m_Info[i].IciB[ki].nPrevTy == ICCT_NULL  ||  m_Info[j].IciB[kj].nNextTy != m_Info[i].IciB[ki].nPrevTy)  &&
-              m_Info[j].IciB[kj].nNextTy != ICCT_SPK  && m_Info[i].IciB[ki].nPrevTy != ICCT_SPK) {
-            vIncoherenceWithPrev.push_back( i) ;
-            bCoherent = false ;
-         }
-      }
-      // incoerenze sulla curva B
-      if ( ! bCoherent) {
-         for ( int i : vIncoherenceWithPrev) {
-            int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
-            int ki = m_Info[i].bOverlap && ! m_Info[i].bCBOverEq ? 1 : 0 ;
-            int kj = m_Info[j].bOverlap && m_Info[j].bCBOverEq ? 1 : 0 ;
-            int nType = 0 ;
-            CalcSide( j, i, &CCompoB, &CCompoA, false, nType) ;
-            if ( nType != ICCT_ON) {
-               m_Info[i].IciB[ki].nPrevTy = nType ;
-               m_Info[j].IciB[kj].nNextTy = nType ;
-            }
-            else
-               vNewOverlap.push_back( i) ;
-         }
-      }
-
-      // faccio il merge se ho trasformato delle intersezioni in overlap
-      for ( int i : views::reverse( vNewOverlap))
-         MergeNewOverlap( i, false) ;
-   }
-   else {
-      // posso completare A guardando B e viceversa
-   }
-
-   stable_sort( m_Info.begin(), m_Info.end(), SortGreaterA) ;
   // verifiche su intersezioni in zone non-manifold
    OrderNonManifoldInters( m_Info, CCompoA, CCompoB) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-IntersCrvCompoCrvCompo::CalcSide( int j, int i,const ICurve* pThisCrv, const ICurve* pOtherCrv, bool bCrvAOrB, int& nType)
-{
-   const IntCrvCrvInfo& Icci1 = m_Info[j] ;
-   const IntCrvCrvInfo& Icci2 = m_Info[i] ;
-   // calcolo tra l'intersezione 1 e 2 se la curva sta dentro o fuori
-   int kj = Icci1.bOverlap ? 1 : 0 ;
-   double dU = 0 ;
-   bool bPrevIsBefore = true ;
-   if ( bCrvAOrB) {
-      // se precedente minore del successivo faccio la media
-      if ( Icci1.IciA[kj].dU < Icci2.IciA[0].dU)
-         dU = ( Icci2.IciA[0].dU + Icci1.IciA[kj].dU) / 2 ;
-      // altrimenti guardo tra lo start e il successivo
-      else {
-         bPrevIsBefore = false ;
-         dU = ( Icci2.IciA[0].dU + 0.) / 2 ;
-         if ( dU < EPS_SMALL) {
-            double dStart, dEnd ;
-            pThisCrv->GetDomain( dStart, dEnd) ;
-            double dUNew = dEnd - Icci1.IciA[kj].dU / 2 ;
-            if ( dUNew > dU)
-               dU = dUNew ;
-         }
-      }
-   }
-   else {
-      // se precedente minore del successivo faccio la media
-      if ( Icci1.IciB[kj].dU < Icci2.IciB[0].dU)
-         dU = ( Icci2.IciB[0].dU + Icci1.IciB[kj].dU) / 2 ;
-      // altrimenti guardi tra lo start e il successivo
-      else {
-         bPrevIsBefore = false ;
-         dU = ( Icci2.IciB[0].dU + 0.) / 2 ;
-         if ( dU < EPS_SMALL) {
-            double dStart, dEnd ;
-            pThisCrv->GetDomain( dStart, dEnd) ;
-            double dUNew = dEnd - Icci1.IciB[kj].dU / 2 ;
-            if ( dUNew > dU)
-               dU = dUNew ;
-         }
-      }
-   }
-   Point3d ptTest ; pThisCrv->GetPointD1D2( dU, ICurve::FROM_MINUS, ptTest) ;
-   DistPointCurve dpc( ptTest, *pOtherCrv) ;
-   dpc.GetSideAtMinDistPoint( 0, Z_AX, nType, EPS_ZERO) ;
-   if ( nType == MDS_LEFT)
-      nType = ICCT_IN ;
-   else if ( nType == MDS_RIGHT)
-      nType = ICCT_OUT ;
-   // se lo trovo sulla curva controllo se posso definire un tratto overlap
-   if ( nType == MDS_ON) {
-      double dFactor = 1./3. ;
-      DBLVECTOR vdU(2) ;
-      bool bIsOn = false ;
-      if ( bCrvAOrB) {
-         if ( bPrevIsBefore) {
-            vdU[0] = ( 1 - dFactor) * Icci2.IciA[0].dU + dFactor * Icci1.IciA[kj].dU ;
-            vdU[1] = ( 1 - 2 * dFactor) * Icci2.IciA[0].dU + 2 * dFactor * Icci1.IciA[kj].dU ;
-         }
-         else if ( Icci2.IciA[0].dU > 2 * EPS_SMALL){
-            vdU[0] = ( Icci2.IciA[0].dU + 0.) * dFactor ;
-            vdU[1] = ( Icci2.IciA[0].dU + 0.) * 2 * dFactor ;
-         }
-         else
-            bIsOn = true ;
-      }
-      else {
-         if ( bPrevIsBefore) {
-            vdU[0] = ( 1 - dFactor) * Icci2.IciB[0].dU + dFactor * Icci1.IciB[kj].dU ;
-            vdU[1] = ( 1 - 2 * dFactor) * Icci2.IciB[0].dU + 2 * dFactor * Icci1.IciB[kj].dU ;
-         }
-         else if ( Icci2.IciB[0].dU > 2 * EPS_SMALL) {
-            vdU[0] = ( Icci2.IciB[0].dU + 0.) * dFactor ;
-            vdU[1] = ( Icci2.IciB[0].dU + 0.) * 2 * dFactor ;
-         }
-         else
-            bIsOn = true ;
-      }
-      if ( ! bIsOn) {
-         bIsOn = true ;
-         for ( int k = 0 ; k < ssize(vdU) && bIsOn ; ++k) {
-            Point3d ptTest2 ; pThisCrv->GetPointD1D2( vdU[k], ICurve::FROM_MINUS, ptTest2) ;
-            DistPointCurve dpc2( ptTest2, *pOtherCrv) ;
-            dpc2.GetSideAtMinDistPoint( 0, Z_AX, nType, EPS_ZERO) ;
-            if ( nType != MDS_ON)
-               bIsOn = false ;
-         }
-      }
-      if ( bIsOn) {
-         m_Info[i].bOverlap = true ;
-         Vector3d vtDirThis, vtDirOther ;
-         Point3d ptCommon ;
-         double dUThis = 0 ;
-         if ( bCrvAOrB)
-            dUThis = m_Info[i].IciA[0].dU ;
-         else
-            dUThis = m_Info[i].IciB[0].dU ;
-         pThisCrv->GetPointD1D2( dUThis, ICurve::Side::FROM_MINUS, ptCommon, &vtDirThis) ;
-         double dUOther = 0 ; pOtherCrv->GetParamAtPoint( ptCommon, dUOther) ;
-         pOtherCrv->GetPointD1D2( dUOther, ICurve::Side::FROM_MINUS, ptCommon, &vtDirOther) ;
-         m_Info[i].bCBOverEq = vtDirThis * vtDirOther > 0 ;
-         if ( m_Info[i].bCBOverEq) {
-            m_Info[i].IciA[1] = m_Info[i].IciA[0] ;
-            m_Info[i].IciB[1] = m_Info[i].IciB[0] ;
-            m_Info[i].IciA[0] = m_Info[j].IciA[kj] ;
-            m_Info[i].IciB[0] = m_Info[j].IciB[kj] ;
-            m_Info[i].IciA[1].nPrevTy = ICCT_ON ;
-            m_Info[i].IciB[1].nPrevTy = ICCT_ON ;
-            m_Info[i].IciA[0].nNextTy = ICCT_ON ;
-            m_Info[i].IciB[0].nNextTy = ICCT_ON ;
-         }
-         else {
-            if ( bCrvAOrB) {
-               m_Info[i].IciA[1] = m_Info[i].IciA[0] ;
-               m_Info[i].IciA[0] = m_Info[j].IciA[kj] ;
-               m_Info[i].IciA[1].nPrevTy = ICCT_ON ;
-               m_Info[i].IciA[0].nNextTy = ICCT_ON ;
-               m_Info[i].IciB[1] = m_Info[j].IciB[kj] ;
-               m_Info[i].IciB[0].nPrevTy = ICCT_ON ;
-               m_Info[i].IciB[1].nNextTy = ICCT_ON ;
-            }
-            else {
-               m_Info[i].IciB[1] = m_Info[i].IciB[0] ;
-               m_Info[i].IciB[0] = m_Info[j].IciB[kj] ;
-               m_Info[i].IciB[1].nPrevTy = ICCT_ON ;
-               m_Info[i].IciB[0].nNextTy = ICCT_ON ;
-               m_Info[i].IciA[1] = m_Info[j].IciA[kj] ;
-               m_Info[i].IciA[0].nPrevTy = ICCT_ON ;
-               m_Info[i].IciA[1].nNextTy = ICCT_ON ;
-            }
-         }
-         nType = ICCT_ON ;
-      }
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IntersCrvCompoCrvCompo::MergeNewOverlap( int i, bool bCrvAOrB)
-{
-   // faccio il merge col precedente
-   int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
-   if ( m_Info[j].bOverlap) {
-      m_Info[i].IciA[0] = m_Info[j].IciA[0] ;
-      m_Info[i].IciB[0] = m_Info[j].IciB[0] ;
-   }
-   m_Info.erase( m_Info.begin() + j) ;
-   -- j ;
-   -- m_nNumInters ;
-   return true ;
-}
-
-
 //----------------------------------------------------------------------------
 bool
 IntersCrvCompoCrvCompo::IntersSimpleCurves( const ICurve& CurveA, int nA, const ICurve& CurveB, int nB,
@@ -1100,23 +806,9 @@ bool
 IntersCrvCompoCrvCompo::EraseOtherInfo( int& nIndCurr, int& nIndOther)
 {
    m_Info.erase( m_Info.begin() + nIndOther) ;
-   -- nIndCurr ;
-   -- nIndOther ;
-   -- m_nNumInters ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IntersCrvCompoCrvCompo::EraseBothInfo( int& nIndCurr, int& nIndOther)
-{
-   m_Info.erase( m_Info.begin() + nIndOther) ;
-   -- nIndCurr ;
-   -- nIndOther ;
-   -- m_nNumInters ;
-   m_Info.erase( m_Info.begin() + nIndCurr) ;
-   if ( nIndCurr != -1)
+   if ( nIndOther < nIndCurr)
       -- nIndCurr ;
+   -- nIndOther ;
    -- m_nNumInters ;
    return true ;
 }
@@ -1187,7 +879,7 @@ SortGreaterB( const IntCrvCrvInfo& aInfo1, const IntCrvCrvInfo& aInfo2)
 bool
 OrderNonManifoldInters( ICCIVECTOR& Info, const ICurve& CurveA, const ICurve& CurveB)
 {
-  // questi controlli sono validi solo se la curva B è chiusa
+  // questi controlli sono validi solo se la curva B è chiusa
    if ( ! CurveB.IsClosed())
       return false ;
 
@@ -1216,7 +908,7 @@ OrderNonManifoldInters( ICCIVECTOR& Info, const ICurve& CurveA, const ICurve& Cu
         // se prima curva aperta, salto alla prossima
          if ( ! CurveA.IsClosed())
             continue ;
-        // è chiusa quindi prendo l'ultima
+        // è chiusa quindi prendo l'ultima
          j = nNumInters - 1 ;
       }
      // se i due indici coincidono, salto
@@ -1268,20 +960,11 @@ OrderNonManifoldInters( ICCIVECTOR& Info, const ICurve& CurveA, const ICurve& Cu
 //----------------------------------------------------------------------------
 static bool
 CompatibleParamA( const IntCrvCrvInfo& Icci1, const IntCrvCrvInfo& Icci2,
-                  bool bCrvAClosed, double dCrvASpan, bool bOrderedOnB)
+                  bool bCrvAClosed, double dCrvASpan)
 {
-   int ki = 0 ;
-   int kj = 0 ;
-   if ( ! bOrderedOnB) {
-      ki = 0 ;
-      kj = Icci1.bOverlap ? 1 : 0 ;
-   }
-   else {
-      ki = Icci2.bOverlap && ! Icci2.bCBOverEq ? 1 : 0 ;
-      kj = Icci1.bOverlap && Icci1.bCBOverEq ? 1 : 0 ;
-   }
-   if ( abs( Icci1.IciA[kj].dU - Icci2.IciA[ki].dU) > 0.1 * SPAN_PARAM  &&
-        ( ! bCrvAClosed  ||  abs( abs( Icci1.IciA[kj].dU - Icci2.IciA[ki].dU) - dCrvASpan) > 0.1 * SPAN_PARAM))
+   int k = ( Icci1.bOverlap ? 1 : 0) ;  // del precedente si prende il secondo se overlap
+   if ( abs( Icci1.IciA[k].dU - Icci2.IciA[0].dU) > 0.1 * SPAN_PARAM  &&
+        ( ! bCrvAClosed  ||  abs( abs( Icci1.IciA[k].dU - Icci2.IciA[0].dU) - dCrvASpan) > 0.1 * SPAN_PARAM))
       return false ;
    return true ;
 }
@@ -1289,21 +972,11 @@ CompatibleParamA( const IntCrvCrvInfo& Icci1, const IntCrvCrvInfo& Icci2,
 //----------------------------------------------------------------------------
 static bool
 CompatibleParamB( const IntCrvCrvInfo& Icci1, const IntCrvCrvInfo& Icci2,
-                  bool bCrvBClosed, double dCrvBSpan, bool bOrderedOnB)
+                  bool bCrvBClosed, double dCrvBSpan)
 {
-   int ki = 0 ;
-   int kj = 0 ;
-   if ( ! bOrderedOnB) {
-      ki = 0 ;
-      kj = Icci1.bOverlap ? 1 : 0 ;
-   }
-   else {
-      ki = Icci2.bOverlap && ! Icci2.bCBOverEq ? 1 : 0 ;
-      kj = Icci1.bOverlap && Icci1.bCBOverEq ? 1 : 0 ;
-   }
-   
-   if ( abs( Icci1.IciB[kj].dU - Icci2.IciB[ki].dU) > 0.1 * SPAN_PARAM  &&
-        ( ! bCrvBClosed  ||  abs( abs( Icci1.IciB[kj].dU - Icci2.IciB[ki].dU) - dCrvBSpan) > 0.1 * SPAN_PARAM))
+   int k = ( Icci1.bOverlap ? 1 : 0) ;  // del precedente si prende il secondo se overlap
+   if ( abs( Icci1.IciB[k].dU - Icci2.IciB[0].dU) > 0.1 * SPAN_PARAM  &&
+        ( ! bCrvBClosed  ||  abs( abs( Icci1.IciB[k].dU - Icci2.IciB[0].dU) - dCrvBSpan) > 0.1 * SPAN_PARAM))
       return false ;
    return true ;
 }
@@ -1325,7 +998,7 @@ MediaParamPoints( IntCrvInfo& Ici1, IntCrvInfo& Ici2, const ICurveComposite& crv
    //Point3d ptMed ;
    //if ( ! crvCompo.GetPointD1D2( dUmed, ICurve::FROM_MINUS, ptMed))
    //   return ;
-  // verifico che non sia più lontano dei punti originali dal loro medio
+  // verifico che non sia più lontano dei punti originali dal loro medio
    //if ( SqDist( Ici1.ptI, ptMed) > dSqDist / 4)
    //   return ;
   // medio i parametri
@@ -1339,13 +1012,13 @@ MediaParamPoints( IntCrvInfo& Ici1, IntCrvInfo& Ici2, const ICurveComposite& crv
 static int
 GetCrvBDirAPrev( IntCrvCrvInfo& Icci)
 {
-  // non è overlap, è il prev del primo punto 
+  // non è overlap, è il prev del primo punto 
    if ( ! Icci.bOverlap)
       return Icci.IciB[0].nPrevTy ;
-  // è overlap equiverso, è il prev del primo punto
+  // è overlap equiverso, è il prev del primo punto
    if ( Icci.bCBOverEq)
       return Icci.IciB[0].nPrevTy ;
-  // è overlap controverso, è il next del primo punto
+  // è overlap controverso, è il next del primo punto
    return Icci.IciB[0].nNextTy ;
 }
 
@@ -1355,13 +1028,13 @@ GetCrvBDirAPrev( IntCrvCrvInfo& Icci)
 static int
 GetCrvBDirANext( IntCrvCrvInfo& Icci)
 {
-  // non è overlap, è il next del primo punto 
+  // non è overlap, è il next del primo punto 
    if ( ! Icci.bOverlap)
       return Icci.IciB[0].nNextTy ;
-  // è overlap equiverso, è il next del secondo punto
+  // è overlap equiverso, è il next del secondo punto
    if ( Icci.bCBOverEq)
       return Icci.IciB[1].nNextTy ;
-  // è overlap controverso, è il prev del secondo punto
+  // è overlap controverso, è il prev del secondo punto
    return Icci.IciB[1].nPrevTy ;
 }
 
@@ -1405,7 +1078,7 @@ CalcATypeFromDisk( const ICurve& CurveA, double dUA, ICurve::Side nSideA,
       return false ;
    if ( dAngBpDeg < 0)
       dAngBpDeg += ANG_FULL ;
-  // se l'angolo di DirA è compreso tra DirBn e DirBp (muovendosi in senso CCW) allora è IN, altrimenti OUT
+  // se l'angolo di DirA è compreso tra DirBn e DirBp (muovendosi in senso CCW) allora è IN, altrimenti OUT
    if ( dAngADeg > 0  &&  dAngADeg < dAngBpDeg)
       nType = ICCT_IN ; 
    else
@@ -1478,12 +1151,12 @@ CalcATypeFromDisk2( const ICurve& CurveA, double dUA, ICurve::Side nSideA,
    // li ordino in senso crescente
    if ( dAngB1pDeg > dAngB2pDeg)
       swap( dAngB1pDeg, dAngB2pDeg) ;
-  // se non ci sono variazioni angolari significative, non posso decidere alcunché
+  // se non ci sono variazioni angolari significative, non posso decidere alcunché
    const double MIN_DEV_ANG = 2 ;
    if ( abs( DiffAngle( dAngB1pDeg + ANG_STRAIGHT, 0)) < MIN_DEV_ANG  &&
         abs( DiffAngle( dAngB2pDeg + ANG_STRAIGHT, dAngB2nDeg)) < MIN_DEV_ANG)
       return false ;
-  // IN è tra 0 e dAngB1pDeg e tra dAngB2nDeg e dAngB2pDeg
+  // IN è tra 0 e dAngB1pDeg e tra dAngB2nDeg e dAngB2pDeg
    if ( ( dAngADeg > 0  &&  dAngADeg < dAngB1pDeg)  ||
         ( dAngADeg > dAngB2nDeg  &&  dAngADeg < dAngB2pDeg))
       nType = ICCT_IN ; 

IntersCrvCompoCrvCompo.h

@@ -43,9 +43,6 @@ class IntersCrvCompoCrvCompo
                                bool bAutoInters, bool bClosed, int nCurvesNbr) ;
       bool EraseCurrentInfo( int& nIndCurr, int& nIndOther) ;
       bool EraseOtherInfo( int& nIndCurr, int& nIndOther) ;
-      bool EraseBothInfo( int& nIndCurr, int& nIndOther) ;
-      bool CalcSide( int j, int i,const ICurve* pThisCrv, const ICurve* pOtherCrv, bool bCrvAOrB, int& nType) ;
-      bool MergeNewOverlap( int i, bool bCrvAOrB) ;
 
    private :
       bool       m_bOverlaps ;

IntersCurveCurve.cpp

@@ -47,7 +47,7 @@ IntersCurveCurve::IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB,
 
   // ciclo sulle curve per verificare se da approssimare
    for ( int i = 0 ; i < 2 ; ++ i) {
-     // se curva è arco da approssimare oppure è curva di Bezier
+     // se curva è arco da approssimare oppure è curva di Bezier
       if ( ( m_pCurve[i]->GetType() == CRV_ARC  &&  IsArcToApprox( *m_pCurve[i]))  ||
            m_pCurve[i]->GetType() == CRV_BEZIER) {
         // approssimo con rette
@@ -127,7 +127,7 @@ IntersCurveCurve::IsArcToApprox( const ICurve& Curve)
    const CurveArc* pArc = GetBasicCurveArc( &Curve) ;
    if ( pArc == nullptr)
       return false ;
-  // verifico se non è nel piano XY o ha più di un giro al centro
+  // 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) ;
 }
@@ -252,10 +252,10 @@ IntersCurveCurve::CrvCompoCrvCompoCalculate( const ICurve& CurveA, const ICurve&
 bool
 IntersCurveCurve::AdjustIntersParams( bool bAdjCrvA, bool bAdjCrvB)
 {
-  // se non ci sono intersezioni, non va fatto alcunché
+  // 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é
+  // se le curve originali non sono state approssimate, non va fatto alcunché
    if ( ! bAdjCrvA  &&  ! bAdjCrvB)
       return true ;
   // procedo ad aggiustare
@@ -296,8 +296,8 @@ 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)) {
+   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 ;
       }
@@ -365,8 +365,8 @@ 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)) {
+   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 ;
       }
@@ -374,7 +374,7 @@ IntersCurveCurve::GetInt3DCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo)
          if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[1].ptI.z) < EPS_SMALL)
             ++nCount ;
       }
-      if ( nCount == nInd) {
+      if( nCount == nInd) {
          aInfo = m_Info[nInd] ;
          return true ;
       }
@@ -389,11 +389,11 @@ IntersCurveCurve::GetIntersPointNearTo( int nCrv, const Point3d& ptNear, Point3d
    if ( m_nIntersCount == 0  ||  nCrv < 0  ||  nCrv > 1)
       return false ;
 
-  // ricerca del punto più vicino tra le intersezioni singole
+  // 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
+     // se è un'intersezione singola
       if ( ! m_Info[i].bOverlap) {
         // faccio la verifica sul punto
          Point3d ptP = ( nCrv == 0 ? m_Info[i].IciA[0].ptI : m_Info[i].IciB[0].ptI) ;
@@ -458,7 +458,7 @@ IntersCurveCurve::GetCurveClassification( int nCrv, double dLenMin, CRVCVECTOR&
      // se esiste almeno una intersezione
       if ( m_nIntersCount >= 1)
          return CalcCurveClassification( m_pCurve[0], m_Info, dLenMin, ccClass) ;
-     // altrimenti la curva è completamente interna oppure completamente esterna
+     // altrimenti la curva è completamente interna oppure completamente esterna
       else
          return CalcCurveInOrOut( m_pCurve[0], m_pCurve[1], ccClass) ;
    }
@@ -475,7 +475,7 @@ IntersCurveCurve::GetCurveClassification( int nCrv, double dLenMin, CRVCVECTOR&
      // se esiste almeno una intersezione
       if ( m_nIntersCount >= 1)
          return CalcCurveClassification( m_pCurve[1], InfoTmp, dLenMin, ccClass) ;
-     // altrimenti la curva è completamente interna oppure completamente esterna
+     // altrimenti la curva è completamente interna oppure completamente esterna
       else
          return CalcCurveInOrOut( m_pCurve[1], m_pCurve[0], ccClass) ;
    }
@@ -540,7 +540,7 @@ IntersCurveCurve::CalcCurveClassification( const ICurve* pCurve, const ICCIVECTO
             double dU2 = Info[j].IciA[1].dU ;
             if ( dU2 < dU1  &&  pCurve->IsClosed())
                dU2 += dEndPar ;
-           // se cade nell'intervallo è da saltare
+           // se cade nell'intervallo è da saltare
             if ( Info[i].IciA[0].dU >= dU1  &&  Info[i].IciA[0].dU <= dU2) {
                bToSkip = true ;
                break ;
@@ -559,7 +559,7 @@ IntersCurveCurve::CalcCurveClassification( const ICurve* pCurve, const ICCIVECTO
    double dCurrPar = dStartPar ;
    double dCurrLen = 0 ;
    double dEndLen ; pCurve->GetLength( dEndLen) ;
-   // se è chiusa, recupero come finisce
+   // se è chiusa, recupero come finisce
    if ( pCurve->IsClosed()) {
       if ( ! InfoCorr[nNumInters-1].bOverlap)
          nLastTy = InfoCorr[nNumInters-1].IciA[0].nNextTy ;
@@ -577,7 +577,7 @@ IntersCurveCurve::CalcCurveClassification( const ICurve* pCurve, const ICCIVECTO
    }
   // costruisco il vettore delle classificazioni
    for ( int i = 0 ; i < nNumInters ; ++ i) {
-     // se è definito un tratto precedente
+     // se è definito un tratto precedente
       double dLenU ; pCurve->GetLengthAtParam( InfoCorr[i].IciA[0].dU, dLenU) ;
       if ( InfoCorr[i].IciA[0].dU > dCurrPar + EPS_PARAM  &&  dLenU - dCurrLen > dLenMin) {
         // verifico che la definizione sul tratto sia omogenea e valida
@@ -599,7 +599,7 @@ IntersCurveCurve::CalcCurveClassification( const ICurve* pCurve, const ICCIVECTO
      // altrimenti, salvo il tipo
       else
          nLastTy = InfoCorr[i].IciA[0].nNextTy ;
-     // se è definito un tratto in sovrapposizione
+     // se è definito un tratto in sovrapposizione
       if ( InfoCorr[i].bOverlap) {
         // assegno i dati
          CrvClass segClass ;
@@ -639,7 +639,7 @@ IntersCurveCurve::CalcCurveInOrOut( const ICurve* pCurveA, const ICurve* pCurveB
    double dStartParB, dEndParB ;
    if ( ! pCurveB->GetDomain( dStartParB, dEndParB))
       return false ;
-  // se almeno un punto di ciascuna curva è esterno al box dell'altra, sono sicuramente esterne
+  // se almeno un punto di ciascuna curva è esterno al box dell'altra, sono sicuramente esterne
    BBox3d boxCrvA, boxCrvB ;
    if ( ! pCurveA->GetLocalBBox( boxCrvA)  ||
         ! pCurveB->GetLocalBBox( boxCrvB))
@@ -682,37 +682,13 @@ IntersCurveCurve::CalcCurveInOrOut( const ICurve* pCurveA, const ICurve* pCurveB
    IntersCurveCurve iCC( clLine, *pCurveB) ;
    // dichiaro la classe della curva per default
    int nClass = CRVC_OUT ;
-   // se c'è almeno una intersezione
+   // se c'è almeno una intersezione
    if ( iCC.GetIntersCount() > 0) {
-     // se quanto precede la prima intersezione è interno, allora la curva è interna
+     // se quanto precede la prima intersezione è interno, allora la curva è interna
       IntCrvCrvInfo aInfo ;
       iCC.GetIntCrvCrvInfo( 0, aInfo) ;
       if ( aInfo.IciA[0].nPrevTy == ICCT_IN)
          nClass = CRVC_IN ;
-      else if ( aInfo.IciA[0].nPrevTy == ICCT_OUT)
-         nClass = CRVC_OUT ;
-      else if ( aInfo.IciA[0].nPrevTy == ICCT_NULL) {
-         // se il primo punto scelto non va bene allora ne cerco uno che mi dia informazioni sull'essere interno o esterno
-         CurveLine clLine ;
-         Point3d ptNewChoice ; pCurveA->GetPointD1D2( 0.25, ICurve::FROM_MINUS, ptNewChoice) ;
-         if ( ! clLine.SetPDL( ptNewChoice, 0, dLen))
-            return false ;
-         // calcolo l'intersezione
-         IntersCurveCurve iCC( clLine, *pCurveB) ;
-         if ( iCC.GetIntersCount() > 0) {
-           // se quanto precede la prima intersezione è interno, allora la curva è interna
-            IntCrvCrvInfo aInfo ;
-            iCC.GetIntCrvCrvInfo( 0, aInfo) ;
-            if ( aInfo.IciA[0].nPrevTy == ICCT_IN)
-               nClass = CRVC_IN ;
-            else if ( aInfo.IciA[0].nPrevTy == ICCT_OUT)
-               nClass = CRVC_OUT ;
-            else
-               return false ;  // se arrivo qui potrei ritentare la ricerca
-         }
-         else
-            return false ;
-      }
    }
    // altrimenti sono esterni tra loro
    else {

IntersCurvePlane.cpp

@@ -139,6 +139,8 @@ IntersCurvePlane::CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Cur
 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 ;}) ;

IntersLineLine.cpp

@@ -14,6 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "IntersLineLine.h"
+#include "/EgtDev/Include/EgtNumUtils.h"
 #include <algorithm>
 
 using namespace std ;
@@ -156,34 +157,34 @@ 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
+   
+   // analisi casi speciali di quasi parallelismo
    // segmento sovrapposto all'altro
    double dDist1, dDist2 ;
-   if ( nS1Side == 0  ||  nE1Side == 0  ||  nS1Side == nE1Side) {
+   if( nS1Side == 0 ||  nE1Side == 0  ||  nS1Side == nE1Side) {
       dDist1 = CrossXY( ptS1 - ptS2, vtDir2) ;
       dDist2 = CrossXY( ptE1 - ptS2, vtDir2) ;
-      if ( abs( dDist1 - dDist2) < EPS_SMALL * dLen2XY) {
+      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) {
+   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) {
+      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  &&  ScalarXY( vtDir1, vtDir2) < 0  &&  ! AreSamePointXYEpsilon( ptS1, ptS2, 2 * EPS_SMALL))  ||
-          ( nS1Side == 0  &&  nE2Side == 0  &&  ScalarXY( vtDir1, vtDir2) > 0  &&  ! AreSamePointXYEpsilon( ptS1, ptE2, 2 * EPS_SMALL))  ||
-          ( nE1Side == 0  &&  nS2Side == 0  &&  ScalarXY( vtDir1, vtDir2) > 0  &&  ! AreSamePointXYEpsilon( ptE1, ptS2, 2 * EPS_SMALL))  ||
-          ( nE1Side == 0  &&  nE2Side == 0  &&  ScalarXY( vtDir1, vtDir2) < 0  &&  ! AreSamePointXYEpsilon( ptE1, ptE2, 2 * EPS_SMALL))) {
+      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 ;
       }
@@ -194,27 +195,54 @@ IntersLineLine::IntersFiniteLines( const CurveLine& Line1, const CurveLine& Line
      // 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 ( 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 ( 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 ;
+      }
      // verifica posizione intersezione su seconda linea
       int nPos2 = ICurve::PP_NULL ;     // fuori
-      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 ( 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)
       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)

Polygon3d.cpp

@@ -173,7 +173,7 @@ Polygon3d::FromPlaneTrimmedWithBox( const Point3d& ptOn, const Vector3d& vtN,
 {
    Plane3d plPlane ;
    plPlane.Set( ptOn, vtN) ;
-   return FromPlaneTrimmedWithBox( plPlane, ptMin, ptMax, bOnEq, bOnCt, dToler) ;
+   return FromPlaneTrimmedWithBox( plPlane, ptMin, ptMax, bOnEq, bOnCt) ;
 }
 
 //----------------------------------------------------------------------------

PolygonElevation.cpp

@@ -172,9 +172,9 @@ PolygonElevationInClosedSurfTm( const Polygon3d& pgFacet, const ISurfTriMesh& Cl
                return true ;
             }
          }
-         else if ( ( Inters.nILTT == ILTT_VERT  ||  Inters.nILTT == ILTT_EDGE  ||  Inters.nILTT == ILTT_IN)  &&  Inters.dCosDN > EPS_ZERO)
+         else if ( ( Inters.nILTT == ILTT_VERT   ||  Inters.nILTT == ILTT_EDGE  ||  Inters.nILTT == ILTT_IN)  &&  Inters.dCosDN > EPS_ZERO)
             dElev = max( dElev, Inters.dU) ;
-         else if ( Inters.nILTT == ILTT_SEGM  ||  Inters.nILTT == ILTT_SEGM_ON_EDGE)
+         else if ( Inters.nILTT == ILTT_SEGM   ||  Inters.nILTT == ILTT_SEGM_ON_EDGE)
             dElev = max( dElev, Inters.dU2) ;
       }
    }
@@ -206,30 +206,22 @@ PolygonElevationInClosedSurfTm( const Polygon3d& pgFacet, const ISurfTriMesh& Cl
       if ( vEdges[i].first.z < EPS_SMALL  &&  vEdges[i].second.z < EPS_SMALL)
          continue ;
      // calcolo il segmento di linea
-      CurveLine clLine ;
+     CurveLine clLine ;
       if ( ! clLine.Set( vEdges[i].first, vEdges[i].second))
          return false ;
      // l'elevazione va aggiornata con la massima Z delle eventuali intersezioni dell'edge con il loop
       IntersCurveCurve intLL( clLine, ccLoop) ;
-      if ( intLL.GetIntersCount() == 0) {
-         Point3d ptM = Media( vEdges[i].first, vEdges[i].second) ;
-         ptM.z = 0 ;
-         if ( IsPointInsidePolyLine( ptM, PL, -EPS_SMALL))
-            dElev = max( dElev, max( vEdges[i].first.z, vEdges[i].second.z)) ;
-      }
-      else {
-         IntCrvCrvInfo aInfo ;
-         for ( int j = 0 ; intLL.GetIntCrvCrvInfo( j, aInfo) ; ++ j) {
-            dElev = max( dElev, aInfo.IciA[0].ptI.z) ;
-            if ( aInfo.bOverlap)
-               dElev = max( dElev, aInfo.IciA[1].ptI.z) ;
-           // se prima intersezione va da interno ad esterno allora devo considerare il punto iniziale del segmento (vertice)
-            if ( j == 0  &&  aInfo.IciA[0].nPrevTy == ICCT_IN)
-               dElev = max( dElev, vEdges[i].first.z) ;
-           // se ultima intersezione va da esterno a interno allora devo considerare il punto finale del segmento (vertice)
-            else if ( j == intLL.GetIntersCount() - 1  && aInfo.IciA[ aInfo.bOverlap ? 1 : 0].nNextTy == ICCT_IN)
-               dElev = max( dElev, vEdges[i].second.z) ;
-         }
+      IntCrvCrvInfo aInfo ;
+      for ( int j = 0 ; intLL.GetIntCrvCrvInfo( j, aInfo) ; ++ j) {
+         dElev = max( dElev, aInfo.IciA[0].ptI.z) ;
+         if ( aInfo.bOverlap)
+            dElev = max( dElev, aInfo.IciA[1].ptI.z) ;
+        // se prima intersezione va da interno ad esterno allora devo considerare il punto iniziale del segmento (vertice)
+         if ( j == 0  &&  aInfo.IciA[0].nPrevTy == ICCT_IN)
+            dElev = max( dElev, vEdges[i].first.z) ;
+        // se ultima intersezione va da esterno a interno allora devo considerare il punto finale del segmento (vertice)
+         else if ( j == intLL.GetIntersCount() - 1  && aInfo.IciA[ aInfo.bOverlap ? 1 : 0].nNextTy == ICCT_IN)
+            dElev = max( dElev, vEdges[i].second.z) ;
       }
    }
 

ProjectCurveSurf.cpp

@@ -19,7 +19,6 @@
 #include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
-#include "/EgtDev/Include/EGkDistPointSurfBz.h"
 #include "/EgtDev/Include/EGkIntersPlanePlane.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
@@ -93,8 +92,6 @@ AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
                      Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
                      Pt5ax.vtDir1 = vPt5ax[j].vtDir1 ;
                      Pt5ax.vtDir2 = vPt5ax[j].vtDir2 ;
-                     Pt5ax.vtDirU = vPt5ax[j].vtDirU ;
-                     Pt5ax.vtDirV = vPt5ax[j].vtDirV ;
                      Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
                      Pt5ax.nFlag = P5AX_CVEX ;
                      vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
@@ -107,8 +104,6 @@ AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
                      Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
                      Pt5ax.vtDir1 = vPt5ax[i].vtDir1 ;
                      Pt5ax.vtDir2 = vPt5ax[i].vtDir2 ;
-                     Pt5ax.vtDirU = vPt5ax[i].vtDirU ;
-                     Pt5ax.vtDirV = vPt5ax[i].vtDirV ;
                      Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
                      Pt5ax.nFlag = P5AX_CVEX ;
                      vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
@@ -123,8 +118,6 @@ AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
                   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.vtDirU = Media( vPt5ax[i].vtDirU, vPt5ax[j].vtDirU) ; Pt5ax.vtDirU.Normalize() ;
-                  Pt5ax.vtDirV = Media( vPt5ax[i].vtDirV, vPt5ax[j].vtDirV) ; Pt5ax.vtDirV.Normalize() ;
                   Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
                   Pt5ax.nFlag = P5AX_CONC ;
                   vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
@@ -239,56 +232,24 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
    return true ;
 }
 
-//----------------------------------------------------------------------------
-static const SurfTriMesh*
-MyGetAuxSurf( const ISurf* pSrf)
-{
-   if ( pSrf == nullptr)
-      return nullptr ;
-   switch ( pSrf->GetType()) {
-   case SRF_TRIMESH :
-      return GetBasicSurfTriMesh( pSrf) ;
-   case SRF_FLATRGN :
-      return GetBasicSurfFlatRegion( pSrf)->GetAuxSurf() ;
-   case SRF_BEZIER :
-      return GetBasicSurfBezier( pSrf)->GetAuxSurf() ;
-   default :
-      return nullptr ;
-   }
-}
-
 //----------------------------------------------------------------------------
 static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISURFPVECTOR& vpSurf, double dPar, Point5ax& Pt5ax)
+ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, double dPar, Point5ax& Pt5ax)
 {
-  // punto sulle superfici a minima distanza
+  // punto sulle supefici a minima distanza
    int nSurfMin = -1 ;
-   int nTriaMin = -1 ;
-   double dUMin = -1, dVMin = -1 ;
+   int nTriaMin ;
    Point3d ptMin ;
-   double dMinDist = NAN ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
+   double dMinDist ;
+   for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
      // punto sulla superficie a minima distanza
-      int nSrfType = ( vpSurf[i] != nullptr ? vpSurf[i]->GetType() : GEO_NONE) ;
-      if ( nSrfType == SRF_TRIMESH  ||  nSrfType == SRF_FLATRGN) {
-         DistPointSurfTm dPS( ptP, *MyGetAuxSurf( vpSurf[i])) ;
-         double dDist ;
-         if ( dPS.GetDist( dDist)  &&  ( nSurfMin == -1  ||  dDist < dMinDist)) {
-            nSurfMin = i ;
-            dPS.GetMinDistPoint( ptMin) ;
-            dPS.GetMinDistTriaIndex ( nTriaMin) ;
-            dMinDist = dDist ;
-         }
-      }
-      else if ( nSrfType == SRF_BEZIER) {
-         DistPointSurfBz dPS( ptP, *GetBasicSurfBezier( vpSurf[i])) ;
-         double dDist ;
-         if ( dPS.GetDist( dDist)  &&  ( nSurfMin == -1  ||  dDist < dMinDist)) {
-            nSurfMin = i ;
-            dPS.GetMinDistPoint( ptMin) ;
-            dPS.GetParamsAtMinDistPoint( dUMin, dVMin) ;
-            dMinDist = dDist ;
-         }
+      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 ;
       }
    }
 
@@ -296,44 +257,19 @@ ProjectPointOnSurf( const Point3d& ptP, const CISURFPVECTOR& vpSurf, double dPar
    if ( nSurfMin >= 0) {
      // assegno il punto
       Point3d ptInt = ptMin ;
-     // calcolo gli altri dati
-      int nSrfType = ( vpSurf[nSurfMin] != nullptr ? vpSurf[nSurfMin]->GetType() : GEO_NONE) ;
-      if ( nSrfType == SRF_TRIMESH  ||  nSrfType == SRF_FLATRGN) {
-        // recupero superficie trimesh
-         const SurfTriMesh* pSurfTm = MyGetAuxSurf( vpSurf[nSurfMin]) ;
-        // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
-         Triangle3dEx trTria ;
-         if ( ! pSurfTm->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.vtDirU = V_NULL ;
-         Pt5ax.vtDirV = V_NULL ;
-         Pt5ax.dPar = dPar ;
-         Pt5ax.nFlag = P5AX_STD ;
-      }
-      else if ( nSrfType == SRF_BEZIER) {
-         Point3d ptSB ;
-         Vector3d vtN, vtDerU, vtDerV ;
-         if ( ! GetBasicSurfBezier( vpSurf[nSurfMin])->GetPointNrmD1D2( dUMin, dVMin, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS,
-                                                                        ptSB, vtN, &vtDerU, &vtDerV))
-            return false ;
-         vtDerU.Normalize() ;
-         vtDerV.Normalize() ;
-        // assegno valori al punto 5assi
-         Pt5ax.ptP = ptInt ;
-         Pt5ax.vtDir1 = vtN ;
-         Pt5ax.vtDir2 = vtN ;
-         Pt5ax.vtDirU = vtDerU ;
-         Pt5ax.vtDirV = vtDerV ;
-         Pt5ax.dPar = dPar ;
-         Pt5ax.nFlag = P5AX_STD ;
-      }
+     // 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 ;
    }
@@ -346,6 +282,31 @@ 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) ;
@@ -370,7 +331,7 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
    while ( bFound) {
      // se trovo proiezione, la salvo
       Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurf, dPar, Pt5ax))
+      if ( ProjectPointOnSurf( ptP, vpSurfTm, dPar, Pt5ax))
          vPt5ax.emplace_back( Pt5ax) ;
      // passo al successivo
       bFound = PL.GetNextUPoint( &dPar, &ptP) ;
@@ -442,8 +403,6 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const Frame
       Pt5ax.ptP = ptInt ;
       Pt5ax.vtDir1 = vtN ;
       Pt5ax.vtDir2 = frRefLine.VersZ() ;
-      Pt5ax.vtDirU = V_NULL ;
-      Pt5ax.vtDirV = V_NULL ;
       Pt5ax.dPar = dPar ;
       Pt5ax.nFlag = P5AX_STD ;
      // ritorno con successo
@@ -598,8 +557,6 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const IGeoP
          Pt5ax.ptP = ptInt ;
          Pt5ax.vtDir1 = vtN ;
          Pt5ax.vtDir2 = vtLine ;
-         Pt5ax.vtDirU = V_NULL ;
-         Pt5ax.vtDirV = V_NULL ;
          Pt5ax.dPar = dPar ;
          Pt5ax.nFlag = P5AX_STD ;
         // ritorno con successo
@@ -739,8 +696,6 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const ICurv
             Pt5ax.ptP = ptInt ;
             Pt5ax.vtDir1 = vtN ;
             Pt5ax.vtDir2 = vtLine ;
-            Pt5ax.vtDirU = V_NULL ;
-            Pt5ax.vtDirV = V_NULL ;
             Pt5ax.dPar = dPar ;
             Pt5ax.nFlag = P5AX_STD ;
            // ritorno con successo
@@ -897,8 +852,6 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const SurfT
          Pt5ax.ptP = ptInt ;
          Pt5ax.vtDir1 = vtN ;
          Pt5ax.vtDir2 = vtN2 ;
-         Pt5ax.vtDirU = V_NULL ;
-         Pt5ax.vtDirV = V_NULL ;
          Pt5ax.dPar = dPar ;
          Pt5ax.nFlag = P5AX_STD ;
         // ritorno con successo

SbzFromCurves.cpp

@@ -735,7 +735,8 @@ GetSurfBezierRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, dou
 
 //-------------------------------------------------------------------------------
 ISurfBezier*
-GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const BIPNTVECTOR& vCrv, double dLinTol)
+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)
@@ -762,7 +763,7 @@ GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const BI
 
    // creo e setto la superficie trimesh
    PtrOwner<SurfBezier> pSbz( CreateBasicSurfBezier()) ;
-   if ( IsNull( pSbz)  ||  ! pSbz->CreateByIsoParamSet( pCC1, pCC2, vCrv))
+   if ( IsNull( pSbz)  ||  ! pSbz->CreateByIsoParamSet( pCC1, pCC2, vCrv, vNewCrv, vShown, vNewOrEdited))
       return nullptr ;
 
    // restituisco la superficie

StringUtils3d.cpp

@@ -76,18 +76,11 @@ FromString( const string& sVal, Frame3d& frFrame)
 bool
 FromString( const string& sVal, Color& cCol)
 {
-  // dovrebbero essere 4 parametri : Red, Green, Blue, Alpha
-   int vnRGBA[4] ;
-   if ( FromString( sVal, vnRGBA)) {
-      cCol.Set( vnRGBA[0], vnRGBA[1], vnRGBA[2], vnRGBA[3]) ;
-      return true ;
-   }
-  // riprovo con 3 parametri : Red, Green, Blue
-   int vnRGB[3] ;
-   if ( FromString( sVal, vnRGB)) {
-      cCol.Set( vnRGB[0], vnRGB[1], vnRGB[2]) ;
-      return true ;
-   }
-  // altrimenti errore
-   return false ;
+  // devono essere 4 parametri : Red, Green, Blue, Alpha
+   int vnVal[4] ;
+   if ( ! FromString( sVal, vnVal))
+      return false ;
+  // assegno il colore
+   cCol.Set( vnVal[0], vnVal[1], vnVal[2], vnVal[3]) ;
+   return true ;
 }

SurfAux.cpp

@@ -24,13 +24,6 @@
 #include "/EgtDev/Include/EGkSurfAux.h"
 #include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EGkChainCurves.h"
-
-
-#define SAVEMKUNIF_CRVS 0
-#if SAVEMKUNIF_CRVS
-   #include "/EgtDev/Include/EGkGeoObjSave.h"
-#endif
 
 using namespace std ;
 
@@ -537,25 +530,6 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
    return Release( pSrfBz) ;
 }
 
-//----------------------------------------------------------------------------
-ICurveComposite*
-GetRectangleCurve( const Point3d& ptStart, double dWidth, double dHeight)
-{
-   PolyLine PL ;
-   PL.AddUPoint( 0, ptStart) ;
-   PL.AddUPoint( 1, Point3d( ptStart.x + dWidth, ptStart.y)) ;
-   PL.AddUPoint( 2, Point3d( ptStart.x + dWidth, ptStart.y + dHeight, 0)) ;
-   PL.AddUPoint( 3, Point3d( ptStart.x , ptStart.y + dHeight, 0)) ;
-   PL.AddUPoint( 4, ptStart) ;
-   // creo la curva e la inserisco nel GDB
-   PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
-   bool bOk = true ;
-   bOk = bOk && ! IsNull( pCrvCompo) ;
-   // inserisco i segmenti che uniscono i punti
-   bOk = bOk && pCrvCompo->FromPolyLine( PL) ;
-   return Release( pCrvCompo) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 MakeUniform( ISurfFlatRegion*& pSfr, bool& bRescaled, const DBLVECTOR& vU0, const DBLVECTOR& vV0,
@@ -565,33 +539,36 @@ MakeUniform( ISurfFlatRegion*& pSfr, bool& bRescaled, const DBLVECTOR& vU0, cons
    bool bRescaledU = false ;
    bool bRescaledV = false ;
    int nSpanU = 1, nSpanV = 1 ;
-   ICRVCOMPOPOVECTOR vUniformedCurves ;
-   BOOLVECTOR vbUniform(2) ;
-   fill( vbUniform.begin(), vbUniform.end(), true) ;
-   DBLMATRIX mKnots(2) ;
+   PtrOwner<ISurfFlatRegion> pRescaledSfr( CreateSurfFlatRegion()) ;
    for ( int nDir = 0 ; nDir <= 1 ; ++ nDir) {
      // vettore dei nodi
-      DBLVECTOR& vU = mKnots[nDir] ;
+      DBLVECTOR vU ;
       int nExtraKnots = 0 ;
      // controllo in U
       if ( nDir == 0) {
-         for ( int i = nExtraKnots ; i < ssize( vU0) - nExtraKnots ; ++i ) {
+         if ( nDegU > 1) {
+            nExtraKnots = nDegU - 1 ;
+         }
+         for ( int i = nExtraKnots ; i < int( vU0.size()) - nExtraKnots ; ++i ) {
             double dKnot = vU0[i] * SBZ_TREG_COEFF ;
             // lo aggiungo solo se è diverso dal precedente
-            if ( i == nExtraKnots  ||  dKnot > vU.back() + EPS_SMALL)
+            if ( i == nExtraKnots  ||  dKnot > vU.back() + EPS_SMALL  ||  dKnot < vU.back() - EPS_SMALL)
                vU.push_back( dKnot) ;
          }
-         nSpanU = ssize( vU) - 1 ;
+         nSpanU = (int)vU.size() - 1 ;
       }
      // controllo in V
       else if ( nDir == 1 ) {
-         for ( int i = nExtraKnots ; i < ssize( vV0) - nExtraKnots ; ++i ) {
+         if ( nDegV > 1) {
+            nExtraKnots = nDegV - 1 ;
+         }
+         for ( int i = nExtraKnots ; i < int( vV0.size()) - nExtraKnots ; ++i ) {
             double dKnot = vV0[i] * SBZ_TREG_COEFF ;
             // lo aggiungo solo se è diverso dal precedente
-            if ( i == nExtraKnots  ||  dKnot > vU.back() + EPS_SMALL)
+            if ( i == nExtraKnots  ||  dKnot > vU.back() + EPS_SMALL  ||  dKnot < vU.back() - EPS_SMALL)
                vU.push_back( dKnot) ;
          }
-         nSpanV = ssize( vU) - 1 ;
+         nSpanV = (int)vU.size() - 1 ;
       }
 
      // controllo se il vettore dei nodi è uniforme
@@ -604,97 +581,45 @@ MakeUniform( ISurfFlatRegion*& pSfr, bool& bRescaled, const DBLVECTOR& vU0, cons
          if ( b < (int)vU.size())
             d1 = abs( vU[b] - vU[a]) ;
       }
-      if ( b != (int)vU.size())
-         vbUniform[nDir] = false ;
-   }
-   // vettore delle curve di loop della regione di trim
-   ICRVCOMPOPOVECTOR vLoop ;
-   if ( ! vbUniform[0]  ||  ! vbUniform[1]) {
-      for ( int c = 0 ;  c < pSfr->GetChunkCount() ; ++c) {
-         for ( int l = 0 ; l < pSfr->GetLoopCount( c); ++l)
-            vLoop.emplace_back( ConvertCurveToComposite( pSfr->GetLoop( c, l))) ;
-      }
-   }
-
-#if SAVEMKUNIF_CRVS
-   //debug
-   vector<IGeoObj*> vGeo ;
-   for( int i = 0 ; i < ssize( vLoop); ++i){
-      vGeo.push_back(vLoop[i]->Clone()) ;
-   }
-   SaveGeoObj( vGeo, "D:\\Temp\\bezier\\import3dm\\trim_error\\failed_trim_crv_loops.nge") ;
-   //debug
-#endif
-
-   for ( int nDir = 0 ; nDir <= 1 ; ++ nDir) {
-      DBLVECTOR& vU = mKnots[nDir] ;
-      if ( ! vbUniform[nDir]) {
+      if ( b != (int)vU.size()) {
          nDir == 0 ? bRescaledU = true : bRescaledV = true ;
-         // creo il vettore delle curve all'interno di una striscia
-         ICRVCOMPOPOVECTOR vCrvStrip ; 
+         pRescaledSfr.Set( CreateSurfFlatRegion()) ;
+         if ( IsNull( pRescaledSfr))
+            return false ;
          for ( int p = 0 ; p < (int)vU.size() - 1 ; ++p) {
+            PtrOwner<ISurfFlatRegion> pSfr_copy( pSfr->Clone()) ;
+            if ( IsNull( pSfr_copy))
+               return false ;
             double dLenStrip = abs( vU[p+1] - vU[p]) ;
             if ( dLenStrip < EPS_SMALL)
                continue ;
             // creo la maschera per tagliare la superficie originale e ottenere una striscia
-            PtrOwner<ICurveComposite> pTrimMask ;
+            PtrOwner<ISurfFlatRegion> pSfrTrim( CreateSurfFlatRegion()) ;
 
             // ricavo la maschera del trim, con cui poi farò l'intersezione con la sfr iniziale
+            Vector3d vtTrim ;
             if ( nDir == 0) {
-               Point3d ptStart( abs(vU[p] - vU.front()), - 1, 0) ;
-               pTrimMask.Set( GetRectangleCurve( ptStart, dLenStrip, dScaleV + 2)) ;
+               pSfrTrim.Set( GetSurfFlatRegionRectangle( dLenStrip, dScaleV + 2)) ;
+               vtTrim.Set( abs(vU[p] - vU.front()), - 1, 0) ;
             }
             else{
-               Point3d ptStart( - 1, abs(vU[p] - vU.front()), 0) ;
-               pTrimMask.Set( GetRectangleCurve( ptStart, dScaleU + 2, dLenStrip)) ;
+               pSfrTrim.Set( GetSurfFlatRegionRectangle( dScaleU + 2, dLenStrip)) ;
+               vtTrim.Set( - 1, abs(vU[p] - vU.front()), 0) ;
             }
+            pSfrTrim->Translate( vtTrim) ;
 
-            // qui potrei decidere di eliminare tutti i tratti dei loop paralleli alla direzione del parametro che sto analizzando ( e di valore coincidente a quello di un nodo)
+            if ( ! pSfr_copy->Intersect( *pSfrTrim))
+               return false ;
 
-            for ( int l = 0 ; l < ssize( vLoop); ++l) {
-               #if SAVEMKUNIF_CRVS
-                  //debug
-                  vector<IGeoObj*> vGeo ;
-                  vGeo.push_back(pTrimMask->Clone()) ;
-                  vGeo.push_back(vLoop[l]->Clone()) ;
-                  SaveGeoObj( vGeo, "D:\\Temp\\bezier\\import3dm\\trim_error\\failed_trim_crv_inters.nge") ;
-                  //debug
-               #endif
-               IntersCurveCurve icc( *pTrimMask, *vLoop[l]) ;
-               CRVCVECTOR vCurveClass ;
-               icc.GetCurveClassification( 1, 10 * EPS_SMALL, vCurveClass) ;
-               for( int i = 0 ; i < ssize( vCurveClass); ++i) {
-                  if( vCurveClass[i].nClass == CRVC_IN  ||  vCurveClass[i].nClass == CRVC_ON_P)
-                     vCrvStrip.emplace_back( ConvertCurveToComposite( vLoop[l]->CopyParamRange( vCurveClass[i].dParS, vCurveClass[i].dParE))) ;
-               }
-            }
-
-            #if SAVEMKUNIF_CRVS
-               //debug
-               vector<IGeoObj*> vGeo ;
-               for( int i = 0 ; i < ssize( vCrvStrip); ++i){
-                  vGeo.push_back(vCrvStrip[i]->Clone()) ;
-               }
-               SaveGeoObj( vGeo, "D:\\Temp\\bezier\\import3dm\\trim_error\\failed_trim_crv_strip.nge") ;
-               //debug
-            #endif
-
-            // riscalo le curve nella striscia
-            if ( ! vCrvStrip.empty()) {
-               double dCoeffX = 1, dCoeffY = 1 ;
-               
+            // aggiungo la nuova striscia solo se è valida
+            if ( pSfr_copy->IsValid() ) {
                if ( nDir == 0)
-                  dCoeffX = SBZ_TREG_COEFF / dLenStrip ;
-               else 
-                  dCoeffY = SBZ_TREG_COEFF / dLenStrip ;
-               for( int i = 0 ; i < ssize( vCrvStrip); ++i) {
-                  if( ! IsNull( vCrvStrip[i]))
-                     vCrvStrip[i]->Scale( GLOB_FRM, dCoeffX, dCoeffY, 1) ;
-                  else
-                     return false ;
-               }
+                  pSfr_copy->Scale( GLOB_FRM, SBZ_TREG_COEFF / dLenStrip, 1, 1) ;
+               else
+                  pSfr_copy->Scale( GLOB_FRM, 1, SBZ_TREG_COEFF / dLenStrip, 1) ;
+
+               // prima di riunire la striscia al resto devo traslarla sul bordo destro della superificie che sto ricostruendo
 
-               // prima di riunire le curve al resto devo traslarle sul bordo destro della superificie che sto ricostruendo
                Point3d pt ;
                nDir == 0 ? pt.Set( abs(vU[p] - vU.front()), 0, 0) : pt.Set( 0,abs(vU[p] - vU.front()), 0) ;
                if ( nDir == 0)
@@ -707,78 +632,25 @@ MakeUniform( ISurfFlatRegion*& pSfr, bool& bRescaled, const DBLVECTOR& vU0, cons
                   vtJoin.Set( p * SBZ_TREG_COEFF - pt.x, 0, 0) ;
                else
                   vtJoin.Set( 0, p  * SBZ_TREG_COEFF - pt.y, 0) ;
-               for( int i = 0 ; i < ssize( vCrvStrip); ++i)
-                  vCrvStrip[i]->Translate( vtJoin) ;
-
-            #if SAVEMKUNIF_CRVS
-               //debug
-               vector<IGeoObj*> vGeo ;
-               for( int i = 0 ; i < ssize( vCrvStrip); ++i){
-                  vGeo.push_back(vCrvStrip[i]->Clone()) ;
-               }
-               SaveGeoObj( vGeo, "D:\\Temp\\bezier\\import3dm\\trim_error\\failed_trim_crv_strip.nge") ;
-               //debug
-            #endif
-               
-               // faccio la chain con le curve delle striscie precedenti
-               
-               if ( ! vUniformedCurves.empty()  ||  ! vCrvStrip.empty()) {
-                  #if SAVEMKUNIF_CRVS
-                     //debug
-                     vector<IGeoObj*> vGeo ;
-                     for( int i = 0 ; i < ssize( vUniformedCurves); ++i){
-                        vGeo.push_back(vUniformedCurves[i]->Clone()) ;
-                     }
-                     SaveGeoObj( vGeo, "D:\\Temp\\bezier\\import3dm\\trim_error\\failed_trim_crv_unif.nge") ;
-                     //debug
-                  #endif
-
-                  ChainCurves chainCrv ;
-                  double dChainTol = 5 * EPS_SMALL ;
-                  chainCrv.Init( false, dChainTol, max(ssize( vUniformedCurves), ssize(vCrvStrip))) ;
-                  for ( int c = 0 ; c < ssize( vUniformedCurves) ; ++c) {
-                     Point3d ptStart, ptEnd ;
-                     Vector3d vtStart, vtEnd ;
-                     vUniformedCurves[c]->GetStartPoint( ptStart) ;
-                     vUniformedCurves[c]->GetEndPoint( ptEnd) ;
-                     vUniformedCurves[c]->GetStartDir( vtStart) ;
-                     vUniformedCurves[c]->GetEndDir( vtEnd) ;
-                     chainCrv.AddCurve( 1 + c, ptStart, vtStart, ptEnd, vtEnd) ;
-                  }
-                  for ( int c = 0 ; c < ssize( vCrvStrip); ++c) {
-                     Point3d ptStart, ptEnd ;
-                     Vector3d vtStart, vtEnd ;
-                     vCrvStrip[c]->GetStartPoint( ptStart) ;
-                     vCrvStrip[c]->GetEndPoint( ptEnd) ;
-                     vCrvStrip[c]->GetStartDir( vtStart) ;
-                     vCrvStrip[c]->GetEndDir( vtEnd) ;
-                     chainCrv.AddCurve( 1 + ssize( vUniformedCurves) + c, ptStart, vtStart, ptEnd, vtEnd) ;
-                  }
-                  INTVECTOR vIds ;
-                  ICRVCOMPOPOVECTOR vNewCrv ;
-                  int nCrvPrec = ssize( vUniformedCurves) ;
-                  while ( chainCrv.GetChainFromNear( ORIG, false, vIds)) {
-                     vNewCrv.emplace_back( CreateBasicCurveComposite()) ;
-                     for ( int nId : vIds) {
-                        nId -= 1 ;
-                        if ( nId < nCrvPrec)
-                           vNewCrv.back()->AddCurve( Release( vUniformedCurves[nId]), true, dChainTol) ;
-                        else
-                           vNewCrv.back()->AddCurve( Release( vCrvStrip[nId - ssize( vUniformedCurves)]), true, dChainTol) ;
-                     }
-                  }
-                  // aggiorno le curve 
-                  vUniformedCurves.clear() ;
-                  vUniformedCurves.swap( vNewCrv)  ;
+               pSfr_copy->Translate( vtJoin) ;
+               // se sto ritentando MakeUniform, allora faccio anche OFFSET e controOFFSET
+               if ( bRetry)
+                  pSfr_copy->Offset( 10 * EPS_SMALL, ICurve::OFF_CHAMFER) ; // OFFSET
+               if ( pRescaledSfr->IsValid()) {
+                  if ( ! pRescaledSfr->Add( *pSfr_copy))
+                     return false ;
                }
+               else
+                  pRescaledSfr.Set( pSfr_copy) ;
             }
-            vCrvStrip.clear() ;
          }
          if ( nDir == 0) {
             dScaleU = ((int)vU.size() - 1) * SBZ_TREG_COEFF ;
-            if( ! vbUniform[1]) {
-               vLoop.swap( vUniformedCurves) ;
-               vUniformedCurves.clear() ;
+            if ( pRescaledSfr->IsValid()) {
+               if ( bRetry)
+                  pRescaledSfr->Offset( -10 * EPS_SMALL, ICurve::OFF_CHAMFER) ;  //contro OFFSET
+               delete pSfr ;
+               pSfr = Release( pRescaledSfr) ;
             }
          }
          else
@@ -786,38 +658,12 @@ MakeUniform( ISurfFlatRegion*& pSfr, bool& bRescaled, const DBLVECTOR& vU0, cons
       }
    }
 
-   if ( ! vUniformedCurves.empty()) {
-      #if SAVEMKUNIF_CRVS
-         //debug
-         vector<IGeoObj*> vGeo ;
-         for( int i = 0 ; i < ssize( vUniformedCurves); ++i){
-            vGeo.push_back(vUniformedCurves[i]->Clone()) ;
-         }
-         SaveGeoObj( vGeo, "D:\\Temp\\bezier\\import3dm\\trim_error\\failed_trim_crv_unif.nge") ;
-         //debug
-      #endif
-
-      // controllo che tutte le curve siano chiuse, sennò vuol dire che ho perso qualche pezzo durante le intersezioni
-      for ( int i = 0 ; i < ssize( vUniformedCurves); ++i) {
-         if ( ! vUniformedCurves[i]->IsClosed())
-            return false ;
-      }
-
-      // creo una regione dalle curve riscalate
-      SurfFlatRegionByContours sfrRescaled ;
-      for ( int i = 0 ; i < ssize( vUniformedCurves); ++i)
-         sfrRescaled.AddCurve( Release( vUniformedCurves[i])) ;
-
-      PtrOwner<ISurfFlatRegion> pRescaledSfr( sfrRescaled.GetSurf()) ;
-      if ( ! IsNull( pRescaledSfr)  &&  pRescaledSfr->IsValid()) {
-         delete pSfr ;
-         pSfr = Release( pRescaledSfr) ;
-      }
-      else
-         return false ;
+   if ( ! IsNull( pRescaledSfr)  &&  pRescaledSfr->IsValid()) {
+      if ( bRetry)
+         pRescaledSfr->Offset( -10 * EPS_SMALL, ICurve::OFF_CHAMFER) ;  // contro OFFSET
+      delete pSfr ;
+      pSfr = Release( pRescaledSfr) ;
    }
-   else if( ! vbUniform[0]  ||  ! vbUniform[1])
-      return false ;
 
    if ( ! bRescaledU  &&  ! bRescaledV)
       pSfr->Scale( GLOB_FRM, nSpanU / dScaleU * SBZ_TREG_COEFF, nSpanV / dScaleV * SBZ_TREG_COEFF, 1) ;

SurfBezier.h

@@ -116,9 +116,9 @@ 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 = 10 * EPS_SMALL, bool bUpdateEdges = false) const override ;
+      SurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL, bool bUpdateEdges = false) 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, bool bRefined = false) const override ;
+      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 ;
@@ -143,16 +143,16 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool IsPlanar( void) const override ;
       bool CreateByFlatContour( const PolyLine& PL) override ;
       bool CreateByRegion( const POLYLINEVECTOR& vPL) override ;
-      bool CreateByExtrusion( const ICurve* pCurve, const Vector3d& vtExtr) override ;
+      bool CreateByExtrusion( const ICurve* pCurve, const Vector3d& vtExtr, bool bDeg3OrDeg2 = false) override ;
       bool CreateByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vector3d& vtAx, double dAngRotDeg, double dMove) override ;
       bool CreateByPointCurve( const Point3d& pt, const ICurve* pCurve) override ;
       bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) override ;
       bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3) override ;
       PNTVECTOR GetAllControlPoints( void) const ;
       bool GetAllPatchesIsocurves( bool bUorV, ICURVEPOVECTOR& vCrv) const ;
-      bool CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const BIPNTVECTOR& vCrv) ;
-      bool RemoveCollapsedSpans( void) override ;
-      bool SwapParameters( void) ;
+      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 ;

SurfFlatRegion.cpp

@@ -28,11 +28,6 @@
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
-#define SAVECLASSCRV 0
-#if SAVECLASSCRV
-#include "/EgtDev/Include/EGkGeoObjSave.h"
-#endif
-
 using namespace std ;
 
 //----------------------------------------------------------------------------
@@ -1379,15 +1374,6 @@ SurfFlatRegion::MyGetCurveClassification( const ICurve& Crv, double dLenMin, CRV
       for ( int nLoop = 0 ; nLoop < GetLoopCount( nChunk) ; ++ nLoop) {
          const ICurve* pLoop = GetMyLoop( nChunk, nLoop) ;
         // intersezione
-
-#if SAVECLASSCRV
-         //debug
-         vector<IGeoObj*> vGeo ;
-         vGeo.push_back( Crv.Clone()) ;
-         vGeo.push_back( pLoop->Clone()) ;
-         SaveGeoObj( vGeo, "D:\\Temp\\inters\\CrvCrvInters\\crv_and_loop.nge") ;
-#endif
-
          IntersCurveCurve ccInt( Crv, *pLoop) ;
         // classificazione
          CRVCVECTOR ccPart ;

SurfTriMesh.cpp

@@ -4415,35 +4415,6 @@ SurfTriMesh::ClonePart( int nPart) const
    return Release( pSurfTM) ;
 }
 
-//----------------------------------------------------------------------------
-bool 
-SurfTriMesh::GetPartAndShellFromFacet( int nFacet, int& nPart, int& nShell) const
-{
-   // l'indice della faccia deve essere nei limiti
-   if ( nFacet < 0  ||  nFacet >= int( m_vFacet.size()))
-      return false ;
-
-   // mi assicuro che siano calcolate il numero di parti e di shell
-   int nParts = GetPartCount() ;
-
-   int nTria = m_vFacet[nFacet] ;
-   nShell = m_vTria[nTria].nShell ;
-
-   // scopro in quale part è la shell
-   int nPartTemp = 0 ;
-   nPart = - 1 ;
-   while ( nPartTemp < nParts  &&  nPart == - 1) {
-      for ( int i : m_vPart[nPartTemp].vShell) {
-         if ( i == nShell) {
-            nPart = nPartTemp ;
-            break ;
-         }
-      }
-      ++nPartTemp ;
-   }
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 SurfTriMesh::ResetTFlags( void)

SurfTriMesh.h

@@ -347,7 +347,6 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       bool GetPartVolume( int nPart, double& dVolume) const override ;
       bool GetPartLoops( int nPart, POLYLINEVECTOR& vPL) const override ;
       SurfTriMesh* ClonePart( int nPart) const override ;
-      bool GetPartAndShellFromFacet( int nFacet, int& nPart, int& nShell) const override ;
       bool SetTFlag( int nId, int nTFlag) override ;
       bool GetTFlag( int nId, int& nFlag) const override ;
       int  GetMaxTFlag( void) const override 

Tool.h

@@ -36,25 +36,25 @@ class Tool
       bool SetAdditiveTool( const std::string& sToolName, double dH, double dR, double dRc, int nToolNum) ;
       bool SetToolNum( int nToolNum)
                { m_nCurrentNum = nToolNum ; return true ; }
-      int GetType( void) const
+      int GetType() const
                { return m_nType ; }
-      int GetToolNum( void) const
+      int GetToolNum() const
                { return m_nCurrentNum ; }
-      double GetHeigth( void) const
+      double GetHeigth() const
                { return m_dHeight ; }
-      double GetTipHeigth( void) const
+      double GetTipHeigth() const
                { return m_dTipHeight ; }
-      double GetRadius( void) const
+      double GetRadius() const
                { return m_dRadius ; }
-      double GetTipRadius( void) const
+      double GetTipRadius() const
                { return m_dTipRadius ; } 
-      double GetCornRadius( void) const
+      double GetCornRadius() const
                { return m_dRCorner ; }
-      double GetRefRadius( void) const
+      double GetRefRadius() const
                { return m_dRefRadius ; } 
-      double GetMrtChsWidth( void) const
+      double GetMrtChsWidth() const
                { return m_dMrtChsWidth ; }
-      double GetMrtChsThickness( void) const
+      double GetMrtChsThickness() const
                { return m_dMrtChsThickness ; }
       const CurveComposite& GetOutline( void) const
                { return ( m_Outline) ; }

Tree.cpp

@@ -177,7 +177,7 @@ Tree::SetSurf( const SurfBezier* pSrfBz, const Point3d& ptMin, const Point3d& pt
       int nLoop = 0 ;
      // recupero la superficie di trim per avere accesso diretto ai loop e mantenendo le informazioni sui chunk
       PtrOwner<SurfFlatRegion> pTrimReg( m_pSrfBz->GetTrimRegion()->Clone()) ;
-      double dLinTol = 0.005 ; // questo è riferito allo spazio parametrico
+      double dLinTol = 0.01 ; // questo è riferito allo spazio parametrico
       double dAngTolDeg = 5 ;
       for ( int i = 0 ; i < pTrimReg->GetChunkCount() ; ++ i) {
          PtrOwner<SurfFlatRegion> pChunk( pTrimReg->CloneChunk( i)) ;
@@ -185,8 +185,6 @@ Tree::SetSurf( const SurfBezier* pSrfBz, const Point3d& ptMin, const Point3d& pt
            // i chunk della falt region sono ancora flat region composte da 1 chunk
             // rimuovo i difetti dei loop prima di salvarli
             PtrOwner<ICurveComposite> pLoop( GetBasicCurveComposite( pChunk->GetLoop( 0, j))) ;
-            if ( IsNull( pLoop))
-               return false ;
             pLoop->MergeCurves( dLinTol, dAngTolDeg) ;
             pLoop->RemoveSmallDefects( dLinTol, dAngTolDeg, true) ;
             pLoop->RemoveSmallParts( dLinTol, dAngTolDeg) ;
@@ -463,8 +461,8 @@ Tree::Split( int nId, double dSplitValue)
                           dSplitValue < cToSplit.GetTopRight().y - 10 * EPS_SMALL ;
    Point3d ptP00, ptP01, ptP10, ptP11 ;
    
-   if ( bGoodSplitVert) {
-      if ( cToSplit.GetBottomRight().x - dSplitValue > dSplitValue - cToSplit.GetBottomLeft().x) {
+   if( bGoodSplitVert) {
+      if( cToSplit.GetBottomRight().x - dSplitValue > dSplitValue - cToSplit.GetBottomLeft().x) {
          GetPoint( cToSplit.GetBottomLeft().x, cToSplit.GetBottomLeft().y, ptP00) ;
          GetPoint( dSplitValue, cToSplit.GetBottomRight().y, ptP10) ;
          GetPoint( cToSplit.GetTopLeft().x, cToSplit.GetTopLeft().y, ptP01) ;
@@ -476,13 +474,12 @@ Tree::Split( int nId, double dSplitValue)
          GetPoint( dSplitValue, cToSplit.GetTopLeft().y, ptP01) ;
          GetPoint( cToSplit.GetTopRight().x, cToSplit.GetTopRight().y, ptP11) ;
       }
-      if ( AreSamePointApprox( ptP00, ptP10)  &&  AreSamePointApprox( ptP01, ptP11)  &&
-          ( cToSplit.GetBottomRight().x - dSplitValue < SBZ_TREG_COEFF - EPS_SMALL  ||
-            dSplitValue - cToSplit.GetBottomLeft().x < SBZ_TREG_COEFF - EPS_SMALL))
+      if( AreSamePointApprox( ptP00, ptP10)  &&  AreSamePointApprox( ptP01, ptP11)  &&
+         ( cToSplit.GetBottomRight().x - dSplitValue < SBZ_TREG_COEFF - EPS_SMALL  ||  dSplitValue - cToSplit.GetBottomLeft().x < SBZ_TREG_COEFF - EPS_SMALL))
          bGoodSplitVert = false ;
    }
-   if ( bGoodSplitHoriz) {
-      if ( cToSplit.GetTopLeft().y - dSplitValue > dSplitValue - cToSplit.GetBottomLeft().y) {
+   if( bGoodSplitHoriz) {
+      if( cToSplit.GetTopLeft().y - dSplitValue > dSplitValue - cToSplit.GetBottomLeft().y) {
          GetPoint( cToSplit.GetBottomLeft().x, cToSplit.GetBottomLeft().y, ptP00) ;
          GetPoint( cToSplit.GetBottomRight().x, cToSplit.GetBottomRight().y, ptP10) ;
          GetPoint( cToSplit.GetTopLeft().x, dSplitValue, ptP01) ;
@@ -494,9 +491,8 @@ Tree::Split( int nId, double dSplitValue)
          GetPoint( cToSplit.GetTopLeft().x, cToSplit.GetTopLeft().y, ptP01) ;
          GetPoint( cToSplit.GetTopRight().x, cToSplit.GetTopRight().y, ptP11) ;
       }
-      if ( AreSamePointApprox( ptP00, ptP01)  &&  AreSamePointApprox( ptP10, ptP11)  &&
-          ( cToSplit.GetTopLeft().y - dSplitValue < SBZ_TREG_COEFF - EPS_SMALL  ||
-            dSplitValue - cToSplit.GetBottomLeft().y < SBZ_TREG_COEFF - EPS_SMALL))
+      if( AreSamePointApprox( ptP00, ptP01)  &&  AreSamePointApprox( ptP10, ptP11)  &&
+          ( cToSplit.GetTopLeft().y - dSplitValue < SBZ_TREG_COEFF - EPS_SMALL  ||  dSplitValue - cToSplit.GetBottomLeft().y < SBZ_TREG_COEFF - EPS_SMALL))
          bGoodSplitHoriz = false ;
    }
    
@@ -666,18 +662,8 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
                }
             }
 
-            // calcolo se la parte di superficie nella cella è piatta
-            PolyLine PL ;
-            PL.AddUPoint( 0, ptP00) ;
-            PL.AddUPoint( 1, ptP10) ;
-            PL.AddUPoint( 2, ptP11) ;
-            PL.AddUPoint( 3, ptP01) ;
-            PL.AddUPoint( 4, ptCen) ;
-            Plane3d plPlane ;
-            bool bIsFlat = PL.IsFlat( plPlane, dLinTol) ;
-
            // su isoparametriche in U e V
-            if ( dSagU < dLinTol  &&  dSagV < dLinTol  &&  ! bIsFlat) {
+            if ( dSagU < dLinTol  &&  dSagV < dLinTol) {
               // step di verifica in U e in V
                int nStepU = ( dLenParU > 1. / m_nDegU ? m_nDegU + 1 : 2) ;
                int nStepV = ( dLenParV > 1. / m_nDegV ? m_nDegV + 1 : 2) ;
@@ -738,73 +724,6 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
                //{ string sLog = " Da Isoparam : FrecciaU=" + ToString( dSagU, 3) + " FrecciaV=" + ToString( dSagV, 3) ;
                //  LOG_DBG_INFO( GetEGkLogger(), sLog.c_str())}
             }
-            else if ( dSagU < dLinTol  &&  dSagV < dLinTol  &&  bIsFlat) {
-               // se la cella è piatta devo verificare che i bordi siano dei tratti retti, altrimenti potrei commettere un errore di approssimazione
-               
-               // bordo inferiore e superiore
-               double dMaxDist = 0 ;
-               for ( int i = 0 ; i < 2 ; ++i) {
-                  CurveLine clU ;
-                  if ( i == 0)
-                     clU.Set( ptP00, ptP10) ;
-                  else if ( i == 1)
-                     clU.Set( ptP01, ptP11) ;
-                  double dV = 0 ;
-                  if ( i == 0)
-                     dV = pcToSplit->GetBottomLeft().y ;
-                  else if ( i == 1)
-                     dV = pcToSplit->GetTopRight().y ;
-
-
-                  int nStepU = 4 ;
-                  for ( int j = 1 ; j < nStepU ; ++ j) {
-                    // parametro U
-                     double dCoeffU = double( j) / nStepU ;
-                     double dU = ( 1 - dCoeffU) * pcToSplit->GetBottomLeft().x + dCoeffU * pcToSplit->GetTopRight().x ;
-                     Point3d ptBez ;
-                     GetPoint( dU, dV, ptBez) ;
-                     DistPointCurve dpc( ptBez, clU) ;
-                     double dDist = 0 ;
-                     dpc.GetDist( dDist) ;
-                     if ( dDist > dMaxDist)
-                        dMaxDist = dDist ;
-                  }
-               }
-               if ( dMaxDist > dLinTol)
-                  dSagU = dMaxDist ;
-
-               // bordo sinistro e destro
-               dMaxDist = 0 ;
-               for ( int i = 0 ; i < 2 ; ++i) {
-                  CurveLine clV ;
-                  if ( i == 0)
-                     clV.Set( ptP00, ptP01) ;
-                  else if ( i == 1)
-                     clV.Set( ptP10, ptP11) ;
-                  double dU = 0 ;
-                  if ( i == 0)
-                     dU = pcToSplit->GetBottomLeft().x ;
-                  else if ( i == 1)
-                     dU = pcToSplit->GetTopRight().x ;
-
-                  int nStepV = 4 ;
-                  for ( int j = 1 ; j < nStepV ; ++ j) {
-                    // parametro in V
-                     double dCoeffV = double( j) / nStepV ;
-                     double dV = ( 1 - dCoeffV) * pcToSplit->GetBottomLeft().y + dCoeffV * pcToSplit->GetTopRight().y ;
-                     Point3d ptBez ;
-                     GetPoint( dU, dV, ptBez) ;
-                     DistPointCurve dpc( ptBez, clV) ;
-                     double dDist = 0 ;
-                     dpc.GetDist( dDist) ;
-                     if ( dDist > dMaxDist)
-                        dMaxDist = dDist ;
-                  }
-               }
-               if ( dMaxDist > dLinTol)
-                  dSagV = dMaxDist ;
-            }
-
 
            // per lo split scelgo la direzione che è più vicina alla superficie originale nel punto di maggior distanza
            // misura approssimativa della curvatura in una direzione
@@ -815,8 +734,7 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
                bVert = false ;
             else
                bVert = ( dSagV <= dSagU) ;
-            bool bFirstTry = true ;
-            retry :
+            pcToSplit->SetSplitDirVert( bVert) ;
             // verifico che la cella sia da splittare e che eventualmente sia abbastanza grande da poterlo fare
             double dSideMinVal = 0 ;
             double dLengMinVal = 0 ;
@@ -858,11 +776,6 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
             }
             else if ( dSagV > dLinTol  ||  dSagU > dLinTol) {
                bSplit = bDimOk ;
-               if ( ! bSplit  &&  bFirstTry) {
-                  bFirstTry = false ;
-                  bVert = ! bVert ;
-                  goto retry ;
-               }
                //if ( bSplit)
                //   LOG_DBG_INFO( GetEGkLogger(), "  Split by SagittaUV")
             }
@@ -1542,7 +1455,7 @@ Tree::GetPolygons( POLYLINEMATRIX& vvPolygons, POLYLINEMATRIX& vvPolygons3d, vec
             ++ nPolyInd ;
             continue ;
          }
-         else if ( m_mTree[nId].m_nCollapsed != Cell::Collapsed::NO_COLLAPSE)
+         else if( m_mTree[nId].m_nCollapsed != Cell::Collapsed::NO_COLLAPSE)
             continue ;
          else {
             // vettore in cui salvo il chunk di appartenenza di ogni loop che attraversa la cella
@@ -2067,7 +1980,7 @@ Tree::FindCell( const Point3d& ptToAssign, const CurveLine& cl, INTVECTOR vCells
             nCells.push_back( nCell) ;
          nEdge = -2 ;
       }
-      if ( ssize( nCells) == 1)
+      if( ssize( nCells) == 1)
          return nCells ;
 
       Vector3d vtDir ;
@@ -2096,14 +2009,14 @@ Tree::FindCell( const Point3d& ptToAssign, const CurveLine& cl, INTVECTOR vCells
          if ( abs(vtDir.x) < 1 - EPS_SMALL/100  &&  abs(vtDir.y) < 1 - EPS_SMALL/100 )
             ptIntersPlus = ptIntersPlus + vtDir * EPS_SMALL ;
          // altrimenti ruoto a destra
-         else if (( nEdge == 4 && vtDir.x > 1 - EPS_SMALL / 100)  ||  ( nEdge == 6 && vtDir.x < - 1 + EPS_SMALL / 100) ||
+         else if( ( nEdge == 4 && vtDir.x > 1 - EPS_SMALL / 100)  ||  ( nEdge == 6 && vtDir.x < - 1 + EPS_SMALL / 100) ||
                   ( nEdge == 5 && vtDir.y > 1 - EPS_SMALL / 100)  ||  ( nEdge == 7 && vtDir.y < - 1 + EPS_SMALL / 100)) {
             Vector3d vtDirDX = vtDir ; vtDirDX.Rotate( Z_AX, -45) ;
             ptIntersPlus = ptIntersPlus + vtDirDX * EPS_SMALL ;
          }
          // altrimenti ruoto a sinistra
-         else /*if (( nEdge == 4 && vtDir.y < - 1 + EPS_SMALL / 100)  ||  ( nEdge == 6 && vtDir.y < 1 - EPS_SMALL / 100) ||
-                    ( nEdge == 5 && vtDir.x > 1 - EPS_SMALL / 100)  ||  ( nEdge == 7 && vtDir.x < - 1 + EPS_SMALL / 100))    // + tutti gli altri casi */ {
+         else /*if( ( nEdge == 4 && vtDir.y < - 1 + EPS_SMALL / 100)  ||  ( nEdge == 6 && vtDir.y < 1 - EPS_SMALL / 100) ||
+                  ( nEdge == 5 && vtDir.x > 1 - EPS_SMALL / 100)  ||  ( nEdge == 7 && vtDir.x < - 1 + EPS_SMALL / 100))    // + tutti gli altri casi */ {
             Vector3d vtDirDX = vtDir ; vtDirDX.Rotate( Z_AX, 45) ;
             ptIntersPlus = ptIntersPlus + vtDirDX * EPS_SMALL ;
          }
@@ -2225,7 +2138,7 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons)
       bool bLoopInside = true ;
       Point3d ptCurr ;
       int nIdPolygon = - 1;
-      if ( ! pCell->m_vnPolyId.empty())
+      if( ! pCell->m_vnPolyId.empty())
          nIdPolygon = pCell->m_vnPolyId[0] ;
       else
          return false ;
@@ -2265,9 +2178,9 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons)
             }
             // se l'intersezione e la stessa della precedente allora potrei essere entrato in un loop infinito
             // se per più volte il punto di intersezione resta più o meno lo stesso allora blocco tutto
-            if ( AreSamePointEpsilon( vptInters.back(), ptLastInters, 10 * EPS_SMALL)) {
+            if( AreSamePointEpsilon( vptInters.back(), ptLastInters, 10 * EPS_SMALL)) {
                ++ nInfiniteLoopCount ;
-               if ( nInfiniteLoopCount == 4) {
+               if( nInfiniteLoopCount == 4) {
                   LOG_ERROR( GetEGkLogger(), "Error Triangulating SurfBezier: infinte while loop occured in Tree::TraceLoopLabelCell") 
                   return false ;
                }
@@ -2276,7 +2189,7 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons)
             // aggiorno il puntatore alla cella
             pCell = &m_mTree[nId] ;
             // recupero l'indice del poligono base associato alla cella
-            if ( ! pCell->m_vnPolyId.empty())
+            if( ! pCell->m_vnPolyId.empty())
                nIdPolygon = pCell->m_vnPolyId[0] ;
             else
                return false ;
@@ -4112,8 +4025,7 @@ Tree::OnWhichEdge( int nId, const Point3d& ptToAssign, int& nEdge) const
    Point3d ptTl ( ptBL.x, ptTR.y) ;
    Point3d ptBr ( ptTR.x, ptBL.y) ;
 
-   if ( ptToAssign.y < ptBL.y - EPS_SMALL  ||  ptToAssign.y > ptTR.y + EPS_SMALL  || 
-        ptToAssign.x < ptBL.x - EPS_SMALL  ||  ptToAssign.x > ptTR.x + EPS_SMALL)
+   if( ptToAssign.y < ptBL.y - EPS_SMALL  ||  ptToAssign.y > ptTR.y + EPS_SMALL  ||  ptToAssign.x < ptBL.x - EPS_SMALL ||  ptToAssign.x > ptTR.x + EPS_SMALL)
       return false ;
    else if ( AreSamePointXYApprox( ptToAssign, ptTR))
       nEdge = 7 ;

Tree.h

@@ -23,8 +23,7 @@
 #include <utility>
 
 struct PairHashInt64 {
-   size_t
-   operator()( const std::pair<int64_t, int64_t>& key) const {
+   size_t operator()(const std::pair<int64_t, int64_t>& key) const {
       size_t h1 = std::hash<int64_t>{}(key.first) ;
       size_t h2 = std::hash<int64_t>{}(key.second) ;
       return h1 ^ (h2 << 1);  // Combine hashes
@@ -34,20 +33,14 @@ struct PairHashInt64 {
 //----------------------------------------------------------------------------
 struct Inters {
    int nIn ;
-   int nOut ;
    PNTVECTOR vpt ;
+   int nOut ;
    bool bCCW ;
    int nChunk ;
    bool bSortedbyStart ;
-
-   // nIn e nOut sono flag che indicano da quale lato ho l'ingresso e l'uscita a partire dal lato top in senso antiorario
-   // oltre il 3 sono le celle adiacenti in diagonale al vertice-> 4 corrisponde al ptTl e da lì in senso antiorario
-   // -1 se la curva è sempre dentro la cella
-
-  // riordino le intersezioni per lato in senso antiorario dal top
-  // 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)
+   // riordino le intersezioni per lato in senso antiorario dal top
+   // 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
       INTVECTOR vEdges = { 7, 0, 4, 1, 5, 2, 6, 3} ;
@@ -82,8 +75,7 @@ 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
@@ -143,18 +135,18 @@ struct Inters {
               ( nPos1 == 3  &&  a.vpt[nFirstA].y < b.vpt[nFirstB].y) ;
    }
 
-   bool
-   operator == ( Inters& b)
+   bool operator == ( Inters& b)
    {
       return AreSamePointExact( vpt[0], b.vpt[0]) ;
    }
-
-   bool
-   operator != ( Inters& b)
+   bool operator != ( Inters& b)
    {
       return ! AreSamePointExact( vpt[0], b.vpt[0]) ;
    }
 } ;
+// nIn e nOut sono flag che indicano da quale lato ho l'ingresso e l'uscita a partire dal lato top in senso antiorario
+// oltre il 3 sono le celle adiacenti in diagonale al vertice-> 4 corrisponde al ptTl e da lì in senso antiorario
+// -1 se la curva è sempre dentro la cella
 
 //----------------------------------------------------------------------------
 class Cell
@@ -168,12 +160,11 @@ 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:
+   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) {}
@@ -345,4 +336,4 @@ class Tree
       INTVECTOR                   m_vnParents ;        // vettore delle celle ottenute dalla divisione preliminare in singole patch
       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

@@ -1694,15 +1694,16 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
    if ( ! IsValid())
       return false ;
 
-  // Creo lo ZMap per i riferimenti degli intervalli sulle griglie
+  // creo lo ZMap per i riferimenti degli intervalli sulle griglie
    PtrOwner<VolZmap> pZMapCopy( CloneBasicVolZmap( this)) ;
    if ( IsNull( pZMapCopy)  ||  ! pZMapCopy->IsValid())
       return false ;
 
-  // Creo uno ZMap per gli intervalli da aggiungere o da rimuovere
+  // 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],
+        ! 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 ;
 
@@ -1718,7 +1719,7 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
   // 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 < ssize( pZMapCopy->m_Values[nGrid]) ; ++ nDex) {
+      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 ;
@@ -1726,9 +1727,9 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
          int nI = nDex % m_nNx[nGrid] ;
          int nJ = nDex / m_nNx[nGrid] ;
         // Recupero il numero di intervalli presenti nel Dexel corrente
-         int nIntervals = ssize( pZMapCopy->m_Values[nGrid][nDex]) ;
+         int nIntervals = int( pZMapCopy->m_Values[nGrid][nDex].size()) ;
         // Scorro gli intervalli presenti
-         for ( int nInfo = 0 ; nInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nInfo) {
+         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
@@ -1738,54 +1739,57 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
                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 != ssize( m_Values[nGrid][nDex])) {
+               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 = ssize( m_Values[nGrid][nDex]) ;
+                  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) ;
+                                                       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 != ssize( m_Values[nGrid][nDex])) {
+               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 = ssize( m_Values[nGrid][nDex]) ;
+                  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) ;
+                                                       Interval.dMax,
+                                                       pZMapCopy->m_Values[nGrid][nDex][nInfo+1].dMin, dToler, true,
+                                                       nToolNum, V_INVALID, V_INVALID) ;
                }
             }
            // --- Se richiesta prima restrizione
             else {
-              // Se la lunghezza dell'intervallo non è almeno il doppio della tolleranza
-               double dLen = Interval.dMax - Interval.dMin ;
-               if ( dLen < 2. * ( dToler + EPS_SMALL)) {
-                 // L'intervallo sparisce completamente
-                  SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL,
-                                     Interval.vtMinN, Interval.vtMaxN, nToolNum, true) ;
-                 // Rimuovo le parti di spillone nelle altre dimensioni
-                  if ( IsTriDexel()) {
-                     -- nIntervals ;
-                     pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
-                                                          Interval.dMin, Interval.dMax,
-                                                          dToler, true, Tool::UNDEF, V_INVALID, V_INVALID) ;
-                  }
+              // *** 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) ;
                }
-              // Se sufficientemente lungo, allora
-               else {
-                 // *** Estremo inferiore -> Intervallo : [ dMin, dMin + dToler ]
-                 // Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
-                  SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMin + dToler,
-                                     Interval.vtMinN, Interval.vtMinN, nToolNum, true) ;
-                 // *** Estremo superiore -> Intervallo : [ dMax - dToler, dMax ]
-                 // Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
-                  SubtractIntervals( nGrid, nI, nJ, Interval.dMax - dToler, Interval.dMax + EPS_SMALL,
-                                     Interval.vtMaxN, Interval.vtMaxN, nToolNum, true) ;
+              // *** 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) ;
                }
             }
          }
@@ -1795,12 +1799,12 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
   // Ciclo sulle griglie ( uso lo Zmap Corrente, lascio invariato pZMapCopy)
    for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
      // Ciclo sul numero di dexel presenti
-      for ( int nDex = 0 ; nDex < ssize( m_Values[nGrid]) ; ++ nDex) {
+      for ( int nDex = 0 ; nDex < int( m_Values[nGrid].size()) ; ++ nDex) {
         // Se l'intervallo è vuoto, non faccio nulla
          if ( m_Values[nGrid][nDex].empty())
             continue ;
         // Per ogni intervallo ricavato fino ad ora, restringo della tolleranza
-         for ( int nInfo = 0 ; nInfo < ssize( m_Values[nGrid][nDex]) ; ++ nInfo) {
+         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 ;
@@ -1812,7 +1816,7 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
                m_Values[nGrid][nDex][nInfo].dMax += dToler ;
             }
            // Definisco il colore
-            for ( int nOrigInfo = 0 ; nOrigInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nOrigInfo) {
+            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)
@@ -1826,7 +1830,7 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
   // 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 < ssize( pZMapExtra->m_Values[nGrid]) ; ++ nDex) {
+      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 ;
@@ -1834,19 +1838,19 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
          int nI = nDex % m_nNx[nGrid] ;
          int nJ = nDex / m_nNx[nGrid] ;
         // Per ogni intervallo ricavato fino ad ora...
-         for ( int nInfo = 0 ; nInfo < ssize( pZMapExtra->m_Values[nGrid][nDex]) ; ++ nInfo) {
+         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) ;
+              // ... aggiungo i contributi
+                AddIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, true) ;
             }
            // --- Se richiesta prima restrizione
             else {
-              // Sottraggo i contributi
+              // ... sottraggo i contributi
                SubtractIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, true) ;
             }
          }

VolZmap.h

@@ -21,8 +21,9 @@
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include <unordered_map>
 #include <stack>
-#include <tuple>
+#include <mutex>
 #include <atomic>
+#include <tuple>
 
 typedef std::pair<Point3d, Vector3d>  PNTVEC3D ;
 typedef std::vector<PNTVEC3D>        PNTVEC3DVECTOR ;  // vettore di intersezioni punto, vettore, tipo superficie
@@ -556,9 +557,9 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       mutable std::vector<InterVoxMatter> m_SliceXY ;
       mutable std::vector<InterVoxMatter> m_SliceXZ ;
       mutable std::vector<InterVoxMatter> m_SliceYZ ;
-      mutable std::atomic_flag            m_SliceFlag ;
+      mutable std::mutex                  m_SliceMutex ;
 
-      bool                                m_bIsBox ;
+      std::atomic<bool>                   m_bIsBox ;
 
       int                                 m_nCurrTool ;
       std::vector<Tool>                   m_vTool ;

VolZmapGraphics.cpp

@@ -1271,15 +1271,13 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
                         bDefTopology = true ;
                      }
                      if ( GetBlockNFromIJK( nSlBlockIJK, nSlBlockN)) {
-                        while ( m_SliceFlag.test_and_set( memory_order_acquire))
-                           m_SliceFlag.wait( true, memory_order_relaxed) ;
+                        m_SliceMutex.lock() ;
                         auto it = m_SliceYZ[nSlBlockN].find( nSliceN) ;
                         if ( it != m_SliceYZ[nSlBlockN].end()) {
                            bMatOnSlice = it->second ;
                            bDefTopology = true ;
                         }
-                        m_SliceFlag.clear( memory_order_release) ;
-                        m_SliceFlag.notify_one() ;
+                        m_SliceMutex.unlock() ;
                      }
                   }
                   else if ( abs( nAdjVox3[nCount]) == 2) {
@@ -1289,15 +1287,13 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
                         bDefTopology = true ;
                      }
                      if ( GetBlockNFromIJK( nSlBlockIJK, nSlBlockN)) {
-                        while ( m_SliceFlag.test_and_set( memory_order_acquire))
-                           m_SliceFlag.wait( true, memory_order_relaxed) ;
+                        m_SliceMutex.lock() ;
                         auto it = m_SliceXZ[nSlBlockN].find( nSliceN) ;
                         if ( it != m_SliceXZ[nSlBlockN].end()) {
                            bMatOnSlice = it->second ;
                            bDefTopology = true ;
                         }
-                        m_SliceFlag.clear( memory_order_release) ;
-                        m_SliceFlag.notify_one() ;
+                        m_SliceMutex.unlock() ;
                      }
                   }
                   else if ( abs( nAdjVox3[nCount]) == 3) {
@@ -1307,15 +1303,13 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
                         bDefTopology = true ;
                      }
                      if ( GetBlockNFromIJK( nSlBlockIJK, nSlBlockN)) {
-                        while ( m_SliceFlag.test_and_set( memory_order_acquire))
-                           m_SliceFlag.wait( true, memory_order_relaxed) ;
+                        m_SliceMutex.lock() ;
                         auto it = m_SliceXY[nSlBlockN].find( nSliceN) ;
                         if ( it != m_SliceXY[nSlBlockN].end()) {
                            bMatOnSlice = it->second ;
                            bDefTopology = true ;
                         }
-                        m_SliceFlag.clear( memory_order_release) ;
-                        m_SliceFlag.notify_one() ;
+                        m_SliceMutex.unlock() ;
                      }
                   }
                }
@@ -1380,33 +1374,27 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
                      if ( nSlBlockN == nBlock)
                         SliceYZ.emplace( nSliceN, bMatOnSlice) ;
                      else {
-                        while ( m_SliceFlag.test_and_set( memory_order_acquire))
-                           m_SliceFlag.wait( true, memory_order_relaxed) ;
+                        m_SliceMutex.lock() ;
                         m_SliceYZ[nSlBlockN].emplace( nSliceN, bMatOnSlice) ;
-                        m_SliceFlag.clear( memory_order_release) ;
-                        m_SliceFlag.notify_one() ;
+                        m_SliceMutex.unlock() ;
                      }
                   }
                   else if ( abs(nAdjVox3[nCount]) == 2) {
                      if ( nSlBlockN == nBlock)
                         SliceXZ.emplace( nSliceN, bMatOnSlice) ;
                      else {
-                        while ( m_SliceFlag.test_and_set( memory_order_acquire))
-                           m_SliceFlag.wait( true, memory_order_relaxed) ;
+                        m_SliceMutex.lock() ;
                         m_SliceXZ[nSlBlockN].emplace( nSliceN, bMatOnSlice) ;
-                        m_SliceFlag.clear( memory_order_release) ;
-                        m_SliceFlag.notify_one() ;
+                        m_SliceMutex.unlock() ;
                      }
                   }
                   else if ( abs(nAdjVox3[nCount]) == 3) {
                      if ( nSlBlockN == nBlock)
                         SliceXY.emplace(nSliceN, bMatOnSlice) ;
                      else {
-                        while ( m_SliceFlag.test_and_set( memory_order_acquire))
-                           m_SliceFlag.wait( true, memory_order_relaxed) ;
+                        m_SliceMutex.lock() ;
                         m_SliceXY[nSlBlockN].emplace( nSliceN, bMatOnSlice) ;
-                        m_SliceFlag.clear( memory_order_release) ;
-                        m_SliceFlag.notify_one() ;
+                        m_SliceMutex.unlock() ;
                      }
                   }
                }

VolZmapVolume.cpp

@@ -31,13 +31,6 @@
 #include <future>
 #include <numeric>
 
-#define SAVETRIMMINGTOOL 0
-
-#if SAVETRIMMINGTOOL
-std::vector<IGeoObj*> vGeo ;
-#include "/EgtDev/Include/EGkGeoObjSave.h"
-#endif
-
 using namespace std ;
 
 // ------------------------- OPERAZIONI SU INTERVALLI --------------------------------------------------------------------------------------
@@ -1576,6 +1569,10 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    else if ( n5AxisType == Move5Axis::ACROSS)
       nTotSurf = 2 + nSub * 4 + nSub * 2 + 16 ; // come sopra
 
+   int nSurfInd = 0 ;
+   vector<SurfBezForInters> vSurfBez( nTotSurf) ;
+   double dSide = 0 ;
+
    // punti di riferimento sul tool
    // tip del tool
    Point3d ptP1T ;
@@ -1588,14 +1585,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    Vector3d vtDirTip = ptP2T - ptP1T ;
    bool bTopIsPivot = vtDirTop.IsSmall() ;
    bool bTipIsPivot = vtDirTip.IsSmall() ;
-   bool bInverse = ! (bTopIsPivot || bTipIsPivot)  &&  vtDirTop * vtDirTip < 0 ;
-
-   if ( bInverse)
-      nTotSurf += 4 ;
-
-   int nSurfInd = 0 ;
-   vector<SurfBezForInters> vSurfBez( nTotSurf) ;
-   double dSide = 0 ;
+   bool bTopAndTipAreEquiverse = vtDirTop * vtDirTip > 0 ;
 
    // box dell'intero volume spazzato, nel riferimento object oriented
    BBox3d bbVol ;
@@ -1612,9 +1602,9 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    PNTVECTOR vPntTopStartBack(3) ;
    PNTVECTOR vPntTopEndBack(3) ;
    if ( nSub > 1) {
-      if ( bTopIsPivot)
+      if( bTopIsPivot)
          vtDirTop = vtDirTip ;
-      if ( bTipIsPivot)
+      if( bTipIsPivot)
          vtDirTip = vtDirTop ;
       // determino in che modo collegare il cilindro iniziale con quello finale
       Vector3d vtTopBaseEnd = vtDirTop - (( vtDirTop * vtLe) * vtLe) ;
@@ -1628,10 +1618,10 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
       dSide = ( ptRefEnd - ptRefStart) * vtLs ;
 
       // calcolo anche i vettori per le basi inferiori
-      Vector3d vtTipBaseStart = bInverse ? ( vtLs ^ vtDirTip) : -( vtLs ^ vtDirTip) ;
+      Vector3d vtTipBaseStart = -( vtLs ^ vtDirTip) ;
       vtTipBaseStart.Normalize() ;
       vtTipBaseStart *= dMinRad ;
-      Vector3d vtTipBaseEnd = bInverse ? ( vtLe ^ vtDirTip) : -( vtLe ^ vtDirTip) ;
+      Vector3d vtTipBaseEnd = -( vtLe ^ vtDirTip) ;
       vtTipBaseEnd.Normalize() ;
       vtTipBaseEnd *= dMinRad ;
       // aggiungo il primo punto per ognuno dei gruppi
@@ -1681,24 +1671,20 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
 
    vector<PNTVECTOR> vvPtCtrl ;
    // superficie laterale sinistra
-   CurveLine cLineLeftBottom ; cLineLeftBottom.Set( vPntTipEndFront.back(), vPntTipStartFront.back()) ;
-   if ( bInverse)
-      cLineLeftBottom.Invert() ;
-   PtrOwner<CurveBezier> cBezLeftBottom( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftBottom, nDegU, bRat))) ;
-   CurveLine cLineLeftTop ; cLineLeftTop.Set( vPntTopEndFront.back(), vPntTopStartFront.back()) ;
-   PtrOwner<CurveBezier> cBezLeftTop( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftTop, nDegU, bRat))) ;
-   vvPtCtrl.emplace_back( cBezLeftBottom->GetAllControlPoints()) ;
-   PNTVECTOR vPntLeft = cBezLeftTop->GetAllControlPoints() ;
+   CurveLine cLineLeftStart ; cLineLeftStart.Set( vPntTipStartFront.back(), vPntTopStartFront.back()) ;
+   PtrOwner<CurveBezier> cBezLeftStart( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftStart, nDegU, bRat))) ;
+   CurveLine cLineLeftEnd ; cLineLeftEnd.Set( vPntTipEndFront.back(), vPntTopEndFront.back()) ;
+   PtrOwner<CurveBezier> cBezLeftEnd( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftEnd, nDegU, bRat))) ;
+   vvPtCtrl.emplace_back( cBezLeftStart->GetAllControlPoints()) ;
+   PNTVECTOR vPntLeft = cBezLeftEnd->GetAllControlPoints() ;
    vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntLeft.begin(), vPntLeft.end()) ;
    // superficie laterale destra
-   CurveLine cLineRightBottom ; cLineRightBottom.Set( vPntTipStartFront.front(), vPntTipEndFront.front()) ;
-   if ( bInverse)
-      cLineRightBottom.Invert() ;
-   PtrOwner<CurveBezier> cBezRightBottom( GetBasicCurveBezier( LineToBezierCurve( &cLineRightBottom, nDegU, bRat))) ;
-   CurveLine cLineRightTop ; cLineRightTop.Set( vPntTopStartFront.front(), vPntTopEndFront.front()) ;
-   PtrOwner<CurveBezier> cBezRightTop( GetBasicCurveBezier( LineToBezierCurve( &cLineRightTop, nDegU, bRat))) ;
-   vvPtCtrl.emplace_back( cBezRightBottom->GetAllControlPoints()) ;
-   PNTVECTOR vPntRight = cBezRightTop->GetAllControlPoints() ;
+   CurveLine cLineRightStart ; cLineRightStart.Set( vPntTopStartFront.front(), vPntTipStartFront.front()) ;
+   PtrOwner<CurveBezier> cBezRightStart( GetBasicCurveBezier( LineToBezierCurve( &cLineRightStart, nDegU, bRat))) ;
+   CurveLine cLineRightEnd ; cLineRightEnd.Set( vPntTopEndFront.front(), vPntTipEndFront.front()) ;
+   PtrOwner<CurveBezier> cBezRightEnd( GetBasicCurveBezier( LineToBezierCurve( &cLineRightEnd, nDegU, bRat))) ;
+   vvPtCtrl.emplace_back( cBezRightStart->GetAllControlPoints()) ;
+   PNTVECTOR vPntRight = cBezRightEnd->GetAllControlPoints() ;
    vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntRight.begin(), vPntRight.end()) ;
    if ( nSub == 1) {
       // superficie inferiore
@@ -1763,83 +1749,43 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
          if ( ! bTipIsPivot) {
             // inferiori
             if ( dSide > 0) {
-               PNTVECTOR vPntTipEnd01 = cBezTipStartF1->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.emplace_back( vPntTipEnd01.begin(), vPntTipEnd01.end()) ;
-               else
-                  vvPtCtrl.emplace_back( vPntTipEnd01.rbegin(), vPntTipEnd01.rend()) ;
-               PNTVECTOR vPntTipEnd1 = cBezTipEndF1->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd1.begin(), vPntTipEnd1.end()) ;
-               else
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd1.rbegin(), vPntTipEnd1.rend()) ;
-               PNTVECTOR vPntTipEnd02 = cBezTipStartF2->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.emplace_back( vPntTipEnd02.begin(), vPntTipEnd02.end()) ;
-               else
-                  vvPtCtrl.emplace_back( vPntTipEnd02.rbegin(), vPntTipEnd02.rend()) ;
-               PNTVECTOR vPntTipEnd2 = cBezTipEndF2->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd2.begin(), vPntTipEnd2.end()) ;
-               else
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd2.rbegin(), vPntTipEnd2.rend()) ;
+               vvPtCtrl.emplace_back(cBezTipStartF1->GetAllControlPoints());
+               PNTVECTOR vPntTipEnd1 = cBezTipEndF1->GetAllControlPoints();
+               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTipEnd1.begin(), vPntTipEnd1.end());
+               vvPtCtrl.emplace_back(cBezTipStartF2->GetAllControlPoints());
+               PNTVECTOR vPntTipEnd2 = cBezTipEndF2->GetAllControlPoints();
+               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTipEnd2.begin(), vPntTipEnd2.end());
             }
             else {
-               PNTVECTOR vPntTipEnd01 = cBezTipStartB1->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.emplace_back( vPntTipEnd01.rbegin(), vPntTipEnd01.rend()) ;
-               else
-                  vvPtCtrl.emplace_back( vPntTipEnd01.begin(), vPntTipEnd01.end()) ;
-               PNTVECTOR vPntTipEnd1 = cBezTipEndB1->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd1.rbegin(), vPntTipEnd1.rend()) ;
-               else
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd1.begin(), vPntTipEnd1.end()) ;
-               PNTVECTOR vPntTipEnd02 = cBezTipStartB2->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.emplace_back( vPntTipEnd02.rbegin(), vPntTipEnd02.rend()) ;
-               else
-                  vvPtCtrl.emplace_back( vPntTipEnd02.begin(), vPntTipEnd02.end()) ;
-               PNTVECTOR vPntTipEnd2 = cBezTipEndB2->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd2.rbegin(), vPntTipEnd2.rend()) ;
-               else
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd2.begin(), vPntTipEnd2.end()) ;
+               PNTVECTOR vPntTipEnd01 = cBezTipStartB1->GetAllControlPoints();
+               vvPtCtrl.emplace_back(vPntTipEnd01.rbegin(), vPntTipEnd01.rend());
+               PNTVECTOR vPntTipEnd1 = cBezTipEndB1->GetAllControlPoints();
+               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTipEnd1.rbegin(), vPntTipEnd1.rend());
+               PNTVECTOR vPntTipEnd02 = cBezTipStartB2->GetAllControlPoints();
+               vvPtCtrl.emplace_back(vPntTipEnd02.rbegin(), vPntTipEnd02.rend());
+               PNTVECTOR vPntTipEnd2 = cBezTipEndB2->GetAllControlPoints();
+               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTipEnd2.rbegin(), vPntTipEnd2.rend());
             }
          }
          if ( ! bTopIsPivot) {
             // superiori
             if ( dSide > 0) {
-               PNTVECTOR vPntTopEnd01 = cBezTopStartB1->GetAllControlPoints() ;
-               vvPtCtrl.emplace_back( vPntTopEnd01.begin(), vPntTopEnd01.end()) ;
-               PNTVECTOR vPntTopEnd1 = cBezTopEndB1->GetAllControlPoints() ;
-               vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd1.begin(), vPntTopEnd1.end()) ;
-               PNTVECTOR vPntTopEnd02 = cBezTopStartB2->GetAllControlPoints() ;
-               vvPtCtrl.emplace_back( vPntTopEnd02.begin(), vPntTopEnd02.end()) ;
-               PNTVECTOR vPntTopEnd2 = cBezTopEndB2->GetAllControlPoints() ;
-               vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd2.begin(), vPntTopEnd2.end()) ;
+               vvPtCtrl.emplace_back(cBezTopStartB1->GetAllControlPoints());
+               PNTVECTOR vPntTopEnd1 = cBezTopEndB1->GetAllControlPoints();
+               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTopEnd1.begin(), vPntTopEnd1.end());
+               vvPtCtrl.emplace_back(cBezTopStartB2->GetAllControlPoints());
+               PNTVECTOR vPntTopEnd2 = cBezTopEndB2->GetAllControlPoints();
+               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTopEnd2.begin(), vPntTopEnd2.end());
             }
             else {
-               PNTVECTOR vPntTopEnd01 = cBezTopStartF1->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.emplace_back( vPntTopEnd01.rbegin(), vPntTopEnd01.rend()) ;
-               else
-                  vvPtCtrl.emplace_back( vPntTopEnd01.begin(), vPntTopEnd01.end()) ;
-               PNTVECTOR vPntTopEnd1 = cBezTopEndF1->GetAllControlPoints() ;
-               if ( ! bInverse) 
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd1.rbegin(), vPntTopEnd1.rend()) ;
-               else
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd1.begin(), vPntTopEnd1.end()) ;
-               PNTVECTOR vPntTopEnd02 = cBezTopStartF2->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.emplace_back( vPntTopEnd02.rbegin(), vPntTopEnd02.rend()) ;
-               else
-                  vvPtCtrl.emplace_back( vPntTopEnd02.begin(), vPntTopEnd02.end()) ;
-               PNTVECTOR vPntTopEnd2 = cBezTopEndF2->GetAllControlPoints() ;
-               if ( ! bInverse)
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd2.rbegin(), vPntTopEnd2.rend()) ;
-               else
-                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd2.begin(), vPntTopEnd2.end()) ;
+               PNTVECTOR vPntTopEnd01 = cBezTopStartF1->GetAllControlPoints();
+               vvPtCtrl.emplace_back(vPntTopEnd01.rbegin(), vPntTopEnd01.rend());
+               PNTVECTOR vPntTopEnd1 = cBezTopEndF1->GetAllControlPoints();
+               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTopEnd1.rbegin(), vPntTopEnd1.rend());
+               PNTVECTOR vPntTopEnd02 = cBezTopStartF2->GetAllControlPoints();
+               vvPtCtrl.emplace_back(vPntTopEnd02.rbegin(), vPntTopEnd02.rend());
+               PNTVECTOR vPntTopEnd2 = cBezTopEndF2->GetAllControlPoints();
+               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTopEnd2.rbegin(), vPntTopEnd2.rend());
             }
          }
          
@@ -1848,74 +1794,36 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
             if ( ! bTipIsPivot) {
                // inferiori
                if ( dSide > 0) {
-                  PNTVECTOR vPntTip01 = cBezTipStartB1->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.emplace_back( vPntTip01.rbegin(), vPntTip01.rend()) ;
-                  else
-                     vvPtCtrl.emplace_back( vPntTip01.begin(), vPntTip01.end()) ;
-                  PNTVECTOR vPntTip1 = cBezTipEndB1->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.rbegin(), vPntTip1.rend()) ;
-                  else 
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.begin(), vPntTip1.end()) ;
-                  PNTVECTOR vPntTip02 = cBezTipStartB2->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.emplace_back( vPntTip02.rbegin(), vPntTip02.rend()) ;
-                  else
-                     vvPtCtrl.emplace_back( vPntTip02.begin(), vPntTip02.end()) ;
-                  PNTVECTOR vPntTip2 = cBezTipEndB2->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.rbegin(), vPntTip2.rend()) ;
-                  else
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.begin(), vPntTip2.end()) ;
+                  PNTVECTOR vPntTip01 = cBezTipStartB1->GetAllControlPoints();
+                  vvPtCtrl.emplace_back(vPntTip01.rbegin(), vPntTip01.rend());
+                  PNTVECTOR vPntTip1 = cBezTipEndB1->GetAllControlPoints();
+                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTip1.rbegin(), vPntTip1.rend());
+                  PNTVECTOR vPntTip02 = cBezTipStartB2->GetAllControlPoints();
+                  vvPtCtrl.emplace_back(vPntTip02.rbegin(), vPntTip02.rend());
+                  PNTVECTOR vPntTip2 = cBezTipEndB2->GetAllControlPoints();
+                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTip2.rbegin(), vPntTip2.rend());
                }
                else {
-                  PNTVECTOR vPntTip01 = cBezTipStartF1->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.emplace_back( vPntTip01.begin(), vPntTip01.end()) ;
-                  else
-                     vvPtCtrl.emplace_back( vPntTip01.rbegin(), vPntTip01.rend()) ;
-                  PNTVECTOR vPntTip1 = cBezTipEndF1->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.begin(), vPntTip1.end()) ;
-                  else
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.rbegin(), vPntTip1.rend()) ;
-                  PNTVECTOR vPntTip02 = cBezTipStartF2->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.emplace_back( vPntTip02.begin(), vPntTip02.end()) ;
-                  else
-                     vvPtCtrl.emplace_back( vPntTip02.rbegin(), vPntTip02.rend()) ;
-                  PNTVECTOR vPntTip2 = cBezTipEndF2->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.begin(), vPntTip2.end()) ;
-                  else
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.rbegin(), vPntTip2.rend()) ;
+                  vvPtCtrl.emplace_back(cBezTipStartF1->GetAllControlPoints());
+                  PNTVECTOR vPntTip1 = cBezTipEndF1->GetAllControlPoints();
+                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTip1.begin(), vPntTip1.end());
+                  vvPtCtrl.emplace_back(cBezTipStartF2->GetAllControlPoints());
+                  PNTVECTOR vPntTip2 = cBezTipEndF2->GetAllControlPoints();
+                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTip2.begin(), vPntTip2.end());
                }
             }
             
-            if ( ! bTopIsPivot) {
+            if( ! bTopIsPivot) {
                // superiori
                if ( dSide > 0) {
-                  PNTVECTOR vPntTop01 = cBezTopStartF1->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.emplace_back( vPntTop01.rbegin(), vPntTop01.rend()) ;
-                  else
-                     vvPtCtrl.emplace_back( vPntTop01.begin(), vPntTop01.end()) ;
-                  PNTVECTOR vPntTop1 = cBezTopEndF1->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop1.rbegin(), vPntTop1.rend()) ;
-                  else
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop1.begin(), vPntTop1.end()) ;
-                  PNTVECTOR vPntTop02 = cBezTopStartF2->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.emplace_back( vPntTop02.rbegin(), vPntTop02.rend()) ;
-                  else
-                     vvPtCtrl.emplace_back( vPntTop02.begin(), vPntTop02.end()) ;
-                  PNTVECTOR vPntTop2 = cBezTopEndF2->GetAllControlPoints() ;
-                  if ( ! bInverse)
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop2.rbegin(), vPntTop2.rend()) ;
-                  else
-                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop2.begin(), vPntTop2.end()) ;
+                  PNTVECTOR vPntTop01 = cBezTopStartF1->GetAllControlPoints();
+                  vvPtCtrl.emplace_back(vPntTop01.rbegin(), vPntTop01.rend());
+                  PNTVECTOR vPntTop1 = cBezTopEndF1->GetAllControlPoints();
+                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTop1.rbegin(), vPntTop1.rend());
+                  PNTVECTOR vPntTop02 = cBezTopStartF2->GetAllControlPoints();
+                  vvPtCtrl.emplace_back(vPntTop02.rbegin(), vPntTop02.rend());
+                  PNTVECTOR vPntTop2 = cBezTopEndF2->GetAllControlPoints();
+                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTop2.rbegin(), vPntTop2.rend());
                }
                else {
                   vvPtCtrl.emplace_back(cBezTopStartB1->GetAllControlPoints());
@@ -1931,43 +1839,23 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
 
       // chiudo il volume con le superfici verticali e le basi dei tool
 
-      // chiudo il volume con le superici verticali end front 1
+      // chiudo il volume con le superici verticali end 1
       vvPtCtrl.emplace_back( cBezTipEndF1->GetAllControlPoints()) ;
-      PNTVECTOR vPntEndF1 = cBezTopEndF1->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEndF1.begin(), vPntEndF1.end()) ;
-      // chiudo il volume con le superici verticali end front 2
+      PNTVECTOR vPntEnd1 = cBezTopEndF1->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEnd1.begin(), vPntEnd1.end()) ;
+      // chiudo il volume con le superici verticali end 2
       vvPtCtrl.emplace_back( cBezTipEndF2->GetAllControlPoints()) ;
-      PNTVECTOR vPntEndF2 = cBezTopEndF2->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEndF2.begin(), vPntEndF2.end()) ;
-      if ( bInverse) {
-         // chiudo il volume con le superici verticali end back 1
-         vvPtCtrl.emplace_back( cBezTipEndB1->GetAllControlPoints()) ;
-         PNTVECTOR vPntEndB1 = cBezTopEndB1->GetAllControlPoints() ;
-         vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEndB1.begin(), vPntEndB1.end()) ;
-         // chiudo il volume con le superici verticali end back 2
-         vvPtCtrl.emplace_back( cBezTipEndB2->GetAllControlPoints()) ;
-         PNTVECTOR vPntEndB2 = cBezTopEndB2->GetAllControlPoints() ;
-         vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEndB2.begin(), vPntEndB2.end()) ;
-      }
+      PNTVECTOR vPntEnd2 = cBezTopEndF2->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEnd2.begin(), vPntEnd2.end()) ;
 
-      // chiudo il volume con le superici verticali start back 1
+      // chiudo il volume con le superici verticali start 1
       vvPtCtrl.emplace_back( cBezTipStartB1->GetAllControlPoints()) ;
-      PNTVECTOR vPntStartB1 = cBezTopStartB1->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStartB1.begin(), vPntStartB1.end()) ;
-      // chiudo il volume con le superfici verticali start back 2
+      PNTVECTOR vPntStart1 = cBezTopStartB1->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStart1.begin(), vPntStart1.end()) ;
+      // chiudo il volume con le superfici verticali start 2
       vvPtCtrl.emplace_back( cBezTipStartB2->GetAllControlPoints()) ;
-      PNTVECTOR vPntStartB2 = cBezTopStartB2->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStartB2.begin(), vPntStartB2.end()) ;
-      if ( bInverse) {
-         // chiudo il volume con le superici verticali start front 1
-         vvPtCtrl.emplace_back( cBezTipStartF1->GetAllControlPoints()) ;
-         PNTVECTOR vPntStartF1 = cBezTopStartF1->GetAllControlPoints() ;
-         vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStartF1.begin(), vPntStartF1.end()) ;
-         // chiudo il volume con le superfici verticali start front 2
-         vvPtCtrl.emplace_back( cBezTipStartF2->GetAllControlPoints()) ;
-         PNTVECTOR vPntStartF2 = cBezTopStartF2->GetAllControlPoints() ;
-         vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStartF2.begin(), vPntStartF2.end()) ;
-      }
+      PNTVECTOR vPntStart2 = cBezTopStartB2->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStart2.begin(), vPntStart2.end()) ;
 
       // superfici di base dei tool
       if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS  &&  dSide < 0)) {
@@ -2049,11 +1937,6 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
       vSurfBez[nSurfInd].sBez.SetControlPoint( 6, vvPtCtrl[z][6]) ;
       vSurfBez[nSurfInd].sBez.SetControlPoint( 7, vvPtCtrl[z][7]) ;
 
-#if SAVETRIMMINGTOOL
-      if ( nGrid == 0)
-         vGeo.push_back( vSurfBez[nSurfInd].sBez.Clone()) ;
-#endif
-
       Vector3d A = vvPtCtrl[z][4] - vvPtCtrl[z][0] ;
       Vector3d B = vvPtCtrl[z][5] - vvPtCtrl[z][1] ;
       Vector3d C = vvPtCtrl[z][6] - vvPtCtrl[z][2] ;
@@ -2102,11 +1985,6 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
       ++ nSurfInd ;
    }
 
-#if SAVETRIMMINGTOOL
-   if ( nGrid == 0)
-      SaveGeoObj( vGeo, "D:\\Temp\\VirtualMilling\\5axisAdvanced\\marmo sottosquadra\\volume.nge") ;
-#endif
-
    // scorro tutti gli spilloni interessati
    int j = 0 ;
    int nLastForwardJ = -1 ;

Voronoi.cpp

@@ -1155,7 +1155,7 @@ Voronoi::AdjustOffsetStart( ICurveComposite* pCrv) const
 
 //---------------------------------------------------------------------------
 bool
-Voronoi::Translate( const Vector3d& vtMove)
+Voronoi::Translate( const Vector3d & vtMove)
 {
    if ( ! IsValid())
       return false ;