Merge commit 'e490c173e84ed5bf576888ac4bc5f023c49680f7' into VmillAdditivo

2024-04-30 08:36:48 +02:00
138 changed files with 7864 additions and 36199 deletions
@@ -317,8 +317,6 @@ AdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst, bool bNeedSameProp)
         pCrvCo->RemoveSmallDefects( 2 * LIN_TOL_MIN, ANG_TOL_STD_DEG, true) ;
        // unisco eventuali tratti allineati
         pCrvCo->MergeCurves( LIN_TOL_MIN, ANG_TOL_STD_DEG, true, bNeedSameProp) ;
-        // richiudo i loop per sicurezza
-         pCrvCo->Close() ;
      }
   }

@@ -16,9 +16,9 @@
 #include "CurveBezier.h"
 #include "CurveComposite.h"
 #include "CreateCurveAux.h"
+#include "DistPointLine.h"
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkArcPntDirTgCurve.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkArcSpecial.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
@@ -134,8 +134,7 @@ GetArc3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d& ptEnd,

  // calcolo arco non riuscito, se i punti sono allineati nel giusto verso per essere una retta
   // verifico se i punti sono allineati nel giusto verso
-   if ( ( ptOther - ptStart) * ( ptEnd - ptOther) > EPS_ZERO  ||
-        AreSamePointApprox( ptOther, ptStart)  ||  AreSamePointApprox( ptEnd, ptOther)) {
+   if ( ( ptOther - ptStart) * ( ptEnd - ptOther) > EPS_ZERO) {
     // creo l'oggetto retta
      PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
      if ( IsNull( pLine))
@@ -133,22 +133,22 @@ Attribs::Load( NgeReader& ngeIn)
   unsigned char ucLev ;
   if ( ! ngeIn.ReadUchar( ucLev, ","))
      return false ;
-   m_Data[LEVEL] = Clamp( ucLev, GDB_LV_USER, GDB_LV_TEMP) ;
+   m_Data[LEVEL] = CLIP( ucLev, GDB_LV_USER, GDB_LV_TEMP) ;
  // modo
   unsigned char ucMode ;
   if ( ! ngeIn.ReadUchar( ucMode, ","))
      return false ;
-   m_Data[MODE] = Clamp( ucMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
+   m_Data[MODE] = CLIP( ucMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
  // stato (se SEL è convertito in ON)
   unsigned char ucStat ;
   if ( ! ngeIn.ReadUchar( ucStat, ","))
      return false ;
-   m_Data[STATUS] = Clamp( ucStat, GDB_ST_OFF, GDB_ST_ON) ;
+   m_Data[STATUS] = CLIP( ucStat, GDB_ST_OFF, GDB_ST_ON) ;
  // marcatura (sempre OFF)
   unsigned char ucMark ;
   if ( ! ngeIn.ReadUchar( ucMark, ";"))
      return false ;
-   m_Data[MARK] = Clamp( ucMark, GDB_MK_OFF, GDB_MK_OFF) ;
+   m_Data[MARK] = CLIP( ucMark, GDB_MK_OFF, GDB_MK_OFF) ;
  // materiale
   if ( ! ngeIn.ReadInt( m_Material, ";"))
      return false ;
@@ -185,22 +185,22 @@ Attribs::DataFromString( const string& sParam)
   int nLev ;
   if ( ! FromString( vsParams[0], nLev))
      return false ;
-   m_Data[LEVEL] = Clamp( nLev, GDB_LV_USER, GDB_LV_TEMP) ;
+   m_Data[LEVEL] = CLIP( nLev, GDB_LV_USER, GDB_LV_TEMP) ;
  // modo
   int nMode ;
   if ( ! FromString( vsParams[1], nMode))
      return false ;
-   m_Data[MODE] = Clamp( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
+   m_Data[MODE] = CLIP( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
  // stato (ammessi solo OFF e ON)
   int nStat ;
   if ( ! FromString( vsParams[2], nStat))
      return false ;
-   m_Data[STATUS] = Clamp( nStat, GDB_ST_OFF, GDB_ST_ON) ;
+   m_Data[STATUS] = CLIP( nStat, GDB_ST_OFF, GDB_ST_ON) ;
  // marcatura (ammesso solo OFF)
   int nMark ;
   if ( ! FromString( vsParams[3], nMark))
      return false ;
-   m_Data[MARK] = Clamp( nMark, GDB_MK_OFF, GDB_MK_OFF) ;
+   m_Data[MARK] = CLIP( nMark, GDB_MK_OFF, GDB_MK_OFF) ;

   return true ;
 }
@@ -16,12 +16,14 @@
 #include "/EgtDev/Include/EGkGdbConst.h"
 #include "/EgtDev/Include/EGkColor.h"
 #include "/EgtDev/Include/EgtStringBase.h"
-#include "/EgtDev/Include/EgtNumUtils.h"

 class NgeWriter ;
 class NgeReader ;
 class GeomDB ;

+//----------------------------------------------------------------------------
+#define CLIP( nV, nMIN, nMAX)  (( nV < nMIN) ? nMIN : (( nV > nMAX) ? nMAX : nV))
+
 //----------------------------------------------------------------------------
 class Attribs
 {
@@ -44,14 +46,14 @@ class Attribs
      bool Load( NgeReader& ngeIn) ;
      void SetLevel( int nLev)
              { m_OldData[LEVEL] = m_Data[LEVEL] ;
-                m_Data[LEVEL] = Clamp( nLev, GDB_LV_USER, GDB_LV_TEMP) ; }
+                m_Data[LEVEL] = CLIP( nLev, GDB_LV_USER, GDB_LV_TEMP) ; }
      void RevertLevel( void)
              { std::swap( m_Data[LEVEL], m_OldData[LEVEL]) ; }
      int  GetLevel( void) const
              { return m_Data[LEVEL] ; }
      void SetMode( int nMode)
              { m_OldData[MODE] = m_Data[MODE] ;
-                m_Data[MODE] = Clamp( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ; }
+                m_Data[MODE] = CLIP( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ; }
      void RevertMode( void)
              { std::swap( m_Data[MODE], m_OldData[MODE]) ; }
      int  GetMode( void) const
@@ -59,13 +61,13 @@ class Attribs
      void SetStatus( int nStat)
              { if ( m_Data[STATUS] != GDB_ST_SEL)
                   m_OldData[STATUS] = m_Data[STATUS] ;
-                m_Data[STATUS] = Clamp( nStat, GDB_ST_OFF, GDB_ST_SEL) ; }
+                m_Data[STATUS] = CLIP( nStat, GDB_ST_OFF, GDB_ST_SEL) ; }
      void RevertStatus( void)
              { SetStatus( m_OldData[STATUS]) ; }
      int  GetStatus( void) const
              { return m_Data[STATUS] ; }
-      void SetMark( int nMark)
-              { m_Data[MARK] = Clamp( nMark, GDB_MK_OFF, GDB_MK_ON_2) ; }
+      void SetMark( void)
+              { m_Data[MARK] = GDB_MK_ON ; }
      void ResetMark( void)
              { m_Data[MARK] = GDB_MK_OFF ; }
      int  GetMark( void) const
@@ -83,7 +83,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
 //----------------------------------------------------------------------------
 ICurve*
 GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir1Deg,
-          const PolyLine& PL, double& dDist, double dTol)
+          const PolyLine& PL, double& dDist)
 {
  // calcolo la curva dove giacciono i punti di giunzione tra i due archi del biarco
   PtrOwner<ICurve> pJCrv( CalcJCurve( ptP0, dDir0Deg, ptP1, dDir1Deg)) ;
@@ -122,7 +122,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
            }
         }
      }
-     // non c'è intersezione, assegno valore medio
+     // non c'è intersezione, assegno valore medio
      if ( dU < -0.5)
         dU = 0.5 ;
     // elimino casi vicino agli estremi, danno solo problemi
@@ -142,10 +142,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
   Point3d ptPrev = ptCurr ;
   while ( bPnt) {
      double dLen = Dist( ptCurr, ptPrev) ;
-      int nStep = int( dLen / STEP) + 1 ;
-      int nMinStep = ( dLen > 50 * dTol ? 3 : ( dLen > 10 * dTol ? 2 : 1)) ;
-      int nMaxStep = 10 ;
-      nStep = Clamp( nStep, nMinStep, nMaxStep) ;
+      int nStep = ( dLen < STEP ? 2 : 1) * int( dLen / STEP) + 1 ;
      for ( int i = 1 ; i <= nStep ; ++ i) {
         double dCoeff = double( i) / nStep ;
         Point3d ptP = Media( ptPrev, ptCurr, dCoeff) ;
@@ -166,7 +163,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
 static ICurve*
 CalcJCurve( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir1Deg)
 {
-  // se i due punti coincidono, non si può fare alcunché
+  // se i due punti coincidono, non si può fare alcunché
   if ( AreSamePointApprox( ptP0, ptP1))
      return nullptr ;

@@ -208,14 +205,14 @@ CalcJCurve( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dD
   double dDir0RelDeg = DiffAngle( dDir0Deg, dDirDiffDeg) ;
   // direzione iniziale secondo arco limite rispetto a direzione P0->P1 (dalla finale simmetrico e invert)
   double dDir1RelDeg = - DiffAngle( dDir1Deg, dDirDiffDeg) ;
-   // nel caso di direzioni a 180deg si sceglie la più compatta
+   // nel caso di direzioni a 180deg si sceglie la più compatta
   if ( abs( abs( dDir1RelDeg) - ANG_STRAIGHT) < EPS_SMALL)
      dDir1RelDeg = ( dDir0RelDeg > 0 ? ANG_STRAIGHT : - ANG_STRAIGHT) ;
   else if ( abs( abs( dDir0RelDeg) - ANG_STRAIGHT) < EPS_SMALL)
      dDir0RelDeg = ( dDir1RelDeg > 0 ? ANG_STRAIGHT : - ANG_STRAIGHT) ;
   // intervallo angolare ammissibile a partire da direzione iniziale primo arco ammissibile ( == Dir0)
   double dDeltaAngDeg = - dDir0RelDeg + dDir1RelDeg ;
-  // se non è nella regione, prendo l'altra parte di arco
+  // se non è nella regione, prendo l'altra parte di arco
   if ( ! AngleInSpan( dDirStartRelDeg, dDir0RelDeg, dDeltaAngDeg)) 
      pArc->ToExplementary() ;
  // inverto per avere parametrizzazione crescente allontanandosi da Dir0 e avvicinandosi a Dir1
@@ -17,5 +17,5 @@

 //-----------------------------------------------------------------------------
 ICurve* GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir1Deg,
-                  const PolyLine& PL, double& dDist, double dTol) ;
+                  const PolyLine& PL, double& dDist) ;

@@ -1,57 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : CAvSilhouetteSurfTm.h      Data : 16.06.24      Versione : 2.6f2
-// Contenuto : Dichiarazione della classe calcolo multi-silhouette.
-//
-//
-//
-// Modifiche : 10.06.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "CAvToolSurfTm.h"
-#include "SurfFlatRegion.h"
-#include "/EgtDev/Include/EGkCAvSilhouetteSurfTm.h"
-
-
-//-----------------------------------------------------------------------------
-class CAvParSilhouettesSurfTm : public ICAvParSilhouettesSurfTm
-{
-   public :
-     // generica
-      bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol) override ;
-      bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol,
-                    double dSideAng, double dDiam, double dCornRad, double dMaxMat, double dOffsR,
-                    double dMaxDepth) override ;
-      bool GetSilhouette( double dLevel, POLYLINEVECTOR& vPL) override ;
-
-   public :
-      CAvParSilhouettesSurfTm( void) ;
-
-   private :
-      bool Prepare( void) ;
-
-   private :
-      CISURFTMPVECTOR  m_vpStm ;
-      CAvToolSurfTm    m_cavTstm ;
-      Frame3d          m_frGrid ;
-      double           m_dTol ;
-      double           m_dSharpedTol ;
-      int              m_nStepX ;
-      int              m_nStepY ;
-      double           m_dRad ;
-      double           m_dCornRad ;
-      double           m_dMaxMat ;
-      double           m_dSideAng ;
-      double           m_dOffsR ;
-      double           m_dDimZ ;
-      double           m_dLevelOffs ;
-      double           m_dMaxDepth ;
-      bool             m_bGridOk ;
-      bool             m_bTool ;
-      DBLVECTOR        m_vdGrid ;
-} ;
@@ -1,21 +1,21 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2018-2024
+//  EgalTech 2018-2018
 //----------------------------------------------------------------------------
-// File : CAvToolSurfTm.cpp    Data : 07.06.24    Versione : 2.6f2
+// File : CAvToolSurfTm.cpp    Data : 08.05.18    Versione : 1.9e2
 // Contenuto : Implementazione della classe CAvToolSurfTm.
 //
 //
 //
 // Modifiche : 27.04.18 DS Creazione modulo.
-//             07.06.24 DS Con tolleranza lineare negativa non si controlla il punto medio.
+//
 //
 //----------------------------------------------------------------------------

 #include "stdafx.h"
 #include "CAvToolTriangle.h"
 #include "CAvToolSurfTm.h"
+#include "DistPointLine.h"
 #include "DllMain.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
 #include <thread>
 #include <future>
@@ -24,7 +24,6 @@ using namespace std ;

 //----------------------------------------------------------------------------
 const int STEP_PE = 50 ;
-const double MAX_MOVE = 20000 ;

 //----------------------------------------------------------------------------
 ICAvToolSurfTm*
@@ -38,29 +37,10 @@ CreateCAvToolSurfTm( void)
 // CAvToolSurfTm
 //----------------------------------------------------------------------------
 CAvToolSurfTm::CAvToolSurfTm( void)
-   :  m_frMove( false), m_Tool( false)
+   :  m_Tool( false)
 {
 }

-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::Clear( void)
-{
-  // pulisco la lista dei puntatori a Stm
-   m_vSTM.clear() ;
-  // pulisco e inizializzo la prima posizione della lista delle basi per gli indici dei triangoli
-   m_vBaseInd.clear() ;
-   m_vBaseInd.emplace_back( 0) ;
-  // pulisco HashGrid 2d
-   m_HGrids.Clear() ;
-  // reset utensile
-   m_Tool.Clear() ;
-  // reset riferimento
-   m_frMove.Reset( false) ;
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 CAvToolSurfTm::SetSurfTm( const ISurfTriMesh& Stm)
@@ -70,9 +50,6 @@ CAvToolSurfTm::SetSurfTm( const ISurfTriMesh& Stm)
  // pulisco e inizializzo la prima posizione della lista delle basi per gli indici dei triangoli
   m_vBaseInd.clear() ;
   m_vBaseInd.emplace_back( 0) ;
-  // pulisco HashGrid 2d
-   m_HGrids.Clear() ;
-  // non tocco l'utensile
  // aggiungo la superficie
   return AddSurfTm( Stm) ;
 }
@@ -81,7 +58,7 @@ CAvToolSurfTm::SetSurfTm( const ISurfTriMesh& Stm)
 bool
 CAvToolSurfTm::AddSurfTm( const ISurfTriMesh& Stm)
 {
-  // verifico validità superficie
+  // verifico validità superficie
   const SurfTriMesh* pStm = GetBasicSurfTriMesh( &Stm) ;
   if ( pStm == nullptr  ||  ! pStm->IsValid())
      return false ;
@@ -122,8 +99,7 @@ CAvToolSurfTm::SetGenTool( const ICurveComposite* pToolOutline)

 //----------------------------------------------------------------------------
 bool
-CAvToolSurfTm::TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
-                             double& dTotDist, Vector3d* pvtTriaN) const
+CAvToolSurfTm::TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist)
 {
  // Se utensile non definito, errore
   if ( m_Tool.GetType() == Tool::UNDEF)
@@ -131,189 +107,20 @@ CAvToolSurfTm::TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Ve
  // Se direzioni non definite, errore
   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
      return false ;
-  // Se riferimento di movimento già presente
-   if ( m_frMove.IsValid()) {
-     // Calcolo nuovo riferimento di movimento
-      Frame3d frMove ;
-      if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-         frMove.Set( ORIG, vtMove, vtDir) ;
-      else
-         frMove.Set( ORIG, vtMove) ;
-     // Se riferimenti di movimento uguali, sfrutto HashGrid 2d
-      if ( AreSameFrame( frMove, m_frMove)) {
-        // Eseguo controllo
-         Point3d ptCurr = ptT ;
-         Vector3d vtTriaN ;
-         dTotDist = MyTestPositionHG( ptCurr, vtDir, vtTriaN) ;
-         if ( pvtTriaN != nullptr)
-            *pvtTriaN = vtTriaN ;
-         return ( dTotDist > - EPS_SMALL) ;
-      }
-   }
-  // Altrimenti eseguo controllo diretto
-   Point3d ptCurr = ptT ;
-   Vector3d vtTriaN ;
-   dTotDist = MyTestPosition( ptCurr, vtDir, vtMove, vtTriaN) ;
-   if ( pvtTriaN != nullptr)
-      *pvtTriaN = vtTriaN ;
-   return ( dTotDist > - EPS_SMALL) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestPositionAdv( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
-                                double& dTotDist, VCT3DVECTOR& vVtN) const
-{
-  // Funzione per calcolo collisione tra utensile e superfici ;
-  // dToTDist è la distanza di traslazione del punto ptT lungo vtDir per evitare la collisione,
-  // vVtN è la normale del triangolo che genera collsione ( NB. Nel caso di più triangoli concorrenti,
-  // vengono restituite tutte le normali trovate)
-
-  // Inizializzazione parametri
-   dTotDist = 0 ;
-   vVtN.clear() ;
- // Se utensile non definito, errore
-   if ( m_Tool.GetType() == Tool::UNDEF)
-      return false ;
-  // Se direzioni non definite, errore
-   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
-      return false ;
-  // Se riferimento di movimento già presente
-   if ( m_frMove.IsValid()) {
-     // Calcolo nuovo riferimento di movimento
-      Frame3d frMove ;
-      if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-         frMove.Set( ORIG, vtMove, vtDir) ;
-      else
-         frMove.Set( ORIG, vtMove) ;
-     // Se riferimenti di movimento uguali, sfrutto HashGrid 2d
-      if ( AreSameFrame( frMove, m_frMove)) {
-        // Eseguo controllo
-         Point3d ptCurr = ptT ;
-         dTotDist = MyTestPositionHGAdv( ptCurr, vtDir, vVtN) ;
-         return ( dTotDist > - EPS_SMALL) ;
-      }
-   }
-  // Altrimenti eseguo controllo diretto
-   Point3d ptCurr = ptT ;
-   dTotDist = MyTestPositionAdv( ptCurr, vtDir, vtMove, vVtN) ;
-   return ( dTotDist > - EPS_SMALL) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestSeries( PNTUVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff)
-{
-  // Se utensile non definito, errore
-   if ( m_Tool.GetType() == Tool::UNDEF)
-      return false ;
-  // Se direzioni non definite, errore
-   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
-      return false ;
-  // Se vettore vuoto, non devo fare alcunché
-   if ( vPntM.empty())
-      return true ;
-  // Calcolo nuovo riferimento di movimento
-   Frame3d frMove ;
+  // Imposto il riferimento di movimento
   if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-      frMove.Set( ORIG, vtMove, vtDir) ;
+      m_frMove.Set( ORIG, vtMove, vtDir) ;
   else
-      frMove.Set( ORIG, vtMove) ;
-  // Se riferimento di movimento non presente o diverso dal calcolato
-   if ( ! m_frMove.IsValid()  ||  ! AreSameFrame( frMove, m_frMove)) {
-     // Salvo nuovo riferimento
-      m_frMove = frMove ;
-     // Ricalcolo HashGrid
-      if ( ! PrepareHashGrid())
-         return false ;
-   }
-  // Determino il numero di punti dell'insieme
-   m_nTotPnt = int( vPntM.size()) ;
-  // Recupero il numero massimo di thread concorrenti
-   int nThreadMax = thread::hardware_concurrency() ;
-   bool bOk = true ;
-  // Se un solo thread o pochi punti
-   if ( nThreadMax <= 1  ||  m_nTotPnt < 500) {
-      m_nCurrPnt = 0 ;
-      bOk = TestSubSeries( -1, vPntM, vtDir, 0, m_nTotPnt - 1, dProgCoeff) ;
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
-   }
-  // altrimenti
-   else {
-      const int MAX_PARTS = 32 ;
-      INTINTVECTOR vFstLst( MAX_PARTS) ;
-     // calcolo le parti del vettore
-      int nPartCnt = min( nThreadMax, MAX_PARTS) ;
-      int nPartDim = m_nTotPnt / nPartCnt + 1 ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i) {
-         vFstLst[i].first = i * nPartDim ;
-         vFstLst[i].second = min( ( i + 1) * nPartDim, m_nTotPnt) - 1 ;
-      }
-     // processo le parti
-      m_nCurrPnt = 0 ;
-      m_bBreak = false ;
-      future<bool> vRes[MAX_PARTS] ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i)
-         vRes[i] = async( launch::async, &CAvToolSurfTm::TestSubSeries, this, i, ref( vPntM), cref( vtDir), vFstLst[i].first, vFstLst[i].second, dProgCoeff) ;
-     // attendo i risultati
-      int nFin = 0 ;
-      int nNextPE = 0 ;
-      while ( nFin < nPartCnt) {
-         for ( int i = 0 ; i < nPartCnt ; ++ i) {
-            if ( vRes[i].valid()  &&  vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
-               bOk = vRes[i].get() && bOk ;
-               ++ nFin ;
-            }
-         }
-         if ( m_nCurrPnt > nNextPE) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 10) ;
-            nNextPE += STEP_PE ;
-            if ( nRes == 1)
-               m_bBreak = true ;
-         }
-      }
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
-   }
-   return bOk ;
+      m_frMove.Set( ORIG, vtMove) ;
+  // Eseguo controllo
+   Point3d ptCurr = ptT ;
+   dTotDist = MyTestPosition( ptCurr, vtDir) ;
+   return ( dTotDist > - EPS_SMALL) ;
 }

 //----------------------------------------------------------------------------
 bool
-CAvToolSurfTm::TestSubSeries( int nId, PNTUVECTOR& vPntM, const Vector3d& vtDir, int nFirst, int nLast, double dProgCoeff)
-{
-  // Se vettore vuoto, non devo fare alcunché
-   if ( vPntM.empty())
-      return true ;
-  // Ciclo sui punti da verificare
-   for ( int i = nFirst ; i <= nLast ; ++ i) {
-     // verifico il punto
-      Vector3d vtTriaN ;
-      double dMove = MyTestPositionHG( vPntM[i].first, vtDir, vtTriaN) ;
-      vPntM[i].second = dMove ;
-      if ( dMove < - EPS_SMALL)
-         return false ;
-      ++ m_nCurrPnt ;
-     // se singolo thread
-      if ( nId == -1) {
-        // gestione eventi (ogni STEP_PE punti)
-         if (( m_nCurrPnt % STEP_PE) == 0) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 0) ;
-            if ( nRes == 1)
-               return false ;
-         }
-      }
-     // altrimenti multithread
-      else {
-         if ( m_bBreak)
-            return false ;
-      }
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol, double dProgCoeff)
+CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol)
 {
  // Se utensile non definito, errore
   if ( m_Tool.GetType() == Tool::UNDEF)
@@ -321,28 +128,17 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d&
  // Se direzioni non definite, errore
   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
      return false ;
-  // Se lista vuota, non devo fare alcunché
+  // Se lista vuota, non devo fare alcunché
   if ( lPntM.empty())
      return true ;
-  // Controllo la tolleranza lineare (se negativa non vanno fatti controlli sui punti medi)
-   if ( dLinTol > -EPS_ZERO)
-      dLinTol = max( dLinTol, EPS_SMALL) ;
-   else
-      dLinTol = -1 ;
-  // Calcolo nuovo riferimento di movimento
-   Frame3d frMove ;
+  // Imposto il riferimento di movimento
   if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-      frMove.Set( ORIG, vtMove, vtDir) ;
+      m_frMove.Set( ORIG, vtMove, vtDir) ;
   else
-      frMove.Set( ORIG, vtMove) ;
-  // Se riferimento di movimento non presente o diverso dal calcolato
-   if ( ! m_frMove.IsValid()  ||  ! AreSameFrame( frMove, m_frMove)) {
-     // Salvo nuovo riferimento
-      m_frMove = frMove ;
-     // Ricalcolo HashGrid
-      if ( ! PrepareHashGrid())
-         return false ;
-   }
+      m_frMove.Set( ORIG, vtMove) ;
+  // Predispongo Hash Grid
+   if ( ! PrepareHashGrid())
+      return false ;
  // Determino il numero di punti del path
   m_nTotPnt = int( lPntM.size()) ;
  // Recupero il numero massimo di thread concorrenti
@@ -350,9 +146,8 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d&
   bool bOk = true ;
  // Se un solo thread o pochi punti
   if ( nThreadMax <= 1  ||  m_nTotPnt < 500) {
-      m_nCurrPnt = 0 ;
-      bOk = TestSubPath( -1, lPntM, vtDir, dLinTol, dProgCoeff) ;
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
+      bOk = TestSubPath( -1, lPntM, vtDir, dLinTol) ;
+      ProcessEvents( 100, 0) ;
   }
  // altrimenti
   else {
@@ -372,7 +167,7 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d&
      m_bBreak = false ;
      future<bool> vRes[MAX_PARTS] ;
      for ( int i = 0 ; i < nPartCnt ; ++ i)
-         vRes[i] = async( launch::async, &CAvToolSurfTm::TestSubPath, this, i, ref( vlPntM[i]), cref( vtDir), dLinTol, dProgCoeff) ;
+         vRes[i] = async( launch::async, &CAvToolSurfTm::TestSubPath, this, i, ref( vlPntM[i]), cref( vtDir), dLinTol) ;
     // attendo i risultati
      int nFin = 0 ;
      int nNextPE = 0 ;
@@ -384,7 +179,7 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d&
            }
         }
         if ( m_nCurrPnt > nNextPE) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 10) ;
+            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt), 10) ;
            nNextPE += STEP_PE ;
            if ( nRes == 1)
               m_bBreak = true ;
@@ -396,98 +191,18 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d&
            lPntM.pop_back() ;
         lPntM.splice( lPntM.end(), vlPntM[i]) ;
      }
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
+      ProcessEvents( 100, 0) ;
   }
+  // pulisco HashGrid 2d
+   m_HGrids.Clear() ;
   return bOk ;
 }

 //----------------------------------------------------------------------------
 bool
-CAvToolSurfTm::TestSeriesAdv( PNTUVVECTVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff)
+CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, double dLinTol)
 {
-  // NB. la posizione del punto non viene modificata :
-  // get<0> vPntM[i] è il punto su cui viene posizionata la testa dell'utensile ( const)
-  // get<1> vPntM[i] è il parametro di traslazione del punto lungo vtDir per evitare collisioni con i triangoli
-  // get<2> vPntM[i] è un vettore di Vector3d contenente tutte le normali di tangenza ( a meno di 10 * EPS_SMALL)
-
-  // Se utensile non definito, errore
-   if ( m_Tool.GetType() == Tool::UNDEF)
-      return false ;
-  // Se direzioni non definite, errore
-   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
-      return false ;
-  // Se vettore vuoto, non devo fare alcunché
-   if ( vPntM.empty())
-      return true ;
-  // Calcolo nuovo riferimento di movimento
-   Frame3d frMove ;
-   if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-      frMove.Set( ORIG, vtMove, vtDir) ;
-   else
-      frMove.Set( ORIG, vtMove) ;
-  // Se riferimento di movimento non presente o diverso dal calcolato
-   if ( ! m_frMove.IsValid()  ||  ! AreSameFrame( frMove, m_frMove)) {
-     // Salvo nuovo riferimento
-      m_frMove = frMove ;
-     // Ricalcolo HashGrid
-      if ( ! PrepareHashGrid())
-         return false ;
-   }
-  // Determino il numero di punti del path
-   m_nTotPnt = int( vPntM.size()) ;
-  // Recupero il numero massimo di thread concorrenti
-   int nThreadMax = thread::hardware_concurrency() ;
-   bool bOk = true ;
-  // Se un solo thread o pochi punti
-   if ( nThreadMax <= 1  ||  m_nTotPnt < 500) {
-      m_nCurrPnt = 0 ;
-      bOk = TestSubSeriesAdv( -1, vPntM, vtDir, 0, m_nTotPnt - 1, dProgCoeff) ;
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
-   }
-  // altrimenti
-   else {
-      const int MAX_PARTS = 32 ;
-      INTINTVECTOR vFstLst( MAX_PARTS) ;
-     // calcolo le parti del vettore
-      int nPartCnt = min( nThreadMax, MAX_PARTS) ;
-      int nPartDim = m_nTotPnt / nPartCnt + 1 ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i) {
-         vFstLst[i].first = i * nPartDim ;
-         vFstLst[i].second = min( ( i + 1) * nPartDim, m_nTotPnt) - 1 ;
-      }
-     // processo le parti
-      m_nCurrPnt = 0 ;
-      m_bBreak = false ;
-      future<bool> vRes[MAX_PARTS] ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i)
-         vRes[i] = async( launch::async, &CAvToolSurfTm::TestSubSeriesAdv, this, i, ref( vPntM), cref( vtDir), vFstLst[i].first, vFstLst[i].second, dProgCoeff) ;
-     // attendo i risultati
-      int nFin = 0 ;
-      int nNextPE = 0 ;
-      while ( nFin < nPartCnt) {
-         for ( int i = 0 ; i < nPartCnt ; ++ i) {
-            if ( vRes[i].valid()  &&  vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
-               bOk = vRes[i].get() && bOk ;
-               ++ nFin ;
-            }
-         }
-         if ( m_nCurrPnt > nNextPE) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 10) ;
-            nNextPE += STEP_PE ;
-            if ( nRes == 1)
-               m_bBreak = true ;
-         }
-      }
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
-   }
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, double dLinTol, double dProgCoeff)
-{
-  // Se lista vuota, non devo fare alcunché
+  // Se lista vuota, non devo fare alcunché
   if ( lPntM.empty())
      return true ;
  // Ciclo sui punti
@@ -497,13 +212,11 @@ CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, dou
   while ( itPntMCurr != lPntM.end()) {
     // verifico il punto
      ptCurr = itPntMCurr->first ;
-      Vector3d vtTriaN ;
-      double dMove = MyTestPositionHG( itPntMCurr->first, vtDir, vtTriaN) ;
-      itPntMCurr->second = dMove ;
-      if ( dMove < - EPS_SMALL)
+      itPntMCurr->second = MyTestPositionHG( itPntMCurr->first, vtDir) ;
+      if ( itPntMCurr->second < - EPS_SMALL)
         return false ;
-     // se esiste il punto precedente e richiesto devo verificare il medio
-      if ( itPntMPrev != lPntM.end()  &&  dLinTol > 0) {
+     // se esiste il punto precedente devo verificare il medio
+      if ( itPntMPrev != lPntM.end()) {
         MyTestMidPointHG( lPntM, itPntMPrev, itPntMCurr, ptPrev, ptCurr, vtDir, dLinTol, 1) ;
      }
     // passo al successivo
@@ -515,7 +228,7 @@ CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, dou
      if ( nId == -1) {
        // gestione eventi (ogni STEP_PE punti)
         if (( m_nCurrPnt % STEP_PE) == 0) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 0) ;
+            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt), 0) ;
            if ( nRes == 1)
               return false ;
         }
@@ -529,44 +242,10 @@ CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, dou
   return true ;
 }

-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestSubSeriesAdv( int nId, PNTUVVECTVECTOR& vPntM, const Vector3d& vtDir, int nFirst, int nLast, double dProgCoeff)
-{
-  // Se vettore vuoto, non devo fare alcunché
-   if ( vPntM.empty())
-      return true ;
-  // Ciclo sui punti da verificare
-   for ( int i = nFirst ; i <= nLast ; ++ i) {
-     // verifico il punto
-      Point3d ptCurr = get<0>( vPntM[i]) ;
-      get<1>( vPntM[i]) = MyTestPositionHGAdv( ptCurr, vtDir, get<2>( vPntM[i])) ;
-      if ( get<1>( vPntM[i]) < - EPS_SMALL)
-         return false ;
-      ++ m_nCurrPnt ;
-     // se singolo thread
-      if ( nId == -1) {
-        // gestione eventi (ogni STEP_PE punti)
-         if (( m_nCurrPnt % STEP_PE) == 0) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 0) ;
-            if ( nRes == 1)
-               return false ;
-         }
-      }
-     // altrimenti multithread
-      else {
-         if ( m_bBreak)
-            return false ;
-      }
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPntMPrev, const PNTULIST::iterator& itPntMCurr,
-                                 const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) const
+                                 const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev)
 {
  // se superato limite di ricursione, esco
   const int MAX_LEV = 10 ;
@@ -576,8 +255,7 @@ CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPn
   Point3d ptMid = Media( ptPrev, ptCurr, 0.5) ;
  // ne effettuo la correzione per evitare la collisione
   Point3d ptNewMid = ptMid ;
-   Vector3d vtTriaN ;
-   double dMidMove = MyTestPositionHG( ptNewMid, vtDir, vtTriaN) ;
+   double dMidMove = MyTestPositionHG( ptNewMid, vtDir) ;
   if ( dMidMove < - EPS_SMALL)
      return false ;
  // massima distanza ammissibile
@@ -586,7 +264,7 @@ CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPn
   if ( abs(( Media( itPntMPrev->first, itPntMCurr->first, 0.5) - ptNewMid) * m_frMove.VersZ()) > 0.5 * dLinTol  ||
        SqDist( itPntMPrev->first, itPntMCurr->first) > dMaxSqDist) {
     // aggiungo
-      lPntM.emplace( itPntMCurr, ptNewMid, dMidMove) ;
+      lPntM.emplace( itPntMCurr, ptNewMid, - dMidMove) ;
      auto itPntMMid = itPntMCurr ;
      -- itPntMMid ;
     // verifico intervallo precedente
@@ -599,48 +277,20 @@ CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPn

 //----------------------------------------------------------------------------
 double
-CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, Vector3d& vtTriaN) const
+CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir)
 {
-  // box dell'utensile con suo movimento
-   BBox3d b3Tool ;
-   // utensile
-   b3Tool.Add( ptT) ;
-   b3Tool.Add( ptT - vtDir * m_Tool.GetHeigth()) ;
-   if ( vtDir.IsX())
-      b3Tool.Expand( 0, m_Tool.GetRadius(), m_Tool.GetRadius()) ;
-   else if ( vtDir.IsY())
-      b3Tool.Expand( m_Tool.GetRadius(), 0, m_Tool.GetRadius()) ;
-   else if ( vtDir.IsZ())
-      b3Tool.Expand( m_Tool.GetRadius(), m_Tool.GetRadius(), 0) ;
-   else {
-      double dExpandX = m_Tool.GetRadius() * sqrt( 1 - vtDir.x * vtDir.x) ;
-      double dExpandY = m_Tool.GetRadius() * sqrt( 1 - vtDir.y * vtDir.y) ;
-      double dExpandZ = m_Tool.GetRadius() * sqrt( 1 - vtDir.z * vtDir.z) ;
-      b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
-   }
-   // aggiungo movimento
-   BBox3d b3Moved = b3Tool ;
-   b3Moved.Translate( MAX_MOVE * vtMove) ;
-   b3Tool.Add( b3Moved) ;
-
-  // determino movimento minimo per evitare collisione con superfici
   double dTotDist = 0 ;
-   vtTriaN = V_NULL ;
   for ( auto pStm : m_vSTM) {
-      INTVECTOR vTria ;
-      if ( pStm->GetAllTriaOverlapBox( b3Tool, vTria)) {
-         for ( int nTria : vTria) {
-            Triangle3d Tria ;
-            if ( pStm->GetTriangle( nTria, Tria)) {
-               double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, vtMove) ;
-               if ( dDist < - EPS_SMALL)
-                  return -1 ;
-               if ( dDist > EPS_SMALL) {
-                  dTotDist += dDist ;
-                  ptT += dDist * vtMove ;
-                  vtTriaN = Tria.GetN() ;
-               }
-            }
+      Triangle3d Tria ;
+      for ( int nTria = pStm->GetFirstTriangle( Tria) ;
+            nTria != SVT_NULL ;
+            nTria = pStm->GetNextTriangle( nTria, Tria)) {
+         double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, m_frMove.VersZ()) ;
+         if ( dDist < - EPS_SMALL)
+            return -1 ;
+         if ( dDist > EPS_SMALL) {
+            dTotDist += dDist ;
+            ptT += dDist * m_frMove.VersZ() ;
         }
      }
   }
@@ -649,61 +299,7 @@ CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector

 //----------------------------------------------------------------------------
 double
-CAvToolSurfTm::MyTestPositionAdv( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, VCT3DVECTOR& vVtTriaN) const
-{
-  // box dell'utensile con suo movimento
-   BBox3d b3Tool ;
-   // utensile
-   b3Tool.Add( ptT) ;
-   b3Tool.Add( ptT - vtDir * m_Tool.GetHeigth()) ;
-   if ( vtDir.IsX())
-      b3Tool.Expand( 0, m_Tool.GetRadius(), m_Tool.GetRadius()) ;
-   else if ( vtDir.IsY())
-      b3Tool.Expand( m_Tool.GetRadius(), 0, m_Tool.GetRadius()) ;
-   else if ( vtDir.IsZ())
-      b3Tool.Expand( m_Tool.GetRadius(), m_Tool.GetRadius(), 0) ;
-   else {
-      double dExpandX = m_Tool.GetRadius() * sqrt( 1 - vtDir.x * vtDir.x) ;
-      double dExpandY = m_Tool.GetRadius() * sqrt( 1 - vtDir.y * vtDir.y) ;
-      double dExpandZ = m_Tool.GetRadius() * sqrt( 1 - vtDir.z * vtDir.z) ;
-      b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
-   }
-   // aggiungo movimento
-   BBox3d b3Moved = b3Tool ;
-   b3Moved.Translate( MAX_MOVE * vtMove) ;
-   b3Tool.Add( b3Moved) ;
-
-  // determino movimento minimo per evitare collisione con superfici
-   double dTotDist = 0 ;
-   vVtTriaN.clear() ;
-   for ( auto pStm : m_vSTM) {
-      INTVECTOR vTria ;
-      if ( pStm->GetAllTriaOverlapBox( b3Tool, vTria)) {
-         for ( int nTria : vTria) {
-            Triangle3d Tria ;
-            if ( pStm->GetTriangle( nTria, Tria)) {
-               double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, vtMove) ;
-               if ( dDist < - EPS_SMALL)
-                  return -1 ;
-              // se devo traslare il punto, c'è collisione
-               if ( dDist > EPS_SMALL) {
-                  if ( dDist > 10 * EPS_SMALL) {
-                     vVtTriaN.clear() ;
-                     dTotDist += dDist ;
-                     ptT += ( dDist - 5 * EPS_SMALL) * m_frMove.VersZ() ;
-                  }
-                  vVtTriaN.push_back( Tria.GetN()) ;
-               }
-            }
-         }
-      }
-   }
-   return dTotDist ;
-}
-
-//----------------------------------------------------------------------------
-double
-CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir, Vector3d& vtTriaN) const
+CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir)
 {
  // calcolo box utensile nel riferimento di movimento
   BBox3d b3Tool ;
@@ -723,10 +319,8 @@ CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir, Vector3d&
      double dExpandZ = m_Tool.GetRadius() * sqrt( 1 - vtDirL.z * vtDirL.z) ;
      b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
   }
-
-  // ciclo sui triangoli che intersecano box in 2d
+  // ciclo sui triangoli che intersecano box in 2d 
   double dTotDist = 0 ;
-   vtTriaN = V_NULL ;
   INTVECTOR vnIds ;
   if ( m_HGrids.Find( b3Tool, vnIds)) {
      for ( int i = 0 ; i < int( vnIds.size()) ; ++ i) {
@@ -742,70 +336,11 @@ CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir, Vector3d&
         if ( dDist > EPS_SMALL) {
            dTotDist += dDist ;
            ptT += dDist * m_frMove.VersZ() ;
-            vtTriaN = Tria.GetN() ;
         }
         else if ( dDist < -EPS_SMALL)
            return -1 ;
      }
   }
-
-   return dTotDist ;
-}
-
-//----------------------------------------------------------------------------
-double
-CAvToolSurfTm::MyTestPositionHGAdv( Point3d& ptT, const Vector3d& vtDir, VCT3DVECTOR& vVtTriaN) const
-{
-  // calcolo box utensile nel riferimento di movimento
-   BBox3d b3Tool ;
-   Point3d ptTL = ptT ; ptTL.ToLoc( m_frMove) ;
-   Vector3d vtDirL = vtDir ; vtDirL.ToLoc( m_frMove) ;
-   b3Tool.Add( ptTL) ;
-   b3Tool.Add( ptTL - vtDirL * m_Tool.GetHeigth()) ;
-   if ( vtDirL.IsX())
-      b3Tool.Expand( 0, m_Tool.GetRadius(), m_Tool.GetRadius()) ;
-   else if ( vtDirL.IsY())
-      b3Tool.Expand( m_Tool.GetRadius(), 0, m_Tool.GetRadius()) ;
-   else if ( vtDirL.IsZ())
-      b3Tool.Expand( m_Tool.GetRadius(), m_Tool.GetRadius(), 0) ;
-   else {
-      double dExpandX = m_Tool.GetRadius() * sqrt( 1 - vtDirL.x * vtDirL.x) ;
-      double dExpandY = m_Tool.GetRadius() * sqrt( 1 - vtDirL.y * vtDirL.y) ;
-      double dExpandZ = m_Tool.GetRadius() * sqrt( 1 - vtDirL.z * vtDirL.z) ;
-      b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
-   }
-
-  // ciclo sui triangoli che intersecano box in 2d
-   double dTotDist = 0. ;
-   INTVECTOR vnIds ;
-   if ( m_HGrids.Find( b3Tool, vnIds)) {
-      for ( int i = 0 ; i < int( vnIds.size()) ; ++ i) {
-        // recupero la superficie
-         int nInd = vnIds[i] ;
-         int nSurf = GetSurfInd( nInd) ;
-         if ( nSurf == -1)
-            return -1 ;
-        // recupero il triangolo
-         int nT = nInd - m_vBaseInd[nSurf] ;
-         Triangle3d Tria ;
-         if ( ! m_vSTM[nSurf]->GetTriangle( nT, Tria))
-            return -1 ;
-        // calcolo della collisione
-         double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, m_frMove.VersZ()) ;
-         if ( dDist < - EPS_SMALL)
-            return -1 ;
-        // se devo traslare il punto, c'è collisione
-         if ( dDist > EPS_SMALL) {
-            if ( dDist > 10 * EPS_SMALL) {
-               vVtTriaN.clear() ;
-               dTotDist += dDist ;
-               ptT += ( dDist - 5 * EPS_SMALL) * m_frMove.VersZ() ;
-            }
-            vVtTriaN.push_back( Tria.GetN()) ;
-         }
-      }
-   }
-
   return dTotDist ;
 }

@@ -816,7 +351,7 @@ CAvToolSurfTm::PrepareHashGrid( void)
  // pulisco HashGrid 2d
   m_HGrids.Clear() ;
  // verifico esistenza superfici
-   if ( m_vSTM.empty()  ||  m_vBaseInd.size() < m_vSTM.size() + 1)
+   if ( m_vSTM.size() == 0  ||  m_vBaseInd.size() < m_vSTM.size() + 1)
      return false ;
  // creo HashGrid 2d
   const int LIM_HG_TRIA = 256 ;
@@ -843,7 +378,7 @@ CAvToolSurfTm::PrepareHashGrid( void)

 //----------------------------------------------------------------------------
 int
-CAvToolSurfTm::GetSurfInd( int nT) const
+CAvToolSurfTm::GetSurfInd( int nT)
 {
  // verifico la presenza di almeno un intervallo
   if ( m_vBaseInd.size() < 2)
@@ -34,47 +34,22 @@ class CAvToolSurfTm : public ICAvToolSurfTm
                  { return m_Tool.GetRadius() ; }
      double GetToolHeight( void) const override
                  { return m_Tool.GetHeigth() ; }
-      double GetToolTipHeight( void) const override
-                  { return m_Tool.GetTipHeigth() ; } ;
-      double GetToolTipRadius( void) const override
-                  { return m_Tool.GetTipRadius() ; } ;
-      double GetToolCornRadius( void) const override
-                  { return m_Tool.GetCornRadius() ; } ;
-      CISURFTMPVECTOR GetvStm( void) const {
-                     CISURFTMPVECTOR vcStm ;
-                     for ( int i = 0 ; i < int( m_vSTM.size()) ; ++ i)
-                        vcStm.emplace_back( CloneSurfTriMesh( m_vSTM[i])) ;
-                     return vcStm ;
-                  }
      const ICurveComposite& GetToolOutline( bool bApprox = false) const override
                  { return ( bApprox ? m_Tool.GetApproxOutline() : m_Tool.GetOutline()) ;}
-
-      bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
-                         double& dTotDist, Vector3d* pvtTriaN = nullptr) const override ;
-      bool TestPositionAdv( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
-                            double& dTotDist, VCT3DVECTOR& vVtN) const override ;
-
-      bool TestSeries( PNTUVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff = 1) override ;
-      bool TestSeriesAdv( PNTUVVECTVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff = 1) override ;
-
-      bool TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol, double dProgCoeff = 1) override ;
+      bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist) override ;
+      bool TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol) override ;

   public :
      CAvToolSurfTm( void) ;
-      bool Clear( void) ;

   private :
-      bool   TestSubSeries( int nId, PNTUVECTOR& vPntM, const Vector3d& vtDir, int nFirst, int nLast, double dProgCoeff) ;
-      bool   TestSubSeriesAdv( int nId, PNTUVVECTVECTOR& vPntM, const Vector3d& vtDir, int nFirst, int nLast, double dProgCoeff) ;
-      bool   TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, double dLinTol, double dProgCoeff) ;
-      double MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, Vector3d& vtTriaN) const ;
-      double MyTestPositionAdv( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, VCT3DVECTOR& vVtTriaN) const ;
-      double MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir, Vector3d& vtTriaN) const ;
-      double MyTestPositionHGAdv( Point3d& ptT, const Vector3d& vtDir, VCT3DVECTOR& vVtTriaN) const ;
+      bool   TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, double dLinTol) ;
+      double MyTestPosition( Point3d& ptT, const Vector3d& vtDir) ;
+      double MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir) ;
      bool   MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPntMPrev, const PNTULIST::iterator& itPntMCurr,
-                               const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) const ;
+                               const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) ;
      bool   PrepareHashGrid( void) ;
-      int    GetSurfInd( int nT) const ;
+      int    GetSurfInd( int nT) ;

   private :
      typedef std::vector<const SurfTriMesh*>    CSURFTMPVECTOR ;   // vettore di puntatori a const SurfTriMesh
@@ -17,8 +17,8 @@
 #include "CAvToolTriangle.h"
 #include "IntersLineSurfStd.h"
 #include "IntersLineTria.h"
+#include "DistPointLine.h"
 #include "CDeUtility.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/ENkPolynomialRoots.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
@@ -2503,7 +2503,7 @@ DiskSegmentEscapeDistLongMot( const Point3d& ptDiskCen, double dDiskRad,
   double dSegDist = 0. ;
   for ( int nSol = 0 ; nSol < nRoot ; ++ nSol) {
     // Soluzione interna al segmento
-      if ( vdRoots[nSol] > 0.  &&  vdRoots[nSol] < dSegLen + EPS_ZERO) {
+      if ( vdRoots[nSol] > 0.  &&  vdRoots[nSol] < dSegLen) {
         Point3d ptC = ptSeg + vdRoots[nSol] * vtSeg ;
        // Distanza del punto soluzione dal piano del disco nella posizione iniziale
         double dCurDist = PointPlaneSignedDist( ptC, ptDiskCen, vtMove) ;
@@ -13,9 +13,9 @@

 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
+#include "DistPointLine.h"
 #include "CDeCylTria.h"
 #include "CDeConvexTorusTria.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkPolygon3d.h"

 using namespace std ;
@@ -12,10 +12,11 @@
 //----------------------------------------------------------------------------

 #include "stdafx.h"
+#include "DistLineLine.h"
 #include "CDeTriaTria.h"
-#include "/EgtDev/Include/EGkDistLineLine.h"
 #include "/EgtDev/Include/EGkIntersPlanePlane.h"
 #include <array>
+#include <algorithm>

 using namespace std ;

@@ -1,6 +1,6 @@
 #include "stdafx.h"
 #include "CDeUtility.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
 #include "/EgtDev/Include/ENkPolynomialRoots.h"

 using namespace std ;
@@ -2,7 +2,7 @@
 //  EgalTech 2013-2014
 //----------------------------------------------------------------------------
 // File : ChainCurves.cpp           Data : 20.07.14       Versione : 1.5g3
-// Contenuto : Implementazione della funzione ChainCurves, per creare una o più
+// Contenuto : Implementazione della funzione ChainCurves, per creare una o più
 //             curve composite a partire dalle curve date.
 //
 //
@@ -43,10 +43,10 @@ bool
 ChainCurves::AddCurve( int nId, const Point3d& ptStart, const Vector3d& vtStart,
                       const Point3d& ptEnd, const Vector3d& vtEnd)
 {
-  // verifico validità Id
+  // verifico validità Id
   if ( nId <= 0)
      return false ;
-  // verifico non sia già stata aggiunta la stessa entità
+  // verifico non sia già stata aggiunta la stessa entità
   if ( ! m_sCrvId.insert( nId).second)
      return true ;
  // inserisco i dati della curva nel vettore
@@ -68,7 +68,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
   m_bIsFork = false ;
   m_vFork.clear() ;

-  // recupero l'entità più vicina al punto di start
+  // recupero l'entità più vicina al punto di start
   int nStart ;
   INTVECTOR vStart ;
   if ( ! m_PointGrid.FindNearest( ptStart, vStart)  ||
@@ -82,7 +82,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
   // tolgo dal grid
   RemoveEntityFromGrid( nId) ;

-  // se devo fermarmi su biforcazione, verifico se sono già su vecchia biforcazione
+  // se devo fermarmi su biforcazione, verifico se sono già su vecchia biforcazione
   bool bSkip = false ;
   if ( bHaltOnFork) {
      auto iIter = GetForkPoint( m_vCrvData[nId].ptEnd) ;
@@ -93,7 +93,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
      }
   }

-  // concateno dopo la fine dell'entità di partenza
+  // concateno dopo la fine dell'entità di partenza
   INTVECTOR vIdsAfter ;
   bool bClosed = false ;
   if ( ! bSkip  &&  ! GetChainFromPoint( m_vCrvData[nId].ptEnd, m_vCrvData[nId].vtEnd,
@@ -102,7 +102,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
      return false ;
   }

-  // se devo fermarmi su biforcazione, verifico se sono già su vecchia biforcazione
+  // se devo fermarmi su biforcazione, verifico se sono già su vecchia biforcazione
   bool bRevSkip = false ;
   if ( bHaltOnFork) {
      auto iIter = GetForkPoint( m_vCrvData[nId].ptStart) ;
@@ -113,7 +113,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
      }
   }

-  // se non ho già chiuso l'anello, concateno prima dell'inizio dell'entità di partenza
+  // se non ho già chiuso l'anello, concateno prima dell'inizio dell'entità di partenza
   INTVECTOR vIdsBefore ;
   if ( ! bClosed) {
      bool bRevClosed ;
@@ -258,7 +258,7 @@ ChainCurves::RemoveEntityFromGrid( int nId)
 bool
 ChainCurves::ChooseStart( const Point3d& ptStart, const INTVECTOR& vStart, int& nStart)
 {
-  // numero di entità candidate
+  // numero di entità candidate
   int nSize = int( vStart.size()) ;

  // se nessuna, errore
@@ -273,7 +273,7 @@ ChainCurves::ChooseStart( const Point3d& ptStart, const INTVECTOR& vStart, int&

  // altrimenti, cerco la migliore
   int nI = - 1 ;
-   double dDistMin = INFINITO ;
+   double dSqDistMin = SQ_INFINITO ;
   for ( int i = 0 ; i < nSize ; ++ i) {
     // recupero indice e verso
      int nId = abs( vStart[i]) - 1 ;
@@ -281,12 +281,9 @@ ChainCurves::ChooseStart( const Point3d& ptStart, const INTVECTOR& vStart, int&
     // calcolo un punto vicino all'estremo lungo la tangente
      Point3d ptNear = ( bEquiv ? m_vCrvData[nId].ptStart + m_vCrvData[nId].vtStart :
                                  m_vCrvData[nId].ptEnd - m_vCrvData[nId].vtEnd) ;
-      double dDist = Dist( ptStart, ptNear) ;
-      // tengo il segmento più vicino al punto
-      // favorendo eventualmente quello equiverso se entro EPS da un concorrente
-      if ( dDist < dDistMin - EPS_SMALL  ||
-         ((dDist < dDistMin + EPS_SMALL)  &&  bEquiv  &&  vStart[nI] < 0)) {
-         dDistMin = dDist ;
+      double dSqDist = SqDist( ptStart, ptNear) ;
+      if ( dSqDist < dSqDistMin) {
+         dSqDistMin = dSqDist ;
         nI = i ;
      }
   }
@@ -305,7 +302,7 @@ bool
 ChainCurves::ChooseNext( const Point3d& ptCurr, const Vector3d& vtCurr, const INTVECTOR& vNext, bool bHaltOnFork, int& nNext)
 {
   INTVECTOR vMyNext = vNext ;
-  // scarto quelle entità che sono più vicine all'altro estremo del più vicino
+  // scarto quelle entità che sono più vicine all'altro estremo del più vicino
   int nM = -1 ;
   Point3d ptRef ;
   double dSqMinDist = m_dToler * m_dToler ;
@@ -322,19 +319,19 @@ ChainCurves::ChooseNext( const Point3d& ptCurr, const Vector3d& vtCurr, const IN
      }
   }
   for ( int i = 0 ; i < int( vMyNext.size()) ; ++ i) {
-     // salto l'entità più vicina
+     // salto l'entità più vicina
      if ( i == nM)
         continue ;
     // recupero indice e verso
      int nId = abs( vMyNext[i]) - 1 ;
      bool bEquiv = ( vMyNext[i] > 0) ;
-     // verifico se più vicino al più vicino
+     // verifico se più vicino al più vicino
      double dCurrSqDist = SqDist( ptCurr, ( bEquiv ? m_vCrvData[nId].ptStart : m_vCrvData[nId].ptEnd)) ;
      double dRefSqDist = SqDist( ptRef, ( bEquiv ? m_vCrvData[nId].ptStart : m_vCrvData[nId].ptEnd)) ;
      if ( dRefSqDist < dCurrSqDist)
         vMyNext[i] = 0 ;
   }
-  // cerco la direzione più vicina
+  // cerco la direzione più vicina
   int nI = -1 ;
   int nF = 0 ;
   INTVECTOR vFork ;
@@ -346,7 +343,7 @@ ChainCurves::ChooseNext( const Point3d& ptCurr, const Vector3d& vtCurr, const IN
     // recupero indice e verso
      int nId = abs( vMyNext[i]) - 1 ;
      bool bEquiv = ( vMyNext[i] > 0) ;
-     // incremento contatore indice entità tra cui scegliere
+     // incremento contatore indice entità tra cui scegliere
      ++ nF ;
      vFork.push_back( vMyNext[i]) ;
     // se vietata inversione, salto se controverso
@@ -390,7 +387,7 @@ bool
 ChainCurves::ChoosePrev( const Point3d& ptCurr, const Vector3d& vtCurr, const INTVECTOR& vPrev, bool bHaltOnFork, int& nPrev)
 {
   INTVECTOR vMyPrev = vPrev ;
-  // scarto quelle entità che sono più vicine all'altro estremo del più vicino
+  // scarto quelle entità che sono più vicine all'altro estremo del più vicino
   int nM = -1 ;
   Point3d ptRef ;
   double dSqMinDist = m_dToler * m_dToler ;
@@ -407,19 +404,19 @@ ChainCurves::ChoosePrev( const Point3d& ptCurr, const Vector3d& vtCurr, const IN
      }
   }
   for ( int i = 0 ; i < int( vMyPrev.size()) ; ++ i) {
-     // salto l'entità più vicina
+     // salto l'entità più vicina
      if ( i == nM)
         continue ;
     // recupero indice e verso
      int nId = abs( vMyPrev[i]) - 1 ;
      bool bEquiv = ( vMyPrev[i] < 0) ;
-     // verifico se più vicino al più vicino
+     // verifico se più vicino al più vicino
      double dCurrSqDist = SqDist( ptCurr, ( bEquiv ? m_vCrvData[nId].ptEnd : m_vCrvData[nId].ptStart)) ;
      double dRefSqDist = SqDist( ptRef, ( bEquiv ? m_vCrvData[nId].ptEnd : m_vCrvData[nId].ptStart)) ;
      if ( dRefSqDist < dCurrSqDist)
         vMyPrev[i] = 0 ;
   }
-  // cerco la direzione più vicina
+  // cerco la direzione più vicina
   int nI = - 1 ;
   int nF = 0 ;
   double dProScaMax = - 1.1 ; 
@@ -431,7 +428,7 @@ ChainCurves::ChoosePrev( const Point3d& ptCurr, const Vector3d& vtCurr, const IN
     // recupero indice e verso
      int nId = abs( vMyPrev[i]) - 1 ;
      bool bEquiv = ( vMyPrev[i] < 0) ;
-     // incremento contatore indice entità tra cui scegliere
+     // incremento contatore indice entità tra cui scegliere
      ++ nF ;
      vFork.push_back( vMyPrev[i]) ;
     // se vietata inversione, salto se controverso
@@ -16,8 +16,8 @@
 #include "CurveBezier.h"
 #include "CurveComposite.h"
 #include "CreateCurveAux.h"
+#include "DistPointLine.h"
 #include "GeoConst.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkCircleCenTgCurve.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
@@ -127,7 +127,7 @@ GetHSVFromColor( const Color& cCol)
   hsv.dSat = dDelta / dMax ;
   if ( cCol.GetRed() >= dMax)                                        // tra giallo e magenta
       hsv.dHue = ( cCol.GetGreen() - cCol.GetBlue()) / dDelta ;
-   else if ( cCol.GetGreen() >= dMax)                                  // tra ciano e giallo
+   else if( cCol.GetGreen() >= dMax)                                  // tra ciano e giallo
       hsv.dHue = 2.0 + ( cCol.GetBlue() - cCol.GetRed()) / dDelta ;
   else                                                               // tra magenta e ciano
       hsv.dHue = 4.0 + ( cCol.GetRed() - cCol.GetGreen()) / dDelta ;
@@ -398,7 +398,7 @@ CurveArc::Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bo
   if ( dLenA > ( dRad - EPS_ZERO))
      dLenH = 0 ;
   else
-      dLenH = sqrt( dRad * dRad - dLenA * dLenA) ;
+      dLenH= sqrt( dRad * dRad - dLenA * dLenA) ;
  // versore dal punto medio della corda al centro
   Vector3d vtH = vtA / dLenA ;
   vtH.Rotate( Z_AX, 0, ( bCCW ? 1 : -1)) ;
@@ -410,7 +410,6 @@ CurveArc::Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bo
   m_dRad = dRad ;
  // calcolo il versore di start
   m_VtS = ( ptStart - m_PtCen) / m_dRad ;
-   m_VtS.Normalize() ;
  // calcolo l'angolo al centro
   bool bDet ;
   if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, m_dAngCenDeg, bDet)  ||  ! bDet)
@@ -1294,7 +1293,7 @@ CurveArc::Invert( void)

 //----------------------------------------------------------------------------
 bool
-CurveArc::SimpleOffset( double dDist, int nType, double dMaxAngExt)
+CurveArc::SimpleOffset( double dDist, int nType)
 {
  // la curva deve essere validata
   if ( m_nStatus != OK)
@@ -1329,7 +1328,7 @@ CurveArc::SimpleOffset( double dDist, int nType, double dMaxAngExt)

 //----------------------------------------------------------------------------
 bool
-CurveArc::MyExtendedOffset( double dDist, bool bAll)
+CurveArc::MyExtendedOffset( double dDist, bool bAll, int nType)
 {
  // bAll == true fa accettare raggi nulli ==> da usare solo internamente 
  // quando si è sicuri di aumentare subito il raggio o di cancellare
@@ -116,7 +116,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
              { return ApproxWithArcs( dLinTol, dAngTolDeg, PA) ; }
      ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
      bool Invert( void) override ;
-      bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) override ;
+      bool SimpleOffset( double dDist, int nType = OFF_FILLET) override ;
      bool ModifyStart( const Point3d& ptNewStart) override ;
      bool ModifyEnd( const Point3d& ptNewEnd) override ;
      bool SetExtrusion( const Vector3d& vtExtr) override
@@ -178,8 +178,8 @@ class CurveArc : public ICurveArc, public IGeoObjRW
      bool ChangeDeltaN( double dNewDeltaN) override ;
      bool ChangeAngCenter( double dNewAngCenDeg) override ;
      bool ChangeStartPoint( double dU) override ;
-      bool ExtendedOffset( double dDist) override
-              { return MyExtendedOffset( dDist, false) ; }
+      bool ExtendedOffset( double dDist, int nType = OFF_FILLET) override
+              { return MyExtendedOffset( dDist, false, nType) ; }
      bool ToExplementary( void) override ;
      bool Flip( void) override ;

@@ -200,7 +200,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
                     { if ( ! CopyFrom( caSrc))
                          LOG_ERROR( GetEGkLogger(), "CurveArc : copy error")
                       return *this ; }
-      bool MyExtendedOffset( double dDist, bool bAll) ;
+      bool MyExtendedOffset( double dDist, bool bAll, int nType = OFF_FILLET) ;
      bool MyCalcPointParamPosiz( const Point3d& ptP, double& dU, int& nPos, double dLinTol) const ;
      Voronoi* GetVoronoiObject( void) const ;
      void ResetVoronoiObject( void) const ;
@@ -33,5 +33,4 @@ bool CurveGetArea( const ICurve& crvC, Plane3d& plPlane, double& dArea) ;
 bool CurveDump( const ICurve& crvC, std::string& sOut, bool bMM, const char* szNewLine) ;
 bool CopyExtrusion( const ICurve* pSouCrv, ICurve* pDestCrv) ;
 bool CopyThickness( const ICurve* pSouCrv, ICurve* pDestCrv) ;
-ICurveBezier* ApproxCurveBezierWithSingleCubic( const ICurve* pCrv) ;
 Voronoi* GetCurveVoronoi( const ICurve& crvC) ;
@@ -13,13 +13,13 @@

 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "CurveAux.h"
 #include "CurveBezier.h"
 #include "CurveComposite.h"
 #include "DistPointCrvBezier.h"
 #include "BiArcs.h"
 #include "GeoConst.h"
 #include "PolygonPlane.h"
+#include "DistPointLine.h"
 #include "GeoObjFactory.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
@@ -27,16 +27,12 @@
 #include "Bernstein.h"
 #include "deCasteljau.h"
 #include "Voronoi.h"
-#include "IntersLineLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
 #include "/EgtDev/Include/ENkPolynomial.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EGkGeoPoint3d.h"
-#include "/EgtDev/Include/EGkCurveLine.h"
 #include <array>

 using namespace std ;
@@ -93,11 +89,8 @@ CurveBezier::Init( int nDeg, bool bIsRational)
 bool
 CurveBezier::SetControlPoint( int nInd, const Point3d& ptCtrl)
 {
-  // verifico validità indice e punto
-   if ( m_nStatus != OK  ||  m_bRat  ||  nInd < 0  ||  nInd > m_nDeg  ||  ! ptCtrl.IsValid())
-      return false ;
-
-   if ( abs( ptCtrl.x) > INFINITO  ||  abs( ptCtrl.y) > INFINITO  ||  abs( ptCtrl.z) > INFINITO)
+  // verifico validità indice
+   if ( m_nStatus != OK  ||  m_bRat  ||  nInd < 0  ||  nInd > m_nDeg)
      return false ;

  // assegno il valore
@@ -126,11 +119,8 @@ CurveBezier::SetControlPoint( int nInd, const Point3d& ptCtrl, double dW)
   if ( m_nStatus != OK  ||  ! m_bRat  ||  nInd < 0  ||  nInd > m_nDeg)
      return false ;

-  // verifico che il punto sia valido e il peso non sia nullo o negativo
-   if ( ! ptCtrl.IsValid()  ||  dW < EPS_SMALL  ||  ! isfinite( dW)  ||  dW > INFINITO)
-      return false ;
-
-   if ( abs( ptCtrl.x) > INFINITO  ||  abs( ptCtrl.y) > INFINITO  ||  abs( ptCtrl.z) > INFINITO)
+  // verifico che il peso non sia nullo o negativo
+   if ( dW < EPS_SMALL)
      return false ;

  // assegno il valore e il peso
@@ -148,32 +138,6 @@ CurveBezier::SetControlPoint( int nInd, const Point3d& ptCtrl, double dW)
   return true ;
 }

-//----------------------------------------------------------------------------
-bool
-CurveBezier::SetControlWeight( int nInd, double dW)
-{
-   // verifico validità, razionalità e indice
-   if ( m_nStatus != OK  ||  ! m_bRat  ||  nInd < 0  ||  nInd > m_nDeg)
-      return false ;
-
-   // verifico che il peso non sia nullo o negativo
-   if ( dW < EPS_SMALL  ||  ! isfinite( dW)  ||  dW > INFINITO)
-      return false ;
-
-   // assegno il valore e il peso
-   m_vWeCtrl[nInd] = dW ;
-
-   // annullo analisi presenza singolarità
-   m_dParSing = - 2 ;
-
-   // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
-   // imposto ricalcolo della grafica
-   m_OGrMgr.Reset() ;
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 CurveBezier::FromArc( const ICurveArc& crArc)
@@ -231,35 +195,6 @@ CurveBezier::FromArc( const ICurveArc& crArc)
      SetControlPoint( 1, ptNew1, dW) ;
      SetControlPoint( 2, ptNew2, dW) ;
      SetControlPoint( 3, ptEnd, 1) ;
-
-   //// anziché usare una bezier cubica approssimo le eliche con più bezier quadratiche razionali.
-   //// più è grande l'angolo al centro dell'arco e maggiore sarà l'errore di approssimazione
-   //
-   //  // quadratica razionale
-   //  // peso del punto di controllo intermedio
-   //   double dW = dCosAhalf ;
-   //  // calcolo dei punti di controllo
-   //   Point3d  ptStart ;
-   //   crArc.GetStartPoint( ptStart) ;
-   //   Point3d  ptEnd ;
-   //   crArc.GetEndPoint( ptEnd) ;
-   //  // Point3d ptMed = Media( ptStart, ptEnd, 0.5) ;
-   //  //Vector3d vtDir = ptMed - crArc.GetCenter() ;
-   //  // Point3d ptNew = crArc.GetCenter() + vtDir / ( dCosAhalf * dCosAhalf) ;
-   //   Vector3d vtStart ; crArc.GetStartDir( vtStart) ;
-   //   Vector3d vtEnd ; crArc.GetEndDir( vtEnd) ;
-   //   PtrOwner<CurveLine> pCrvLine1( CreateBasicCurveLine()) ;
-   //   pCrvLine1->SetPVL( ptStart, vtStart, 10) ;
-   //   PtrOwner<CurveLine> pCrvLine2( CreateBasicCurveLine()) ;
-   //   pCrvLine2->SetPVL( ptEnd, vtEnd, 10) ;
-   //   IntersLineLine ill( *pCrvLine1, *pCrvLine2, false) ;
-   //   IntCrvCrvInfo iccInfo ; ill.GetIntCrvCrvInfo( iccInfo) ;
-   //   Point3d ptNew = 0.5 * (iccInfo.IciA->ptI + iccInfo.IciB->ptI) ;
-   //  // inserimento nella curva dei punti di controllo con i pesi
-   //   Init( 2, true) ;
-   //   SetControlPoint( 0, ptStart, 1) ;
-   //   SetControlPoint( 1, ptNew, dW) ;
-   //   SetControlPoint( 2, ptEnd, 1) ;
   }

  // copio estrusione e spessore
@@ -269,30 +204,6 @@ CurveBezier::FromArc( const ICurveArc& crArc)
   return true ;
 }

-//----------------------------------------------------------------------------
-bool
-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, 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, dWeight) ;
-      ++nCount ;
-   }
-   Point3d ptEnd ; crLine.GetEndPoint( ptEnd) ;
-   SetControlPoint( nCount, ptEnd, dWeight) ;
-   ++nCount ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 CurveBezier::IsAPoint( void) const
@@ -373,11 +284,8 @@ CurveBezier::CopyFrom( const CurveBezier& cbSrc)
 {
   if ( &cbSrc == this)
      return true ;
-   if ( ! cbSrc.IsValid())
-      return false ;
   if ( ! Init( cbSrc.m_nDeg, cbSrc.m_bRat))
      return false ;
-   m_dParSing = cbSrc.m_dParSing ;
   m_vPtCtrl = cbSrc.m_vPtCtrl ;
   if ( cbSrc.m_bRat)
      m_vWeCtrl = cbSrc.m_vWeCtrl ;
@@ -525,21 +433,21 @@ bool
 CurveBezier::Validate( void)
 {
   if ( m_nStatus == TO_VERIFY) {
-         for ( const auto& ptP : m_vPtCtrl) {
-            if ( ! ptP.IsValid()) {
-               m_nStatus = ERR ;
-               break ;
-            }
+      for ( const auto& ptP : m_vPtCtrl) {
+         if ( ! ptP.IsValid()) {
+            m_nStatus = ERR ;
+            break ;
         }
      }
+   }
   if ( m_nStatus == TO_VERIFY) {
-         for ( const auto& dWe : m_vWeCtrl) {
-            if ( ! isfinite( dWe)) {
-               m_nStatus = ERR ;
-               break ;
-            }
+      for ( const auto& dWe : m_vWeCtrl) {
+         if ( ! isfinite( dWe)) {
+            m_nStatus = ERR ;
+            break ;
         }
      }
+   }
   if ( m_nStatus == TO_VERIFY)
      m_nStatus = ( ( m_nDeg >= 1  &&  m_vPtCtrl.size() >= 2) ? OK : ERR) ;

@@ -1578,7 +1486,7 @@ CurveBezier::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAngTo
            return false ;
         vtDir.ToSpherical( nullptr, nullptr, &dDir1Deg) ;
        // costruisco un biarco sulla polilinea (secondo metodo di Z. Sir)
-         pCrv.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, PL, dMaxDist, dLinTol)) ;
+         pCrv.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, PL, dMaxDist)) ;
         if ( IsNull( pCrv))
            return false ;
      }
@@ -1666,10 +1574,6 @@ CurveBezier::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAngTo
 ICurve*
 CurveBezier::CopyParamRange( double dUStart, double dUEnd) const
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return nullptr ;
-
  // i parametri start ed end devono essere compresi nel dominio parametrico della curva
   if ( dUStart < - EPS_PARAM  ||  dUStart > 1 + EPS_PARAM  ||
        dUEnd < - EPS_PARAM  ||  dUEnd > 1 + EPS_PARAM)
@@ -1812,10 +1716,6 @@ CurveBezier::TrimEndAtParam( double dUTrim)
 bool
 CurveBezier::TrimStartEndAtParam( double dUStartTrim, double dUEndTrim)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
  // i parametri start ed end devono essere compresi nel dominio parametrico della curva
   if ( dUStartTrim < - EPS_PARAM  ||  dUStartTrim > 1 + EPS_PARAM  ||
        dUEndTrim < - EPS_PARAM  ||  dUEndTrim > 1 + EPS_PARAM)
@@ -1823,34 +1723,18 @@ CurveBezier::TrimStartEndAtParam( double dUStartTrim, double dUEndTrim)
  // verifico che i trim non cancellino interamente la curva
   if ( dUStartTrim > dUEndTrim - EPS_PARAM)
      return false ;
-   // se razionale devo trovare il punto di trim iniziale per ricalcolare il parametro di trim
-   Point3d ptStart ;
-   if ( m_bRat)
-      GetPointD1D2( dUStartTrim, ptStart) ;
  // trim finale
   if ( ! TrimEndAtParam( dUEndTrim))
      return false ;
  // trim iniziale con il parametro opportunamente ricalcolato
-   double dNewUStartTrim ;
-   if ( m_bRat)
-      GetParamAtPoint( ptStart, dNewUStartTrim) ;
-   else
-      dNewUStartTrim = dUStartTrim / dUEndTrim ;
-   //trim iniziale
-   if ( ! TrimStartAtParam( dNewUStartTrim))
-      return false ;
-
-   return true ;
+   double dNewUStartTrim = dUStartTrim / dUEndTrim ;
+   return TrimStartAtParam( dNewUStartTrim) ;
 }

 //----------------------------------------------------------------------------
 bool
 CurveBezier::TrimStartAtLen( double dLenTrim)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
  // lunghezze negative vengono considerate nulle
   dLenTrim = max( dLenTrim, 0.) ;

@@ -1860,20 +1744,13 @@ CurveBezier::TrimStartAtLen( double dLenTrim)
      return false ;

  // utilizzo il trim sui parametri
-   if ( ! TrimStartAtParam( dUTrim))
-      return false ;
-
-   return true ;
+   return TrimStartAtParam( dUTrim) ;
 }

 //----------------------------------------------------------------------------
 bool
 CurveBezier::TrimEndAtLen( double dLenTrim)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
  // lunghezze negative vengono considerate nulle
   dLenTrim = max( dLenTrim, 0.) ;

@@ -1883,20 +1760,13 @@ CurveBezier::TrimEndAtLen( double dLenTrim)
      return false ;

  // utilizzo il trim sui parametri
-   if ( ! TrimEndAtParam( dUTrim))
-      return false ;
-
-   return true ;
+   return TrimEndAtParam( dUTrim) ;
 }

 //----------------------------------------------------------------------------
 bool
 CurveBezier::ExtendStartByLen( double dLenExt)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
  // la lunghezza deve essere positiva
   if ( dLenExt < - EPS_ZERO)
      return false ;
@@ -1948,10 +1818,6 @@ CurveBezier::ExtendStartByLen( double dLenExt)
 bool
 CurveBezier::ExtendEndByLen( double dLenExt)
 {
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-
  // la lunghezza deve essere positiva
   if ( dLenExt < - EPS_ZERO)
      return false ;
@@ -2286,190 +2152,3 @@ CurveBezier::ResetVoronoiObject() const
      delete m_pVoronoiObj ;
   m_pVoronoiObj = nullptr ;
 }
-
-//----------------------------------------------------------------------------
-bool
-CurveBezier::MakeRational( void)
-{ 
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-   
-   if ( m_bRat)
-      return true ;
-   // creo il vettore dei pesi e li setto tutti a 1
-   m_vWeCtrl.assign( m_nDeg + 1, 1) ;
-   // aggiorno il flag rational
-   m_bRat = true ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CurveBezier::MakeRationalStandardForm( void)
-{ 
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-   
-   if ( ! m_bRat)
-      return false ;
-   double dW0 = m_vWeCtrl.front() ;
-   double dWn = m_vWeCtrl.back() ;
-   if ( dW0 > 1 - EPS_ZERO  &&  dWn > 1 - EPS_ZERO)
-      return true ;
-   if ( dW0 < EPS_ZERO  ||  dWn < EPS_ZERO)
-      return false ;
-
-  // formula del Farin
-   double dCoeff = pow( dW0 / dWn, 1. / m_nDeg) ;
-   for ( int i = 0 ; i < m_nDeg + 1 ; ++i)
-      m_vWeCtrl[i] *= Pow( dCoeff, i) / dW0 ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CurveBezier::MakeNonRational( double dTol)
-{
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-   
-   if ( ! m_bRat)
-      return true ;
-
-   // controllo se i pesi sono tutti == 1 allora è una finta razionale e mi basta fare una copia dei punti di controllo
-   bool bIsActualRat = false ;
-   for ( int i = 0 ; i < m_nDeg ; ++i) {
-      if ( abs( m_vWeCtrl[i] - 1) > EPS_SMALL) {
-         bIsActualRat = true ;
-         break ;
-      }
-   }
-
-   bool bOk = true ;
-   if ( ! bIsActualRat) {
-      // semplicemente tolgo il booleano della razionalità e i punti restano gli stessi
-      m_bRat = false ;
-   }
-   else {
-      // provo ad approssimare la curva di bezier con una controparte non razionale
-      int nDeg = m_nDeg ;
-      // se ho una curva razionale di grado 2 verifico se è un arco, in quel caso la converto in una curva di grado 3 non razionale con la funzione dedicata
-      if ( nDeg == 2  &&  m_bRat) {
-         // prendo due punti sulla curva e calcolo l'intersezione dei due assi dei segmenti formati da pt2-pt0 e pt3-pt1
-         Point3d pt0 ; GetStartPoint( pt0) ;
-         Point3d pt1 ; GetPointD1D2( 0.3, pt1) ;
-         Point3d pt2 ; GetPointD1D2( 0.6, pt2) ;
-         Point3d pt3 ; GetEndPoint( pt3) ;
-
-         Vector3d vtDir1 = pt2 - pt0 ;
-         Vector3d vtDir2 = pt3 - pt1 ;
-         Vector3d vtN = vtDir2 ^ vtDir1 ;
-
-         CurveLine cl1 ; cl1.Set( pt1, pt1 + (vtDir1 ^ vtN) * 5) ;
-         CurveLine cl2 ; cl1.Set( pt2, pt2 + (vtDir2 ^ vtN) * 5) ;
-         IntersLineLine ill( cl1, cl2, false) ;
-         IntCrvCrvInfo iccInfo ; ill.GetIntCrvCrvInfo( iccInfo) ;
-         Point3d ptCen = iccInfo.IciA[0].ptI ;
-         
-         // se sia l'inizio che la fine della curva distano uguale dal punto di intersezione tra i due assi trovati allora la curva è un arco di circonferenza
-         if ( abs(Dist( pt0, ptCen) - Dist( pt3, ptCen)) < EPS_SMALL) {
-            PtrOwner<ICurveBezier> pNew ( ApproxArcCurveBezierWithSingleCubic( this, ptCen, vtN)) ;
-
-            if ( IsNull( pNew)  ||  ! pNew->IsValid())
-               return false ;
-            Init( 3, false) ;
-            for ( int i = 0 ; i < 3 ; ++i)
-               SetControlPoint( i, pNew->GetControlPoint(i)) ;
-
-            return true ;
-         }
-      }
-
-      // punto di rientro in caso fallisca il primo tentativo
-      retry :
-         nDeg += 2 ;
-         PtrOwner<CurveBezier> pNewBez( CreateBasicCurveBezier()) ;
-         pNewBez->Init( nDeg, false) ;
-         PNTVECTOR vPntCtrl ;
-         PNTVECTOR vPntSampling ;
-         for ( int p = 0 ; p < nDeg + 1 ; ++p) {
-            Point3d pt ; GetPointD1D2( double( p) / nDeg, pt) ;
-            pNewBez->SetControlPoint( p, pt) ;
-            vPntCtrl.push_back( pt) ;
-         }
-         vPntSampling = vPntCtrl ;
-         int c = 0 ;
-         double dErr = INFINITO ;
-         while ( dErr > dTol  &&  c < 100) {
-            double dErrMax = 0 ;
-            // calcolo le differenze tra i punti di sampling sulla nuova curva e quelli sulla curva originale
-            for ( int p = 0 ; p < nDeg + 1 ; ++p) {
-               Point3d pt ; pNewBez->GetPointD1D2( double( p) / nDeg, pt) ;
-               Vector3d vDiff = vPntSampling[p] - pt ;
-               double dErrLoc = vDiff.Len() ;
-               if ( dErrLoc > dErrMax)
-                  dErrMax = dErrLoc ;
-               // aggiorno il vettore dei punti di controllo della nuova curva
-               vPntCtrl[p] += vDiff ;
-            }
-            dErr = dErrMax ;
-            // aggiorno i punti di controllo della nuova curva
-            for ( int i = 0 ; i < nDeg + 1 ; ++i)
-               pNewBez->SetControlPoint( i, vPntCtrl[i]) ;
-            ++c ;
-         }
-
-         // calcolo l'errore di approssimazione sulla curva
-         CalcApproxError( this, pNewBez, dErr) ;
-         bOk = dErr < dTol ;
-         if ( bOk) {
-            // aggiorno la curva di bezier originale con quella approssimata
-            Init( nDeg, false) ;
-            for ( int i = 0 ; i < nDeg + 1 ; ++i) {
-               SetControlPoint( i, pNewBez->GetControlPoint( i)) ;
-               SetControlWeight( i, pNewBez->GetControlWeight( i)) ;
-            }
-         }
-         else if ( nDeg < m_nDeg + 4)
-            goto retry ;
-   }
-
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CurveBezier::IsALine( void) const
-{
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return false ;
-   
-   Point3d ptStart ; GetStartPoint( ptStart) ;
-   Point3d ptEnd ; GetEndPoint( ptEnd) ;
-   for ( int i = 1 ; i < m_nDeg ; ++i) {
-      Point3d ptCtrl = GetControlPoint( i) ;
-      DistPointLine dpl( ptCtrl, ptStart, ptEnd) ;
-      double dDist = 0 ; dpl.GetDist( dDist) ;
-      if ( dDist > EPS_SMALL)
-         return false ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-PNTVECTOR
-CurveBezier::GetAllControlPoints( void) const
-{
-   PNTVECTOR vPntCtrl ;
-   // la curva deve essere valida
-   if ( m_nStatus != OK)
-      return vPntCtrl ;
-   
-   return m_vPtCtrl ;
-}
@@ -116,7 +116,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
              { return ApproxWithArcs( dLinTol, dAngTolDeg, PA) ; }
      ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
      bool Invert( void) override ;
-      bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) override
+      bool SimpleOffset( double dDist, int nType = OFF_FILLET) override
              { return false ; }  // l'offset di crvBezier non è crvBezier tranne in casi molto particolari
      bool ModifyStart( const Point3d& ptNewStart) override ;
      bool ModifyEnd( const Point3d& ptNewEnd) override ;
@@ -137,9 +137,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
      bool Init( int nDeg, bool bIsRational) override ;
      bool SetControlPoint( int nInd, const Point3d& ptCtrl) override ;
      bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) override ;
-      bool SetControlWeight( int nInd, double dW) override ;
      bool FromArc( const ICurveArc& crArc) override ;
-      bool FromLine( const ICurveLine& crLine) override ;
      int  GetDegree( void) const override
                { return m_nDeg ; }
      bool IsRational( void) const override
@@ -149,11 +147,6 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
      double GetControlWeight( int nInd, bool* pbOk = NULL) const override ;
      bool GetControlPolygonLength( double& dLen) const override ;
      int  GetSingularParam( double& dPar) const override ;
-      bool MakeRational( void) override ;
-      bool MakeRationalStandardForm( void) override ;
-      bool MakeNonRational( double dTol) override ;
-      bool IsALine( void) const override ;
-      PNTVECTOR GetAllControlPoints( void) const ;  // non aggiunta in interfaccia

   public :                      // IGeoObjRW
      int GetNgeId( void) const override ;
@@ -197,7 +190,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW

   private :
      enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
-      static const int MAXDEG = 21 ;
+      static const int MAXDEG = 11 ;

   private :
      ObjGraphicsMgr m_OGrMgr ;         // gestore grafica dell'oggetto
@@ -16,8 +16,8 @@
 #include "CurveComposite.h"
 #include "CalcDerivate.h"
 #include "BiArcs.h"
+#include "DistPointLine.h"
 #include "RemoveCurveDefects.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkCurveByApprox.h"
 #include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkPolyArc.h"
@@ -439,12 +439,12 @@ CurveByApprox::CalcSplitPoints( double dLinTol, double dAngTolDeg, double dLinFe
         m_vSplits.push_back(i) ;
         continue ;
      }
-     // verifico linearità del tratto precedente
+     // verifico linearità del tratto precedente
      bool bPrevLin = vtPrev.SqLen() > dSqLinFea  &&
                      ( m_vNextDer[i-1] * m_vPrevDer[i]) > dAngTolCos  &&
                      ( vtPrev ^ m_vNextDer[i-1]).SqLen() < dSqLinTol  &&
                      ( vtPrev ^ m_vPrevDer[i]).SqLen() < dSqLinTol ;
-     // verifico linearità del tratto successivo
+     // verifico linearità del tratto successivo
      bool bNextLin = vtNext.SqLen() > dSqLinFea  &&
                      ( m_vNextDer[i] * m_vPrevDer[i+1]) > dAngTolCos  &&
                      ( vtNext ^ m_vNextDer[i]).SqLen() < dSqLinTol  &&
@@ -483,7 +483,7 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
      PtrOwner<ICurve> pCrv ;
      double dMaxDist ;

-     // se la polilinea ha più di 2 punti
+     // se la polilinea ha più di 2 punti
      if ( PL.GetPointNbr() > 2)  {
        // calcolo punti e direzioni agli estremi della polilinea usando la curva di Bezier
         int nI ;
@@ -501,12 +501,11 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
         ptP1 = m_vPnt[nI] ;
         m_vPrevDer[nI].ToSpherical( nullptr, nullptr, &dDir1Deg) ;
        // costruisco un biarco sulla polilinea (secondo metodo di Z. Sir)
-         pCrv.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, PL, dMaxDist, dLinTol)) ;
-        // forzo la spezzatura della curva
+         pCrv.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, PL, dMaxDist)) ;
         if ( IsNull( pCrv))
-            dMaxDist = 2 * dLinTol ;
+            return false ;
      }
-     // se la polilinea è formata da 2 punti
+     // se la polilinea è formata da 2 punti
      else if ( PL.GetPointNbr() == 2) {
        // se molto vicini, esco
         double dLen ;
@@ -525,15 +524,13 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng

     // se raggiunto il massimo livello di recursione, forzo l'accettazione del biarco
      if ( nLev >= MAX_LEV) {
-         if ( IsNull( pCrv))
-            return false ;
         dMaxDist = 0 ;
        // segnalo situazione per debug
         if ( GetEGkDebugLev() >= 5)
            LOG_DBG_ERR( GetEGkLogger(), "ERROR : Exceeded recursions")
      }

-     // se lunghezza abbastanza piccola, forzo l'accettazione della curva
+     // se lunghezza abbastanza picccola, forzo l'accettazione della curva
      double dLen ;
      if ( PL.GetApproxLength( dLen)  &&  dLen < 10 * EPS_SMALL)
         dMaxDist = 0 ;
@@ -564,7 +561,7 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
      return false ;
   }

-  // spezzo l'intervallo in due parti a metà
+  // spezzo l'intervallo in due parti a metà
   double dParStart, dParEnd ;
   if ( ! PL.GetFirstU( dParStart)  ||  ! PL.GetLastU( dParEnd))
      return false ;
@@ -572,9 +569,9 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
   PolyLine PL2 ;
   if ( ! PL.Split( dParMid, PL2))
      return false ;
-  // prima metà
+  // prima metà
   if ( ! BiArcOrSplit( nLev + 1, PL, dLinTol, dAngTolDeg, PA))
      return false ;
-  // seconda metà
+  // seconda metà
   return BiArcOrSplit( nLev + 1, PL2, dLinTol, dAngTolDeg, PA) ;
 }
@@ -55,7 +55,7 @@ CurveByInterp::GetCurve( int nMethod, int nType)
      if ( ! CalcBesselTangents())
         return nullptr ;
   }
-   else if ( nType != CUBIC_BEZIERS_LONG) {
+   else {
      if ( ! CalcAkimaTangents( nMethod == AKIMA_CORNER))
         return nullptr ;
   }
@@ -103,16 +103,6 @@ CurveByInterp::GetCurve( int nMethod, int nType)
      return ::Release( pCrvCompo) ;
   }

-   // se richieste curve di Bezier cubiche (ottenute da interpolazione con Nurbs)
-   if ( nType == CUBIC_BEZIERS_LONG) {
-       // creo la curva composita
-       PtrOwner<ICurve> pCrv ;
-       pCrv.Set( InterpolatePointSetWithBezier( m_vPnt, 50 * EPS_SMALL, 50)) ;
-       if ( IsNull(pCrv)  ||  ! pCrv->IsValid())
-          return nullptr ;
-       return Release( pCrv) ;
-   }
-
   return nullptr ;
 }

@@ -14,6 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CurveComposite.h"
+#include "DistPointLine.h"
 #include "DistPointCrvComposite.h"
 #include "CurveLine.h"
 #include "CurveArc.h"
@@ -26,7 +27,6 @@
 #include "NgeWriter.h"
 #include "NgeReader.h"
 #include "Voronoi.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkCurveByApprox.h"
 #include "/EgtDev/Include/EGkArcSpecial.h"
 #include "/EgtDev/Include/EGkSfrCreate.h"
@@ -192,7 +192,7 @@ CurveComposite::AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart, double dLinT
      return false ;

  // verifico lo stato
-   if ( m_nStatus != OK  &&  ! ( m_CrvSmplS.empty()  &&  ( m_nStatus == TO_VERIFY  ||  m_nStatus == IS_A_POINT)))
+   if ( m_nStatus != OK  &&  ! ( m_CrvSmplS.empty()  &&  m_nStatus == TO_VERIFY))
      return false ;

  // controllo la tolleranza
@@ -224,11 +224,8 @@ CurveComposite::AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart, double dLinT
              // lunghezza della curva originale
               double dOldLen ; pCrv->GetLength( dOldLen) ;
              // eseguo modifica
-               if ( ! pCrv->ModifyStart( ptEnd)) {
-                  CurveLine crvLine ;
-                  if ( ! crvLine.Set( ptEnd, ptCrvEnd)  ||  ! pCrv.Set( crvLine.Clone()))
-                     return false ;
-               }
+               if ( ! pCrv->ModifyStart( ptEnd))
+                  return false ;
              // verifico che la lunghezza non sia variata troppo
               double dNewLen ; pCrv->GetLength( dNewLen) ;
               if ( abs( dNewLen - dOldLen) > 10 * dLinTol)
@@ -249,11 +246,8 @@ CurveComposite::AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart, double dLinT
              // lunghezza della curva originale
               double dOldLen ; pCrv->GetLength( dOldLen) ;
              // eseguo modifica
-               if ( ! pCrv->ModifyEnd( ptStart)) {
-                  CurveLine crvLine ;
-                  if ( ! crvLine.Set( ptCrvStart, ptStart)  ||  ! pCrv.Set( crvLine.Clone()))
-                     return false ;
-               }
+               if ( ! pCrv->ModifyEnd( ptStart))
+                  return false ;
              // verifico che la lunghezza non sia variata troppo
               double dNewLen ; pCrv->GetLength( dNewLen) ;
               if ( abs( dNewLen - dOldLen) > 10 * dLinTol)
@@ -297,15 +291,9 @@ CurveComposite::Close( void)
      return true ;
  // se molto vicini li modifico
   if ( AreSamePointEpsilon( ptStart, ptEnd, 10 * EPS_SMALL)) {
-     // se un solo arco
-      if ( m_CrvSmplS.size() == 1  &&  m_CrvSmplS.front()->GetType() == CRV_ARC) {
-         CurveArc* pArc = GetBasicCurveArc( m_CrvSmplS.front()) ;
-         return pArc->ChangeAngCenter( pArc->GetAngCenter() > 0 ? ANG_FULL : -ANG_FULL) ;
-      }
-     // caso generale
      Point3d ptMid = Media( ptStart, ptEnd) ;
-      if ( ! m_CrvSmplS.front()->ModifyStart( ptMid)  ||
-           ! m_CrvSmplS.back()->ModifyEnd( ptMid))
+      if ( ! ModifyStart( ptMid)  ||
+           ! ModifyEnd( ptMid))
         return false ;
   }   
  // altrimenti aggiungo la linea di chiusura
@@ -381,10 +369,9 @@ CurveComposite::FromPolyLine( const PolyLine& PL)
      return false ;

  // ciclo di inserimento dei segmenti che uniscono i punti
-   double dParIni, dParFin ;
   Point3d ptIni, ptFin ;
-   PL.GetFirstUPoint( &dParIni, &ptIni) ;
-   while ( PL.GetNextUPoint( &dParFin, &ptFin)) {
+   PL.GetFirstPoint( ptIni) ;
+   while ( PL.GetNextPoint( ptFin)) {
     // se i punti della coppia coincidono, passo alla coppia successiva
      if ( AreSamePointApprox( ptIni, ptFin))
         continue ;
@@ -395,14 +382,10 @@ CurveComposite::FromPolyLine( const PolyLine& PL)
     // assegno i punti estremi
      if ( ! pCrvLine->Set( ptIni, ptFin))
         return false ;
-     // assegno i parametri degli estremi
-      pCrvLine->SetTempParam( dParIni, 0) ;
-      pCrvLine->SetTempParam( dParFin, 1) ;
     // aggiungo la retta alla curva composita
      if ( ! AddSimpleCurve( Release( pCrvLine)))
         return false ;
     // aggiorno dati prossimo punto iniziale
-      dParIni = dParFin ;
      ptIni = ptFin ;
   }

@@ -615,10 +598,6 @@ CurveComposite::CopyFrom( const CurveComposite& ccSrc)
      if ( ! AddCurve( *pCrv))
         return false ;
   }
-   if ( ccSrc.m_nStatus == IS_A_POINT) {
-      m_ptStart = ccSrc.m_ptStart ;
-      m_nStatus = IS_A_POINT ;
-   }
   return true ;
 }

@@ -677,7 +656,7 @@ CurveComposite::Dump( string& sOut, bool bMM, const char* szNewLine) const
   while ( pCrvSmpl != nullptr  &&  i < MAX_CRV) {
     // assegno ed emetto nome e tipo della curva semplice
      sOut += "#" + ToString( i) + " " + pCrvSmpl->GetTitle() + szNewLine ;
-     // dati della curva semplice
+     // salvataggio della curva semplice
      if ( ! pCrvSmpl->Dump( sOut, bMM, szNewLine))
         return false ;
     // passo alla successiva
@@ -766,7 +745,7 @@ CurveComposite::Load( NgeReader& ngeIn)
      ICurve* pCrv = ::GetCurve( pGeoO) ;
      bOk = bOk && ( pCrv != nullptr  &&  pCrv->IsSimple()) ;
     // aggiungo questa curva (sicuramente semplice)
-      bOk = bOk && AddSimpleCurve( pCrv, true, 10 * EPS_SMALL) ;
+      bOk = bOk && AddSimpleCurve( pCrv) ;
     // se errore 
     if ( ! bOk)
         return false ;
@@ -889,32 +868,20 @@ CurveComposite::Validate( void)

 //----------------------------------------------------------------------------
 bool
-CurveComposite::TestClosure( double dLinTol)
+CurveComposite::TestClosure( void)
 {
-  // se non valida o vuota, esco subito
-   if ( m_nStatus != OK  ||  m_CrvSmplS.empty())
-      return true ;
-  // se non è chiusa entro la tolleranza, esco subito
-   Point3d ptStart, ptEnd ;
-   if ( ! m_CrvSmplS.front()->GetStartPoint( ptStart)  ||
-        ! m_CrvSmplS.back()->GetEndPoint( ptEnd)  ||
-        ! AreSamePointEpsilon( ptStart, ptEnd, dLinTol))
-      return true ;
-  // se singola retta, esco subito
-   if ( m_CrvSmplS.size() == 1  &&  m_CrvSmplS.front()->GetType() == CRV_LINE)
+  // se non è chiusa, esco subito
+   if ( ! IsClosed())
      return true ;
  // verifico ed eventualmente aggiusto coincidenza punti estremi
+   Point3d ptStart ; m_CrvSmplS.front()->GetStartPoint( ptStart) ;
+   Point3d ptEnd ; m_CrvSmplS.back()->GetEndPoint( ptEnd) ;
   // se distanza superiore al limite ridotto forzo i punti a coincidere
   if ( ! AreSamePointEpsilon( ptStart, ptEnd, EPS_CONNECT)) {
-     // se un solo arco
-      if ( m_CrvSmplS.size() == 1  &&  m_CrvSmplS.front()->GetType() == CRV_ARC) {
-         CurveArc* pArc = GetBasicCurveArc( m_CrvSmplS.front()) ;
-         return pArc->ChangeAngCenter( pArc->GetAngCenter() > 0 ? ANG_FULL : -ANG_FULL) ;
-      }
-     // caso generale
      Point3d ptM = Media( ptStart, ptEnd) ;
-      return ( m_CrvSmplS.front()->ModifyStart( ptM)  &&
-               m_CrvSmplS.back()->ModifyEnd( ptM)) ;
+      if ( ! m_CrvSmplS.front()->ModifyStart( ptM)  ||
+           ! m_CrvSmplS.back()->ModifyEnd( ptM))
+         return false ;
   }
   return true ;
 }
@@ -970,8 +937,6 @@ CurveComposite::IsFlat( Plane3d& plPlane, bool bUseExtrusion, double dToler) con
                  return false ;
            }
         } break ;
-      default :
-         return false ;
     }
   }
  // recupero dati sulla planarità della polilinea
@@ -1714,7 +1679,7 @@ CurveComposite::Invert( void)

 //----------------------------------------------------------------------------
 bool
-CurveComposite::SimpleOffset( double dDist, int nType, double dMaxAngExt)
+CurveComposite::SimpleOffset( double dDist, int nType)
 {
  // se distanza di offset nulla, non devo fare alcunché
   if ( abs( dDist) < EPS_SMALL)
@@ -1736,7 +1701,7 @@ CurveComposite::SimpleOffset( double dDist, int nType, double dMaxAngExt)
   }

  // eseguo l'offset nel piano XY
-   bool bOk = SimpleOffsetXY( dDist, nType, dMaxAngExt) ;
+   bool bOk = SimpleOffsetXY( dDist, nType) ;

  // riporto la curva nel riferimento originale
   if ( bNeedRef)
@@ -1796,11 +1761,10 @@ bool
 CurveComposite::AddPoint( const Point3d& ptStart)
 {
  // verifico lo stato
-   if ( m_nStatus != TO_VERIFY  &&  m_nStatus != IS_A_POINT)
+   if ( m_nStatus != TO_VERIFY)
      return false ;
-  // assegno il punto e setto lo stato
+  // assegno il punto
   m_ptStart = ptStart ;
-   m_nStatus = IS_A_POINT ;

   return true ;
 }
@@ -1844,7 +1808,7 @@ bool
 CurveComposite::AddLine( const Point3d& ptNew, bool bEndOrStart)
 {
  // verifico lo stato
-   if ( m_nStatus != OK  &&  m_nStatus != IS_A_POINT)
+   if ( m_nStatus != OK  &&  m_nStatus != TO_VERIFY)
      return false ;
  // costruisco la linea
   PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
@@ -3008,7 +2972,7 @@ CurveComposite::RemoveFirstOrLastCurve( bool bLast)
         m_CrvSmplS.pop_front() ;
      }
     // eseguo mini verifica
-      m_nStatus = ( ! m_CrvSmplS.empty() ? OK : TO_VERIFY) ;
+      m_nStatus = ( m_CrvSmplS.size() > 0 ? OK : TO_VERIFY) ;
     // assegno estrusione e spessore della curva composita
      pCrv->SetExtrusion( m_VtExtr) ;
      pCrv->SetThickness( m_dThick) ;
@@ -3053,7 +3017,7 @@ CurveComposite::ArcsToBezierCurves( void)
     // se arco, devo trasformare in una o più curve di Bezier
      if ( (*Iter)->GetType() == CRV_ARC) {
        // eseguo trasformazione
-         PtrOwner<ICurve> pNewCrv( ArcToBezierCurve( GetCurveArc( *Iter))) ;
+         PtrOwner<ICurve> pNewCrv( ArcToBezierCurve( (*Iter))) ;
         if ( IsNull( pNewCrv))
            return false ;
        // se risultato è singola curva
@@ -3187,26 +3151,11 @@ MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTol, double dCosAn
  // se precedente molto corta
   double dLenP ;
   if ( pCrvP->GetLength( dLenP)  &&  dLenP < dCurrLinTol) {
-     // se abbastanza allineata alla successiva
+     // se abbastanza allineata alla successiva 
      Vector3d vtDirP, vtDirC ;
      if ( pCrvP->GetEndDir( vtDirP)  &&  pCrvC->GetStartDir( vtDirC)  &&  ( vtDirP * vtDirC) >= dCosAngTol) {
-         bool bModifStart = ( pCrvC->GetType() != CRV_ARC) ;
-         if ( ! bModifStart) {
-           /* nel caso in cui la curva corrente sia un arco, bisogna controllare che la somma tra
-              l'angolo al centro e l'angolo sotteso dalla curva precedente non superi l'angolo giro; in 
-              caso positivo, la modifica del punto inziale dell'arco ( curva corrente) rimoverebbe
-              tutti gli angoli superiori a 360deg [curve a ricciolo per regioni non svuotate in Pocketing] */
-            Point3d ptS ; pCrvP->GetStartPoint( ptS) ;
-            Point3d ptE ; pCrvC->GetStartPoint( ptE) ;
-            const ICurveArc* pArcC = GetBasicCurveArc( pCrvC) ;
-            double dAngRef = ( Dist( ptS, ptE) / pArcC->GetRadius()) * RADTODEG ;
-            bModifStart = ( abs( pArcC->GetAngCenter()) + dAngRef < ANG_FULL - 10 * EPS_ANG_SMALL) ;
-
-         }
-         if ( bModifStart) {
-            Point3d ptStart ;
-            return ( pCrvP->GetStartPoint( ptStart)  &&  pCrvC->ModifyStart( ptStart) ? -1 : 0) ;
-         }
+         Point3d ptStart ;
+         return ( pCrvP->GetStartPoint( ptStart)  &&  pCrvC->ModifyStart( ptStart) ? -1 : 0) ;
      }
   }
  // se corrente molto corta
@@ -3215,24 +3164,10 @@ MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTol, double dCosAn
     // se abbastanza allineata alla precedente 
      Vector3d vtDirP, vtDirC ;
      if ( pCrvP->GetEndDir( vtDirP)  &&  pCrvC->GetStartDir( vtDirC)  &&  ( vtDirP * vtDirC) >= dCosAngTol) {
-         bool bModifEnd = ( pCrvP->GetType() != CRV_ARC) ;
-         if ( ! bModifEnd) {
-           /* nel caso in cui la curva predecente sia un arco, bisogna controllare che la somma tra
-              l'angolo al centro e l'angolo sotteso dalla curva corrente non superi l'angolo giro; in 
-              caso positivo, la modifica del punto finale dell'arco ( curva precedente) rimoverebbe
-              tutti gli angoli superiori a 360deg [curve a ricciolo per regioni non svuotate in Pocketing] */
-            Point3d ptS ; pCrvP->GetEndPoint( ptS) ;
-            Point3d ptE ; pCrvC->GetEndPoint( ptE) ;
-            const CurveArc* pArcP = GetBasicCurveArc( pCrvP) ;
-            double dAngRef = ( Dist( ptS, ptE) / pArcP->GetRadius()) * RADTODEG ;
-            bModifEnd = ( abs( pArcP->GetAngCenter()) + dAngRef < ANG_FULL - 10. * EPS_ANG_SMALL) ;
-         }
-         if ( bModifEnd) {
-            Point3d ptEnd ;
-            return ( pCrvC->GetEndPoint( ptEnd)  &&  pCrvP->ModifyEnd( ptEnd) ? 1 : 0) ;
-         }
+         Point3d ptEnd ;
+         return ( pCrvC->GetEndPoint( ptEnd)  &&  pCrvP->ModifyEnd( ptEnd) ? 1 : 0) ;
      }
-   }
+   }  
  // coefficiente deduzione tolleranza
   const double COEFF_TOL = 0.7 ;
  // se entrambe rette
@@ -3287,69 +3222,61 @@ MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTol, double dCosAn
     // verifico di non superare l'angolo giro al centro
      if ( abs( pArcP->GetAngCenter() + pArcC->GetAngCenter()) > ANG_FULL + EPS_ANG_SMALL)
         return 0 ;
-     // verifico se archi piatti
-      bool bPlaneArcs = pArcP->IsPlane()  &&  pArcC->IsPlane() ;
-     // se archi non piatti verifico coincidenza pendenza sulla normale
-      if ( ! bPlaneArcs) {        
-         double dN = pArcP->GetNormVersor() * pArcC->GetNormVersor() ;
-         if ( abs(( pArcC->GetDeltaN() * pArcP->GetAngCenter() - dN * pArcP->GetDeltaN() * pArcC->GetAngCenter()) /
-            ( pArcP->GetAngCenter() + pArcC->GetAngCenter())) > dCurrLinTol)
-            return 0 ;
-      }
-
-     // se calcolo nuovo arco ok, procedo con l'unione
-      Point3d ptP1 ;
-      pArcP->GetStartPoint( ptP1) ;
-      Point3d ptP2 ;
-      pArcP->GetEndPoint( ptP2) ;
-      Point3d ptP3 ;
-      pArcC->GetEndPoint( ptP3) ;
-
-     // se archi non piani costruisco arco sul piano definito dalla normale e dal punto di partenza del primo arco
-      Frame3d frRef ;
-      if ( ! frRef.Set( ptP1, pArcP->GetNormVersor()))
-         return 0 ;
-      if ( ! bPlaneArcs) {
-         ptP1.Scale( frRef, 1, 1, 0) ;
-         ptP2.Scale( frRef, 1, 1, 0) ;
-         ptP3.Scale( frRef, 1, 1, 0) ;
-         ptC1Fin.Scale( frRef, 1, 1, 0) ;
-      }
-
-     // verifico se circonferenza completa
-      bool bCirc = ( AreSamePointEpsilon( ptP1, ptP3, dCurrLinTol)) ;
-      if ( bCirc) {
-         pArcC->GetMidPoint( ptP3) ;
-         if ( ! bPlaneArcs)
-            ptP3.Scale( frRef, 1, 1, 0) ;
-      }
-         
-      CurveArc NewArc ;
-      if ( NewArc.Set3P( ptP1, ptP2, ptP3, bCirc)) {
-        // se vicino a circonferenza arco per 3 punti potrebbe non dare il risultato desiderato quindi faccio controllo su raggio e centro
-         if ( Dist( NewArc.GetCenter(), ptC1Fin) > 2 * dCurrLinTol  ||  abs( NewArc.GetRadius() - pArcP->GetRadius()) > 2 * dCurrLinTol)
-            return 0 ;
-
-        // verifico normale al piano dell'arco
-         if ( NewArc.GetNormVersor() * pArcC->GetNormVersor() < 0)
-            NewArc.InvertN() ;
-        // se archi non piani ripristino il deltaN
-         if ( ! bPlaneArcs) {
-            double dDeltaN1 = pArcP->GetDeltaN() ;
-            double dDeltaN2 = pArcC->GetDeltaN() ;
-            NewArc.ChangeDeltaN( dDeltaN1 + dDeltaN2) ;
+     // se archi piatti
+      if ( pArcP->IsPlane()  &&  pArcC->IsPlane()) {
+        // se calcolo nuovo arco ok, procedo con l'unione
+         Point3d ptP1 ;
+         pArcP->GetStartPoint( ptP1) ;
+         Point3d ptP2 ;
+         pArcP->GetEndPoint( ptP2) ;
+         Point3d ptP3 ;
+         pArcC->GetEndPoint( ptP3) ;
+         // verifico se circonferenza completa
+         bool bCirc = ( AreSamePointApprox( ptP1, ptP3)) ;
+         if ( bCirc)
+            pArcC->GetMidPoint( ptP3) ;
+         CurveArc NewArc ;
+         if ( NewArc.Set3P( ptP1, ptP2, ptP3, bCirc)) {
+           // verifico normale al piano dell'arco
+            if ( NewArc.GetNormVersor() * pArcC->GetNormVersor() < 0)
+               NewArc.InvertN() ;
+           // se curve originali con la stessa proprietà, la riporto
+            if ( nTpr0P == nTpr0C)
+               NewArc.SetTempProp( nTpr0C, 0) ;
+            if ( nTpr1P == nTpr1C)
+               NewArc.SetTempProp( nTpr1C, 1) ;
+           // aggiorno l'arco corrente e torno flag modifica
+            *pArcC = NewArc ;
+            return -1 ;
         }
-        // se curve originali con la stessa proprietà, la riporto
-         if ( nTpr0P == nTpr0C)
-            NewArc.SetTempProp( nTpr0C, 0) ;
-         if ( nTpr1P == nTpr1C)
-            NewArc.SetTempProp( nTpr1C, 1) ;
-        // aggiorno l'arco corrente e torno flag modifica
-         *pArcC = NewArc ;
-         return -1 ;
+         else
+            return 0 ;
+      }
+     // verifico coincidenza pendenza sulla normale
+      double dN = pArcP->GetNormVersor() * pArcC->GetNormVersor() ;
+      if ( abs(( pArcC->GetDeltaN() * pArcP->GetAngCenter() - dN * pArcP->GetDeltaN() * pArcC->GetAngCenter()) /
+                ( pArcP->GetAngCenter() + pArcC->GetAngCenter())) < dCurrLinTol) {
+        // se calcolo nuovo arco ok, procedo con l'unione
+         Point3d ptP1 ;
+         pArcP->GetStartPoint( ptP1) ;
+         Vector3d vtDir1 ;
+         pArcP->GetStartDir( vtDir1) ;
+         Point3d ptP3 ;
+         pArcC->GetEndPoint( ptP3) ;
+         CurveArc NewArc ;
+         if ( NewArc.Set2PVN( ptP1, ptP3, vtDir1, pArcC->GetNormVersor())) {
+           // se curve originali con la stessa proprietà, la riporto
+            if ( nTpr0P == nTpr0C)
+               NewArc.SetTempProp( nTpr0C, 0) ;
+            if ( nTpr1P == nTpr1C)
+               NewArc.SetTempProp( nTpr1C, 1) ;
+           // aggiorno l'arco corrente e torno flag modifica
+            *pArcC = NewArc ;
+            return -1 ;
+         }
+         else
+            return 0 ;
      }
-      else
-         return 0 ;
   }

  // nessuna fusione
@@ -3847,6 +3774,19 @@ CurveComposite::ResetVoronoiObject() const
   m_pVoronoiObj = nullptr ;
 }

+//----------------------------------------------------------------------------
+bool
+CurveComposite::FromPoint(Point3d& ptStart)
+{
+  // verifico lo stato
+   if ( m_nStatus != TO_VERIFY)
+      return false ;
+  // assegno il punto e setto lo stato
+   m_ptStart = ptStart ;
+   m_nStatus = IS_A_POINT ;
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 CurveComposite::GetOnlyPoint(Point3d& ptStart) const 
@@ -113,7 +113,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
      bool ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) const override ;
      ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
      bool Invert( void) override ;
-      bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) override ;
+      bool SimpleOffset( double dDist, int nType = OFF_FILLET) override ;
      bool ModifyStart( const Point3d& ptNewStart) override ;
      bool ModifyEnd( const Point3d& ptNewEnd) override ;
      bool SetExtrusion( const Vector3d& vtExtr) override
@@ -177,7 +177,8 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
      bool GetCurveTempProp( int nCrv, int& nProp, int nPropInd = 0) const override ;
      bool SetCurveTempParam( int nCrv, double dParam, int nParamInd = 0) override ;
      bool GetCurveTempParam( int nCrv, double& dParam, int nParamInd = 0) const override ;
-      bool GetOnlyPoint( Point3d& ptStart) const override ;
+      bool FromPoint( Point3d& ptStart) override ;        // funzione per settare la curva ad un unico punto
+      bool GetOnlyPoint( Point3d& ptStart) const override ;  // funzione per recuperare l'unico punto da cui è composta la curva ( degenere)
      
   public :                      // IGeoObjRW
      int GetNgeId( void) const override ;
@@ -198,17 +199,17 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
                       return *this ; }
      bool RelocateFrom( CurveComposite& ccSrc) ;
      bool GetApproxLength( double& dLen) const ;
-      bool TestClosure( double dLinTol = EPS_SMALL) ;
      Voronoi* GetVoronoiObject( void) const ;
      void ResetVoronoiObject( void) const ;

   private :
      bool CopyFrom( const CurveComposite& ccSrc) ;
      bool Validate( void) ;
+      bool TestClosure( void) ;
      bool AddCurveByRelocate( CurveComposite& ccSrc, bool bEndOrStart = true, double dLinTol = EPS_SMALL) ;
      bool AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart = true, double dLinTol = EPS_SMALL) ;
      bool GetIndSCurveAndLocPar( double dU, Side nS, int& nSCrv, double& dLocU) const ;
-      bool SimpleOffsetXY( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) ;
+      bool SimpleOffsetXY( double dDist, int nType = OFF_FILLET) ;
      bool IsOneCircle( Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const ;      
      bool CalcVoronoiObject( void) const ;

@@ -19,7 +19,6 @@
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkIntersCurves.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"

 using namespace std ;
@@ -31,14 +30,14 @@ static const int TP_IS_VERT_LINE = 1 ;
 static bool IsVerticalLine( const ICurve* pCrv, double* pdLenZ) ;
 static bool VerifyAndAdjustSamePoint( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAux) ;
 static bool VerifyAndAdjustInternalAngle( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAux) ;
-static bool VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nType, double dMaxAngExt,
+static bool VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nType,
                                          CurveComposite& ccAux) ;
 static bool AddFirstLastVerticalLines( CurveComposite& ccOffs, double dLenVertFirst, double dLenVertLast) ;
 static bool MediaInternalAngleDeltaZ( CurveComposite& ccOffs) ;

 //----------------------------------------------------------------------------
 bool
-CurveComposite::SimpleOffsetXY( double dDist, int nType, double dMaxAngExt)
+CurveComposite::SimpleOffsetXY( double dDist, int nType)
 {
  // creo una copia formata solo da rette e archi che giacciono nel piano XY (VtExtr è Z+)
   CurveComposite ccCopy ;
@@ -99,7 +98,7 @@ CurveComposite::SimpleOffsetXY( double dDist, int nType, double dMaxAngExt)
      CurveComposite ccTemp ;
      if ( VerifyAndAdjustSamePoint( pCrvPrev, pCrv2, ccTemp)  ||
           VerifyAndAdjustInternalAngle( pCrvPrev, pCrv2, ccTemp)  ||
-           VerifyAndAdjustExternalAngle( pCrvPrev, pCrv2, dDist, nType, dMaxAngExt, ccTemp)) {
+           VerifyAndAdjustExternalAngle( pCrvPrev, pCrv2, dDist, nType, ccTemp)) {
         if ( ccTemp.GetCurveCount() > 0  &&  ! ccOffs.AddCurveByRelocate( ccTemp))
            return false ;
      }
@@ -123,7 +122,7 @@ CurveComposite::SimpleOffsetXY( double dDist, int nType, double dMaxAngExt)
      CurveComposite ccTemp ;
      if ( VerifyAndAdjustSamePoint( pCrvPrev, pCrvNext, ccTemp)  ||
           VerifyAndAdjustInternalAngle( pCrvPrev, pCrvNext, ccTemp)  ||
-           VerifyAndAdjustExternalAngle( pCrvPrev, pCrvNext, dDist, nType, dMaxAngExt, ccTemp)) {
+           VerifyAndAdjustExternalAngle( pCrvPrev, pCrvNext, dDist, nType, ccTemp)) {
         int nCrvCount = ccTemp.GetCurveCount() ;
         if ( nCrvCount > 0  &&  ! ccOffs.AddCurveByRelocate( ccTemp))
            return false ;
@@ -175,7 +174,7 @@ bool
 VerifyAndAdjustSamePoint( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAux)
 {
  // verifica dei puntatori
-   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr)
+   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr  ||  &ccAux == nullptr)
      return false ;

  // pulisco la curva ausiliaria
@@ -219,7 +218,7 @@ bool
 VerifyAndAdjustInternalAngle( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAux)
 {
  // verifica dei puntatori
-   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr)
+   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr  ||  &ccAux == nullptr)
      return false ;

  // pulisco la curva ausiliaria
@@ -260,11 +259,11 @@ VerifyAndAdjustInternalAngle( ICurve* pCrv1, ICurve* pCrv2, CurveComposite& ccAu

 //----------------------------------------------------------------------------
 bool
-VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nType, double dMaxAngExt,
+VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nType,
                              CurveComposite& ccAux)
 {
  // verifica dei puntatori
-   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr)
+   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr  ||  &ccAux == nullptr)
      return false ;

  // pulisco la curva ausiliaria
@@ -273,9 +272,6 @@ VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nT
  // elimino dal tipo le parti estranee all'angolo esterno
   nType &= ( ICurve::OFF_FILLET | ICurve::OFF_CHAMFER | ICurve::OFF_EXTEND) ;

-  // porto il massimo angolo per tipo Extend in limiti accettabili (90° - 150°)
-   dMaxAngExt = Clamp( dMaxAngExt, ANG_RIGHT, 1.667 * ANG_RIGHT) ;
-
  // calcolo direzioni tangenti sull'estremo in comune
   Vector3d vtDir1, vtDir2 ;
   if ( ! pCrv1->GetEndDir( vtDir1)  ||  ! pCrv2->GetStartDir( vtDir2))
@@ -323,8 +319,8 @@ VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dDist, int nT
          ( dDist > 0  &&  dAngDeg < 0)))
      return false ;

-  // se l'angolo esterno supera il limite, offset extend diventa offset chamfer
-   if ( nType == ICurve::OFF_EXTEND  &&  abs( dAngDeg) > dMaxAngExt + EPS_ANG_SMALL)
+  // se l'angolo esterno supera il retto, offset extend diventa offset chamfer
+   if ( nType == ICurve::OFF_EXTEND  &&  abs( dAngDeg) > ANG_RIGHT + EPS_ANG_SMALL)
      nType = ICurve::OFF_CHAMFER ;

  // se angolo esterno molto piccolo, semplifico tutto
@@ -14,11 +14,11 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CurveLine.h"
+#include "DistPointLine.h"
 #include "GeoObjFactory.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
 #include "Voronoi.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
@@ -577,7 +577,7 @@ CurveLine::Invert( void)

 //----------------------------------------------------------------------------
 bool
-CurveLine::SimpleOffset( double dDist, int nType, double dMaxAngExt)
+CurveLine::SimpleOffset( double dDist, int nType)
 {
  // verifico lo stato
   if ( m_nStatus != OK)
@@ -117,7 +117,7 @@ class CurveLine : public ICurveLine, public IGeoObjRW
              { return ApproxWithArcs( dLinTol, dAngTolDeg, PA) ; }
      ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
      bool Invert( void) override ;
-      bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) override ;
+      bool SimpleOffset( double dDist, int nType = OFF_FILLET) override ;
      bool ModifyStart( const Point3d& ptNewStart) override ;
      bool ModifyEnd( const Point3d& ptNewEnd) override ;
      bool SetExtrusion( const Vector3d& vtExtr) override
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2022
 //----------------------------------------------------------------------------
-// File : DistLineLine.cpp      Data : 10.05.24         Versione : 2.6e3
+// File : DistLineLine.h      Data : 12.08.22         Versione : 2.4h1
 // Contenuto : Implementazione della classe distanza fra elementi lineari.
 //
 //
@@ -12,10 +12,11 @@
 //----------------------------------------------------------------------------

 #include "stdafx.h"
-#include "/EgtDev/Include/EGkDistLineLine.h"
+#include "DistLineLine.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
 #include "/EgtDev/Include/EGkGeoConst.h"
+#include <algorithm>

 using namespace std ;

@@ -0,0 +1,53 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2020-2020
+//----------------------------------------------------------------------------
+// File : DistLineLine.h      Data : 06.11.20         Versione : 2.2k1
+// Contenuto : Dichiarazione della classe distanza fra elementi lineari.
+//
+//
+//
+// Modifiche : 06.11.20 LM Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkVector3d.h"
+#include "/EgtDev/Include/EGkPoint3d.h"
+
+//----------------------------------------------------------------------------
+class DistLineLine
+{
+   public :
+      DistLineLine( const Point3d& ptSt1, const Point3d& ptEn1,
+                    const Point3d& ptSt2, const Point3d& ptEn2,
+                    bool bIsSegment1 = true, bool bIsSegment2 = true) ;
+      DistLineLine( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
+                    const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
+                    bool bIsSegment1 = true, bool bIsSegment2 = true) ;
+
+   public :
+      bool GetSqDist( double& dSqDist) const ;
+      bool GetDist( double& dDist) const ;
+      bool IsEpsilon( double dTol) const
+              { double dSqDist ; return ( GetSqDist( dSqDist)  &&  ( dSqDist < SQ_EPS_ZERO  ||  dSqDist < dTol * dTol)) ; }
+      bool IsSmall( void) const
+              { return IsEpsilon( EPS_SMALL) ; }
+      bool IsZero( void) const
+              { return IsEpsilon( EPS_ZERO) ;  }
+      bool GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2) const ;
+      bool GetPositionsAtMinDistPoints( double& dPos1, double& dPos2) const ;
+
+   private :
+      void Calculate( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
+                      const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
+                      bool bIsSegment1, bool bIsSegment2) ;
+   private:
+      double  m_dSqDist ;
+      mutable double  m_dDist ;
+      double  m_dPos1 ;
+      double  m_dPos2 ;
+      Point3d m_ptMinDist1 ;
+      Point3d m_ptMinDist2 ;
+} ;
@@ -14,9 +14,9 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "DllMain.h"
-#include "GeoConst.h"
 #include "DistPointCrvAux.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
+#include "GeoConst.h"


 //----------------------------------------------------------------------------
@@ -50,7 +50,7 @@ DistPointCrvComposite::DistPointCrvComposite( const Point3d& ptP, const ICurveCo
      }
     // altrimenti, per curve successive
      else {
-        // verifico se la distanza minima dal box è superiore al minimo già trovato
+        // verifico se la distanza minima dal box è superiore al minimo già trovato
         BBox3d b3B ;
         if ( pCrvSmpl->GetLocalBBox( b3B)  &&
              b3B.SqDistFromPoint( ptP) <= m_dDist * m_dDist) {
@@ -105,7 +105,7 @@ DistPointCrvComposite::DistPointCrvComposite( const Point3d& ptP, const ICurveCo
                  ++ i ;
               }
            }
-           // con minima distanza più bassa
+           // con minima distanza più bassa
            else if ( dCurrDist < m_dDist) {
              // aggiorno i minimi
               m_dDist = dCurrDist ;
@@ -13,10 +13,10 @@

 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
+#include "DistPointLine.h"
 #include "DistPointArc.h"
 #include "DistPointCrvBezier.h"
 #include "DistPointCrvComposite.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"


@@ -47,8 +47,6 @@ DistPointCurve::DistPointCurve( const Point3d& ptP, const ICurve& Curve, bool bI
   case CRV_COMPO :
      CrvCompositeCalculate( ptP, Curve) ;
      break ;
-   default :
-      break ;
   }
  // salvo il punto
   m_ptP = ptP ;
@@ -152,7 +150,7 @@ DistPointCurve::GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFl
      }
   }

-  // cerco punto discreto più vicino (anche estremi di zone continue)
+  // cerco punto discreto più vicino (anche estremi di zone continue)
   double dParam ;
   for ( int i = 0 ; i < (int) m_Info.size() ; ++ i) {
      if ( i == 0  ||
@@ -197,7 +195,7 @@ DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int&
      }
   }

-  // cerco punto discreto più vicino (anche estremi di zone continue)
+  // cerco punto discreto più vicino (anche estremi di zone continue)
   for ( int i = 0 ; i < (int) m_Info.size() ; ++ i) {
      if ( i == 0  ||
           abs( m_Info[i].dPar - dNearParam) < abs( dParam - dNearParam)) {
@@ -232,20 +230,9 @@ DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide
   Vector3d vtTg = 0.5 * ( vtPreTg + vtPostTg) ;
  // se tangenti opposte, si deve ricalcolare spostandosi un poco
   if ( ! vtTg.Normalize()) {
-      double dDeltaU = 1000 * EPS_PARAM ;    
-      double dParPre = m_Info[nInd].dPar - dDeltaU ;
-      double dParPost = m_Info[nInd].dPar + dDeltaU ;
-     // verifico se il parametro deve essere modificato per adattarsi a curva chiusa
-      if ( m_pCurve->IsClosed()) {
-         double dParS, dParE ;
-         m_pCurve->GetDomain( dParS, dParE) ;
-         if ( dParPre < dParS)
-            dParPre = dParE - dDeltaU ;
-         if ( dParPost > dParE)
-            dParPost = dParS + dDeltaU ;      
-      }
-      if ( ! m_pCurve->GetPointTang( dParPre, ICurve::FROM_MINUS, ptQ, vtPreTg)  ||
-           ! m_pCurve->GetPointTang( dParPost, ICurve::FROM_PLUS, ptQ, vtPostTg))
+      double dDeltaU = 1000 * EPS_PARAM ;
+      if ( ! m_pCurve->GetPointTang( m_Info[nInd].dPar - dDeltaU, ICurve::FROM_MINUS, ptQ, vtPreTg)  ||
+           ! m_pCurve->GetPointTang( m_Info[nInd].dPar + dDeltaU, ICurve::FROM_PLUS, ptQ, vtPostTg))
         return false ;
      vtTg = 0.5 * ( vtPreTg + vtPostTg) ;
      if ( ! vtTg.Normalize( EPS_ZERO))
@@ -275,7 +262,7 @@ DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, i
   if ( m_dDist < 0  ||  m_Info.empty())
      return false ;

-  // cerco punto discreto più vicino (anche estremi di zone continue)
+  // cerco punto discreto più vicino (anche estremi di zone continue)
   int nInd ;
   double dParam ;
   for ( int i = 0 ; i < (int) m_Info.size() ; ++ i) {
@@ -1,19 +1,19 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2024
+//  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : DistPointLine.cpp       Data : 20.05.24          Versione : 2.6e5
+// File : DistPointLine.cpp       Data : 17.12.13          Versione : 1.4l1
 // Contenuto : Implementazione della classe distanza punto da linea/segmento.
 //
 //
 //
 // Modifiche : 17.12.13 DS Creazione modulo.
-//             20.05.24 DS Reso pubblico in Include.
+//
 //
 //----------------------------------------------------------------------------

 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"


 //----------------------------------------------------------------------------
@@ -0,0 +1,58 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2013-2014
+//----------------------------------------------------------------------------
+// File : DistPointLine.h      Data : 02.01.14          Versione : 1.5a1
+// Contenuto : Dichiarazione della classe distanza punto da linea/segmento.
+//
+//
+//
+// Modifiche : 30.12.12 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkPoint3d.h"
+#include "/EgtDev/Include/EGkCurveLine.h"
+
+
+//-----------------------------------------------------------------------------
+class DistPointLine
+{
+   friend class DistPointCurve ;
+
+   public :
+      DistPointLine( const Point3d& ptP,
+                     const ICurveLine& crvLine, bool bIsSegment = true) ;
+      DistPointLine( const Point3d& ptP,
+                     const Point3d& ptIni, const Point3d& ptFin, bool bIsSegment = true) ;
+      DistPointLine( const Point3d& ptP,
+                     const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment = true) ;
+
+   public :
+      bool GetSqDist( double& dSqDist) const ;
+      bool GetDist( double& dDist) const ;
+      bool IsEpsilon( double dTol) const
+              { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
+      bool IsSmall( void) const
+              { return IsEpsilon( EPS_SMALL) ; }
+      bool IsZero( void) const
+              { return IsEpsilon( EPS_ZERO) ; }
+      int  GetNbrMinDist( void) const
+              { return (( m_dSqDist < 0) ? 0 : 1) ; }
+      bool GetMinDistPoint( Point3d& ptMinDist) const ;
+      bool GetParamAtMinDistPoint( double& dParam) const ;
+
+   private :
+      DistPointLine( void) ;
+      void Calculate( const Point3d& ptP,
+                      const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment) ;
+
+   private :
+      double  m_dSqDist ;
+      mutable double  m_dDist ;
+      double  m_dParam ;
+      Point3d m_ptMinDist ;
+} ;
+
@@ -1,119 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025
-//----------------------------------------------------------------------------
-// File : DistPointSurfBz.cpp     Data : 29.10.25        Versione : 2.7j3
-// Contenuto : Implementazione della classe distanza Punto da superficie Bezier.
-//
-//
-//
-// Modifiche : 29.10.25 DB Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#include "stdafx.h"
-#include "SurfTriMesh.h"
-#include "SurfBezier.h"
-#include "/EgtDev/Include/EGkDistPointTria.h"
-#include "/EgtDev/Include/EGkDistPointSurfTm.h"
-#include "/EgtDev/Include/EGkDistPointSurfBz.h"
-#include "/EgtDev/Include/EGkIntersLineTria.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-DistPointSurfBz::DistPointSurfBz( const Point3d& ptP, const ISurfBezier& pSrfBz)
-   : m_dDist( -1), m_bIsInside( false)
-{
-  // Bezier non valida 
-   if ( &pSrfBz == nullptr  ||  ! pSrfBz.IsValid())
-      return ;
-  // Calcolo la distanza
-   Calculate( ptP, pSrfBz) ;
-}
-
-//----------------------------------------------------------------------------
-void 
-DistPointSurfBz::Calculate( const Point3d& ptP, const ISurfBezier& srfBz)
-{
-  // Inizializzo distanza non calcolata
-   m_dDist = - 1. ;
-
-  // Controllo se la superficie è chiusa
-   m_bIsSurfClosed = srfBz.IsClosed() ;
-
-  // Lavoro con l'oggetto superficie trimesh di base
-   const ISurfTriMesh* pStmRef = srfBz.GetAuxSurfRefined() ;
-   if ( pStmRef == nullptr)
-      return ;
-
-   DistPointSurfTm dpst( ptP, *pStmRef) ;
-
-  //recupero il punto a distanza minima sulla trimesh e lo raffino, prima di restituire distanza e punto minimo
-   Point3d ptMinTm ; dpst.GetMinDistPoint( ptMinTm) ;
-   int nT ; dpst.GetMinDistTriaIndex( nT) ;
-  //salvo il punto corrispondente nel parametrico
-   srfBz.UnprojectPointFromStm( nT, ptMinTm, m_ptParam)  ;
-  // salvo il punto a minima distanza sulla superficie e la normale alla superficie in quel punto
-   srfBz.GetPointNrmD1D2( m_ptParam.x, m_ptParam.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, m_ptMinDistPoint, m_vtN)  ;
-
-  // salvo la distanza minima
-   m_dDist = Dist( ptP, m_ptMinDistPoint) ;
-  // se il punto è sulla superficie
-   if ( m_dDist < EPS_SMALL) {
-      m_bIsInside = false ;
-      return ;
-   }
-   else {
-      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * m_vtN < - EPS_SMALL) ;
-      return ;
-   }
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfBz::GetDist( double& dDist) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   dDist = m_dDist ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-DistPointSurfBz::GetMinDistPoint( Point3d& ptMinDistPoint) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   ptMinDistPoint = m_ptMinDistPoint ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-DistPointSurfBz::GetParamPoint( Point3d& ptParamPoint) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   ptParamPoint = m_ptParam ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-DistPointSurfBz::GetNorm( Vector3d& vtN) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   vtN = m_vtN ;
-   return true ;
-}
@@ -1,156 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2018-2020
-//----------------------------------------------------------------------------
-// File : DistPointSurfTm.cpp     Data : 19.12.20        Versione : 2.2l3
-// Contenuto : Implementazione della classe distanza Punto da Trimesh.
-//
-//
-//
-// Modifiche : 07.12.18 LM Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#include "stdafx.h"
-#include "SurfFlatRegion.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
-#include "/EgtDev/Include/EGkDistPointSurfFr.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-DistPointSurfFr::DistPointSurfFr( const Point3d& ptP, const ISurfFlatRegion& frSurf)
-   : m_dDist( -1)
-{
-  // FlatRegion non valida 
-   if ( &frSurf == nullptr  ||  ! frSurf.IsValid())
-      return ;
-  // Calcolo la distanza
-   Calculate( ptP, frSurf) ;
-}
-
-//----------------------------------------------------------------------------
-void 
-DistPointSurfFr::Calculate( const Point3d& ptP, const ISurfFlatRegion& frSurf)
-{
-  // Inizializzo distanza non calcolata
-   m_dDist = -1 ;
-
-  // Converto regione in classe base
-   const SurfFlatRegion* pSfr = GetBasicSurfFlatRegion( &frSurf) ;
-   if ( pSfr == nullptr)
-      return ;
-
-  // ciclo sulle parti della regione
-   for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; nC ++) {
-      // ciclo sui loop della parte di regione
-      for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; nL ++) {
-         PtrOwner<ICurve> pLoop( pSfr->GetLoop( nC, nL)) ;
-         if ( IsNull( pLoop)) {
-            m_dDist = -1 ;
-            return ;
-         }
-         DistPointCurve DPL( ptP, *pLoop) ;
-         double dDist ;
-         if ( DPL.GetDist( dDist)  &&  ( m_dDist < -EPS_SMALL  ||  dDist < m_dDist)) {
-            m_dDist = dDist ;
-            int nFlag ;
-            m_nMinChunk = nC ;
-            m_nMinLoop = nL ;
-            DPL.GetParamAtMinDistPoint( 0, m_dMinPar, nFlag) ;
-            DPL.GetMinDistPoint( 0, m_ptMinDistPoint, nFlag) ;
-            DPL.GetSideAtMinDistPoint( 0, pSfr->GetNormVersor(), m_nSide) ;
-         } 
-      }
-   }
-  // se trovata, aggiorno minima distanza sul piano
-   if ( m_dDist > - EPS_SMALL) {
-      Point3d ptOn = ptP - ( ptP - pSfr->GetPlanePoint()) * pSfr->GetNormVersor() * pSfr->GetNormVersor() ;
-      m_dDistOnPlane = min( Dist( ptOn, m_ptMinDistPoint), m_dDist) ;
-   }
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetDist( double& dDist) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   dDist = m_dDist ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetDistOnRegionPlane( double& dDist) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   dDist = m_dDistOnPlane ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetPointAtMinDist( Point3d& ptMinDist) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   ptMinDist = m_ptMinDistPoint ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetParamAtMinDist( int& nMinChunk, int& nMinLoop, double& dMinPar) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   nMinChunk = m_nMinChunk ;
-   nMinLoop = m_nMinLoop ;
-   dMinPar = m_dMinPar ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetSideAtMinDist( int& nSide) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   nSide = m_nSide ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IsPointInsideSurfFr( const Point3d& ptP, const ISurfFlatRegion* pSfr, double dMinDist, bool& bInside, int& nChunk)
-{
-  // default non include
-   bInside = false ;
-   nChunk = -1 ;
-  // verifica regione
-   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
-      return false ;
-  // verifico se la proiezione del punto sul piano della regione sta nel suo box
-   Point3d ptOn = ptP - ( ptP - pSfr->GetPlanePoint()) * pSfr->GetNormVersor() * pSfr->GetNormVersor() ;
-   BBox3d b3Box ;
-   pSfr->GetLocalBBox( b3Box) ;
-   b3Box.Expand( dMinDist) ;
-   if ( ! b3Box.Encloses( ptOn))
-      return true ;
-  // determino dove sta il punto
-   DistPointSurfFr DPR( ptP, *pSfr) ;
-   double dDist ; int nMinCh, nMinL; double dMinPar ; int nSide ;
-   if ( DPR.GetDistOnRegionPlane( dDist)  &&  DPR.GetParamAtMinDist( nMinCh, nMinL, dMinPar)  &&  DPR.GetSideAtMinDist( nSide)) {
-      if ( abs( dMinDist) < EPS_SMALL)
-         bInside = ( nSide != PRS_OUT) ;
-      else if ( dMinDist < 0)
-         bInside = ( nSide == PRS_IN  &&  dDist > abs( dMinDist) - EPS_SMALL) ;
-      else
-         bInside = ( nSide != PRS_OUT  ||  dDist < dMinDist + EPS_SMALL) ;
-      if ( bInside)
-         nChunk = nMinCh ;
-   }
-   return true ;
-}
@@ -15,16 +15,15 @@
 #include "SurfTriMesh.h"
 #include "/EgtDev/Include/EGkDistPointTria.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
-#include "/EgtDev/Include/EGkIntersLineTria.h"

 using namespace std ;

 //----------------------------------------------------------------------------
 // Calcola la differenza fra i bounding-box A e B.
-// L'insieme differenza non è un bounding-box, ma è esprimibile come unione di al più sei bounding-box.
+// L'insieme differenza non è un bounding-box, ma è esprimibile come unione di al più sei bounding-box.
 // Se l'insieme differenza fra i box non ha misura nulla viene restituito true, false altrimenti.
-// I casi in cui non vengono trovati box di misura positiva sono quelli in cui o il box A è contenuto
-// nel box B; uno di questi si verifica se il box A è vuoto.
+// I casi in cui non vengono trovati box di misura positiva sono quelli in cui o il box A è contenuto
+// nel box B; uno di questi si verifica se il box A è vuoto.
 // Nel vettore vBoxDiff vengono restituiti i box la cui unione costituisce la differenza fra A e B.
 static bool 
 BoundingBoxDifference( const BBox3d& boxA, const BBox3d& boxB, BOXVECTOR& vBoxDiff) 
@@ -34,7 +33,7 @@ BoundingBoxDifference( const BBox3d& boxA, const BBox3d& boxB, BOXVECTOR& vBoxDi
  // Se box A vuoto, risultato vuoto
   if ( boxA.IsEmpty())
      return false ;
-  // Se box B vuoto o i box non si intersecano, risultato è ancora A
+  // Se box B vuoto o i box non si intersecano, risultato è ancora A
   BBox3d boxInt ;
   if ( boxB.IsSmall()  ||  ! boxA.FindIntersection( boxB, boxInt)) {
      vBoxDiff.emplace_back( boxA) ;
@@ -94,10 +93,6 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
 {
  // Inizializzo distanza non calcolata
   m_dDist = - 1. ;
-  // Vettore di indici dei triangoli più vicini inizialmente vuoto
-   m_vnMinDistTriaIndex.clear() ;
-  // Controllo se la superficie è chiusa
-   m_bIsSurfClosed = tmSurf.IsClosed() ;

  // Lavoro con l'oggetto superficie trimesh di base
   const SurfTriMesh* pStm = GetBasicSurfTriMesh( &tmSurf) ;
@@ -109,8 +104,8 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
   if ( b3Stm.IsEmpty())
      return ;

-  // Cerco triangoli in box centrati sul punto dato di ampiezza crescente ed escludendo le parti già verificate.
-  // Termino quando non trovo più triangoli che possano soddisfare la richiesta. 
+  // Cerco triangoli in box centrati sul punto dato di ampiezza crescente ed escludendo le parti già verificate.
+  // Termino quando non trovo più triangoli che possano soddisfare la richiesta. 
   Point3d ptMin, ptMax ; b3Stm.GetMinMax( ptMin, ptMax) ;
   double dDeltaLen = max( min( min( b3Stm.GetDimX(), b3Stm.GetDimY()), b3Stm.GetDimZ()) / 40., 20.) ;
   double dBoxHalfLenX = max( max( ptMin.x - ptP.x, ptP.x - ptMax.x), 0.) + dDeltaLen ;
@@ -120,17 +115,14 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
   BBox3d boxPPrev( ptP) ;
   BBox3d boxP( ptP, dBoxHalfLenX, dBoxHalfLenY, dBoxHalfLenZ) ;
  // Variabili distanza minima, indice del triangolo di distanza minima, punto di distanza minima 
-   double dMinDist = DBL_MAX ;
+   double dMinSqDist = DBL_MAX ;
   int nMinDistTriaIndex = SVT_NULL ;
   Point3d ptMinDistPoint ;
-  // Finché non si verifica la condizione di terminazione ingrandisco il box.
+  // Finché non si verifica la condizione di terminazione ingrandisco il box.
   pStm->ResetTempInts() ;
   bool bContinue = true ;
-
-  // creazione del vettore dei triangoli più vicini a ptP
-   vector<pair<int, Triangle3d>> vTria ; // <indice triangolo, Triangolo>
   while ( bContinue) {
-     // Calcolo il box differenza con il precedente per non esplorare parti già considerate
+     // Calcolo il box differenza con il precedente per non esplorare parti già considerate
      BOXVECTOR vBox ;
      BoundingBoxDifference( boxP, boxPPrev, vBox) ;
     // Ciclo sui box differenza
@@ -138,12 +130,12 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
      for ( const auto& b3Box : vBox) {
        // interseco il box con quello della superficie e ne verifico la distanza minima dal punto
         BBox3d b3Int ;
-         if ( ! b3Box.FindIntersection( b3Stm, b3Int)  ||  b3Int.DistFromPoint( ptP) > dMinDist)
+         if ( ! b3Box.FindIntersection( b3Stm, b3Int)  ||  b3Int.SqDistFromPoint( ptP) > dMinSqDist)
            continue ;
        // ricerca sui triangoli nel box
         bCollide = true ;
-         INTVECTOR vnIds ;
-         if ( pStm->GetAllTriaOverlapBox( b3Int, vnIds)) {
+         INTVECTOR vnIds ; 
+         if ( pStm->GetAllTriaOverlapBox( b3Int, vnIds)) { 
           // Ciclo sui triangoli del sotto-box corrente
            for ( auto nT : vnIds) {
               int nTriaTemp ;
@@ -151,30 +143,19 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
               if ( pStm->GetTempInt( nT, nTriaTemp)  &&  nTriaTemp == 0  &&  pStm->GetTriangle( nT, trCurTria)) {
                  pStm->SetTempInt( nT, 1) ;
                  DistPointTriangle distPT( ptP, trCurTria) ;
-                  double dCurrDist ;
-                 // Se la distanza del triangolo è valida e minore di quella attuale aggiorno
-                  if ( distPT.GetDist( dCurrDist)) {
-                    // se distanze uguali...
-                     if ( abs( dCurrDist - dMinDist) < EPS_SMALL)
-                       // aggiungo il triangolo
-                        vTria.emplace_back( make_pair( nT, trCurTria)) ;
-                    // se minore...
-                     else if ( dCurrDist < dMinDist) {
-                        // pulisco il vettore
-                        vTria.clear() ;
-                        dMinDist = dCurrDist ;
-                        nMinDistTriaIndex = nT ;
-                        distPT.GetMinDistPoint( ptMinDistPoint) ;
-                       // aggiungo il triangolo
-                        vTria.emplace_back( make_pair( nT, trCurTria)) ;
-                     }
+                  double dCurSqDist ;
+                 // Se la distanza del triangolo è valida e minore di quella attuale aggiorno 
+                  if ( distPT.GetSqDist( dCurSqDist)  &&  dCurSqDist < dMinSqDist) {
+                     dMinSqDist = dCurSqDist ;
+                     nMinDistTriaIndex = nT ;
+                     distPT.GetMinDistPoint( ptMinDistPoint) ;
                  }
               }
            }
         }
      }
     // Se si verifica la condizione di terminazione arresto il ciclo altrimenti aggiorno i box 
-      if ( ! bCollide  ||  dMinDist < EPS_SMALL)
+      if ( ! bCollide  ||  dMinSqDist < EPS_SMALL * EPS_SMALL)
         bContinue = false ;
      else {
        boxPPrev = boxP ;
@@ -182,71 +163,15 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
      }
   }

-  // se non ho trovato nessun triangolo, esco
-   if ( nMinDistTriaIndex == SVT_NULL)
-      return ;
-
-  // Inizializzo il vettore dei triangoli a minima distanza
-   for ( auto& Tria : vTria)
-      m_vnMinDistTriaIndex.emplace_back( Tria.first) ;
-
-  // salvo la distanza minima
-   m_dDist = dMinDist ;
-  // salvo il punto a distanza minima
-   m_ptMinDistPoint = ptMinDistPoint ;
-  // se il punto è sulla TriMesh...
-   if ( m_dDist < EPS_SMALL) {
+   if ( nMinDistTriaIndex != SVT_NULL) {
+      m_dDist = sqrt( max( dMinSqDist, 0.)) ;
      m_nMinDistTriaIndex = nMinDistTriaIndex ;
-      m_bIsInside = false ;
-      return ;
+      m_ptMinDistPoint = ptMinDistPoint ;
+      Triangle3d trMinDistTria ;
+      pStm->GetTriangle( m_nMinDistTriaIndex, trMinDistTria) ;
+      trMinDistTria.Validate() ;
+      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * trMinDistTria.GetN() < - EPS_SMALL)  &&  pStm->IsClosed() ;
   }
-  // se ho un solo triangolo, allora deduco le informazioni da lui
-   else if ( int( vTria.size()) == 1) {
-      m_nMinDistTriaIndex = vTria.back().first ;
-      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * vTria.back().second.GetN() < - EPS_SMALL) ;
-      return ;
-   }
-  
-  // controllo se tutti i triangoli a minima distanza forniscono la stessa informazione
-  // ( il punto potrebbe essere esterno a tutti, interno a tutti o indefinito )
-   bool bInside = false ;
-   bool bOutside = false ;
-   for ( int i = 0 ; i < int( vTria.size()) ; ++ i) { // scorro i triangoli a minima distanza
-      if ( ( ptP - vTria[i].second.GetP( 0)) * vTria[i].second.GetN() < - EPS_SMALL)
-         bInside = true ;
-      else
-         bOutside = true ;
-   }
-
-  // inizializzo le variabili membro
-   m_nMinDistTriaIndex = nMinDistTriaIndex ;
-   m_bIsInside = false ;
-
-  // se le informazioni non sono coerenti, allora :
-  // 1) calcolo i centroidi dei triangoli in questione
-  // 2) ottengo il punto medio di questi centroidi
-  // 3) controllo quale triangolo interseca il segmento che parte da ptP e arriva a tale punto
-  // 4) userò questo triangolo per classificare ptP
-   if ( bOutside == bInside) {
-     // calcolo il baricentro complessivo
-      Point3d ptBar_tot ;
-      for ( auto& Tria : vTria)
-         ptBar_tot += Tria.second.GetCentroid() ;
-      ptBar_tot /= int( vTria.size()) ;
-     // per ogni triangolo, cerco quello che interseca il segmento
-      for ( auto& Tria : vTria) {
-         Point3d ptInters1, ptInters2 ;
-         int nType = IntersLineTria( ptP, ptBar_tot, Tria.second, ptInters1, ptInters2) ;
-         if ( nType == ILTT_IN) { // se intersezione ho finito
-            DistPointTriangle( ptP, Tria.second).GetMinDistPoint( m_ptMinDistPoint) ;
-            m_bIsInside = ( ( ptP - m_ptMinDistPoint) * Tria.second.GetN() < - EPS_SMALL) ;
-            m_nMinDistTriaIndex = Tria.first ;
-            break ;
-         }
-      }
-   }
-   else // se informazioni coerenti
-      m_bIsInside = bInside ;
 }

 //----------------------------------------------------------------------------
@@ -285,18 +210,6 @@ DistPointSurfTm::GetMinDistTriaIndex( int& nMinDistIndex) const
   return true ;
 }

-//----------------------------------------------------------------------------
-bool
-DistPointSurfTm::GetMinDistTriaIndices( INTVECTOR& vMinDistTriaIndex) const
-{
-  // Distanza non valida
-   if ( m_dDist < - EPS_ZERO)
-      return false ;
-  // Distanza valida
-   vMinDistTriaIndex = m_vnMinDistTriaIndex ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 int
 GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf)
@@ -311,8 +224,8 @@ GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf)
   if ( b3Stm.IsEmpty())
      return SVT_NULL ;

-  // Cerco triangoli in box centrati sul punto dato di ampiezza crescente ed escludendo le parti già verificate.
-  // Termino quando non trovo più triangoli che possano soddisfare la richiesta. 
+  // Cerco triangoli in box centrati sul punto dato di ampiezza crescente ed escludendo le parti già verificate.
+  // Termino quando non trovo più triangoli che possano soddisfare la richiesta. 
   Point3d ptMin, ptMax ; b3Stm.GetMinMax( ptMin, ptMax) ;
   double dDeltaLen = max( min( min( b3Stm.GetDimX(), b3Stm.GetDimY()), b3Stm.GetDimZ()) / 40., 20.) ;
   double dBoxHalfLenX = max( max( ptMin.x - ptP.x, ptP.x - ptMax.x), 0.) + dDeltaLen ;
@@ -324,11 +237,11 @@ GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf)
  // Variabili distanza minima 
   int nVert = SVT_NULL ;
   double dMinSqDist = DBL_MAX ;
-  // Finché non si verifica la condizione di terminazione ingrandisco il box.
+  // Finché non si verifica la condizione di terminazione ingrandisco il box.
   pStm->ResetTempInts() ;
   bool bContinue = true ;
   while ( bContinue) {
-     // Calcolo il box differenza con il precedente per non esplorare parti già considerate
+     // Calcolo il box differenza con il precedente per non esplorare parti già considerate
      BOXVECTOR vBox ;
      BoundingBoxDifference( boxP, boxPPrev, vBox) ;
     // Ciclo sui box differenza
@@ -14,7 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "ProjPlane.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointTria.h"


@@ -159,20 +159,11 @@ InitFontManager( const string& sNfeFontDir, const string& sDefaultFont)
 {
  // recupero il font manager
   FontManager& fntMgr = FontManager::GetFontManager() ;
+
  // lo inizializzo
   fntMgr.Init( sNfeFontDir, sDefaultFont) ;
 }

-//-----------------------------------------------------------------------------
-void
-SetDefaultFont( const string& sDefaultFont)
-{
-  // recupero il font manager
-   FontManager& fntMgr = FontManager::GetFontManager() ;
-  // imposto il dato
-   fntMgr.SetDefaultFont( sDefaultFont) ;
-}
-
 //-----------------------------------------------------------------------------
 const string&
 GetNfeFontDir( void)
@@ -194,11 +185,11 @@ GetDefaultFont( void)
 }

 //-----------------------------------------------------------------------------
-static psfProcEvents s_pFunProcEvents = nullptr ;
+static pfProcEvents s_pFunProcEvents = nullptr ;

 //-----------------------------------------------------------------------------
 bool
-SetEGkProcessEvents( psfProcEvents pFun)
+SetEGkProcessEvents( pfProcEvents pFun)
 {
   s_pFunProcEvents = pFun ;
   return ( pFun != nullptr) ;
@@ -22,7 +22,7 @@
    <ProjectGuid>{9A98A202-2853-454A-84CA-DCD1714176C9}</ProjectGuid>
    <RootNamespace>EgtGeomKernel</RootNamespace>
    <Keyword>MFCDLLProj</Keyword>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0.20348.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@@ -30,7 +30,7 @@
    <UseDebugLibraries>true</UseDebugLibraries>
    <CharacterSet>Unicode</CharacterSet>
    <UseOfMfc>false</UseOfMfc>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v141_xp</PlatformToolset>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
@@ -46,7 +46,7 @@
    <WholeProgramOptimization>false</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
    <UseOfMfc>false</UseOfMfc>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v141_xp</PlatformToolset>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
@@ -116,7 +116,7 @@
      <MultiProcessorCompilation>true</MultiProcessorCompilation>
      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
      <EnablePREfast>false</EnablePREfast>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
@@ -151,7 +151,7 @@ copy $(TargetPath) \EgtProg\DllD32</Command>
      <MinimalRebuild>false</MinimalRebuild>
      <MultiProcessorCompilation>true</MultiProcessorCompilation>
      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
      <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
    </ClCompile>
    <Link>
@@ -199,7 +199,7 @@ copy $(TargetPath) \EgtProg\DllD64</Command>
      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
      <WholeProgramOptimization>false</WholeProgramOptimization>
      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
@@ -245,7 +245,7 @@ copy $(TargetPath) \EgtProg\Dll32</Command>
      <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
      <WholeProgramOptimization>false</WholeProgramOptimization>
      <DebugInformationFormat>None</DebugInformationFormat>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
      <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
      <IntelJCCErratum>true</IntelJCCErratum>
    </ClCompile>
@@ -281,7 +281,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClCompile Include="BBox3d.cpp" />
    <ClCompile Include="BiArcs.cpp" />
    <ClCompile Include="CalcPocketing.cpp" />
-    <ClCompile Include="CAvSilhouetteSurfTm.cpp" />
    <ClCompile Include="CAvSimpleSurfFrMove.cpp" />
    <ClCompile Include="CAvToolSurfTm.cpp" />
    <ClCompile Include="CAvToolTriangle.cpp" />
@@ -310,9 +309,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClCompile Include="CurveByApprox.cpp" />
    <ClCompile Include="CurveByInterp.cpp" />
    <ClCompile Include="CurveCompositeOffset.cpp" />
-    <ClCompile Include="DistPointSurfBz.cpp" />
-    <ClCompile Include="DistPointSurfFr.cpp" />
-    <ClCompile Include="IntersCurvePlane.cpp" />
    <ClCompile Include="IntersCurveSurfTm.cpp">
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
@@ -322,36 +318,26 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClCompile Include="IntersLineVolZmap.cpp" />
    <ClCompile Include="IntersPlaneVolZmap.cpp" />
    <ClCompile Include="IntersLineSurfBez.cpp" />
-    <ClCompile Include="Trimming.cpp" />
-    <ClCompile Include="MultiGeomDB.cpp" />
-    <ClCompile Include="SurfTriMeshOffset.cpp" />
-    <ClCompile Include="VolZmapOffset.cpp" />
    <ClCompile Include="PolygonElevation.cpp" />
    <ClCompile Include="Quaternion.cpp" />
    <ClCompile Include="RotationMinimizingFrame.cpp" />
    <ClCompile Include="RotationXplaneFrame.cpp" />
-    <ClCompile Include="SbzFromCurves.cpp" />
    <ClCompile Include="SbzStandard.cpp" />
    <ClCompile Include="Voronoi.cpp" />
    <ClInclude Include="..\Include\EGkCDeClosedSurfTmClosedSurfTm.h" />
    <ClInclude Include="..\Include\EGkCDeConeFrustumClosedSurfTm.h" />
    <ClInclude Include="..\Include\EGkCDeConvexTorusClosedSurfTm.h" />
    <ClInclude Include="..\Include\EGkCDeRectPrismoidClosedSurfTm.h" />
-    <ClInclude Include="..\Include\EGkDistLineLine.h" />
-    <ClInclude Include="..\Include\EGkDistPointLine.h" />
    <ClInclude Include="..\Include\EGkIntersCurveSurfTm.h" />
    <ClInclude Include="..\Include\EGkIntersLineBox.h" />
    <ClInclude Include="..\Include\EGkIntersLineVolZmap.h" />
    <ClInclude Include="..\Include\EGkIntersPlaneBox.h" />
    <ClInclude Include="..\Include\EGkIntersPlaneVolZmap.h" />
-    <ClInclude Include="..\Include\EGkMultiGeomDB.h" />
    <ClInclude Include="..\Include\EGkPolygonElevation.h" />
    <ClInclude Include="..\Include\EGkQuaternion.h" />
    <ClInclude Include="..\Include\EGkRotationMinimizingFrame.h" />
    <ClInclude Include="..\Include\EGkRotationXplaneFrame.h" />
    <ClInclude Include="..\Include\EGkSubtractProjectedFacesOnStmFace.h" />
-    <ClInclude Include="..\Include\EGkSurfTriMeshAux.h" />
-    <ClInclude Include="CAvSilhouetteSurfTm.h" />
    <ClInclude Include="CDeBoxTria.h" />
    <ClInclude Include="CDeCapsTria.h" />
    <ClInclude Include="CDeConeFrustumTria.h" />
@@ -437,7 +423,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClCompile Include="OffsetCurveOnX.cpp" />
    <ClCompile Include="Polygon3d.cpp" />
    <ClCompile Include="AdjustLoops.cpp" />
-    <ClCompile Include="ProjectCurveSurf.cpp" />
+    <ClCompile Include="ProjectCurveSurfTm.cpp" />
    <ClCompile Include="RemoveCurveDefects.cpp" />
    <ClCompile Include="SelfIntersCurve.cpp" />
    <ClCompile Include="SfrCreate.cpp" />
@@ -609,10 +595,12 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClInclude Include="CAvSimpleSurfFrMove.h" />
    <ClInclude Include="CAvToolSurfTm.h" />
    <ClInclude Include="CreateCurveAux.h" />
+    <ClInclude Include="DistLineLine.h" />
    <ClInclude Include="DistPointArc.h" />
    <ClInclude Include="DistPointCrvAux.h" />
    <ClInclude Include="DistPointCrvBezier.h" />
    <ClInclude Include="DistPointCrvComposite.h" />
+    <ClInclude Include="DistPointLine.h" />
    <ClInclude Include="DllMain.h" />
    <ClInclude Include="earcut.hpp" />
    <ClInclude Include="ExtDimension.h" />
@@ -55,9 +55,6 @@
    <Filter Include="File di origine\GeoCollisionDetection">
      <UniqueIdentifier>{865b76ee-b10d-41fc-861c-b48ce52fa277}</UniqueIdentifier>
    </Filter>
-    <Filter Include="File di origine\GeoStriping">
-      <UniqueIdentifier>{54901321-08f6-4428-80c7-a1f859136a32}</UniqueIdentifier>
-    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="Vector3d.cpp">
@@ -489,7 +486,7 @@
    <ClCompile Include="IntersLineCaps.cpp">
      <Filter>File di origine\GeoInters</Filter>
    </ClCompile>
-    <ClCompile Include="ProjectCurveSurf.cpp">
+    <ClCompile Include="ProjectCurveSurfTm.cpp">
      <Filter>File di origine\GeoProject</Filter>
    </ClCompile>
    <ClCompile Include="SubtractProjectedFacesOnStmFace.cpp">
@@ -540,33 +537,6 @@
    <ClCompile Include="Quaternion.cpp">
      <Filter>File di origine\Base</Filter>
    </ClCompile>
-    <ClCompile Include="CAvSilhouetteSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionAvoid</Filter>
-    </ClCompile>
-    <ClCompile Include="SbzFromCurves.cpp">
-      <Filter>File di origine\GeoCreate</Filter>
-    </ClCompile>
-    <ClCompile Include="DistPointSurfFr.cpp">
-      <Filter>File di origine\GeoDist</Filter>
-    </ClCompile>
-    <ClCompile Include="VolZmapOffset.cpp">
-      <Filter>File di origine\Geo</Filter>
-    </ClCompile>
-    <ClCompile Include="SurfTriMeshOffset.cpp">
-      <Filter>File di origine\GeoOffset</Filter>
-    </ClCompile>
-    <ClCompile Include="MultiGeomDB.cpp">
-      <Filter>File di origine\Gdb</Filter>
-    </ClCompile>
-    <ClCompile Include="DistPointSurfBz.cpp">
-      <Filter>File di origine\GeoDist</Filter>
-    </ClCompile>
-    <ClCompile Include="IntersCurvePlane.cpp">
-      <Filter>File di origine\GeoInters</Filter>
-    </ClCompile>
-    <ClCompile Include="Trimming.cpp">
-      <Filter>File di origine\GeoStriping</Filter>
-    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="stdafx.h">
@@ -623,6 +593,9 @@
    <ClInclude Include="DistPointArc.h">
      <Filter>File di intestazione</Filter>
    </ClInclude>
+    <ClInclude Include="DistPointLine.h">
+      <Filter>File di intestazione</Filter>
+    </ClInclude>
    <ClInclude Include="DistPointCrvBezier.h">
      <Filter>File di intestazione</Filter>
    </ClInclude>
@@ -1145,6 +1118,9 @@
    <ClInclude Include="..\Include\EGkIntersPlaneBox.h">
      <Filter>File di intestazione\Include</Filter>
    </ClInclude>
+    <ClInclude Include="DistLineLine.h">
+      <Filter>File di intestazione</Filter>
+    </ClInclude>
    <ClInclude Include="CDeUtility.h">
      <Filter>File di intestazione</Filter>
    </ClInclude>
@@ -1238,21 +1214,6 @@
    <ClInclude Include="..\Include\EGkQuaternion.h">
      <Filter>File di intestazione\Include</Filter>
    </ClInclude>
-    <ClInclude Include="..\Include\EGkDistLineLine.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkDistPointLine.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="CAvSilhouetteSurfTm.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkSurfTriMeshAux.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkMultiGeomDB.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="EgtGeomKernel.rc">
@@ -1087,7 +1087,7 @@ ExtDimension::Update( void) const
         if ( m_nType == DT_RADIAL)
            sVal = "R " + sVal ;
         else if ( m_nType == DT_DIAMETRAL)
-            sVal = reinterpret_cast<const char *>( u8"\u00D8") + sVal ;
+            sVal = u8"\u00D8 " + sVal ;
         ReplaceString( m_sCalcText, IS_MEASURE, sVal) ;
      }
     // punto di inserimento del testo
@@ -147,10 +147,6 @@ CreateFillet( const ICurve& cCrv1, const Point3d& ptNear1,
        &vtNorm == nullptr  ||  &dPar1 == nullptr  ||  &dPar2 == nullptr)
      return nullptr ;

-  // verifico il minimo raggio
-   if ( dRadius < 10 * EPS_SMALL)
-      return nullptr ;
-
  // eseguo calcoli
   Point3d ptCen, ptTg1, ptTg2 ;
   int nSide1, nSide2 ;
@@ -169,11 +165,6 @@ CreateFillet( const ICurve& cCrv1, const Point3d& ptNear1,
         return nullptr ;
   }

-  // verifico dimensione minima
-   double dLen = Dist( ptTg1, ptTg2) ;
-   if ( dLen < 2 * EPS_SMALL)
-      return nullptr ;
-
  // orientamento tra le curve
   bool bCCW = ( dSinA > 0) ;

@@ -216,10 +207,6 @@ CreateChamfer( const ICurve& cCrv1, const Point3d& ptNear1,
        &vtNorm == nullptr  ||  &dPar1 == nullptr  ||  &dPar2 == nullptr)
      return nullptr ;

-  // verifico lo smusso minimo
-   if ( dDist < 10 * EPS_SMALL)
-      return nullptr ;
-
  // calcolo un riferimento sul piano perpendicolare alla normale
   Frame3d frIntr ;
   if ( ! frIntr.Set( ORIG, vtNorm))
@@ -29,8 +29,6 @@ class FontManager

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

   private :
-      FontManager( void) : m_bCurrNfeFont( false)  {}
+      FontManager( void) {}
      FontManager( FontManager const& copy) = delete ;
      FontManager& operator=( FontManager const& copy) = delete ;
 } ;
@@ -493,7 +493,7 @@ NfeFont::GetTextLines( const string& sText, int nInsPos, PNTVECTOR& vPt, STRVECT
      int nLbLen ;
      if ( IsLineBreak( vCode, i, nLbLen)) {
        // salvo la linea, se contiene qualcosa
-         if ( ! vTmpCode.empty()) {
+         if ( vTmpCode.size() > 0) {
            string sLine ;
            SetCodePoints( vTmpCode, sLine) ;
            vLine.push_back( sLine) ;
@@ -523,7 +523,7 @@ NfeFont::GetTextLines( const string& sText, int nInsPos, PNTVECTOR& vPt, STRVECT
         dMaxW = vtMove.x ;
   }
  // salvo eventuale ultima linea
-   if ( ! vTmpCode.empty()) {
+   if ( vTmpCode.size() > 0) {
      string sLine ;
      SetCodePoints( vTmpCode, sLine) ;
      vLine.push_back( sLine) ;
@@ -619,7 +619,7 @@ OsFont::GetTextLines( const string& sText, int nInsPos, PNTVECTOR& vPt, STRVECTO
      int nLbLen ;
      if ( IsLineBreak( vCode, i, nLbLen)) {
        // salvo la linea, se contiene qualcosa
-         if ( ! vTmpCode.empty()) {
+         if ( vTmpCode.size() > 0) {
            string sLine ;
            SetCodePoints( vTmpCode, sLine) ;
            vLine.push_back( sLine) ;
@@ -646,7 +646,7 @@ OsFont::GetTextLines( const string& sText, int nInsPos, PNTVECTOR& vPt, STRVECTO
         dMaxW = vtMove.x ;
   }
  // salvo eventuale ultima linea
-   if ( ! vTmpCode.empty()) {
+   if ( vTmpCode.size() > 0) {
      string sLine ;
      SetCodePoints( vTmpCode, sLine) ;
      vLine.push_back( sLine) ;
@@ -37,23 +37,6 @@ Frame3d::Set( const Point3d& ptOrig, const Vector3d& vtDirX,
        ! m_vtVersZ.Normalize())
      return false ;

-  // se ci sono errori molto piccoli di ortogonalità, li correggo
-   double dOrtXZ = m_vtVersX * m_vtVersZ ;
-   if ( dOrtXZ > EPS_ZERO  &&  dOrtXZ < 10 * EPS_ZERO) {
-      m_vtVersX = OrthoCompo( m_vtVersX, m_vtVersZ) ;
-      m_vtVersX.Normalize() ;
-   }
-   double dOrtYX = m_vtVersY * m_vtVersX ;
-   if ( dOrtYX > EPS_ZERO  &&  dOrtYX < 10 * EPS_ZERO) {
-      m_vtVersY = OrthoCompo( m_vtVersY, m_vtVersX) ;
-      m_vtVersY.Normalize() ;
-   }
-   double dOrtYZ = m_vtVersY * m_vtVersZ ;
-   if ( dOrtYZ > EPS_ZERO  &&  dOrtYZ < 10 * EPS_ZERO) {
-      m_vtVersY = OrthoCompo( m_vtVersY, m_vtVersZ) ;
-      m_vtVersY.Normalize() ;
-   }
-
  // verifica della ortogonalità dei versori e del senso destrorso
   if ( ! Verify())
      return false ;
@@ -2267,7 +2267,7 @@ bool
 GdbExecutor::SurfTriMeshEnd( const STRVECTOR& vsParams) 
 {
  // nessun parametro
-   if ( ! vsParams.empty())
+   if ( vsParams.size() != 0)
      return false ;
  // recupero la superficie
   ISurfTriMesh* pSTM = GetSurfTriMesh( m_pGeoObj) ;
@@ -6632,7 +6632,7 @@ GdbExecutor::ExecuteDeselect( const string& sCmd2, const STRVECTOR& vsParams)
  // deselezione di tutto
   else if ( sCmd2 == "ALL") {
     // nessun parametro
-      if ( ! vsParams.empty())
+      if ( vsParams.size() != 0)
         return false ;
     // cancello selezione oggetti
      if ( ! m_pGDB->ClearSelection())
@@ -7773,7 +7773,7 @@ bool
 GdbExecutor::ExecuteNew( const string& sCmd2, const STRVECTOR& vsParams) 
 {
  // nessun parametro
-   if ( ! vsParams.empty())
+   if ( vsParams.size() != 0)
      return false ;
  // pulizia e reinizializzazione del DB geometrico
   m_pGDB->Clear() ;
@@ -7946,7 +7946,7 @@ GdbExecutor::ExecuteOutTsc( const string& sCmd2, const STRVECTOR& vsParams)
  // chiudo il file di uscita Tsc
   else if ( sCmd2 == "CLOSE") {
     // nessun parametro
-      if ( ! vsParams.empty())
+      if ( vsParams.size() != 0)
         return false ;
     // scrivo terminazioni e chiudo il file
      return m_OutTsc.Close() ;
@@ -7969,7 +7969,7 @@ GdbExecutor::ExecuteOutTsc( const string& sCmd2, const STRVECTOR& vsParams)
   else if ( sCmd2 == "SETGR") {
      Frame3d frF ;
     // nessun parametro
-      if ( vsParams.empty())
+      if ( vsParams.size() == 0)
         frF.Reset() ;
     // un parametro ( Id del gruppo)
      else if ( vsParams.size() == 1) {
@@ -336,7 +336,7 @@ GdbGeo::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoe
        // curva originale
         ICurve* pCrv = GetCurve( m_pGeoObj) ;
        // trasformo in curva di Bezier (semplice o composta)
-         ICurve* pCrvNew = ArcToBezierCurve( GetCurveArc( pCrv)) ;
+         ICurve* pCrvNew = ArcToBezierCurve( pCrv) ;
         if ( pCrvNew == nullptr)
            return false ;
        // assegno alla nuova curva estrusione e spessore di quella originale
@@ -389,7 +389,7 @@ GdbGeo::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDi
      if ( ! pArc->IsPlane()  ||
           ! AreSameOrOppositeVectorExact( pArc->GetNormVersor(), vtNorm)) {
        // trasformo in curva di Bezier (semplice o composta)
-         ICurve* pCrvNew = ArcToBezierCurve( GetCurveArc( m_pGeoObj)) ;
+         ICurve* pCrvNew = ArcToBezierCurve( GetCurve( m_pGeoObj)) ;
         if ( pCrvNew == nullptr)
            return false ;
        // assegno alla nuova curva estrusione e spessore di quella originale
@@ -1254,13 +1254,13 @@ GdbIterator::GetCalcStatus( int& nStat) const

 //----------------------------------------------------------------------------
 bool
-GdbIterator::SetMark( int nMark)
+GdbIterator::SetMark( void)
 {
   if ( m_pGDB == nullptr  ||  m_pCurrObj == nullptr)
      return false ;

  // imposto la marcatura
-   return m_pCurrObj->SetMark( nMark) ;
+   return m_pCurrObj->SetMark() ;
 }

 //----------------------------------------------------------------------------
@@ -103,7 +103,7 @@ class GdbIterator : public IGdbIterator
      bool RevertStatus( void) override ;
      bool GetStatus( int& nStat) const override ;
      bool GetCalcStatus( int& nStat) const override ;
-      bool SetMark( int nMark = GDB_MK_ON) override ;
+      bool SetMark( void) override ;
      bool ResetMark( void) override ;
      bool GetMark( int& nMark) const override ;
      bool GetCalcMark( int& nMark) const override ;
@@ -101,20 +101,6 @@ GdbObj::CopyFrom( const GdbObj* pSou)
   return ( CopyAttribsFrom( pSou) && CopyTextureDataFrom( pSou) && CopyUserObjFrom( pSou)) ;
 }

-//----------------------------------------------------------------------------
-bool
-GdbObj::CopyStippleDataFrom( const GdbObj* pSou)
-{
-  // se l'oggetto sorgente non esiste
-   if ( pSou == nullptr)
-      return false ;
-  // copio stipple
-   m_nStpFactor = pSou->m_nStpFactor ;
-   m_nStpPattern = pSou->m_nStpPattern ;
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 GdbObj::CopyAttribsFrom( const GdbObj* pSou)
@@ -626,14 +612,14 @@ GdbObj::GetCalcStatus( int& nStat, int nLev) const

 //----------------------------------------------------------------------------
 bool
-GdbObj::SetMark( int nMark)
+GdbObj::SetMark( void)
 {
  // verifico esistenza (con eventuale creazione) degli attributi
   if ( GetSafeAttribs() == nullptr)
      return false ;

  // assegno la marcatura
-   m_pAttribs->SetMark( nMark) ;
+   m_pAttribs->SetMark() ;
   return true ;
 }

@@ -673,8 +659,8 @@ GdbObj::GetCalcMark( int& nMark) const
      nObjMark = m_pAttribs->GetMark() ;

  // se la marcatura è ON, non ho bisogno di sapere altro
-   if ( nObjMark == GDB_MK_ON  ||  nObjMark == GDB_MK_ON_2) {
-      nMark = nObjMark ;
+   if ( nObjMark == GDB_MK_ON) {
+      nMark = GDB_MK_ON ;
      return true ;
   }

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

@@ -82,7 +81,7 @@ class GdbObj
      bool IsSelected( void) const ;
      bool GetStatus( int& nStat) const ;
      bool GetCalcStatus( int& nStat, int nLev = 0) const ;
-      bool SetMark( int nMark) ;
+      bool SetMark( void) ;
      bool ResetMark( void) ;
      bool GetMark( int& nMark) const ;
      bool GetCalcMark( int& nMark) const ;
@@ -28,6 +28,41 @@
 #define GEOOBJ_NGEIDTOTYPE( nNgeId)       GeoObjFactory::NgeIdToType( nNgeId)
 #define GEOOBJ_CREATE( nKey)              GeoObjFactory::Create( nKey)

+//----------------------------------------------------------------------------
+template <class T> 
+class GeoObjRegister
+{
+   public :
+      static bool DoRegister( int nKey, int nNgeId)
+         {  if ( ! GeoObjFactory::Register( nKey, NgeAscKeyW[nNgeId], nNgeId, Create))
+               return false ;
+            GetTypePrivate() = nKey ;
+            GetKeyPrivate() = NgeAscKeyW[nNgeId] ;
+            GetNgeIdPrivate() = nNgeId ;
+            return true ; }
+      static IGeoObj* Create( void) 
+         {  return new( std::nothrow) T ; }
+      static int GetType( void) 
+         { return GetTypePrivate() ; }
+      static const std::string& GetKey( void) 
+         { return GetKeyPrivate() ; }
+      static int GetNgeId( void) 
+         { return GetNgeIdPrivate() ; }
+
+   private :
+      GeoObjRegister( void)  {}
+      ~GeoObjRegister( void) {}
+      static int& GetTypePrivate( void) 
+         { static int  s_nType ;
+           return s_nType ; }
+      static std::string& GetKeyPrivate( void) 
+         { static std::string  s_sKey ;
+           return s_sKey ; }
+      static int& GetNgeIdPrivate( void) 
+         { static int  s_nNgeId ;
+           return s_nNgeId ; }
+} ;
+
 //----------------------------------------------------------------------------
 class GeoObjFactory
 {
@@ -82,38 +117,3 @@ class GeoObjFactory
         {  static CreatorMap s_CreatorMap ;
            return s_CreatorMap ; }
 } ;
-
-//----------------------------------------------------------------------------
-template <class T> 
-class GeoObjRegister
-{
-   public :
-      static bool DoRegister( int nKey, int nNgeId)
-         {  if ( ! GeoObjFactory::Register( nKey, NgeAscKeyW[nNgeId], nNgeId, Create))
-               return false ;
-            GetTypePrivate() = nKey ;
-            GetKeyPrivate() = NgeAscKeyW[nNgeId] ;
-            GetNgeIdPrivate() = nNgeId ;
-            return true ; }
-      static IGeoObj* Create( void) 
-         {  return new( std::nothrow) T ; }
-      static int GetType( void) 
-         { return GetTypePrivate() ; }
-      static const std::string& GetKey( void) 
-         { return GetKeyPrivate() ; }
-      static int GetNgeId( void) 
-         { return GetNgeIdPrivate() ; }
-
-   private :
-      GeoObjRegister( void)  {}
-      ~GeoObjRegister( void) {}
-      static int& GetTypePrivate( void) 
-         { static int  s_nType ;
-           return s_nType ; }
-      static std::string& GetKeyPrivate( void) 
-         { static std::string  s_sKey ;
-           return s_sKey ; }
-      static int& GetNgeIdPrivate( void) 
-         { static int  s_nNgeId ;
-           return s_nNgeId ; }
-} ;
@@ -38,22 +38,20 @@ using namespace std ;
 class LockAddErase
 {
   public :
-      LockAddErase( atomic_flag& bAddEraseOn, bool bUse = true)
-         : m_bAddEraseOn( bAddEraseOn), m_bUse( bUse)
+      LockAddErase(std::atomic_flag& bAddEraseOn, bool bUse = true): m_bAddEraseOn( bAddEraseOn), m_bUse( bUse)
         {  if ( ! m_bUse) return ;
-            while ( m_bAddEraseOn.test_and_set( memory_order_acquire)) {
-               m_bAddEraseOn.wait( true, memory_order_relaxed) ;
+            while ( m_bAddEraseOn.test_and_set()) {
+               this_thread::sleep_for( chrono::nanoseconds{ 1}) ;
            }
         } ;

      ~LockAddErase( void)
         {  if ( ! m_bUse) return ;
-            m_bAddEraseOn.clear( memory_order_release) ;
-            m_bAddEraseOn.notify_one() ;
+            m_bAddEraseOn.clear() ;
         } ;

   private :
-      atomic_flag& m_bAddEraseOn ;
+      std::atomic_flag& m_bAddEraseOn ;
      bool m_bUse ;
 } ;

@@ -613,7 +611,7 @@ GeomDB::GetGdbObj( int nId) const
  // radice
   else if ( nId == GDB_ID_ROOT)
      return &m_GrpRadix ;
-  // un nodo qualunque
+  // un nodo qualubque
   else
      return m_IdManager.FindObj( nId) ;
 }
@@ -660,7 +658,7 @@ GeomDB::InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bLo
          return false ;
   }
  // inserisco come figlio, in testa alla lista del padre
-   else if ( nSonBeforeAfter == GDB_FIRST_SON) {
+   else if ( nSonBeforeAfter == GDB_FIRST_SON){
      GdbGroup* pGroup = ::GetGdbGroup( pGRef) ;
      if ( pGroup == nullptr)
         return false ;
@@ -879,7 +877,7 @@ GeomDB::GetFirstNameInGroup( int nGroupId, const string& sName) const
     // se ha il nome o la parte iniziale di nome cercato
      string sObjName ;
      if ( pGdbO->GetName( sObjName)  &&  
-           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.rfind( sToFind, 0) == 0)))
+           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.find( sToFind) == 0)))
         return ( pGdbO->m_nId) ;
     // passo al successivo
      pGdbO = pGdbO->GetNext() ;
@@ -907,7 +905,7 @@ GeomDB::GetNextName( int nId, const string& sName) const
     // se ha il nome o la parte iniziale di nome cercato
      string sObjName ;
      if ( pGdbNext->GetName( sObjName)  &&  
-           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.rfind( sToFind, 0) == 0)))
+           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.find( sToFind) == 0)))
         return ( pGdbNext->m_nId) ;
     // passo al successivo
      pGdbNext = pGdbNext->GetNext() ;
@@ -935,7 +933,7 @@ GeomDB::GetLastNameInGroup( int nGroupId, const string& sName) const
     // se ha il nome o la parte iniziale di nome cercato
      string sObjName ;
      if ( pGdbO->GetName( sObjName)  &&  
-           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.rfind( sToFind, 0) == 0)))
+           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.find( sToFind) == 0)))
         return ( pGdbO->m_nId) ;
     // passo al precedente
      pGdbO = pGdbO->GetPrev() ;
@@ -963,7 +961,7 @@ GeomDB::GetPrevName( int nId, const string& sName) const
     // se ha il nome o la parte iniziale di nome cercato
      string sObjName ;
      if ( pGdbPrev->GetName( sObjName)  &&  
-           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.rfind( sToFind, 0) == 0)))
+           (( ! bWild  &&  sObjName == sToFind)  ||  ( bWild  &&  sObjName.find( sToFind) == 0)))
         return ( pGdbPrev->m_nId) ;
     // passo al precedente
      pGdbPrev = pGdbPrev->GetPrev() ;
@@ -2312,7 +2310,7 @@ GeomDB::GetCalcStatus( int nId, int& nStat) const

 //----------------------------------------------------------------------------
 bool
-GeomDB::SetMark( int nId, int nMark)
+GeomDB::SetMark( int nId)
 {
  // recupero l'oggetto
   GdbObj* pGdbObj = GetGdbObj( nId) ;
@@ -2320,7 +2318,7 @@ GeomDB::SetMark( int nId, int nMark)
      return false ;

  // imposto la marcatura
-   return  pGdbObj->SetMark( nMark) ;
+   return  pGdbObj->SetMark() ;
 }

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

   public :
      ~GeomDB( void) override ;
@@ -140,7 +136,7 @@ class GeomDB : public IGeomDB
      bool RevertStatus( int nId) override ;
      bool GetStatus( int nId, int& nStat) const override ;
      bool GetCalcStatus( int nId, int& nStat) const override ;
-      bool SetMark( int nId, int nMark = GDB_MK_ON) override ;
+      bool SetMark( int nId) override ;
      bool ResetMark( int nId) override ;
      bool GetMark( int nId, int& nMark) const override ;
      bool GetCalcMark( int nId, int& nMark) const override ;
@@ -116,7 +116,7 @@ HashGrid1d::~HashGrid1d( void)
 {
   Clear() ;

-   for ( Cell* pCell  = m_cell ; pCell != nullptr && pCell < m_cell + m_CellCount ; ++ pCell) {
+   for ( Cell* pCell  = m_cell ; pCell < m_cell + m_CellCount ; ++ pCell) {
      if ( pCell->m_neighborOffset != m_stdNeighborOffset)
         delete[] pCell->m_neighborOffset ;
   }
@@ -396,10 +396,8 @@ HashGrid1d::Enlarge( void)
   for ( auto pCell = m_cell ; pCell < m_cell + m_CellCount ; ++ pCell) {
      if ( pCell->m_neighborOffset != m_stdNeighborOffset)
         delete[] pCell->m_neighborOffset ;
-      pCell->m_neighborOffset = nullptr ;
   }
   delete[] m_cell ;
-   m_cell = nullptr ;

  // ... the number of cells is doubled in each coordinate direction, ...
   m_CellCount *= 2 ;   
@@ -571,7 +569,7 @@ HashGrids1d::Update( void)
     // Salvo stato di precedente attivazione delle griglie
      bool bGridActivePrev = m_bGridActive ;
     // Inseriamo gli oggetti presenti nel vettore m_objsToAdd
-      if ( ! m_objsToAdd.empty()) {
+      if ( m_objsToAdd.size() > 0 ) {
         for ( auto pObj : m_objsToAdd) {
            if ( m_bGridActive)
               addGrid( *pObj) ;
@@ -636,22 +634,24 @@ HashGrids1d::Find( const BBox3d& b3Test, INTVECTOR& vnIds) const
   sort( vnIds.begin(), vnIds.end()) ;
   vnIds.erase( unique( vnIds.begin(), vnIds.end()), vnIds.end()) ;

-   return ( ! vnIds.empty()) ;
+   return ( vnIds.size() > 0) ;
 }

 //----------------------------------------------------------------------------
 void
 HashGrids1d::Clear( void)
 {
-   m_ObjsList.clear() ;
-   m_ObjsMap.clear() ;
-   m_objsToAdd.clear() ;
-   m_nonGridObjs.clear() ;
-   for ( auto pGrid : m_GridList)
+   for ( auto pGrid : m_GridList) {
      delete pGrid ;
+   }
   m_GridList.clear() ;
-   m_bActivate = true ;
+
   m_bGridActive = false ;
+
+   m_nonGridObjs.clear() ;
+
+   m_objsToAdd.clear() ;
+
   m_b3Objs.Reset() ;
 }

@@ -125,7 +125,7 @@ HashGrid2d::~HashGrid2d( void)
 {
   Clear() ;

-   for ( Cell* pCell = m_cell ; pCell != nullptr && pCell < m_cell + m_xyCellCount ; ++ pCell) {
+   for ( Cell* pCell  = m_cell ; pCell < m_cell + m_xyCellCount ; ++ pCell) {
      if ( pCell->m_neighborOffset != m_stdNeighborOffset)
         delete[] pCell->m_neighborOffset ;
   }
@@ -445,10 +445,8 @@ HashGrid2d::Enlarge( void)
   for ( auto pCell = m_cell ; pCell < m_cell + m_xyCellCount ; ++ pCell) {
      if ( pCell->m_neighborOffset != m_stdNeighborOffset)
         delete[] pCell->m_neighborOffset ;
-      pCell->m_neighborOffset = nullptr ;
   }
   delete[] m_cell ;
-   m_cell = nullptr ;

   // ... the number of cells is doubled in each coordinate direction, ...
   m_xCellCount *= 2 ;
@@ -625,7 +623,7 @@ HashGrids2d::Update( void)
     // Salvo stato di precedente attivazione delle griglie
      bool bGridActivePrev = m_bGridActive ;
     // Inseriamo gli oggetti presenti nel vettore m_objsToAdd
-      if ( ! m_objsToAdd.empty()) {
+      if ( m_objsToAdd.size() > 0 ) {
         for ( auto pObj : m_objsToAdd) {
            if ( m_bGridActive)
               addGrid( *pObj) ;
@@ -690,22 +688,24 @@ HashGrids2d::Find( const BBox3d& b3Test, INTVECTOR& vnIds) const
   sort( vnIds.begin(), vnIds.end()) ;
   vnIds.erase( unique( vnIds.begin(), vnIds.end()), vnIds.end()) ;

-   return ( ! vnIds.empty()) ;
+   return ( vnIds.size() > 0) ;
 }

 //----------------------------------------------------------------------------
 void
 HashGrids2d::Clear( void)
 {
-   m_ObjsList.clear() ;
-   m_ObjsMap.clear() ;
-   m_objsToAdd.clear() ;
-   m_nonGridObjs.clear() ;
-   for ( auto pGrid : m_GridList)
+   for ( auto pGrid : m_GridList) {
      delete pGrid ;
+   }
   m_GridList.clear() ;
-   m_bActivate = true ;
+
   m_bGridActive = false ;
+
+   m_nonGridObjs.clear() ;
+
+   m_objsToAdd.clear() ;
+
   m_b3Objs.Reset() ;
 }

@@ -132,7 +132,7 @@ HashGrid3d::~HashGrid3d( void)
 {
   Clear() ;

-   for ( Cell* pCell = m_cell ; pCell != nullptr && pCell < m_cell + m_xyzCellCount ; ++ pCell) {
+   for ( Cell* pCell = m_cell ; pCell < m_cell + m_xyzCellCount ; ++ pCell) {
      if ( pCell->m_neighborOffset != m_stdNeighborOffset)
         delete[] pCell->m_neighborOffset ;
   }
@@ -486,10 +486,8 @@ HashGrid3d::Enlarge( void)
   for ( auto pCell = m_cell ; pCell < m_cell + m_xyzCellCount ; ++ pCell) {
      if ( pCell->m_neighborOffset != m_stdNeighborOffset)
         delete[] pCell->m_neighborOffset ;
-      pCell->m_neighborOffset = nullptr ;
   }
   delete[] m_cell ;
-   m_cell = nullptr ;

   // ... the number of cells is doubled in each coordinate direction, ...
   m_xCellCount *= 2 ;
@@ -669,7 +667,7 @@ HashGrids3d::Update( void)
     // Salvo stato di precedente attivazione delle griglie
      bool bGridActivePrev = m_bGridActive ;
     // Inseriamo gli oggetti presenti nel vettore m_objsToAdd
-      if ( ! m_objsToAdd.empty()) {
+      if ( m_objsToAdd.size() > 0 ) {
         for ( auto pObj : m_objsToAdd) {
            if ( m_bGridActive)
               addGrid( *pObj) ;
@@ -733,7 +731,7 @@ HashGrids3d::Find( const BBox3d& b3Test, INTVECTOR& vnIds) const
   sort( vnIds.begin(), vnIds.end()) ;
   vnIds.erase( unique( vnIds.begin(), vnIds.end()), vnIds.end()) ;

-   return ( ! vnIds.empty()) ;                               
+   return ( vnIds.size() > 0) ;                               
 }


@@ -741,15 +739,17 @@ HashGrids3d::Find( const BBox3d& b3Test, INTVECTOR& vnIds) const
 void
 HashGrids3d::Clear( void)
 {
-   m_ObjsList.clear() ;
-   m_ObjsMap.clear() ;
-   m_objsToAdd.clear() ;
-   m_nonGridObjs.clear() ;
-   for ( auto pGrid : m_GridList)
+   for ( auto pGrid : m_GridList) {
      delete pGrid ;
+   }
   m_GridList.clear() ;
-   m_bActivate = true ;
+
   m_bGridActive = false ;
+
+   m_nonGridObjs.clear() ;
+
+   m_objsToAdd.clear() ;
+
   m_b3Objs.Reset() ;
 }

@@ -17,9 +17,6 @@

 using namespace std ;

-//----------------------------------------------------------------------------
-static const double EPS_INTER_ARC = 0.1 * EPS_SMALL ;
-
 //----------------------------------------------------------------------------
 IntersArcArc::IntersArcArc( const CurveArc& Arc1, const CurveArc& Arc2)
 {
@@ -63,15 +60,15 @@ IntersArcArc::IntersArcArc( const CurveArc& Arc1, const CurveArc& Arc2)
   vtDir /= dDist ;

  // cerchi esterni -> nessuna intersezione
-   if ( dDist > m_Arc1.GetRadius() + m_Arc2.GetRadius() + EPS_INTER_ARC)
+   if ( dDist > m_Arc1.GetRadius() + m_Arc2.GetRadius() + EPS_SMALL)
      return ;

  // cerchi interni -> nessuna intersezione
-   if ( dDist < abs( m_Arc1.GetRadius() - m_Arc2.GetRadius()) - EPS_INTER_ARC)
+   if ( dDist < abs( m_Arc1.GetRadius() - m_Arc2.GetRadius()) - EPS_SMALL)
      return ;

  // cerchi coincidenti -> sovrapposizioni e/o intersezioni agli estremi 
-   if ( dDist < EPS_SMALL  &&  abs( m_Arc1.GetRadius() - m_Arc2.GetRadius()) < EPS_INTER_ARC) {
+   if ( dDist < EPS_SMALL  &&  abs( m_Arc1.GetRadius() - m_Arc2.GetRadius()) < EPS_SMALL) {
     // coefficiente da parametro dell'arco 1 a lunghezza
      double dU2L = abs( m_Arc1.GetAngCenter()) * DEGTORAD * m_Arc1.GetRadius() ;
     // determino se sono equiversi o controversi
@@ -239,7 +236,7 @@ IntersArcArc::IntersArcArc( const CurveArc& Arc1, const CurveArc& Arc2)
   double dSqH = m_Arc1.GetRadius() * m_Arc1.GetRadius() - dA * dA ;

  // cerchi tangenti esterni -> una intersezione
-   if ( abs( dDist - ( m_Arc1.GetRadius() + m_Arc2.GetRadius())) < EPS_INTER_ARC) {
+   if ( abs( dDist - ( m_Arc1.GetRadius() + m_Arc2.GetRadius())) < EPS_SMALL) {
     // tolleranza tangenziale sull'intersezione
      double dTgTol = ( dSqH > SQ_EPS_SMALL ? sqrt( dSqH) : EPS_SMALL) ;
     // calcolo il punto di intersezione
@@ -361,7 +358,7 @@ IntersArcArc::IntersArcArc( const CurveArc& Arc1, const CurveArc& Arc2)
   }

  // cerchi tangenti interni -> una intersezione
-   if ( abs( dDist - abs( m_Arc1.GetRadius() - m_Arc2.GetRadius())) < EPS_INTER_ARC) {
+   if ( abs( dDist - abs( m_Arc1.GetRadius() - m_Arc2.GetRadius())) < EPS_SMALL) {
     // tolleranza tangenziale sull'intersezione
      double dTgTol = ( dSqH > SQ_EPS_SMALL ? sqrt( dSqH) : EPS_SMALL) ;
     // determino quale dei due contiene l'altro
@@ -78,8 +78,6 @@ IntersCurveCurve::IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB,
      case CRV_COMPO :
         LineCrvCompoCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
         break ;
-      default :
-         break ;
      }
      break ;
   case CRV_ARC :
@@ -93,8 +91,6 @@ IntersCurveCurve::IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB,
      case CRV_COMPO :
         ArcCrvCompoCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
         break ;
-      default :
-         break ;
      }
      break ;
   case CRV_COMPO :
@@ -108,12 +104,8 @@ IntersCurveCurve::IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB,
      case CRV_COMPO :
         CrvCompoCrvCompoCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
         break ;
-      default :
-         break ;
      }
      break ;
-   default :
-      break ;
   }
  // per curve approssimate, sistemo...
   AdjustIntersParams( ( pCalcCrv[0] !=  m_pCurve[0]), ( pCalcCrv[1] !=  m_pCurve[1])) ;
@@ -253,7 +245,7 @@ bool
 IntersCurveCurve::AdjustIntersParams( bool bAdjCrvA, bool bAdjCrvB)
 {
  // se non ci sono intersezioni, non va fatto alcunché
-   if ( m_Info.empty())
+   if ( m_Info.size() == 0)
      return true ;
  // se le curve originali non sono state approssimate, non va fatto alcunché
   if ( ! bAdjCrvA  &&  ! bAdjCrvB)
@@ -291,24 +283,6 @@ IntersCurveCurve::GetIntersCount( void)
   return m_nIntersCount ;
 }

-//----------------------------------------------------------------------------
-int
-IntersCurveCurve::GetInters3DCount( void)
-{
-   int nCount = 0 ;
-   for( int i = 0 ; i < m_nIntersCount ; ++i) {
-      if( ! m_Info[i].bOverlap  ||  ( m_Info[i].bOverlap  &&  m_Info[i].bCBOverEq)) {
-         if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[0].ptI.z) < EPS_SMALL)
-            ++nCount ;
-      }
-      else {
-         if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[1].ptI.z) < EPS_SMALL)
-            ++nCount ;
-      }
-   }
-   return nCount ;
-}
-
 //----------------------------------------------------------------------------
 int
 IntersCurveCurve::GetCrossIntersCount( void)
@@ -358,30 +332,6 @@ IntersCurveCurve::GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo)
   return true ;
 }

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

-  // Se non c'è intersezione
+  // Se non c'è intersezione
   if ( ! bInters  ||  ( bFinite  &&  ( dU1 > dLen + EPS_SMALL  ||  dU2 < -EPS_SMALL)))
      return true ;

@@ -144,14 +144,8 @@ IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double dLen, const BBox3
         else if ( dU2 < EPS_SMALL)
            vInters.emplace_back( ILBT_OUT, 0) ;
         else {
-            if ( dU1 < - EPS_SMALL)
-               vInters.emplace_back( ILBT_TG_INSIDE, 0.) ;
-            else
-               vInters.emplace_back( ILBT_TG_INI, Clamp( dU1, 0., dLen)) ;
-            if ( dU2 > dLen + EPS_SMALL)
-               vInters.emplace_back( ILBT_TG_INSIDE, dLen) ;
-            else
-               vInters.emplace_back( ILBT_TG_FIN, Clamp( dU2, 0., dLen)) ;
+            vInters.emplace_back( ILBT_TG_INI, Clamp( dU1, 0., dLen)) ;
+            vInters.emplace_back( ILBT_TG_FIN, Clamp( dU2, 0., dLen)) ;
         }
      }
      return true ;
@@ -168,14 +162,8 @@ IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double dLen, const BBox3
      else if ( dU2 < EPS_SMALL)
         vInters.emplace_back( ILBT_OUT, 0) ;
      else {
-         if ( dU1 < - EPS_SMALL)
-            vInters.emplace_back( ILBT_INSIDE, 0.) ;
-         else
-            vInters.emplace_back( ILBT_IN, Clamp( dU1, 0., dLen)) ;
-         if ( dU2 > dLen + EPS_SMALL)
-            vInters.emplace_back( ILBT_INSIDE, dLen) ;
-         else
-            vInters.emplace_back( ILBT_OUT, Clamp( dU2, 0., dLen)) ;
+         vInters.emplace_back( ILBT_IN, Clamp( dU1, 0., dLen)) ;
+         vInters.emplace_back( ILBT_OUT, Clamp( dU2, 0., dLen)) ;
      }
   }
   return true ;
@@ -14,7 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "IntersLineCaps.h"
-#include "/EgtDev/Include/EGkDistLineLine.h"
+#include "DistLineLine.h"
 #include "/EgtDev/Include/EGkIntersLineSphere.h"

 using namespace std ;
@@ -14,24 +14,25 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "IntersLineLine.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include <algorithm>

 using namespace std ;

 //----------------------------------------------------------------------------
-// Posizione del punto rispetto alla linea (+1=a destra, 0=nella banda di tolleranza, -1=a sinistra) 
-static int
-GetPointToLineSide( const Point3d& ptP, const Point3d& ptS, const Vector3d& vtDir, double dLenXY, double dTol)
+// Il punto è esterno al FatSegment se dista da questo più di Tol e la sua proiezione sta sul segmento 
+bool
+IsPointOutFatSegment( const Point3d& ptP, const Point3d& ptS, const Vector3d& vtDir, double dLenXY, double dTol)
 {
-   double dCross = CrossXY( ( ptP - ptS), vtDir) ;
-   double dFat = ( dTol + EPS_ZERO) * dLenXY ;
-   if ( dCross > dFat)
-      return +1 ;
-   else if ( dCross < - dFat)
-      return -1 ;
-   else
-      return 0 ;
+  // distanza del punto dalla linea del segmento (con compensazione piccolissimi errori)
+   if ( abs( CrossXY( ( ptP - ptS), vtDir)) < ( dTol + EPS_ZERO) * dLenXY)
+      return false ;
+  // distanza con segno della proiezione del punto sul segmento dall'inizio per lunghezza segmento
+   double dDistXY = ScalarXY( ( ptP - ptS), vtDir) ;
+  // se il punto non si proietta sul segmento entro la tolleranza
+   if ( dDistXY < - dTol * dLenXY  ||  dDistXY > ( dLenXY + dTol) * dLenXY)
+      return false ;
+  // altrimenti
+   return true ;
 }

 //----------------------------------------------------------------------------
@@ -43,7 +44,7 @@ IntersLineLine::IntersLineLine( const CurveLine& Line1, const CurveLine& Line2,
   m_bOverlaps = false ;
   m_nNumInters = 0 ;

-  // verifico validità linee
+  // verifico validità linee
   if ( ! Line1.IsValid()  ||  ! Line2.IsValid())
      return ;

@@ -129,120 +130,56 @@ IntersLineLine::IntersFiniteLines( const CurveLine& Line1, const CurveLine& Line
   if ( ! boxL1.OverlapsXY( boxL2))
      return ;

-  // segmento 1 : Start, End, Direzione e Lunghezza
+  // linea 1 : Start, End, Direzione e Lunghezza
   Point3d ptS1 = Line1.GetStart() ;
   Point3d ptE1 = Line1.GetEnd() ;
   Vector3d vtDir1 = ptE1 - ptS1 ;
   double dLen1XY = vtDir1.LenXY() ;
   if ( dLen1XY < EPS_SMALL)
      return ;
-  // segmento 2 : Start, Direzione e Lunghezza
+  // linea 2 : Start, Direzione e Lunghezza
   Point3d ptS2 = Line2.GetStart() ;
   Point3d ptE2 = Line2.GetEnd() ;
   Vector3d vtDir2 = ptE2 - ptS2 ;
   double dLen2XY = vtDir2.LenXY() ;
   if ( dLen2XY < EPS_SMALL)
      return ;
-  // posizioni estremi segmento 1 rispetto a linea 2
-   int nS1Side = GetPointToLineSide( ptS1, ptS2, vtDir2, dLen2XY, EPS_SMALL) ;
-   int nE1Side = GetPointToLineSide( ptE1, ptS2, vtDir2, dLen2XY, EPS_SMALL) ;
-   if ( ( nS1Side == 1  &&  nE1Side == 1)  ||  ( nS1Side == -1  &&  nE1Side == -1))
-      return ;
-  // posizioni estremi segmento 2 rispetto a linea 1
-   int nS2Side = GetPointToLineSide( ptS2, ptS1, vtDir1, dLen1XY, EPS_SMALL) ;
-   int nE2Side = GetPointToLineSide( ptE2, ptS1, vtDir1, dLen1XY, EPS_SMALL) ;
-   if ( ( nS2Side == 1  &&  nE2Side == 1)  ||  ( nS2Side == -1  &&  nE2Side == -1))
-      return ;
  // prodotto vettoriale nel piano XY tra le direzioni delle linee
   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
-   bool bFarEnds = ( nS1Side != 0  ||  nE1Side != 0  ||  nS2Side != 0  ||  nE2Side != 0) ;
-   
-   // analisi casi speciali di quasi parallelismo
-   // segmento sovrapposto all'altro
-   double dDist1, dDist2 ;
-   if( nS1Side == 0 ||  nE1Side == 0  ||  nS1Side == nE1Side) {
-      dDist1 = CrossXY( ptS1 - ptS2, vtDir2) ;
-      dDist2 = CrossXY( ptE1 - ptS2, vtDir2) ;
-      if( abs( dDist1 - dDist2) < EPS_SMALL * dLen2XY) {
-         bParallel = true ;
-         bFarEnds = ! ( (nS1Side == 0  &&  nE1Side == 0)  ||  (nS2Side == 0  &&  nE2Side == 0)) ;
-      }
-   }
-   else if( nS2Side == 0  ||  nE2Side == 0  ||  nS2Side == nE2Side) {
-      dDist1 = CrossXY( ptS2 - ptS1, vtDir1) ;
-      dDist2 = CrossXY( ptE2 - ptS1, vtDir1) ;
-      if( abs( dDist1 - dDist2) < EPS_SMALL * dLen1XY){
-         bParallel = true ;
-         bFarEnds = ! ( (nS1Side == 0  &&  nE1Side == 0)  ||  (nS2Side == 0  &&  nE2Side == 0)) ;
-      }
-   }
-   // estremità sovrapposte di poco
-   if ( ! bParallel  &&  abs( dCrossXY) < ( 0.1 * DEGTORAD) * ( dLen1XY * dLen2XY)) {
-      if (( nS1Side == 0  &&  nS2Side == 0  &&  ! AreSamePointXYEpsilon( ptS1, ptS2, 2 * EPS_SMALL))  ||
-          ( nS1Side == 0  &&  nE2Side == 0  &&  ! AreSamePointXYEpsilon( ptS1, ptE2, 2 * EPS_SMALL))  ||
-          ( nE1Side == 0  &&  nS2Side == 0  &&  ! AreSamePointXYEpsilon( ptE1, ptS2, 2 * EPS_SMALL))  ||
-          ( nE1Side == 0  &&  nE2Side == 0  &&  ! AreSamePointXYEpsilon( ptE1, ptE2, 2 * EPS_SMALL))) {
-         bParallel = true ;
-         bFarEnds = false ;
-      }
-   }
+  // flag per segmenti che si allontanano significativamente
+   bool bFarEnds = ( /*( abs( dCrossXY) > SIN_EPS_ANG_SMALL * ( dLen1XY * dLen2XY))  ||*/
+                     IsPointOutFatSegment( ptS1, ptS2, vtDir2, dLen2XY, EPS_SMALL)  ||
+                     IsPointOutFatSegment( ptE1, ptS2, vtDir2, dLen2XY, EPS_SMALL)  ||
+                     IsPointOutFatSegment( ptS2, ptS1, vtDir1, dLen1XY, EPS_SMALL)  ||
+                     IsPointOutFatSegment( ptE2, ptS1, vtDir1, dLen1XY, EPS_SMALL)) ;

  // se non sono paralleli e si allontanano tra loro abbastanza
   if ( ! bParallel  &&  bFarEnds) {
     // posizioni parametriche dell'intersezione sulle linee
      m_Info.IciA[0].dU = CrossXY( ( ptS2 - ptS1), vtDir2) / dCrossXY ;
      m_Info.IciB[0].dU = CrossXY( ( ptS2 - ptS1), vtDir1) / dCrossXY ;
-      // verifica posizione intersezione su prima linea
+     // verifica posizione intersezione su prima linea
      int nPos1 = ICurve::PP_NULL ;     // fuori
-      if ( nS1Side == 0 ||  nE1Side == 0) {
-         if( nS1Side == 0) {
-            nPos1 = ICurve::PP_START ;
-            m_Info.IciA[0].dU = 0 ;
-            m_Info.IciB[0].dU = vtDir2 * ( ptS1 - ptS2) / Pow( vtDir2.Len(), 2) ;
-         }
-         else {
-            nPos1 = ICurve::PP_END ;
-            m_Info.IciA[0].dU = 1 ;
-            m_Info.IciB[0].dU = vtDir2 * ( ptE1 - ptS2) / Pow( vtDir2.Len(), 2) ;
-         }
-      }
-      else {
-         if ( abs( m_Info.IciA[0].dU * dLen1XY) < EPS_SMALL)
-            nPos1 = ICurve::PP_START ;     // vicino a inizio
-         else if ( abs(( 1 - m_Info.IciA[0].dU) * dLen1XY) < EPS_SMALL)
-            nPos1 = ICurve::PP_END ;       // vicino a fine
-         else if ( m_Info.IciA[0].dU > 0  &&  m_Info.IciA[0].dU < 1)
-            nPos1 = ICurve::PP_MID ;       // nell'interno
-         else
-            return ;
-      }
+      if ( abs( m_Info.IciA[0].dU * dLen1XY) < EPS_SMALL)
+         nPos1 = ICurve::PP_START ;     // vicino a inizio
+      else if ( abs(( 1 - m_Info.IciA[0].dU) * dLen1XY) < EPS_SMALL)
+         nPos1 = ICurve::PP_END ;       // vicino a fine
+      else if ( m_Info.IciA[0].dU > 0  &&  m_Info.IciA[0].dU < 1)
+         nPos1 = ICurve::PP_MID ;       // nell'interno
     // verifica posizione intersezione su seconda linea
      int nPos2 = ICurve::PP_NULL ;     // fuori
-      if ( nS2Side == 0 ||  nE2Side == 0) {
-         if( nS2Side == 0) {
-            nPos2 = ICurve::PP_START ;
-            m_Info.IciB[0].dU = 0 ;
-            m_Info.IciA[0].dU = vtDir1 * (ptS2 - ptS1) / Pow( vtDir1.Len(), 2) ;
-         }
-         else {
-            nPos2 = ICurve::PP_END ;
-            m_Info.IciB[0].dU = 1 ;
-            m_Info.IciA[0].dU = vtDir1 * (ptE2 - ptS1) / Pow( vtDir1.Len(), 2) ;
-         }
-      }
-      else {
-         if ( abs( m_Info.IciB[0].dU * dLen2XY) < EPS_SMALL)
-            nPos2 = ICurve::PP_START ;     // vicino a inizio
-         else if ( abs(( 1 - m_Info.IciB[0].dU) * dLen2XY) < EPS_SMALL)
-            nPos2 = ICurve::PP_END ;       // vicino a fine
-         else if ( m_Info.IciB[0].dU > 0  &&  m_Info.IciB[0].dU < 1)
-            nPos2 = ICurve::PP_MID ;       // nell'interno
-         else
-            return ;
-      }     // limito i parametri a stare sui segmenti (0...1)
+      if ( abs( m_Info.IciB[0].dU * dLen2XY) < EPS_SMALL)
+         nPos2 = ICurve::PP_START ;     // vicino a inizio
+      else if ( abs(( 1 - m_Info.IciB[0].dU) * dLen2XY) < EPS_SMALL)
+         nPos2 = ICurve::PP_END ;       // vicino a fine
+      else if ( m_Info.IciB[0].dU > 0  &&  m_Info.IciB[0].dU < 1)
+         nPos2 = ICurve::PP_MID ;       // nell'interno
+     // se soluzione non accettata, esco
+      if ( nPos1 == ICurve::PP_NULL  ||  nPos2 == ICurve::PP_NULL)
+         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)
@@ -253,7 +190,7 @@ IntersLineLine::IntersFiniteLines( const CurveLine& Line1, const CurveLine& Line
      m_Info.IciA[0].nNextTy = ICCT_NULL ;
      m_Info.IciB[0].nPrevTy = ICCT_NULL ;
      m_Info.IciB[0].nNextTy = ICCT_NULL ;
-      // si incontrano alle estremità, non si può dire alcunché
+      // si incontrano alle estremità, non si può dire alcunché
      if ( ( nPos1 == ICurve::PP_START  ||  nPos1 == ICurve::PP_END)  &&
           ( nPos2 == ICurve::PP_START  ||  nPos2 == ICurve::PP_END)) {
         ; // rimangono tutti NULL
@@ -13,18 +13,12 @@

 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "CurveLine.h"
-#include "CurveBezier.h"
-#include "CurveComposite.h"
-#include "SurfFlatRegion.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
-#include "/EgtDev/Include/EGkDistLineLine.h"
-#include "/EgtDev/Include/EGkDistPointSurfFr.h"
 #include "/EgtDev/Include/EGkIntersLineTria.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
 #include "/EgtDev/Include/EGkIntersLineSurfBez.h"
 #include "/EgtDev/Include/EGkSurfBezier.h"
-#include "/EgtDev/Include/ENkPolynomialRoots.h"
+#include "DistPointLine.h"
+#include "CurveLine.h"

 using namespace std ;

@@ -34,6 +28,7 @@ RefineIntersNewton( const Point3d& ptL, const Vector3d& vtL, double dLen, bool b
                    const ISurfBezier* pSurfBz, Point3d& ptSP, Point3d& ptIBz)
 {
  // la funzione raffina la posisione del punto ptSP, minimizzando la distanza dalla retta e restituisce il punto di intersezione ptIBz
+   pSurfBz->GetPointD1D2( ptSP.x / SBZ_TREG_COEFF, ptSP.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
  // usando un algoritmo di newton cerco di avvicinarmi il più possibile alla retta
   DistPointLine dpl( ptIBz, ptL, vtL, dLen, bFinite) ;
   double dDistNew = 0, dDistPre = 0 ;
@@ -47,18 +42,18 @@ RefineIntersNewton( const Point3d& ptL, const Vector3d& vtL, double dLen, bool b
   while ( dDistNew > EPS_SMALL  &&  nCount < 100) {
      dDistPre = dDistNew ;
      Point3d ptIBzNew1 ;
-      pSurfBz->GetPointD1D2( ( ptSP.x + dh), ptSP.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew1) ;
+      pSurfBz->GetPointD1D2( ( ptSP.x + dh)  / SBZ_TREG_COEFF, ptSP.y  / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew1) ;
      DistPointLine dplNewU( ptIBzNew1, ptL, vtL, dLen, bFinite) ;
      dplNewU.GetDist( dDistNew) ;
      double dfdU = ( dDistNew - dDistPre) / dh ;
      Point3d ptIBzNew2 ;
-      pSurfBz->GetPointD1D2( ptSP.x, ( ptSP.y + dh), ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew2) ;
+      pSurfBz->GetPointD1D2( ptSP.x  / SBZ_TREG_COEFF, ( ptSP.y + dh) / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew2) ;
      DistPointLine dplNewV( ptIBzNew2, ptL, vtL, dLen, bFinite) ;
      dplNewV.GetDist( dDistNew) ;
      double dfdV = ( dDistNew - dDistPre) / dh ;
     // mi avvicino cercando di annullare la distanza in un colpo solo
      double dr = - dDistPre / ( dfdU + dfdV) ;
-      pSurfBz->GetPointD1D2(( ptSP.x + dr * dfdU), ( ptSP.y + dr * dfdV), ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
+      pSurfBz->GetPointD1D2(( ptSP.x + dr * dfdU) / SBZ_TREG_COEFF, ( ptSP.y + dr * dfdV) / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
      DistPointLine dplNew( ptIBz, ptL, vtL, dLen, bFinite) ;
      dplNew.GetDist( dDistNew) ;
      ++ nCount ;
@@ -72,11 +67,11 @@ static void
 UpdateInfoIntersLineSurfBz( const Point3d& ptL, const Vector3d& vtDir, int nILT, int nT, const Point3d& ptSP, const Point3d& ptIBz, double dCos,
                            const Point3d& ptSP2, const Point3d& ptIBz2, double dCos2, ILSBIVECTOR& vInfo)
 {
-   if ( nILT == ILTA_IN  ||  nILT == ILTA_EDGE  ||  nILT == ILTA_VERT  ||  nILT == ILTA_NO_TRIA) {
+   if ( nILT == ILTT_IN  ||  nILT == ILTT_EDGE  ||  nILT == ILTT_VERT) {
      double dU = ( ptIBz - ptL) * vtDir ;
      vInfo.emplace_back( nILT, dU, nT, dCos, ptIBz, ptSP) ;
   }
-   else if ( nILT == ILTA_SEGM  ||  nILT == ILTA_SEGM_ON_EDGE) {
+   else if ( nILT == ILTT_SEGM  ||  nILT == ILTT_SEGM_ON_EDGE) {
      double dU = ( ptIBz - ptL) * vtDir ;
      double dU2 = ( ptIBz2 - ptL) * vtDir ;
      vInfo.emplace_back( nILT, dU, dU2, nT, dCos2, ptIBz, ptIBz2, ptSP, ptSP2) ;
@@ -88,13 +83,13 @@ static void
 OrderInfoIntersLineSurfBz( ILSBIVECTOR& vInfo)
 {
   // se non trovati, esco 
-   if ( vInfo.empty())
+   if ( vInfo.size() == 0)
      return ;
   // ordino il vettore delle intersezioni secondo il senso crescente del parametro di linea
   sort( vInfo.begin(), vInfo.end(), 
      []( const IntLinSbzInfo& a, const IntLinSbzInfo& b)
-      {  double dUa = ( ( a.nILTA == ILTA_SEGM  ||  a.nILTA == ILTA_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
-         double dUb = ( ( b.nILTA == ILTA_SEGM  ||  b.nILTA == ILTA_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
+      {  double dUa = ( ( a.nILTT == ILTT_SEGM  ||  a.nILTT == ILTT_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
+   double dUb = ( ( b.nILTT == ILTT_SEGM  ||  b.nILTT == ILTT_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
   return ( dUa < dUb) ; }) ;
 }

@@ -142,16 +137,16 @@ IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
         pSurfTm->GetTriangle( InfoTm.nT, nVert) ;
         double dU0, dV0 ;
         pSurfTm->GetVertexParam( nVert[0], dU0, dV0) ;
-         ptSP = ptSP + Point3d( dU0, dV0, 0) ;
+         ptSP = ptSP + Point3d(dU0, dV0, 0) ;
         if ( ! RefineIntersNewton( ptL,vtL, dLen, bFinite, pSurfBz, ptSP, ptIBz))
            return false ;
      }
      Vector3d vtN ;
-      pSurfBz->GetPointNrmD1D2(ptSP.x, ptSP.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz, vtN) ;
+      pSurfBz->GetPointNrmD1D2(ptSP.x / SBZ_TREG_COEFF, ptSP.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz, vtN) ;
      double dCos = vtN * vtL ;
      double dCos2 = 0 ;
      // eventualmente ripeto tutto per ptI2 ( se ho un'intersezione con sovrapposizione)
-      if ( InfoTm.nILTT == ILTA_SEGM || InfoTm.nILTT == ILTA_SEGM_ON_EDGE ) {
+      if ( InfoTm.nILTT == ILTT_SEGM || InfoTm.nILTT == ILTT_SEGM_ON_EDGE ) {
         pSurfBz->UnprojectPointFromStm( InfoTm.nT, InfoTm.ptI2, ptSP2, InfoTm.nILTT) ;
         if ( ! RefineIntersNewton(ptL, vtL, dLen, bFinite, pSurfBz, ptSP2, ptIBz2) ) {
            int nVert[3] ;
@@ -162,7 +157,7 @@ IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
            if ( ! RefineIntersNewton( ptL,vtL, dLen, bFinite, pSurfBz, ptSP, ptIBz))
               return false ;
         }
-         pSurfBz->GetPointNrmD1D2( ptSP2.x, ptSP2.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz2, vtN) ;
+         pSurfBz->GetPointNrmD1D2( ptSP2.x / SBZ_TREG_COEFF, ptSP2.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz2, vtN) ;
         dCos2 = vtN * vtL ;
      }
      UpdateInfoIntersLineSurfBz( ptL, vtL, InfoTm.nILTT, InfoTm.nT, ptSP, ptIBz, dCos, ptSP2, ptIBz2, dCos2, vInfo) ;
@@ -181,7 +176,7 @@ FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters)
   // ciclo sulle intersezioni
   for ( const auto& Info : vInfo) {
      // se intersezione puntuale
-      if ( Info.nILTA == ILTA_VERT  ||  Info.nILTA == ILTA_EDGE  ||  Info.nILTA == ILTA_IN) {
+      if ( Info.nILTT == ILTT_VERT  ||  Info.nILTT == ILTT_EDGE  ||  Info.nILTT == ILTT_IN) {
         int nFlag = LSBT_TOUCH ;
         if ( Info.dCosDN > EPS_ZERO)
            nFlag = LSBT_OUT ;
@@ -190,7 +185,7 @@ FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters)
         vInters.emplace_back( nFlag, Info.dU) ;
      }
      // se altrimenti intersezione con coincidenza
-      else if ( Info.nILTA == ILTA_SEGM  ||  Info.nILTA == ILTA_SEGM_ON_EDGE) {
+      else if ( Info.nILTT == ILTT_SEGM  ||  Info.nILTT == ILTT_SEGM_ON_EDGE) {
         vInters.emplace_back( LSBT_TG_INI, Info.dU) ;
         vInters.emplace_back( LSBT_TG_FIN, Info.dU2) ;
      }
@@ -237,255 +232,3 @@ FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters)
   }
   return true ;
 }
-
-//----------------------------------------------------------------------------
-//  Intersezione di una linea con una superficie di Bezier
-//----------------------------------------------------------------------------
-bool
-IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfBezier* pSurfBz,
-                          ILSBIVECTOR& vInfo, bool bFinite)
-{
-   int nDegU, nDegV, nSpanU, nSpanV ;
-   bool bRat, bTrimmed ;
-   pSurfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
-
-   // funzione pensata per funzionare solo con una monopatch bilineare
-   if ( nDegU > 1 || nDegV > 1 ||  nSpanU > 1  || nSpanV > 1 || bRat)
-      return false ;
-
-   int nInters = int( vInfo.size()) ;
-
-   PNTVECTOR vPntCtrl ;
-   for ( int p = 0 ; p < 4 ; ++p) {
-      bool bOk = false ;
-      vPntCtrl.push_back( pSurfBz->GetControlPoint( p, &bOk)) ;
-   }
-
-   Vector3d a = vPntCtrl[3] - vPntCtrl[1] + ( vPntCtrl[0] - vPntCtrl[2]) ;
-   Vector3d b = vPntCtrl[1] - vPntCtrl[0] ;
-   Vector3d c = vPntCtrl[2] - vPntCtrl[0] ;
-   Vector3d d =  vPntCtrl[0] - ORIG ;
-
-   double A1 =  a.x * vtL.z - a.z * vtL.x ;
-   double B1 =  b.x * vtL.z - b.z * vtL.x ;
-   double C1 =  c.x * vtL.z - c.z * vtL.x ;
-   double A2 =  a.y * vtL.z - a.z * vtL.y ;
-   double B2 =  b.y * vtL.z - b.z * vtL.y ;
-   double C2 =  c.y * vtL.z - c.z * vtL.y ;
-
-   double D1 = ( d.x - ptL.x) * vtL.z - ( d.z - ptL.z) * vtL.x ;
-   double D2 = ( d.y - ptL.y) * vtL.z - ( d.z - ptL.z) * vtL.y ;
-
-   DBLVECTOR vdCoeff, vdRoots ;
-   vdCoeff = { (B2 * D1 - B1 * D2), ( A2 * D1 - A1 * D2 + B2 * C1 - B1 * C2), ( A2 * C1 - A1 * C2)} ;
-   int nRoots = PolynomialRoots( 2, vdCoeff, vdRoots) ;
-   bool bFound = false ;
-   for ( int w = 0 ; w < nRoots ; ++w) {
-      if ( vdRoots[w] > 0 - EPS_ZERO && vdRoots[w] < 1 + EPS_ZERO ) {
-         double dU = 0, dV = vdRoots[w] ;
-         // verifico che non sia una soluzione con molteplicità > 1
-         bool bAlreadyFound = false ;
-         for ( int k = w - 1 ; k >= 0 &&  ! bAlreadyFound ; --k)
-            bAlreadyFound = abs( dV - vdRoots[k]) < EPS_PARAM ;
-         if ( ! bAlreadyFound) {
-            dU = (dV * (C1 - C2) + ( D1 - D2)) / ( dV * ( A2 - A1) + ( B2 - B1)) ;
-            if ( dU > - EPS_ZERO  &&  dU < 1 + EPS_ZERO) {
-               Point3d ptIBez, ptIBez2 ;
-               Vector3d vtN ;
-               pSurfBz->GetPointNrmD1D2(dU, dV, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez, vtN) ;
-               Point3d ptSP( dU, dV, 0), ptSP2 ;
-               double dCos = vtN * vtL, dCos2 = 0 ;
-               UpdateInfoIntersLineSurfBz( ptL, vtL, ILTA_NO_TRIA, -1, ptSP, ptIBez, dCos, ptSP2, ptIBez2, dCos2, vInfo) ;
-               bFound = true ;
-            }
-         }
-      }
-   }
-
-   // se tutti i coefficienti sono zero allora potrei avere una linea che giace sulla superficie
-   // per trovare i punti di inizio e fine sovrapposizione trovo i punti a minima distanza tra la linea e gli edge della superficie
-   if ( ! bFound  &&  abs( vdCoeff[0]) < EPS_ZERO  &&  abs( vdCoeff[1]) < EPS_ZERO  &&  abs( vdCoeff[2]) < EPS_ZERO) {
-      ICRVCOMPOPOVECTOR vCrvEdge( 4) ;
-      vCrvEdge[0].Set(pSurfBz->GetCurveOnU( 0)) ;
-      vCrvEdge[1].Set(pSurfBz->GetCurveOnV( 1)) ;
-      vCrvEdge[2].Set(pSurfBz->GetCurveOnU( 1)) ;
-      vCrvEdge[3].Set(pSurfBz->GetCurveOnV( 0)) ;
-      double dAngTolDeg = 5 ;
-      for ( int i = 0 ; i < 4 ; ++i) {
-         PolyLine plApprox ; vCrvEdge[0]->ApproxWithLines( EPS_SMALL, dAngTolDeg, ICurve::ApprLineType::APL_STD, plApprox) ;
-         //CurveComposite cCC ;
-         //cCC.FromPolyLine( plApprox) ;
-         int nClosestLine = -1 ;
-         double dMinDist = INFINITO ;
-         Point3d pt ;  plApprox.GetFirstPoint( pt) ;
-         Point3d ptClosest ;
-         int c = 0 ;
-         int nTot = plApprox.GetPointNbr() ;
-         for ( int j = 0 ; j < nTot ; ++j) {
-            DistPointLine dpl( pt, ptL, vtL, dLen, bFinite) ;
-            double dDist = INFINITO ;
-            dpl.GetDist( dDist) ;
-            if ( dDist < dMinDist) {
-               nClosestLine = c ;
-               dMinDist = dDist ;
-            }
-            plApprox.GetNextPoint( pt) ;
-            ++ c ;
-         }
-
-         Point3d ptInt1, ptInt2 ;
-         if ( nClosestLine < nTot - 1  && nClosestLine > 0) {
-            // tra i due tratti dell'approssimazione che arrivano al punto selezionato come più vicino, devo trovare quale si avvicina di più
-            Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ;
-            Point3d ptEnd ;
-            for ( int z = 1 ; z < nClosestLine - 1 ; ++z)
-               plApprox.GetNextPoint( ptStart) ;
-            plApprox.GetNextPoint( ptEnd) ;
-            // linea precedente al punto
-            Vector3d vtLinePre = ptEnd - ptStart ;
-            double dLenPre = vtLinePre.Len() ;
-            DistLineLine dllPre( ptStart, vtLinePre, dLenPre, ptL, vtL,dLen) ;
-            double dDistPre = INFINITO ;
-            dllPre.GetDist( dDistPre) ;
-            // linea che inzia con quel punto
-            ptStart = ptEnd ;
-            plApprox.GetNextPoint( ptEnd) ;
-            Vector3d vtLineCurr = ptEnd - ptStart ;
-            double dLenCurr = vtLineCurr.Len() ;
-            DistLineLine dllCurr( ptStart, vtLineCurr, dLenCurr, ptL, vtL,dLen) ;
-            double dDistCurr = INFINITO ;
-            dllCurr.GetDist( dDistCurr) ;
-
-            if ( dDistPre < dDistCurr)
-               dllPre.GetMinDistPoints( ptInt1, ptInt2) ;
-            else
-               dllCurr.GetMinDistPoints( ptInt1, ptInt2) ;
-         }
-         else if ( nClosestLine == 0) {
-            // il punto più vicino è sulla prima linea
-            Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ;
-            Point3d ptEnd ; plApprox.GetNextPoint( ptEnd) ;
-            Vector3d vtLineCurr = ptEnd - ptStart ;
-            double dLenCurr = vtLineCurr.Len() ;
-            DistLineLine dllCurr( ptStart, vtLineCurr, dLenCurr, ptL, vtL,dLen) ;
-            dllCurr.GetMinDistPoints( ptInt1, ptInt2) ;
-         }
-         else if ( nClosestLine == nTot- 1) {
-            // il punto più vicino è sull'ultima linea
-            Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ;
-            Point3d ptEnd ;
-            for ( int z = 1 ; z < nClosestLine - 1 ; ++z)
-               plApprox.GetNextPoint( ptStart) ;
-            plApprox.GetNextPoint( ptEnd) ;
-            Vector3d vtLinePre = ptEnd - ptStart ;
-            double dLenPre = vtLinePre.Len() ;
-            DistLineLine dllCurr( ptStart, vtLinePre, dLenPre, ptL, vtL,dLen) ;
-            dllCurr.GetMinDistPoints( ptInt1, ptInt2) ;
-         }
-         
-         double dU1 = 0, dV1 = 0, dU2 = 0, dV2 = 0 ;
-         // se ho trovato due punti vuol dire che la linea coincide con un edge e ho trovato tutto quello che serve
-         if ( ! AreSamePointExact( ptInt2, ORIG)) {
-            if ( i == 0) {
-               //dV1 = 0 ; dV2 = 0 ;
-               vCrvEdge[0]->GetParamAtPoint( ptInt1, dU1) ;
-               vCrvEdge[0]->GetParamAtPoint( ptInt2, dU2) ;
-            }
-            else if ( i == 1) {
-               //dU1 = 1 ; dU2 = 1 ;
-               vCrvEdge[1]->GetParamAtPoint( ptInt1, dV1) ;
-               vCrvEdge[1]->GetParamAtPoint( ptInt2, dV2) ;
-            }
-            else if ( i == 2){
-               //dV1 = 1 ; dV2 = 1 ;
-               vCrvEdge[2]->GetParamAtPoint( ptInt1, dU1) ;
-               vCrvEdge[2]->GetParamAtPoint( ptInt2, dU2) ;
-            }
-            else if ( i == 3){
-               //dU1 = 0 ; dU2 = 0 ;
-               vCrvEdge[3]->GetParamAtPoint( ptInt1, dV1) ;
-               vCrvEdge[3]->GetParamAtPoint( ptInt2, dV2) ;
-            }
-            Point3d ptIBez1, ptIBez2 ;
-            Vector3d vtN1, vtN2 ;
-            pSurfBz->GetPointNrmD1D2(dU1, dV1, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez1, vtN1) ;
-            pSurfBz->GetPointNrmD1D2(dU2, dV2, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez2, vtN2) ;
-            Point3d ptSP1( dU1, dV1, 0) ;
-            double dCos1 = vtN1 * vtL ;
-            Point3d ptSP2( dU2, dV2, 0) ;
-            double dCos2 = vtN2 * vtL ;
-            // se avevo già trovato un punto singolo che coincide col primo punto di questa intersezione sovrapposta, allora cancello l'intersezione singola che
-            // avevo salvato e aggiungo quella sovrapposto che ho trovato ora
-            if ( bFound) {
-               int nNewTot = int(vInfo.size()) ;
-               int nNewInters = nNewTot - nInters ;
-               bool bAlreadyFound = false ;
-               for ( int i = 0 ; i < nNewInters ; ++i) {
-                  bAlreadyFound = AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP1) ||  AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP2) ;
-                  if ( bAlreadyFound) {
-                     vInfo.erase( vInfo.begin() + nNewTot - i) ;
-                     break ;
-                  }
-               }
-            }
-            UpdateInfoIntersLineSurfBz( ptL, vtL, ILTA_NO_TRIA, -1, ptSP1, ptIBez1, dCos1, ptSP2, ptIBez2, dCos2, vInfo) ;
-            bFound = true ;
-            break ;
-         }
-         // se ho trovato un punto a distanza zero dalla linea allora ho trovato l'intersezione
-         else if ( dMinDist < EPS_SMALL) {
-            if ( i == 0) {
-               //dV1 = 0 ;
-               vCrvEdge[0]->GetParamAtPoint( ptInt1, dU1) ;
-            }
-            else if ( i == 1) {
-               //dU1 = 1 ;
-               vCrvEdge[1]->GetParamAtPoint( ptInt1, dV1) ;
-            }
-            else if ( i == 2) {
-               //dV1 = 1 ;
-               vCrvEdge[2]->GetParamAtPoint( ptInt1, dU1) ;
-            }
-            else if ( i == 3) {
-               //dU1 = 0 ;
-               vCrvEdge[3]->GetParamAtPoint( ptInt1, dV1) ;
-            }
-            Point3d ptSP1( dU1, dV1, 0), ptSP2 ;
-            // se avevo trovato già altri punti controllo di non essere esattamente su una diagonale ( e quindi avere un'intersezione con ogni edge, ma due sono doppie)
-            if ( bFound) {
-               int nNewTot = int(vInfo.size()) ;
-               int nNewInters = nNewTot - nInters ;
-               bool bAlreadyFound = false ;
-               for ( int i = 0 ; i < nNewInters ; ++i)
-                  bAlreadyFound = AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP1) ;
-               if ( bAlreadyFound)
-                  continue ;
-            }
-
-            Point3d ptIBez1, ptIBez2 ;
-            Vector3d vtN1, vtN2 ;
-            pSurfBz->GetPointNrmD1D2(dU1, dV1, ISurfBezier::Side::FROM_MINUS, ISurfBezier::Side::FROM_MINUS, ptIBez1, vtN1) ;
-            double dCos1 = vtN1 * vtL, dCos2 = 0 ;
-            UpdateInfoIntersLineSurfBz( ptL, vtL, ILTA_NO_TRIA, -1, ptSP1, ptIBez1, dCos1, ptSP2, ptIBez2, dCos2, vInfo) ;
-            bFound = true ;
-         }
-      }
-   }
-
-   // se la superficie è trimmed verifico che i punti trovati siano all'interno del parametrico trimmato
-   if ( bTrimmed  &&  bFound) {
-      int nNewTot = int(vInfo.size()) ;
-      int nNewInters = nNewTot - nInters ;
-      const ISurfFlatRegion* pFRTrim = pSurfBz->GetTrimRegion() ;
-      for ( int i = 0 ; i < nNewInters ; ++i) {
-         Point3d ptTest = vInfo[nNewTot - i].ptUV * SBZ_TREG_COEFF ;
-         bool bInside = false ;
-         double dDist = INFINITO ;
-         IsPointInsideSurfFr( ptTest, pFRTrim, dDist, bInside) ;
-         if ( ! bInside)
-            vInfo.erase( vInfo.begin() + nNewTot - i) ;
-      }
-   }
-
-   return true ;
-}
@@ -1662,7 +1662,7 @@ LineTorus( const Point3d& ptLine, const Vector3d& vtLine,
  // Riordino le soluzioni
   for ( int ni = 0 ; ni < int( vdPar.size()) - 1 ; ++ ni) {
      for ( int nj = ni ; nj < int( vdPar.size()) ; ++ nj) {
-         if ( vdPar[ni] > vdPar[nj]) {
+         if( vdPar[ni] > vdPar[nj]) {
            swap( vdPar[ni], vdPar[nj]) ;
         }
      }
@@ -1670,7 +1670,7 @@ LineTorus( const Point3d& ptLine, const Vector3d& vtLine,

  // Studio le soluzioni
   int nIntType = T_ERROR ;
-   if ( vdPar.empty()) 
+   if ( vdPar.size() == 0) 
      nIntType = T_NO_INT ;
   else if ( vdPar.size() == 1) {
      nIntType = T_ONE_TAN ;
@@ -23,20 +23,20 @@ using namespace std ;
 //----------------------------------------------------------------------------
 static void
 UpdateInfoIntersLineSurfTm( const Point3d& ptL, const Vector3d& vtDir, double dLen,
-                            int nStm, int nT, const Triangle3d& Tria, ILSIVECTOR& vInfo, bool bFinite)
+                            int nT, const Triangle3d& Tria, ILSIVECTOR& vInfo, bool bFinite)
 {
   Point3d ptInt, ptInt2 ;
   int nRes = IntersLineTria( ptL, vtDir, dLen, Tria, ptInt, ptInt2, bFinite) ;
   if ( nRes == ILTT_IN  ||  nRes == ILTT_EDGE  ||  nRes == ILTT_VERT) {
      double dU = ( ptInt - ptL) * vtDir ;
      double dCosDN = vtDir * Tria.GetN() ;
-      vInfo.emplace_back( nRes, dU, nStm, nT, dCosDN, ptInt) ;
+      vInfo.emplace_back( nRes, dU, nT, dCosDN, ptInt) ;
   }
   else if ( nRes == ILTT_SEGM  ||  nRes == ILTT_SEGM_ON_EDGE) {
      double dU = ( ptInt - ptL) * vtDir ;
      double dU2 = ( ptInt2 - ptL) * vtDir ;
      double dCosDN = vtDir * Tria.GetN() ;
-      vInfo.emplace_back( nRes, dU, dU2, nStm, nT, dCosDN, ptInt, ptInt2) ;
+      vInfo.emplace_back( nRes, dU, dU2, nT, dCosDN, ptInt, ptInt2) ;
   }
 }

@@ -45,15 +45,13 @@ static void
 OrderInfoIntersLineSurfTm( ILSIVECTOR& vInfo)
 {
  // se non trovati, esco 
-   if ( vInfo.empty())
+   if ( vInfo.size() == 0)
      return ;
  // ordino il vettore delle intersezioni secondo il senso crescente del parametro di linea
-   sort( vInfo.begin(), vInfo.end(),
+   sort( vInfo.begin(), vInfo.end(), 
            []( const IntLinStmInfo& a, const IntLinStmInfo& b)
               {  double dUa = ( ( a.nILTT == ILTT_SEGM  ||  a.nILTT == ILTT_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
                  double dUb = ( ( b.nILTT == ILTT_SEGM  ||  b.nILTT == ILTT_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
-                  if ( abs( dUa - dUb) < EPS_SMALL)
-                     return ( a.dCosDN < b.dCosDN) ;
                  return ( dUa < dUb) ; }) ;
 }

@@ -108,7 +106,7 @@ IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
               Triangle3d Tria ;
               Stm.GetTriangle( nT, Tria) ;
              // aggiorno info con intersezione
-               UpdateInfoIntersLineSurfTm( ptL, vtDir, dLen, 0, nT, Tria, vInfo, bFinite) ;
+               UpdateInfoIntersLineSurfTm( ptL, vtDir, dLen, nT, Tria, vInfo, bFinite) ;
            }
         }
      }
@@ -124,23 +122,19 @@ IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
 //  Intersezione di molte linee parallele con una superficie TriMesh
 //----------------------------------------------------------------------------
 IntersParLinesSurfTm::IntersParLinesSurfTm( const Frame3d& frLines, const ISurfTriMesh& Stm)
-   : m_bOk( false), m_frLines( frLines), m_vpSTm( {&Stm})
+   : m_bOk( false), m_frLines( frLines), m_pSTm( &Stm)
 {
  // verifico esistenza superficie
-   if ( m_vpSTm[0] == nullptr  ||  ! m_vpSTm[0]->IsValid())
+   if ( m_pSTm == nullptr  ||  ! m_pSTm->IsValid())
      return ;

-  // aggiorno il vettore degli indici di base per mappare i triangoli con le rispettivi superfici
-  // ( in questo caso la superficie è unica, quindi ho solo due elementi)
-   m_vBaseInd = { 0, m_vpSTm[0]->GetTriangleCount()} ;
-
-  // creo HashGrid 2d ed eventualmente attivo la griglia
+  // creo HashGrid 2d
   const int LIM_HG_TRIA = 127 ;
-   m_HGrids.SetActivationGrid( m_vBaseInd.back() > LIM_HG_TRIA) ;
+   m_HGrids.SetActivationGrid( m_pSTm->GetTriangleCount() > LIM_HG_TRIA) ;

-  // riempio HashGrid
+  // riempio HashGrid 
   Triangle3d Tria ;
-   int nT = m_vpSTm[0]->GetFirstTriangle( Tria) ;
+   int nT = Stm.GetFirstTriangle( Tria) ;
   while ( nT != SVT_NULL) {
     // calcolo il BBox del triangolo nel riferimento scelto
      Tria.ToLoc( m_frLines) ;
@@ -149,55 +143,10 @@ IntersParLinesSurfTm::IntersParLinesSurfTm( const Frame3d& frLines, const ISurfT
      b3Tria.Add( Tria.GetP( 1)) ;
      b3Tria.Add( Tria.GetP( 2)) ;
     // inserisco nella griglia
-      if ( ! m_HGrids.Add( nT, b3Tria))  // ( 0 + nT, Tria)
+      if ( ! m_HGrids.Add( nT, b3Tria))
         return ;
-     // passo al prossimo triangolo
-      nT = m_vpSTm[0]->GetNextTriangle( nT, Tria) ;
-   }
-  // aggiorno
-   m_bOk = m_HGrids.Update() ;
-}
-
-//----------------------------------------------------------------------------
-//  Intersezione di molte linee parallele con un vettore di superfici TriMesh
-//----------------------------------------------------------------------------
-IntersParLinesSurfTm::IntersParLinesSurfTm( const Frame3d& frLines, const CISURFTMPVECTOR& vStm)
-   : m_bOk( false), m_frLines( frLines), m_vpSTm( vStm), m_vBaseInd( {0})
-{
-  // verifico esistenza superfici
-   if ( m_vpSTm.empty())
-      return ;
-   for ( const ISurfTriMesh* pStm : m_vpSTm) {
-      if ( pStm == nullptr  ||  ! pStm->IsValid())
-         return ;
-   }
-
-  // aggiorno il vettore degli indici di base per mappare i triangoli con le rispettivi superfici
-  // NB. dal costruttore è già inizializzato a {0}
-   for ( int i = 0 ; i < int( m_vpSTm.size()) ; ++ i)
-      m_vBaseInd.emplace_back( m_vBaseInd.back() + m_vpSTm[i]->GetTriangleCount()) ;
-
-  // creo HashGrid 2d ed eventualmente attivo la griglia
-   const int LIM_HG_TRIA = 256 ;
-   m_HGrids.SetActivationGrid( m_vBaseInd.back() > LIM_HG_TRIA) ;
-
-  // riempio HashGrid
-   for ( int i = 0 ; i < int( m_vpSTm.size()) ; ++ i) {
-      Triangle3d Tria ;
-      int nT = m_vpSTm[i]->GetFirstTriangle( Tria) ;
-      while ( nT != SVT_NULL) {
-        // calcolo il BBox del triangolo nel riferimento scelto
-         Tria.ToLoc( m_frLines) ;
-         BBox3d b3Tria ;
-         b3Tria.Add( Tria.GetP( 0)) ;
-         b3Tria.Add( Tria.GetP( 1)) ;
-         b3Tria.Add( Tria.GetP( 2)) ;
-        // inserisco nella griglia ( aggiungo shift per indice del triangolo)
-         if ( ! m_HGrids.Add( m_vBaseInd[i] + nT, b3Tria))
-            return ;
-        // passo al prossimo triangolo
-         nT = m_vpSTm[i]->GetNextTriangle( nT, Tria) ;
-      }
+     // passo al prossimo triangolo 
+      nT = Stm.GetNextTriangle( nT, Tria) ;
   }
  // aggiorno
   m_bOk = m_HGrids.Update() ;
@@ -211,7 +160,7 @@ IntersParLinesSurfTm::GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vI
   if ( &vInfo == nullptr)
      return false ;
   vInfo.clear() ;
-  // verifico validità
+  // verifico validità
   if ( ! m_bOk)
      return false ;

@@ -223,22 +172,15 @@ IntersParLinesSurfTm::GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vI
   Point3d ptLL = ptL ;
   ptLL.ToGlob( m_frLines) ;

-  // recupero indici triangoli che intersecano box in 2d
+  // recupero indici triangoli che intersecano box in 2d 
   INTVECTOR vnIds ;
   if ( m_HGrids.Find( b3Line, vnIds)) {
      for ( int i = 0 ; i < int( vnIds.size()) ; ++ i) {
-        // recupero la superficie
-         int nInd = vnIds[i] ;
-         int nSurf = GetSurfInd( nInd) ;
-         if ( nSurf == -1)
-            return false ;
-        // recupero il triangolo
-         int nT = nInd - m_vBaseInd[nSurf] ;
+         int nT = vnIds[i] ;
         Triangle3d Tria ;
-         if ( ! m_vpSTm[nSurf]->GetTriangle( nT, Tria))
-            return false ;
+         m_pSTm->GetTriangle( nT, Tria) ;
        // aggiorno info con intersezione
-         UpdateInfoIntersLineSurfTm( ptLL, m_frLines.VersZ(), dLen, nSurf, nT, Tria, vInfo, bFinite) ;
+         UpdateInfoIntersLineSurfTm( ptLL, m_frLines.VersZ(), dLen, nT, Tria, vInfo, bFinite) ;
      }
   }

@@ -248,35 +190,6 @@ IntersParLinesSurfTm::GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vI
   return true ;
 }

-//----------------------------------------------------------------------------
-int
-IntersParLinesSurfTm::GetSurfInd( int nT) const
-{
-  // verifico la presenza di almeno un intervallo
-   if ( m_vBaseInd.size() < 2)
-      return -1 ;
-  // se la superficie è unica, allora non devo cercarla
-   if ( int( m_vBaseInd.size()) == 2)
-      return 0 ;
-  // ricerca binaria dell'intervallo contenente la posizione del triangolo
-   int nS = 0 ;
-   int nE = int( m_vBaseInd.size()) - 1 ;
-   while ( true) {
-      if ( nT < m_vBaseInd[nS]  ||  nT >= m_vBaseInd[nE])
-         return -1 ;
-      if ( nE - nS == 1)
-         return nS ;
-      int nM = ( nS + nE) / 2 ;
-      if ( nT == m_vBaseInd[nM])
-         return nM ;
-      if ( nT < m_vBaseInd[nM])
-         nE = nM ;
-      else
-         nS = nM ;
-   }
-   return -1 ;
-}
-
 //----------------------------------------------------------------------------
 bool
 FilterLineSurfTmInters( const ILSIVECTOR& vInfo, INTDBLVECTOR& vInters)
@@ -302,7 +215,7 @@ FilterLineSurfTmInters( const ILSIVECTOR& vInfo, INTDBLVECTOR& vInters)
   for ( size_t j = 1 ; j < vInters.size() ; ) {
     // intersezione precedente
      size_t i = j - 1 ;
-     // se hanno lo stesso parametro
+     // se hanno lo stesso parametro 
      if ( abs( vInters[i].second - vInters[j].second) < EPS_SMALL) {
        // se sono entrambe entranti o uscenti, elimino la seconda
         if ( ( vInters[i].first == LST_IN  &&  vInters[j].first == LST_IN)  ||
@@ -17,8 +17,8 @@
 #include "CurveLine.h"
 #include "IntersLineLine.h"
 #include "IntersLineTria.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
-#include "/EgtDev/Include/EGkDistLineLine.h"
+#include "DistPointLine.h"
+#include "DistLineLine.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EGkFrame3d.h"
 #include <array>
@@ -42,5 +42,5 @@ Inters3Planes( const Plane3d& plPlane1, const Plane3d& plPlane2, const Plane3d&
   if ( IntersPlanePlane( plPlane1, plPlane2, ptL, vtL) != IPPT_YES)
      return IPPT_NO ;
  // intersezione della linea con il terzo piano
-   return ( IntersLinePlane( ptL, vtL, 1, plPlane3, ptInt, false) == ILPT_YES ? IPPT_YES : IPPT_NO) ;
+   return ( IntersLinePlane( ptL, vtL, 1, plPlane3, ptInt) == ILPT_YES ? IPPT_YES : IPPT_NO) ;
 }
@@ -15,7 +15,7 @@
 #include "stdafx.h"
 #include "ProjPlane.h"
 #include "CurveLine.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
 #include "/EgtDev/Include/EGkIntersPlaneSurfTm.h"
 #include "/EgtDev/Include/EGkIntersPlaneTria.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
@@ -19,7 +19,7 @@
 using namespace std ;

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

  // eseguo intersezione
   return pVzm->GetPlaneIntersection( plPlane, vpLoop) ;
@@ -13,9 +13,9 @@

 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
+#include "DistPointLine.h"
 #include "IntersLineTria.h"
 #include "DllMain.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkIntersSurfTmSurfTm.h"
 #include "/EgtDev/Include/EGkIntersTriaTria.h"
 #include "/EgtDev/Include/EGkPointGrid3d.h"
@@ -14,7 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CreateCurveAux.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
 #include "/EgtDev/Include/EGkLineTgCurvePerpCurve.h"
 #include "/EgtDev/Include/EGkLinePntTgCurve.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
@@ -14,7 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CreateCurveAux.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
 #include "/EgtDev/Include/EGkLineTgTwoCurves.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"

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

 using namespace std ;

@@ -35,12 +34,8 @@ NgeReader::Init( const string& sFileIn)
      break ;
   case NGE_BINARY :
      m_bBinary = true ;
-      m_InFile = gzopen_w( stringtoW( sFileIn), "rb") ;
-      if ( m_InFile == nullptr)
-         return false ;
-      const int DIM_BUFFER = 65536 ;
-      gzbuffer( m_InFile, DIM_BUFFER) ;
-      return true ;
+      m_InFile.open( stringtoW( sFileIn), ios::in | ios::binary, _SH_DENYWR) ;
+      return ( ! m_InFile.fail()) ;
      break ;
   }
   return false ;
@@ -51,12 +46,10 @@ bool
 NgeReader::Close( void) 
 {
   if ( m_bBinary) {
-      if ( m_InFile != nullptr) {
-         bool bOk = ( gzclose( m_InFile) == Z_OK) ;
-         m_InFile = nullptr ;
-         return bOk ;
-      }
-      return true ;
+      bool bOk = ( m_InFile.good()  &&  m_InFile.is_open()) ;
+      if ( m_InFile.is_open())
+         m_InFile.close() ;
+      return bOk ;
   }
   else
      return m_Scan.Terminate() ;
@@ -66,24 +59,31 @@ NgeReader::Close( void)
 int
 NgeReader::NgeType( const string& sFile)
 {
-  // apertura file
-   gzFile_s* InFile = gzopen_w( stringtoW( sFile), "rb") ;
-   if ( InFile == nullptr)
+  // apertura del file di ingresso
+   ifstream InFile ;
+   InFile.open( stringtoW( sFile), ios::in | ios::binary) ;
+   if ( InFile.fail())
      return NGE_ERROR ;
-  // lettura dei primi caratteri
-   char szBuff[9] = "\0\0\0\0\0\0\0\0" ;
-   int nLen = gzread( InFile, &szBuff, 8) ;
-   if ( gzclose( InFile) != Z_OK  ||  nLen == Z_ERRNO)
-      return NGE_ERROR ;
-  // se binario
-   if ( szBuff[0] == '\x0F'  &&  szBuff[1] == '\x0F')
-      return NGE_BINARY ;
-  // se testo
-   string sBuff{ szBuff} ;
-   if ( sBuff.find( "START") != string::npos)
+
+  // lettura dei primi 31 byte
+   char cBuff[32] ;
+   InFile.read( cBuff, 31) ;
+   cBuff[InFile.gcount()] = '\0' ;
+
+  // chiusura del file
+   InFile.close() ;
+
+  // verifico se file compresso (gz)
+   if ( cBuff[0] == '\x1F'  &&  cBuff[1] == '\x8B')
      return NGE_ASCII ;
-  // altrimenti errore
-   return NGE_ERROR ;
+
+  // verifico se iniziano con "START"
+   string sBuff = cBuff ;
+   size_t nPos = sBuff.find( "START") ;
+   if ( nPos != string::npos  &&  nPos < 10)
+      return NGE_ASCII ;
+   else
+      return NGE_BINARY ;
 }

 //----------------------------------------------------------------------------
@@ -91,7 +91,7 @@ int
 NgeReader::GetCurrPos( void)
 {
   if ( m_bBinary)
-      return int( gztell( m_InFile)) ;
+      return int( m_InFile.tellg()) ;
   else
      return m_Scan.GetCurrLineNbr() ;
 }
@@ -131,9 +131,10 @@ bool
 NgeReader::ReadUchar( unsigned char& ucVal, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
-      return ( gzread( m_InFile, &ucVal, sizeof( ucVal)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &ucVal, sizeof( ucVal)) ;
+      return m_InFile.good() ;
   }
   else {
     // recupero il token
@@ -153,9 +154,10 @@ bool
 NgeReader::ReadBool( bool& bVal, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
-      return ( gzread( m_InFile, &bVal, sizeof( bVal)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &bVal, sizeof( bVal)) ;
+      return m_InFile.good() ;
   }
   else {
     // recupero il token
@@ -171,9 +173,10 @@ bool
 NgeReader::ReadInt( int& nVal, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
-      return ( gzread( m_InFile, &nVal, sizeof( nVal)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &nVal, sizeof( nVal)) ;
+      return m_InFile.good() ;
   }
   else {
     // recupero il token
@@ -200,9 +203,10 @@ bool
 NgeReader::ReadDouble( double& dVal, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
-      return ( gzread( m_InFile, &dVal, sizeof( dVal)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &dVal, sizeof( dVal)) ;
+      return m_InFile.good() ;
   }
   else {
     // recupero il token
@@ -218,9 +222,10 @@ bool
 NgeReader::ReadVector( Vector3d& vtV, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
-      return ( gzread( m_InFile, &vtV.v, sizeof( vtV.v)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &vtV.v, sizeof( vtV.v)) ;
+      return m_InFile.good() ;
   }
   else {
     // recupero il token
@@ -236,9 +241,10 @@ bool
 NgeReader::ReadPoint( Point3d& ptP, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
-      return ( gzread( m_InFile, &ptP.v, sizeof( ptP.v)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &ptP.v, sizeof( ptP.v)) ;
+      return m_InFile.good() ;
   }
   else {
     // recupero il token
@@ -254,10 +260,11 @@ bool
 NgeReader::ReadPointW( Point3d& ptP, double& dW, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
-      return ( gzread( m_InFile, &ptP.v, sizeof( ptP.v)) != Z_ERRNO  &&
-               gzread( m_InFile, &dW, sizeof( dW)) != Z_ERRNO) ;
+      m_InFile.read( (char*) &ptP.v, sizeof( ptP.v)) ;
+      m_InFile.read( (char*) &dW, sizeof( dW)) ;
+      return m_InFile.good() ;
   }
   else {
     // recupero il token
@@ -273,13 +280,17 @@ bool
 NgeReader::ReadFrame( Frame3d& frF, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
-      Point3d ptOrig ; Vector3d vtDirX, vtDirY, vtDirZ ;
-      if ( gzread( m_InFile, &ptOrig.v, sizeof( ptOrig.v)) == Z_ERRNO  ||
-           gzread( m_InFile, &vtDirX.v, sizeof( vtDirX.v)) == Z_ERRNO  ||
-           gzread( m_InFile, &vtDirY.v, sizeof( vtDirY.v)) == Z_ERRNO  ||
-           gzread( m_InFile, &vtDirZ.v, sizeof( vtDirZ.v)) == Z_ERRNO)
+      Point3d ptOrig ;
+      m_InFile.read( (char*) &ptOrig.v, sizeof( ptOrig.v)) ;
+      Vector3d vtDirX ;
+      m_InFile.read( (char*) &vtDirX.v, sizeof( vtDirX.v)) ;
+      Vector3d vtDirY ;
+      m_InFile.read( (char*) &vtDirY.v, sizeof( vtDirY.v)) ;
+      Vector3d vtDirZ ;
+      m_InFile.read( (char*) &vtDirZ.v, sizeof( vtDirZ.v)) ;
+      if ( ! m_InFile.good())
         return false ;
      return frF.Set( ptOrig, vtDirX, vtDirY, vtDirZ) ;
   }
@@ -297,20 +308,18 @@ bool
 NgeReader::ReadString( string& sVal, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
-         return false ;
      const int MAX_STR_DIM = 65535 ;
-      int nDim ;
-      if ( gzread( m_InFile, &nDim, sizeof( nDim)) == Z_ERRNO  ||  nDim > MAX_STR_DIM)
+      if ( ! m_InFile.is_open())
+         return false ;
+      int nDim ;
+      m_InFile.read( (char*) &nDim, sizeof( nDim)) ;
+      if ( nDim > MAX_STR_DIM  ||  ! m_InFile.good())
         return false ;
-      if ( nDim == 0) {
-         sVal = "" ;
-         return true ;
-      }
      char* szBuff = new( nothrow) char[ nDim + 1] ;
      if ( szBuff == nullptr)
         return false ;
-      if ( gzread( m_InFile, szBuff, nDim) == Z_ERRNO) {
+      m_InFile.read( szBuff, nDim) ;
+      if ( ! m_InFile.good()) {
         delete[] szBuff ;
         return false ;
      }
@@ -339,11 +348,12 @@ NgeReader::ReadKey( int& nKey)
      return true ;
   }
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
     // leggo il dato
      int nVal ;
-      if ( gzread( m_InFile, &nVal, sizeof( nVal)) == Z_ERRNO)
+      m_InFile.read( (char*) &nVal, sizeof( nVal)) ;
+      if ( ! m_InFile.good())
         return false ;
     // ricavo l'indice
      for ( int i = 0 ; i <= NGE_LAST_ID ; ++ i) {
@@ -376,10 +386,11 @@ bool
 NgeReader::ReadCol( Color& cCol, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_InFile == nullptr)
+      if ( ! m_InFile.is_open())
         return false ;
      unsigned char ucCol[4] ;
-      if ( gzread( m_InFile, &ucCol, sizeof( ucCol)) == Z_ERRNO)
+      m_InFile.read( (char*) &ucCol, sizeof( ucCol)) ;
+      if ( ! m_InFile.good())
         return false ;
      cCol.Set( ucCol[0], ucCol[1], ucCol[2], ucCol[3]) ;
      return true ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2025
+//  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : NgeReader.h          Data : 29.12.25           Versione : 2.7l6
+// File : NgeReader.h          Data : 14.04.14           Versione : 1.5d5
 // Contenuto : Dichiarazione della classe NgeReader.
 //
 //
@@ -18,16 +18,14 @@
 #include "/EgtDev/Include/EGkColor.h"
 #include "/EgtDev/Include/EGnScanner.h"
 #include "/EgtDev/Include/EgtStringBase.h"
-
-struct gzFile_s ;
+#include <fstream>

 //----------------------------------------------------------------------------
 class NgeReader
 {
   public :
      NgeReader( void)
-            : m_bBinary( false), m_InFile( nullptr), m_iPosStart( std::string::npos),
-              m_bUngetKey( false), m_nLastKey(), m_nFileVer() {}
+            : m_iPosStart( std::string::npos), m_bUngetKey( false), m_nFileVer() {}
      ~NgeReader( void)
            { Close() ; }
      bool Init( const std::string& sFileIn) ;
@@ -62,7 +60,7 @@ class NgeReader
   private :
      bool                   m_bBinary ;
      // per file binari
-      gzFile_s*              m_InFile ;
+      std::ifstream          m_InFile ;
      // per file ASCII
      Scanner                m_Scan ;
      std::string::size_type m_iPosStart ;
@@ -23,23 +23,23 @@
 using namespace std ;

 //----------------------------------------------------------------------------
-static bool
-WriteStringOutTxt( gzFile OutFile, const char* szVal, const char* szSep, bool bEndL)
+inline bool
+WriteStringOutTxt( gzFile OutTxtFile, const char* szVal, const char* szSep, bool bEndL)
 {
  // verifico apertura file
-   if ( OutFile == nullptr)
+   if ( OutTxtFile == nullptr)
      return false ;
  // scrivo stringa
-   if ( gzputs( OutFile, szVal) == Z_ERRNO)
+   if ( gzputs( OutTxtFile, szVal) == Z_ERRNO)
      return false ;
  // se fornito, scrivo separatore
   if ( szSep != nullptr  &&  szSep[0] != '\0') {
-      if ( gzputs( OutFile, szSep) == Z_ERRNO)
+      if ( gzputs( OutTxtFile, szSep) == Z_ERRNO)
         return false ;
   }
  // se richiesto, scrivo fine linea
   if ( bEndL) {
-      if ( gzputs( OutFile, "\r\n") == Z_ERRNO)
+      if ( gzputs( OutTxtFile, "\r\n") == Z_ERRNO)
         return false ;
   }
   return true ;
@@ -50,22 +50,27 @@ bool
 NgeWriter::Init( const string& sFileOut, int nFlag) 
 {
  // salvo tipo file
-   m_bBinary = ( nFlag == GDB_SV_BIN  ||  nFlag == GDB_SV_CMPBIN) ;
+   m_bBinary = ( nFlag == GDB_SV_BIN) ;

  // apertura del file di uscita
-   if ( nFlag == GDB_SV_TXT  ||  nFlag == GDB_SV_BIN) {
-      m_OutFile = gzopen_w( stringtoW( sFileOut), "wbT") ;
-      return ( m_OutFile != nullptr) ;
+   if ( m_bBinary) {
+      ios_base::openmode nMode = ios::out | ( m_bBinary ? ios::binary : 0) ;
+      int nProt = _SH_DENYWR ;
+      m_OutBinFile.open( stringtoW( sFileOut), nMode, nProt) ;
+      return m_OutBinFile.good() ;
   }
-   else {     // GDB_SV_CMPTXT  o  GDB_SV_CMPBIN
-      m_OutFile = gzopen_w( stringtoW( sFileOut), "wb") ;
-      if ( m_OutFile == nullptr)
+   else {
+      if ( nFlag == GDB_SV_TXT)
+         m_OutTxtFile = gzopen_w( stringtoW( sFileOut), "wbT") ;
+      else       // GDB_SV_CMPTXT
+         m_OutTxtFile = gzopen_w( stringtoW( sFileOut), "wb") ;
+      if ( m_OutTxtFile == nullptr)
         return false ;
      const int DIM_BUFFER = 65536 ;
-      if ( gzbuffer( m_OutFile, DIM_BUFFER) != Z_OK)
+      if ( gzbuffer( m_OutTxtFile, DIM_BUFFER) != Z_OK)
         return false ;
      const int COMPR_LEVEL = 3 ;    // 0 = no compression ... 9 = max compression
-      if ( gzsetparams( m_OutFile, COMPR_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK)
+      if ( gzsetparams( m_OutTxtFile, COMPR_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK)
         return false ;
      return true ;
   }
@@ -75,12 +80,20 @@ NgeWriter::Init( const string& sFileOut, int nFlag)
 bool
 NgeWriter::Close( void) 
 {
-   if ( m_OutFile != nullptr) {
-      bool bOk = ( gzclose( m_OutFile) == Z_OK) ;
-      m_OutFile = nullptr ;
+   if ( m_bBinary) {
+      bool bOk = ( m_OutBinFile.good()  &&  m_OutBinFile.is_open()) ;
+      if ( m_OutBinFile.is_open())
+         m_OutBinFile.close() ;
      return bOk ;
   }
-   return true ;
+   else {
+      if ( m_OutTxtFile != nullptr) {
+         bool bOk = ( gzclose( m_OutTxtFile) == Z_OK) ;
+         m_OutTxtFile = nullptr ;
+         return bOk ;
+      }
+      return true ;
+   }
 }

 //----------------------------------------------------------------------------
@@ -88,12 +101,13 @@ bool
 NgeWriter::WriteUchar( unsigned char ucVal, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      return ( gzwrite( m_OutFile, &ucVal, sizeof( ucVal)) > 0) ;
+      m_OutBinFile.write( (char*) &ucVal, sizeof( ucVal)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, ToString( ucVal).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( ucVal).c_str(), szSep, bEndL) ;
   }
 }

@@ -102,12 +116,13 @@ bool
 NgeWriter::WriteBool( bool bVal, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      return ( gzwrite( m_OutFile, &bVal, sizeof( bVal)) > 0) ;
+      m_OutBinFile.write( (char*) &bVal, sizeof( bVal)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, ToString( bVal).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( bVal).c_str(), szSep, bEndL) ;
   }
 }

@@ -116,12 +131,13 @@ bool
 NgeWriter::WriteInt( int nVal, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      return ( gzwrite( m_OutFile, &nVal, sizeof( nVal)) > 0) ;
+      m_OutBinFile.write( (char*) &nVal, sizeof( nVal)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, ToString( nVal).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( nVal).c_str(), szSep, bEndL) ;
   }
 }

@@ -130,12 +146,13 @@ bool
 NgeWriter::WriteDouble( double dVal, const char* szSep, bool bEndL, int nPrec)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      return ( gzwrite( m_OutFile, &dVal, sizeof( dVal)) > 0) ;     
+      m_OutBinFile.write( (char*) &dVal, sizeof( dVal)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, ToString( dVal, nPrec).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( dVal, nPrec).c_str(), szSep, bEndL) ;
   }
 }

@@ -144,14 +161,15 @@ bool
 NgeWriter::WriteString( const string& sVal, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      int nDim = ssize( sVal) ;
-      return ( gzwrite( m_OutFile, &nDim, sizeof( nDim)) > 0  &&
-               ( nDim == 0  ||  gzwrite( m_OutFile, sVal.c_str(), sVal.size()) > 0)) ;
+      int nDim = int( sVal.size()) ; 
+      m_OutBinFile.write( (char*) &nDim, sizeof( nDim)) ;
+      m_OutBinFile.write( sVal.c_str(), sVal.size()) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, sVal.c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, sVal.c_str(), szSep, bEndL) ;
   }
 }

@@ -160,12 +178,13 @@ bool
 NgeWriter::WriteVector( const Vector3d& vtV, const char* szSep, bool bEndL, int nPrec)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      return ( gzwrite( m_OutFile, &vtV.v, sizeof( vtV.v)) > 0) ;
+      m_OutBinFile.write( (char*) &vtV.v, sizeof( vtV.v)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, ToString( vtV, nPrec).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( vtV, nPrec).c_str(), szSep, bEndL) ;
   }
 }

@@ -174,12 +193,13 @@ bool
 NgeWriter::WritePoint( const Point3d& ptP, const char* szSep, bool bEndL, int nPrec)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      return ( gzwrite( m_OutFile, &ptP.v, sizeof( ptP.v)) > 0) ;
+      m_OutBinFile.write( (char*) &ptP.v, sizeof( ptP.v)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, ToString( ptP, nPrec).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( ptP, nPrec).c_str(), szSep, bEndL) ;
   }
 }

@@ -188,13 +208,14 @@ bool
 NgeWriter::WritePointW( const Point3d& ptP, double dW, const char* szSep, bool bEndL, int nPrecP, int nPrecW)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      return ( gzwrite( m_OutFile, &ptP.v, sizeof( ptP.v)) > 0  &&
-               gzwrite( m_OutFile, &dW, sizeof( dW)) > 0) ;
+      m_OutBinFile.write( (char*) &ptP.v, sizeof( ptP.v)) ;
+      m_OutBinFile.write( (char*) &dW, sizeof( dW)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, ToString( ptP, dW, nPrecP, nPrecW).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( ptP, dW, nPrecP, nPrecW).c_str(), szSep, bEndL) ;
   }
 }

@@ -203,15 +224,16 @@ bool
 NgeWriter::WriteFrame( const Frame3d& frF, const char* szSep, bool bEndL, int nPrecP, int nPrecV)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      return ( gzwrite( m_OutFile, &frF.Orig().v, sizeof( frF.Orig().v)) > 0  &&
-               gzwrite( m_OutFile, &frF.VersX().v, sizeof( frF.VersX().v)) > 0  &&
-               gzwrite( m_OutFile, &frF.VersY().v, sizeof( frF.VersY().v)) > 0  &&
-               gzwrite( m_OutFile, &frF.VersZ().v, sizeof( frF.VersZ().v)) > 0) ;
+      m_OutBinFile.write( (char*) &frF.Orig().v, sizeof( frF.Orig().v)) ;
+      m_OutBinFile.write( (char*) &frF.VersX().v, sizeof( frF.VersX().v)) ;
+      m_OutBinFile.write( (char*) &frF.VersY().v, sizeof( frF.VersY().v)) ;
+      m_OutBinFile.write( (char*) &frF.VersZ().v, sizeof( frF.VersZ().v)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, ToString( frF, nPrecP, nPrecV).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( frF, nPrecP, nPrecV).c_str(), szSep, bEndL) ;
   }
 }

@@ -223,12 +245,13 @@ NgeWriter::WriteKey( int nKey)
      return false ;

   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
-      return ( gzwrite( m_OutFile, &NgeBinKeyW[nKey], sizeof( int)) > 0) ;
+      m_OutBinFile.write( (char*) &NgeBinKeyW[nKey], sizeof( int)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, NgeAscKeyW[nKey].c_str(), nullptr, true) ;
+      return WriteStringOutTxt( m_OutTxtFile, NgeAscKeyW[nKey].c_str(), nullptr, true) ;
   }
 }

@@ -237,17 +260,18 @@ bool
 NgeWriter::WriteCol( const Color& cCol, const char* szSep, bool bEndL)
 {
   if ( m_bBinary) {
-      if ( m_OutFile == nullptr)
+      if ( ! m_OutBinFile.is_open())
         return false ;
      unsigned char ucCol[4] ;
      ucCol[0] = cCol.GetIntRed() ;
      ucCol[1] = cCol.GetIntGreen() ;
      ucCol[2] = cCol.GetIntBlue() ;
      ucCol[3] = cCol.GetIntAlpha() ;
-      return ( gzwrite( m_OutFile, ucCol, sizeof( ucCol)) > 0) ;
+      m_OutBinFile.write( (char*) ucCol, sizeof( ucCol)) ;
+      return m_OutBinFile.good() ;
   }
   else {
-      return WriteStringOutTxt( m_OutFile, ToString( cCol).c_str(), szSep, bEndL) ;
+      return WriteStringOutTxt( m_OutTxtFile, ToString( cCol).c_str(), szSep, bEndL) ;
   }
 }

@@ -255,11 +279,9 @@ NgeWriter::WriteCol( const Color& cCol, const char* szSep, bool bEndL)
 bool
 NgeWriter::WriteRemark( const string& sVal)
 {
-   if ( m_bBinary) {
+   if ( m_bBinary)
      return true ;
-   }
-   else {
-      return ( WriteStringOutTxt( m_OutFile, "//", nullptr, false)  &&
-               WriteStringOutTxt( m_OutFile, sVal.c_str(), nullptr, true)) ;
-   }
+   else
+      return ( WriteStringOutTxt( m_OutTxtFile, "//", nullptr, false)  &&
+               WriteStringOutTxt( m_OutTxtFile, sVal.c_str(), nullptr, true)) ;
 }
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2025
+//  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : NgeWriter.h          Data : 29.12.25           Versione : 2.7l6
+// File : NgeWriter.h          Data : 12.04.14           Versione : 1.5d5
 // Contenuto : Dichiarazione della classe NgeWriter.
 //
 //
@@ -16,6 +16,7 @@
 #include "NgeConst.h"
 #include "/EgtDev/Include/EGkPoint3d.h"
 #include "/EgtDev/Include/EGkColor.h"
+#include <fstream>

 struct gzFile_s ;

@@ -23,7 +24,7 @@ struct gzFile_s ;
 class NgeWriter
 {
   public :
-      NgeWriter( void) : m_bBinary( false), m_OutFile( nullptr) {}
+      NgeWriter( void) : m_bBinary( false), m_OutTxtFile( nullptr) {}
      ~NgeWriter( void)
            { Close() ; }
      bool Init( const std::string& sFileOut, int nFlag) ;
@@ -43,6 +44,9 @@ class NgeWriter
      bool WriteRemark( const std::string& sVal /* bEndL = true*/) ;

   private :
-      bool      m_bBinary ;
-      gzFile_s* m_OutFile ;
+      bool          m_bBinary ;
+      // per file binari
+      std::ofstream m_OutBinFile ;
+      // per file ASCII
+      gzFile_s*     m_OutTxtFile ;
 } ;
@@ -2,7 +2,7 @@
 //  EgalTech 2013-2013
 //----------------------------------------------------------------------------
 // File : OffsetAux.cpp         Data : 23.11.23          Versione : 2.5k5
-// Contenuto : Implementazione di alcune funzioni di utilità per gli offset delle curve.
+// Contenuto : Implementazione di alcune funzioni di utilità per gli offset delle curve.
 //
 //
 //
@@ -16,24 +16,20 @@
 #include "CurveArc.h"
 #include "CurveLine.h"
 #include "GeoConst.h"
-#include "/EgtDev/Include/EGkIntervals.h" 
-#include "/EgtDev/Include/EGkIntersCurves.h" 
-#include "/EgtDev/Include/EGkChainCurves.h" 

 using namespace std ;  

-//----------------------------------------------------------------------------
-static bool IsFillet( const ICurve* pCrv, double dDist) ;
-static bool ModifyFillet( ICurve* pCrv, double dDist, int nType, ICurveComposite& ccAux) ;
-static bool AdjustIntersections( ICRVCOMPOPVECTOR& CrvList) ;
-
 //----------------------------------------------------------------------------
 bool
 IdentifyFillets( ICurveComposite* pCrvCo, double dDist)
 {
  // identifico le sottocurve di tipo fillet e assegno loro temp param 1.0 per riconoscerle nella funzione AdjustCurveFillets
   for ( int i = 0 ; i < pCrvCo->GetCurveCount() ; i ++) {
-      if ( IsFillet( pCrvCo->GetCurve( i), dDist))
+     // recupero la curva
+      PtrOwner<ICurve> pCrv( pCrvCo->GetCurve(i)->Clone()) ;
+      if ( IsNull( pCrv))
+         return false ;
+      if ( IsFillet( pCrv, dDist))
         pCrvCo->SetCurveTempParam( i, 1.0) ;
      else
         pCrvCo->SetCurveTempParam( i, 0.0) ;
@@ -43,14 +39,12 @@ IdentifyFillets( ICurveComposite* pCrvCo, double dDist)

 //----------------------------------------------------------------------------
 bool
-IsFillet( const ICurve* pCrv, double dDist)
+IsFillet( ICurve* pCrv, double dDist)
 {
-   if ( pCrv == nullptr)
-      return false ;
  // deve essere un arco
   if ( pCrv->GetType() != CRV_ARC)
      return false ;
-   const CurveArc* pArc = GetBasicCurveArc( pCrv) ;
+   CurveArc* pArc = GetBasicCurveArc( pCrv) ;
  // deve avere raggio uguale alla distanza di offset
   if ( abs( pArc->GetRadius() - abs( dDist)) > EPS_SMALL)
      return false ;
@@ -60,76 +54,36 @@ IsFillet( const ICurve* pCrv, double dDist)

 //----------------------------------------------------------------------------
 bool
-AdjustCurveFillets( ICURVEPOVECTOR& vOffset, double dDist, int nType)
+AdjustCurveFillets( ICurveComposite* pCrvCo, double dDist, int nType)
 {
-   if ( vOffset.empty())
-      return true ;
-
-  // suddivido le curve di offset individuando i fillet e isolandoli dagli altri tratti  
-   ICRVCOMPOPVECTOR vCrvs ;
-   for ( int i = 0 ; i < int( vOffset.size()) ; i ++) {
-      CurveComposite* pCompo = GetBasicCurveComposite( vOffset[i]) ;
-      if ( pCompo == nullptr)
-         return false ;
-      bool bNewCrv = true ;
-      PtrOwner<ICurve> pCrv( pCompo->RemoveFirstOrLastCurve(false)) ;      
-      while ( ! IsNull( pCrv)) {
-         if ( pCrv->GetTempParam() > EPS_SMALL) {
-           // se fillet calcolo il nuovo raccordo
-            CurveComposite* ccTemp = CreateBasicCurveComposite() ;
-            ModifyFillet( pCrv, dDist, nType, *ccTemp) ;
-           // assegno temp param per identificarlo nei conti successivi
-            ccTemp->SetTempParam( 1) ;
-            vCrvs.push_back( ccTemp) ;         
-            bNewCrv = true ; 
-         }
-         else {
-           // aggiungo la curva
-            if ( bNewCrv) {
-               bNewCrv = false ;
-               CurveComposite* pCompo = ConvertCurveToBasicComposite( Release( pCrv)) ;
-               if ( pCompo == nullptr)
-                  return false ;
-               vCrvs.push_back( pCompo) ;
+   ICURVEPLIST CrvLst ;
+   PtrOwner<ICurve> pCrv( pCrvCo->RemoveFirstOrLastCurve( false)) ;
+   while ( ! IsNull( pCrv)) {
+     // se identificato come fillet lo trasformo in smusso o estensione
+      if ( pCrv->GetTempParam() > EPS_SMALL) {
+         CurveComposite ccTemp ;
+         ModifyFillet( pCrv, dDist, nType, ccTemp) ;
+        // metto in lista le curve risultanti
+         if ( ccTemp.GetCurveCount() > 0) {
+            PtrOwner<ICurve> pCrv2( ccTemp.RemoveFirstOrLastCurve( false)) ;
+            while ( ! IsNull( pCrv2)) {
+               CrvLst.push_back( Release( pCrv2)) ;
+               pCrv2.Set( ccTemp.RemoveFirstOrLastCurve( false)) ;
            }
-            else
-               vCrvs.back()->AddCurve( Release( pCrv)) ;      
         }
-        // passo alla curva successiva
-         pCrv.Set( pCompo->RemoveFirstOrLastCurve( false)) ;
      }
+     // altrimenti salvo in lista
+      else
+         CrvLst.push_back( Release( pCrv)) ;
+     // passo alla curva successiva
+      pCrv.Set( pCrvCo->RemoveFirstOrLastCurve( false)) ;
   }
-   vOffset.clear() ;
-
-  // gestione delle intersezioni
-   if ( ! AdjustIntersections( vCrvs))
-      return false ;
-
-  // concateno i tratti ottenuti
-   ChainCurves ChainCrv ;
-   ChainCrv.Init( false, 2 * EPS_SMALL, vCrvs.size()) ;
-   for ( int i = 0 ; i < int( vCrvs.size()); ++ i) {
-      Point3d ptS, ptE ;
-      Vector3d vtS, vtE ;
-      vCrvs[i]->GetStartPoint( ptS) ;
-      vCrvs[i]->GetEndPoint( ptE) ;
-      vCrvs[i]->GetStartDir( vtS) ;
-      vCrvs[i]->GetEndDir( vtE) ;
-      ChainCrv.AddCurve( i + 1, ptS, vtS, ptE, vtE) ;
-   }
-  // recupero i concatenamenti
-   Point3d ptRef ; vCrvs[0]->GetStartPoint( ptRef) ;
-   INTVECTOR vIds ;
-   while ( ChainCrv.GetChainFromNear( ptRef, false, vIds)) {
-      PtrOwner<CurveComposite> pCompo( CreateBasicCurveComposite()) ;
-      if ( IsNull( pCompo))
-         return false ;
-      for ( auto i : vIds)
-         pCompo->AddCurve( vCrvs[i-1]) ;
-      pCompo->MergeCurves( LIN_TOL_MIN, ANG_TOL_STD_DEG) ;
-      pCompo->GetEndPoint( ptRef) ;
-      vOffset.emplace_back( Release( pCompo)) ;
+  // rimetto le curve nella composita
+   for ( auto pCrv : CrvLst) {
+      pCrvCo->AddCurve( pCrv) ;
   }
+  // unisco tratti allineati
+   pCrvCo->MergeCurves( LIN_TOL_MIN, ANG_TOL_STD_DEG) ;

   return true ;
 }
@@ -223,79 +177,3 @@ ModifyFillet( ICurve* pCrv, double dDist, int nType, ICurveComposite& ccAux)
   }
   return false ;
 }
-
-//----------------------------------------------------------------------------
-bool
-AdjustIntersections( ICRVCOMPOPVECTOR& vCrvs)
-{
-  // sistema le curve nel vettore vCrvs eliminando le parti coinvolte nelle intersezioni
-
-   vector<Intervals> vIntervals( vCrvs.size()) ;
-   INTVECTOR vFillets ;
-   for ( int i = 0 ; i < int( vCrvs.size()) ; i ++) {
-     // salvo i parametri della curva
-      double dParS, dParE ;
-      vCrvs[i]->GetDomain( dParS, dParE) ;
-      vIntervals[i].Set( dParS, dParE) ;
-     // verifico se raccordo
-      if ( vCrvs[i]->GetTempParam() > EPS_SMALL)
-        vFillets.emplace_back( i) ;      
-   }
-
-  // verifico se i raccordi intersecano le altre curve
-   bool bInters = false ;
-   for ( int i = 0 ; i < int( vFillets.size()) ; i ++) {
-      int nIdx = vFillets[i] ;
-      for ( int j = 0 ; j < int( vCrvs.size()) ; j ++) {
-         if ( j == nIdx)
-            continue ;
-
-         IntersCurveCurve intCC( *vCrvs[nIdx], *vCrvs[j]) ;
-         int nCnt = intCC.GetIntersCount() ;
-         if ( nCnt > 1) {
-           // aggiorno gli intervalli della curva sottraendo la parte coinvolta dall'intersezione
-            for ( int k = 0 ; k < nCnt - 1 ; k = k+2) {
-               IntCrvCrvInfo iccInfo1, iccInfo2 ;
-               intCC.GetIntCrvCrvInfo( k, iccInfo1) ;
-              // verifico non sia intersezione nell'estremo iniziale o sovrapposizione
-               if ( iccInfo1.IciA[0].dU < EPS_SMALL  ||  iccInfo1.bOverlap) {
-                  k-- ;
-                  continue ;
-               }        
-               intCC.GetIntCrvCrvInfo( k+1, iccInfo2) ;
-
-               vIntervals[nIdx].Subtract( iccInfo1.IciA[0].dU, iccInfo2.IciA[0].dU) ;
-               vIntervals[j].Subtract( iccInfo1.IciB[0].dU, iccInfo2.IciB[0].dU) ;
-               bInters = true ;
-            }
-         }
-      }  
-   }
-
-   if ( ! bInters)
-      return true ;
-
-  // aggiorno le curve eliminando i tratti coinvolti nelle intersezioni
-   for ( int i = 0 ; i < int( vIntervals.size()) ; i++) {      
-      if ( vIntervals[i].GetCount() > 1) {
-         PtrOwner<CurveComposite> pCompo( CloneBasicCurveComposite( vCrvs[i])) ;
-         if ( IsNull( pCompo))
-            return false ;
-         double dParS, dParE ;
-         vIntervals[i].GetFirst( dParS, dParE) ;
-         vCrvs[i]->TrimStartEndAtParam( dParS, dParE) ;
-         while ( vIntervals[i].GetNext( dParS, dParE)) {
-            CurveComposite* pCrv = ConvertCurveToBasicComposite( pCompo->CopyParamRange( dParS, dParE)) ;
-            if ( pCrv == nullptr)
-               return false ;
-            vCrvs.emplace_back( pCrv) ;
-         }            
-      }
-      else {
-         double dParS, dParE ;
-         vIntervals[i].GetFirst( dParS, dParE) ;
-         vCrvs[i]->TrimStartEndAtParam( dParS, dParE) ;      
-      }  
-   }
-   return true ;
-}
@@ -2,7 +2,7 @@
 //  EgalTech 2013-2013
 //----------------------------------------------------------------------------
 // File : OffsetAux.h         Data : 23.11.23          Versione : 2.5k5
-// Contenuto : Dichiarazione di alcune funzioni di utilità per gli offset delle curve.
+// Contenuto : Dichiarazione di alcune funzioni di utilità per gli offset delle curve.
 //
 //
 //
@@ -16,4 +16,6 @@

 //----------------------------------------------------------------------------
 bool IdentifyFillets( ICurveComposite* pCrvCo, double dDist) ;
-bool AdjustCurveFillets( ICURVEPOVECTOR& vCrvs, double dDist, int nType) ;
+bool IsFillet( ICurve* pCrv, double dDist) ;
+bool AdjustCurveFillets( ICurveComposite* pCrvCo, double dDist, int nType) ;
+bool ModifyFillet( ICurve* pCrv, double dDist, int nType, ICurveComposite& ccAux) ;
@@ -60,8 +60,6 @@ OffsetCurve::Reset( void)
      }
   }
   m_CrvLst.clear() ;
-   m_ptOffs = P_INVALID ;
-   m_vtOut = V_INVALID ;
   return true ;
 }

@@ -76,7 +74,7 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
  // verifico che la curva esista
   if ( pCrv == nullptr)
      return false ;
-  // verifico se la curva è un segmento di retta
+  // verifico se la curva è un segmento di retta
   bool bIsLine = false ;
   const CurveLine* pLine = GetBasicCurveLine( pCrv) ;
   if ( pLine != nullptr)
@@ -87,7 +85,7 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
      if ( pCompo != nullptr  &&  pCompo->IsALine( m_dLinTol, ptStart, ptEnd))
         bIsLine = true ;
   }
-  // verifico che la curva sia piana (per le linee è comunque sempre vero)
+  // verifico che la curva sia piana (per le linee è comunque sempre vero)
   Plane3d plPlane ;
   if ( ! pCrv->IsFlat( plPlane, bIsLine, 10 * EPS_SMALL)  &&  ! bIsLine)
      return false ;
@@ -169,7 +167,7 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
   // -------------------- OFFSET STANDARD ---------------------------------
   if ( ! USE_VORONOI) {

-     // verifico che la curva sia fatta solo da rette e archi che giacciono nel piano XY (VtExtr è ora Z+)
+     // verifico che la curva sia fatta solo da rette e archi che giacciono nel piano XY (VtExtr è ora Z+)
      if ( ! ccCopy.ArcsBezierCurvesToArcsPerpExtr( m_dLinTol, ANG_TOL_STD_DEG))
         return false ;

@@ -189,11 +187,11 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
      if ( ! ccCopy.MergeCurves( m_dLinTol, ANG_TOL_STD_DEG, bClosed, true))
         return false ;

-     // verifico se il punto iniziale è stato modificato
+     // verifico se il punto iniziale è stato modificato
      Point3d ptNewStart ; ccCopy.GetStartPoint( ptNewStart) ;
      bChangeStart = ( ! AreSamePointApprox( ptNewStart, ptStart)) ;

-     // calcolo le lunghezze delle diverse entità
+     // calcolo le lunghezze delle diverse entità
      DBLVECTOR vLens ;
      {
         const ICurve* pCrv1 = ccCopy.GetFirstCurve() ;
@@ -205,7 +203,7 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
            pCrv1 = ccCopy.GetNextCurve() ;
         }
      }
-     // calcolo gli angoli tra le diverse entità
+     // calcolo gli angoli tra le diverse entità
      DBLVECTOR vAngs ;
      {
         vAngs.push_back( 0) ;
@@ -232,7 +230,7 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
            vAngs.push_back( 0) ;
      }

-     // primo passo : estraggo entità dalla copia, loro offset elementare e aggiunta raccordi esterni (sempre fillet)
+     // primo passo : estraggo entità dalla copia, loro offset elementare e aggiunta raccordi esterni (sempre fillet)
      CurveComposite ccCopy2 ;
      if ( ! ccCopy2.CopyFrom( &ccCopy))
         return false ;
@@ -243,11 +241,11 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
      if ( IsNull( pCrv1))
         return false ;
      pCrv1->SetTempProp( nInd1) ;
-      if ( ! pCrv1->SimpleOffset( dDist)) {
+      if ( ! pCrv1->SimpleOffset( dDist, ICurve::OFF_FILLET)) {
         CurveArc* pArc = GetBasicCurveArc( pCrv1) ;
         if ( pArc == nullptr)
            return false ;
-         if ( pArc->MyExtendedOffset( dDist, true))
+         if ( pArc->MyExtendedOffset( dDist, true, ICurve::OFF_FILLET))
            pCrv1->SetTempProp( - nInd1) ;
      }       
      // curve successive
@@ -255,11 +253,11 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
      while ( ! IsNull( pCrv2)) {
        // eseguo semplice offset
         pCrv2->SetTempProp( nInd1 + 1) ;
-         if ( ! pCrv2->SimpleOffset( dDist)) {
+         if ( ! pCrv2->SimpleOffset( dDist, ICurve::OFF_FILLET)) {
            CurveArc* pArc = GetBasicCurveArc( pCrv2) ;
            if ( pArc == nullptr)
               return false ;
-            if ( pArc->MyExtendedOffset( dDist, true))
+            if ( pArc->MyExtendedOffset( dDist, true, ICurve::OFF_FILLET))
               pCrv2->SetTempProp( - ( nInd1 + 1)) ;
         }
        // verifico relazione con la curva precedente e aggiungo eventuali curve intermedie
@@ -287,9 +285,9 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)

      // se originale chiuso, devo confrontare anche ultima e prima curva
      if ( bClosed  &&  m_CrvLst.size() >= 2) {
-        // la curva precedente è l'ultima dell'offset
+        // la curva precedente è l'ultima dell'offset
         ICurve* pCrv1 = m_CrvLst.back() ;
-        // la curva successiva ora è la prima dell'offset
+        // la curva successiva ora è la prima dell'offset
         ICurve* pCrv2 = m_CrvLst.front() ;
        // verifico relazione con la curva precedente e aggiungo eventuali curve intermedie
         CurveComposite ccTemp ;
@@ -336,7 +334,7 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
            bool bNextInt = NextIsLine( iIter, m_CrvLst, bClosed)  &&
                            NextIsLonger( nInd1, vLens, bClosed)  &&
                            ( ( dDist < 0  &&  vAngs[nInd1] > 0)  ||  ( dDist > 0  &&  vAngs[nInd1] < 0)) ;
-           // calcolo la massima estensione di offset (Voronoi con entità adiacenti)
+           // calcolo la massima estensione di offset (Voronoi con entità adiacenti)
            double dMaxDist = INFINITO ;
            if ( bPrevInt  &&  bNextInt) {
               double dTgA = tan( 0.5 * ( ANG_STRAIGHT - abs( vAngs[nInd1-1])) * DEGTORAD) ;
@@ -504,7 +502,7 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)

     // sesto passo : se curva aperta, elimino i tratti che stanno nella circonferenza di offset dei punti estremi
      if ( ! bClosed) {
-        // ciconferenza sull'estremità iniziale
+        // ciconferenza sull'estremità iniziale
         Point3d ptStart ; ccCopy.GetStartPoint( ptStart) ;
         PtrOwner<CurveArc> pCircS( CreateBasicCurveArc()) ;
         if ( IsNull( pCircS)  ||  ! pCircS->Set( ptStart, Z_AX, abs( dDist)))
@@ -553,7 +551,7 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
           // passo alla successiva
            ++ iIter ;
         }
-        // circonferenza sull'estremità finale
+        // circonferenza sull'estremità finale
         Point3d ptEnd ; ccCopy.GetEndPoint( ptEnd) ;
         PtrOwner<CurveArc> pCircE( CreateBasicCurveArc()) ;
         if ( IsNull( pCircE)  ||  ! pCircE->Set( ptEnd, Z_AX, abs( dDist)))
@@ -674,20 +672,12 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
      }

     // nono passo : se con smusso o estensione, sostituisco i fillet con questi
-     // NB questa parte non è gestita in modo efficiente perchè dovrebbe essere sempre disabilitata.
-     // Le funzioni sono state ottimizzate per lavorare con voronoi
      if ( ( nType & ICurve::OFF_CHAMFER) != 0  ||  ( nType & ICurve::OFF_EXTEND) != 0) {
-         ICURVEPOVECTOR vCrvs ;
-         vCrvs.reserve( m_CrvLst.size()) ;
-         for ( auto pCrv : m_CrvLst) {
-            IdentifyFillets( GetCurveComposite( pCrv), dDist) ;
-            vCrvs.emplace_back( pCrv) ;
-         }            
-         if ( ! AdjustCurveFillets( vCrvs, dDist, nType))
-            return false ;
-         m_CrvLst.clear() ;
-         for ( int j = 0 ; j < int( vCrvs.size()) ; j ++)
-            m_CrvLst.emplace_back( Release( vCrvs[j])) ;         
+         for ( auto iIter = m_CrvLst.begin() ; iIter != m_CrvLst.end() ; ++ iIter) {
+            CurveComposite* pCrvCo = GetBasicCurveComposite( *iIter) ;
+            IdentifyFillets( pCrvCo, dDist) ;
+            AdjustCurveFillets( pCrvCo, dDist, nType) ; 
+         }
      }
   }

@@ -707,27 +697,6 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
     // calcolo offset con Voronoi
      ICURVEPOVECTOR vOffs ;
      voronoiObj->CalcOffset( vOffs, dDist, nType) ;
-      if ( vOffs.empty()) {
-        // se non ho ottenuto offset e sono circa al valore limite ritento con valore leggermente diverso per le tolleranze di vroni
-         double dMaxOffs ;
-         if ( ! pCrv->IsClosed()  ||  ( voronoiObj->CalcLimitOffset( 0, dDist < 0, dMaxOffs)  &&  abs( dMaxOffs - abs( dDist)) < EPS_SMALL)) {
-            double dCorr = ( dDist > 0 ? - VRONI_OFFS_TOL : VRONI_OFFS_TOL) ;
-            voronoiObj->CalcOffset( vOffs, dDist + dCorr, nType) ;
-         }
-        // se ancora vuoto calcolo i punti speciali di offset ( punti e direzioni sui bisettore alla distanza richiesta)      
-         if ( vOffs.empty()) {
-            PNTVECTVECTOR vPntOffs ;
-            voronoiObj->CalcSpecialPointOffset( vPntOffs, dDist) ;
-           // NB al momento vengono gestiti solo i casi in cui vi è un unico punto di offset. Se si ottengono più punti di offset 
-           // ( e.g. alcune curve aperte) non se ne restiusce nessuno. Da estendere, se necessario, individuando i punti dal lato 
-           // di offset richiesto
-            if ( vPntOffs.size() == 1) {
-               m_ptOffs = vPntOffs[0].first ;
-               m_vtOut = vPntOffs[0].second ;            
-            }        
-         }
-      }         
-
      for ( int i = 0 ; i < ( int)vOffs.size() ; i ++)
         m_CrvLst.emplace_back( Release( vOffs[i])) ;

@@ -755,21 +724,10 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
         pCrv->Scale( GLOB_FRM, 1 / dExtrOnN, 1, 1) ;
         pCrv->ToGlob( frCopy) ;
      }
-      if ( m_ptOffs.IsValid()) {
-         m_ptOffs.Scale( GLOB_FRM, 1 / dExtrOnN, 1, 1) ;
-         m_ptOffs.ToGlob( frCopy) ;
-         m_vtOut.Scale( GLOB_FRM, 1 / dExtrOnN, 1, 1) ;
-         m_vtOut.ToGlob( frCopy) ;
-      }
-
   }
   else if ( bNeedRef) {
      for ( auto pCrv : m_CrvLst)
         pCrv->ToGlob( frCopy) ;
-      if ( m_ptOffs.IsValid()) {       
-         m_ptOffs.ToGlob( frCopy) ;
-         m_vtOut.ToGlob( frCopy) ;
-      }
   }

  // assegno estrusione e spessore come curva originale e unisco parti allineate
@@ -847,20 +805,6 @@ OffsetCurve::GetShorterCurve( void)
   return pCrv ;
 }

-//----------------------------------------------------------------------------
-bool
-OffsetCurve::GetPointOffset( Point3d& ptOffs, Vector3d& vtOut)
-{
-  // verifico se valori validi da restituire
-   if ( ! m_ptOffs.IsValid()  ||  ! m_vtOut.IsValid())
-      return false ;
-
-   ptOffs = m_ptOffs ;
-   vtOut = m_vtOut ;
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 PreviousIsLine( ICURVEPLIST::const_iterator iIter, const ICURVEPLIST& CrvLst, bool bClosed)
@@ -873,7 +817,7 @@ PreviousIsLine( ICURVEPLIST::const_iterator iIter, const ICURVEPLIST& CrvLst, bo
  // se non esiste e curva chiusa prendo l'ultimo
   if ( iPrev == CrvLst.end()  &&  bClosed)
      -- iPrev ;
-  // se non esiste o non è una linea, test fallito
+  // se non esiste o non è una linea, test fallito
   if ( iPrev == CrvLst.end() || (*iPrev)->GetType() != CRV_LINE )
      return false ;
  // test superato
@@ -886,7 +830,7 @@ PreviousIsLonger( int nInd1, const DBLVECTOR& vLens, bool bClosed)
 {
  // massimo indice nel vettore
   int nMax = int( vLens.size()) - 1 ;
-  // verifico validità indice (questo indice è incrementato di 1)
+  // verifico validità indice (questo indice è incrementato di 1)
   if ( nInd1 < 1  ||  nInd1 > nMax + 1)
      return false ;
  // indice del precedente nel vettore di lunghezze
@@ -910,7 +854,7 @@ NextIsLine( ICURVEPLIST::const_iterator iIter, const ICURVEPLIST& CrvLst, bool b
  // se non esiste e curva chiusa prendo il primo
   if ( iNext == CrvLst.end()  &&  bClosed)
      iNext = CrvLst.begin() ;
-  // se non esiste o non è una linea, test fallito
+  // se non esiste o non è una linea, test fallito
   if ( iNext == CrvLst.end() || (*iNext)->GetType() != CRV_LINE )
      return false ;
  // test superato
@@ -923,7 +867,7 @@ NextIsLonger( int nInd1, const DBLVECTOR& vLens, bool bClosed)
 {
  // massimo indice nel vettore
   int nMax = int( vLens.size()) - 1 ;
-  // verifico validità indice (questo indice è incrementato di 1)
+  // verifico validità indice (questo indice è incrementato di 1)
   if ( nInd1 < 1  ||  nInd1 > nMax + 1)
      return false ;
  // indice del successivo nel vettore di lunghezze
@@ -1002,7 +946,7 @@ VerifyAndAdjustSamePoint( ICurve* pCrv1, ICurve* pCrv2, int& nRes)
      nRes = 4 ;
      return true ;
   }
-  // se coincidono esattamente, va bene così
+  // se coincidono esattamente, va bene così
   if ( AreSamePointExact( ptP1, ptP2)) {
      nRes = 0 ;
      return true ;
@@ -1032,7 +976,7 @@ VerifyAndAdjustInternalAngle( ICurve* pCrv1, ICurve* pCrv2, int& nRes)
   IntersCurveCurve intCC( *pCrv1, *pCrv2) ;
   if ( intCC.GetIntersCount() == 0)
      return false ;
-  // prendo l'intersezione più vicina al punto medio tra gli estremi delle curve
+  // prendo l'intersezione più vicina al punto medio tra gli estremi delle curve
   Point3d ptP1, ptP2 ;
   if ( ! pCrv1->GetEndPoint( ptP1)  ||  ! pCrv2->GetStartPoint( ptP2))
      return false ;
@@ -1080,7 +1024,7 @@ VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dAngDeg, doub
      vtDir2.Invert() ;
   }

-  // verifico sia angolo esterno (accetto se entità quasi esattamente sovrapposte)
+  // verifico sia angolo esterno (accetto se entità quasi esattamente sovrapposte)
   if ( abs( dAngDeg) < ( ANG_STRAIGHT - 10 * EPS_ANG_ZERO)  &&
        ( ( dDist < 0  &&  dAngDeg > 0)  ||
          ( dDist > 0  &&  dAngDeg < 0)))
@@ -1122,7 +1066,7 @@ VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dAngDeg, doub
         return false ;
      ptP1a = ptP1 + vtDir1 * dLen ;
      ptP2a = ptP2 - vtDir2 * dLen ;
-     // se prima c'è linea posso allungarla
+     // se prima c'è linea posso allungarla
      if ( pCrv1->GetType() == CRV_LINE)
         pCrv1->ModifyEnd( ptP1a) ;
     // altrimenti, devo aggiungere una nuova linea
@@ -1141,7 +1085,7 @@ VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dAngDeg, doub
         if ( ! ccAux.AddCurve( Release( pCrv)))
            return false ;
      }
-     // se dopo c'è linea posso allungarla
+     // se dopo c'è linea posso allungarla
      if ( pCrv2->GetType() == CRV_LINE)
         pCrv2->ModifyStart( ptP2a) ;
     // altrimenti, devo aggiungere una nuova linea
@@ -1164,7 +1108,7 @@ VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dAngDeg, doub
      if ( ! pCrv1->GetEndPoint( ptP1)  ||  ! pCrv2->GetStartPoint( ptP2))
         return false ;
      ptPc = ptP1 + vtDir1 * dLen ;
-     // se prima c'è linea o angolo molto piccolo posso allungarla
+     // se prima c'è linea o angolo molto piccolo posso allungarla
      if ( ( pCrv1->GetType() == CRV_LINE)  ||  bAngSmall)
         pCrv1->ModifyEnd( ptPc) ;
     // altrimenti, devo aggiungere una nuova linea
@@ -1175,7 +1119,7 @@ VerifyAndAdjustExternalAngle( ICurve* pCrv1, ICurve* pCrv2, double dAngDeg, doub
         if ( ! ccAux.AddCurve( Release( pCrv)))
            return false ;
      }
-     // se dopo c'è linea o angolo molto piccolo posso allungarla
+     // se dopo c'è linea o angolo molto piccolo posso allungarla
      if ( ( pCrv2->GetType() == CRV_LINE)  ||  bAngSmall)
         pCrv2->ModifyStart( ptPc) ;
     // altrimenti, devo aggiungere una nuova linea
@@ -195,7 +195,7 @@ PointGrid3d::Find( const Point3d& ptTest, double dTol, INTVECTOR& vnIds) const
      }
   }

-   return ( ! vnIds.empty()) ;
+   return ( vnIds.size() > 0) ;
 }

 //----------------------------------------------------------------------------
@@ -221,7 +221,7 @@ PointGrid3d::Find( const BBox3d& b3Test, INTVECTOR& vnIds) const
      }
   }

-   return ( ! vnIds.empty()) ;
+   return ( vnIds.size() > 0) ;
 }

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


 //----------------------------------------------------------------------------
 PointsPCA::PointsPCA( void)
 {
+  // azzero numero punti
+   m_dTotW = 0 ;
+  // azzero il baricentro
+   m_ptCen.Set( 0, 0, 0) ;
+  // azzero matrice di covarianza
+   m_CovMat.setZero() ;
  // inizializzo il rank ad un valore assurdo
   m_nRank = - 1 ;
-  // inizializzo baricentro
-   m_ptCen.Set( 0, 0, 0) ;
-  // inizializzo il peso totale
-   m_dTotW = 0 ;
-  // riservo memoria per la matrice di punti e pesi
-   m_vPntW.reserve( 128) ;
 }

 //----------------------------------------------------------------------------
 void
 PointsPCA::AddPoint( const Point3d& ptP, double dW)
 {
-  // salvo i dati
-   m_vPntW.emplace_back( ptP, dW) ;
+  // incremento numero punti
+   m_dTotW += dW ;
+  // aggiorno il baricentro
+   m_ptCen += dW * ptP ;
+  // aggiorno la matrice di covarianza (solo triangolo superiore perchè simmetrica)
+   m_CovMat(0,0) += dW * ( ptP.x * ptP.x) ;
+   m_CovMat(1,1) += dW * ( ptP.y * ptP.y) ;
+   m_CovMat(2,2) += dW * ( ptP.z * ptP.z) ;
+   m_CovMat(0,1) += dW * ( ptP.x * ptP.y) ;
+   m_CovMat(0,2) += dW * ( ptP.x * ptP.z) ;
+   m_CovMat(1,2) += dW * ( ptP.y * ptP.z) ;
 }

 //----------------------------------------------------------------------------
@@ -51,47 +58,29 @@ PointsPCA::Finalize( void)
   m_nRank = 0 ;

  // se non sono stati assegnati punti, esco
-   if ( m_vPntW.empty())
-      return false ;
-
-  // calcolo del peso totale
-   for ( const auto& PntW : m_vPntW)
-      m_dTotW += PntW.second ;
   if ( m_dTotW < EPS_ZERO)
      return false ;
-  // fattore di scala
+
+  // fattore di scala per numero di punti
   double dScale = 1 / m_dTotW ;

  // calcolo del baricentro
-   for ( const auto& PntW : m_vPntW)
-      m_ptCen += PntW.second * PntW.first ;
   m_ptCen *= dScale ;

-  // matrice di covarianza
-   Eigen::Matrix3d CovMat ;
-   CovMat.setZero() ;
-   for ( const auto& PntW : m_vPntW) {
-      Point3d ptP( PntW.first.x - m_ptCen.x, PntW.first.y - m_ptCen.y, PntW.first.z - m_ptCen.z) ;
-      CovMat(0,0) += PntW.second * ( ptP.x * ptP.x) ;
-      CovMat(1,1) += PntW.second * ( ptP.y * ptP.y) ;
-      CovMat(2,2) += PntW.second * ( ptP.z * ptP.z) ;
-      CovMat(0,1) += PntW.second * ( ptP.x * ptP.y) ;
-      CovMat(0,2) += PntW.second * ( ptP.x * ptP.z) ;
-      CovMat(1,2) += PntW.second * ( ptP.y * ptP.z) ;
-   }
-   CovMat(0,0) = CovMat(0,0) * dScale ;
-   CovMat(1,1) = CovMat(1,1) * dScale ;
-   CovMat(2,2) = CovMat(2,2) * dScale ;
-   CovMat(0,1) = CovMat(0,1) * dScale ;
-   CovMat(0,2) = CovMat(0,2) * dScale ;
-   CovMat(1,2) = CovMat(1,2) * dScale ;
-   CovMat(1,0) = CovMat(0,1) ;
-   CovMat(2,0) = CovMat(0,2) ;
-   CovMat(2,1) = CovMat(1,2) ;
+  // completo la matrice di covarianza
+   m_CovMat(0,0) = m_CovMat(0,0) * dScale - m_ptCen.x * m_ptCen.x ;
+   m_CovMat(1,1) = m_CovMat(1,1) * dScale - m_ptCen.y * m_ptCen.y ;
+   m_CovMat(2,2) = m_CovMat(2,2) * dScale - m_ptCen.z * m_ptCen.z ;
+   m_CovMat(0,1) = m_CovMat(0,1) * dScale - m_ptCen.x * m_ptCen.y ;
+   m_CovMat(0,2) = m_CovMat(0,2) * dScale - m_ptCen.x * m_ptCen.z ;
+   m_CovMat(1,2) = m_CovMat(1,2) * dScale - m_ptCen.y * m_ptCen.z ;
+   m_CovMat(1,0) = m_CovMat(0,1) ;
+   m_CovMat(2,0) = m_CovMat(0,2) ;
+   m_CovMat(2,1) = m_CovMat(1,2) ;

-  // calcolo gli autovalori e autovettori
+  // calcolo gli autovalori e autovettori (essendo matrice 3x3 uso metodo diretto)
   Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> es ;
-   es.compute( CovMat) ;        // non usare computeDirect : errore nell'ordine degli autovettori
+   es.compute( m_CovMat) ;        // non usare computeDirect : errore nell'ordine degli autovettori
   if ( es.info() == Eigen::NoConvergence)
      return false ;

@@ -13,7 +13,8 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeoCollection.h"
+#include "/EgtDev/Include/EGkPoint3d.h"
+#include "/EgtDev/Extern/Eigen/Dense"

 //----------------------------------------------------------------------------
 class PointsPCA
@@ -32,9 +33,9 @@ class PointsPCA
      static const int MAX_RANK = 3 ;

   private :
-      PNTUVECTOR      m_vPntW ;            // vettore dei punti con i loro pesi
+      double          m_dTotW ;            // peso totale (se pesi tutti unitari, allora è numero punti)
      Point3d         m_ptCen ;            // baricentro
-      double          m_dTotW ;            // peso totale
+      Eigen::Matrix3d m_CovMat ;           // matrice di covarianza
      int             m_nRank ;            // numero delle componenti principali (MAX_RANK = 3)
      Vector3d        m_vtPC[MAX_RANK] ;   // direzioni delle componenti principali
 } ;
@@ -13,9 +13,9 @@

 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
+#include "DistPointLine.h"
 #include "GeoConst.h"
 #include "CurveArc.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkPolyArc.h"
 #include "/EgtDev/Include/EGkFrame3d.h"
 #include <algorithm>
@@ -62,7 +62,7 @@ bool
 PolyArc::AddUPoint( double dPar, const Point3d& ptP, double dBulge)
 {
  // se il punto è uguale al precedente (ignoro parametro e bulge), non lo inserisco ma ok
-   if ( ! m_lUPointBs.empty()  &&  AreSamePointApprox( ptP, m_lUPointBs.back().ptP)) {
+   if ( m_lUPointBs.size() > 0  &&  AreSamePointApprox( ptP, m_lUPointBs.back().ptP)) {
     // assegno parametro e bulge
      m_lUPointBs.back().dU = dPar ;
      m_lUPointBs.back().dB = dBulge ;
@@ -285,10 +285,10 @@ bool
 PolyArc::Join( PolyArc& PA, double dOffsetPar)
 {
  // se l'altro poliarco non contiene alcunchè, esco con ok
-   if ( PA.m_lUPointBs.empty())
+   if ( PA.m_lUPointBs.size() == 0)
      return true ;
  // verifico che l'ultimo punto di questo poliarco coincida con il primo dell'altro
-   if ( ! m_lUPointBs.empty()  &&  ! AreSamePointApprox( m_lUPointBs.back().ptP, PA.m_lUPointBs.front().ptP))
+   if ( m_lUPointBs.size() > 0  &&  ! AreSamePointApprox( m_lUPointBs.back().ptP, PA.m_lUPointBs.front().ptP))
      return false ;
  // cancello l'ultimo di questo
   EraseLastUPoint() ;
@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 //  EgalTech 2013-2013
 //----------------------------------------------------------------------------
 // File : PolyLine.cpp          Data : 22.12.13          Versione : 1.4l3
@@ -14,15 +14,13 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CurveLine.h"
+#include "DistPointLine.h"
 #include "IntersLineLine.h"
 #include "PolygonPlane.h"
 #include "PointsPCA.h"
 #include "GeoConst.h"
-#include "CurveComposite.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkPlane3d.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
 #include "/EgtDev/Include/EgtNumUtils.h"

@@ -55,8 +53,8 @@ PolyLine::AddUPoint( double dPar, const Point3d& ptP, bool bEndOrStart)
 {
  // se da aggiungere in coda
   if ( bEndOrStart) {
-     // se il punto è uguale all'ultimo (ignoro parametro), non lo inserisco ma ok
-      if ( ! m_lUPoints.empty()  &&  AreSamePointApprox( ptP, m_lUPoints.back().first)) {
+     // se il punto è uguale all'ultimo (ignoro parametro), non lo inserisco ma ok
+      if ( m_lUPoints.size() > 0  &&  AreSamePointApprox( ptP, m_lUPoints.back().first)) {
         ++ m_nRejected ;
         return true ;
      }
@@ -70,8 +68,8 @@ PolyLine::AddUPoint( double dPar, const Point3d& ptP, bool bEndOrStart)
   }
  // altrimenti si aggiunge in testa
   else {
-     // se il punto è uguale al primo (ignoro parametro), non lo inserisco ma ok
-      if ( ! m_lUPoints.empty()  &&  AreSamePointApprox( ptP, m_lUPoints.front().first)) {
+     // se il punto è uguale al primo (ignoro parametro), non lo inserisco ma ok
+      if ( m_lUPoints.size() > 0  &&  AreSamePointApprox( ptP, m_lUPoints.front().first)) {
         ++ m_nRejected ;
         return true ;
      }
@@ -94,7 +92,7 @@ PolyLine::Close( void)
  // ci devono essere almeno 2 punti
   if ( m_lUPoints.size() < 2)
      return false ;
-  // verifico non sia già chiuso
+  // verifico non sia già chiuso
   if ( AreSamePointApprox( m_lUPoints.front().first, m_lUPoints.back().first))
      return false ;
  // aggiungo un punto uguale al primo in coda
@@ -221,7 +219,7 @@ PolyLine::ToLoc( const Frame3d& frRef)
 bool
 PolyLine::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
 {
-  // se i due riferimenti coincidono, non devo fare alcunché
+  // se i due riferimenti coincidono, non devo fare alcunché
   if ( AreSameFrame( frOri, frDest))
      return true ;
  // ciclo sui punti
@@ -235,11 +233,11 @@ PolyLine::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
 bool
 PolyLine::Join( PolyLine& PL, double dOffsetPar)
 {
-  // se l'altra polilinea non contiene alcunchè, esco con ok
-   if ( PL.m_lUPoints.empty())
+  // se l'altra polilinea non contiene alcunchè, esco con ok
+   if ( PL.m_lUPoints.size() == 0)
      return true ;
  // verifico che l'ultimo punto di questa polilinea coincida con il primo dell'altra
-   if ( ! m_lUPoints.empty()  &&  ! AreSamePointApprox( m_lUPoints.back().first, PL.m_lUPoints.front().first))
+   if ( m_lUPoints.size() > 0  &&  ! AreSamePointApprox( m_lUPoints.back().first, PL.m_lUPoints.front().first))
      return false ;
  // cancello l'ultimo di questa
   EraseLastUPoint() ;
@@ -387,7 +385,7 @@ PolyLine::GetPrevUPoint( double* pdPar, Point3d* pptP, bool bNotFirst) const
 bool
 PolyLine::GetCurrUPoint( double* pdPar, Point3d* pptP) const
 {
-  // verifico validità punto corrente
+  // verifico validità punto corrente
   if ( m_iter == m_lUPoints.end())
      return false ;

@@ -428,7 +426,7 @@ PolyLine::GetFirstULine( double* pdIni, Point3d* pptIni, double* pdFin, Point3d*
 bool
 PolyLine::GetNextULine( double* pdIni, Point3d* pptIni, double* pdFin, Point3d* pptFin) const
 {
-  // parametro e punto iniziali (è il precedente finale)
+  // parametro e punto iniziali (è il precedente finale)
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( pdIni != nullptr)
@@ -512,19 +510,19 @@ PolyLine::IsFlat( int& nRank, Point3d& ptCen, Vector3d& vtDir, double dToler) co
      ptsPCA.AddPoint( Media( ptP1, ptP2, 0.25), dLen / 2) ;
      ptsPCA.AddPoint( Media( ptP1, ptP2, 0.75), dLen / 2) ;
   }
-  // recupero il rango, ovvero la dimensionalità dell'insieme di punti
+  // recupero il rango, ovvero la dimensionalità dell'insieme di punti
   nRank = ptsPCA.GetRank() ;
  // se dimensione nulla, o non ci sono punti o sono tutti praticamente coincidenti
   if ( nRank == 0)
      return ptsPCA.GetCenter( ptCen) ;
  // se dimensione 1, allora i punti sono distribuiti su una linea
   if ( nRank == 1) {
-     // assegno il centro e la direzione della linea (il verso è indifferente)
+     // assegno il centro e la direzione della linea (il verso è indifferente)
      ptsPCA.GetCenter( ptCen) ;
      ptsPCA.GetPrincipalComponent( 0, vtDir) ;
      return true ;
   }
-  // altrimenti dimensione 2 o 3, allora è determinato un piano principale, verifico se tutti i punti vi giacciono
+  // altrimenti dimensione 2 o 3, allora è determinato un piano principale, verifico se tutti i punti vi giacciono
   // Center and normal vector
   ptsPCA.GetCenter( ptCen) ;
   Vector3d vtX, vtY ;
@@ -532,9 +530,9 @@ PolyLine::IsFlat( int& nRank, Point3d& ptCen, Vector3d& vtDir, double dToler) co
   ptsPCA.GetPrincipalComponent( 1, vtY) ;
   vtDir = vtX ^ vtY ;
   if ( ! vtDir.Normalize()) {
-     // riduco la dimensionalità a lineare
+     // riduco la dimensionalità a lineare
      nRank = 1 ;
-     // assegno il centro e la direzione della linea (il verso è indifferente)
+     // assegno il centro e la direzione della linea (il verso è indifferente)
      ptsPCA.GetCenter( ptCen) ;
      vtDir = vtX ;
      return true ;
@@ -563,12 +561,12 @@ PolyLine::IsFlat( Plane3d& plPlane, double dToler) const
      plPlane.Reset() ;
      return false ;
   }
-  // recupero dati sulla planarità della polilinea
+  // recupero dati sulla planarità della polilinea
   int nRank ;
   Point3d ptCen ;
   Vector3d vtDir ;
   bool bFlat = IsFlat( nRank, ptCen, vtDir, dToler) ;
-   // imposto il piano a seconda della dimensionalità
+   // imposto il piano a seconda della dimensionalità
   switch ( nRank) {
   case 0 :      // punto
      plPlane.Set( ptCen, Z_AX) ;
@@ -589,29 +587,18 @@ PolyLine::IsClosedAndFlat( Plane3d& plPlane, double& dArea, double dToler) const
  // Test if closed
   if ( ! IsClosed())
      return false ;
+  // Compute a representative plane for the polygon
   Point3d ptP ;
-  // Calcolo il centro (per minimizzare gli errori nelle successive operazioni)
-   Point3d ptCen = ORIG ;
-   int nCount = 0 ;
-   for ( bool bFound = GetFirstPoint( ptP) ; bFound ; bFound = GetNextPoint( ptP)) {
-      ptCen += ptP ;
-      ++ nCount ;
-   }  
-   ptCen /= nCount ;
-   Vector3d vtMove = ptCen - ORIG ;
-  // Compute a representative plane for the polygon (faccio il calcolo nel centro e poi traslo al contrario il piano)
   PolygonPlane PolyPlane ;
   for ( bool bFound = GetFirstPoint( ptP) ; bFound ; bFound = GetNextPoint( ptP))
-      PolyPlane.AddPoint( ptP - vtMove) ;
+      PolyPlane.AddPoint( ptP) ;
   if ( ! PolyPlane.GetPlane( plPlane)  ||  ! PolyPlane.GetArea( dArea)) {
      dArea = 0 ;
      return IsFlat( plPlane, dToler) ;
   }
-   plPlane.Translate( vtMove) ;
-  // Sistemo il piano per l'offset utilizzato
  // Test each vertex to see if it is farther from plane than allowed max distance
   for ( bool bFound = GetFirstPoint( ptP) ; bFound ; bFound = GetNextPoint( ptP)) {
-      double dDist = DistPointPlane( ptP, plPlane) ;
+      double dDist = ( ( ptP - ORIG) * plPlane.GetVersN()) - plPlane.GetDist() ;
      if ( abs( dDist) > dToler)
         return false ;
   }
@@ -652,13 +639,13 @@ PolyLine::GetAreaXY( double& dArea) const
  // verifico sia chiusa
   if ( ! IsClosed())
      return false ;
-  // calcolo l'area considerando solo XY (è la Z di Newell)
+  // calcolo l'area considerando solo XY (è la Z di Newell)
   dArea = 0 ;
   Point3d ptIni, ptFin ;
   for ( bool bFound = GetFirstLine( ptIni, ptFin) ; bFound ; bFound = GetNextLine( ptIni, ptFin)) {
      dArea += ( ptIni.x - ptFin.x) * ( ptIni.y + ptFin.y) ;   // projection on xy
   }
-  // considero anche la linea tra l'ultimo e il primo punto perchè in alcuni casi potrebbero definire area 
+  // considero anche la linea tra l'ultimo e il primo punto perchè in alcuni casi potrebbero definire area 
  // significativa anche se sono coincidenti per le nostre tolleranze
   ptIni = ptFin ;
   GetFirstPoint( ptFin) ;
@@ -759,7 +746,7 @@ DouglasPeuckerSimplification( const PNTUVECTOR& vPtU, const double dSqTol, const
      }
   }

-  // se la distanza massima trovata è sopra la tolleranza, allora controllo la parte di PolyLine tra
+  // se la distanza massima trovata è sopra la tolleranza, allora controllo la parte di PolyLine tra
  // (nIndStart, nMaxInd) e quella tra (nMaxInd, nIndEnd)
   if ( dMaxSqDist > dSqTol) {
     // inserisco il punto
@@ -775,7 +762,7 @@ DouglasPeuckerSimplification( const PNTUVECTOR& vPtU, const double dSqTol, const

 //----------------------------------------------------------------------------
 bool
-PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd)
+PolyLine::RemoveAlignedPoints( double dToler)
 {
  // se non ci sono almeno 3 punti, esco subito
   if ( m_lUPoints.size() < 3)
@@ -798,11 +785,11 @@ PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd)
      vInd.push_back( 0) ;
      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, int( vPtU.size()) - 1, vInd))
         return false ;
-      vInd.push_back( int( vPtU.size()) - 1) ;
+      vInd.push_back( vPtU.size() - 1) ;
   }
  // altrimenti chiusa
   else {
-     // cerco il punto più distante dal primo
+     // cerco il punto più distante dal primo
      double dMaxDist = 0. ;
      int nMaxInd = 0 ;
      for ( int i = 1 ; i < int( vPtU.size()) ; ++ i) {
@@ -819,20 +806,12 @@ PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd)
      vInd.push_back( nMaxInd) ;
      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, nMaxInd, int( vPtU.size()) - 1, vInd))
         return false ;
-      vInd.push_back( int( vPtU.size()) - 1) ;
+      vInd.push_back( vPtU.size() - 1) ;
   }

  // ordino in senso crescente
   sort( vInd.begin(), vInd.end()) ;

-  // se richiesto e chiusa e almeno 4 punti rimasti, controllo allineamento dell'inizio con precedente e successivo rimasti
-   if ( bStartEnd  &&  IsClosed()  &&  vInd.size() >= 4) {
-      if ( DistPointLine( vPtU[vInd[0]].first, vPtU[vInd[1]].first, vPtU[vInd[int(vInd.size())-2]].first).IsEpsilon( dToler)) {
-         vInd.erase( vInd.begin()) ;
-         vInd.back() = vInd.front() ;
-      }
-   }
-
  // rimetto in lista i soli punti rimasti
   m_lUPoints.clear() ;
   for ( auto Ind : vInd)
@@ -979,7 +958,7 @@ PolyLine::MyApproxOnSide( const Vector3d& vtN,  bool bLeftSide, double dToler)
            }
         }
      }
-     // non è stato eliminato alcunché
+     // non è stato eliminato alcunché
     // ripristino la tolleranza corrente
      dCurrToler = dToler ;
     // avanzo il terzetto di uno step
@@ -1020,7 +999,7 @@ PolyLine::MakeConvex( const Vector3d& vtN,  bool bLeftSide)
 bool
 PolyLine::MyMakeConvex( const Vector3d& vtN,  bool bLeftSide)
 {
-  // ciclo i controlli finchè non ci sono rimozioni
+  // ciclo i controlli finchè non ci sono rimozioni
   bool bRemoved = true ;
   while ( bRemoved) {
      bRemoved = false ;
@@ -1048,7 +1027,7 @@ PolyLine::MyMakeConvex( const Vector3d& vtN,  bool bLeftSide)
            bRemoved = true ;
            continue ;
         }
-        // non è stato eliminato alcunché : avanzo il terzetto di uno step
+        // non è stato eliminato alcunché : avanzo il terzetto di uno step
         precP = currP ;
         currP = nextP ;
         ++ nextP ;
@@ -1075,7 +1054,7 @@ PolyLine::Invert( bool bInvertU)
   m_lUPoints.reverse() ;
  // se richiesto, inverto anche il parametro U
   if ( bInvertU) {
-     // recupero il primo valore di U che è il vecchio finale ed è il riferimento di inversione
+     // recupero il primo valore di U che è il vecchio finale ed è il riferimento di inversione
      double dUfin = m_lUPoints.front().second ;
     // ciclo su tutti gli elementi
      for ( auto& UPoint : m_lUPoints) {
@@ -1085,35 +1064,6 @@ PolyLine::Invert( bool bInvertU)
   return true ;
 }

-//----------------------------------------------------------------------------
-bool
-PolyLine::MyRemoveSamePoints( double dToler)
-{
-  // elimino i punti consecutivi diventati coincidenti (almeno 2)
-   if ( m_lUPoints.size() < 2)
-      return true ;
-  // punto precedente
-   auto precP = m_lUPoints.begin() ;
-  // punto corrente
-   auto currP = next( precP) ;
-  // mentre esiste un corrente
-   while ( currP != m_lUPoints.end()) {
-     // se coincidono
-      if ( AreSamePointEpsilon( precP->first, currP->first, dToler)) {
-        // elimino il punto corrente
-         currP = m_lUPoints.erase( currP) ;
-        // il precedente rimane inalterato
-      }
-     // altrimenti da tenere
-      else {
-        // avanzo la coppia di uno step
-         precP = currP ;
-         ++ currP ;
-      }
-   }
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 PolyLine::Flatten( double dZ)
@@ -1122,39 +1072,31 @@ PolyLine::Flatten( double dZ)
   if ( m_lUPoints.empty())
      return true ;
  // ciclo su tutti gli elementi per portarli alla Z indicata
-   for ( auto& UPoint : m_lUPoints)
+   for ( auto& UPoint : m_lUPoints) {
      UPoint.first.z = dZ ;
-  // elimino i punti consecutivi diventati coincidenti
-   MyRemoveSamePoints() ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-PolyLine::FlattenInAutoPlane( double dToler)
-{
-  // verifico non sia vuota
-   if ( m_lUPoints.empty())
+   }
+  // elimino i punti consecutivi diventati coincidenti (almeno 2)
+   if ( m_lUPoints.size() < 2)
      return true ;
-  // recupero dati sulla planarità della polilinea
-   int nRank ;
-   Point3d ptCen ;
-   Vector3d vtDir ;
-   bool bFlat = IsFlat( nRank, ptCen, vtDir, dToler) ;
-  // se non planare entro la tolleranza, esco
-   if ( ! bFlat)
-      return false ;
-  // se punto o linea, non devo fare alcunché
-   if ( nRank == 0  ||  nRank == 1)
-      return true ;
-  // assegno il piano medio
-   Plane3d plPlane ;
-   plPlane.Set( ptCen, vtDir) ;
-  // proietto i punti su questo piano
-   for ( auto& UPoint : m_lUPoints)
-      UPoint.first = ProjectPointOnPlane( UPoint.first, plPlane) ;
-  // elimino i punti consecutivi diventati coincidenti
-   MyRemoveSamePoints() ;
+  // punto precedente
+   auto precP = m_lUPoints.begin() ;
+  // punto corrente
+   auto currP = next( precP) ;
+  // mentre esiste un corrente
+   while ( currP != m_lUPoints.end()) {
+     // se coincidono
+      if ( AreSamePointApprox( precP->first, currP->first)) {
+        // elimino il punto corrente
+         currP = m_lUPoints.erase( currP) ;
+        // il precedente rimane inalterato
+      }
+     // altrimenti da tenere
+      else {
+        // avanzo la coppia di uno step
+         precP = currP ;
+         ++ currP ;
+      }
+   }
   return true ;
 }

@@ -1327,8 +1269,8 @@ PolyLine::GetMinAreaRectangleXY( Point3d& ptCen, Vector3d& vtAx, double& dLen, d
 bool
 PolyLine::Trim( const Plane3d& plPlane, bool bInVsOut)
 {
-  // se vuota non faccio alcunché
-   if ( m_lUPoints.empty())
+  // se vuota non faccio alcunché
+   if ( m_lUPoints.size() == 0)
      return false ;

  // determino le intersezioni dei lati con il piano
@@ -1429,7 +1371,7 @@ IsPointInsidePolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler
      return false ;
  // Riferimento alla lista dei punti
   PNTULIST& List = const_cast<PolyLine&>( plPoly).GetUPointList() ;
-  // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
+  // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
   double dMinSqDist = SQ_INFINITO ;
   Point3d ptMinDist ;
   auto itMinDistEnd = List.end() ;
@@ -1447,7 +1389,7 @@ IsPointInsidePolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler
   }
  // Determino tangente di riferimento
   Vector3d vtTang ;
-  // se minima distanza nell'estremo iniziale del segmento
+   // se minima distanza nell'estremo iniziale del segmento
   if ( AreSamePointApprox( ptMinDist, prev( itMinDistEnd)->first)) {
     // direzione del segmento
      Vector3d vtCurrTg = itMinDistEnd->first - prev( itMinDistEnd)->first ;
@@ -1463,7 +1405,7 @@ IsPointInsidePolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler
      vtTang = vtPrevTg + vtCurrTg ;
      vtTang.Normalize() ;
   }
-  // se altrimenti minima distanza nell'estremo finale del segmento
+   // se altrimenti minima distanza nell'estremo finale del segmento
   else if ( AreSamePointApprox( ptMinDist, itMinDistEnd->first)) {
     // direzione del segmento
      Vector3d vtCurrTg = itMinDistEnd->first - prev( itMinDistEnd)->first ;
@@ -1479,7 +1421,7 @@ IsPointInsidePolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler
      vtTang = vtCurrTg + vtNextTg ;
      vtTang.Normalize() ;
   }
-  // altrimenti minima distanza con l'interno
+   // altrimenti minima distanza con l'interno
   else {
      vtTang = itMinDistEnd->first - prev( itMinDistEnd)->first ;
   }
@@ -1518,7 +1460,7 @@ GetPointParamOnPolyLine( const Point3d& ptP, const PolyLine& plPoly, double dTol
     // assegno nuovo inizio
      ptStart = ptEnd ;
   }
-  // Il punto è sulla linea se la sua distanza rispetta la tolleranza
+  // Il punto è sulla linea se la sua distanza rispetta la tolleranza
   return ( dMinSqDist < dToler * dToler) ;
 }

@@ -1531,11 +1473,7 @@ ChangePolyLineStart( PolyLine& plPoly, const Point3d& ptNewStart, double dToler)
      return false ;
  // Riferimento alla lista dei punti
   PNTULIST& LoopList = const_cast<PolyLine&>( plPoly).GetUPointList() ;
-  // Se il punto inziale è già quello, non faccio nulla
-   if ( AreSamePointEpsilon( LoopList.begin()->first, ptNewStart, dToler))
-      return true ;
-
-  // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
+  // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
   double dMinSqDist = SQ_INFINITO ;
   auto itMinDistEnd = LoopList.end() ;
   auto itStart = LoopList.begin() ;
@@ -1579,7 +1517,7 @@ SplitPolyLineAtPoint( const PolyLine& plPoly, const Point3d& ptP, double dToler,
      return false ;
  // Riferimento alla lista dei punti
   const PNTULIST& LoopList = const_cast<PolyLine&>( plPoly).GetUPointList() ;
-  // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
+  // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
   double dMinSqDist = SQ_INFINITO ;
   auto itMinDistEnd = LoopList.end() ;
   auto itStart = LoopList.begin() ;
@@ -1618,9 +1556,8 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
   int nPnt2 = PL2.GetPointNbr() ;
   if ( nPnt1 == 0 || nPnt2 == 0)
      return false ;
- 
-  // indica la presenza di punti interni in comune tra le due polylines
-   bCommonInternalPoints = false ;
+
+   bCommonInternalPoints = false ;   // indica la presenza di punti interni in comune tra le due polylines

   vPnt1.reserve( PL1.GetPointNbr()) ;
   Point3d ptP1 ;
@@ -1644,6 +1581,10 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
   int nLastJ = 0 ;
   vPnt1[0].second = 0 ;

+   double dFirstDist, dFirstParMinDist ;
+   DistPointPolyLine( vPnt1[0].first, PL2, dFirstDist, dFirstParMinDist) ;      
+   int nFirstMinJ = ( int)( dFirstParMinDist + 0.5) ;
+
   for ( int i = 1 ; i < nTotP1 ; ++ i) {

      double dDist = INFINITO ;
@@ -1652,7 +1593,7 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
        // distanza del punto dal segmento della polilinea
         DistPointLine PointLineDistCalc( vPnt1[i].first, vPnt2[j-1].first, vPnt2[j].first) ;
         double dPlDist ;         
-         if ( PointLineDistCalc.GetDist( dPlDist)  &&  dPlDist < dDist - EPS_SMALL) {
+         if ( PointLineDistCalc.GetDist( dPlDist) && dPlDist < dDist) {
            dDist = dPlDist ;
            PointLineDistCalc.GetParamAtMinDistPoint( dMinDistPar) ;
            dMinDistPar += j - 1 ;
@@ -1660,11 +1601,15 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
      }
      int nMinJ = ( int)( dMinDistPar + 0.5) ;

+     // eventuale correzione per i primi punti ( da forzare nel vertice 0)
+      if ( nLastJ == 0 && nFirstMinJ > 0.5 * nTotP2  && nMinJ >= nFirstMinJ) 
+         nMinJ = 0 ;
+
      if ( nMinJ < nLastJ)
         nMinJ = nLastJ ;

-     // verifica se è un punto interno in comune con l'altra polyline  
-      if ( i < nTotP1 - 1  &&  dDist < EPS_SMALL  &&  abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
+     // verifica se è un punto interno in comune con l'altra polyline  
+      if ( i < nTotP1 - 1  &&  dDist < EPS_SMALL  && abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
         bCommonInternalPoints = true ;

      vPnt1[i].second = nMinJ ;
@@ -1674,6 +1619,9 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
  // calcoli per seconda curva
   int nLastI = 0 ;
   vPnt2[0].second = 0 ;
+   
+   DistPointPolyLine( vPnt2[0].first, PL1, dFirstDist, dFirstParMinDist) ;      
+   int nFirstMinI = ( int)( dFirstParMinDist + 0.5) ;

   for ( int j = 1 ; j < nTotP2 ; ++ j) {

@@ -1683,7 +1631,8 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
        // distanza del punto dal segmento della polilinea
         DistPointLine PointLineDistCalc( vPnt2[j].first, vPnt1[i-1].first, vPnt1[i].first) ;
         double dPlDist ;
-         if ( PointLineDistCalc.GetDist( dPlDist)  &&  dPlDist < dDist - EPS_SMALL) {
+         PointLineDistCalc.GetDist( dPlDist) ;
+         if ( dPlDist < dDist) {
            dDist = dPlDist ;
            PointLineDistCalc.GetParamAtMinDistPoint( dMinDistPar) ;
            dMinDistPar += i - 1 ;
@@ -1691,331 +1640,19 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
      }
      int nMinI = ( int)( dMinDistPar + 0.5) ;

+     // eventuale correzione per primi punti 
+      if ( nLastI == 0 && nFirstMinI > 0.5 * nTotP1  && nMinI >= nFirstMinI) 
+         nMinI = 0 ;
+
      if ( nMinI < nLastI)
         nMinI = nLastI ;

-      if ( j < nTotP2 - 1  &&  dDist < EPS_SMALL &&  abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
+      if ( j < nTotP2 - 1  &&  dDist < EPS_SMALL && abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
         bCommonInternalPoints = true ;

      vPnt2[j].second = nMinI ;
      nLastI = nMinI ;
   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-MatchPolyLinesAddingPoints( const PolyLine& PL1, const PolyLine& PL2, int nType, PNTIVECTOR& vPnt1, PNTIVECTOR& vPnt2)
-{
-  // prima trovo le associazioni senza aggiunte di punti
-   Point3d ptP2 ;
-   CurveComposite cc1, cc2 ;
-   cc1.FromPolyLine( PL1) ;
-   cc2.FromPolyLine( PL2) ;
-   int nPnt1 = PL1.GetPointNbr() ;
-   int nPnt2 = PL2.GetPointNbr() ;
-   vector<POINTU> vMatch2 ;
-   PL2.GetFirstPoint( ptP2) ;
-   while ( PL2.GetNextPoint( ptP2, true)) {
-      DistPointCurve dpc( ptP2, cc1, false) ;
-      int nFlag = 0 ;
-      double dParam ; dpc.GetParamAtMinDistPoint( 0, dParam, nFlag) ;
-      Point3d ptJoint ; dpc.GetMinDistPoint( 0, ptJoint, nFlag) ;
-      vMatch2.emplace_back( ptJoint, dParam) ;
-   }
-
-   int nAtStart2 = 0 ;  // match ripetuti dalla curva U0 allo start della curva U1
-   int nAtEnd2 = 0 ;
-   Point3d ptP1 ; PL1.GetFirstPoint( ptP1) ;
-   int c = 0 ;
-   int nRep1 = 0 ;  // match interni consecutivi uguali di punti della curva U0 con punti della curva U1
-   int nRep2 = 0 ;
-   double dLastParamMatch = 0 ;
-   Point3d ptLastPointMatch = ptP1 ;
-   BOOLVECTOR vbRep1( nPnt1) ;
-   INTVECTOR vnAddedOrNextIsRep1 ;  // 0 non Rep, 1 Rep, 2 Next is Rep ;
-   DBLVECTOR vdSplit1 ;
-   DBLVECTOR vdMatch1 ;
-   fill( vbRep1.begin(), vbRep1.end(), false) ;
-   while ( PL1.GetNextPoint( ptP1, true)) {
-      // devo salvarmi se matcho più punti con lo start o l'end della curva totale
-      DistPointCurve dpc( ptP1, cc2, false) ;
-      int nFlag = 0 ;
-      double dParam ; dpc.GetParamAtMinDistPoint( 0, dParam, nFlag) ;
-      Point3d ptJoint ; dpc.GetMinDistPoint( 0, ptJoint, nFlag) ;
-      vdMatch1.push_back( dParam) ;
-      if ( dParam < EPS_SMALL ) {
-         ++nAtStart2 ;
-         vbRep1[c] = true ;
-         ++c ;
-         continue ;
-      }
-      else if ( dParam > nPnt2 - EPS_SMALL ) {
-         vbRep1[c] = nAtEnd2 == 0 ? false : true ;
-         vbRep1.back() = true ;
-         ++ nAtEnd2 ;
-         ++c ;
-         continue ;
-      }
-      if ( dParam <= dLastParamMatch  ||  AreSamePointApprox( ptJoint, ptLastPointMatch)) {
-         dParam = dLastParamMatch ;
-         vbRep1[c] = true ;
-         ++ nRep1 ;
-         ++c ;
-         continue ;
-      }
-      else {
-         dLastParamMatch = dParam ;
-         ptLastPointMatch = ptJoint ;
-         // se sono già troppo vicino ad un split esistente allora non faccio nulla
-         if ( abs(dParam - round( dParam)) < 100 * EPS_PARAM) {
-            ++c ;
-            continue ;
-         }
-         vdSplit1.push_back( dParam) ;
-         // verifico se ho un match per questo punto
-         // in tal caso vuol dire che sto creando una ripetizione nRep1
-         int nCase = 0 ;
-         for ( int j = 0 ; j < int( vMatch2.size()) ; ++j) {
-            if ( abs(vMatch2[j].second - (c + 1)) < EPS_SMALL) {
-               // devo però verificare che non ci sia un match successivo, perché in quel caso non ho una ripetizione
-               bool bFoundMatch = false ;
-               for ( int z = int( vMatch2[j].second) ; z < int( vdMatch1.size()) ; ++z) {
-                  if ( abs( vdMatch1[z] - ( j + 1 )) < EPS_SMALL ) {
-                     bFoundMatch = true ;
-                     break ;
-                  }
-               }
-
-               if ( ! bFoundMatch) {
-                  ++ nRep2 ;
-                  // capisco se il punto è rep o se lo è il suo successivo
-                  if ( j + 1 < dParam)
-                     nCase = 1 ;
-                  else
-                     nCase = 2 ;
-               }
-               break ;
-            }
-         }
-         vnAddedOrNextIsRep1.push_back( nCase) ;
-      }
-      ++c ;
-   }
-   int nAtStart1 = 0 ;
-   int nAtEnd1 = 0 ;
-   PL2.GetFirstPoint( ptP2) ;
-   c = 0 ;
-   dLastParamMatch = 0 ;
-   ptLastPointMatch = ptP2 ;
-   INTVECTOR vnAddedOrNextIsRep2 ;  // 0 non Rep, 1 Rep, 2 Next is Rep ;
-   DBLVECTOR vdSplit2 ;
-   BOOLVECTOR vbRep2( nPnt2) ;
-   fill( vbRep2.begin(), vbRep2.end(), false) ;
-   while ( PL2.GetNextPoint( ptP2, true)) {
-      DistPointCurve dpc( ptP2, cc1, false) ;
-      int nFlag = 0 ;
-      double dParam ; dpc.GetParamAtMinDistPoint( 0, dParam, nFlag) ;
-      Point3d ptJoint ; dpc.GetMinDistPoint( 0, ptJoint, nFlag) ;
-      if ( dParam < EPS_SMALL ) {
-         ++nAtStart1 ;
-         vbRep2[c] = true ;
-         ++c ;
-         continue ;
-      }
-      else if ( dParam > nPnt1 - EPS_SMALL ) {
-         vbRep2[c] = ( nAtEnd1 == 0 ? false : true) ;
-         vbRep2.back() = true ;
-         ++ nAtEnd1 ;
-         ++c ;
-         continue ;
-      }
-      if ( dParam <= dLastParamMatch  ||  AreSamePointApprox( ptJoint, ptLastPointMatch)) {
-         dParam = dLastParamMatch ;
-         vbRep2[c] = true ;
-         ++ nRep2 ;
-         ++c ;
-         continue ;
-      }
-      else {
-         dLastParamMatch = dParam ;
-         ptLastPointMatch = ptJoint ;
-        // se sono troppo vicino ad uno split esistente allora non faccio nulla
-         if ( abs( dParam - round( dParam)) < 100 * EPS_PARAM) {
-            ++c ;
-            continue ;
-         }
-         vdSplit2.push_back( dParam) ;
-        // verifico se ho un match per questo punto
-        // in tal caso vuol dire che sto creando una ripetizione nRep0
-         int nCase = 0 ;
-         for ( int j = 0 ; j < int( vdMatch1.size()) ; ++j) {
-            if ( abs( vdMatch1[j] - (c + 1)) < EPS_SMALL) {
-              // devo però verificare che non ci sia un match successivo, perché in quel caso non ho una ripetizione
-               bool bFoundMatch = false ;
-               for ( int z = int( vdMatch1[j]) ; z < int( vMatch2.size()) ; ++z) {
-                  if ( abs( vMatch2[z].second - ( j + 1 )) < EPS_SMALL) {
-                     bFoundMatch = true ;
-                     break ;
-                  }
-               }
-
-               if ( ! bFoundMatch) {
-                  ++nRep1 ;
-                 // capisco se il punto è rep o se lo è il suo successivo
-                  if ( j + 1 < dParam)
-                     nCase = 1 ;
-                  else
-                     nCase = 2 ;
-               }
-               break ;
-            }
-         }
-         vnAddedOrNextIsRep2.push_back( nCase) ;
-      }
-      ++c ;
-   }
-
-  // applico effettivamente gli split e aggiungo gli elementi ai vettori vbRep
-   int nUnit = 0 ;
-   if ( ! vdSplit1.empty())
-      nUnit = int( vdSplit1.back()) ;
-   for ( int z = int( vdSplit1.size()) - 1 ; z >= 0 ; --z) {
-      double dSplit = vdSplit1[z] ;
-      int nSplit = int( dSplit) ;
-     // se sto cercando di fare uno split sulla stessa curva che ho già splittato al passaggio precedente allora devo
-     // riscalare
-      if ( nSplit == nUnit  &&  z < int( vdSplit1.size()) - 1) {
-         dSplit = nSplit + ( dSplit - nSplit) / ( vdSplit1[z+1] - nSplit) ;
-      }
-      nUnit = nSplit ;
-      cc2.AddJoint( dSplit) ;
-      switch ( vnAddedOrNextIsRep1[z]) {
-      case 0 :
-         if ( vbRep2[nSplit])
-            ++ nRep2 ;
-        // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo
-         vbRep2.insert( vbRep2.begin() + nSplit, vbRep2[nSplit]) ;
-         break ;
-      case 1 :
-         vbRep2.insert( vbRep2.begin() + nSplit, true) ;
-         break ;
-      case 2 :
-         if ( vbRep2[nSplit])
-            --nRep2 ;
-         else
-            vbRep2[nSplit] = true ;
-         vbRep2.insert( vbRep2.begin() + nSplit, false) ;
-         break ;
-      }
-   }
-   if ( ! vdSplit2.empty())
-      nUnit = int( vdSplit2.back()) ;
-   for ( int z = int( vdSplit2.size()) - 1 ; z >= 0 ; --z) {
-      double dSplit = vdSplit2[z] ;
-      int nSplit = int( dSplit) ;
-     // se sto cercando di fare uno split sulla stessa curva che ho già splittato al passaggio precedente allora devo
-     // riscalare
-      if ( nSplit == nUnit  &&  z < int( vdSplit2.size()) - 1) {
-         dSplit = nSplit + ( dSplit - nSplit) / (vdSplit2[z+1] - nSplit) ;
-      }
-      nUnit = nSplit ;
-      cc1.AddJoint( dSplit) ;
-      switch ( vnAddedOrNextIsRep2[z]) {
-      case 0 :
-         if ( vbRep1[nSplit])
-            ++ nRep1 ;
-        // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo
-         vbRep1.insert( vbRep1.begin() + nSplit, vbRep1[nSplit]) ;
-         break ;
-      case 1 :
-         vbRep1.insert( vbRep1.begin() + nSplit, true) ;
-         break ;
-      case 2 :
-         if ( vbRep1[nSplit])
-            -- nRep1 ;
-         else
-            vbRep1[nSplit] = true ;
-         vbRep1.insert( vbRep1.begin() + nSplit, false) ;
-         break ;
-      }
-   }
-
-   nPnt1 = cc1.GetCurveCount() ;
-   nPnt2 = cc2.GetCurveCount() ;
-   //aggiusto i vettori delle ripetizioni in modo in modo che non arrivino mai ad essere contemporaneamente true
-   int nAddedSpan = 0 ;
-   int nCrv1 = 0 ;
-   int nCrv2 = 0 ;
-   while ( nAddedSpan < nPnt1 + nAtStart1 + nAtEnd1 + nRep2) {
-      if ( nCrv1 >= nPnt1)
-         nCrv1 = nPnt1 - 1 ;
-      if ( nCrv2 >= nPnt2)
-         nCrv2 = nPnt2 - 1 ;
-      bool bRep1 = vbRep1[nCrv1] ;
-      bool bRep2 = vbRep2[nCrv2] ;
-      if ( bRep1  &&  bRep2) {
-         vbRep1[nCrv1] = false ;
-         bRep1 = false ;
-         vbRep2[nCrv2] = false ;
-         bRep2 = false ;
-         -- nRep1 ;
-         -- nRep2 ;
-      }
-      if ( ! bRep1  ||  nCrv2 == nPnt2 - 1)
-         ++ nCrv2 ;
-      if ( ! bRep2  ||  nCrv1 == nPnt1 - 1)
-         ++ nCrv1 ;
-      ++ nAddedSpan ;
-   }
-  // se non sono arrivato all'ultima curva su U0 o U1 vuol dire che ho creato delle ripetizioni che non ho contato prima
-   if ( nCrv2 < nPnt2) {
-      nRep2 += nPnt2 - nCrv2 ;
-      for ( int z = int( vbRep2.size()) - 1 ; z >= nCrv2 ; --z)
-         vbRep2[z] = true ;
-   }
-   if ( nCrv1 < nPnt1) {
-      nRep1 += nPnt1 - nCrv1 ;
-      for ( int z = int( vbRep1.size()) - 1 ; z >= nCrv1 ; --z)
-         vbRep1[z] = true ;
-   }
-
-  // trovo il numero di span che dovrà avere la superficie
-  // ( numero di sottocurve che compongono la U0 + tutte le ripetizioni dei match di punti della curva U1 con i punti di U0)
-   int nPnt = nPnt1 + nAtStart1 + nAtEnd1 + nRep2 ;
-
-   if ( nPnt != nPnt2 + nAtStart2 + nAtEnd2 + nRep1)
-      LOG_DBG_ERR( GetEGkLogger(), "There could be an error in the creation of a ruled surface in mode RLT_B_MINDIST_PLUS") ;
-
-  // aggiungo i punti di controllo scorrendo in contemporanea le due curve
-   nAddedSpan = 0 ;
-   nCrv1 = 0 ;
-   nCrv2 = 0 ;
-   bool bLast1 = false ;
-   bool bLast2 = false ;
-   while ( nAddedSpan < nPnt) {
-      if ( nCrv1 >= nPnt1) {
-         nCrv1 = nPnt1 - 1 ;
-         bLast1 = true ;
-      }
-      if ( nCrv2 >= nPnt2) {
-         nCrv2 = nPnt2 - 1 ;
-         bLast2 = true ;
-      }
-      bool bRep1 = vbRep1[nCrv1] ;
-      bool bRep2 = vbRep2[nCrv2] ;
-      const ICurve* pSubCrv1 = cc1.GetCurve( nCrv1) ;
-      Point3d ptStart1 ; pSubCrv1->GetStartPoint( ptStart1) ;
-      vPnt1.emplace_back( ptStart1, nAddedSpan) ;
-      const ICurve* pSubCrv2 = cc2.GetCurve( nCrv2) ;
-      Point3d ptStart2 ; pSubCrv2->GetStartPoint( ptStart2) ;
-      vPnt2.emplace_back( ptStart2, nAddedSpan) ;
-      if ( ! bRep2)
-         ++ nCrv1 ;
-      if ( ! bRep1)
-         ++ nCrv2 ;
-      ++ nAddedSpan ;
-   }

   return true ;
-}
+}
@@ -150,18 +150,12 @@ PolygonElevationInClosedSurfTm( const Polygon3d& pgFacet, const ISurfTriMesh& Cl
   Vector3d vtN = pgFacet.GetVersN() ;
   PolyLine PL = pgFacet.GetPolyLine() ;

-  // calcolo elevazione massima del contorno della faccia e nel suo centro
+  // calcolo elevazione massima del contorno della faccia
   const double RAY_LEN = 100000 ;
   dElev = 0 ;
-   PNTVECTOR vptP ; vptP.reserve( PL.GetPointNbr()) ;
   Point3d ptP ;
   bool bFound = PL.GetFirstPoint( ptP) ;
   while ( bFound) {
-      vptP.push_back( ptP) ;
-      bFound = PL.GetNextPoint( ptP, true) ;
-   }
-   vptP.push_back( ptCen) ;
-   for ( const Point3d& ptP : vptP) {
      ILSIVECTOR vInters ;
      IntersLineSurfTm( ptP, vtN, RAY_LEN, CldStm, vInters, true) ;
      for ( int i = 0 ; i < int( vInters.size()) ; ++ i) {
@@ -177,6 +171,7 @@ PolygonElevationInClosedSurfTm( const Polygon3d& pgFacet, const ISurfTriMesh& Cl
         else if ( Inters.nILTT == ILTT_SEGM   ||  Inters.nILTT == ILTT_SEGM_ON_EDGE)
            dElev = max( dElev, Inters.dU2) ;
      }
+      bFound = PL.GetNextPoint( ptP, true) ; 
   }
  // calcolo elevazione massima degli eventuali spigoli (e vertici) della superficie chiusa dalla parte positiva della faccia e che cadono in essa
   int nEdgeCnt = CldStm.GetEdgeCount() ;
@@ -19,10 +19,10 @@
 void
 PolygonPlane::AddPoint( const Point3d& ptP)
 {
-  // se è il primo punto (parto da -1 perchè verrà contato alla chiusura)
+  // se è il primo punto (parto da -1 perchè verrà contato alla chiusura)
   if ( m_nPntNbr == -1) {
     // inizializzazioni
-      m_dLenN = -1 ;
+      m_dLenN = 0 ;
      m_vtN = V_NULL ;
      m_ptMid = ORIG ;
      m_dSXy = 0 ; m_dSXz = 0 ;
@@ -60,16 +60,16 @@ PolygonPlane::AddPoint( const Point3d& ptP)
 bool
 PolygonPlane::Finalize( void)
 {
-  // almeno 3 punti (il triangolo è il poligono con minimo numero di lati)
+  // almeno 3 punti (il triangolo è il poligono con minimo numero di lati)
   if ( m_nPntNbr + 1 < 3)
      return false ;
-  // se il poligono non è stato chiuso, aggiungo calcolo per ultimo lato
+  // se il poligono non è stato chiuso, aggiungo calcolo per ultimo lato
   if ( ! AreSamePointExact( m_ptFirst, m_ptLast)) {
     // aggiungo il primo punto per far eseguire i conti sul lato di chiusura
      AddPoint( m_ptFirst) ;
   }
  // se non effettuato, eseguo il calcolo finale
-   if ( m_dLenN < 0) {
+   if ( m_dLenN < EPS_SMALL) {
     // lunghezza della normale (doppio dell'area del poligono)
      m_dLenN = m_vtN.Len() ;
      if ( m_dLenN < SQ_EPS_SMALL)
@@ -1,953 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2026
-//----------------------------------------------------------------------------
-// File : ProjectCurveSurfTm.cpp    Data : 03.01.26        Versione : 3.1a1
-// Contenuto : Implementazione funzioni proiezione curve su superficie Trimesh.
-//
-//
-//
-// Modifiche : 31.08.23 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "SurfTriMesh.h"
-#include "SurfBezier.h"
-#include "GeoConst.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
-#include "/EgtDev/Include/EGkDistPointSurfTm.h"
-#include "/EgtDev/Include/EGkIntersPlanePlane.h"
-#include "/EgtDev/Include/EGkIntersLinePlane.h"
-#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
-#include "/EgtDev/Include/EGkProjectCurveSurf.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-// Angolo limite tra normale al triangolo e direzione di proiezione 89°
-const double COS_ANG_LIM = 0.0175 ;
-// Angolo massimo tra normali per effettuare bisezione su spigolo
-const double COS_ANG_MAX_CORNER = 0.8660 ;
-// Tipologia di punto
-const int P5AX_TO_DELETE = -1 ;        // da cancellare
-const int P5AX_OUT = 0 ;               // aggiunto prima di inizio o dopo fine
-const int P5AX_STD = 1 ;               // standard
-const int P5AX_CVEX = 2 ;              // su angolo convesso
-const int P5AX_CONC = 3 ;              // in angolo concavo
-const int P5AX_BEFORE_CONC = 4 ;       // adiacente ad angolo concavo
-const int P5AX_AFTER_CONC = 5 ;        // adiacente ad angolo concavo
-
-//----------------------------------------------------------------------------
-static double
-GetSurfBezierTol( double dLinTol)
-{
-   return max( dLinTol / 10, EPS_SMALL) ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext, double dSqTol)
-{
-   for ( int i = nPrec + 1 ; i < nCurr ; ++ i) {
-      double dSqDist ;
-      if ( ! DistPointLine( vPt5ax[i].ptP, vPt5ax[nPrec].ptP, vPt5ax[nNext].ptP).GetSqDist( dSqDist)  ||  dSqDist > dSqTol)
-         return false ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
-{
-   for ( int i = 1 ; i < ssize( vPt5ax) ; ++ i) {
-     // precedente
-      int j = i - 1 ;
-     // se normali tra corrente e precedente oltre limite e punti abbastanza lontani
-      if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER  &&
-           SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
-        // intersezione tra le due facce
-         Plane3d plPlane1 ; plPlane1.Set( vPt5ax[j].ptP, vPt5ax[j].vtDir1) ;
-         Plane3d plPlane2 ; plPlane2.Set( vPt5ax[i].ptP, vPt5ax[i].vtDir1) ;
-         Point3d ptEdge ; Vector3d vtEdge ;
-         if ( IntersPlanePlane( plPlane1, plPlane2, ptEdge, vtEdge) == IPPT_YES) {
-            Plane3d plPlane3 ; plPlane3.Set(vPt5ax[i].ptP, (vPt5ax[i].ptP - vPt5ax[j].ptP) ^ ( vPt5ax[i].vtDir1 + vPt5ax[j].vtDir1)) ;
-            Point3d ptInt ;
-            if ( IntersLinePlane( ptEdge, vtEdge, 1, plPlane3, ptInt, false) == ILPT_YES) {
-              // verifico se spigolo convesso o concavo
-               bool bConvex ;
-               if ( ! AreSamePointApprox( ptInt, vPt5ax[j].ptP))
-                  bConvex = ( ( vPt5ax[j].vtDir1 ^ ( ptInt - vPt5ax[j].ptP)) * vtEdge > 0) ;
-               else
-                  bConvex = (( vPt5ax[i].vtDir1 ^ ( ptInt - vPt5ax[i].ptP)) * vtEdge < 0) ;
-              // se convesso, metto due punti con direzione appena prima e appena dopo
-               if ( bConvex) {
-                  Vector3d vtLine1 = ptInt - vPt5ax[j].ptP ; double dLen1 = vtLine1.Len() ;
-                  Vector3d vtLine2 = vPt5ax[i].ptP - ptInt ; double dLen2 = vtLine2.Len() ;
-                  if ( dLen1 > 2 * EPS_SMALL) {
-                     Point5ax Pt5ax ;
-                     Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
-                     Pt5ax.vtDir1 = vPt5ax[j].vtDir1 ;
-                     Pt5ax.vtDir2 = vPt5ax[j].vtDir2 ;
-                     Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
-                     Pt5ax.nFlag = P5AX_CVEX ;
-                     vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
-                     ++ i ;
-                  }
-                  else
-                     vPt5ax[j].nFlag = P5AX_CVEX ;
-                  if ( dLen2 > 2 * EPS_SMALL) {
-                     Point5ax Pt5ax ;
-                     Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
-                     Pt5ax.vtDir1 = vPt5ax[i].vtDir1 ;
-                     Pt5ax.vtDir2 = vPt5ax[i].vtDir2 ;
-                     Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
-                     Pt5ax.nFlag = P5AX_CVEX ;
-                     vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
-                     ++ i ;
-                  }
-                  else
-                     vPt5ax[i].nFlag = P5AX_CVEX ;
-               }
-              // altrimenti concavo, aggiungo un solo punto con la direzione media
-               else {
-                  Point5ax Pt5ax ;
-                  Pt5ax.ptP = ptInt ;
-                  Pt5ax.vtDir1 = Media( vPt5ax[i].vtDir1, vPt5ax[j].vtDir1) ; Pt5ax.vtDir1.Normalize() ;
-                  Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ; Pt5ax.vtDir2.Normalize() ;
-                  Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
-                  Pt5ax.nFlag = P5AX_CONC ;
-                  vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
-                  ++ i ;
-               }
-            }
-         }
-      }
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen, bool bTestDir)
-{
-  // Parametri di riferimento
-   double dSqMaxLen = dMaxSegmLen * dMaxSegmLen ;
-   double dSqTol = dLinTol * dLinTol ;
-   const double LENREF = 200 ;
-   double dCosAngLim = 1 - dSqTol / ( 2 * LENREF * LENREF) ;
-  // Cerco gli angoli interni e marco opportunamente i punti nelle vicinanze fino ai limiti prima e dopo
-   int nInd = 0 ;
-   while ( nInd  < ssize( vPt5ax)) {
-      if ( vPt5ax[nInd].nFlag == P5AX_CONC) {
-        // analizzo i punti appena precedenti
-         int nIpv = nInd - 1 ;
-         while ( nIpv >= 0) {
-            double dSqLen = SqDist( vPt5ax[nInd].ptP, vPt5ax[nIpv].ptP) ;
-            if ( dSqLen < dSqMaxLen)
-               vPt5ax[nIpv].nFlag = P5AX_TO_DELETE ;
-            else {
-               vPt5ax[nIpv].nFlag = P5AX_BEFORE_CONC ;
-               break ;
-            }
-            -- nIpv ;
-         }
-        // analizzo i punti appena successivi
-         int nInx = nInd + 1 ;
-         while ( nInx < ssize( vPt5ax)) {
-            double dSqLen = SqDist( vPt5ax[nInd].ptP, vPt5ax[nInx].ptP) ;
-            if ( dSqLen < dSqMaxLen)
-               vPt5ax[nInx].nFlag = P5AX_TO_DELETE ;
-            else {
-               vPt5ax[nInx].nFlag = P5AX_AFTER_CONC ;
-               break ;
-            }
-            ++ nInx ;
-         }
-      }
-      ++ nInd ;
-   }
-  // Rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
-   int nCnt = 0 ;
-   int nPrec = 0 ;
-   int nCurr = 1 ;
-   int nNext = 2 ;
-   while ( nNext < ssize( vPt5ax)) {
-      bool bRemove = false ;
-     // lunghezza del segmento che unisce gli adiacenti
-      double dSqLen = SqDist( vPt5ax[nPrec].ptP, vPt5ax[nNext].ptP) ;
-     // se rimovibile (Flag standard) e lunghezza inferiore al massimo, passo agli altri controlli
-      if ( vPt5ax[nCurr].nFlag == P5AX_STD  &&  dSqLen <= dSqMaxLen) {
-        // distanza del punto corrente dal segmento che unisce gli adiacenti
-         DistPointLine dPL( vPt5ax[nCurr].ptP, vPt5ax[nPrec].ptP, vPt5ax[nNext].ptP) ;
-         double dSqDist ;
-        // se distanza inferiore a tolleranza lineare
-         if ( dPL.GetSqDist( dSqDist)  &&  dSqDist < dSqTol  &&  PointsInTolerance( vPt5ax, nPrec, nCurr, nNext, dSqTol)) {
-           // verifico se errore angolare inferiore a limite
-            double dPar ; dPL.GetParamAtMinDistPoint( dPar) ;
-            if ( bTestDir) {
-               Vector3d vtNew = Media( vPt5ax[nPrec].vtDir1, vPt5ax[nNext].vtDir1, dPar) ;
-               if ( vtNew.Normalize()  &&  vtNew * vPt5ax[nCurr].vtDir1 > dCosAngLim)
-                  bRemove = true ;
-            }
-            else {
-               Vector3d vtNew = Media( vPt5ax[nPrec].vtDir2, vPt5ax[nNext].vtDir2, dPar) ;
-               if ( vtNew.Normalize()  &&  vtNew * vPt5ax[nCurr].vtDir2 > dCosAngLim)
-                  bRemove = true ;
-            }
-         }
-      }
-     // se da eliminare
-      if ( bRemove) {   
-         // dichiaro da eliminare il punto
-         vPt5ax[nCurr].nFlag = P5AX_TO_DELETE ;
-        // avanzo con corrente e successivo
-         nCurr = nNext ;
-         ++ nNext ;
-      }
-     // altrimenti da tenere
-      else {
-        // avanzo il terzetto di uno step
-         nPrec = nCurr ;
-         nCurr = nNext ;
-         ++ nNext ;
-        // incremento contatore dei punti conservati
-         ++ nCnt ;
-      }
-   }
-
-  // Copio i punti da conservare in un vettore temporaneo
-   PNT5AXVECTOR vMyPt5ax ;
-   vMyPt5ax.reserve( nCnt) ;
-   for ( const auto& Pt5ax : vPt5ax) {
-      if ( Pt5ax.nFlag != P5AX_TO_DELETE)
-         vMyPt5ax.emplace_back( Pt5ax) ;
-   }
-  // scambio i due vettori
-   vPt5ax.swap( vMyPt5ax) ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, double dPar, Point5ax& Pt5ax)
-{
-  // punto sulle supefici a minima distanza
-   int nSurfMin = -1 ;
-   int nTriaMin ;
-   Point3d ptMin ;
-   double dMinDist ;
-   for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
-     // punto sulla superficie a minima distanza
-      DistPointSurfTm dPS( ptP, *vpStm[i]) ;
-      double dDist ;
-      if ( dPS.GetDist( dDist)  &&  ( nSurfMin == -1  ||  dDist < dMinDist)) {
-         nSurfMin = i ;
-         dPS.GetMinDistPoint( ptMin) ;
-         dPS.GetMinDistTriaIndex ( nTriaMin) ;
-         dMinDist = dDist ;
-      }
-   }
-
-  // se trovato
-   if ( nSurfMin >= 0) {
-     // assegno il punto
-      Point3d ptInt = ptMin ;
-     // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
-      Triangle3dEx trTria ;
-      if ( ! vpStm[nSurfMin]->GetTriangle( nTriaMin, trTria))
-         return false ;
-      Vector3d vtN ;
-      if ( ! CalcNormal( ptMin, trTria, vtN))
-         vtN = trTria.GetN() ;
-     // assegno valori al punto 5assi
-      Pt5ax.ptP = ptInt ;
-      Pt5ax.vtDir1 = vtN ;
-      Pt5ax.vtDir2 = vtN ;
-      Pt5ax.dPar = dPar ;
-      Pt5ax.nFlag = P5AX_STD ;
-     // ritorno con successo
-      return true ;
-   }
-
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
-{
-  // sistemazioni per tipo di superficie
-   CISRFTMPVECTOR vpSurfTm ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
-      const SurfTriMesh* pSurfTm = nullptr ;
-      switch ( vpSurf[i]->GetType()) {
-      case SRF_TRIMESH :
-         pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
-         break ;
-      case SRF_BEZIER :
-       { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-         SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
-         SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-       } break ;
-      case SRF_FLATRGN :
-         pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
-         break ;
-      default :
-         break ;
-      }
-      if ( pSurfTm == nullptr)
-         return false ;
-      vpSurfTm.emplace_back( pSurfTm) ;
-   }
-
-  // controllo le tolleranze
-   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
-   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
-
-  // approssimo la curva con una polilinea entro la tolleranza
-   PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
-      return false ;
-   const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
-   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
-      return false ;
-
-  // Pulisco e riservo spazio nel vettore dei punti risultanti
-   vPt5ax.clear() ;
-   vPt5ax.reserve( PL.GetPointNbr()) ;
-
-  // proietto i punti della polilinea sulla superficie secondo la direzione di minima distanza
-   double dPar ;
-   Point3d ptP ;
-   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
-   while ( bFound) {
-     // se trovo proiezione, la salvo
-      Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, dPar, Pt5ax))
-         vPt5ax.emplace_back( Pt5ax) ;
-     // passo al successivo
-      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
-   }
-
-  // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
-
-  // rimozione punti in eccesso rispetto alle tolleranze
-   RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-// --- vettore di oggetti intersezione massiva rette parallele SurfTM --------
-typedef std::vector<IntersParLinesSurfTm*> INTPARLINESTMPVECTOR ;
-
-//----------------------------------------------------------------------------
-static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const Frame3d& frRefLine, const INTPARLINESTMPVECTOR& vpIntPLSTM,
-                    double dPar, Point5ax& Pt5ax)
-{
-  // intersezione retta di proiezione con superfici  (conservo l'intersezione più alta)
-   Point3d ptL = GetToLoc( ptP, frRefLine) ;
-   int nInd = -1 ;
-   IntLinStmInfo IntRes ;
-   for ( int i = 0 ; i < ssize( vpIntPLSTM) ; ++ i) {
-      ILSIVECTOR vIntRes ;
-      if ( vpIntPLSTM[i]->GetInters( ptL, 1, vIntRes, false)) {
-        // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
-         int nI = ssize( vIntRes) - 1 ;
-         while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
-            --nI ;
-        // se trovata
-         if ( nI >= 0) {
-            if ( nInd < 0) {
-               IntRes = vIntRes[nI] ;
-               nInd = i ;
-            }
-            else {
-               double dUref = (( IntRes.nILTT == ILTT_SEGM || IntRes.nILTT == ILTT_SEGM_ON_EDGE) ? IntRes.dU2 : IntRes.dU) ;
-               double dU = (( vIntRes[nI].nILTT == ILTT_SEGM || vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE) ? vIntRes[nI].dU2 : vIntRes[nI].dU) ;
-               if ( dU > dUref) {
-                  IntRes = vIntRes[nI] ;
-                  nInd = i ;
-               }
-            }
-         }
-      }
-   }
-  // se trovata
-   if ( nInd >= 0) {
-     // calcolo il punto
-      Point3d ptInt ;
-      if ( IntRes.nILTT == ILTT_SEGM  ||  IntRes.nILTT == ILTT_SEGM_ON_EDGE)
-         ptInt = IntRes.ptI2 ;
-      else
-         ptInt = IntRes.ptI ;
-     // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
-      Triangle3dEx trTria ;
-      if ( ! vpStm[nInd]->GetTriangle( IntRes.nT, trTria))
-         return false ;
-      Vector3d vtN ;
-      if ( ! CalcNormal( ptInt, trTria, vtN))
-         vtN = trTria.GetN() ;
-     // assegno valori al punto 5assi
-      Pt5ax.ptP = ptInt ;
-      Pt5ax.vtDir1 = vtN ;
-      Pt5ax.vtDir2 = frRefLine.VersZ() ;
-      Pt5ax.dPar = dPar ;
-      Pt5ax.nFlag = P5AX_STD ;
-     // ritorno con successo
-      return true ;
-   }
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vector3d& vtDir,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
-{
-  // sistemazioni per tipo di superficie
-   CISRFTMPVECTOR vpSurfTm ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
-      const SurfTriMesh* pSurfTm = nullptr ;
-      switch ( vpSurf[i]->GetType()) {
-      case SRF_TRIMESH :
-         pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
-         break ;
-      case SRF_BEZIER :
-       { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-         SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
-         SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-       } break ;
-      case SRF_FLATRGN :
-         pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
-         break ;
-      default :
-         break ;
-      }
-      if ( pSurfTm == nullptr)
-         return false ;
-      vpSurfTm.emplace_back( pSurfTm) ;
-   }
-
-  // controllo le tolleranze
-   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
-   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
-
-  // approssimo la curva con una polilinea entro la tolleranza
-   PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
-      return false ;
-   const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
-   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
-      return false ;
-
-  // Oggetti per calcolo massivo intersezioni tra linee di proiezione e superfici
-   Frame3d frRefLine ;
-   if ( ! frRefLine.Set( ORIG, vtDir))
-      return false ;
-   INTPARLINESTMPVECTOR vpIntPLSTM ; vpIntPLSTM.reserve( vpSurfTm.size()) ;
-   for ( int i = 0 ; i < ssize( vpSurfTm) ; ++ i) {
-      IntersParLinesSurfTm* pIntPLSTM = new IntersParLinesSurfTm( frRefLine, *vpSurfTm[i]) ;
-      if ( pIntPLSTM == nullptr) {
-         for ( int j = 0 ; j < ssize( vpIntPLSTM) ; ++ j)
-            delete vpIntPLSTM[j] ;
-         return false ;
-      }
-      vpIntPLSTM.emplace_back( pIntPLSTM) ;
-   }
-
-  // Pulisco e riservo spazio nel vettore dei punti risultanti
-   vPt5ax.clear() ;
-   vPt5ax.reserve( PL.GetPointNbr()) ;
-
-  // proietto i punti della polilinea sulla superficie
-   double dPar ;
-   Point3d ptP ;
-   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
-   while ( bFound) {
-     // se trovo proiezione, la salvo
-      Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, frRefLine, vpIntPLSTM, dPar, Pt5ax))
-         vPt5ax.emplace_back( Pt5ax) ;
-     // passo al successivo
-      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
-   }
-
-  // Libero oggetti per calcolo massivo
-   for ( int i = 0 ; i < ssize( vpIntPLSTM) ; ++ i)
-      delete vpIntPLSTM[i] ;
-
-  // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
-
-  // rimozione punti in eccesso rispetto alle tolleranze
-   RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const IGeoPoint3d& gpRef, double dPar, Point5ax& Pt5ax)
-{
-  // punto di riferimento
-   Point3d ptMin = gpRef.GetPoint() ;
-  // intersezione della retta di minima distanza con le superfici
-   Vector3d vtLine = ptP - ptMin ;
-   double dLineLen = vtLine.Len() ;
-   if ( dLineLen > EPS_SMALL) {        
-      vtLine /= dLineLen ;
-     // conservo l'intersezione più alta
-      int nInd = -1 ;
-      IntLinStmInfo IntRes ;
-      for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
-         ILSIVECTOR vIntRes ;
-         if ( IntersLineSurfTm( ptP, vtLine, dLineLen, *vpStm[i], vIntRes, false)) {
-           // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
-            int nI = ssize( vIntRes) - 1 ;
-            while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
-               --nI ;
-           // se trovata
-            if ( nI >= 0) {
-               if ( nInd < 0) {
-                  IntRes = vIntRes[nI] ;
-                  nInd = i ;
-               }
-               else {
-                  double dUref = (( IntRes.nILTT == ILTT_SEGM || IntRes.nILTT == ILTT_SEGM_ON_EDGE) ? IntRes.dU2 : IntRes.dU) ;
-                  double dU = (( vIntRes[nI].nILTT == ILTT_SEGM || vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE) ? vIntRes[nI].dU2 : vIntRes[nI].dU) ;
-                  if ( dU > dUref) {
-                     IntRes = vIntRes[nI] ;
-                     nInd = i ;
-                  }
-               }
-            }
-         }
-      }
-     // se trovata
-      if ( nInd >= 0) {
-        // calcolo il punto
-         Point3d ptInt ;
-         if ( IntRes.nILTT == ILTT_SEGM  ||  IntRes.nILTT == ILTT_SEGM_ON_EDGE)
-            ptInt = IntRes.ptI2 ;
-         else
-            ptInt = IntRes.ptI ;
-        // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
-         Triangle3dEx trTria ;
-         if ( ! vpStm[nInd]->GetTriangle( IntRes.nT, trTria))
-            return false ;
-         Vector3d vtN ;
-         if ( ! CalcNormal( ptInt, trTria, vtN))
-            vtN = trTria.GetN() ;
-        // assegno valori al punto 5assi
-         Pt5ax.ptP = ptInt ;
-         Pt5ax.vtDir1 = vtN ;
-         Pt5ax.vtDir2 = vtLine ;
-         Pt5ax.dPar = dPar ;
-         Pt5ax.nFlag = P5AX_STD ;
-        // ritorno con successo
-         return true ;
-      }
-   }
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeoPoint3d& gpRef,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
-{
-  // sistemazioni per tipo di superficie
-   CISRFTMPVECTOR vpSurfTm ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
-      const SurfTriMesh* pSurfTm = nullptr ;
-      switch ( vpSurf[i]->GetType()) {
-      case SRF_TRIMESH :
-         pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
-         break ;
-      case SRF_BEZIER :
-       { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-         SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
-         SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-       } break ;
-      case SRF_FLATRGN :
-         pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
-         break ;
-      default :
-         break ;
-      }
-      if ( pSurfTm == nullptr)
-         return false ;
-      vpSurfTm.emplace_back( pSurfTm) ;
-   }
-
-  // controllo le tolleranze
-   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
-   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
-
-  // approssimo la curva con una polilinea entro la tolleranza
-   PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
-      return false ;
-   const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
-   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
-      return false ;
-
-  // Pulisco e riservo spazio nel vettore dei punti risultanti
-   vPt5ax.clear() ;
-   vPt5ax.reserve( PL.GetPointNbr()) ;
-
-  // proietto i punti della polilinea sulla superficie con direzione data dal punto di riferimento
-   double dPar ;
-   Point3d ptP ;
-   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
-   while ( bFound) {
-     // se trovo proiezione, la salvo
-      Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, gpRef, dPar, Pt5ax))
-         vPt5ax.emplace_back( Pt5ax) ;
-     // passo al successivo
-      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
-   }
-
-  // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
-
-  // rimozione punti in eccesso rispetto alle tolleranze
-   RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const ICurve& crRef, double dPar, Point5ax& Pt5ax)
-{
-  // punto a minima distanza
-   DistPointCurve dPC( ptP, crRef) ;
-   Point3d ptMin ;
-   int nFlag ;
-   if ( dPC.GetMinDistPoint( 0, ptMin, nFlag)) {
-     // intersezione della retta di minima distanza con le superfici
-      Vector3d vtLine = ptP - ptMin ;
-      double dLineLen = vtLine.Len() ;
-      if ( dLineLen > EPS_SMALL) {        
-         vtLine /= dLineLen ;
-        // conservo l'intersezione più alta
-         int nInd = -1 ;
-         IntLinStmInfo IntRes ;
-         for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
-            ILSIVECTOR vIntRes ;
-            if ( IntersLineSurfTm( ptP, vtLine, dLineLen, *vpStm[i], vIntRes, false)) {
-              // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
-               int nI = ssize( vIntRes) - 1 ;
-               while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
-                  --nI ;
-              // se trovata
-               if ( nI >= 0) {
-                  if ( nInd < 0) {
-                     IntRes = vIntRes[nI] ;
-                     nInd = i ;
-                  }
-                  else {
-                     double dUref = (( IntRes.nILTT == ILTT_SEGM || IntRes.nILTT == ILTT_SEGM_ON_EDGE) ? IntRes.dU2 : IntRes.dU) ;
-                     double dU = (( vIntRes[nI].nILTT == ILTT_SEGM || vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE) ? vIntRes[nI].dU2 : vIntRes[nI].dU) ;
-                     if ( dU > dUref) {
-                        IntRes = vIntRes[nI] ;
-                        nInd = i ;
-                     }
-                  }
-               }
-            }
-         }
-        // se trovata
-         if ( nInd >= 0) {
-           // assegno il punto
-            Point3d ptInt ;
-            if ( IntRes.nILTT == ILTT_SEGM  ||  IntRes.nILTT == ILTT_SEGM_ON_EDGE)
-               ptInt = IntRes.ptI2 ;
-            else
-               ptInt = IntRes.ptI ;
-           // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
-            Triangle3dEx trTria ;
-            if ( ! vpStm[nInd]->GetTriangle( IntRes.nT, trTria))
-               return false ;
-            Vector3d vtN ;
-            if ( ! CalcNormal( ptInt, trTria, vtN))
-               vtN = trTria.GetN() ;
-           // assegno valori al punto 5assi
-            Pt5ax.ptP = ptInt ;
-            Pt5ax.vtDir1 = vtN ;
-            Pt5ax.vtDir2 = vtLine ;
-            Pt5ax.dPar = dPar ;
-            Pt5ax.nFlag = P5AX_STD ;
-           // ritorno con successo
-            return true ;
-         }
-      }
-   }
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICurve& crRef,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
-{
-  // Sistemazioni per tipo di superficie
-   CISRFTMPVECTOR vpSurfTm ;
-   for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
-      const SurfTriMesh* pSurfTm = nullptr ;
-      switch ( vpSurf[i]->GetType()) {
-      case SRF_TRIMESH :
-         pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
-         break ;
-      case SRF_BEZIER :
-       { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-         SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-         pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
-         SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-       } break ;
-      case SRF_FLATRGN :
-         pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
-         break ;
-      default :
-         break ;
-      }
-      if ( pSurfTm == nullptr)
-         return false ;
-      vpSurfTm.emplace_back( pSurfTm) ;
-   }
-
-  // Controllo le tolleranze
-   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
-   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
-
-  // Approssimo la curva con una polilinea entro la tolleranza
-   PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
-      return false ;
-   const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
-   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
-      return false ;
-
-  // Pulisco e riservo spazio nel vettore dei punti risultanti
-   vPt5ax.clear() ;
-   vPt5ax.reserve( PL.GetPointNbr()) ;
-
-  // proietto i punti della polilinea sulla superficie con direzione normale alla curva di riferimento
-   double dPar ;
-   Point3d ptP ;
-   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
-   while ( bFound) {
-     // se trovo proiezione, la salvo
-      Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, crRef, dPar, Pt5ax))
-         vPt5ax.emplace_back( Pt5ax) ;
-     // passo al successivo
-      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
-   }
-
-  // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
-
-  // rimozione punti in eccesso rispetto alle tolleranze
-   RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const SurfTriMesh& stmRef, double dPar, Point5ax& Pt5ax)
-{
-  // punto sulla superficie guida a minima distanza
-   DistPointSurfTm dPS( ptP, stmRef) ;
-   Point3d ptMin ;
-   int nTriaMin ;
-   if ( dPS.GetMinDistPoint( ptMin)  &&  dPS.GetMinDistTriaIndex ( nTriaMin)) {
-     // recupero direzione della retta di minima distanza, altrimenti normale alla superficie
-      Vector3d vtLine = ptP - ptMin ;
-      double dLineLen = vtLine.Len() ;
-      if ( dLineLen > EPS_SMALL)       
-         vtLine /= dLineLen ;
-      else {
-        // calcolo la normale della superficie guida
-         Triangle3dEx trGuide ;
-         if ( ! stmRef.GetTriangle( nTriaMin, trGuide))
-            return false ;
-         if ( ! CalcNormal( ptMin, trGuide, vtLine))
-            vtLine = trGuide.GetN() ;
-         dLineLen = 100 ;
-      }
-     // intersezione della retta con le superfici (conservo l'intersezione più alta)
-      int nInd = -1 ;
-      IntLinStmInfo IntRes ;
-      for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
-         ILSIVECTOR vIntRes ;
-         if ( IntersLineSurfTm( ptP, vtLine, dLineLen, *vpStm[i], vIntRes, false)) {
-           // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
-            int nI = ssize( vIntRes) - 1 ;
-            while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
-               --nI ;
-           // se trovata
-            if ( nI >= 0) {
-               if ( nInd < 0) {
-                  IntRes = vIntRes[nI] ;
-                  nInd = i ;
-               }
-               else {
-                  double dUref = (( IntRes.nILTT == ILTT_SEGM || IntRes.nILTT == ILTT_SEGM_ON_EDGE) ? IntRes.dU2 : IntRes.dU) ;
-                  double dU = (( vIntRes[nI].nILTT == ILTT_SEGM || vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE) ? vIntRes[nI].dU2 : vIntRes[nI].dU) ;
-                  if ( dU > dUref) {
-                     IntRes = vIntRes[nI] ;
-                     nInd = i ;
-                  }
-               }
-            }
-         }
-      }
-     // se trovata
-      if ( nInd >= 0) {
-        // calcolo il punto
-         Point3d ptInt ;
-         if ( IntRes.nILTT == ILTT_SEGM  ||  IntRes.nILTT == ILTT_SEGM_ON_EDGE)
-            ptInt = IntRes.ptI2 ;
-         else
-            ptInt = IntRes.ptI ;
-        // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
-         Triangle3dEx trTria ;
-         if ( ! vpStm[nInd]->GetTriangle( IntRes.nT, trTria))
-            return false ;
-         Vector3d vtN ;
-         if ( ! CalcNormal( ptMin, trTria, vtN))
-            vtN = trTria.GetN() ;
-        // calcolo la normale della superficie guida
-         Triangle3dEx trGuide ;
-         if ( ! stmRef.GetTriangle( nTriaMin, trGuide))
-            return false ;
-         Vector3d vtN2 ;
-         if ( ! CalcNormal( ptMin, trGuide, vtN2))
-            vtN2 = trGuide.GetN() ;
-        // assegno valori al punto 5assi
-         Pt5ax.ptP = ptInt ;
-         Pt5ax.vtDir1 = vtN ;
-         Pt5ax.vtDir2 = vtN2 ;
-         Pt5ax.dPar = dPar ;
-         Pt5ax.nFlag = P5AX_STD ;
-        // ritorno con successo
-         return true ;
-      }
-   }
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISurf& sfRef,
-                    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) ;
-   }
-
-  // sistemazioni per tipo di superficie di riferimento
-   const SurfTriMesh* pRefTm = nullptr ;
-   switch ( sfRef.GetType()) {
-   case SRF_TRIMESH :
-      pRefTm = GetBasicSurfTriMesh( &sfRef) ;
-      break ;
-   case SRF_BEZIER :
-    { double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
-      SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
-      pRefTm = GetBasicSurfBezier(  &sfRef)->GetAuxSurfRefined() ;
-      SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
-    } break ;
-   case SRF_FLATRGN :
-      pRefTm = GetBasicSurfFlatRegion( &sfRef)->GetAuxSurf() ;
-      break ;
-   default :
-      break ;
-   }
-   if ( pRefTm == nullptr)
-      return false ;
-
-  // controllo le tolleranze
-   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
-   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
-
-  // approssimo la curva con una polilinea entro la tolleranza
-   PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)  ||
-        ! PL.RemoveAlignedPoints( dLinTol, false) )
-      return false ;
-   const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
-   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
-      return false ;
-
-  // Pulisco e riservo spazio nel vettore dei punti risultanti
-   vPt5ax.clear() ;
-   vPt5ax.reserve( PL.GetPointNbr()) ;
-
-  // proietto i punti della polilinea sulla superficie con direzione normale alla curva di riferimento
-   double dPar ;
-   Point3d ptP ;
-   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
-   while ( bFound) {
-     // se trovo proiezione, la salvo
-      Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, *pRefTm, dPar, Pt5ax))
-         vPt5ax.emplace_back( Pt5ax) ;
-     // passo al successivo
-      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
-   }
-
-  // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
-
-  // rimozione punti in eccesso rispetto alle tolleranze
-   RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
-
-   return true ;
-}
@@ -0,0 +1,393 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : ProjectCurveSurfTm.cpp    Data : 16.11.23        Versione : 2.5kh3
+// Contenuto : Implementazione funzioni proiezione curve su superficie Trimesh.
+//
+//
+//
+// Modifiche : 31.08.23 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "DistPointLine.h"
+#include "GeoConst.h"
+#include "/EgtDev/Include/EGkDistPointCurve.h"
+#include "/EgtDev/Include/EGkDistPointSurfTm.h"
+#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
+#include "/EgtDev/Include/EGkProjectCurveSurfTm.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+static bool
+PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext, double dSqTol)
+{
+   for ( int i = nPrec + 1 ; i < nCurr ; ++ i) {
+      double dSqDist ;
+      if ( ! DistPointLine( vPt5ax[i].ptP, vPt5ax[nPrec].ptP, vPt5ax[nNext].ptP).GetSqDist( dSqDist)  ||  dSqDist > dSqTol)
+         return false ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+static bool
+RemovePointsInExcess( PNT5AXVECTOR& vMyPt5ax, double dLinTol, double dMaxSegmLen)
+{
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   double dSqMaxLen = dMaxSegmLen * dMaxSegmLen ;
+   double dSqTol = dLinTol * dLinTol ;
+   int nPrec = 0 ;
+   int nCurr = 1 ;
+   int nNext = 2 ;
+   while ( nNext < int( vMyPt5ax.size())) {
+      bool bRemove = false ;
+     // lunghezza del segmento che unisce gli adiacenti
+      double dSqLen = SqDist( vMyPt5ax[nPrec].ptP, vMyPt5ax[nNext].ptP) ;
+     // se lunghezza inferiore al massimo, passo agli altri controlli
+      if ( dSqLen <= dSqMaxLen) {
+        // distanza del punto corrente dal segmento che unisce gli adiacenti
+         DistPointLine dPL( vMyPt5ax[nCurr].ptP, vMyPt5ax[nPrec].ptP, vMyPt5ax[nNext].ptP) ;
+         double dSqDist ;
+        // se distanza inferiore a tolleranza lineare
+         if ( dPL.GetSqDist( dSqDist)  &&  dSqDist < dSqTol  &&  PointsInTolerance( vMyPt5ax, nPrec, nCurr, nNext, dSqTol)) {
+           // verifico se errore angolare inferiore a limite
+            double dPar ; dPL.GetParamAtMinDistPoint( dPar) ;
+            Vector3d vtNew = Media( vMyPt5ax[nPrec].vtDir, vMyPt5ax[nNext].vtDir, dPar) ;
+            if ( vtNew.Normalize()  &&  vtNew * vMyPt5ax[nCurr].vtDir > cos( 2 * DEGTORAD))
+               bRemove = true ;
+         }
+      }
+     // se da eliminare
+      if ( bRemove) {   
+         // dichiaro da eliminare il punto
+         vMyPt5ax[nCurr].nFlag = -1 ;
+        // avanzo con corrente e successivo
+         nCurr = nNext ;
+         ++ nNext ;
+      }
+     // altrimenti da tenere
+      else {
+        // avanzo il terzetto di uno step
+         nPrec = nCurr ;
+         nCurr = nNext ;
+         ++ nNext ;
+      }
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir, double dLinTol, double dMaxSegmLen,
+                      PNT5AXVECTOR& vPt5ax)
+{
+  // controllo le tolleranze
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
+  // approssimo la curva con una polilinea entro la metà della tolleranza
+   PolyLine PL ;
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+      return false ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
+   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
+      return false ;
+
+  // Oggetto per calcolo massivo intersezioni tra linee di proiezione e superficie
+   Frame3d frRefLine ;
+   if ( ! frRefLine.Set( ORIG, vtDir))
+      return false ;
+   IntersParLinesSurfTm intPLSTM( frRefLine, tmSurf) ;
+
+  // Vettore locale dei punti risultanti
+   PNT5AXVECTOR vMyPt5ax ;
+   vMyPt5ax.reserve( PL.GetPointNbr()) ;
+
+  // proietto i punti della polilinea sulla superficie
+   double dPar ;
+   Point3d ptP ;
+   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
+   while ( bFound) {
+      Point3d ptL = GetToLoc( ptP, frRefLine) ;
+      ILSIVECTOR vIntRes ;
+      intPLSTM.GetInters( ptL, 1, vIntRes, false) ;
+      if ( ! vIntRes.empty()) {
+        // calcolo il punto
+         int nI = int( vIntRes.size()) - 1 ;
+         Point3d ptInt ;
+         if ( vIntRes[nI].nILTT == ILTT_SEGM  ||  vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE)
+            ptInt = vIntRes[nI].ptI2 ;
+         else
+            ptInt = vIntRes[nI].ptI ;
+        // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
+         Triangle3dEx trTria ;
+         if ( ! tmSurf.GetTriangle( vIntRes[nI].nT, trTria))
+            return false ;
+         Vector3d vtN ;
+         double dU, dV, dW ;
+         if ( BarycentricCoord( ptInt, trTria, dU, dV, dW)) 
+            vtN = dU * trTria.GetVertexNorm( 0) + dV * trTria.GetVertexNorm( 1) + dW * trTria.GetVertexNorm( 2) ;
+         if ( ! vtN.Normalize())
+            vtN = trTria.GetN() ;
+        // aggiungo al vettore dei proiettati
+         vMyPt5ax.emplace_back( ptInt, vtN, dPar, 1) ;
+      }
+      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
+   }
+
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   RemovePointsInExcess( vMyPt5ax, dLinTol, dMaxSegmLen) ;
+
+  // copio i punti rimasti nel vettore di ritorno
+   vPt5ax.clear() ;
+   for ( const auto& Pt5ax : vMyPt5ax) {
+      if ( Pt5ax.nFlag != -1)
+         vPt5ax.emplace_back( Pt5ax) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const IGeoPoint3d& gpRef,
+                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax)
+{
+  // controllo le tolleranze
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
+
+  // approssimo la curva con una polilinea entro la metà della tolleranza
+   PolyLine PL ;
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+      return false ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
+   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
+      return false ;
+
+  // Vettore locale dei punti risultanti
+   PNT5AXVECTOR vMyPt5ax ;
+   vMyPt5ax.reserve( PL.GetPointNbr()) ;
+
+  // proietto i punti della polilinea sulla superficie con direzione data dal punto di riferimento
+   double dPar ;
+   Point3d ptP ;
+   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
+   while ( bFound) {
+     // punto di riferimento
+      Point3d ptMin = gpRef.GetPoint() ;
+     // intersezione della retta di minima distanza con la superficie
+      Vector3d vtLine = ptP - ptMin ;
+      double dLineLen = vtLine.Len() ;
+      if ( dLineLen > EPS_SMALL) {        
+         vtLine /= dLineLen ;
+         ILSIVECTOR vIntRes ;
+         if ( IntersLineSurfTm( ptP, vtLine, dLineLen, tmSurf, vIntRes, false)) {
+            if ( vIntRes.size() > 0) {
+              // calcolo il punto
+               int nI = int( vIntRes.size()) - 1 ;
+               Point3d ptInt ;
+               if ( vIntRes[nI].nILTT == ILTT_SEGM  ||  vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE)
+                  ptInt = vIntRes[nI].ptI2 ;
+               else
+                  ptInt = vIntRes[nI].ptI ;
+              // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
+               Triangle3dEx trTria ;
+               if ( ! tmSurf.GetTriangle( vIntRes[nI].nT, trTria))
+                  return false ;
+               Vector3d vtN ;
+               double dU, dV, dW ;
+               if ( BarycentricCoord( ptInt, trTria, dU, dV, dW)) 
+                  vtN = dU * trTria.GetVertexNorm( 0) + dV * trTria.GetVertexNorm( 1) + dW * trTria.GetVertexNorm( 2) ;
+               if ( ! vtN.Normalize())
+                  vtN = trTria.GetN() ;
+              // aggiungo al vettore dei proiettati
+               vMyPt5ax.emplace_back( ptInt, vtN, vtLine, dPar, 1) ;
+            }
+         }
+      }
+      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
+   }
+
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   RemovePointsInExcess( vMyPt5ax, dLinTol, dMaxSegmLen) ;
+
+  // copio i punti rimasti nel vettore di ritorno
+   vPt5ax.clear() ;
+   for ( const auto& Pt5ax : vMyPt5ax) {
+      if ( Pt5ax.nFlag != -1)
+         vPt5ax.emplace_back( Pt5ax) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ICurve& crRef,
+                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax)
+{
+  // controllo le tolleranze
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
+
+  // approssimo la curva con una polilinea entro la metà della tolleranza
+   PolyLine PL ;
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+      return false ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
+   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
+      return false ;
+
+  // Vettore locale dei punti risultanti
+   PNT5AXVECTOR vMyPt5ax ;
+   vMyPt5ax.reserve( PL.GetPointNbr()) ;
+
+  // proietto i punti della polilinea sulla superficie con direzione normale alla curva di riferimento
+   double dPar ;
+   Point3d ptP ;
+   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
+   while ( bFound) {
+     // punto sulla curva a minima distanza
+      DistPointCurve dPC( ptP, crRef) ;
+      Point3d ptMin ;
+      int nFlag ;
+      if ( dPC.GetMinDistPoint( 0, ptMin, nFlag)) {
+        // intersezione della retta di minima distanza con la superficie
+         Vector3d vtLine = ptP - ptMin ;
+         double dLineLen = vtLine.Len() ;
+         if ( dLineLen > EPS_SMALL) {        
+            vtLine /= dLineLen ;
+            ILSIVECTOR vIntRes ;
+            if ( IntersLineSurfTm( ptP, vtLine, dLineLen, tmSurf, vIntRes, false)) {
+               if ( vIntRes.size() > 0) {
+                 // calcolo il punto
+                  int nI = int( vIntRes.size()) - 1 ;
+                  Point3d ptInt ;
+                  if ( vIntRes[nI].nILTT == ILTT_SEGM  ||  vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE)
+                     ptInt = vIntRes[nI].ptI2 ;
+                  else
+                     ptInt = vIntRes[nI].ptI ;
+                 // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
+                  Triangle3dEx trTria ;
+                  if ( ! tmSurf.GetTriangle( vIntRes[nI].nT, trTria))
+                     return false ;
+                  Vector3d vtN ;
+                  double dU, dV, dW ;
+                  if ( BarycentricCoord( ptInt, trTria, dU, dV, dW)) 
+                     vtN = dU * trTria.GetVertexNorm( 0) + dV * trTria.GetVertexNorm( 1) + dW * trTria.GetVertexNorm( 2) ;
+                  if ( ! vtN.Normalize())
+                     vtN = trTria.GetN() ;
+                 // aggiungo al vettore dei proiettati
+                  vMyPt5ax.emplace_back( ptInt, vtN, vtLine, dPar, 1) ;
+               }
+            }
+         }
+      }
+      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
+   }
+
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   RemovePointsInExcess( vMyPt5ax, dLinTol, dMaxSegmLen) ;
+
+  // copio i punti rimasti nel vettore di ritorno
+   vPt5ax.clear() ;
+   for ( const auto& Pt5ax : vMyPt5ax) {
+      if ( Pt5ax.nFlag != -1)
+         vPt5ax.emplace_back( Pt5ax) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ISurfTriMesh& tmRef,
+                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax)
+{
+  // controllo le tolleranze
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
+
+  // approssimo la curva con una polilinea entro la metà della tolleranza
+   PolyLine PL ;
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+      return false ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
+   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
+      return false ;
+
+  // Vettore locale dei punti risultanti
+   PNT5AXVECTOR vMyPt5ax ;
+   vMyPt5ax.reserve( PL.GetPointNbr()) ;
+
+  // proietto i punti della polilinea sulla superficie con direzione normale alla curva di riferimento
+   double dPar ;
+   Point3d ptP ;
+   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
+   while ( bFound) {
+     // punto sulla superficie guida a minima distanza
+      DistPointSurfTm dPS( ptP, tmRef) ;
+      Point3d ptMin ;
+      int nTriaMin ;
+      if ( dPS.GetMinDistPoint( ptMin)  &&  dPS.GetMinDistTriaIndex ( nTriaMin)) {
+        // intersezione della retta di minima distanza con la superficie
+         Vector3d vtLine = ptP - ptMin ;
+         double dLineLen = vtLine.Len() ;
+         if ( dLineLen > EPS_SMALL) {        
+            vtLine /= dLineLen ;
+            ILSIVECTOR vIntRes ;
+            if ( IntersLineSurfTm( ptP, vtLine, dLineLen, tmSurf, vIntRes, false)) {
+               if ( vIntRes.size() > 0) {
+                 // calcolo il punto
+                  int nI = int( vIntRes.size()) - 1 ;
+                  Point3d ptInt ;
+                  if ( vIntRes[nI].nILTT == ILTT_SEGM  ||  vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE)
+                     ptInt = vIntRes[nI].ptI2 ;
+                  else
+                     ptInt = vIntRes[nI].ptI ;
+                 // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
+                  Triangle3dEx trTria ;
+                  if ( ! tmSurf.GetTriangle( vIntRes[nI].nT, trTria))
+                     return false ;
+                  Vector3d vtN ;
+                  double dU, dV, dW ;
+                  if ( BarycentricCoord( ptInt, trTria, dU, dV, dW)) 
+                     vtN = dU * trTria.GetVertexNorm( 0) + dV * trTria.GetVertexNorm( 1) + dW * trTria.GetVertexNorm( 2) ;
+                  if ( ! vtN.Normalize())
+                     vtN = trTria.GetN() ;
+                 // calcolo la normale della superficie guida
+                  Triangle3dEx trGuide ;
+                  if ( ! tmRef.GetTriangle( nTriaMin, trGuide))
+                     return false ;
+                  Vector3d vtN2 ;
+                  double dU2, dV2, dW2 ;
+                  if ( BarycentricCoord( ptMin, trGuide, dU2, dV2, dW2)) 
+                     vtN2 = dU2 * trGuide.GetVertexNorm( 0) + dV2 * trGuide.GetVertexNorm( 1) + dW2 * trGuide.GetVertexNorm( 2) ;
+                  if ( ! vtN2.Normalize())
+                     vtN2 = trGuide.GetN() ;
+                 // aggiungo al vettore dei proiettati
+                  vMyPt5ax.emplace_back( ptInt, vtN, vtN2, dPar, 1) ;
+               }
+            }
+         }
+      }
+      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
+   }
+
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   RemovePointsInExcess( vMyPt5ax, dLinTol, dMaxSegmLen) ;
+
+  // copio i punti rimasti nel vettore di ritorno
+   vPt5ax.clear() ;
+   for ( const auto& Pt5ax : vMyPt5ax) {
+      if ( Pt5ax.nFlag != -1)
+         vPt5ax.emplace_back( Pt5ax) ;
+   }
+
+   return true ;
+}
@@ -15,8 +15,8 @@
 #include "stdafx.h"
 #include "GeoConst.h"
 #include "CurveComposite.h"
+#include "DistPointLine.h"
 #include "RemoveCurveDefects.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include <algorithm>

--- a/Show More
+++ b/Show More