EgtGeomKernel :

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

AdjustLoops.cpp

@@ -151,11 +151,11 @@ MyAdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
          else {
             double dParA = vIccInfo[i].IciA[0].dU ;
             double dParB = vIccInfo[i].IciB[0].dU ;
-            if ( dParA > dParB)
+            if ( abs( dParA - dEnd) < EPS_SMALL)
                swap( dParA, dParB) ;
            // verifico se uno dei due intervalli dà origine ad un tratto trascurabile
             PtrOwner<ICurve> pCrv1( pMyCrv->CopyParamRange( dParA, dParB)) ;
-            PtrOwner<ICurve> pCrv2( pMyCrv->CopyParamRange( dParB, dParA)) ;
+            PtrOwner<ICurve> pCrv2( pMyCrv->CopyParamRange( dParB, dParA)) ;           
             double dArea1 = 0, dArea2 = 0 ;
             if ( ! IsNull( pCrv1))
                pCrv1->GetAreaXY( dArea1) ;

CAvSimpleSurfFrMove.cpp

@@ -140,20 +140,16 @@ MyCAvSimpleSurfFrMove::Translate( const Vector3d& vtDir, double& dLen)
                   if ( scInfoCurr.nType == SCI_LINE_LINE  ||  scInfoCurr.nType == SCI_PNT_LINE) {
                      m_SCollInfo = scInfoCurr ;
                      m_SCollInfo.nChunkM = j ;
-                     m_SCollInfo.nLoopM = 0 ;
                      m_SCollInfo.nCrvM = k ;
                      m_SCollInfo.nChunkF = i ;
-                     m_SCollInfo.nLoopF = 0 ;
                      m_SCollInfo.nCrvF = l ;
                   }
                }
                else if ( dNewLenXY < dPrevLenXY) {
                   m_SCollInfo = scInfoCurr ;
                   m_SCollInfo.nChunkM = j ;
-                  m_SCollInfo.nLoopM = 0 ;
                   m_SCollInfo.nCrvM = k ;
                   m_SCollInfo.nChunkF = i ;
-                  m_SCollInfo.nLoopF = 0 ;
                   m_SCollInfo.nCrvF = l ;
                }
                pCrv2 = ( pCompo2 != nullptr ? pCompo2->GetNextCurve() : nullptr) ;

CAvSimpleSurfFrMove.h

@@ -30,7 +30,7 @@ class MyCAvSimpleSurfFrMove
       const SCollInfo& GetSCollInfo()
                { return m_SCollInfo ;}
 
-   protected :
+   private :
       bool TranslateCurveNoCollisionCurve( const ICurve* pCrv1, const ICurve* pCrv2,
                                            const Vector3d& vtDir, double& dLen, SCollInfo& scInfo) ;
       bool TranslateLineNoCollisionLine( const CurveLine* pLine1, const CurveLine* pLine2,
@@ -40,7 +40,7 @@ class MyCAvSimpleSurfFrMove
       bool RotateLineNoCollisionLine( const CurveLine* pLine1, const CurveLine* pLine2,
                                       const Point3d& ptCen, double& dAng) ;
 
-   protected :
+   private :
       const SurfFlatRegion* m_pRegM ;
       const SurfFlatRegion* m_pRegF ;
       SCollInfo m_SCollInfo ;

CAvSurfFrMove.cpp

@@ -1,257 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2026-2026
-//----------------------------------------------------------------------------
-// File : CASurfFrMove.cpp   Data : 26.03.2026     Versione : 3.1c7
-// Contenuto : Implementazione delle funzioni di movimento per SurfFlatRegion
-//             senza collisione con altri oggetti dello stesso tipo e nello
-//             stesso piano o in piani paralleli.
-//
-//
-// Modifiche : 26.03.2026 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "CAvSurfFrMove.h"
-#include "SurfFlatRegion.h"
-#include "CurveLine.h"
-#include "CurveArc.h"
-#include "CurveComposite.h"
-#include "IntersLineArc.h"
-#include "GeoConst.h"
-#include "/EgtDev/Include/EGkCAvSurfFrMove.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-// CASurfFrMove
-//----------------------------------------------------------------------------
-CAvSurfFrMove::CAvSurfFrMove( const ISurfFlatRegion& SfrM, const ISurfFlatRegion& SfrF)
-{
-  // salvo puntatori alle regioni
-   m_pRegM = &SfrM ;
-   m_pRegF = &SfrF ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvSurfFrMove::Translate( const Vector3d& vtDir, double& dLen)
-{
-   MyCAvSurfFrMove ScdMove( *m_pRegM, *m_pRegF) ;
-   m_CollInfo.nType = SCI_NONE ;
-   if ( ! ScdMove.Translate( vtDir, dLen))
-      return false ;
-   m_CollInfo = ScdMove.GetCollInfo() ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvSurfFrMove::Rotate( const Point3d& ptCen, double& dAng)
-{
-   MyCAvSurfFrMove ScdMove( *m_pRegM, *m_pRegF) ;
-   m_CollInfo.nType = SCI_NONE ;
-   return ScdMove.Rotate( ptCen, dAng) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-MyCAvSurfFrMove::Translate( const Vector3d& vtDir, double& dLen)
-{
-  // verifico validità regioni
-   if ( m_pRegM == nullptr  ||  m_pRegF == nullptr)
-      return false ;
-
-  // verifico che le due regioni giacciano in piani paralleli
-   if ( ! AreSameVectorApprox( m_pRegM->m_frF.VersZ(), m_pRegF->m_frF.VersZ()))
-      return false ;
-
-  // reset info di collisione
-   m_SCollInfo.nType = SCI_NONE ;
-
-  // porto il vettore di movimento nel riferimento intrinseco e ne annullo la componente Z
-   Vector3d vtDirL = vtDir ;
-   vtDirL.ToLoc( m_pRegM->m_frF) ;
-   vtDirL.z = 0 ;
-   double dLenXY = vtDirL.Len() ;
-   if ( dLenXY < EPS_SMALL)
-      return true ;
-   vtDirL /= dLenXY ;
-   dLenXY *= dLen ;
-   double dNewLenXY = dLenXY ;
-
-  // ciclo sui chunk della seconda superficie
-   for ( int nCF = 0 ; nCF < m_pRegF->GetChunkCount() ; ++ nCF) {
-     // ciclo sui bordi dei chunk
-      for ( int nLF = 0 ; nLF < m_pRegF->GetLoopCount( nCF) ; ++ nLF) {
-
-        // curva corrente del chunk della seconda regione in locale nel riferimento intrinseco della prima
-         const ICurve* pCrv2Loc = nullptr ;
-         PtrOwner<ICurve> pCopyCrv ;
-         if ( AreSameFrame( m_pRegM->m_frF, m_pRegF->m_frF))
-            pCrv2Loc = m_pRegF->GetMyLoop( nCF, nLF) ;
-         else {
-            pCopyCrv.Set( m_pRegF->GetMyLoop( nCF, nLF)->Clone()) ;
-            if ( IsNull( pCopyCrv))
-               return false ;
-            pCopyCrv->LocToLoc( m_pRegF->m_frF, m_pRegM->m_frF) ;
-            pCrv2Loc = pCopyCrv ;
-         }
-         const CurveComposite* pCompo2 = GetBasicCurveComposite( pCrv2Loc) ;
-
-        // ciclo sui chunk della prima superficie
-         for ( int nCM = 0 ; nCM < m_pRegM->GetChunkCount() ; ++ nCM) {
-           // ciclo sui bordi del chunk
-            for ( int nLM = 0 ; nLM < m_pRegM->GetLoopCount( nCM) ; ++ nLM) {
-
-              // per CAv non ha senso confrontare due loop interni tra di loro.
-              // posso confrontatare - due loop esterni (come per la CAvSimpleSurfFrMove)
-              //                     - un loop esterno con uno interno (nel caso in cui un Chunk sia contenuto dentro un isola)
-               if ( nLF > 0  &&  nLM > 0)
-                  continue ;
-
-              // curva corrente del chunk della prima regione (ovviamente già in locale al riferimento intrinseco)
-               const ICurve* pCrv1Loc = m_pRegM->GetMyLoop( nCM, nLM) ;
-               const CurveComposite* pCompo1 = GetBasicCurveComposite( pCrv1Loc) ;
-
-              // verifico la collisione tra le entità dei loop esterni dei due chunk
-               int k = 0 ;
-               const ICurve* pCrv1 = ( pCompo1 != nullptr ? pCompo1->GetFirstCurve() : pCrv1Loc) ;
-               while ( pCrv1 != nullptr) {
-                  int l = 0 ;
-                  const ICurve* pCrv2 = ( pCompo2 != nullptr ? pCompo2->GetFirstCurve() : pCrv2Loc) ;
-                  while ( pCrv2 != nullptr) {
-                     SCollInfo cInfoCurr ;
-                     double dPrevLenXY = dNewLenXY ;
-                     if ( ! TranslateCurveNoCollisionCurve( pCrv1, pCrv2, vtDirL, dNewLenXY, cInfoCurr))
-                        return false ;
-                     if ( abs( dNewLenXY - dPrevLenXY) < EPS_SMALL) {
-                        if ( cInfoCurr.nType == SCI_LINE_LINE  ||  cInfoCurr.nType == SCI_PNT_LINE) {
-                           m_SCollInfo = cInfoCurr ;
-                           m_SCollInfo.nChunkM = nCM ;
-                           m_SCollInfo.nLoopM = nLM ;
-                           m_SCollInfo.nCrvM = k ;
-                           m_SCollInfo.nChunkF = nCF ;
-                           m_SCollInfo.nLoopF = nLF ;
-                           m_SCollInfo.nCrvF = l ;
-                        }
-                     }
-                     else if ( dNewLenXY < dPrevLenXY) {
-                        m_SCollInfo = cInfoCurr ;
-                        m_SCollInfo.nChunkM = nCM ;
-                        m_SCollInfo.nLoopM = nLM ;
-                        m_SCollInfo.nCrvM = k ;
-                        m_SCollInfo.nChunkF = nCF ;
-                        m_SCollInfo.nLoopF = nLF ;
-                        m_SCollInfo.nCrvF = l ;
-                     }
-                     pCrv2 = ( pCompo2 != nullptr ? pCompo2->GetNextCurve() : nullptr) ;
-                     ++ l ;
-                  }
-                  pCrv1 = ( pCompo1 != nullptr ? pCompo1->GetNextCurve() : nullptr) ;
-                  ++ k ;
-               }
-            }
-         }
-      }
-   }
-
-  // se da limitare il movimento
-   if ( dNewLenXY < dLenXY - EPS_SMALL)
-      dLen *= dNewLenXY / dLenXY ;
-
-  // porto i punti e le direzioni di SCollInfo da intrinseco a locale della prima regione
-   if ( m_SCollInfo.nType != SCI_NONE) {
-      m_SCollInfo.ptP1.ToGlob( m_pRegM->m_frF) ;
-      m_SCollInfo.vtDirM.ToGlob( m_pRegM->m_frF) ;
-      m_SCollInfo.vtDirF.ToGlob( m_pRegM->m_frF) ;
-   }
-   if ( m_SCollInfo.nType == SCI_LINE_LINE)
-      m_SCollInfo.ptP2.ToGlob( m_pRegM->m_frF) ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-MyCAvSurfFrMove::Rotate( const Point3d& ptCen, double& dAng)
-{
-  // verifico validità regioni
-   if ( m_pRegM == nullptr  ||  m_pRegF == nullptr)
-      return false ;
-
-  // verifico che le due regioni giacciano in piani paralleli
-   if ( ! AreSameVectorApprox( m_pRegM->m_frF.VersZ(), m_pRegF->m_frF.VersZ()))
-      return false ;
-
-  // reset info di collisione
-   m_SCollInfo.nType = SCI_NONE ;
-
-  // porto il centro di rotazione nel riferimento intrinseco e ne annullo la componente Z
-   Point3d ptCenL = ptCen ;
-   ptCenL.ToLoc( m_pRegM->m_frF) ;
-   ptCenL.z = 0 ;
-   if ( abs( dAng) < EPS_ANG_SMALL)
-      return true ;
-   double dNewAng = dAng ;
-
-  // ciclo sui chunk della seconda superficie
-   for ( int nCF = 0 ; nCF < m_pRegF->GetChunkCount() ; ++ nCF) {
-     // ciclo sui bordi del Chunk
-      for ( int nLF = 0 ; nLF < m_pRegF->GetLoopCount( nCF) ; ++ nLF) {
-
-        // curva corrente del chunk della seconda regione in locale nel riferimento intrinseco della prima
-         const ICurve* pCrv2Loc = nullptr ;
-         PtrOwner<ICurve> pCopyCrv ;
-         if ( AreSameFrame( m_pRegM->m_frF, m_pRegF->m_frF))
-            pCrv2Loc = m_pRegF->GetMyLoop( nCF, nLF) ;
-         else {
-            pCopyCrv.Set( m_pRegF->GetMyLoop( nCF, nLF)->Clone()) ;
-            if ( IsNull( pCopyCrv))
-               return false ;
-            pCopyCrv->LocToLoc( m_pRegF->m_frF, m_pRegM->m_frF) ;
-            pCrv2Loc = pCopyCrv ;
-         }
-         const CurveComposite* pCompo2 = GetBasicCurveComposite( pCrv2Loc) ;
-
-        // ciclo sui chunk della prima superficie
-         for ( int nCM = 0 ; nCM < m_pRegM->GetChunkCount() ; ++ nCM) {
-           // ciclo sui bordi del chunk
-            for ( int nLM = 0 ; nLM < m_pRegM->GetLoopCount( nCM) ; ++ nLM) {
-
-              // per CAv non ha senso confrontare due loop interni tra di loro.
-              // posso confrontatare - due loop esterni (come per la CAvSimpleSurfFrMove)
-              //                     - un loop esterno con uno interno (nel caso in cui un Chunk sia contenuto dentro un isola)
-               if ( nLF > 0  &&  nLM > 0)
-                  continue ;
-
-              // curva esterna del chunk della prima regione (ovviamente già in locale al riferimento intrinseco)
-               const ICurve* pCrv1Loc = m_pRegM->GetMyLoop( nCM, nLM) ;
-               const CurveComposite* pCompo1 = GetBasicCurveComposite( pCrv1Loc) ;
-
-              // verifico la collisione tra le entità dei loop esterni dei due chunk
-               const ICurve* pCrv1 = ( pCompo1 != nullptr ? pCompo1->GetFirstCurve() : pCrv1Loc) ;
-               while ( pCrv1 != nullptr) {
-                  const ICurve* pCrv2 = ( pCompo2 != nullptr ? pCompo2->GetFirstCurve() : pCrv2Loc) ;
-                  while ( pCrv2 != nullptr) {
-                     if ( ! RotateCurveNoCollisionCurve( pCrv1, pCrv2, ptCenL, dNewAng))
-                        return false ;
-                     pCrv2 = ( pCompo2 != nullptr ? pCompo2->GetNextCurve() : nullptr) ;
-                  }
-                  pCrv1 = ( pCompo1 != nullptr ? pCompo1->GetNextCurve() : nullptr) ;
-               }
-            }
-         }
-      }
-   }
-
-  // se da limitare il movimento
-   if ( ( dAng > 0  &&  dNewAng < dAng - EPS_ANG_SMALL)  ||
-        ( dAng < 0  &&  dNewAng > dAng + EPS_ANG_SMALL))
-      dAng = dNewAng ;
-
-   return true ;
-}

CAvSurfFrMove.h

@@ -1,29 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2015-2018
-//----------------------------------------------------------------------------
-// File : CAvSurfFrMove.h      Data : 27.04.18    Versione : 3.1c7
-// Contenuto : Dich.ne classe privata per movimento di superfici flat region
-//             nel loro piano evitando collisioni
-//
-// Modifiche : 26.03.2026 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "CAvSimpleSurfFrMove.h"
-
-//----------------------------------------------------------------------------
-class MyCAvSurfFrMove : public MyCAvSimpleSurfFrMove
-{
-   public :
-      MyCAvSurfFrMove( const ISurfFlatRegion& SfrM, const ISurfFlatRegion& SfrF) :
-         MyCAvSimpleSurfFrMove( SfrM, SfrF) {} ;
-
-   public :
-      bool Translate( const Vector3d& vtDir, double& dLen) ;
-      bool Rotate( const Point3d& ptCen, double& dAng) ;
-      const SCollInfo& GetCollInfo()
-               { return m_SCollInfo ; }
-} ;

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) ;

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 ;
@@ -169,7 +168,7 @@ ChainCurves::GetChainFromPoint( const Point3d& ptStart, const Vector3d& vtStart,
       ptCurr = bEquiv ? m_vCrvData[nId].ptEnd : m_vCrvData[nId].ptStart ;
       vtCurr = bEquiv ? m_vCrvData[nId].vtEnd : - m_vCrvData[nId].vtStart ;
      // verifico se sono arrivato al punto di chiusura
-      if ( AreSamePointEpsilon( ptCurr, ptStop, 0.5 * EPS_SMALL)) {
+      if ( AreSamePointEpsilon( ptCurr, ptStop, m_dToler)) {
          bStopped = true ;
          break ;
       }

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,10 +281,8 @@ 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="CAvSurfFrMove.cpp" />
     <ClCompile Include="CAvToolSurfTm.cpp" />
     <ClCompile Include="CAvToolTriangle.cpp" />
     <ClCompile Include="CDeBoxClosedSurfTm.cpp" />
@@ -354,7 +352,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkSubtractProjectedFacesOnStmFace.h" />
     <ClInclude Include="..\Include\EGkSurfTriMeshAux.h" />
     <ClInclude Include="CAvSilhouetteSurfTm.h" />
-    <ClInclude Include="CAvSurfFrMove.h" />
     <ClInclude Include="CDeBoxTria.h" />
     <ClInclude Include="CDeCapsTria.h" />
     <ClInclude Include="CDeConeFrustumTria.h" />

EgtGeomKernel.vcxproj.filters

@@ -567,12 +567,6 @@
     <ClCompile Include="Trimming.cpp">
       <Filter>File di origine\GeoStriping</Filter>
     </ClCompile>
-    <ClCompile Include="CalcDerivate.cpp">
-      <Filter>File di origine\Geo</Filter>
-    </ClCompile>
-    <ClCompile Include="CAvSurfFrMove.cpp">
-      <Filter>File di origine\GeoCollisionAvoid</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="stdafx.h">
@@ -1259,9 +1253,6 @@
     <ClInclude Include="..\Include\EGkMultiGeomDB.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
-    <ClInclude Include="CAvSurfFrMove.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtGeomKernel.rc">

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 ;
@@ -576,25 +576,9 @@ IntersCurveCurve::CalcCurveClassification( const ICurve* pCurve, const ICCIVECTO
       }
    }
   // costruisco il vettore delle classificazioni
-   for ( int i = 0 ; i < nNumInters ; ++ i) { 
-     // se è definito un tratto precedente
+   for ( int i = 0 ; i < nNumInters ; ++ i) {
+     // se è definito un tratto precedente
       double dLenU ; pCurve->GetLengthAtParam( InfoCorr[i].IciA[0].dU, dLenU) ;
-      /*int j = i < nNumInters - 1 ? i + 1 : -1 ;
-      if ( pCurve->IsClosed()  &&  j == - 1)
-         j = 0 ;*/
-      int j = i == 0 ? -1 : i - 1 ;
-      if ( pCurve->IsClosed()  &&  j == - 1)
-         j = nNumInters - 1 ;
-      bool bSpike = false ;
-      if ( j != -1) {
-         bSpike = InfoCorr[i].bOverlap  &&  InfoCorr[j].bOverlap  &&  InfoCorr[i].bCBOverEq != InfoCorr[j].bCBOverEq ;
-         if ( bSpike) {
-            bSpike = abs( InfoCorr[i].IciA[0].dU - InfoCorr[j].IciA[0].dU) < EPS_PARAM || 
-                     abs( InfoCorr[i].IciA[0].dU - InfoCorr[j].IciA[1].dU) < EPS_PARAM || 
-                     abs( InfoCorr[i].IciA[1].dU - InfoCorr[j].IciA[0].dU) < EPS_PARAM ||
-                     abs( InfoCorr[i].IciA[1].dU - InfoCorr[j].IciA[1].dU) < EPS_PARAM ;
-         }
-      }
       if ( InfoCorr[i].IciA[0].dU > dCurrPar + EPS_PARAM  &&  dLenU - dCurrLen > dLenMin) {
         // verifico che la definizione sul tratto sia omogenea e valida
          int nPrevTy = InfoCorr[i].IciA[0].nPrevTy ;
@@ -615,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 ;
@@ -626,11 +610,7 @@ IntersCurveCurve::CalcCurveClassification( const ICurve* pCurve, const ICCIVECTO
         // salvo dati correnti
          dCurrPar = InfoCorr[i].IciA[1].dU ;
          dCurrLen = dLenU ;
-         // se sono in un caso di spike devo trattare l'overlap in modo diverso
-         if ( ! bSpike)
-            nLastTy = InfoCorr[i].IciA[1].nNextTy ;
-         else
-            nLastTy = InfoCorr[i].IciA[0].nPrevTy ;
+         nLastTy = InfoCorr[i].IciA[1].nNextTy ;
       }
    }
   // eventuale tratto finale rimasto
@@ -659,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))
@@ -702,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 {
@@ -756,7 +712,7 @@ IntersCurveCurve::GetCurveOutClass( const ICurve* pCurve, int& nClass)
    double dArea ;
    if ( ! pCurve->GetAreaXY( dArea))
       return false ;
-   nClass = (( dArea >= 0) ? CRVC_OUT : CRVC_IN) ;
+   nClass = (( dArea > 0) ? CRVC_OUT : CRVC_IN) ;
    return true ;
 }
 

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 ;}) ;
@@ -235,16 +237,6 @@ IntersCurvePlane::GetIntersCount( void)
    return m_nIntersCount ;
 }
 
-//----------------------------------------------------------------------------
-bool
-IntersCurvePlane::GetIntCrvPlnInfo( int nInd, IntCrvPlnInfo& aInfo)
-{
-   if ( nInd < 0  ||  nInd >= m_nIntersCount)
-      return false ;
-   aInfo = m_Info[nInd] ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 IntersCurvePlane::GetIntersPointNearTo( const Point3d& ptNear, Point3d& ptI, double& dParam)

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)

IntersLineSurfBez.cpp

@@ -72,28 +72,14 @@ static void
 UpdateInfoIntersLineSurfBz( const Point3d& ptL, const Vector3d& vtDir, int nILT, int nT, const Point3d& ptSP, const Point3d& ptIBz, double dCos,
                             const Point3d& ptSP2, const Point3d& ptIBz2, double dCos2, ILSBIVECTOR& vInfo)
 {
-   int nType = LSBT_NONE ;
-   if ( dCos > EPS_ZERO)
-      nType = LSBT_IN ;
-   else if ( dCos < EPS_ZERO)
-      nType = LSBT_OUT ;
-   else
-      nType = LSBT_TOUCH ;
-
    if ( nILT == ILTA_IN  ||  nILT == ILTA_EDGE  ||  nILT == ILTA_VERT  ||  nILT == ILTA_NO_TRIA) {
       double dU = ( ptIBz - ptL) * vtDir ;
-      vInfo.emplace_back( nType, dU, nT, dCos, ptIBz, ptSP) ;
+      vInfo.emplace_back( nILT, dU, nT, dCos, ptIBz, ptSP) ;
    }
    else if ( nILT == ILTA_SEGM  ||  nILT == ILTA_SEGM_ON_EDGE) {
       double dU = ( ptIBz - ptL) * vtDir ;
       double dU2 = ( ptIBz2 - ptL) * vtDir ;
-      int nType2 = LSBT_NONE ;
-      if ( dCos2 > EPS_ZERO)
-         nType2 = LSBT_IN ;
-      else if ( dCos2 < EPS_ZERO)
-         nType2 = LSBT_OUT ;
-      vInfo.emplace_back( nType, dU, 0, nT, dCos, ptIBz, P_INVALID, ptSP, P_INVALID) ;
-      vInfo.emplace_back( nType2, dU2, 0, nT, dCos2, ptIBz2, P_INVALID, ptSP2, P_INVALID) ;
+      vInfo.emplace_back( nILT, dU, dU2, nT, dCos2, ptIBz, ptIBz2, ptSP, ptSP2) ;
    }
 }
 
@@ -107,7 +93,9 @@ OrderInfoIntersLineSurfBz( ILSBIVECTOR& vInfo)
    // ordino il vettore delle intersezioni secondo il senso crescente del parametro di linea
    sort( vInfo.begin(), vInfo.end(), 
       []( const IntLinSbzInfo& a, const IntLinSbzInfo& b)
-      {  return ( a.dU < b.dU) ; }) ;
+      {  double dUa = ( ( a.nILTA == ILTA_SEGM  ||  a.nILTA == ILTA_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
+         double dUb = ( ( b.nILTA == ILTA_SEGM  ||  b.nILTA == ILTA_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
+   return ( dUa < dUb) ; }) ;
 }
 
 //----------------------------------------------------------------------------
@@ -193,9 +181,19 @@ FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters)
    // ciclo sulle intersezioni
    for ( const auto& Info : vInfo) {
       // se intersezione puntuale
-      vInters.emplace_back( Info.nILSB, Info.dU) ;
-      // se intersezione sovrapposta
-      // da sviluppare
+      if ( Info.nILTA == ILTA_VERT  ||  Info.nILTA == ILTA_EDGE  ||  Info.nILTA == ILTA_IN) {
+         int nFlag = LSBT_TOUCH ;
+         if ( Info.dCosDN > EPS_ZERO)
+            nFlag = LSBT_OUT ;
+         else if ( Info.dCosDN < -EPS_ZERO)
+            nFlag = LSBT_IN ;
+         vInters.emplace_back( nFlag, Info.dU) ;
+      }
+      // se altrimenti intersezione con coincidenza
+      else if ( Info.nILTA == ILTA_SEGM  ||  Info.nILTA == ILTA_SEGM_ON_EDGE) {
+         vInters.emplace_back( LSBT_TG_INI, Info.dU) ;
+         vInters.emplace_back( LSBT_TG_FIN, Info.dU2) ;
+      }
    }
    // elimino intersezioni ripetute
    for ( size_t j = 1 ; j < vInters.size() ; ) {
@@ -241,343 +239,7 @@ FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters)
 }
 
 //----------------------------------------------------------------------------
-//  Intersezione di una linea con una superficie di Bezier di grado 3x1 monopatch
-//----------------------------------------------------------------------------
-bool
-IntersLineSurfBzCubicLinear( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfBezier* pSurfBz,
-                             ILSBIVECTOR& vInfo, bool bFinite)
-{
-   int nDegU, nDegV, nSpanU, nSpanV ;
-   bool bRat, bTrimmed ;
-   pSurfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
-
-   // funzione pensata per funzionare solo con una monopatch di grado 3x1
-   if ( nDegU != 3 || nDegV != 1 ||  nSpanU > 1  || nSpanV > 1 || bRat)
-      return false ;
-
-   int nInters = int( vInfo.size()) ;
-
-   Point3d r = ptL ;
-   Vector3d q = vtL ;
-   bool bNeedToRotX = AreSameVectorApprox( q, X_AX) ;
-   bool bNeedToRotY = AreSameVectorApprox( q, Y_AX) ;
-   bool bNeedToRot = bNeedToRotX  ||  bNeedToRotY ;
-   Frame3d frRot ;
-   if ( bNeedToRotX)
-      frRot.Set( ORIG, X_AX) ;
-   if ( bNeedToRotY)
-      frRot.Set( ORIG, Y_AX) ;
-   if ( bNeedToRot) {
-      r.ToLoc( frRot) ;
-      q.ToLoc( frRot) ;
-   }
-
-   PNTVECTOR vPntCtrl = pSurfBz->GetAllControlPoints() ;
-
-   if ( bNeedToRot) {
-      for ( Point3d& pt: vPntCtrl)
-         pt.ToLoc( frRot) ;
-   }
-
-   Vector3d A = vPntCtrl[4] - vPntCtrl[0] ;
-   Vector3d B = vPntCtrl[5] - vPntCtrl[1] ;
-   Vector3d C = vPntCtrl[6] - vPntCtrl[2] ;
-   Vector3d D = vPntCtrl[7] - vPntCtrl[3] ;
-   Vector3d E = vPntCtrl[0] - ORIG ;
-   Vector3d F = vPntCtrl[1] - ORIG ;
-   Vector3d G = vPntCtrl[2] - ORIG ;
-   Vector3d H = vPntCtrl[3] - ORIG ;
-
-   Vector3d a3 = -A + 3 * B - 3 * C + D ;
-   Vector3d a2 = 3 * A - 6 * B + 3 * C ;
-   Vector3d a1 = -3 * A + 3 * B ;
-   Vector3d a0 = A ;
-
-   Vector3d b3 = -E + 3 * F - 3 * G + H ;
-   Vector3d b2 = 3 * E - 6 * F + 3 * G ;
-   Vector3d b1 = -3 * E + 3 * F ;
-   Vector3d b0 = E ;
-
-   
-
-   DBLVECTOR vdCoeff, vdRoots ;
-   // coefficienti dal grado più basso al grado più alto
-   vdCoeff = { // c0
-               q.x*q.z*a0.y*b0.z - q.x*q.y*a0.z*b0.z                                          // 3
-               - r.z*q.x*q.z*a0.y + r.z*q.x*q.y*a0.z +                                        // 3
-               q.y*q.z*a0.z*b0.z - q.z*q.z*a0.y*b0.x                                          // 4
-               - r.x*q.y*q.z*a0.z + r.x*q.z*q.z*a0.y +                                        // 4
-               q.z*q.z*a0.x*b0.y - q.y*q.z*a0.x*b0.z - q.x*q.z*a0.z*b0.y + q.x*q.y*a0.z*b0.z  // 5
-               - r.y*q.z*q.z*a0.x + r.z*q.y*q.z*a0.x + r.y*q.x*q.z*a0.z - r.z*q.x*q.y*a0.z,   // 5
-
-               // c1
-               q.x*q.z*(a1.y*b0.z + a0.y*b1.z) - q.x*q.y*(a1.z*b0.z + a0.z*b1.z)             // 3
-               - r.z*q.x*q.z*a1.y + r.z*q.x*q.y*a1.z +                                       // 3
-               q.y*q.z*(a1.z*b0.x + a0.z*b1.x) - q.z*q.z*(a1.y*b0.x + a0.y*b1.x)             // 4
-               - r.x*q.y*q.z*a1.z + r.x*q.z*q.z*a1.y +                                       // 4
-               q.z*q.z*(a1.x*b0.y + a0.x*b1.y) - q.y*q.z*(a1.x*b0.z + a0.x*b1.z)             // 5
-               - q.x*q.z*(a1.z*b0.y + a0.z*b1.y) + q.x*q.y*(a1.z*b0.z + a0.z*b1.z)           // 5
-               - r.y*q.z*q.z*a1.x + r.z*q.y*q.z*a1.x + r.y*q.x*q.z*a1.z - r.z*q.x*q.y*a1.z,  // 5
-                    
-               // c2
-               q.x*q.z*(a2.y*b0.z + a1.y*b1.z + a0.y*b2.z) - q.x*q.y*(a2.z*b0.z + a1.z*b1.z + a0.z*b2.z)  // 3
-               - r.z*q.x*q.z*a2.y + r.z*q.x*q.y*a2.z +                                                    // 3
-               q.y*q.z*(a2.z*b0.x + a1.z*b1.x + a0.z*b2.x) - q.z*q.z*(a2.y*b0.x + a1.y*b1.x + a0.y*b2.x)  // 4
-               - r.x*q.y*q.z*a2.z + r.x*q.z*q.z*a2.y +                                                    // 4
-               q.z*q.z*(a2.x*b0.y + a1.x*b1.y + a0.x*b2.y) - q.y*q.z*(a2.x*b0.z + a1.x*b1.z + a0.x*b2.z)  // 5
-               - q.x*q.z*(a2.z*b0.y + a1.z*b1.y + a0.z*b2.y) + q.x*q.y*(a2.z*b0.z + a1.z*b1.z + a0.z*b2.z)// 5
-               - r.y*q.z*q.z*a2.x + r.z*q.y*q.z*a2.x + r.y*q.x*q.z*a2.z - r.z*q.x*q.y*a2.z,               // 5
-
-               // c3
-               q.x*q.z*(a3.y*b0.z + a2.y*b1.z + a1.y*b2.z + a0.y*b3.z) - q.x*q.y*(a3.z*b0.z + a2.z*b1.z + a1.z*b2.z + a0.z*b3.z)  // 3
-               - r.z*q.x*q.z*a3.y + r.z*q.x*q.y*a3.z +                                                                            // 3
-               q.y*q.z*(a3.z*b0.x + a2.z*b1.x + a1.z*b2.x + a0.z*b3.x) - q.z*q.z*(a3.y*b0.x + a2.y*b1.x + a1.y*b2.x + a0.y*b3.x)  // 4
-               - r.x*q.y*q.z*a3.z + r.x*q.z*q.z*a3.y +                                                                            // 4
-               q.z*q.z*(a3.x*b0.y + a2.x*b1.y + a1.x*b2.y + a0.x*b3.y) - q.y*q.z*(a3.x*b0.z + a2.x*b1.z + a1.x*b2.z + a0.x*b3.z)  // 5
-               - q.x*q.z*(a3.z*b0.y + a2.z*b1.y + a1.z*b2.y + a0.z*b3.y) + q.x*q.y*(a3.z*b0.z + a2.z*b1.z + a1.z*b2.z + a0.z*b3.z)// 5
-               - r.y*q.z*q.z*a3.x + r.z*q.y*q.z*a3.x + r.y*q.x*q.z*a3.z - r.z*q.x*q.y*a3.z,                                       // 5
-                    
-               // c4
-               q.x*q.z*(a3.y*b1.z + a2.y*b2.z + a1.y*b3.z) - q.x*q.y*(a3.z*b1.z + a2.z*b2.z + a1.z*b3.z) +     // 3
-               q.y*q.z*(a3.z*b1.x + a2.z*b2.x + a1.z*b3.x) - q.z*q.z*(a3.y*b1.x + a2.y*b2.x + a1.y*b3.x) +     // 4
-               q.z*q.z*(a3.x*b1.y + a2.x*b2.y + a1.x*b3.y) - q.y*q.z*(a3.x*b1.z + a2.x*b2.z + a1.x*b3.z)       // 5
-               - q.x*q.z*(a3.z*b1.y + a2.z*b2.y + a1.z*b3.y) + q.x*q.y*(a3.z*b1.z + a2.z*b2.z + a1.z*b3.z),    // 5
-
-               // c5
-               q.x*q.z*(a3.y*b2.z + a2.y*b3.z) - q.x*q.y*(a3.z*b2.z + a2.z*b3.z) +     // 3
-               q.y*q.z*(a3.z*b2.x + a2.z*b3.x) - q.z*q.z*(a3.y*b2.x + a2.y*b3.x) +     // 4
-               q.z*q.z*(a3.x*b2.y + a2.x*b3.y) - q.y*q.z*(a3.x*b2.z + a2.x*b3.z)       // 5
-               - q.x*q.z*(a3.z*b2.y + a2.z*b3.y) + q.x*q.y*(a3.z*b2.z + a2.z*b3.z),    // 5
-
-               // c6
-               q.x*q.z*a3.y*b3.z - q.x*q.y*a3.z*b3.z +                                           // 3
-               q.y*q.z*a3.z*b3.x - q.z*q.z*a3.y*b3.x +                                           // 4
-               q.z*q.z*a3.x*b3.y - q.y*q.z*a3.x*b3.z - q.x*q.z*a3.z*b3.y + q.x*q.y*a3.z*b3.z} ;  // 5
-   int nRoots = PolynomialRoots( 6, vdCoeff, vdRoots) ;
-   bool bFound = false ;
-   for ( int w = 0 ; w < nRoots ; ++w) {
-      double dU = 0, dV = 0 ;
-      if ( vdRoots[w] > 0 - EPS_ZERO  &&  vdRoots[w] < 1 + EPS_ZERO) {
-         dU = vdRoots[w] ;
-         // verifico che non sia una soluzione con molteplicità > 1
-         bool bAlreadyFound = false ;
-         for ( int k = w - 1 ; k >= 0  &&  ! bAlreadyFound ; --k)
-            bAlreadyFound = ( abs( dU - vdRoots[k]) < EPS_PARAM) ;
-         if ( ! bAlreadyFound) {
-            Vector3d vAlpha = a3 * pow(dU, 3) + a2 * pow( dU, 2) + a1 * dU + a0 ;
-            Vector3d vBeta = b3 * pow(dU, 3) + b2 * pow( dU, 2) + b1 * dU + b0 ;
-            double dDen = ( vAlpha.x * q.z - vAlpha.z * q.x) ;
-            if ( abs( dDen) > EPS_ZERO) 
-               dV = ( ( vBeta.z - r.z) * q.x - ( vBeta.x - r.x ) * q.z) / dDen ;
-            else {
-               // se la prima equazione risulta un x/0 allora uso la seconda equazione per trovare il secondo parametro
-               double dDen2 = ( vAlpha.y * q.z - vAlpha.z * q.y) ;
-               dV = ( ( vBeta.z - r.z) * q.y - ( vBeta.y - r.y ) * q.z) / dDen2 ;
-            }
-            if ( dV > - EPS_ZERO  &&  dV < 1 + EPS_ZERO) {
-               Point3d ptIBez, ptIBez2 ;
-               Vector3d vtN ;
-               pSurfBz->GetPointNrmD1D2(dU, dV, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez, vtN) ;
-               Point3d ptSP( dU, dV, 0), ptSP2 ;
-               double dCos = vtN * vtL, dCos2 = 0 ;
-               int nType = ILTA_NO_TRIA ;
-               UpdateInfoIntersLineSurfBz( ptL, vtL, nType, -1, ptSP, ptIBez, dCos, ptSP2, ptIBez2, dCos2, vInfo) ;
-               bFound = true ;
-            }
-         }
-      }
-   }
-
-   //// se tutti i coefficienti sono zero allora potrei avere una linea che giace sulla superficie
-   //// per trovare i punti di inizio e fine sovrapposizione trovo i punti a minima distanza tra la linea e gli edge della superficie
-   //if ( ! bFound  &&  abs( vdCoeff[0]) < EPS_ZERO  &&  abs( vdCoeff[1]) < EPS_ZERO  &&  abs( vdCoeff[2]) < EPS_ZERO) {
-   //   ICRVCOMPOPOVECTOR vCrvEdge( 4) ;
-   //   vCrvEdge[0].Set(pSurfBz->GetCurveOnU( 0)) ;
-   //   vCrvEdge[1].Set(pSurfBz->GetCurveOnV( 1)) ;
-   //   vCrvEdge[2].Set(pSurfBz->GetCurveOnU( 1)) ;
-   //   vCrvEdge[3].Set(pSurfBz->GetCurveOnV( 0)) ;
-   //   double dAngTolDeg = 5 ;
-   //   for ( int i = 0 ; i < 4 ; ++i) {
-   //      PolyLine plApprox ; vCrvEdge[0]->ApproxWithLines( EPS_SMALL, dAngTolDeg, ICurve::ApprLineType::APL_STD, plApprox) ;
-   //      //CurveComposite cCC ;
-   //      //cCC.FromPolyLine( plApprox) ;
-   //      int nClosestLine = -1 ;
-   //      double dMinDist = INFINITO ;
-   //      Point3d pt ;  plApprox.GetFirstPoint( pt) ;
-   //      Point3d ptClosest ;
-   //      int c = 0 ;
-   //      int nTot = plApprox.GetPointNbr() ;
-   //      for ( int j = 0 ; j < nTot ; ++j) {
-   //         DistPointLine dpl( pt, ptL, vtL, dLen, bFinite) ;
-   //         double dDist = INFINITO ;
-   //         dpl.GetDist( dDist) ;
-   //         if ( dDist < dMinDist) {
-   //            nClosestLine = c ;
-   //            dMinDist = dDist ;
-   //         }
-   //         plApprox.GetNextPoint( pt) ;
-   //         ++ c ;
-   //      }
-
-   //      Point3d ptInt1, ptInt2 ;
-   //      if ( nClosestLine < nTot - 1  && nClosestLine > 0) {
-   //         // tra i due tratti dell'approssimazione che arrivano al punto selezionato come più vicino, devo trovare quale si avvicina di più
-   //         Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ;
-   //         Point3d ptEnd ;
-   //         for ( int z = 1 ; z < nClosestLine - 1 ; ++z)
-   //            plApprox.GetNextPoint( ptStart) ;
-   //         plApprox.GetNextPoint( ptEnd) ;
-   //         // linea precedente al punto
-   //         Vector3d vtLinePre = ptEnd - ptStart ;
-   //         double dLenPre = vtLinePre.Len() ;
-   //         DistLineLine dllPre( ptStart, vtLinePre, dLenPre, ptL, vtL,dLen) ;
-   //         double dDistPre = INFINITO ;
-   //         dllPre.GetDist( dDistPre) ;
-   //         // linea che inzia con quel punto
-   //         ptStart = ptEnd ;
-   //         plApprox.GetNextPoint( ptEnd) ;
-   //         Vector3d vtLineCurr = ptEnd - ptStart ;
-   //         double dLenCurr = vtLineCurr.Len() ;
-   //         DistLineLine dllCurr( ptStart, vtLineCurr, dLenCurr, ptL, vtL,dLen) ;
-   //         double dDistCurr = INFINITO ;
-   //         dllCurr.GetDist( dDistCurr) ;
-
-   //         if ( dDistPre < dDistCurr)
-   //            dllPre.GetMinDistPoints( ptInt1, ptInt2) ;
-   //         else
-   //            dllCurr.GetMinDistPoints( ptInt1, ptInt2) ;
-   //      }
-   //      else if ( nClosestLine == 0) {
-   //         // il punto più vicino è sulla prima linea
-   //         Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ;
-   //         Point3d ptEnd ; plApprox.GetNextPoint( ptEnd) ;
-   //         Vector3d vtLineCurr = ptEnd - ptStart ;
-   //         double dLenCurr = vtLineCurr.Len() ;
-   //         DistLineLine dllCurr( ptStart, vtLineCurr, dLenCurr, ptL, vtL,dLen) ;
-   //         dllCurr.GetMinDistPoints( ptInt1, ptInt2) ;
-   //      }
-   //      else if ( nClosestLine == nTot- 1) {
-   //         // il punto più vicino è sull'ultima linea
-   //         Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ;
-   //         Point3d ptEnd ;
-   //         for ( int z = 1 ; z < nClosestLine - 1 ; ++z)
-   //            plApprox.GetNextPoint( ptStart) ;
-   //         plApprox.GetNextPoint( ptEnd) ;
-   //         Vector3d vtLinePre = ptEnd - ptStart ;
-   //         double dLenPre = vtLinePre.Len() ;
-   //         DistLineLine dllCurr( ptStart, vtLinePre, dLenPre, ptL, vtL,dLen) ;
-   //         dllCurr.GetMinDistPoints( ptInt1, ptInt2) ;
-   //      }
-   //      
-   //      double dU1 = 0, dV1 = 0, dU2 = 0, dV2 = 0 ;
-   //      // se ho trovato due punti vuol dire che la linea coincide con un edge e ho trovato tutto quello che serve
-   //      if ( ! AreSamePointExact( ptInt2, ORIG)) {
-   //         if ( i == 0) {
-   //            //dV1 = 0 ; dV2 = 0 ;
-   //            vCrvEdge[0]->GetParamAtPoint( ptInt1, dU1) ;
-   //            vCrvEdge[0]->GetParamAtPoint( ptInt2, dU2) ;
-   //         }
-   //         else if ( i == 1) {
-   //            //dU1 = 1 ; dU2 = 1 ;
-   //            vCrvEdge[1]->GetParamAtPoint( ptInt1, dV1) ;
-   //            vCrvEdge[1]->GetParamAtPoint( ptInt2, dV2) ;
-   //         }
-   //         else if ( i == 2){
-   //            //dV1 = 1 ; dV2 = 1 ;
-   //            vCrvEdge[2]->GetParamAtPoint( ptInt1, dU1) ;
-   //            vCrvEdge[2]->GetParamAtPoint( ptInt2, dU2) ;
-   //         }
-   //         else if ( i == 3){
-   //            //dU1 = 0 ; dU2 = 0 ;
-   //            vCrvEdge[3]->GetParamAtPoint( ptInt1, dV1) ;
-   //            vCrvEdge[3]->GetParamAtPoint( ptInt2, dV2) ;
-   //         }
-   //         Point3d ptIBez1, ptIBez2 ;
-   //         Vector3d vtN1, vtN2 ;
-   //         pSurfBz->GetPointNrmD1D2(dU1, dV1, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez1, vtN1) ;
-   //         pSurfBz->GetPointNrmD1D2(dU2, dV2, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez2, vtN2) ;
-   //         Point3d ptSP1( dU1, dV1, 0) ;
-   //         double dCos1 = vtN1 * vtL ;
-   //         Point3d ptSP2( dU2, dV2, 0) ;
-   //         double dCos2 = vtN2 * vtL ;
-   //         // se avevo già trovato un punto singolo che coincide col primo punto di questa intersezione sovrapposta, allora cancello l'intersezione singola che
-   //         // avevo salvato e aggiungo quella sovrapposto che ho trovato ora
-   //         if ( bFound) {
-   //            int nNewTot = int(vInfo.size()) ;
-   //            int nNewInters = nNewTot - nInters ;
-   //            bool bAlreadyFound = false ;
-   //            for ( int i = 0 ; i < nNewInters ; ++i) {
-   //               bAlreadyFound = AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP1) ||  AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP2) ;
-   //               if ( bAlreadyFound) {
-   //                  vInfo.erase( vInfo.begin() + nNewTot - i) ;
-   //                  break ;
-   //               }
-   //            }
-   //         }
-   //         UpdateInfoIntersLineSurfBz( ptL, vtL, ILTA_NO_TRIA, -1, ptSP1, ptIBez1, dCos1, ptSP2, ptIBez2, dCos2, vInfo) ;
-   //         bFound = true ;
-   //         break ;
-   //      }
-   //      // se ho trovato un punto a distanza zero dalla linea allora ho trovato l'intersezione
-   //      else if ( dMinDist < EPS_SMALL) {
-   //         if ( i == 0) {
-   //            //dV1 = 0 ;
-   //            vCrvEdge[0]->GetParamAtPoint( ptInt1, dU1) ;
-   //         }
-   //         else if ( i == 1) {
-   //            //dU1 = 1 ;
-   //            vCrvEdge[1]->GetParamAtPoint( ptInt1, dV1) ;
-   //         }
-   //         else if ( i == 2) {
-   //            //dV1 = 1 ;
-   //            vCrvEdge[2]->GetParamAtPoint( ptInt1, dU1) ;
-   //         }
-   //         else if ( i == 3) {
-   //            //dU1 = 0 ;
-   //            vCrvEdge[3]->GetParamAtPoint( ptInt1, dV1) ;
-   //         }
-   //         Point3d ptSP1( dU1, dV1, 0), ptSP2 ;
-   //         // se avevo trovato già altri punti controllo di non essere esattamente su una diagonale ( e quindi avere un'intersezione con ogni edge, ma due sono doppie)
-   //         if ( bFound) {
-   //            int nNewTot = int(vInfo.size()) ;
-   //            int nNewInters = nNewTot - nInters ;
-   //            bool bAlreadyFound = false ;
-   //            for ( int i = 0 ; i < nNewInters ; ++i)
-   //               bAlreadyFound = AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP1) ;
-   //            if ( bAlreadyFound)
-   //               continue ;
-   //         }
-
-   //         Point3d ptIBez1, ptIBez2 ;
-   //         Vector3d vtN1, vtN2 ;
-   //         pSurfBz->GetPointNrmD1D2(dU1, dV1, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez1, vtN1) ;
-   //         double dCos1 = vtN1 * vtL, dCos2 = 0 ;
-   //         UpdateInfoIntersLineSurfBz( ptL, vtL, ILTA_NO_TRIA, -1, ptSP1, ptIBez1, dCos1, ptSP2, ptIBez2, dCos2, vInfo) ;
-   //         bFound = true ;
-   //      }
-   //   }
-   //}
-
-   // se la superficie è trimmed verifico che i punti trovati siano all'interno del parametrico trimmato
-   if ( bTrimmed  &&  bFound) {
-      int nNewTot = int(vInfo.size()) ;
-      int nNewInters = nNewTot - nInters ;
-      const ISurfFlatRegion* pFRTrim = pSurfBz->GetTrimRegion() ;
-      for ( int i = 0 ; i < nNewInters ; ++i) {
-         Point3d ptTest = vInfo[nNewTot - i].ptUV * SBZ_TREG_COEFF ;
-         bool bInside = false ;
-         double dDist = INFINITO ;
-         IsPointInsideSurfFr( ptTest, pFRTrim, dDist, bInside) ;
-         if ( ! bInside)
-            vInfo.erase( vInfo.begin() + nNewTot - i) ;
-      }
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-//  Intersezione di una linea con una superficie di Bezier bilineare monopatch
+//  Intersezione di una linea con una superficie di Bezier
 //----------------------------------------------------------------------------
 bool
 IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfBezier* pSurfBz,

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*
-GetSurfBezierRuledSmooth( const ICurve* pCurve1, const ICurve* pCurve2, double dSampleLen)
+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,43 +763,7 @@ GetSurfBezierRuledSmooth( const ICurve* pCurve1, const ICurve* pCurve2, double d
 
    // creo e setto la superficie trimesh
    PtrOwner<SurfBezier> pSbz( CreateBasicSurfBezier()) ;
-   if ( IsNull( pSbz)  ||  ! pSbz->CreateSmoothRuledByTwoCurves( pCC1, pCC2, dSampleLen))
-      return nullptr ;
-
-   // restituisco la superficie
-   return Release( pSbz) ;
-}
-
-//-------------------------------------------------------------------------------
-ISurfBezier*
-GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const BIPNTVECTOR& vCrv, double dLinTol)
-{
-   // verifica parametri
-   if ( pCurve1 == nullptr  ||  pCurve2 == nullptr)
-      return nullptr ;
-
-   // dLinTol servirà quando ci sarà la funzione ApproxWithCurveBezier
-   // se la curva è già una bezier singola la tengo, sennò la converto
-   PtrOwner<ICurveComposite> pCC1( CreateCurveComposite()) ;
-   if ( pCurve1->GetType() != CRV_BEZIER)
-      pCC1->AddCurve( CurveToBezierCurve( pCurve1, 3, false)) ;
-   else
-      pCC1->AddCurve( pCurve1->Clone()) ;
-   if ( IsNull( pCC1)  ||  ! pCC1->IsValid())
-      return nullptr ;
-
-   // se la curva è già una bezier singola la tengo, sennò la converto
-   PtrOwner<ICurveComposite> pCC2( CreateCurveComposite()) ;
-   if ( pCurve2->GetType() != CRV_BEZIER)
-      pCC2->AddCurve( CurveToBezierCurve( pCurve2, 3, false)) ;
-   else
-      pCC2->AddCurve( pCurve2->Clone()) ;
-   if ( IsNull( pCC2)  ||  ! pCC2->IsValid())
-      return nullptr ;
-
-   // creo e setto la superficie trimesh
-   PtrOwner<SurfBezier> pSbz( CreateBasicSurfBezier()) ;
-   if ( IsNull( pSbz)  ||  ! pSbz->CreateByIsoParamSet( pCC1, pCC2, vCrv))
+   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,14 +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
-   std::vector<IGeoObj*> vGeo ;
-   #include "/EgtDev/Include/EGkGeoObjSave.h"
-#endif
 
 using namespace std ;
 
@@ -538,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,
@@ -566,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
@@ -605,268 +581,76 @@ 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
-   vGeo.clear() ;
-   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 ; 
-         for ( int p = 0 ; p < ssize(vU) - 1 ; ++p) {
+         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
-                  vGeo.clear() ;
-                  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( *vLoop[l], *pTrimMask) ;
-               int nInters = icc.GetIntersCount() ;
-               ICCIVECTOR vICCI ;
-               for ( int i = 0 ; i < nInters ; ++i) {
-                  IntCrvCrvInfo icci ; icc.GetIntCrvCrvInfo( i, icci) ;
-                  vICCI.push_back( std::move( icci)) ;
-               }
-               CRVCVECTOR vCrvClass, vMaskClass ;
-               icc.GetCurveClassification( 0, EPS_SMALL, vCrvClass) ;
-               icc.GetCurveClassification( 1, EPS_SMALL, vMaskClass) ;
-               // se dei pezzi di trim risultano esterni allo spazio parametrico tengo il bordo della maschera di trim
-               double dLastParam1 = 0 ;
-               double dStartA = 0, dEndA = 0 ; vLoop[l]->GetDomain( dStartA, dEndA) ;
-               double dEndB = 4 ;
-               for ( int i = 0 ; i < ssize( vCrvClass); ++i) {
-                  if ( vCrvClass[i].nClass == CRVC_IN  ||  vCrvClass[i].nClass == CRVC_ON_P) {
-                     vCrvStrip.emplace_back( ConvertCurveToComposite( vLoop[l]->CopyParamRange( vCrvClass[i].dParS, vCrvClass[i].dParE))) ;
-         
-                     for ( int j = 0 ; j < ssize( vICCI) ; ++j) {
-                        int k = vICCI[j].bOverlap ? 1 : 0 ;
-                        if ( abs( vICCI[j].IciA[k].dU - vCrvClass[i].dParE) < EPS_PARAM) {
-                           dLastParam1 = vICCI[j].IciB[k].dU ;
-                           break ;
-                        }
-                     }
-                  }
-                  else if ( vCrvClass[i].nClass == CRVC_OUT  &&  ( p == 0  ||  p == ssize(vU) - 2)){
-                     double dMin, dMax ;
-                     if ( p == 0) {
-                        dMin = nDir == 0 ? 3 : 0 ;
-                        dMax = nDir == 0 ? 4 : 1 ;
-                     }
-                     else {
-                        dMin = nDir == 0 ? 1 : 2 ;
-                        dMax = nDir == 0 ? 2 : 3 ;
-                     }
-                     // aggiungo la parte di curva di edge al posto della parte di curva che esce dal parametrico
-                     // se non ho ancora aggiunto un tratto parto dal primo punto di intersezione
-                     if ( ssize( vCrvStrip) == 0) {
-                        double dPar0 = vCrvClass[i].dParS ;
-                        for ( int j = 0 ; j < ssize( vICCI) ; ++j) {
-                           int k = vICCI[j].bOverlap ? 1 : 0 ;
-                           if ( abs(vICCI[j].IciA[k].dU - dPar0) < EPS_PARAM  ||
-                               ( abs( dEndA - vICCI[j].IciA[k].dU - dPar0) < EPS_PARAM)) {
-                              if ( abs( dEndB - vICCI[j].IciB[k].dU) < EPS_PARAM)
-                                 dLastParam1 = 0 ;
-                              else
-                                 dLastParam1 = vICCI[j].IciB[k].dU ;
-                              break ;
-                           }
-                        }
-                     }
-                     int c = 0 ;
-                     while ( c < ssize( vMaskClass) - 1 &&  abs( vMaskClass[c].dParS - dLastParam1) > EPS_PARAM)
-                        ++c ;
-
-                     if ( vMaskClass[c].nClass == CRVC_IN  &&  vMaskClass[c].dParS < dMax  &&  vMaskClass[c].dParS >= dMin) {
-                        vCrvStrip.emplace_back( ConvertCurveToComposite( pTrimMask->CopyParamRange( vMaskClass[c].dParS, vMaskClass[c].dParE))) ;
-                        dLastParam1 = vMaskClass[c].dParE ;
-                        // se sono alla fine curva verifico se devo aggiungere anche un pezzo di inizio
-                        if ( dLastParam1 == dEndB  &&  vMaskClass[0].nClass == CRVC_IN) {
-                           c = 0 ;
-                           vCrvStrip.emplace_back( ConvertCurveToComposite( pTrimMask->CopyParamRange( vMaskClass[c].dParS, vMaskClass[c].dParE))) ;
-                           dLastParam1 = vMaskClass[c].dParE ;
-                        }
-                     }
-                  }
-               }
-            }
-
-            #if SAVEMKUNIF_CRVS
-               //debug
-               vGeo.clear() ;
-               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
+                  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
+
+               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)
+                  pt.Scale( GLOB_FRM, SBZ_TREG_COEFF / dLenStrip, 1, 1) ;
+               else
+                  pt.Scale( GLOB_FRM, 1, SBZ_TREG_COEFF / dLenStrip, 1) ;
+
+               Vector3d vtJoin ;
+               if ( nDir == 0)
+                  vtJoin.Set( p * SBZ_TREG_COEFF - pt.x, 0, 0) ;
+               else
+                  vtJoin.Set( 0, p  * SBZ_TREG_COEFF - pt.y, 0) ;
+               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 ;
                }
-
-               // prima di riunire le curve al resto devo traslarle sul bordo destro della superificie che sto ricostruendo (nDir == 0)
-               // oppure sul bordo superiore ( nDir == 1)
-               Point3d pt ;
-               Vector3d vtJoin ;
-               if ( nDir == 0) {
-                  pt.Set( abs( vU[p] - vU.front()), 0, 0) ;
-                  pt.Scale( GLOB_FRM, SBZ_TREG_COEFF / dLenStrip, 1, 1) ;
-                  vtJoin.Set( p * SBZ_TREG_COEFF - pt.x, 0, 0) ;
-               }
-               else {
-                  pt.Set( 0, abs(vU[p] - vU.front()), 0) ;
-                  pt.Scale( GLOB_FRM, 1, SBZ_TREG_COEFF / dLenStrip, 1) ;
-                  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
-               vGeo.clear() ;
-               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
-                     vGeo.clear() ;
-                     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)) {
-                     // se ho una solo curva piccola allora la salto
-                     if ( ssize(vIds) == 1) {
-                           double dLen = 0 ; 
-                           int nId = vIds[0] - 1 ;
-                           bool bSkip = false ;
-                           if ( nId < nCrvPrec)
-                              bSkip = vUniformedCurves[nId]->GetLength( dLen) &&  dLen < dChainTol ;
-                           else
-                              bSkip = vCrvStrip[nId - ssize(vUniformedCurves)]->GetLength(dLen) && dLen < dChainTol ;
-                           
-                           if ( bSkip)
-                              continue ;
-                     }
-
-                     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) ;
-                     }
-                  }
-                  #if SAVEMKUNIF_CRVS
-                     //debug
-                     vGeo.clear() ;
-                     for( int i = 0 ; i < ssize( vNewCrv); ++i){
-                        vGeo.push_back(vNewCrv[i]->Clone()) ;
-                     }
-                     SaveGeoObj( vGeo, "D:\\Temp\\bezier\\import3dm\\trim_error\\trim_crv_unif_AFTERchain.nge") ;
-                     //debug
-                  #endif
-
-                  // aggiorno le curve 
-                  vUniformedCurves.clear() ;
-                  vUniformedCurves.swap( vNewCrv)  ;
-               }
+               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
@@ -874,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()  &&  ! vUniformedCurves[i]->Close())
-            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,18 +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 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 LimitSurfToTrimmedRegion( void) override ;
-      bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen) override ;
+      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,13 +28,6 @@
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
-#define SAVECLASSCRV 0
-#define SAVEADJUSTCRV 0
-#if SAVECLASSCRV || SAVEADJUSTCRV
-std::vector<IGeoObj*> vGeo ;
-#include "/EgtDev/Include/EGkGeoObjSave.h"
-#endif
-
 using namespace std ;
 
 //----------------------------------------------------------------------------
@@ -114,20 +107,8 @@ SurfFlatRegion::AddExtLoop( ICurve* pCrv)
    pMyCrv->SetThickness( 0) ;
   // rimuovo eventuali sovrapposizioni (calcolate nel suo piano)
    ICURVEPLIST CrvLst ;
-
-#if SAVEADJUSTCRV
-   SaveGeoObj( pMyCrv->Clone(), "D:\\Temp\\inters\\CrvCrvInters\\before_adjust.nge") ;
-#endif
-
    if ( ! AdjustLoops( Release( pMyCrv), CrvLst, true))
       return false ;
-
-#if SAVEADJUSTCRV
-   for ( auto& pSingCrv : CrvLst)
-      vGeo.push_back( pSingCrv->Clone()) ;
-   SaveGeoObj( vGeo, "D:\\Temp\\inters\\CrvCrvInters\\after_adjust.nge") ;
-#endif
-
   // aggiungo le singole curve
    int nExtAdded = 0 ;
    bool bOk = true ;
@@ -188,18 +169,14 @@ SurfFlatRegion::AddSimpleExtLoop( ICurve* pCrv, bool& bAdded)
    Vector3d vtExtr ;
    if ( pMyCrv->GetExtrusion( vtExtr)  &&  ! vtExtr.IsSmall())
       pMyCrv->SetExtrusion( Z_AX) ;
-
+  // verifico non abbia auto-intersezioni che si attraversano o si sovrappongano
+   SelfIntersCurve sInt( *pMyCrv) ;
+   if ( sInt.GetCrossOrOverlapIntersCount() > 0)
+      return false ;
   // verifico che sia esterna alle curve esterne degli altri chunk
    bool bOk = true ;
    CRVCVECTOR ccClass ;
    for ( auto i : m_vExtInd) {
-#if SAVEADJUSTCRV
-         vGeo.clear() ;
-         vGeo.push_back( pMyCrv->Clone()) ;
-         vGeo.push_back( m_vpLoop[i]->Clone()) ;
-         SaveGeoObj( vGeo, "D:\\Temp\\inters\\CrvCrvInters\\during_add_simpleExt.nge") ;
-#endif
-
       IntersCurveCurve ccInt( *pMyCrv, *m_vpLoop[i]) ;
       if ( ccInt.GetCrossOrOverlapIntersCount() > 0  ||
            ! ccInt.GetCurveClassification( 0, EPS_SMALL, ccClass)  ||
@@ -239,9 +216,14 @@ SurfFlatRegion::AddSimpleExtLoop( ICurve* pCrv, bool& bAdded)
 bool
 SurfFlatRegion::MyAddExtLoop( ICurve* pCrv)
 {
-   m_vpLoop.push_back( pCrv) ;
-   m_vExtInd.push_back( int( m_vpLoop.size()) - 1) ;
-   m_nStatus = OK ;
+   try {
+      m_vpLoop.push_back( pCrv) ;
+      m_vExtInd.push_back( int( m_vpLoop.size()) - 1) ;
+      m_nStatus = OK ;
+   }
+   catch (...) {
+      return false ;
+   }
 
    return true ;
 }
@@ -322,7 +304,10 @@ SurfFlatRegion::AddSimpleIntLoop( ICurve* pCrv)
   // sistemo il senso di rotazione (deve essere CW -> se N==Z+ area < 0, se N==Z- area > 0)
    if ( ( plPlane.GetVersN().z > 0  &&  dArea > 0)  ||  ( plPlane.GetVersN().z < 0  &&  dArea < 0))
       pMyCrv->Invert() ;
-
+  // verifico non abbia auto-intersezioni
+   SelfIntersCurve sInt( *pMyCrv) ;
+   if ( sInt.GetCrossOrOverlapIntersCount() > 0)
+      return false ;
   // ricerca del chunk in cui andrebbe inserito
    int nChunk = -1 ;
    for ( int i = 0 ; i < int( m_vExtInd.size()) ; ++ i) {
@@ -369,18 +354,23 @@ SurfFlatRegion::AddSimpleIntLoop( ICurve* pCrv)
 bool
 SurfFlatRegion::MyAddIntLoop( ICurve* pCrv, int nChunk)
 {
-   //se da aggiungere all'ultimo chunk
-   if ( nChunk == -1)
-      m_vpLoop.push_back( pCrv) ;
-   //altrimenti aggiungo al chunck indicato
-   else {
-      int nLoopCnt = GetLoopCount( nChunk) ;
-      if ( nLoopCnt == 0)
-         return false ;
-      int nOffset = m_vExtInd[nChunk] + nLoopCnt ;
-      m_vpLoop.insert( m_vpLoop.begin() + nOffset, pCrv) ;
-      for ( int i = nChunk + 1 ; i < int( m_vExtInd.size()) ; ++ i)
-         ++ m_vExtInd[i] ;
+   try {
+     // se da aggiungere all'ultimo chunk
+      if ( nChunk == -1)
+         m_vpLoop.push_back( pCrv) ;
+     // altrimenti aggiungo al chunck indicato
+      else {
+         int nLoopCnt = GetLoopCount( nChunk) ;
+         if ( nLoopCnt == 0)
+            return false ;
+         int nOffset = m_vExtInd[nChunk] + nLoopCnt ;
+         m_vpLoop.insert( m_vpLoop.begin() + nOffset, pCrv) ;
+         for ( int i = nChunk + 1 ; i < int( m_vExtInd.size()) ; ++ i)
+            ++ m_vExtInd[i] ;
+      }
+   }
+   catch (...) {
+      return false ;
    }
 
    return true ;
@@ -1384,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 ;
@@ -1556,7 +1537,7 @@ SurfFlatRegion::GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion&
   // classifico il loop esterno del chunk della prima regione rispetto a quello del chunk della seconda
    IntersCurveCurve ccInt( *pCrv1Loc, *pCrv2Loc) ;
    int nClass = ccInt.GetRegionCurveClassification() ;
-   switch ( nClass) {
+   switch ( nClass){
    default :   // CCREGC_NULL
       return REGC_NULL ;
    case CCREGC_IN1 :
@@ -1569,141 +1550,7 @@ SurfFlatRegion::GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion&
       return REGC_OUT ;
    case CCREGC_INTERS :
       return REGC_INTERS ;
-   }
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfFlatRegion::CheckChunkInterference( int nChunk, const ISurfFlatRegion& Other, int nOthChunk, bool& bInterference) const
-{
-   bInterference = false ;
-  // verifico lo stato e il numero di chunk
-   if ( m_nStatus != OK  ||  m_vpLoop.empty()  ||  nChunk >= GetChunkCount())
-      return false ;
-  // recupero rappresentazione base dell'altra regione
-   const SurfFlatRegion& Reg2 = *GetBasicSurfFlatRegion( &Other) ;
-  // verifico lo stato e il numero di chunk dell'altra regione
-   if ( Reg2.m_nStatus != OK  ||  Reg2.m_vpLoop.empty()  ||  nOthChunk >= Reg2.GetChunkCount())
-      return false ;
-
-  // verifico che le due regioni giacciano in piani paralleli
-   if ( ! AreSameVectorApprox( m_frF.VersZ(), Reg2.m_frF.VersZ()))
-      return false ;
-
-  // classifico il loop esterno del chunk della prima regione rispetto a quello del chunk della seconda
-   int nClass = GetChunkSimpleClassification( nChunk, Other, nOthChunk) ;
-   if ( nClass == REGC_NULL)
-      return false ;
-  // se le regioni non hanno isole, allora ho già identificato se i Chunks fanno interferenza
-   int nLoopCnt = GetLoopCount( nChunk) ;
-   int nOtherLoopCnt = Other.GetLoopCount( nOthChunk) ;
-   if ( nLoopCnt == 1  &&  nOtherLoopCnt == 1) {
-      bInterference = ( nClass != REGC_OUT) ;
-      return true ;
-   }
-
-  // --- a prescindere dalle isole presenti nei 2 Chunks in esame :
-  // se i due loop esterni si intersecano tra loro o sono gli stessi, allora fanno per forza interferenza
-   if ( nClass == REGC_INTERS  ||  nClass == CCREGC_SAME) {
-      bInterference = true ;
-      return true ;
-   }
-  // se invece sono esterni tra loro, allora non c'è interferenza
-   else if ( nClass == REGC_OUT)
-      return true ;
-  // --- Analisi del loop interni :
-  // se la curva esterna corrente è interna alla curva esterna dell'altro chunk
-   else if ( nClass == REGC_IN1) {
-     // se l'altro chunk non ha isole, c'è interferenza (a prescinere da numero di loop interni del primo chunk)
-      if ( nOtherLoopCnt == 1) {
-         bInterference = true ;
-         return true ;
-      }
-     // curva esterna del chunk della prima regione (ovviamente già in locale al riferimento intrinseco)
-      const ICurve* pCrv1Loc = GetMyLoop( nChunk, 0) ;
-     // per ogni loop interno (isole)
-      for ( int i = 1 ; i < nOtherLoopCnt ; ++ i) {
-         const ICurve* pCrv2Loc = nullptr ;
-         PtrOwner<ICurve> pCopyCrv ;
-         if ( AreSameFrame( m_frF, Reg2.m_frF))
-            pCrv2Loc = Reg2.GetMyLoop( nOthChunk, i) ;
-         else {
-            pCopyCrv.Set( Reg2.GetMyLoop( nOthChunk, i)->Clone()) ;
-            if ( IsNull( pCopyCrv))
-               return false ;
-            pCopyCrv->LocToLoc( Reg2.m_frF, m_frF) ;
-            pCrv2Loc = pCopyCrv ;
-         }
-        // classifico il loop esterno del chunk della prima regione rispetto all'interno corrente del chunk della seconda
-         IntersCurveCurve ccInt( *pCrv1Loc, *pCrv2Loc) ;
-         int nInternalClass = ccInt.GetRegionCurveClassification() ;
-        // se le curve non sono classificabili, errore
-         if ( nInternalClass == REGC_NULL)
-            return false ;
-        // se la curva di bordo corrente è interna (le isole girano al contrario) all'isola corrente
-         else if ( nInternalClass == REGC_IN1)
-            ; // non faccio nulla, potrebbe non essere l'isola adatta per la classificazione
-        // se la curva di bordo corrente è esterna (le isole girano al contrario) all'isola corrente, allora non ho interferenza
-         else if ( nInternalClass == REGC_OUT)
-            return true ;
-        // se la curva di bordo corrente interseca l'isola o coincide con essa allora c'è interferenza
-         else if ( nInternalClass == REGC_INTERS  ||  nInternalClass == REGC_SAME) {
-            bInterference = true ;
-            return true ;
-         }
-        // negli altri casi ho un orientamento errato dei loop o delle regioni
-         else
-            return false ;
-      }
-   }
-  // se la curva esterna dell'altro chunk è interna alla curva esterna corrente
-   else if ( nClass == REGC_IN2) {
-     // se l'altro chunk non ha isole, c'è interferenza
-      if ( nLoopCnt == 1) {
-         bInterference = true ;
-         return true ;
-      }
-     // curva esterna del chunk della prima regione (ovviamente già in locale al riferimento intrinseco)
-      const ICurve* pCrv2Loc = Reg2.GetMyLoop( nChunk, 0) ;
-     // per ogni loop interno (isole)
-      for ( int i = 1 ; i < nLoopCnt ; ++ i) {
-         const ICurve* pCrv1Loc = nullptr ;
-         PtrOwner<ICurve> pCopyCrv ;
-         if ( AreSameFrame( Reg2.m_frF, m_frF))
-            pCrv1Loc = GetMyLoop( nOthChunk, i) ;
-         else {
-            pCopyCrv.Set( GetMyLoop( nOthChunk, i)->Clone()) ;
-            if ( IsNull( pCopyCrv))
-               return false ;
-            pCopyCrv->LocToLoc( m_frF, Reg2.m_frF) ;
-            pCrv1Loc = pCopyCrv ;
-         }
-        // classifico il loop esterno del chunk della prima regione rispetto a quello del chunk della seconda
-         IntersCurveCurve ccInt( *pCrv2Loc, *pCrv1Loc) ;
-         int nInternalClass = ccInt.GetRegionCurveClassification() ;
-        // se le curve non sono classificabili, errore
-         if ( nInternalClass == REGC_NULL)
-            return false ;
-        // se la curva di bordo corrente è interna (le isole girano al contrario) all'isola corrente
-         else if ( nInternalClass == REGC_IN1)
-            ; // non faccio nulla, potrebbe non essere l'isola adatta per la classificazione
-        // se la curva di bordo corrente è esterna (le isole girano al contrario) all'isola corrente, allora non ho interferenza
-         else if ( nInternalClass == REGC_OUT)
-            return true ;
-        // se la curva di bordo corrente interseca l'isola o coincide con essa allora c'è interferenza
-         else if ( nInternalClass == REGC_INTERS  ||  nInternalClass == REGC_SAME) {
-            bInterference = true ;
-            return true ;
-         }
-        // negli altri casi ho un orientamento errato dei loop o delle regioni
-         else
-            return false ;
-      }
-   }
-
-  // in questo la curva di bordo è interna ad ogni isola ma interna anche al loop esterno, quindi esiste interferenza
-   bInterference = true ;
-   return true ;
+    }
 }
 
 //----------------------------------------------------------------------------

SurfFlatRegion.h

@@ -107,7 +107,6 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
       bool GetChunkArea( int nChunk, double& dArea) const override ;
       bool GetChunkPerimeter( int nChunk, double& dLen) const override ;
       int  GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion& Other, int nOthChunk) const override ;   // compare only outsides
-      bool CheckChunkInterference( int nChunk, const ISurfFlatRegion& Other, int nOthChunk, bool& bInterference) const override ;         // compare alls
       bool GetChunkMaxOffset( int nChunk, double& dOffs) const override ;
       int  GetLoopCount( int nChunk) const override ;
       int  GetLoopCurveCount( int nChunk, int nLoop) const override ;
@@ -140,7 +139,6 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
       SurfTriMesh* CalcAuxSurf( double dLinTol, double dAngTolDeg) const ;
 
    friend class MyCAvSimpleSurfFrMove ;
-   friend class MyCAvSurfFrMove ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;

SurfFlatRegionBooleans.cpp

@@ -20,12 +20,6 @@
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
-#define SAVELOOPS 0
-#if SAVELOOPS
-std::vector<IGeoObj*> vGeo ;
-#include "/EgtDev/Include/EGkGeoObjSave.h"
-#endif
-
 using namespace std ;
 
 //----------------------------------------------------------------------------
@@ -178,13 +172,6 @@ SurfFlatRegion::Subtract( const ISurfFlatRegion& Other)
       pSfr.Set( new( nothrow) SurfFlatRegion) ;
    else
       pSfr.Set( MyNewSurfFromLoops( vpLoop)) ;
-
-#if SAVELOOPS
-   for (int i = 0 ; i < ssize( vpLoop) ; ++i)
-      vGeo.push_back( vpLoop[i]) ;
-   SaveGeoObj( vGeo, "D:\\Temp\\inters\\CrvCrvInters\\NewLoops.nge") ;
-#endif
-
    if ( IsNull( pSfr)) {
       MyTestAndDelete( vpCurve) ;
       MyTestAndDelete( vpLoop) ;

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) ;
@@ -352,6 +350,10 @@ Tree::SetSurf( const SurfBezier* pSrfBz, const Point3d& ptMin, const Point3d& pt
             }
            // se ho fatto solo 1 split orizzontale e ho due celle foglie nId = 0 e nId = 1
             if ( m_mTree.size() == 3  &&  ! m_mTree.at(-1).IsSplitVert()) {
+               m_mTree[0].m_nLeft = -1 ;
+               m_mTree[0].m_nRight = -1 ;
+               m_mTree[1].m_nLeft = -1 ;
+               m_mTree[1].m_nRight = -1 ;
                m_mTree[0].SetSplitDirVert( true) ;
                Split( 0) ;
                m_mTree[1].SetSplitDirVert( true) ;
@@ -459,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) ;
@@ -472,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) ;
@@ -490,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 ;
    }
    
@@ -662,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) ;
@@ -734,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
@@ -811,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 ;
@@ -854,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")
             }
@@ -1538,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
@@ -2063,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 ;
@@ -2092,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 ;
          }
@@ -2221,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 ;
@@ -2261,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 ;
                }
@@ -2272,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 ;
@@ -4108,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

@@ -29,21 +29,8 @@
 #include <thread>
 #include <future>
 
-#define DEBUG_REMOVE_FINS 0
-#if DEBUG_REMOVE_FINS
-   #include "/EgtDev/Include/EGkGeoObjSave.h"
-   #include "/EgtDev/Include/EGkGeoPoint3d.h"
-   #include "/EgtDev/Include/EGkGeoVector3d.h"
-   std::vector<IGeoObj*> VT ;
-   std::vector<Color> VC ;
-#endif
-
 using namespace std ;
 
-#if !defined(_WIN64)
-   int VolZmap::m_nDexelNbr = 0 ;
-#endif
-
 //----------------------------------------------------------------------------
 GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;
 
@@ -68,13 +55,6 @@ VolZmap::VolZmap(void)
 //----------------------------------------------------------------------------
 VolZmap::~VolZmap( void)
 {
-  // Se versione 32-bit aggiorno il numero di Dexel complessivi rimuovendo il numero dei correnti
-   #if !defined(_WIN64)
-      int nDexelNbr = 0 ;
-      for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
-         nDexelNbr += m_nDim[i] ;
-      m_nDexelNbr = max( 0, m_nDexelNbr - nDexelNbr) ;
-   #endif
 }
 
 //----------------------------------------------------------------------------
@@ -95,13 +75,6 @@ VolZmap::Clear( void)
    m_nNumBlock = 0 ;
    m_nConnectedCompoCount = 0 ;
    m_MapFrame.Reset() ;
-  // Se versione 32-bit aggiorno il numero di Dexel complessivi rimuovendo il numero dei correnti
-   #if !defined(_WIN64)
-      int nDexelNbr = 0 ;
-      for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
-         nDexelNbr += m_nDim[i] ;
-      m_nDexelNbr = max( 0, m_nDexelNbr - nDexelNbr) ;
-   #endif
    for ( int i = 0 ; i < N_MAPS ; ++ i) {
       m_nNx[i] = 0 ;
       m_nNy[i] = 0 ;
@@ -1721,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 ;
 
@@ -1745,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 ;
@@ -1753,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
@@ -1765,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) ;
                }
             }
          }
@@ -1822,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 ;
@@ -1839,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)
@@ -1853,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 ;
@@ -1861,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) ;
             }
          }
@@ -1891,187 +1868,6 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-VolZmap::RemoveFins( const Vector3d& vtDir, double dThick)
-{
-  // Verifico la Validità dello ZMap
-   if ( ! IsValid())
-      return false ;
-
-  // Per sicurezza normalizzo la direzione
-   Vector3d vtMyDir = vtDir ;
-   if ( ! vtMyDir.Normalize())
-      return false ;
-   double dMyThick = max( 10. * EPS_SMALL, dThick) ;
-
-  // 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 e successivamente da rimuovere
-   VolZmap ZMapExtra ;
-   if ( ! ZMapExtra.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 ;
-
-   const double FIN_ANG_DEG_TOL = 55. ; // Approssimazione per eccesso dell'angolo massimo possibile tra una direzione generica
-                                        // e un versore della terna globale ( arccos( 1 / sqrt( 3) ~ 54.375)
-   const double COS_FIN_ANG_DEG_TOL = cos( FIN_ANG_DEG_TOL * DEGTORAD) ;
-   const int NUM_TOOL = 1000 ;         // Identificativo Utensile per riconoscere le parti rimosse
-
-  // NB. Tutti i parametri sono sempre presi dalla Copia dello ZMap corrente
-  // Ciclo sulle griglie
-   DBLVECTOR vdThicks ;
-   if ( IsTriDexel())
-      vdThicks = { dThick, dThick, dThick} ;
-   else
-      vdThicks = { dThick} ;
-   for ( int nGrid = 0 ; nGrid < pZMapCopy->m_nMapNum ; ++ nGrid) {
-     // Verifico se l'angolo tra la direzione degli spilloni della griglia corrente è sotto alla tolleranza rispetto alla direzione
-      double dCosDir = ( nGrid == 0 ? vtMyDir.z :
-                       ( nGrid == 1 ? vtMyDir.x :
-                                      vtMyDir.y)) ;
-      if ( abs( dCosDir) < COS_FIN_ANG_DEG_TOL + EPS_ANG_SMALL)
-         continue ;
-     // Aggiorno l'effettivo valore dello spessore da considerare
-      double dCurrThick = dMyThick / abs( dCosDir) ; // (sicuramente esiste, essendo 55deg il limite)
-      vdThicks[nGrid] = dCurrThick ;
-     // Ciclo sul numero di dexel presenti nella Copia
-      for ( int nDex = 0 ; nDex < ssize( pZMapCopy->m_Values[nGrid]) ; ++ nDex) {
-        // Se il dexel corrente non ha sotto-intervalli passo al successivo
-         if ( pZMapCopy->m_Values[nGrid][nDex].empty())
-            continue ;
-        // Indici del dexel
-         int nI = nDex % m_nNx[nGrid] ;
-         int nJ = nDex / m_nNx[nGrid] ;
-        // Scorro gli intervalli presenti
-         for ( int nInfo = 0 ; nInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nInfo) {
-           // Recupero l'intervallo corrente
-            Data& Interval = pZMapCopy->m_Values[nGrid][nDex][nInfo] ;
-           // Se entrambi gli estremi dell'intervallo non sono stati toccati dall'utensile, allora passo al successivo
-            bool bAnalyze = ( ( Interval.nToolMin == 1  &&  Interval.nToolMax == 1)  ||
-                              ( Interval.dMax > m_dMaxZ[nGrid] - EPS_SMALL  ||  Interval.dMin < m_dMinZ[nGrid] + EPS_SMALL)) ;
-            if ( ! bAnalyze)
-               continue ;
-           // Se la lunghezza dell'intervallo è superiore allo spessore richiesto, non faccio nulla
-            double dLen = Interval.dMax - Interval.dMin ;
-            if ( dLen > dCurrThick + EPS_ZERO)
-               continue ;
-           // Se ZMap composto da una sola griglia, elimino il contributo lungo la direzione corrente
-            if ( ! IsTriDexel()) {
-               SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL,
-                                  - Interval.vtMinN, - Interval.vtMaxN, NUM_TOOL, true) ;
-            }
-           // Se Tridexel, aggiungo il contributo del cubetto corrente allo ZMap Extra
-            else
-               ZMapExtra.AddStripInterval( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL, NUM_TOOL) ;
-         }
-      }
-   }
-  // Se non ho aggiunto alcun elemento allo ZMap Extra, non devo fare nulla
-   if ( ! ZMapExtra.IsValid())
-      return true ;
-   #if DEBUG_REMOVE_FINS
-      SaveGeoObj( ZMapExtra.Clone(), "C:\\Temp\\VolZMapSubt0.nge") ;
-   #endif
-
-  // Ciclo sulle griglie dello ZMap Extra
-   for ( int nGrid = 0 ; nGrid < ZMapExtra.m_nMapNum ; ++ nGrid) {
-     // Ciclo sul numero di dexel presenti
-      for ( int nDex = 0 ; nDex < ssize( ZMapExtra.m_Values[nGrid]) ; ++ nDex) {
-        // Se l'intervallo è vuoto, non faccio nulla
-         if ( ZMapExtra.m_Values[nGrid][nDex].empty())
-            continue ;
-        // Indici del dexel
-         int nI = nDex % m_nNx[nGrid] ;
-         int nJ = nDex / m_nNx[nGrid] ;
-        // Scorro i gli Intervalli dello Spillone corrente
-         for ( int nInfo = 0 ; nInfo < ssize( ZMapExtra.m_Values[nGrid][nDex]) ; ++ nInfo) {
-            double dMin = ZMapExtra.m_Values[nGrid][nDex][nInfo].dMin ;
-            double dMax = ZMapExtra.m_Values[nGrid][nDex][nInfo].dMax ;
-            Vector3d vtNMin = ZMapExtra.m_Values[nGrid][nDex][nInfo].vtMinN ;
-            Vector3d vtNMax = ZMapExtra.m_Values[nGrid][nDex][nInfo].vtMaxN ;
-           // sottraggo tali contributi
-            SubtractIntervals( nGrid, nI, nJ, dMin, dMax, - vtNMin, - vtNMax, NUM_TOOL, true) ;
-         }
-      }
-   }
-   if ( ! IsValid())
-      return true ;
-   #if DEBUG_REMOVE_FINS
-      SaveGeoObj( this->Clone(), "C:\\Temp\\VolZMapSubt1.nge") ;
-   #endif
-
-  // Sistemo le Normali sullo ZMap ricavato
-   for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
-     // Ciclo sul numero di dexel presenti
-      for ( int nDex = 0 ; nDex < ssize( m_Values[nGrid]) ; ++ nDex) {
-        // Se l'Intervallo è vuoto non faccio nulla
-         if ( m_Values[nGrid][nDex].empty())
-            continue ;
-        // Indici del dexel
-         int nI = nDex % m_nNx[nGrid] ;
-         int nJ = nDex / m_nNx[nGrid] ;
-        // Scorro gli intervalli dello spillone corrente
-         for ( int nInfo = 0 ; nInfo < ssize( m_Values[nGrid][nDex]) ; ++ nInfo) {
-           // Se intervallo con estremo minimo derivante dalla sottrazione con ZMapExtra, medio le normali
-            int nToolMin = m_Values[nGrid][nDex][nInfo].nToolMin ;
-            if ( nToolMin == NUM_TOOL) {
-              // Recupero il valore minimo, se sul bordo dello ZMap corrente non faccio nulla
-               double dMin = m_Values[nGrid][nDex][nInfo].dMin ;
-               if ( dMin > m_dMinZ[nGrid] + EPS_SMALL) {
-                  Vector3d vtMinN = V_NULL ;
-                  double dZMin = INFINITO ;
-                  if ( ! pZMapCopy->ComputePointAndNormalForRemovingFins( nGrid, nI, nJ, dMin, vtMyDir, dThick, true, 1, vtMinN, dZMin)) {
-                     vtMinN = - ( nGrid == 0 ? m_MapFrame.VersZ() : nGrid == 1 ? m_MapFrame.VersX() : m_MapFrame.VersY()) ;
-                     dZMin = dMin ;
-                  }
-                  m_Values[nGrid][nDex][nInfo].vtMinN = vtMinN ;
-                  m_Values[nGrid][nDex][nInfo].dMin = dZMin ;
-               }
-            }
-           // Se intervallo con estremo massimo derivante dalla sottrazione con ZMapExtra, medio le normali
-            int nToolMax = m_Values[nGrid][nDex][nInfo].nToolMax ;
-            if ( nToolMax == NUM_TOOL) {
-              // Recupero il valore massimo, se sul bordo dello ZMap corrente non faccio nulla
-               double dMax = m_Values[nGrid][nDex][nInfo].dMax ;
-               if ( dMax < m_dMaxZ[nGrid] - EPS_SMALL) {
-                  Vector3d vtMaxN = V_NULL ;
-                  double dZMax = INFINITO ;
-                  if ( ! pZMapCopy->ComputePointAndNormalForRemovingFins( nGrid, nI, nJ, dMax, vtMyDir, dThick, false, 1, vtMaxN, dZMax)) {
-                     vtMaxN = ( nGrid == 0 ? m_MapFrame.VersZ() : nGrid == 1 ? m_MapFrame.VersX() : m_MapFrame.VersY()) ;
-                     dZMax = dMax ;
-                  }
-                  m_Values[nGrid][nDex][nInfo].vtMaxN = vtMaxN ;
-                  m_Values[nGrid][nDex][nInfo].dMax = dZMax ;
-               }
-            }
-         }
-      }
-   }
-
-  // Riassegno il Tool dell'utensile alle nuove parti
-   for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
-     // Ciclo sul numero di dexel presenti
-      for ( int nDex = 0 ; nDex < ssize( m_Values[nGrid]) ; ++ nDex) {
-        // Se l'Intervallo è vuoto non faccio nulla
-         if ( m_Values[nGrid][nDex].empty())
-            continue ;
-        // Scorro gli intervalli dello spillone corrente
-         for ( int nInfo = 0 ; nInfo < ssize( m_Values[nGrid][nDex]) ; ++ nInfo) {
-            if ( m_Values[nGrid][nDex][nInfo].nToolMin == NUM_TOOL)
-               m_Values[nGrid][nDex][nInfo].nToolMin = 1 ;
-            if ( m_Values[nGrid][nDex][nInfo].nToolMax == NUM_TOOL)
-               m_Values[nGrid][nDex][nInfo].nToolMax = 1 ;
-         }
-      }
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)

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
@@ -81,10 +82,10 @@ class VolZmap : public IVolZmap, public IGeoObjRW
    public :                      // IVolZmap
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
       bool Clear( void) override ;
-      bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) override ;
-      bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) override ;
-      bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) override ;
-      bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0, int* nError = nullptr) override ;
+      bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) override ;
+      bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) override ;
+      bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) override ;
+      bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0) override ;
       int  GetBlockCount( void) const override ;
       int  GetBlockUpdatingCounter( int nBlock) const override ;
       bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const override ;
@@ -151,7 +152,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool AddSurfTm( const ISurfTriMesh* pStm) override ;
       bool SubtractSurfTm( const ISurfTriMesh* pStm) override ;
       bool MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum) override ;
-      bool RemoveFins( const Vector3d& vtDir, double dThick) override ;
       bool Offset( double dOffs, int nType) override ;
 
    public :                      // IGeoObjRW
@@ -227,16 +227,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       typedef std::unordered_map<int, Voxel> VoxelContainer ;
      // Unordered map per la coerenza topologica
       typedef std::unordered_map<int, bool> InterVoxMatter ;
-      #if !defined(_WIN64)
-        // Numero massimo approssimativo di Dexel per versione 32-bit per evitare Crash con memoria
-         #if defined(_DEBUG)
-            static const int MAX_DEXEL_32_BIT = 3000000 + 1 ;
-         #else
-            static const int MAX_DEXEL_32_BIT = 5000000 + 1 ;
-         #endif
-         static int m_nDexelNbr ;                              // numero corrente di Dexel presenti
-      #endif
-
+      
    private :
       bool CopyFrom( const VolZmap& clSrc) ;
       bool ResetGraphics( void) ;
@@ -272,7 +263,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool UniformIntervalsInVoxel( int nGrid, int nI, int nJ, double dZMin, double dZMax,
                                     double dToler, bool bAdd, int nToolNum, const Vector3d& vtToolMin,
                                     const Vector3d& vtToolMax) ;
-      bool AddStripInterval( int nGrid, int nI, int nJ, double dZMin, double dZMax, int nToolNum) ;
       bool ManageSubIntervalInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, int nK, double& dMin, double& dMax,
                                      Vector3d& vtMin, Vector3d& vtMax) ;
      // Spostamenti utensile
@@ -497,11 +487,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
      // Funzioni per Offset di Zmap
       bool OffsetFillet( double dOffs) ;
       bool OffsetSharped( double dOffs, int nType) ;
-     // Funzione analisi punti/Normali per Alette
-      bool GetLocalPoint( int nGrid, int nI, int nJ, double dZ, Point3d& ptLoc) ;
-      bool ComputePointAndNormalForRemovingFins( int nGrid, int nI, int nJ, double dZ,
-                                                 const Vector3d& vtDir, double dThick, bool bMinVsMax, int nTool,
-                                                 Vector3d& vtN, double& dNewZ) ;
 
    private :
       enum Move5Axis {
@@ -572,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 ;

VolZmapCreation.cpp

@@ -27,8 +27,8 @@ using namespace std ;
 // ------------------------- CREAZIONE MAPPA --------------------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
-bool
-VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError)
+bool 
+VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex)
 {
   // Controlli sull'ammissibilità delle dimensioni lineari del grezzo e del passo
    if ( dStep < EPS_SMALL  ||  dDimX < EPS_SMALL  ||  dDimY < EPS_SMALL  ||  dDimZ < EPS_SMALL)
@@ -51,7 +51,7 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
    m_nNx[0] = max( int( ( dDimX + EPS_SMALL) / m_dStep + 0.5), 1) ;
    m_nNy[0] = max( int( ( dDimY + EPS_SMALL) / m_dStep + 0.5), 1) ;
 
-  // Numero di componenti connesse
+  // Numero di componenti connesse 
    m_nConnectedCompoCount = 1 ;
 
   // Se tridexel
@@ -67,7 +67,7 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
       m_nNx[1] = 0 ;
       m_nNy[1] = 0 ;
       m_nNx[2] = 0 ;
-      m_nNy[2] = 0 ;
+      m_nNy[2] = 0 ; 
    }
 
    // Definisco il numero di blocchi lungo x,y e z
@@ -81,24 +81,12 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
       m_nDim[i] = m_nNx[i] * m_nNy[i] ;
 
-  // Se versione 32-bit controllo di non superare il numero di Dexel massimo
-   #if !defined(_WIN64)
-      for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
-         m_nDexelNbr += m_nDim[i] ;
-      if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
-         Clear() ;
-         if ( nError != nullptr)
-            *nError = 1 ;
-         return false ;
-      }
-   #endif
-
   // Creazione delle celle per ogni mappa
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
       m_Values[i].resize( m_nDim[i]) ;
 
   // Riempimento delle celle
-   for ( int i = 0 ; i < m_nMapNum ; ++ i) {
+   for ( int i = 0 ; i < m_nMapNum ; ++ i)
       for ( int j = 0 ; j < m_nDim[i] ; ++ j) {
 
         // Aggiungo il tratto al dexel vuoto
@@ -110,7 +98,7 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
          switch ( i) {
          case 0 :
             m_Values[i][j][0].vtMinN = - Z_AX ;
-            m_Values[i][j][0].dMax = dDimZ ;
+            m_Values[i][j][0].dMax = dDimZ ; 
             m_Values[i][j][0].vtMaxN = Z_AX ;
             m_Values[i][j][0].nToolMax = 0 ;
             break ;
@@ -125,10 +113,9 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
             m_Values[i][j][0].dMax = dDimY ;
             m_Values[i][j][0].vtMaxN = Y_AX ;
             m_Values[i][j][0].nToolMax = 0 ;
-            break ;
+            break ; 
          }
       }
-   }
 
   // Definizione delle limitazioni iniziali in Z per ogni mappa
    m_dMinZ[0] = 0 ;
@@ -149,7 +136,7 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
 
 //----------------------------------------------------------------------------
 bool 
-VolZmap::CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError)
+VolZmap::CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex)
 {
   // Controlli sull'ammissibilità delle dimensioni lineari del grezzo e del passo
    if ( dStep < EPS_SMALL  ||  dDimX < EPS_SMALL  ||  dDimY < EPS_SMALL  ||  dDimZ < EPS_SMALL)
@@ -200,18 +187,6 @@ VolZmap::CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDi
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
       m_nDim[i] = m_nNx[i] * m_nNy[i] ;
 
-  // Se versione 32-bit controllo di non superare il numero di Dexel massimo
-   #if !defined(_WIN64)
-      for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
-         m_nDexelNbr += m_nDim[i] ;
-      if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
-         Clear() ;
-         if ( nError != nullptr)
-            *nError = 1 ;
-         return false ;
-      }
-   #endif
-
   // Creazione delle celle per ogni mappa
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
       m_Values[i].resize( m_nDim[i]) ;
@@ -235,7 +210,7 @@ VolZmap::CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDi
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex, int* nError)
+VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) 
 {
   // Aggiorno la dimensione della mappa 1 o 3
    m_nMapNum = ( bTriDex ? 3 : 1) ;
@@ -275,35 +250,14 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
       m_nNx[1] = m_nNy[0] ;
       m_nNy[1] = int( ( dDimZ + EPS_SMALL) / m_dStep + 0.5) ;
       m_nDim[1] = m_nNx[1] * m_nNy[1] ;
+      m_Values[1].resize( m_nDim[1]) ;
       m_nNx[2] = m_nNy[1] ;
       m_nNy[2] = m_nNx[0] ;
       m_nDim[2] = m_nNx[2] * m_nNy[2] ;
-     // Se versione 32-bit controllo di non superare il numero di Dexel massimo
-      #if !defined(_WIN64)
-         for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
-            m_nDexelNbr += m_nDim[i] ;
-         if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
-            Clear() ;
-            if ( nError != nullptr)
-               *nError = 1 ;
-            return false ;
-         }
-      #endif
-      m_Values[1].resize( m_nDim[1]) ;
       m_Values[2].resize( m_nDim[2]) ;
    }
-  // Se dimensione singola
+
    else {
-     // Se versione 32-bit controllo di non superare il numero di Dexel massimo
-      #if !defined(_WIN64)
-         m_nDexelNbr += m_nDim[0] ;
-         if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
-            Clear() ;
-            if ( nError != nullptr)
-               *nError = 1 ;
-            return false ;
-         }
-      #endif
       m_nNx[1] = 0 ;
       m_nNy[1] = 0 ;
       m_nDim[1] = 0 ;
@@ -834,7 +788,7 @@ VolZmap::SubtractMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ,
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox, int* nError)
+VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox)
 {
   // Se la superficie non è chiusa oppure orientata al contrario non ha senso continuare
    double dVol ;
@@ -884,33 +838,14 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
       m_nNx[1] = m_nNy[0] ;
       m_nNy[1] = int( ( vtLen.z + EPS_SMALL) / m_dStep + 0.5) ;
       m_nDim[1] = m_nNx[1] * m_nNy[1] ;
+      m_Values[1].resize( m_nDim[1]) ;
       m_nNx[2] = m_nNy[1] ;
       m_nNy[2] = m_nNx[0] ;
       m_nDim[2] = m_nNx[2] * m_nNy[2] ;
-      #if !defined(_WIN64)
-         for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
-            m_nDexelNbr += m_nDim[i] ;
-         if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
-            Clear() ;
-            if ( nError != nullptr)
-               *nError = 1 ;
-            return false ;
-         }
-      #endif
-      m_Values[1].resize( m_nDim[1]) ;
       m_Values[2].resize( m_nDim[2]) ;
    }
-  // Se a dimensione singola
+
    else {
-      #if !defined(_WIN64)
-         m_nDexelNbr += m_nDim[0] ;
-         if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
-            Clear() ;
-            if ( nError != nullptr)
-               *nError = 1 ;
-            return false ;
-         }
-      #endif
       m_nNx[1] = 0 ;
       m_nNy[1] = 0 ;
       m_nDim[1] = 0 ;

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 --------------------------------------------------------------------------------------
@@ -845,183 +838,6 @@ VolZmap::UniformIntervalsInVoxel( int nGrid, int nI, int nJ, double dZMin,
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-VolZmap::AddStripInterval( int nGrid, int nI, int nJ, double dZMin, double dZMax, int nToolNum)
-{
-  // Se non Tridex, esco
-   if ( ! IsTriDexel())
-      return true ;
-
-  // Controllo che il numero di griglia sia entro i limiti
-   if ( nGrid < 0  ||  nGrid > 2)
-      return false ;
-
-  // Controllo che indici nI, nJ siano entro i limiti
-   if ( nI < 0  &&  nI >= m_nNx[nGrid]  &&  nJ < 0  &&  nJ >= m_nNy[nGrid])
-      return false ;
-
-  // Numero di voxel contenuti nel dexel corrente ( uguale per ogni dexel di una specifica griglia)
-   int nVoxNum = int( m_nNy[(( nGrid + 1) % 3)] / m_nDexVoxRatio +
-                    ( m_nNy[(( nGrid + 1) % 3)] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
-
-  // Scorro i Voxel correnti
-   for ( int nVox = - 1 ; nVox < nVoxNum - 1 ; ++ nVox) {
-     // Considero solo i Voxel interni all'intervallo corrente
-      if ( ( nVox + 1) * m_dStep > dZMin  &&  ( nVox - 1) * m_dStep < dZMax) {
-        // Recupero gli indici per la griglia successiva
-         int nMyGrid = ( nGrid + 1) % 3 ;
-         int nMyI = nJ ;
-         int nMyJ = nVox ;
-         int nMyK = nI ;
-         double dMyMinZ = nMyK * m_dStep ;
-         double dMyMaxZ = ( nMyK + 1) * m_dStep ;
-         Vector3d vtMyMaxN = ( nMyGrid == 0 ? m_MapFrame.VersZ() :
-                               nMyGrid == 1 ? m_MapFrame.VersX() :
-                                              m_MapFrame.VersY()) ;
-         Vector3d vtMyMinN = - vtMyMaxN ;
-         AddIntervals( nMyGrid, nMyI, nMyJ, dMyMinZ - EPS_SMALL, dMyMaxZ + EPS_SMALL, vtMyMinN, vtMyMaxN, nToolNum, true) ;
-        // Recupero gli indici della griglia precedente
-         nMyGrid = ( nGrid + 2) % 3 ;
-         nMyI = nVox ;
-         nMyJ = nI ;
-         nMyK = nJ ;
-         dMyMinZ = nMyK * m_dStep ;
-         dMyMaxZ = ( nMyK + 1) * m_dStep ;
-         vtMyMaxN = ( nMyGrid == 0 ? m_MapFrame.VersZ() :
-                      nMyGrid == 1 ? m_MapFrame.VersX() :
-                                     m_MapFrame.VersY()) ;
-         vtMyMinN = - vtMyMaxN ;
-         AddIntervals( nMyGrid, nMyI, nMyJ, dMyMinZ - EPS_SMALL, dMyMaxZ + EPS_SMALL, vtMyMinN, vtMyMaxN, nToolNum, true) ;
-      }
-   }
-  // Aggiungo l'intervallo corrente
-   Vector3d vtMyMaxN = ( nGrid == 0 ? m_MapFrame.VersZ() :
-                         nGrid == 1 ? m_MapFrame.VersX() :
-                                      m_MapFrame.VersY()) ;
-   Vector3d vtMyMinN = - vtMyMaxN ;
-   AddIntervals( nGrid, nI, nJ, dZMin, dZMax, vtMyMinN, vtMyMaxN, nToolNum, true) ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-VolZmap::GetLocalPoint( int nGrid, int nI, int nJ, double dZ, Point3d& ptLoc)
-{
-   // Verifico che lo ZMap corrente sia valido
-   if ( ! IsValid())
-      return false ;
-
-  // Controllo che il numero di griglia sia entro i limiti
-   if ( nGrid < 0  ||  nGrid > 2)
-      return false ;
-
-  // Controllo che indici nI, nJ siano entro i limiti
-   if ( nI < 0  &&  nI >= m_nNx[nGrid]  &&  nJ < 0  &&  nJ >= m_nNy[nGrid])
-      return false ;
-
-  // Calcolo il punto
-   ptLoc = m_MapFrame.Orig() ;
-   if ( nGrid == 0)
-      ptLoc += ( ( nI + 0.5) * m_dStep * m_MapFrame.VersX() + ( nJ + 0.5) * m_dStep * m_MapFrame.VersY() + dZ * m_MapFrame.VersZ()) ;
-   else if ( nGrid == 1)
-      ptLoc += ( ( nI + 0.5) * m_dStep * m_MapFrame.VersY() + ( nJ + 0.5) * m_dStep * m_MapFrame.VersZ() + dZ * m_MapFrame.VersX()) ;
-   else
-      ptLoc += ( ( nI + 0.5) * m_dStep * m_MapFrame.VersZ() + ( nJ + 0.5) * m_dStep * m_MapFrame.VersX() + dZ * m_MapFrame.VersY()) ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-VolZmap::ComputePointAndNormalForRemovingFins( int nGrid, int nI, int nJ, double dZ,
-                                             const Vector3d& vtDir, double dThick, bool bMinVsMax, int nTool,
-                                             Vector3d& vtN, double& dNewZ)
-{
-  // Verifico che lo ZMap corrente sia valido
-   if ( ! IsValid())
-      return false ;
-
-  // Controllo che il numero di griglia sia entro i limiti
-   if ( nGrid < 0  ||  nGrid > 2)
-      return false ;
-
-  // Inizializzo il vettore da restituire
-   vtN = V_NULL ;
-   dNewZ = INFINITO ;
-
-  // Proietto la direzione lungo la mappa della griglia corrente
-   Vector3d vtDirProj = OrthoCompo( vtDir, ( nGrid == 0 ? m_MapFrame.VersZ() :
-                                             nGrid == 1 ? m_MapFrame.VersX() :
-                                                          m_MapFrame.VersY())) ;
-  // Sposto il punto corrente nella direzione opposta a quella trovata
-   Point3d ptLoc ;
-   if ( ! GetLocalPoint( nGrid, nI, nJ, dZ, ptLoc))
-      return false ;
-   Point3d ptCenterLoc = ptLoc ;
-   ptCenterLoc.Translate( - vtDirProj * dThick) ;
-
-  // Recupero il Box nel punto
-   BBox3d BBoxLoc ; BBoxLoc.Add( ptCenterLoc) ;
-   double dExpandX = ( m_MapFrame.VersX() * X_AX) * dThick * ( vtDirProj * X_AX) ;
-   double dExpandY = ( m_MapFrame.VersY() * Y_AX) * dThick * ( vtDirProj * Y_AX) ;
-   double dExpandZ = ( m_MapFrame.VersZ() * Z_AX) * dThick * ( vtDirProj * Z_AX) ;
-   BBoxLoc.Expand( max( ( m_dStep + EPS_SMALL), dExpandX),
-                   max( ( m_dStep + EPS_SMALL), dExpandY),
-                   max( ( m_dStep + EPS_SMALL), dExpandZ)) ;
-
-  // Porto il Box nel Frame della Mappa corrente
-   BBox3d BBoxInGrid = GetToLoc( BBoxLoc, m_MapFrame) ;
-  // Recupero i suoi estremi
-   Point3d ptBoxLocMax = BBoxInGrid.GetMax() ;
-   Point3d ptBoxLocMin = BBoxInGrid.GetMin() ;
-  // Determino gli intervalli locali in X e Y locali alla Griglia correnti
-   double dMinXLoc = ( nGrid == 0 ? ptBoxLocMin.x : nGrid == 1 ? ptBoxLocMin.y : ptBoxLocMin.z) ;
-   double dMinYLoc = ( nGrid == 0 ? ptBoxLocMin.y : nGrid == 1 ? ptBoxLocMin.z : ptBoxLocMin.x) ;
-   double dMaxXLoc = ( nGrid == 0 ? ptBoxLocMax.x : nGrid == 1 ? ptBoxLocMax.y : ptBoxLocMax.z) ;
-   double dMaxYLoc = ( nGrid == 0 ? ptBoxLocMax.y : nGrid == 1 ? ptBoxLocMax.z : ptBoxLocMax.x) ;
-
-  // Recupero gli Spilloni coinvolti nel Box
-   int nStartI = max( 0, int( dMinXLoc / m_dStep)) ;
-   int nEndI = min( m_nNx[nGrid] - 1, int( dMaxXLoc / m_dStep)) ;
-   int nStartJ = max( 0, int( dMinYLoc / m_dStep)) ;
-   int nEndJ = min( m_nNy[nGrid] - 1, int( dMaxYLoc / m_dStep)) ;
-   double dSqMinDist = INFINITO ;
-   for ( int i = nStartI ; i <= nEndI ; ++ i) {
-      for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
-        // Determino la posizione corrente dello Spillone
-         int nPos = j * m_nNx[nGrid] + i ;
-         vector<Data>& vDexel = m_Values[nGrid][nPos] ;
-        // Scorro i suoi Intervalli
-         for ( int nInterval = 0 ; nInterval < ssize( vDexel) ; ++ nInterval) {
-           // Se l'Intervallo presenta un indice del Tool da evitare, passo al successivo
-            if ( ( bMinVsMax  &&  vDexel[nInterval].nToolMin != nTool)  ||
-                 ( ! bMinVsMax  &&  vDexel[nInterval].nToolMax != nTool))
-               continue ;
-           // Recupero l'estremo da analizzare
-            double dZInterval = ( bMinVsMax ? vDexel[nInterval].dMin : vDexel[nInterval].dMax) ;
-           // Recupero il punto associato
-            Point3d ptInterval ;
-            if ( ! GetLocalPoint( nGrid, i, j, dZInterval, ptInterval))
-               return false ;
-           // Se il punto è dentro nel Box, aggiungo il contributo della normale presente
-            if ( BBoxLoc.Encloses( ptInterval)) {
-               double dCurrSqDist = ( SqDist( ptInterval, ptLoc)) ;
-               if ( dCurrSqDist < dSqMinDist) {
-                  dSqMinDist = dCurrSqDist ;
-                  vtN = ( bMinVsMax ? vDexel[nInterval].vtMinN : vDexel[nInterval].vtMaxN) ;
-                  dNewZ = dZInterval ;
-               }
-            }
-         }
-      }
-   }
-
-   return ( ! vtN.IsSmall()  &&  dZ < INFINITO - 1) ;
-}
-
-
 // ------------------------- BOUNDING BOX --------------------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
@@ -1753,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 ;
@@ -1765,15 +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 bSmallMovement = vtDirTop.Len() < 10 * EPS_SMALL  &&  vtDirTip.Len() < 10 * EPS_SMALL ;
-   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 ;
@@ -1790,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) ;
@@ -1806,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
@@ -1858,44 +1670,22 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    }
 
    vector<PNTVECTOR> vvPtCtrl ;
-   if ( ! bSmallMovement) {
-      // superficie laterale sinistra
-      CurveLine cLineLeftBottom ; cLineLeftBottom.Set( vPntTipEndFront.back(), vPntTipStartFront.back()) ;
-      if ( ! cLineLeftBottom.IsValid())
-         return false ;
-      if ( bInverse)
-         cLineLeftBottom.Invert() ;
-      PtrOwner<CurveBezier> cBezLeftBottom( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftBottom, nDegU, bRat))) ;
-      if ( IsNull( cBezLeftBottom))
-         return false ;
-      CurveLine cLineLeftTop ; cLineLeftTop.Set( vPntTopEndFront.back(), vPntTopStartFront.back()) ;
-      if ( ! cLineLeftTop.IsValid())
-         return false ;
-      PtrOwner<CurveBezier> cBezLeftTop( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftTop, nDegU, bRat))) ;
-      if ( IsNull( cBezLeftTop))
-         return false ;
-      vvPtCtrl.emplace_back( cBezLeftBottom->GetAllControlPoints()) ;
-      PNTVECTOR vPntLeft = cBezLeftTop->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntLeft.begin(), vPntLeft.end()) ;
-      // superficie laterale destra
-      CurveLine cLineRightBottom ; cLineRightBottom.Set( vPntTipStartFront.front(), vPntTipEndFront.front()) ;
-      if ( ! cLineRightBottom.IsValid())
-         return false ;
-      if ( bInverse)
-         cLineRightBottom.Invert() ;
-      PtrOwner<CurveBezier> cBezRightBottom( GetBasicCurveBezier( LineToBezierCurve( &cLineRightBottom, nDegU, bRat))) ;
-      if ( IsNull( cBezRightBottom))
-         return false ;
-      CurveLine cLineRightTop ; cLineRightTop.Set( vPntTopStartFront.front(), vPntTopEndFront.front()) ;
-      if ( ! cLineRightTop.IsValid())
-         return false ;
-      PtrOwner<CurveBezier> cBezRightTop( GetBasicCurveBezier( LineToBezierCurve( &cLineRightTop, nDegU, bRat))) ;
-      if ( IsNull( cBezRightTop))
-         return false ;
-      vvPtCtrl.emplace_back( cBezRightBottom->GetAllControlPoints()) ;
-      PNTVECTOR vPntRight = cBezRightTop->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntRight.begin(), vPntRight.end()) ;
-   }
+   // superficie laterale sinistra
+   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 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
       vvPtCtrl.emplace_back( PNTVECTOR( { vPntTipStartFront.front(), vPntTipStartFront.back(), vPntTipEndFront.front(), vPntTipEndFront.back() })) ;
@@ -1959,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());
             }
          }
          
@@ -2044,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());
@@ -2127,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  ||  bSmallMovement) {
-         // 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   ||  bSmallMovement) {
-         // 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)) {
@@ -2234,7 +1926,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    }
 
    // inizializzo le superfici bilineari e i parametri per le intersezioni
-   for ( int z = 0 ; z < ssize( vvPtCtrl) ; ++z) {
+   for ( int z = 0 ; z < int( vvPtCtrl.size()) ; ++z) {
       vSurfBez[nSurfInd].sBez.Init( nDegU, nDegV, nSpanU, nSpanV, bRat) ;
       vSurfBez[nSurfInd].sBez.SetControlPoint( 0, vvPtCtrl[z][0]) ;
       vSurfBez[nSurfInd].sBez.SetControlPoint( 1, vvPtCtrl[z][1]) ;
@@ -2245,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] ;
@@ -2298,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 ;