Merge branch 'ZMap_CrackedSurfTM'

- milgiorie e correzioni alla funzione per ottenere lo ZMap da una trimesh con crack.

AdjustLoops.cpp

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

CAvSimpleSurfFrMove.cpp

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

CAvSimpleSurfFrMove.h

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

CAvSurfFrMove.cpp

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

CAvSurfFrMove.h

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

CAvToolTriangle.cpp

@@ -2440,12 +2440,10 @@ CAvDiskTriangle( const Point3d& ptDiskCen, const Vector3d& vtDiskAx, double dDis
      // Allontanamento dall'interno
       double dEscapeDist = max( DiskTriaInteriorEscapeDistGenMot( ptDiskCen, vtDiskAx, dDiskRad, trTria, vtMove), 0.) ;
      // Allontanamento dalla frontiera
-      Vector3d vtMoveOrt = vtMove - vtMove * vtDiskAx * vtDiskAx ;   
+      Vector3d vtMoveOrt = OrthoCompo( vtMove, vtDiskAx) ;
       vtMoveOrt.Normalize() ;
       Frame3d DiskFrame ;
-      Vector3d vtJ = vtDiskAx ^ vtMoveOrt ;
-      vtJ.Normalize() ;
-      DiskFrame.Set( ptDiskCen, vtMoveOrt, vtJ, vtDiskAx) ;
+      DiskFrame.Set( ptDiskCen, vtDiskAx, vtMoveOrt) ;
       Triangle3d trTriaLoc = trTria ;
       Vector3d vtMoveLoc = vtMove ;
       trTriaLoc.ToLoc( DiskFrame) ;

ChainCurves.cpp

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

Color.cpp

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

CurveArc.cpp

@@ -41,7 +41,7 @@ GEOOBJ_REGISTER( CRV_ARC, NGE_C_ARC, CurveArc) ;
 class ArcApproxer
 {
    public :
-      ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const CurveArc& arArc) ;
+      ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const CurveArc& arArc, double dMaxLen = INFINITO) ;
       bool GetPoint( double& dU, Point3d& ptP) ;
 
    private :
@@ -1177,6 +1177,30 @@ CurveArc::ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, PolyLin
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+CurveArc::ApproxWithLimitedLines( double dLinTol, double dAngTolDeg, int nType, double dMaxLen, PolyLine& PL) const
+{
+   // pulisco la polilinea
+   PL.Clear() ;
+
+   // la curva deve essere validata
+   if ( m_nStatus != OK)
+      return false ;
+
+   // eseguo approssimazione
+   bool bInside = true ;
+   ArcApproxer aAppr( dLinTol, dAngTolDeg, bInside, *this, dMaxLen) ;
+   double  dU ;
+   Point3d ptPos ;
+   while ( aAppr.GetPoint( dU, ptPos)) {
+      if ( ! PL.AddUPoint( dU, ptPos))
+         return false ;
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 CurveArc::ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) const
@@ -2170,7 +2194,7 @@ CurveArc::Flip( void)
 // usando il versore medio dal centro e moltiplicandolo per il coefficiente ( 2 / ( 1 + cosA)).
 // Il versore dell'ultimo punto è già stato calcolato per il penultimo.
 //----------------------------------------------------------------------------
-ArcApproxer::ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const CurveArc& arArc)
+ArcApproxer::ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const CurveArc& arArc, double dMaxLen)
 {
   // inizializzazioni
    m_nTotPnt = 0 ;
@@ -2195,6 +2219,11 @@ ArcApproxer::ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const
       dAngStepDeg = sqrt( 8 * dLinTolRel) * RADTODEG ;
    else
       dAngStepDeg = sqrt( 8 * dLinTolRel / ( 1 + dLinTolRel)) * RADTODEG ;
+
+   if ( dMaxLen < INFINITO) {
+      double dAngStepMaxLen = 2 * asin( dMaxLen / ( 2 * arArc.GetRadius()))  * RADTODEG ;
+      dAngStepDeg = min( dAngStepDeg, dAngStepMaxLen) ;
+   }
    dAngStepDeg = min( dAngStepDeg, dAngTolDeg) ;
 
   // dall'angolo al centro ricavo il numero di passi

CurveArc.h

@@ -111,6 +111,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
       bool GetArea( Plane3d& plPlane, double& dArea) const override 
               { return CurveGetArea( *this, plPlane, dArea) ; }
       bool ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, PolyLine& PL) const override ;
+      bool ApproxWithLimitedLines( double dLinTol, double dAngTolDeg, int nType, double dMaxLen, PolyLine& PL) const override ;
       bool ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) const override ;
       bool ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) const override
               { return ApproxWithArcs( dLinTol, dAngTolDeg, PA) ; }

CurveAux.cpp

@@ -25,18 +25,24 @@
 #include "IntersLineLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
+#include "/EgtDev/Include/EGkIntersCurvePlane.h"
 #include "/EgtDev/Include/EGkCurveByInterp.h"
 #include "/EgtDev/Include/EGkChainCurves.h"
+#include "/EgtDev/Include/EgtNumUtils.h"
+#include "/EgtDev/Include/EgtPointerOwner.h"
 #define EIGEN_NO_IO
 #include "/EgtDev/Extern/Eigen/Dense"
 
 #define SAVEAPPROX 0
 #define SAVECURVEPASSED 0
 #define SAVELINEARAPPROX 0
-#if SAVEAPPROX  || SAVECURVEPASSED  ||  SAVELINEARAPPROX
+#define SAVESYNCLINES 0
+#if SAVEAPPROX  || SAVECURVEPASSED  ||  SAVELINEARAPPROX  || SAVESYNCLINES
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
+   static int nCrvPassed = 0 ;
+   std::vector<IGeoObj*> VT ;
+   std::vector<Color> VC ;
    #include "/EgtDev/Include/EGkGeoObjSave.h"
 #endif
 
@@ -533,9 +539,8 @@ LineToBezierCurve( const ICurveLine* pCrvLine, int nDeg, bool bMakeRatOrNot)
       return nullptr ;
 
    PtrOwner<ICurveBezier> pCrvBezier( CreateCurveBezier()) ;
-   // rendo tutte le curve di grado 2 e razionali così posso convertire anche archi e avere tutte curve dello stesso grado e razionali
-   pCrvBezier->Init( nDeg, true) ;
-   if( ! pCrvBezier->FromLine( *pCrvLine))
+   pCrvBezier->Init( nDeg, false) ;
+   if ( ! pCrvBezier->FromLine( *pCrvLine))
       return nullptr ;
    if ( bMakeRatOrNot)
       pCrvBezier->MakeRational() ;
@@ -589,6 +594,13 @@ ArcToBezierCurve( const ICurveArc* pArc, int nDeg, bool bMakeRatOrNot)
          PtrOwner<ICurveBezier> pCrvBez( CreateBasicCurveBezier()) ;
          if ( IsNull( pCrvBez)  ||  ! pCrvBez->FromArc( cArc))
             return nullptr ;
+         if ( ! bMakeRatOrNot) {
+            Point3d ptCen = pArc->GetCenter() ;
+            Vector3d vtN = pArc->GetNormVersor() ;
+            pCrvBez.Set( ApproxArcCurveBezierWithSingleCubic( pCrvBez, ptCen, vtN)) ;
+         }
+         if ( IsNull( pCrvBez))
+             return nullptr ;
          // aumento il grado della curva come richiesto
          while ( pCrvBez->GetDegree() < nDeg)
             pCrvBez.Set( BezierIncreaseDegree( pCrvBez)) ;
@@ -1147,7 +1159,7 @@ FindSpan( double dU, int nDeg, const DBLVECTOR& vKnots, int& nSpan)
       return true ;
    }
    // trovo a quale span appartiene il parametro dU
-   int nKnots = int( vKnots.size()) ;
+   int nKnots = ssize( vKnots) ;
    if ( abs( dU - vKnots[nKnots-1]) < EPS_SMALL) {
       nSpan = nKnots - 1 - nDeg ;
       return true ;
@@ -1173,7 +1185,7 @@ static bool
 CalcBasisFunc( double dU, int nSpan, int nDeg, const DBLVECTOR& vKnots, DBLVECTOR& vBasis)
 {
    // mi aspetto che il vettore vBasis sia di lunghezza  nDeg + 1
-   if ( vBasis.size() != nDeg + 1)
+   if ( ssize( vBasis) != nDeg + 1)
       return false ;
 
    vBasis[0] = 1 ;
@@ -1312,7 +1324,7 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
    int nItCount = 0 ;
    while ( dErr > dLinTol  &&  nItCount < 10) {
       pCrvInt->Clear() ;
-      int nPoints = int( vPnt.size()) ;
+      int nPoints = ssize( vPnt) ;
       int nDeg = 3 ;
       if ( nPoints < 2)
          return nullptr ;
@@ -1328,7 +1340,7 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
       else if ( nPoints == 3) {
          // se ho solo tre punti uso un altro algoritmo
          CurveByInterp cbi ;
-         for ( int i = 0 ; i < int( vPnt.size()) ; ++i)
+         for ( int i = 0 ; i < ssize( vPnt) ; ++i)
             cbi.AddPoint( vPnt[i]) ;
          pCrvInt->AddCurve( cbi.GetCurve( CurveByInterp::AKIMA_CORNER, CurveByInterp::CUBIC_BEZIERS)) ;
          if ( ! IsNull( pCrvInt)  &&  pCrvInt->IsValid())
@@ -1360,7 +1372,7 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
             }
          }
 
-         if ( vLen.size() != 0) {
+         if ( ! vLen.empty()) {
             if ( nEnd == 0)
                nEnd = nPoints - 1 ;
             Vector3d vtStartDir = V_INVALID ; 
@@ -1402,9 +1414,9 @@ ParamByLen( const PNTVECTOR& vPnt, DBLVECTOR& vParam, int nFirst, int nLast)
    int nPoints = nLast - nFirst + 1 ;
    if ( nPoints < 2)
       return false ;
-   if( ssize(vParam) == 0)
+   if ( vParam.empty())
       vParam.resize( nPoints) ;
-   if( vParam[nFirst] == 0  &&  vParam[nLast] == 1)
+   if ( vParam[nFirst] == 0  &&  vParam[nLast] == 1)
       return true ;
    vParam[nFirst] = 0 ;
    for ( int i = nFirst + 1 ; i <= nLast ; ++i) {
@@ -1420,8 +1432,8 @@ ParamByLen( const PNTVECTOR& vPnt, DBLVECTOR& vParam, int nFirst, int nLast)
 
 //----------------------------------------------------------------------------
 ICurveBezier*
-ApproxPointSetWithSingleBezier( const PNTVECTOR& vPnt, int nFirst, int nLast, const Vector3d& vtStartDir, const Vector3d& vtEndDir,
-                                const DBLVECTOR& vParam)
+ApproxPointSetWithSingleBezier( const PNTVECTOR& vPnt, int nFirst, int nLast,
+                                const Vector3d& vtStartDir, const Vector3d& vtEndDir, const DBLVECTOR& vParam)
 {
    // cerco di approssimare un set di punti con una sola bezier cubica non razionale
    int nPoints = nLast - nFirst + 1 ;
@@ -1435,7 +1447,7 @@ ApproxPointSetWithSingleBezier( const PNTVECTOR& vPnt, int nFirst, int nLast, co
    pCrvBez->SetControlPoint( 0, pt0) ;
    pCrvBez->SetControlPoint( 3, pt3) ;
    Eigen::Vector2d mA ;
-   if( nPoints > 4) {
+   if ( nPoints > 4) {
       // risoluzione sistema
       Eigen::Matrix2d mC ; mC.setZero() ;
       Eigen::Vector2d mX ; mX.setZero() ;
@@ -1461,16 +1473,14 @@ ApproxPointSetWithSingleBezier( const PNTVECTOR& vPnt, int nFirst, int nLast, co
    }
    // l'algoritmo è fatto in modo che alpha1 e alpha2 siano positivi ( se tutto va bene)
    // io invece ho tenuto le tangenti con la direzione originale, quindi il primo dovrebbe essere positivo e il secondo negativo
-   if ( mA(0) < 0 || mA(1) > 0 || nPoints < 4) {
-      if( mA(0) < 0 || mA(1) > 0)
+   if ( mA(0) < 0  ||  mA(1) > 0  ||  nPoints < 4) {
+      if ( mA(0) < 0  ||  mA(1) > 0)
          LOG_DBG_ERR( GetEGkLogger(), "valori di alfa sballati, potrebbe essere la spaziatura dismogenea tra punti")
       double dDistCorr = Dist( pt3, pt0) / 3 ;
       mA(0) = dDistCorr ;
       mA(1) = - dDistCorr ;
    }
 
-   double alpah1 = mA(0) ;
-   double alpha2 = mA(1) ;
    Point3d pt1 = pt0 + vtStartDir * mA(0) ;
    Point3d pt2 = pt3 + vtEndDir * mA(1) ;
    pCrvBez->SetControlPoint( 1, pt1) ;
@@ -1480,14 +1490,15 @@ ApproxPointSetWithSingleBezier( const PNTVECTOR& vPnt, int nFirst, int nLast, co
 
 //----------------------------------------------------------------------------
 bool
-CalcPointSetApproxError( const PNTVECTOR& vPntOrig, const DBLVECTOR& vParam, int nFirst, int nLast, const ICurve* pCrvNew, double& dErr, int& nPointMaxErr)
+CalcPointSetApproxError( const PNTVECTOR& vPntOrig, const DBLVECTOR& vParam,
+                         int nFirst, int nLast, const ICurve* pCrvNew, double& dErr, int& nPointMaxErr)
 {
    dErr = 0 ;
    // calcolo l'errore di approssimazione
    for ( int i = nFirst ; i <= nLast ; ++i) {
       Point3d ptBez ; pCrvNew->GetPointD1D2( vParam[i], ICurve::Side::FROM_MINUS, ptBez) ;
       double dErrTemp = Dist( vPntOrig[i], ptBez) ;
-      if( dErrTemp > dErr) {
+      if ( dErrTemp > dErr) {
          dErr = dErrTemp ;
          nPointMaxErr = i ;
       }
@@ -1498,19 +1509,21 @@ CalcPointSetApproxError( const PNTVECTOR& vPntOrig, const DBLVECTOR& vParam, int
 
 //----------------------------------------------------------------------------
 ICurve*
-FitWithBezier( const ICurve* pCrvOrig, const PNTVECTOR& vPnt, DBLVECTOR& vParam, int nFirst, int nLast, const VCT3DVECTOR& vPrevDer, const VCT3DVECTOR& vNextDer, double dTol)
+FitWithBezier( const ICurve* pCrvOrig, const PNTVECTOR& vPnt, DBLVECTOR& vParam,
+               int nFirst, int nLast, const VCT3DVECTOR& vPrevDer, const VCT3DVECTOR& vNextDer, double dTol, bool bLimitSplit = false)
 {
-   ParamByLen(vPnt, vParam, nFirst, nLast) ;
+   ParamByLen( vPnt, vParam, nFirst, nLast) ;
    PtrOwner<ICurveComposite> pCrvFit( CreateCurveComposite()) ;
    PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
    double dErr = INFINITO ;
+   double dErrPrec = INFINITO ;
    double dErrSplit = dTol * 25 ;
    int nIter = 0 ;
-   while ( dErr > dTol  && nIter < 10) {
-      if( dErr < INFINITO) {
-         // riparametrizzo i punti
+   while ( dErr > dTol  &&  nIter < 10) {
+      if ( dErr < INFINITO) {
+        // riparametrizzo i punti
          for ( int i = nFirst + 1 ; i < nLast ; ++i) {
-            //questo potrebbe diventare un while appena capisco di quanto si aggiusta il parametro ad ogni iterazione
+           // questo potrebbe diventare un while appena capisco di quanto si aggiusta il parametro ad ogni iterazione
             double dCorr = 1 ;
             do {
                Vector3d vtDer1, vtDer2 ;
@@ -1525,32 +1538,50 @@ FitWithBezier( const ICurve* pCrvOrig, const PNTVECTOR& vPnt, DBLVECTOR& vParam,
          }
       }
 
-      // fit della curva
-      pCrvBez.Set( ApproxPointSetWithSingleBezier( vPnt, nFirst, nLast, vNextDer[nFirst], vPrevDer[nLast], vParam)) ;
-      if( IsNull( pCrvBez)  ||  ! pCrvBez->IsValid())
+     // fit della curva
+      Vector3d vtStartDir, vtEndDir ;
+      if ( bLimitSplit) {
+         vtStartDir = vNextDer[nFirst / 3] ;
+         vtEndDir = vPrevDer[nLast / 3] ;
+      }
+      else {
+         vtStartDir = vNextDer[nFirst] ;
+         vtEndDir = vPrevDer[nLast] ;
+      }
+      pCrvBez.Set( ApproxPointSetWithSingleBezier( vPnt, nFirst, nLast, vtStartDir, vtEndDir, vParam)) ;
+      if ( IsNull( pCrvBez)  ||  ! pCrvBez->IsValid())
          return nullptr ;
 #if SAVEAPPROX
-      SaveGeoObj( pCrvBez->Clone(), "D:\\Temp\\bezier\\approxWithBezier\\first_approx.nge") ;
+      SaveGeoObj( pCrvBez->Clone(), "D:\\Temp\\bezier\\approxWithBezier\\"+ToString(nCrvPassed) + "first_approx.nge") ;
 #endif
 
       int nPointMaxErr = 0 ;
       CalcPointSetApproxError( vPnt, vParam, nFirst, nLast, pCrvBez, dErr, nPointMaxErr) ;
-      // se sto unendo due punti consecutivi e l'errore è oltre quello richiesto allora restituisco un segmento che unisce i punti
-      if( nLast - nFirst == 1  &&  dErr > dTol) {
+     // se sto unendo due punti consecutivi e l'errore è oltre quello richiesto allora restituisco un segmento che unisce i punti
+      if ( ((nLast - nFirst == 1)  ||  ( bLimitSplit  &&  nLast - nFirst == 3)) &&  dErr > dTol) {
          CurveLine CL ; CL.Set( vPnt[nFirst], vPnt[nLast]) ;
          pCrvBez.Set( GetCurveBezier( CurveToBezierCurve( &CL))) ;
          dErr = 0 ;
       }
 
+      if ( bLimitSplit  &&  nPointMaxErr % 3 != 0) {
+         nPointMaxErr = 3 * int( round( nPointMaxErr / 3.)) ;
+         if ( nPointMaxErr == nFirst)
+            nPointMaxErr += 3 ;
+         else if( nPointMaxErr == nLast)
+            nPointMaxErr -= 3 ;
+      }
+
       ++nIter ;
       bool bSplit = false ;
-      if( nIter == 10  &&  dErr > dTol)
+      if ( ( nIter == 10  &&  dErr > dTol)  || dErr > dErrPrec  ||  dErrPrec - dErr < dErrPrec / 20)
          bSplit = true ;
-      // se la curva di approssimazione è ancora molto lontana dalla curva originale allora divido il set di punti in due 
-      if ( dErr > dErrSplit  || bSplit) {
-         if ( nLast - nFirst > 1) {
-            if( ! pCrvFit->AddCurve( FitWithBezier( pCrvOrig, vPnt, vParam, nFirst, nPointMaxErr, vPrevDer, vNextDer,dTol)) ||
-                ! pCrvFit->AddCurve( FitWithBezier( pCrvOrig, vPnt, vParam, nPointMaxErr, nLast, vPrevDer, vNextDer, dTol)))
+      dErrPrec = dErr ;
+     // se la curva di approssimazione è ancora molto lontana dalla curva originale allora divido il set di punti in due 
+      if ( dErr > dErrSplit  ||  bSplit) {
+         if ( nLast - nFirst > 1  &&  nPointMaxErr - nFirst > 1  &&  nLast - nPointMaxErr > 1) {
+            if ( ! pCrvFit->AddCurve( FitWithBezier( pCrvOrig, vPnt, vParam, nFirst, nPointMaxErr, vPrevDer, vNextDer,dTol, bLimitSplit)) ||
+                ! pCrvFit->AddCurve( FitWithBezier( pCrvOrig, vPnt, vParam, nPointMaxErr, nLast, vPrevDer, vNextDer, dTol, bLimitSplit)))
                return nullptr ;
             break ;
          }
@@ -1561,18 +1592,18 @@ FitWithBezier( const ICurve* pCrvOrig, const PNTVECTOR& vPnt, DBLVECTOR& vParam,
 
    if ( pCrvFit->GetCurveCount() > 0)
       return Release( pCrvFit) ;
-   else if ( dErr < dTol && ! IsNull( pCrvBez)  &&  pCrvBez->IsValid())
+   else if ( dErr < dTol  &&  ! IsNull( pCrvBez)  &&  pCrvBez->IsValid())
       return Release( pCrvBez) ;
    else
       return nullptr ;
 }
 
-static int nCrvPassed = 0 ;
-
 //----------------------------------------------------------------------------
 ICurve*
-ApproxCurveWithBezier( const ICurve* pCrv , double dTol, int nType)
+ApproxCurveWithBezier( const ICurve* pCrv , double dTol, const Vector3d& vtStart, const Vector3d& vtEnd)
 {
+   if ( pCrv == nullptr  ||  ! pCrv->IsValid())
+      return nullptr ;
 
 #if SAVECURVEPASSED
    SaveGeoObj( pCrv->Clone(), "D:\\Temp\\bezier\\approxWithBezier\\CurveDaApprossimare\\"+ToString(nCrvPassed) + ".nge") ;
@@ -1591,47 +1622,48 @@ ApproxCurveWithBezier( const ICurve* pCrv , double dTol, int nType)
    SaveGeoObj( CC.Clone(), "D:\\Temp\\bezier\\approxWithBezier\\approssimazione_lineare.nge") ;
 #endif
 
-   CurveByInterp cbi ;
    PNTVECTOR vPnt ;
+   PNTVECTOR vPntOverSampling ;
    Point3d pt ; plApprox.GetFirstPoint( pt) ;
    do {
-      if ( ssize(vPnt) != 0) {
-         vPnt.push_back( Media(vPnt.back(), pt,1./3.)) ;
-         vPnt.push_back( Media(vPnt.back(), pt,2./3.)) ;
+      if ( ! vPntOverSampling.empty()) {
+         vPntOverSampling.push_back( Media( vPnt.back(), pt,1./3.)) ;
+         vPntOverSampling.push_back( Media( vPnt.back(), pt,2./3.)) ;
       }
+      vPntOverSampling.push_back( pt) ;
       vPnt.push_back( pt) ;
-      cbi.AddPoint( pt) ;
    } while ( plApprox.GetNextPoint( pt)) ;
 
    // calcolo la curvatura nei vari punti per identificare zone a curvatura costante
-   DBLVECTOR vCrvVal( ssize(vPnt)) ;
    DBLVECTOR vRad ( ssize( vPnt)) ;
-   for( int i = 1 ; i < ssize( vPnt) - 1 ; ++i) {
+   for ( int i = 1 ; i < ssize( vPnt) - 1 ; ++i) {
       Vector3d vtA = vPnt[i] - vPnt[i-1] ;
       Vector3d vtB = vPnt[i+1] - vPnt[i-1] ;
-      double dR = ( vtA.Len() * vtB.Len() * ( vtA - vtB).Len()) / ( 2 * (vtA ^ vtB).Len()) ;
-      double dCurvature = dR > 0 ? 1. / dR : 0 ;
+      double dR = ( vtA.Len() * vtB.Len() * ( vtA - vtB).Len()) / ( 2 * ( vtA ^ vtB).Len()) ;
       vRad[i] = dR ;
-      vCrvVal[i] = dCurvature ;
    }
-   vCrvVal[0] = vCrvVal[1] ;
-   vCrvVal.back() = vCrvVal.end()[-2] ;
+   vRad[0] = vRad[1] ;
+   vRad.back() = vRad.end()[-2] ;
    // identifico le zone a curvatura costante // primo e ultimo punto degli intervalli non devono avere curvatura uguale agli altri perché sono di frontiera
    INTINTVECTOR vConstCurv ;
-   double dCurvaturePrec = vCrvVal[0] ;
+   double dRadPrec = vRad[0] ;
    int nStart = 0 ;
    int nEnd = 1 ;
+   double dRatio = 1.5 ;
    while ( nStart < ssize( vPnt) - 1) {
-      dCurvaturePrec = vCrvVal[nEnd] ;
-      while ( nEnd < ssize( vPnt) - 1  &&  abs( vCrvVal[nEnd] - dCurvaturePrec) < 0.1) {
-         dCurvaturePrec = vCrvVal[nEnd] ;
+      double dRadTol = max( max( vRad[nEnd], dRadPrec) / 10 , 1.) ;
+      if ( dRadPrec > dRatio * vRad[nEnd]  ||  dRatio * dRadPrec < vRad[nEnd])
+         dRadTol = 0 ;
+      while ( nEnd < ssize( vPnt) - 1  &&  abs( vRad[nEnd] - dRadPrec) < dRadTol) {
+         dRadPrec = vRad[nEnd] ;
          ++nEnd ;
       }
-      vConstCurv.emplace_back( nStart, nEnd) ;
+      vConstCurv.emplace_back( nStart * 3, nEnd * 3) ;
       nStart = nEnd ;
+      dRadPrec = vRad[nEnd] ;
       ++nEnd ;
    }
-   if( ssize(vConstCurv) == 0)
+   if ( vConstCurv.empty())
       vConstCurv.emplace_back( 0, ssize( vPnt) - 1) ;
 
    int nPoints = ssize( vPnt) ;
@@ -1643,22 +1675,44 @@ ApproxCurveWithBezier( const ICurve* pCrv , double dTol, int nType)
    VCT3DVECTOR vPrevDer ;
    VCT3DVECTOR vNextDer ;
    ComputeAkimaTangents( false, vParam, vPnt, vPrevDer, vNextDer) ;
+   if ( ! AreSameVectorExact(vtStart, V_NULL)) {
+      vNextDer[0] = vtStart ;
+      vPrevDer.back() = vtEnd ;
+   }
+
+   int nOverSampling = ssize( vPntOverSampling) ;
+   vParam.resize( nOverSampling) ;
+   nFirst = 0 ;
+   nLast = nOverSampling - 1 ;
+   ParamByLen( vPntOverSampling, vParam, nFirst, nLast) ;
+
    //normalizzo tutte le derivate
-   for( int i = 0 ; i < ssize( vPrevDer) ; ++i) {
+   for ( int i = 0 ; i < ssize( vPrevDer) ; ++i) {
       vPrevDer[i].Normalize() ;
       vNextDer[i].Normalize() ;
    }
 
+   // potrei verificare prima se un tratto è retto e aggiustare le tangenti del tratto precedente e successivo prima di approssimare
    PtrOwner<ICurveComposite> pCCApproxTot( CreateCurveComposite()) ;
-   for( INTINT iiSE : vConstCurv) {
+   for ( INTINT iiSE : vConstCurv) {
       nFirst = iiSE.first ;
       nLast = iiSE.second ;
-      //definisco la bezier che vado a raffinare iterativamente
-      PtrOwner<ICurve> pCApprox( FitWithBezier( pCrv, vPnt, vParam, nFirst, nLast, vPrevDer, vNextDer, dTol)) ;
-      if( IsNull( pCApprox)  ||  ! pCApprox->IsValid())
-         return nullptr ;
-      if( ! pCCApproxTot->AddCurve( Release( pCApprox)))
-         return nullptr ;
+      // riconosco se ho un tratto retto
+      int nPnt = nFirst / 3 ;
+      if ( nLast - nFirst == 3  &&  ( nPnt > 0 &&  vRad[nPnt] > dRatio * vRad[nPnt - 1])  &&  ( nPnt < ssize( vRad)  &&  vRad[nPnt]> dRatio * vRad[nPnt + 1])) {
+         CurveLine CL ; CL.Set( vPntOverSampling[nFirst], vPntOverSampling[nLast]) ;
+         PtrOwner<ICurveBezier> pCApprox( LineToBezierCurve( &CL, 3, false)) ;
+         if ( ! pCCApproxTot->AddCurve( Release( pCApprox)))
+            return nullptr ;
+      }
+      else {
+         //definisco la bezier che vado a raffinare iterativamente
+         PtrOwner<ICurve> pCApprox( FitWithBezier( pCrv, vPntOverSampling, vParam, nFirst, nLast, vPrevDer, vNextDer, dTol, true)) ;
+         if ( IsNull( pCApprox)  ||  ! pCApprox->IsValid())
+            return nullptr ;
+         if ( ! pCCApproxTot->AddCurve( Release( pCApprox)))
+            return nullptr ;
+      }
    }
 
    return Release( pCCApproxTot) ;
@@ -1668,14 +1722,18 @@ ApproxCurveWithBezier( const ICurve* pCrv , double dTol, int nType)
 bool
 CalcApproxError( const ICurve* pCrvOri, const ICurve* pCrvNew, double& dErr, int nPoints)
 {
-   if( pCrvOri == nullptr  ||  ! pCrvOri->IsValid()  ||  pCrvNew == nullptr  || ! pCrvNew->IsValid()){
+   if ( pCrvOri == nullptr  ||  ! pCrvOri->IsValid()  ||  pCrvNew == nullptr  ||  ! pCrvNew->IsValid()){
       dErr = INFINITO ;
       return false ;
    }
    // controllo l'errore effettivo campionando più finemente
    double dLenOri = 0 ; pCrvOri->GetLength( dLenOri) ;
    double dLenNew = 0 ; pCrvNew->GetLength( dLenNew) ;
-   dErr = 0 ;
+   Point3d ptStart0 ; pCrvOri->GetStartPoint( ptStart0) ;
+   Point3d ptStart1 ; pCrvNew->GetStartPoint( ptStart1) ;
+   Point3d ptEnd0 ; pCrvOri->GetEndPoint( ptEnd0) ;
+   Point3d ptEnd1 ; pCrvNew->GetEndPoint( ptEnd1) ;
+   dErr = max( Dist( ptStart1, ptStart0), Dist( ptEnd1, ptEnd0)) ; 
    for ( int i = 1 ; i < nPoints ; ++i) {
       Point3d ptOri, ptNew ;
       double dParOri, dParNew ;
@@ -1753,7 +1811,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
 {
   // se con nodi extra
    if ( cnData.bExtraKnotes) {
-      int nKnotesNbr = int( cnData.vU.size()) ;
+      int nKnotesNbr = ssize( cnData.vU) ;
       if ( nKnotesNbr < 4)
          return false ;
       cnData.bExtraKnotes = false ;
@@ -1767,7 +1825,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
       bool bAlreadyChecked = false ;
      // se la curva è peridica verifco che effettivamente ci sia un numero di punti ripetituti uguale al grado della curva
      // wrap della curva su se stessa
-      if ( cnData.bPeriodic  &&  (int(cnData.vU.size()) > int(cnData.vCP.size()) + cnData.nDeg - 1)) {
+      if ( cnData.bPeriodic  &&  ( ssize( cnData.vU) > ssize( cnData.vCP) + cnData.nDeg - 1)) {
          bool bRepeated = true ;
          for ( int i = 0 ; i < cnData.nDeg ; ++i) {
             if ( ! AreSamePointApprox( cnData.vCP[i], cnData.vCP.end()[-cnData.nDeg + i]) ) {
@@ -1776,11 +1834,11 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
             }
          }
          bool bFirstAddedAtEnd = false ;
-         if ( ! bRepeated  ||  (bRepeated  && AreSamePointApprox( cnData.vCP[0],cnData.vCP[cnData.nDeg]))){
+         if ( ! bRepeated  ||  ( bRepeated  &&  AreSamePointApprox( cnData.vCP[0], cnData.vCP[cnData.nDeg]))) {
            // salvo il vettore dei nodi in caso mi accorga di avere tra le mani una curva unclamped
             DBLVECTOR vU = cnData.vU ;
            // se effettivamente ho dei nodi in più da togliere allora li tolgo ed eventualmente aggiungo punti di controllo
-            if ( int(cnData.vU.size()) > int(cnData.vCP.size()) + cnData.nDeg - 1 ) {
+            if ( ssize( cnData.vU) > ssize( cnData.vCP) + cnData.nDeg - 1 ) {
               // se il primo e l'ultimo punto non coincidono allora aggiungo il primo punto in fondo al vettore dei punti di controllo
                if ( ! AreSamePointApprox( cnData.vCP[0], cnData.vCP.back())) {
                   bFirstAddedAtEnd = true ;
@@ -1792,11 +1850,11 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
                cnData.vU = DBLVECTOR( cnData.vU.begin(), cnData.vU.end() - cnData.nDeg) ;
               // controllo eventualmente anche i nodi extra
               // se ne ho due in più ne tolgo uno in cima e uno in fondo
-               if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg + 1 ) {   // significa che ci sono due nodi extra, uno all'inizio e uno alla fine, da togliere
+               if ( ssize( cnData.vU) == ssize( cnData.vCP) + cnData.nDeg + 1) {   // significa che ci sono due nodi extra, uno all'inizio e uno alla fine, da togliere
                   cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end() - 1) ;
                }
               // se ne ho solo uno in più lo tolgo in cima
-               else if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg) {
+               else if ( ssize( cnData.vU) == ssize( cnData.vCP) + cnData.nDeg) {
                   cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end()) ;
                }
             }
@@ -1823,7 +1881,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
               // recupero il vettore dei nodi
                cnData.vU = vU ;
               // verifico se ho nodi extra
-               if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg + 1 ) {
+               if ( ssize( cnData.vU) == ssize( cnData.vCP) + cnData.nDeg + 1 ) {
                  // significa che ci sono due nodi extra:
                  // se la curva ha grado maggiore di 1 e i primi due nodi sono uguali allora tolgo quelli
                   if ( cnData.nDeg > 1 && abs(cnData.vU[1] - cnData.vU[0]) < EPS_SMALL) {
@@ -1834,7 +1892,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
                      cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end() - 1) ;
                }
               // se ne ho solo uno in più lo tolgo in cima
-               else if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg)
+               else if ( ssize( cnData.vU) == ssize( cnData.vCP) + cnData.nDeg)
                   cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end()) ;
             }
             bAlreadyChecked = true ;
@@ -1859,7 +1917,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
      // qui aggiungo un controllo se la curva è collassata in un punto ( ho un polo), lascio stare
       bool bCollapsed = true ;
       Point3d ptFirst = cnData.vCP.front() ;
-      for ( int i = 1 ; i < int( cnData.vCP.size()) ; ++i) {
+      for ( int i = 1 ; i < ssize( cnData.vCP) ; ++i) {
          if ( ! AreSamePointApprox( ptFirst, cnData.vCP[i])) {
             bCollapsed = false ;
             break ;
@@ -1876,7 +1934,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
      // agli indici perché uso u_p-1 e u_(m-p+1), anziché u_p e u_m-p
 
      // comincio ad aumentare la molteplictià del nodo u_m-p+1
-      int nCP = int( cnData.vCP.size()) ;
+      int nCP = ssize( cnData.vCP) ;
       int nU = nCP + cnData.nDeg - 1 ;
       int nDeg = cnData.nDeg ;
       PNTVECTOR vBC ;
@@ -2072,9 +2130,9 @@ NurbsToBezierCurve( const CNurbsData& cnData)
    if ( cnData.bPeriodic  ||  cnData.bExtraKnotes)
       return nullptr ;
   // numero dei nodi
-   int nU = int( cnData.vCP.size()) + cnData.nDeg - 1 ;
+   int nU = ssize( cnData.vCP) + cnData.nDeg - 1 ;
   // controllo relazione nodi - punti di controllo
-   if ( nU != int( cnData.vU.size()))
+   if ( nU != ssize( cnData.vU))
       return nullptr ;
   // numero degli intervalli
    int nInt = nU - 2 * cnData.nDeg + 1 ;
@@ -2444,7 +2502,7 @@ CalcCurvesVoronoiDiagram( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, in
    PtrOwner<Voronoi> pVoronoiObj( new( std::nothrow) Voronoi()) ;
    if ( pVoronoiObj == nullptr)
       return false ;
-   for ( int i = 0 ; i < int( vCrvC.size()) ; i ++) {
+   for ( int i = 0 ; i < ssize( vCrvC) ; i ++) {
       if ( ! pVoronoiObj->AddCurve( vCrvC[i]))
          return false ;
    }
@@ -2471,7 +2529,7 @@ CalcCurvesMedialAxis( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, int nS
    PtrOwner<Voronoi> pVoronoiObj( new( std::nothrow) Voronoi()) ;
    if ( pVoronoiObj == nullptr)
       return false ;
-   for ( int i = 0 ; i < int( vCrvC.size()) ; i ++) {
+   for ( int i = 0 ; i < ssize( vCrvC) ; i ++) {
       if ( ! pVoronoiObj->AddCurve( vCrvC[i]))
          return false ;
    }
@@ -2532,7 +2590,7 @@ bool CalcOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR& vCrvs, doubl
    PtrOwner<Voronoi> pVoronoiObj( new( std::nothrow) Voronoi()) ;
    if ( pVoronoiObj == nullptr)
       return false ;
-   for ( int i = 0 ; i < int( vpCrvs.size()) ; i ++) {
+   for ( int i = 0 ; i < ssize( vpCrvs) ; i ++) {
       if ( ! pVoronoiObj->AddCurve( vpCrvs[i]))
          return false ;
    }
@@ -2562,7 +2620,7 @@ bool CalcFatOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR& vCrvs, do
    PtrOwner<Voronoi> pVoronoiObj( new( std::nothrow) Voronoi()) ;
    if ( pVoronoiObj == nullptr)
       return false ;
-   for ( int i = 0 ; i < int( vpCrvs.size()) ; i ++) {
+   for ( int i = 0 ; i < ssize( vpCrvs) ; i ++) {
       if ( ! pVoronoiObj->AddCurve( vpCrvs[i]))
          return false ;
    }
@@ -2594,9 +2652,9 @@ ResetCurveVoronoi( const ICurve& crvC)
 
 //----------------------------------------------------------------------------
 bool
-GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol, bool bAllowInvert)
+GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol, bool bAllowInvert, bool bHaltOnFork)
 {
-   if( ssize( vCrv) == 1)
+   if ( ssize( vCrv) == 1)
       return true ;
    ChainCurves chainCrv ;
    // modifico direttamente le curve passate in input
@@ -2612,26 +2670,188 @@ GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol, bool bAllowInvert)
    }
    INTVECTOR vIds ;
    Point3d ptStart = ORIG ;
-   while ( chainCrv.GetChainFromNear( ptStart, false, vIds)) {
-      ICurveComposite* pFirstCrv = vCrv[abs(vIds[0]) - 1] ;
+   while ( chainCrv.GetChainFromNear( ptStart, bHaltOnFork, vIds)) {
+      int nFirst = vIds[0] ;
+      bool bInvert = false ;
+      if ( nFirst < 0)
+         bInvert = true ;
+      nFirst = abs( nFirst) - 1 ;
+      if ( bInvert)
+         vCrv[nFirst]->Invert() ;
+      ICurveComposite* pFirstCrv = vCrv[nFirst] ;
       for ( int nId : vIds) {
-         bool bInvert = false ;
-         if( nId < 0)
+         bInvert = false ;
+         if ( nId < 0)
             bInvert = true ;
          nId = abs( nId) - 1 ;
-         if( bInvert)
+         if ( nId == nFirst)
+            continue ;
+         if ( bInvert)
             vCrv[nId]->Invert() ;
-         if( ! pFirstCrv->AddCurve( Release( vCrv[nId]), true, dChainTol))
+         if ( ! pFirstCrv->AddCurve( Release( vCrv[nId]), true, dChainTol))
             return false ;
       }
       pFirstCrv->GetEndPoint( ptStart) ;
    }
    // elimino gli elementi del vettore che non contengono più curve
-   int c = ssize( vCrv) ;
-   while( c > -1) {
-      if( IsNull( vCrv[c]))
+   int c = ssize( vCrv) - 1 ;
+   while ( c > -1) {
+      if ( IsNull( vCrv[c]))
          vCrv.erase( vCrv.begin() + c) ;
       --c ;
    }
    return true ;
+}
+
+//----------------------------------------------------------------------------
+double
+CalcWeightVal( double dLen, const ICurve* pCrv, const Vector3d vtCurr1, const Point3d& ptCurr1, double dCoeff, double dMyDist, double& dUStep2)
+{
+   pCrv->GetParamAtLength( dLen, dUStep2) ;
+   Point3d ptStep2 ; Vector3d vtStep2 = V_NULL ;
+   pCrv->GetPointD1D2( dUStep2, ICurve::FROM_MINUS, ptStep2, &vtStep2) ; vtStep2.Normalize() ;
+   double dStepCos2 = vtCurr1 * vtStep2 ;
+   double dDist = Dist( ptCurr1, ptStep2) ;
+   return (1 - dStepCos2) + dCoeff * dDist / dMyDist ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GetIsoPointOnSecondCurve( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2, double dUCurr1, double& dUCurr2, double dMyDist, double dUPrev2,
+                          double dLenPrev2, double& dLenCurr2, double dLen2)
+{
+   Point3d ptCurr1 ;
+   Vector3d vtCurr1 ;
+   pCrvEdge1->GetPointD1D2( dUCurr1, ICurve::FROM_MINUS, ptCurr1, &vtCurr1) ;
+   vtCurr1.Normalize() ;
+   // --- Piano di taglio per punto a minima distanza
+   IntersCurvePlane ICP( *pCrvEdge2, ptCurr1, vtCurr1) ;
+   int nIndParCloser = - 1, nIndPointCloser = -1 ;
+   double dSqMinDist = INFINITO ;
+   for ( int nInfo = 0 ; nInfo < ICP.GetIntersCount() ; ++ nInfo) {
+      IntCrvPlnInfo aInfo ;
+      if ( ICP.GetIntCrvPlnInfo( nInfo, aInfo)  &&  aInfo.Ici[0].dU > dUPrev2) {
+         if ( nIndParCloser == -1)
+            nIndParCloser = nInfo ;
+         double dSqDist = SqDist( ptCurr1, aInfo.Ici[0].ptI) ;
+         if ( dSqDist < dSqMinDist) {
+            dSqMinDist = dSqDist ;
+            nIndPointCloser = nInfo ;
+         }
+      }
+   }
+   bool bOkPlane = ( nIndParCloser != -1  &&  nIndPointCloser != -1) ;
+   if ( bOkPlane) {
+      // Se gli indici sono tra loro coerenti allora ho individuato il punto
+      if ( nIndParCloser == nIndPointCloser) {
+         IntCrvPlnInfo aInfo ;
+         ICP.GetIntCrvPlnInfo( nIndParCloser, aInfo) ;
+         dUCurr2 = aInfo.Ici[0].dU ;
+      }
+      // Se gli indici sono discordi, devo scegliere quale dei due punti tenere
+      else {
+         // scelgo il punto più vicino al corrente
+         IntCrvPlnInfo aInfoPt, aInfoPar ;
+         ICP.GetIntCrvPlnInfo( nIndPointCloser, aInfoPt) ;
+         ICP.GetIntCrvPlnInfo( nIndParCloser, aInfoPar) ;
+         dUCurr2 = ( SqDist( ptCurr1, aInfoPt.Ici[0].ptI) < SqDist( ptCurr1, aInfoPar.Ici[0].ptI) ?
+            aInfoPt.Ici[0].dU : aInfoPar.Ici[0].dU) ;
+#if SAVESYNCLINES
+         VT.clear() ; VC.clear() ;
+         VT.emplace_back( pCrvEdge1->Clone()) ; VC.emplace_back( Color( 0, 128, 255)) ;
+         VT.emplace_back( pCrvEdge2->Clone()) ; VC.emplace_back( Color( 0, 128, 255)) ;
+         PtrOwner<IGeoPoint3d> ptCurr1Geo( CreateGeoPoint3d()) ; ptCurr1Geo->Set( ptCurr1) ;
+         VT.emplace_back( Release( ptCurr1Geo)) ; VC.emplace_back( BLUE) ;
+         PtrOwner<IGeoPoint3d> ptPar( CreateGeoPoint3d()) ; ptPar->Set( aInfoPar.Ici[0].ptI) ;
+         PtrOwner<IGeoPoint3d> ptPt( CreateGeoPoint3d()) ; ptPt->Set( aInfoPt.Ici[0].ptI) ;
+         VT.emplace_back( Release( ptPar)) ; VC.emplace_back( LIME) ;
+         VT.emplace_back( Release( ptPt)) ; VC.emplace_back( FUCHSIA) ;
+         SaveGeoObj( VT, VC, "C:\\Temp\\bezier\\ruled\\TestTrimmingPlane.nge") ;
+#endif
+      }
+      // Verifico di non essermi allontanato troppo
+      double dLen ; pCrvEdge2->GetLengthAtParam( dUCurr2, dLen) ;
+      bOkPlane = ( dLen < dLenPrev2 + 2. * dMyDist) ;
+   }
+   if ( ! bOkPlane) {
+      // --- Altrimenti, cerco il punto a minima distanza
+      DistPointCurve DPC( ptCurr1, *pCrvEdge2) ;
+      int nFlag ;
+      bool bOkMinDist = ( DPC.GetParamAtMinDistPoint( dUPrev2, dUCurr2, nFlag)  &&  dUCurr2 > dUPrev2) ;
+      // Verifico di non essermi allontanato troppo
+      if ( bOkMinDist) {
+         double dLen ; pCrvEdge2->GetLengthAtParam( dUCurr2, dLen) ;
+         bOkMinDist = ( dLen < dLenPrev2 + 2. * dMyDist) ;
+      }
+      if ( ! bOkMinDist) {
+         // --- Aumento la distanza corrente del passo di campionamento
+         double dLen = Clamp( dLenPrev2 + dMyDist, 0., dLen2) ;
+         pCrvEdge2->GetParamAtLength( dLen, dUCurr2) ;
+      }
+   }
+
+   // Recupero il punto corrente e la direzione tangente sul secondo bordo
+   pCrvEdge2->GetLengthAtParam( dUCurr2, dLenCurr2) ;
+   Point3d ptCurr2 ;
+   Vector3d vtCurr2 ;
+   pCrvEdge2->GetPointD1D2( dUCurr2, ICurve::FROM_MINUS, ptCurr2, &vtCurr2) ;
+   vtCurr2.Normalize() ;
+
+   // Verifico se le direzioni tangenti sono tra di loro circa parallele
+   const double COS_ANG_TOL = cos( 15. * DEGTORAD) ;
+   const double COS_SMALL_ANG_TOL = cos( 4. * DEGTORAD) ;
+   double dSearchLen = dMyDist / 2 ;
+   int NUM_STEP = 10 ;
+   const double dCoeff = 0.1 ;
+   double dCos = vtCurr1 * vtCurr2 ;
+   double dDistCurr = Dist( ptCurr1, ptCurr2) ;
+   double dMin = (1 - dCos) + dCoeff * dDistCurr / dMyDist ;
+   double bUpdated = false ;
+   // se poco fuori tolleranza controllo se ho un punto abbastanza vicino con la stessa tangente
+   if ( vtCurr1 * vtCurr2 < COS_SMALL_ANG_TOL) {
+      // Se tanto fuori dalla tolleranza, recupero il miglior versore tangente sul secondo bordo nell'intervallo successivo di lunghezza ( 2. * dMyDist)
+      if ( vtCurr1 * vtCurr2 < COS_ANG_TOL) {
+         dSearchLen = dMyDist ;
+         NUM_STEP = 20 ;
+      }
+      pCrvEdge2->GetLengthAtPoint( ptCurr2, dLenCurr2) ;
+      double dLimInfLen2 = Clamp( dLenCurr2 - dSearchLen, dLenPrev2, dLen2) ;
+      double dLimSupLen2 = Clamp( dLenCurr2 + dSearchLen, dLenPrev2, dLen2) ;
+
+      // faccio un campionamento grossolano e poi campiono più finemente in prossimità dei minimi
+      DBLVECTOR vVal ;
+      for ( int i = 0 ; i <= NUM_STEP ; ++ i) {
+         double dLen = dLimInfLen2 + i * ( dLimSupLen2 - dLimInfLen2) / NUM_STEP ;
+         double dUStep2 ;
+         vVal.push_back( CalcWeightVal( dLen, pCrvEdge2, vtCurr1, ptCurr1, dCoeff, dMyDist, dUStep2)) ;
+         if ( vVal.back() < dMin) {
+            dMin = vVal.back() ;
+            dUCurr2 = dUStep2 ;
+         }
+      }
+      DBLDBLVECTOR vInterv ;
+      for ( int i = 1 ; i < ssize(vVal) - 1 ; ++i) {
+         if ( vVal[i] < vVal[i-1]  && vVal[i] < vVal[i+1])
+            vInterv.emplace_back( dLimInfLen2 + ( i - 1) * ( dLimSupLen2 - dLimInfLen2) / NUM_STEP,
+                                  dLimInfLen2 + ( i + 1) * ( dLimSupLen2 - dLimInfLen2) / NUM_STEP) ;
+      }
+      if ( ssize( vInterv) != 0) {
+         for ( int j = 0 ; j < ssize( vInterv) ; ++j) {
+            for ( int i = 0 ; i <= NUM_STEP ; ++ i) {
+               double dLen = vInterv[j].first + i * ( vInterv[j].second - vInterv[j].first) / NUM_STEP ;
+               double dUStep2 ;
+               double dVal = CalcWeightVal( dLen, pCrvEdge2, vtCurr1, ptCurr1, dCoeff, dMyDist, dUStep2) ;
+               if ( dVal < dMin) {
+                  dUCurr2 = dUStep2 ;
+                  dMin = dVal ;
+                  bUpdated = true ;
+               }
+            }
+         }
+      }
+   }
+   // se il parametro è cambiato devo ricalcolare la lunghezza, che viene restituita
+   if ( bUpdated)
+      pCrvEdge2->GetLengthAtParam( dUCurr2, dLenCurr2) ;
+   return true ;
 }

CurveAux.h

@@ -34,5 +34,4 @@ bool CurveDump( const ICurve& crvC, std::string& sOut, bool bMM, const char* szN
 bool CopyExtrusion( const ICurve* pSouCrv, ICurve* pDestCrv) ;
 bool CopyThickness( const ICurve* pSouCrv, ICurve* pDestCrv) ;
 ICurveBezier* ApproxCurveBezierWithSingleCubic( const ICurve* pCrv) ;
-Voronoi* GetCurveVoronoi( const ICurve& crvC) ;
-bool GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol, bool bAllowInvert) ;
+Voronoi* GetCurveVoronoi( const ICurve& crvC) ;

CurveBezier.cpp

@@ -275,20 +275,19 @@ 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) ;
+   SetControlPoint( nCount, ptStart) ;
    ++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) ;
+      SetControlPoint( nCount, ptMid) ;
       ++nCount ;
    }
    Point3d ptEnd ; crLine.GetEndPoint( ptEnd) ;
-   SetControlPoint( nCount, ptEnd, dWeight) ;
+   SetControlPoint( nCount, ptEnd) ;
    ++nCount ;
    return true ;
 }
@@ -1433,7 +1432,7 @@ CurveBezier::ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, Poly
 //----------------------------------------------------------------------------
 bool
 CurveBezier::FlatOrSplit( int nLev, const CurveBezier& crvBez, double dParStart, double dParEnd,
-                          double dLinTol, double dAngTolDeg, PolyLine& PL) const
+                          double dLinTol, double dAngTolDeg, PolyLine& PL, double dMaxLen) const
 {
   // se raggiunto il massimo livello di recursione ...
    const int MAX_LEV = 10 ;
@@ -1462,7 +1461,10 @@ CurveBezier::FlatOrSplit( int nLev, const CurveBezier& crvBez, double dParStart,
    }
 
   // se distanza entro tolleranza
-   if ( dMaxSqDist <= ( dLinTol * dLinTol)) {
+   bool bSplit = dMaxSqDist > ( dLinTol * dLinTol) ;
+   if ( dMaxLen < INFINITO)
+      bSplit = bSplit  ||  Dist( crvBez.m_vPtCtrl[0], crvBez.m_vPtCtrl[m_nDeg]) > dMaxLen ;
+   if ( ! bSplit) {
      // deviazione angolare tra primo e ultimo tratto del poligono di controllo (grado >= 1)
       Vector3d vtDirI = crvBez.m_vPtCtrl[1] - crvBez.m_vPtCtrl[0] ;
       Vector3d vtDirF = crvBez.m_vPtCtrl[m_nDeg] - crvBez.m_vPtCtrl[m_nDeg-1] ;
@@ -1496,18 +1498,65 @@ CurveBezier::FlatOrSplit( int nLev, const CurveBezier& crvBez, double dParStart,
      // prima metà
       crvBez1 = crvBez ;
       crvBez1.TrimEndAtParam( dParDiv) ;
-      if ( ! FlatOrSplit( nLev + 1, crvBez1, dParStart, dParMid, dLinTol, dAngTolDeg, PL))
+      if ( ! FlatOrSplit( nLev + 1, crvBez1, dParStart, dParMid, dLinTol, dAngTolDeg, PL, dMaxLen))
          return false ;
      // seconda metà
       crvBez1 = crvBez ;
       crvBez1.TrimStartAtParam( dParDiv) ;
-      if ( ! FlatOrSplit( nLev + 1, crvBez1, dParMid, dParEnd, dLinTol, dAngTolDeg, PL))
+      if ( ! FlatOrSplit( nLev + 1, crvBez1, dParMid, dParEnd, dLinTol, dAngTolDeg, PL, dMaxLen))
          return false ;
    }
 
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+CurveBezier::ApproxWithLimitedLines( double dLinTol, double dAngTolDeg, int nType, double dMaxLen, PolyLine& PL) const
+{
+   // pulisco la polilinea
+   PL.Clear() ;
+
+   // la curva deve essere validata
+   if ( m_nStatus != OK)
+      return false ;
+
+   // se di primo grado, basta inserire gli estremi
+   if ( m_nDeg == 1) {
+      PL.AddUPoint( 0, m_vPtCtrl[0]) ;
+      PL.AddUPoint( 1, m_vPtCtrl[m_nDeg]) ;
+      PL.AdjustForMaxSegmentLen( dMaxLen) ;
+      return true ;
+   }
+
+   // limiti minimi su tolleranza e deviazione angolare
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dAngTolDeg = max( dAngTolDeg, ANG_TOL_MIN_DEG) ;
+
+   // inserisco il punto iniziale
+   if ( ! PL.AddUPoint( 0, m_vPtCtrl[0]))
+      return false ;
+
+   // verifico se va divisa
+   if ( ! FlatOrSplit( 0, *this, 0, 1, dLinTol, dAngTolDeg, PL, dMaxLen))
+      return false ;
+
+   // se è stato inserito un solo punto, aggiungo il finale
+   if ( PL.GetPointNbr() == 1)
+      return PL.AddUPoint( 1, m_vPtCtrl[m_nDeg]) ;
+   // altrimenti, se l'ultimo punto non coincide con il finale lo sostituisco (distano al max di dLinTol)
+   else {
+      Point3d  ptLast ;
+      PL.GetLastPoint( ptLast) ;
+      if ( ! AreSamePointApprox( ptLast, m_vPtCtrl[m_nDeg])) {
+         PL.EraseLastUPoint() ;
+         return PL.AddUPoint( 1, m_vPtCtrl[m_nDeg]) ;
+      }
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 CurveBezier::ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) const

CurveBezier.h

@@ -111,6 +111,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       bool GetArea( Plane3d& plPlane, double& dArea) const override 
               { return CurveGetArea( *this, plPlane, dArea) ; }
       bool ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, PolyLine& PL) const override ;
+      bool ApproxWithLimitedLines( double dLinTol, double dAngTolDeg, int nType, double dMaxLen, PolyLine& PL) const override ;
       bool ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) const override ;
       bool ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) const override
               { return ApproxWithArcs( dLinTol, dAngTolDeg, PA) ; }
@@ -188,7 +189,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       bool GetSegmentParam( double dLen, double& dCurrLen, double& dSegLen,
                             double& dUIni, double& dUFin) const ;
       bool FlatOrSplit( int nLev, const CurveBezier& crvBez, double dParStart, double dParEnd,
-                        double dLinTol, double dAngTolDeg, PolyLine& PL) const ;
+                        double dLinTol, double dAngTolDeg, PolyLine& PL, double dMaxLen = INFINITO) const ;
       bool ApproxWithArcsXY(double dLinTol, double dAngTolDeg, PolyArc& PA) const;
       bool BiArcOrSplit(int nLev, PolyLine& PL, double dLinTol, double dAngTolDeg, PolyArc& PA) const;
       bool ToPowerBase( PolynomialPoint3d& pol3P) const ;

CurveComposite.cpp

@@ -1460,6 +1460,68 @@ CurveComposite::ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, P
    return PL.RemoveAlignedPoints( dLinTol) ;
 }
 
+//----------------------------------------------------------------------------
+bool
+CurveComposite::ApproxWithLimitedLines( double dLinTol, double dAngTolDeg, int nType, double dMaxLen, PolyLine& PL) const
+{
+   // funziona solo con le modalità standard e special
+   if ( nType != APL_STD  &&  nType != APL_SPECIAL  &&  nType != APL_SPECIAL_INT)
+      return false ;
+
+   // pulisco la polilinea
+   PL.Clear() ;
+
+   // verifico lo stato
+   if ( m_nStatus != OK)
+      return false ;
+
+   // limiti minimi su tolleranza e deviazione angolare
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dAngTolDeg = max( dAngTolDeg, ANG_TOL_MIN_DEG) ;
+
+   // se speciale, approssimo ogni singola entità e conservo le estremità interne (joint)
+   if ( nType == APL_SPECIAL  ||  nType == APL_SPECIAL_INT) {
+      // eseguo approssimazione
+      double dStartPar = 0 ;
+      for ( auto& pCrv : m_CrvSmplS) {
+         // assegno estrusione e spessore della curva composita
+         pCrv->SetExtrusion( m_VtExtr) ;
+         pCrv->SetThickness( m_dThick) ;
+         // recupero approssimazione per curva semplice
+         PolyLine PLSmpl ;
+         if ( ! pCrv->ApproxWithLimitedLines( dLinTol, dAngTolDeg, nType, dMaxLen, PLSmpl))
+            return false ;
+         // se richiesto almeno un punto interno con curve non rettilinee e ci sono solo gli estremi
+         if ( nType == APL_SPECIAL_INT  &&  pCrv->GetType() != CRV_LINE  &&  PLSmpl.GetPointNbr() == 2) {
+            //  aggiungo il punto interno
+            Point3d ptMid ;
+            if ( ! pCrv->GetMidPoint( ptMid))
+               return false ;
+            double dU ;
+            PLSmpl.GetLastU( dU) ;
+            dU /= 2 ;
+            PNTULIST& List = PLSmpl.GetUPointList() ;
+            List.insert( ++ List.begin(), { ptMid, dU}) ;
+         }
+         // ripristino estrusione e spessore della curva semplice (annullandoli)
+         pCrv->SetExtrusion( V_NULL) ;
+         pCrv->SetThickness( 0) ;
+         // la accodo opportunamente a quella della curva composita
+         if ( ! PL.Join( PLSmpl, dStartPar))
+            return false ;
+         // incremento inizio parametro per prossima curva semplice
+         dStartPar += 1 ;
+      }
+   }
+   else if ( nType == APL_STD) {
+      if ( ! ApproxWithLimitedLines( dLinTol, dAngTolDeg, APL_SPECIAL, dMaxLen, PL))
+         return false ;
+      PL.RemoveAlignedPoints( dLinTol, false, dMaxLen) ;
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 CurveComposite::ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) const
@@ -1967,7 +2029,120 @@ CurveComposite::AddJoint( double dU)
 
 //----------------------------------------------------------------------------
 bool
-CurveComposite::ModifyJoint( int nU, const Point3d& ptNewJoint)
+CurveComposite::ModifyJoint( int nU, const Point3d& ptNewJoint, double dTol)
+{
+   int nCrvCount = GetCurveCount() ;
+   // verifico l'indice della giunzione
+   if ( nU < 0  ||  nU > nCrvCount)
+      return false ;
+  // salvo le vecchie curve e nel caso le ripristino
+   int nPrevCrv = -1 ;
+  // recupero l'indice e il puntatore alla curva precedente (se esiste)
+   if ( nU >= 0)
+      nPrevCrv = nU - 1 ;
+   else if ( IsClosed())
+      nPrevCrv = nCrvCount - 1 ;
+   PtrOwner<CurveComposite> pOrigCrv( CreateBasicCurveComposite()) ;
+   if ( nPrevCrv >= 0)
+      pOrigCrv->AddCurve( m_CrvSmplS[ nPrevCrv]->Clone()) ;
+  // recupero il puntatore alla curva successiva (se esiste)
+   int nNextCrv = -1 ;
+   if ( nU < nCrvCount)
+      nNextCrv = nU ;
+   else if ( IsClosed())
+      nNextCrv = 0 ;
+   else
+      nNextCrv = - 1 ;
+   if ( nNextCrv >= 0)
+      pOrigCrv->AddCurve( m_CrvSmplS[ nNextCrv]->Clone()) ;
+
+   int nCrvNmbr = GetCurveCount() ;
+   int nFlagDel = DeletedCurve::NONE ;
+   if ( ! ModifyJoint( nU, ptNewJoint, &nFlagDel))
+      return false ;
+
+   bool bErasedSomeCrv = nCrvCount > GetCurveCount() ;
+   bool bErasedPrev = ( nFlagDel == DeletedCurve::PREV) ;
+   bool bErasedNext = ( nFlagDel == DeletedCurve::NEXT) ;
+   if ( ( bErasedPrev && nNextCrv == -1)  ||  ( bErasedNext && nPrevCrv == -1)) {
+      // se sono su un estremo di una curva aperta e ho cancellato la sottocurva di estremità devo verificare che fosse più piccola della tolleranza
+      if ( bErasedPrev && nNextCrv == -1) {
+         Point3d ptOrigEnd ; pOrigCrv->GetEndPoint( ptOrigEnd) ;
+         Point3d ptNewEnd ; GetEndPoint( ptNewEnd) ;
+         if ( Dist( ptOrigEnd, ptNewEnd) > dTol)
+            m_CrvSmplS.push_back( Release( pOrigCrv)) ;
+         return true ;
+      }
+      if ( bErasedNext && nPrevCrv == -1) {
+         Point3d ptOrigStart ; pOrigCrv->GetStartPoint( ptOrigStart) ;
+         Point3d ptNewStart ; GetStartPoint( ptNewStart) ;
+         if ( Dist( ptOrigStart, ptNewStart) > dTol)
+            m_CrvSmplS.insert( m_CrvSmplS.begin(), Release( pOrigCrv)) ;
+         return true ;
+      }
+   }
+   double dStart ;
+   double dEnd ;
+   if ( bErasedPrev) {
+      dStart = nU ;
+      dEnd = nNextCrv + 1 ;
+   }
+   else if ( bErasedNext) {
+      dStart = nPrevCrv ;
+      dEnd = nU ;
+      if ( nU == 0)
+         dStart -= 1 ;
+   }
+   else { //  ! bErasedSomeCrv
+      dStart = ( nPrevCrv != -1 ? nPrevCrv : 0) ;
+      dEnd = ( nNextCrv != -1 ? nNextCrv + 1 : nCrvNmbr) ;
+   }
+   PtrOwner<ICurve> pNewCurve( CopyParamRange( dStart, dEnd)) ;
+   double dErr = 0 ;
+   if ( ! CalcApproxError( pOrigCrv, pNewCurve, dErr, 6)  ||  dErr > dTol) {
+      // se ho fallito il check o la variazione è superiore alla tolleranza richiesta, ripristino le curve originali
+      if ( ! bErasedSomeCrv) {
+         if ( nNextCrv != -1) {
+            delete m_CrvSmplS[nNextCrv] ;
+            m_CrvSmplS[nNextCrv] = pOrigCrv->RemoveFirstOrLastCurve( true) ;
+         }
+         if ( nPrevCrv != -1) {
+            delete m_CrvSmplS[nPrevCrv] ;
+            m_CrvSmplS[nPrevCrv] = pOrigCrv->RemoveFirstOrLastCurve( true) ;
+         }
+      }
+      else {
+         if ( bErasedNext) {
+            int nPos = nU == 0 ? nPrevCrv - 1 : nU ;
+            delete m_CrvSmplS[nPos] ;
+            if ( nU == 0) {
+               m_CrvSmplS[nPos] = pOrigCrv->RemoveFirstOrLastCurve( false) ;
+               nPos = 0 ;
+            }
+            else
+               m_CrvSmplS[nPos] = pOrigCrv->RemoveFirstOrLastCurve( true) ;
+            m_CrvSmplS.insert( m_CrvSmplS.begin() + nPos, pOrigCrv->RemoveFirstOrLastCurve( true)) ;
+         }
+         else {
+            int nPos = nU == 0 ? nU : nPrevCrv ;
+            delete m_CrvSmplS[nPos] ;
+            if ( nU == 0) {
+               m_CrvSmplS[nPos] = pOrigCrv->RemoveFirstOrLastCurve( true) ;
+               nPos = nCrvNmbr - 1 ;
+            }
+            else
+               m_CrvSmplS[nPos] = pOrigCrv->RemoveFirstOrLastCurve( true) ;
+            m_CrvSmplS.insert( m_CrvSmplS.begin() + nPos, pOrigCrv->RemoveFirstOrLastCurve( true)) ;
+         }
+      }
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CurveComposite::ModifyJoint( int nU, const Point3d& ptNewJoint, int* pnFlagDel)
 {
   // verifico lo stato
    if ( m_nStatus != OK)
@@ -1977,6 +2152,8 @@ CurveComposite::ModifyJoint( int nU, const Point3d& ptNewJoint)
   // verifico l'indice della giunzione
    if ( nU < 0  ||  nU > nCrvCount)
       return false ;
+   if ( pnFlagDel != nullptr)
+      *pnFlagDel = DeletedCurve::NONE ;
   // recupero l'indice e il puntatore alla curva precedente (se esiste)
    int nPrevCrv = -1 ;
    if ( nU > 0)
@@ -2005,6 +2182,8 @@ CurveComposite::ModifyJoint( int nU, const Point3d& ptNewJoint)
       if ( AreSamePointApprox( ptStart, ptNewJoint)) {
          delete pPrevCrv ;
          m_CrvSmplS.erase( m_CrvSmplS.begin() + nPrevCrv) ;
+         if ( pnFlagDel != nullptr)
+            *pnFlagDel = DeletedCurve::PREV ;
       }
      // altrimenti diventa un segmento di retta
       else {
@@ -2024,6 +2203,8 @@ CurveComposite::ModifyJoint( int nU, const Point3d& ptNewJoint)
       if ( AreSamePointApprox( ptNewJoint, ptEnd)) {
          delete pNextCrv ;
          m_CrvSmplS.erase( m_CrvSmplS.begin() + nNextCrv) ;
+         if ( pnFlagDel != nullptr)
+            *pnFlagDel = DeletedCurve::NEXT ;
       }
      // altrimenti diventa un segmento di retta
       else {
@@ -3858,3 +4039,49 @@ CurveComposite::GetOnlyPoint(Point3d& ptStart) const
    ptStart = m_ptStart ;
    return true ;
 }
+
+//----------------------------------------------------------------------------
+bool
+CurveComposite::ReplaceSingleCurve( int nSubCrv, ICurve* pNewCurveToAdd, double dTolStartEnd, double dTolAlong)
+{
+   // prendo il possesso e verifico la curva
+   PtrOwner<ICurve> pNewCurve( pNewCurveToAdd) ;
+   if ( IsNull( pNewCurve)  ||  ! pNewCurve->IsValid())
+      return false ;
+
+   // verifico lo stato
+   if ( m_nStatus != OK)
+      return false ;
+
+   // verifico l'indice sia sensato
+   if ( nSubCrv < 0 || nSubCrv > GetCurveCount())
+      return false ;
+
+   // verifico che start e end coincidano entro la tolleranza
+   Point3d ptStart ; m_CrvSmplS[nSubCrv]->GetStartPoint( ptStart) ;
+   Point3d ptEnd ; m_CrvSmplS[nSubCrv]->GetEndPoint( ptEnd) ;
+   Point3d ptNewStart ; pNewCurve->GetStartPoint( ptNewStart) ;
+   Point3d ptNewEnd ; pNewCurve->GetEndPoint( ptNewEnd) ;
+   if ( ! AreSamePointApprox( ptStart, ptNewStart)  ||  ! AreSamePointApprox( ptEnd, ptNewEnd)) {
+      // se i punti di inizio e fine non sono entro EPS_SMALL ma sono entro la tolleranza passata allora modifico la curva da aggiungere
+      if ( AreSamePointEpsilon( ptStart, ptNewStart, dTolStartEnd)  &&  AreSamePointEpsilon( ptEnd, ptNewEnd, dTolStartEnd)) {
+         if ( ! pNewCurve->ModifyStart( ptStart)  || ! pNewCurve->ModifyEnd( ptEnd))
+            return false ;
+      }
+      else
+         return false ;
+   }
+
+   // se presente una tolleranza lungo la curva controllo che sia rispettata
+   if ( dTolAlong < INFINITO) {
+      double dErr = 0 ;
+      CalcApproxError( m_CrvSmplS[nSubCrv], pNewCurve, dErr, 20) ;
+      if ( dErr > dTolAlong)
+         return false ;
+   }
+
+   delete m_CrvSmplS[nSubCrv] ;
+   m_CrvSmplS[nSubCrv] = Release( pNewCurve) ;
+
+   return true ;
+}

CurveComposite.h

@@ -26,6 +26,9 @@ class Voronoi ;
 //----------------------------------------------------------------------------
 class CurveComposite : public ICurveComposite, public IGeoObjRW
 {
+   public :
+      enum  DeletedCurve { NONE = 0, PREV = 1, NEXT = 2 } ;
+
    public :                      // IGeoObj
       ~CurveComposite( void) override ;
       CurveComposite* Clone( void) const override ;
@@ -109,6 +112,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool GetArea( Plane3d& plPlane, double& dArea) const override 
               { return CurveGetArea( *this, plPlane, dArea) ; }
       bool ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, PolyLine& PL) const override ;
+      bool ApproxWithLimitedLines( double dLinTol, double dAngTolDeg, int nType, double dMaxLen, PolyLine& PL) const override ;
       bool ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) const override ;
       bool ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) const override ;
       ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
@@ -156,7 +160,9 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool AddArc2P( const Point3d& ptOther, const Point3d& ptNew, bool bEndOrStart = true) override ;
       bool AddArcTg( const Point3d& ptNew, bool bEndOrStart = true) override ;
       bool AddJoint( double dU) override ;
-      bool ModifyJoint( int nU, const Point3d& ptNewJoint) override ;
+      bool ModifyJoint( int nU, const Point3d& ptNewJoint) override
+               { return ModifyJoint( nU, ptNewJoint, nullptr) ; }
+      bool ModifyJoint( int nU, const Point3d& ptNewJoint, double dTol) override ; // verifico se le curve interessate sono in tolleranza con la versione prima della modifica
       bool RemoveJoint( int nU) override ;
       bool MoveCurve( int nCrv, const Vector3d& vtMove) override ;
       bool ModifyCurveToArc( int nCrv, const Point3d& ptMid) override ;
@@ -178,6 +184,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       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 ReplaceSingleCurve( int nSubCrv, ICurve* pNewCurve, double dTolStartEnd, double dTolAlong = INFINITO) override ;
       
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
@@ -211,6 +218,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool SimpleOffsetXY( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) ;
       bool IsOneCircle( Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const ;      
       bool CalcVoronoiObject( void) const ;
+      bool ModifyJoint( int nU, const Point3d& ptNewJoint, int* pnFlagDel) ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2, IS_A_POINT = 3} ;

CurveLine.cpp

@@ -514,6 +514,34 @@ CurveLine::ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, PolyLi
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+CurveLine::ApproxWithLimitedLines( double dLinTol, double dAngTolDeg, int nType, double dMaxLen, PolyLine& PL) const
+{
+   // pulisco la polilinea
+   PL.Clear() ;
+
+   // la curva deve essere validata
+   if ( m_nStatus != OK)
+      return false ;
+
+   // inserisco lo start
+   PL.AddUPoint( 0, m_PtStart) ;
+
+   double dLen = Dist( m_PtStart, m_PtEnd) ;
+   if ( dLen > dMaxLen) {
+      int nStep = int( ceil( dLen / dMaxLen)) ;
+      for ( int i = 1 ; i < nStep ; ++i) {
+         double dPar = 1. / nStep * i ;
+         PL.AddUPoint( dPar, Media( m_PtStart, m_PtEnd, dPar)) ;
+      }
+   }
+   // inserisco l'end
+   PL.AddUPoint( 1, m_PtEnd) ;
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 CurveLine::ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) const

CurveLine.h

@@ -112,6 +112,7 @@ class CurveLine : public ICurveLine, public IGeoObjRW
       bool GetArea( Plane3d& plPlane, double& dArea) const override
               { return false ; }
       bool ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, PolyLine& PL) const override ;
+      bool ApproxWithLimitedLines( double dLinTol, double dAngTolDeg, int nType, double dMaxLen, PolyLine& PL) const override ;
       bool ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) const override ;
       bool ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) const override
               { return ApproxWithArcs( dLinTol, dAngTolDeg, PA) ; }

DistPointCrvAux.cpp

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

DistPointCrvBezier.cpp

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

DistPointCurve.cpp

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

DistPointSurfBz.cpp

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

EgtGeomKernel.vcxproj

@@ -284,6 +284,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="CalcDerivate.cpp" />
     <ClCompile Include="CAvSilhouetteSurfTm.cpp" />
     <ClCompile Include="CAvSimpleSurfFrMove.cpp" />
+    <ClCompile Include="CAvSurfFrMove.cpp" />
     <ClCompile Include="CAvToolSurfTm.cpp" />
     <ClCompile Include="CAvToolTriangle.cpp" />
     <ClCompile Include="CDeBoxClosedSurfTm.cpp" />
@@ -323,6 +324,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="IntersLineVolZmap.cpp" />
     <ClCompile Include="IntersPlaneVolZmap.cpp" />
     <ClCompile Include="IntersLineSurfBez.cpp" />
+    <ClCompile Include="OffsetCurve3d.cpp" />
     <ClCompile Include="Trimming.cpp" />
     <ClCompile Include="MultiGeomDB.cpp" />
     <ClCompile Include="SurfTriMeshOffset.cpp" />
@@ -353,6 +355,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkSubtractProjectedFacesOnStmFace.h" />
     <ClInclude Include="..\Include\EGkSurfTriMeshAux.h" />
     <ClInclude Include="CAvSilhouetteSurfTm.h" />
+    <ClInclude Include="CAvSurfFrMove.h" />
     <ClInclude Include="CDeBoxTria.h" />
     <ClInclude Include="CDeCapsTria.h" />
     <ClInclude Include="CDeConeFrustumTria.h" />

EgtGeomKernel.vcxproj.filters

@@ -570,6 +570,15 @@
     <ClCompile Include="CalcDerivate.cpp">
       <Filter>File di origine\Geo</Filter>
     </ClCompile>
+    <ClCompile Include="CAvSurfFrMove.cpp">
+      <Filter>File di origine\GeoCollisionAvoid</Filter>
+    </ClCompile>
+    <ClCompile Include="Trimming.cpp">
+      <Filter>File di origine\GeoStriping</Filter>
+    </ClCompile>
+    <ClCompile Include="OffsetCurve3d.cpp">
+      <Filter>File di origine\GeoOffset</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="stdafx.h">
@@ -1256,6 +1265,9 @@
     <ClInclude Include="..\Include\EGkMultiGeomDB.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
+    <ClInclude Include="CAvSurfFrMove.h">
+      <Filter>File di intestazione</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtGeomKernel.rc">

IntersCrvCompoCrvCompo.h

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

IntersCurveCurve.cpp

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

IntersCurvePlane.cpp

@@ -139,8 +139,6 @@ IntersCurvePlane::CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Cur
 void
 IntersCurvePlane::OrderAndCompleteIntersections()
 {
-   if ( m_Info.size() < 2)
-      return ;
    // cancello le interesezioni puntuali adiacenti a tratti di sovrapposizione
    // riempio le info PrevTy e NexyTy
    sort( m_Info.begin(), m_Info.end(), []( IntCrvPlnInfo& icpA, IntCrvPlnInfo& icpB) { return icpA.Ici[0].dU < icpA.Ici[0].dU ;}) ;
@@ -237,6 +235,16 @@ IntersCurvePlane::GetIntersCount( void)
    return m_nIntersCount ;
 }
 
+//----------------------------------------------------------------------------
+bool
+IntersCurvePlane::GetIntCrvPlnInfo( int nInd, IntCrvPlnInfo& aInfo)
+{
+   if ( nInd < 0  ||  nInd >= m_nIntersCount)
+      return false ;
+   aInfo = m_Info[nInd] ;
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 IntersCurvePlane::GetIntersPointNearTo( const Point3d& ptNear, Point3d& ptI, double& dParam)

IntersLineCyl.cpp

@@ -15,6 +15,7 @@
 #include "stdafx.h"
 #include "IntersLineCyl.h"
 #include "/EgtDev/Include/EGkFrame3d.h"
+#include "/EgtDev/Include/EGkIntersLineCylinder.h"
 #include "/EgtDev/Include/ENkPolynomialRoots.h"
 
 using namespace std ;
@@ -25,99 +26,176 @@ using namespace std ;
 // In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
 //----------------------------------------------------------------------------
 bool
-IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
-               double dRad, double dHeight,
-               double& dU1, double& dU2)
+IntersLineCyl( const Point3d& ptP, const Vector3d& vtV, double dH, double dRad, bool bTapLow, bool bTapUp,
+               double& dU1, Point3d& ptInt1, Vector3d& vtN1, double& dU2, Point3d& ptInt2, Vector3d& vtN2, bool bIgnoreTap, bool bInvertNormals)
 {
-  // Verifico il versore
-   if ( vtL.IsSmall())
+   dU1 = NAN ;
+   dU2 = NAN ;
+
+   // Verifico il versore
+   if ( vtV.IsSmall())
       return false ;
 
-  // Verifico il cilindro
-   if ( dRad < EPS_SMALL  ||  dHeight < EPS_SMALL)
+   // Verifico il cilindro
+   if ( dRad < EPS_SMALL  ||  dH < EPS_SMALL)
       return false ;
 
-  // Determino le eventuali intersezioni con le due basi a quota minima e massima (solo se linea non parallela ad esse)
+   // Determino le eventuali intersezioni con le due basi a quota minima e massima (solo se linea non parallela ad esse)
    int nBasInt = 0 ;
-   if ( abs( vtL.z) > EPS_ZERO) {
+   if ( abs( vtV.z) > EPS_ZERO) {
       // le linee tangenti al cilindro non sono considerate intersecanti
-      double EpsRad = ( vtL.IsZeroXY() ? - EPS_SMALL : EPS_SMALL) ;
-      Point3d ptInt1 = ptL + ( ( 0 - ptL.z) / vtL.z) * vtL ;
-      if ( ptInt1.x * ptInt1.x + ptInt1.y * ptInt1.y < dRad * dRad + 2 * dRad * EpsRad) {
-         dU1 = ( ptInt1 - ptL) * vtL ;
+      double dEpsRad = ( vtV.IsZeroXY() ? - EPS_SMALL : EPS_SMALL) ;
+      if ( bIgnoreTap)
+         dEpsRad = 0. ;
+      ptInt1 = ptP + ( ( 0 - ptP.z) / vtV.z) * vtV ;
+      if ( ptInt1.x * ptInt1.x + ptInt1.y * ptInt1.y < dRad * dRad + 2 * dRad * dEpsRad) {
          nBasInt += 1 ;
+         vtN1 = - Z_AX ;
+         dU1 = ( ( 0 - ptP.z) / vtV.z) ;
       }
-      Point3d ptInt2 = ptL + ( ( dHeight - ptL.z) / vtL.z) * vtL ;  
-      if ( ptInt2.x * ptInt2.x + ptInt2.y * ptInt2.y < dRad * dRad + 2 * dRad * EpsRad) {
-         dU2 = ( ptInt2 - ptL) * vtL ;
+      ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;  
+      if ( ptInt2.x * ptInt2.x + ptInt2.y * ptInt2.y < dRad * dRad + 2 * dRad * dEpsRad) {
          nBasInt += 2 ;
+         vtN2 = Z_AX ;
+         dU2 = ( ( dH - ptP.z) / vtV.z) ;
       }
    }
 
-  // Se la linea interseca entrambe le basi, si sono trovate le due intersezioni
+   // Se la linea interseca entrambe le basi, si sono trovate le due intersezioni
    if ( nBasInt == 3) {
-      if ( dU1 > dU2)
+      if ( dU1 > dU2) {
          swap( dU1, dU2) ;
-     // Trovate intersezioni
+         swap( ptInt1, ptInt2) ;
+         swap( vtN1, vtN2) ;
+      }
+      if ( bInvertNormals) {
+         vtN1 *= - 1 ;
+         vtN2 *= - 1 ;
+      }
+      // Trovate intersezioni
       return true ;
    }
-   
-  // Determino le intersezioni con la superficie laterale del cilindro
-   DBLVECTOR vdCoeff{ ptL.x * ptL.x + ptL.y * ptL.y - dRad * dRad,
-                      2 * ( ptL.x * vtL.x + ptL.y * vtL.y),
-                      vtL.x * vtL.x + vtL.y * vtL.y} ;
+
+   // Determino le intersezioni con la superficie laterale del cilindro
+   DBLVECTOR vdCoeff{ ptP.x * ptP.x + ptP.y * ptP.y - dRad * dRad,
+                      2 * ( ptP.x * vtV.x + ptP.y * vtV.y),
+                      vtV.x * vtV.x + vtV.y * vtV.y} ;
    DBLVECTOR vdRoots ;
    int nRoot = PolynomialRoots( 2, vdCoeff, vdRoots) ;
 
-  // Elimino le soluzioni cha danno intersezioni fuori dai limiti in Z del cilindro
+   // Epsilon per piani di tappo
+   double dEpsLow = ( bTapLow ? - EPS_SMALL : EPS_SMALL) ;
+   double dEpsUp = ( bTapUp ? EPS_SMALL : - EPS_SMALL) ;
+   if ( bIgnoreTap) {
+      dEpsLow = 0. ;
+      dEpsUp = 0. ;
+   }
+
+   // Elimino le soluzioni cha danno intersezioni fuori dai limiti in Z del cilindro
    if ( nRoot == 2) {
-      double dIntZ2 = ptL.z + vdRoots[1] * vtL.z ;
-      if ( dIntZ2 < 0 - EPS_SMALL  ||  dIntZ2 > dHeight + EPS_SMALL)
+      double dIntZ2 = ptP.z + vdRoots[1] * vtV.z ;
+      if ( dIntZ2 < 0 + dEpsLow  ||  dIntZ2 > dH + dEpsUp)
          -- nRoot ;
    }
    if ( nRoot >= 1) {
-      double dIntZ1 = ptL.z + vdRoots[0] * vtL.z ;
-      if ( dIntZ1 < 0 - EPS_SMALL  ||  dIntZ1 > dHeight + EPS_SMALL) {
+      double dIntZ1 = ptP.z + vdRoots[0] * vtV.z ;
+      if ( dIntZ1 < 0 + dEpsLow  ||  dIntZ1 > dH + dEpsUp) {
          if ( nRoot == 2)
             vdRoots[0] = vdRoots[1] ;
          -- nRoot ;
       }
    }
 
-  // Due soluzioni: la retta interseca due volte la superficie laterale
+   // Due soluzioni: la retta interseca due volte la superficie laterale
    if ( nRoot == 2) {
+      // Punti di intersezione con la superficie del cilindro
+      ptInt1 = ptP + vdRoots[0] * vtV ;
+      ptInt2 = ptP + vdRoots[1] * vtV ;
       dU1 = vdRoots[0] ;
       dU2 = vdRoots[1] ;
-      if ( dU1 > dU2)
+      // Determino le normali
+      vtN1.Set( ptInt1.x, ptInt1.y, 0) ;
+      vtN1.Normalize() ;
+      vtN2.Set( ptInt2.x, ptInt2.y, 0) ;
+      vtN2.Normalize() ;
+      if ( dU1 > dU2) {
          swap( dU1, dU2) ;
-     // Trovate intersezioni
-      return true ;
-   }
-   
-  // Una soluzione : la retta interseca la superficie laterale e un piano
-   else if ( nRoot == 1) {
-     // Se piano superiore
-      if ( nBasInt == 2) {
-         dU1 = vdRoots[0] ;
+         swap( ptInt1, ptInt2) ;
+         swap( vtN1, vtN2) ;
       }
-     // altrimenti piano inferiore
-      else if ( nBasInt == 1) {
-         dU2 = vdRoots[0] ;
+      if ( bInvertNormals) {
+         vtN1 *= - 1 ;
+         vtN2 *= - 1 ;
       }
-     // altrimenti niente
-      else
-         return false ;
-      if ( dU1 > dU2)
-         swap( dU1, dU2) ;
-     // Trovate intersezioni
+      // Trovate intersezioni
       return true ;
    }
 
-  // Nessuna soluzione : nessuna intersezione 
+   // Una soluzione : la retta interseca la superficie laterale e un piano
+   else if ( nRoot == 1) {
+      // Se piano superiore
+      if ( nBasInt == 2) {
+         // Punto di intersezione
+         dU1 = vdRoots[0] ;
+         ptInt1 = ptP + vdRoots[0] * vtV ;
+         // Normale alla superficie del cilindro verso l'interno
+         vtN1.Set( ptInt1.x, ptInt1.y, 0) ;
+         vtN1.Normalize() ;
+      }
+      // altrimenti piano inferiore
+      else if ( nBasInt == 1) {
+         // Punto di intersezione
+         dU2 = vdRoots[0] ;
+         ptInt2 = ptP + vdRoots[0] * vtV ;
+         // Normale alla superficie del cilindro verso l'interno
+         vtN2.Set( ptInt2.x, ptInt2.y, 0) ;
+         vtN2.Normalize() ;
+      }
+      // altrimenti niente
+      else
+         return false ;
+      if ( dU1 > dU2) {
+         swap( dU1, dU2) ;
+         swap( ptInt1, ptInt2) ;
+         swap( vtN1, vtN2) ;
+      }
+      if ( bInvertNormals) {
+         vtN1 *= - 1 ;
+         vtN2 *= - 1 ;
+      }
+      // Trovate intersezioni
+      return true ;
+   }
+
+   // Nessuna soluzione : nessuna intersezione 
    else
       return false ;
 }
 
+//----------------------------------------------------------------------------
+// Riferimento con origine nel centro della base e asse di simmetria coincidente con l'asse Z.
+// La funzione restituisce true in caso di intersezione, false altrimenti.
+//----------------------------------------------------------------------------
+bool
+IntersLineCyl( const Point3d& ptLineSt, const Vector3d& vtLineDir,
+               const Frame3d& CylFrame, double dH, double dRad, bool bTapLow, bool bTapUp,
+               double& dU1, Point3d& ptInt1, Vector3d& vtN1, double& dU2, Point3d& ptInt2, Vector3d& vtN2, bool bIgnoreTap, bool bInvertNormals)
+{
+   // Porto la linea nel riferimento del cilindro
+   Point3d ptP = GetToLoc( ptLineSt, CylFrame) ;
+   Vector3d vtV = GetToLoc( vtLineDir, CylFrame) ;
+   if ( IntersLineCyl( ptP, vtV, dH, dRad, bTapLow, bTapUp,
+                       dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, bIgnoreTap, bInvertNormals))
+   {
+      ptInt1.ToGlob( CylFrame) ;
+      vtN1.ToGlob( CylFrame) ;
+      ptInt2.ToGlob( CylFrame) ;
+      vtN2.ToGlob( CylFrame) ;
+      return true ;
+   }
+   return false ;
+}
+
 //----------------------------------------------------------------------------
 // Linea e cilindro sono nel medesimo riferimento.
 // Il cilindro è definito con centro della base, asse, raggio e altezza.
@@ -133,7 +211,13 @@ IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
    if ( ! frCyl.Set( ptCyl, vtCyl))
       return false ;
   // Ora eseguo i conti nel riferimento intrinseco
-   return IntersLineCyl( GetToLoc( ptL, frCyl), GetToLoc( vtL, frCyl), dRad, dHeight, dU1, dU2) ;
+   bool bTapLow = false ;
+   bool bTapUp = false ;
+   bool bIgnoreTap = true ;
+   Point3d ptInt1, ptInt2 ;
+   Vector3d vtN1, vtN2 ;
+   return IntersLineCyl( ptL, vtL, frCyl, dHeight, dRad, bTapLow, bTapUp,
+                         dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, bIgnoreTap) ;
 }
 
 //----------------------------------------------------------------------------
@@ -144,7 +228,7 @@ IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
 bool
 IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
                const Point3d& ptCyl1, const Point3d& ptCyl2, double dRad,
-               double& dU1, double& dU2) 
+               double& dU1, double& dU2)
 {
   // Determino asse ed altezza del cilindro
    Vector3d vtCyl = ptCyl2 - ptCyl1 ;
@@ -157,5 +241,39 @@ IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
    if ( ! frCyl.Set( ptCyl1, vtCyl))
       return false ;
   // Ora eseguo i conti nel riferimento intrinseco
-   return IntersLineCyl( GetToLoc( ptL, frCyl), GetToLoc( vtL, frCyl), dRad, dHeight, dU1, dU2) ;
+   bool bTapLow = false ;
+   bool bTapUp = false ;
+   bool bIgnoreTap = true ;
+   Point3d ptInt1, ptInt2 ;
+   Vector3d vtN1, vtN2 ;
+   return IntersLineCyl( ptL, vtL, frCyl, dHeight, dRad, bTapLow, bTapUp,
+                         dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, bIgnoreTap) ;
+}
+
+//----------------------------------------------------------------------------
+// linea già nel riferimento intrinseco del cilindro
+//----------------------------------------------------------------------------
+bool IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
+                    double dRad, double dHeight,
+                    double& dU1, double& dU2)
+{
+   Point3d ptInt1, ptInt2 ;
+   Vector3d vtN1, vtN2 ;
+   bool bTapLow = false, bTapUp = false ;
+   bool bIgnoreTap = true ;
+   return IntersLineCyl( ptL, vtL, dHeight, dRad, bTapLow, bTapUp,
+                         dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, bIgnoreTap) ;
+}
+
+
+//----------------------------------------------------------------------------
+// funzione esposta per altre dll
+//----------------------------------------------------------------------------
+bool
+IntersLineCyl( const Point3d& ptLineSt, const Vector3d& vtLineDir,
+               const Frame3d& CylFrame, double dH, double dRad,
+               double& dU1, Point3d& ptInt1, Vector3d& vtN1, double& dU2, Point3d& ptInt2, Vector3d& vtN2)
+{
+   return IntersLineCyl( ptLineSt, vtLineDir, CylFrame, dH, dRad, false, false,
+                         dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, true, false) ;
 }

IntersLineCyl.h

@@ -20,17 +20,27 @@
 // Il cilindro è centrato sull'asse Z e appoggiato sul piano XY.
 // Con intersezione viene restituito true e i parametri in dU1 e dU2.
 //----------------------------------------------------------------------------
-bool IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
-                    double dRad, double dHeight,
-                    double& dU1, double& dU2) ;
+bool
+IntersLineCyl( const Point3d& ptP, const Vector3d& vtV, double dH, double dRad, bool bTapLow, bool bTapUp,
+               double& dU1, Point3d& ptInt1, Vector3d& vtN1, double& dU2, Point3d& ptInt2, Vector3d& vtN2, bool bIgnoreTap = false, bool bInvertNormals = false) ;
+
+// come sopra ma passo il riferimento intrinseco del cilindro in cui portare la linea
+bool
+IntersLineCyl( const Point3d& ptLineSt, const Vector3d& vtLineDir,
+               const Frame3d& CylFrame, double dH, double dRad, bool bTapLow, bool bTapUp,
+               double& dU1, Point3d& ptInt1, Vector3d& vtN1, double& dU2, Point3d& ptInt2, Vector3d& vtN2, bool bIgnoreTap = false, bool bInvertNormals = false) ;
 
 //----------------------------------------------------------------------------
 inline bool
 TestIntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
                    double dRad, double dHeight)
 {
+   Point3d ptInt1, ptInt2 ;
+   Vector3d vtN1, vtN2 ;
    double dU1, dU2 ;
-   return IntersLineCyl( ptL, vtL, dRad, dHeight, dU1, dU2) ;
+   bool bTapLow = false, bTapUp = false ;
+   bool bIgnoreTap = true ;
+   return IntersLineCyl( ptL, vtL, dHeight, dRad, bTapLow, bTapUp, dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, bIgnoreTap) ;
 }
 
 //----------------------------------------------------------------------------
@@ -50,3 +60,12 @@ bool IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
 bool IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
                     const Point3d& ptCyl1, const Point3d& ptCyl2, double dRad,
                     double& dU1, double& dU2) ;
+
+//----------------------------------------------------------------------------
+// // Linea e cilindro sono nel medesimo riferimento.
+// Il cilindro è definito con raggio e altezza. ( la linea è già nel riferimento intrinseco del cilindro)
+// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
+                    double dRad, double dHeight,
+                    double& dU1, double& dU2) ;

IntersLineSurfBez.cpp

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

OffsetCurve3d.cpp

@@ -0,0 +1,794 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2026
+//----------------------------------------------------------------------------
+// File : OffsetCurve3d.cpp       Data : 10.06.26         Versione : 3.1f1
+// Contenuto : Classe per offset di Curve 3d.
+//
+//
+//
+// Modifiche : 10.06.26 DB Creazione modulo.
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "GeoConst.h"
+#include "CurveLine.h"
+#include "CurveComposite.h"
+#include "RemoveCurveDefects.h"
+#include "IntersLineCyl.h"
+#include "/EgtDev/Include/EGkPoint3d.h"
+#include "/EgtDev/Include/EGkPolyLine.h"
+#include "/EgtDev/Include/EGkOffsetCurve3d.h"
+#include "/EgtDev/Include/EGkIntersLinePlane.h"
+#include "/EgtDev/Include/EgtPointerOwner.h"
+#include <algorithm>
+
+using namespace std ;
+
+#define SAVECRVORIG 0
+#define SAVEOFFDIR 0
+#define SAVECYL 0
+#define SAVEOFFSET 0
+#if SAVECRVORIG || SAVEOFFDIR || SAVECYL  || SAVEOFFSET
+   #include "/EgtDev/Include/EGkColor.h"
+   #include "/EgtDev/Include/EGkGeoVector3d.h"
+   vector<IGeoObj*> vGeo ;
+   vector<Color> vCol ;
+   #include "CurveArc.h"
+   #include "/EgtDev/Include/EGkGeoObjSave.h"
+   #include "/EgtDev/Include/EGkStmFromCurves.h"
+#endif
+
+//----------------------------------------------------------------------------
+OffsetCurve3d::~OffsetCurve3d( void)
+{
+   Reset() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OffsetCurve3d::Reset( void)
+{
+   for ( auto& pCrv : m_CrvLst) {
+      if ( pCrv != nullptr) {
+         delete pCrv ;
+         pCrv = nullptr ;
+      }
+   }
+   m_CrvLst.clear() ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OffsetCurve3d::Make( const PNT5AXVECTOR& vPnt5Ax, double dOffDist, int nType)
+{
+   // la funzione è pensata per lavorare con il risultato dell'operazione ProjectCurveOnSurf
+
+   // vOffDir devono essere normalizzati
+   // mi aspetto che siano più o meno perpendicolari alla curva
+
+   // pulisco tutto
+   Reset() ;
+
+   INTVECTOR vFlag ;
+   VCT3DVECTOR vOffDir ;
+   PolyLine PL ;
+   for ( int i = 0 ; i < ssize( vPnt5Ax) ; ++i) {
+      PL.AddUPoint( i, vPnt5Ax[i].ptP) ;
+      vOffDir.push_back( vPnt5Ax[i].vtDir1) ;
+      if ( vPnt5Ax[i].nFlag > 0)
+         vFlag.push_back( vPnt5Ax[i].nFlag) ;
+      else
+         return false ;
+   }
+
+   PtrOwner<CurveComposite> pCrv( CreateBasicCurveComposite()) ;
+   if ( ! pCrv->FromPolyLine( PL))
+      return false ;
+    
+#if SAVECRVORIG  || SAVEOFFDIR
+   vGeo.clear() ;
+   vCol.clear() ;
+
+   vGeo.push_back( pCrv->Clone()) ;
+   vCol.push_back( AQUA) ;
+   #if SAVEOFFDIR
+         Point3d ptBase ; PL.GetFirstPoint( ptBase) ;
+         for ( int i = 0 ; i < ssize( vOffDir) ; ++i) {
+            IGeoVector3d* pVec = CreateGeoVector3d() ;
+            pVec->Set( vOffDir[i] * dOffDist, ptBase) ;
+            PL.GetNextPoint( ptBase) ;
+            vGeo.push_back( pVec) ;
+            vCol.push_back( BLUE) ;
+         }
+   #endif
+   #if ! SAVECYL  &&  ! SAVEOFFSET
+         SaveGeoObj( vGeo, vCol, "C:\\Temp\\curve offset 3d\\crvoffset.nge") ;
+   #endif
+#endif
+
+   // verifico se la curva è un segmento di retta
+   bool bIsLine = PL.GetPointNbr() == 2 ;
+   if ( bIsLine) {
+      // faccio l'offset di una linea
+      return true ;
+   }
+
+   // se offset nullo, copio la curva ed esco
+   if ( abs( dOffDist) < 10 * EPS_SMALL) {
+      PtrOwner<CurveComposite> pCopy( CreateBasicCurveComposite()) ;
+      if ( IsNull( pCopy)  ||  ! pCopy->CopyFrom( pCrv))
+         return false ;
+      // unisco parti allineate (tranne gli estremi)
+      pCopy->MergeCurves( 10 * EPS_SMALL, ANG_TOL_STD_DEG, false) ;
+      // sposto in lista
+      m_CrvLst.push_back( Release( pCopy)) ;
+      return true ;
+   }
+
+   bool bClosed = pCrv->IsClosed() ;
+
+   // identifico le zone circostanti un angolo interno
+   for ( int i = 0 ; i < ssize( vPnt5Ax) ; ++i) {
+      if ( vFlag[i] == OffsetCurve3d::AngType::ANG_CONC) {
+         // scorro indietro e avanti flaggando i tratti da controllare
+         int nPrev = i - 1 ;
+         if ( nPrev < 0)
+            nPrev = ssize( vPnt5Ax) - 1;
+         int nNext = i + 1 ;
+         if ( nNext >= ssize( vPnt5Ax))
+            nNext = 0 ;
+         double dAng = acos( vPnt5Ax[nPrev].vtDir1 * vPnt5Ax[nNext].vtDir1) * RADTODEG ;
+         double dDistAngConc = dOffDist * tan( ( dAng / 2) * DEGTORAD) ;
+         int c = nPrev ;
+         while ( Dist( vPnt5Ax[i].ptP, vPnt5Ax[c].ptP) < dDistAngConc) {
+            vFlag[c] = OffsetCurve3d::AngType::ANG_BEFORE_CONC ;
+            --c ;
+            if ( c < 0) {
+               if ( bClosed)
+                  c = ssize( vPnt5Ax) - 1 ;
+               else
+                  break ;
+            }
+         }
+         vFlag[c] = OffsetCurve3d::AngType::ANG_BEFORE_CONC ;
+         // scorro in avanti
+         c = nNext ;
+         while ( c < ssize( vPnt5Ax) - 1  &&  Dist( vPnt5Ax[i].ptP, vPnt5Ax[c].ptP) < dDistAngConc) {
+            vFlag[c] = OffsetCurve3d::AngType::ANG_AFTER_CONC ;
+            ++c ;
+            if ( c == ssize( vPnt5Ax) - 1) {
+               if ( bClosed)
+                  c = 0 ;
+               else
+                  break ;
+            }  
+         }
+         vFlag[c] = OffsetCurve3d::AngType::ANG_AFTER_CONC ;
+         i = c ;
+      }
+   }
+
+   for ( int i = 1 ; i < ssize( vFlag) - 1 ; ++i) {
+      if ( vFlag[i-1] == OffsetCurve3d::AngType::ANG_SMOOTH_CONC  &&
+         vFlag[i+1] == OffsetCurve3d::AngType::ANG_SMOOTH_CONC &&
+         vFlag[i] != OffsetCurve3d::AngType::ANG_SMOOTH_CONC)
+         vFlag[i] = OffsetCurve3d::AngType::ANG_SMOOTH_CONC ;
+   }
+
+   double dRadCorr ;
+   Point3d ptPrev ; pCrv->GetStartPoint( ptPrev) ;
+   ptPrev += vOffDir[0] * dOffDist ;
+   Vector3d vtCorrPrev ;
+   Vector3d vtTangPrev ;
+   Vector3d vtDirPrev ; pCrv->GetStartDir( vtDirPrev) ;
+   if ( bClosed) {
+      Vector3d vtDirLast ; pCrv->GetEndDir( vtDirLast) ;
+      if ( vFlag[0] != OffsetCurve3d::AngType::ANG_CVEX)
+         vtTangPrev = Media( vtDirLast, vtDirPrev) ;
+      else if ( vFlag[0] == OffsetCurve3d::AngType::ANG_CVEX  &&  vFlag.back() != OffsetCurve3d::AngType::ANG_CVEX)
+         vtTangPrev = vtDirLast ;
+      else
+         vtTangPrev = vtDirPrev ;
+   }
+   const ICurve* pCrvPrev = pCrv->GetFirstCurve() ;
+   const ICurve* pCrvCurr ;
+   OFFSETSEGVEC vOffsetCrvs ;
+   Vector3d vtDirPrevOff  = V_INVALID ;
+   int nRejected = 0 ;
+   int nClosure = bClosed ? 1 : 0 ;
+   bool bCheckingClosure = false ;
+   bool bPlanarConcCvex = false ;
+   for ( int i = 1 ; i <= pCrv->GetCurveCount() + nClosure ; ++i) {
+      int nCurr = i ;
+      int nPrev = i - 1 ;
+      if ( i > pCrv->GetCurveCount()) {
+         nCurr = 0 ;
+         bCheckingClosure = true ;
+      }
+      if ( ! bCheckingClosure)
+         pCrvCurr = pCrv->GetNextCurve() ;
+      if ( pCrvCurr == nullptr  &&  bClosed)
+         pCrvCurr = pCrv->GetFirstCurve() ;
+      Vector3d vtOffDir = vOffDir[nCurr] ;
+      Vector3d vtDirCurr ; 
+      if ( pCrvCurr != nullptr)
+         pCrvCurr->GetStartDir( vtDirCurr) ;
+      else
+         vtDirCurr = vtDirPrev ;
+      pCrvPrev->GetStartDir( vtDirPrev) ;
+      Vector3d vtTang ;
+      // so che ci sono due punti in stretta prossimità dell'angolo, quindi discrimino tra la tangeten prima e dopo l'angolo
+      // negli altri casi faccio la media
+      if ( vFlag[nCurr] != OffsetCurve3d::AngType::ANG_CVEX)
+         vtTang = Media( vtDirCurr, vtDirPrev) ;
+      else if ( vFlag[nCurr] == OffsetCurve3d::AngType::ANG_CVEX  &&  vFlag[nPrev] != OffsetCurve3d::AngType::ANG_CVEX)
+         vtTang = vtDirPrev ;
+      else
+         vtTang = vtDirCurr ;
+      vtTang.Normalize() ;
+      Vector3d vtCorr = vtOffDir ;
+      double dCorrK = 1 ;
+      //if ( vFlag[nCurr] == OffsetCurve3d::AngType::ANG_CONC) {
+      //   double dHalfAlfa = acos( vtTang * vtTangPrev) * RADTODEG ;
+      //   dCorrK = 1 / sin( ( 90 - dHalfAlfa) * DEGTORAD) ;
+      //}
+
+      Point3d ptP ;
+      if ( pCrvCurr != nullptr)
+         pCrvCurr->GetStartPoint( ptP) ;
+      else
+         pCrvPrev->GetEndPoint( ptP) ;
+      dRadCorr = dOffDist ;
+      ptP = ptP + dRadCorr * dCorrK * vtCorr ;
+      // se secondo punto di angolo esterno di fianco, inserisco movimenti intermedi
+      if ( vFlag[nCurr] == OffsetCurve3d::AngType::ANG_CVEX  &&  vFlag[nPrev] == OffsetCurve3d::AngType::ANG_CVEX  &&  bPlanarConcCvex) {
+         double dAlfa = acos( vtTang * vtTangPrev) ;
+         double dDelta = dOffDist * tan( dAlfa / 4) ;
+         Point3d ptAdd1 = ptPrev + dDelta * vtTangPrev ;
+         ICurveLine* pCL1 = CreateBasicCurveLine() ;
+         pCL1->Set( ptPrev, ptAdd1) ;
+         vOffsetCrvs.emplace_back( pCL1, OffsetCurve3d::AngType::ANG_CVEX, -1) ;
+         Point3d ptAdd2 = ptP - dDelta * vtTang ;
+         ICurveLine* pCL2 = CreateBasicCurveLine() ;
+         pCL2->Set( ptAdd1, ptAdd2) ;
+         vOffsetCrvs.emplace_back( pCL2, OffsetCurve3d::AngType::ANG_CVEX, -1) ;
+         ptPrev = ptAdd2 ;
+      }
+      Vector3d vtAng = vtDirPrev ^ vtDirCurr ;
+      const double COS_ANG_MAX_PLANAR = 0.7 ;
+      bPlanarConcCvex = false ;
+      if ( ! vtAng.IsSmall()  &&  vtAng.Normalize())
+         bPlanarConcCvex = abs( vtAng *  vOffDir[nCurr]) < COS_ANG_MAX_PLANAR ;
+
+      if ( ! bCheckingClosure) {
+         Vector3d vtDirCurrOff = ptP - ptPrev ; vtDirCurrOff.Normalize() ;
+         double dProj = 1 ;
+         if ( vtDirPrevOff.IsValid())
+            dProj = vtDirCurrOff * vtDirPrevOff ;
+         // prima di inserirlo controllo che il tratto non torni indietro
+         if ( ( vFlag[nCurr] != ANG_STR  ||  dProj > - 0.966)  && Dist( ptPrev, ptP) > 2 * EPS_SMALL) {
+            // aggiungo tratto
+            ICurveLine* pCL = CreateBasicCurveLine() ;
+            pCL->Set( ptPrev, ptP) ;
+            vOffsetCrvs.emplace_back( pCL, vFlag[nCurr], i - 1) ;
+            // aggiorno punto precedente
+            ptPrev = ptP ;
+            vtCorrPrev = vtCorr ;
+            vtTangPrev = vtTang ;
+            vtDirPrev = vtDirCurr ;
+            if ( i < pCrv->GetCurveCount())
+               pCrvPrev = pCrvCurr ;
+            vtDirPrevOff = vtDirCurrOff ;
+         }
+         else
+            ++nRejected ;
+      }
+   }
+
+   // se chiusa aggiungo il tratto di chiusura
+   if ( bClosed) {
+      Point3d ptPS ; vOffsetCrvs.front().pCrv->GetStartPoint( ptPS) ;
+      ICurveLine* pCL = CreateBasicCurveLine() ;
+      Point3d ptPE ; vOffsetCrvs.back().pCrv->GetEndPoint( ptPE) ;
+      pCL->Set( ptPE, ptPS) ;
+      // aggiungo solo se valida, quindi se non sono già coincidenti
+      if ( pCL->IsValid())
+         vOffsetCrvs.emplace_back( pCL, OffsetCurve3d::AngType::ANG_STR, -1) ;
+   }
+
+   // qui faccio la correzione per gli angoli interni
+   EDITCRVINFOVEC vEditInfo ;
+   if ( ! CalcAdjustConcavePartsInPath( pCrv, vOffsetCrvs, dOffDist, vEditInfo))
+      return false ;
+
+   if ( nType == OFFTYPE::PLANECUT) {
+      if ( ! CalcAdjustConcavePartsPlaneCut( pCrv, vPnt5Ax, vOffsetCrvs, dOffDist, vEditInfo))
+         return false ;
+   }
+
+   // applico le modifiche calcolate
+   for ( int i = ssize( vEditInfo) - 1 ; i >= 0 ; --i) {
+      if ( vEditInfo[i].nFlag == EditCrvInfo::NOEDIT)
+         continue ;
+      else if ( vEditInfo[i].nFlag == EditCrvInfo::DEL)
+         vOffsetCrvs.erase( vOffsetCrvs.begin() + i) ;
+      else if ( vEditInfo[i].nFlag == EditCrvInfo::EDIT) {
+         if ( vEditInfo[i].ptStart.IsValid())
+            vOffsetCrvs[vEditInfo[i].nId].pCrv->ModifyStart( vEditInfo[i].ptStart) ;
+         if ( vEditInfo[i].ptEnd.IsValid())
+            vOffsetCrvs[vEditInfo[i].nId].pCrv->ModifyEnd( vEditInfo[i].ptEnd) ;
+         vOffsetCrvs[vEditInfo[i].nId].nParent = -2 ;
+      }
+   }
+
+   // scorro tutto il vettore delle linee di offset e unisco aggiungendo una linea dove ne ho cancellate
+   for ( int i = 0 ; i < ssize( vOffsetCrvs) - 1 ; ++i) {
+      Point3d ptEndCurr, ptStartNext ;
+      vOffsetCrvs[i].pCrv->GetEndPoint( ptEndCurr) ;
+      vOffsetCrvs[i+1].pCrv->GetStartPoint( ptStartNext) ;
+      if ( ! AreSamePointApprox( ptEndCurr, ptStartNext)) {
+         ICurveLine* pCL = CreateBasicCurveLine() ;
+         pCL->Set( ptEndCurr, ptStartNext) ;
+         vOffsetCrvs.emplace_back( pCL, OffsetCurve3d::AngType::ANG_STR,-1) ;
+         rotate( vOffsetCrvs.begin() + i + 1, vOffsetCrvs.end() - 1, vOffsetCrvs.end()) ;
+         ++i ;
+      }
+   }
+
+#if SAVEOFFSET  || SAVECYL
+   #if SAVEOFFSET
+      for ( int i = 0 ; i < ssize( vOffsetCrvs) ; ++i) {
+         vGeo.push_back( vOffsetCrvs[i].pCrv->Clone()) ;
+         if ( vOffsetCrvs[i].nParent == -2)
+            vCol.push_back( LIME) ;
+         else if ( vOffsetCrvs[i].nFlag == OffsetCurve3d::AngType::ANG_SMOOTH_CONC)
+            vCol.push_back( GREEN) ;
+         else if ( vOffsetCrvs[i].nFlag == OffsetCurve3d::AngType::ANG_STR)
+            vCol.push_back( PURPLE) ;
+         else if ( vOffsetCrvs[i].nFlag == OffsetCurve3d::AngType::ANG_CVEX)
+            vCol.push_back( RED) ;
+         else if ( vOffsetCrvs[i].nFlag == OffsetCurve3d::AngType::ANG_BEFORE_CONC)
+            vCol.push_back( OLIVE) ;
+         else if ( vOffsetCrvs[i].nFlag == OffsetCurve3d::AngType::ANG_AFTER_CONC)
+            vCol.push_back( YELLOW) ;
+         else if ( vOffsetCrvs[i].nFlag == OffsetCurve3d::AngType::ANG_CONC)
+            vCol.push_back( Color(0,64,0)) ; //dark green
+      }
+   #endif
+   SaveGeoObj( vGeo, vCol, "C:\\Temp\\curve offset 3d\\crvoffset.nge") ;
+#endif
+
+   // qua andrebbe gestito con una chain ( ptorebbero essere più di una curva)
+   PtrOwner<ICurveComposite> pCrvOffset( CreateBasicCurveComposite()) ;
+   for ( int i = 0 ; i < ssize( vOffsetCrvs) ; ++i) {
+      if ( ! pCrvOffset->AddCurve( Release( vOffsetCrvs[i].pCrv)))
+         return false ;
+   }
+   m_CrvLst.push_back( Release( pCrvOffset)) ;
+
+   return true ;
+
+   // raccordi
+
+   //// ordino le curve in ordine decrescente di lunghezza
+   //if ( m_CrvLst.size() > 1) {
+   //   for ( auto pCrv : m_CrvLst) {
+   //      double dLen ;
+   //      if ( pCrv->GetLength( dLen))
+   //         pCrv->SetTempProp( int( 1000 * dLen)) ;
+   //      else
+   //         pCrv->SetTempProp( 0) ;
+   //   }
+   //   m_CrvLst.sort( []( const ICurve* pA, const ICurve* pB) { return ( pA->GetTempProp() > pB->GetTempProp()) ; }) ;
+   //}
+
+   //// se originale era chiusa, verifico le risultanti e se necessario cerco di chiuderle
+   //if ( bClosed) {
+   //   for ( auto pCrv : m_CrvLst) {
+   //      CurveComposite* pCrvCo = GetBasicCurveComposite( pCrv) ;
+   //      if ( pCrvCo != nullptr)
+   //         pCrvCo->Close() ;
+   //   }
+   //}
+
+   //return true ;
+}
+
+//----------------------------------------------------------------------------
+ICurve*
+OffsetCurve3d::GetCurve( void)
+{
+   return GetLongerCurve() ;
+}
+
+//----------------------------------------------------------------------------
+ICurve*
+OffsetCurve3d::GetLongerCurve( void)
+{
+   if ( m_CrvLst.empty())
+      return nullptr ;
+   // le curve sono ordinate in senso decrescente di lunghezza
+   ICurve* pCrv = m_CrvLst.front() ;
+   m_CrvLst.pop_front() ;
+   return pCrv ;
+}
+
+//----------------------------------------------------------------------------
+ICurve*
+OffsetCurve3d::GetShorterCurve( void)
+{
+   if ( m_CrvLst.empty())
+      return nullptr ;
+   // le curve sono ordinate in senso decrescente di lunghezza
+   ICurve* pCrv = m_CrvLst.back() ;
+   m_CrvLst.pop_back() ;
+   return pCrv ;
+}
+
+//----------------------------------------------------------------------------
+bool
+IsPointInsideCylinder( const Point3d& ptTest, const Cyl& offCyl, double dLinTol)
+{
+   Point3d ptTestLoc = ptTest ; ptTestLoc.ToLoc( offCyl.frCyl) ;
+   if ( ptTestLoc.z > offCyl.dH  ||  ptTestLoc.z < 0)
+      return false ;
+   double dDist = ptTestLoc.x * ptTestLoc.x + ptTestLoc.y * ptTestLoc.y ;
+   double dRadSq = ( offCyl.dRad - dLinTol) * ( offCyl.dRad - dLinTol) ;
+   if ( dDist > dRadSq)
+      return false ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CalcAdjustConcavePartsInPath( const ICurveComposite* pCrv, const OFFSETSEGVEC& vOffsetCrvs, double dRad, EDITCRVINFOVEC& vEditInfo)
+{
+   const double dLinTol = 0 * EPS_SMALL ;
+   for ( int i = 0 ; i < ssize( vOffsetCrvs) ; ++i) {
+      int nFlag = vOffsetCrvs[i].nFlag ;
+      // considero tutt le zone concave
+      if ( nFlag >= OffsetCurve3d::AngType::ANG_CONC) {
+         // scorro i prossimi finchè trovo la fine della zona concava
+         // controllo se devo considerare anche tratti prima dello start
+         INTVECTOR vLines ;
+         if ( i == 0) {
+            INTVECTOR vLinesAdd ;
+            int c = ssize( vOffsetCrvs) - 1 ;
+            nFlag = vOffsetCrvs[c].nFlag ;
+            while ( nFlag >= OffsetCurve3d::AngType::ANG_CONC) {
+               vLinesAdd.push_back( c) ;
+               --c ;
+               if ( c > 0)
+                  nFlag = vOffsetCrvs[c].nFlag ;
+            }
+            // inserisco il vettore al contrario, in modo che sia in ordine crescente
+            vLines.insert( vLines.end(), vLinesAdd.rbegin(), vLinesAdd.rend()) ;
+         }
+         bool bDone = false ;
+         nFlag = vOffsetCrvs[i].nFlag ;
+         while ( nFlag >= OffsetCurve3d::AngType::ANG_CONC) {
+            vLines.push_back( i) ;
+            ++i ;
+            if ( i < ssize( vOffsetCrvs))
+               nFlag = vOffsetCrvs[i].nFlag ;
+            else {
+               bDone = true ;
+               break ;
+            }
+         }
+         // se sto ricominciando, esco dal for ( il tratto finale è già stato considerato insieme al tratto iniziale)
+         if ( bDone)
+            break ;
+         CYLVECT vCyl ;
+         // creo un cilindro della dimensione del raggio
+         for ( int j = 0 ; j < ssize( vLines) ; ++j) {
+            if ( vOffsetCrvs[vLines[j]].nParent == -1)
+               continue ;
+            const ICurve* pSubCrv = pCrv->GetCurve( vOffsetCrvs[vLines[j]].nParent) ;
+            Point3d ptStart, ptEnd ;
+            pSubCrv->GetStartPoint( ptStart) ;
+            pSubCrv->GetEndPoint( ptEnd) ;
+            // cilindri con asse sul parent
+            Vector3d vtHeight = ptEnd - ptStart ;
+            double dHeight = vtHeight.Len() ;
+            vtHeight.Normalize() ;
+            vCyl.emplace_back( ptStart, vtHeight, dHeight, dRad, dLinTol) ;
+#if SAVECYL
+            CurveArc ca ; ca.Set( ptStart, vtHeight, dRad) ;
+            ISurfTriMesh* pSurfTm = GetSurfTriMeshByExtrusion( &ca, vtHeight * dHeight, false, 2 * EPS_SMALL) ;
+            vGeo.push_back( pSurfTm) ;
+            vCol.push_back( LGRAY) ;
+#endif
+         }
+
+         // controllo l'end di ogni linea per verificare se sta nel cilindro definito da uno degli altri tratti
+         // controllo tutto i punti
+         bool bErasedSomePart = false ;
+         bool bCheckStart = false ;
+         vector<INTINTVECTOR> vEditZones ;
+         for ( int j = 0 ; j < ssize( vLines) ; ++j) {
+            Point3d ptStart, ptEnd ;
+            const ICurve* pSubCrv = vOffsetCrvs[vLines[j]].pCrv ;
+            if ( pSubCrv == nullptr)
+               return false ;
+            pSubCrv->GetEndPoint( ptEnd) ;
+            pSubCrv->GetStartPoint( ptStart) ;
+            // se stanno in uno dei cilindri degli altri tratti della zona concava
+            bool bToErase = false ;
+            for ( int k = 0 ; k < ssize( vCyl) ; ++k) {
+               if ( j == k)
+                  continue ;
+               bToErase = IsPointInsideCylinder( ptEnd, vCyl[k], dLinTol) ;
+               bool bStartInsideCyl = false ;
+               if ( bCheckStart  &&  ! bToErase) {
+                  bStartInsideCyl = IsPointInsideCylinder( ptStart, vCyl[k], dLinTol) ;
+                  bToErase = bToErase || bStartInsideCyl ;
+               }
+               if ( bToErase) {                 
+                  bErasedSomePart = true ;
+                  if ( ! bStartInsideCyl)
+                     bCheckStart = true ;
+
+                  if ( vEditZones.empty()  ||  vEditZones.back().back().first != vLines[j-1])
+                     vEditZones.emplace_back() ;
+                  vEditZones.back().emplace_back( vLines[j], j) ;
+                  if ( ! bStartInsideCyl  &&  j < ssize( vLines) - 1) {
+                     vEditZones.back().emplace_back( vLines[j+1], j + 1) ;
+                     ++j ;
+                  }
+                  break ;
+               }
+            }
+            if ( ! bToErase) {
+               bCheckStart = false ;
+               vEditInfo.emplace_back( vLines[j], EditCrvInfo::NOEDIT) ;
+            }
+         }
+         if ( bErasedSomePart) {
+            // calcolo le intersezioni effettive del primo e ultimo tratto cancellati con i cilindri che li hanno cancellati
+            for ( int z = 0 ; z < ssize( vEditZones) ; ++z) {
+               INTINTVECTOR& vInters = vEditZones[z] ;
+               if ( ssize( vInters) == 1)
+                  continue ;
+               for ( int j = 0 ; j < ssize( vInters) ; ++j) {
+                  // cancello i tratti intermedi
+                  if ( j > 0 && j < ssize( vInters) - 1) {
+                     vEditInfo.emplace_back( vInters[j].first, EditCrvInfo::DEL) ;
+                     continue ;
+                  }
+                  // per il primo e ultimo controllo le intersezioni con tutti i cilindri
+                  PtrOwner<ICurve> pCL ( vOffsetCrvs[vInters[j].first].pCrv->Clone()) ;
+                  Point3d ptStart ; pCL->GetStartPoint( ptStart) ;
+                  Vector3d vtStart ; pCL->GetStartDir( vtStart) ;
+                  double dLen ; pCL->GetLength( dLen) ;
+                  double dUTrim = ( j == 0 ? INFINITO : 0) ;
+                  Point3d ptTrim = P_INVALID ;
+                  for ( int k = 0 ; k < ssize( vCyl) ; ++k) {
+                     if ( vInters[j].second == k)
+                        continue ;
+                     Point3d ptInt1 = P_INVALID, ptInt2 = P_INVALID ;
+                     double dU1, dU2 ;
+                     Vector3d vtN1, vtN2 ;
+                     if ( IntersLineCyl( ptStart, vtStart * dLen, vCyl[k].frCyl, vCyl[k].dH, vCyl[k].dRad, false, false, dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, true)) {
+                        bool bUpdate = ( j == 0 ? dU1 < dUTrim : dU1 > dUTrim) ;
+                        bUpdate = bUpdate &&  ptInt1.IsValid() &&  dU1 > 0  &&  dU1 < 1 ;
+                        bUpdate = bUpdate &&  vtN1 * vtStart < 0 ;
+                        if ( bUpdate) {
+                           dUTrim = dU1 ;
+                           ptTrim = ptInt1 ;
+                        }
+                        bUpdate = ( j == 0 ? dU2 < dUTrim : dU2 > dUTrim) ;
+                        bUpdate = bUpdate &&  ptInt2.IsValid() &&  dU2 > 0  &&  dU2 < 1 ;
+                        bUpdate = bUpdate &&  vtN2 * vtStart > 0 ;
+                        if ( bUpdate) {
+                           dUTrim = dU2 ;
+                           ptTrim = ptInt2 ;
+                        }
+                     }
+                  }
+                  if ( j == 0) {
+                     if ( ptTrim.IsValid()) {
+                        bool bOk = pCL->ModifyEnd( ptTrim) ;
+                        double dNewLen ;
+                        if ( bOk)
+                           pCL->GetLength( dNewLen) ;
+                        if ( ( ! bOk  || dNewLen < 0.1)  &&  vInters[0].first != 0) {  // se fosse il primo allora potrei modificare il successivo
+                           int nPrev = vInters[0].first - 1 ;
+                           vInters[0].first = nPrev ;
+                           int c = 1 ;
+                           while( vEditInfo.end()[-c].nId != nPrev)
+                              ++c ;
+                           vEditInfo.end()[-c].nFlag = EditCrvInfo::EDIT ;
+                           vEditInfo.end()[-c].ptEnd = ptTrim ;
+                           vEditInfo.emplace_back( nPrev + 1, EditCrvInfo::DEL) ;
+                        }
+                        else
+                           vEditInfo.emplace_back( vInters[0].first, EditCrvInfo::EDIT, P_INVALID, ptTrim) ;
+                     }
+                     else
+                        vEditInfo.emplace_back( vInters[0].first, EditCrvInfo::EDIT, P_INVALID, P_INVALID) ;
+                  }
+                  else {
+                     if ( ptTrim.IsValid()) {
+                        bool bOk = pCL->ModifyStart( ptTrim) ;
+                        double dNewLen ;
+                        if ( bOk)
+                           pCL->GetLength( dNewLen) ;
+                        if ( ( ! bOk  ||  dNewLen < 0.1)  &&  vInters[j].first != ssize( vOffsetCrvs) - 1) {  // se fosse l'ultima curva allora potrei modificare la precedente
+                           int nNext = vInters[j].first + 1 ;
+                           vInters[j].first = nNext ;
+                           vEditInfo.emplace_back( nNext - 1, EditCrvInfo::DEL) ;
+                           int c = 1 ;
+                           while ( vEditInfo.end()[-c].nId != nNext  && c < ssize( vEditInfo))
+                              ++c ;
+                           if ( vEditInfo.end()[-c].nId == nNext) {
+                              vEditInfo.end()[-c].nFlag = EditCrvInfo::EDIT ;
+                              vEditInfo.end()[-c].ptStart = ptTrim ;
+                           }
+                           else
+                              vEditInfo.emplace_back( nNext, EditCrvInfo::EDIT, ptTrim, P_INVALID) ;
+                        }
+                        else
+                           vEditInfo.emplace_back( vInters[j].first, EditCrvInfo::EDIT, ptTrim, P_INVALID) ;
+                     }
+                     else
+                        vEditInfo.emplace_back( vInters[j].first, EditCrvInfo::EDIT, P_INVALID, P_INVALID) ;
+                  }
+               }
+            }
+         }
+         i = vLines.back() ;
+      }
+      else {
+         if ( vEditInfo.empty()  ||  vEditInfo.back().nId != i)
+            vEditInfo.emplace_back( i, EditCrvInfo::NOEDIT) ;
+      }   
+   }
+
+   sort( vEditInfo.begin(), vEditInfo.end(), []( EditCrvInfo& a, EditCrvInfo& b) { return a.nId < b.nId ;}) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CalcAdjustConcavePartsPlaneCut( const ICurveComposite* pCrv, const PNT5AXVECTOR& vPnt5Ax, const OFFSETSEGVEC& vOffsetCrvs,
+                                double dRad, EDITCRVINFOVEC& vEditInfo)
+{
+   // calcolo come tagliare il percorso negli angoli misti concavo/convesso
+   // il taglio al percorso lo faccio usando il piano definito dalla direzione di offset
+   // se una delle due direzioni è perpendicolare al piano formato dai due tratti, la cui joint è il punto corrente, allora non faccio nulla
+   for ( int i = 0 ; i < ssize( vOffsetCrvs) ; ++i) {
+      if ( vOffsetCrvs[i].nFlag == OffsetCurve3d::AngType::ANG_CVEX) {
+         // se ho 2 tratti convex di fila, ho un convex non planar e se ho anche un angolo importante tra i due lati, devo correggere
+         // se ho 4 tratti convex di fila, ho un convex planar e non devo fare nulla
+         int c = 1 ;
+         while ( i + c < ssize( vOffsetCrvs)  &&  vOffsetCrvs[i + c].nFlag == OffsetCurve3d::AngType::ANG_CVEX)
+            ++c ;
+         if ( c == 4) {
+            i += 3 ;
+            continue ;
+         }
+
+         // trovo i due piani e taglio i tratti prima e dopo lo spigolo
+         int nParent = vOffsetCrvs[i].nParent ;  // sottocurva di pCrv che ha generato il tratto di offset
+         Point3d pt ; pCrv->GetCurve( nParent)->GetEndPoint( pt) ;
+         int nNextParent = nParent + 1 ;
+         bool bCheckingStart = false ;
+         if ( nNextParent > pCrv->GetCurveCount() - 1) {
+            if ( ! pCrv->IsClosed())
+               return false ;
+            nNextParent = 0 ;
+            bCheckingStart = true ;
+         }
+         Vector3d vtDirNext ; pCrv->GetCurve( nNextParent)-> GetStartDir( vtDirNext) ;
+         Vector3d vtDirPrev ; pCrv->GetCurve( nParent)-> GetEndDir( vtDirPrev) ;
+         // punti che rappresentano la pCrv ( quindi pCrv->GetCurveCount() == ssize( vPnt5Ax) - 1)
+         Vector3d vtNNext ;
+         Vector3d vtNPrev ;
+         if ( ! bCheckingStart) {
+            vtNNext = vPnt5Ax[nNextParent].vtDir2 ^ vtDirNext ;
+            vtNPrev = vPnt5Ax[nNextParent].vtDir1 ^ vtDirPrev ;
+         }
+         else {
+            vtNNext = vPnt5Ax[nNextParent].vtDir1 ^ vtDirNext ;
+            vtNPrev = vPnt5Ax[nNextParent].vtDir2 ^ vtDirPrev ;
+         }
+         Plane3d plNext ; plNext.Set( pt, vtNNext) ;
+         Plane3d plPrev ; plPrev.Set( pt, vtNPrev) ;
+         Point3d ptPrev ;
+         Point3d ptNext ;
+         // interseco con il piano precedente prendendo i tratti successivi
+         bool bFound = false ;
+         // parto a confrontare i segmenti successivi a quelli identificati come concavi
+         if ( ! bCheckingStart)
+            c = i + 2 ;
+         else  // se sono arrivato a fine curva di una curva chiusa controllo con lo start
+            c = 1 ;
+         while ( ! bFound  &&  c > 0) {
+            Point3d ptInt ;
+            Point3d ptStart, ptEnd ;
+            vOffsetCrvs[c].pCrv->GetStartPoint( ptStart) ;
+            vOffsetCrvs[c].pCrv->GetEndPoint( ptEnd) ;
+            IntersLinePlane( ptStart, ptEnd, plPrev, ptInt, false) ;
+            Vector3d vtDir ; vOffsetCrvs[c].pCrv->GetStartDir( vtDir) ;
+            double dLen ; vOffsetCrvs[c].pCrv->GetLength( dLen) ;
+            double dU = ( ptInt - ptStart).Len() / dLen ;
+            if ( vtDir * ( ptInt - ptStart) < 0)
+               dU *= -1 ;
+            if ( dU < 1) {
+               ptNext = ptInt ;
+               bFound = true ;
+            }
+            else
+               ++c ;
+         }
+         // salvo la modifica nel vettore edit
+         int nNext = c ;
+         vEditInfo[c].nFlag = EditCrvInfo::EditFlag::EDIT ;
+         vEditInfo[c].ptStart = ptNext ;
+
+         // interseco con il piano successivo prendendo i tratti precedenti
+         bFound = false ;
+         c = i - 1 ;
+         while ( ! bFound  &&  c < ssize( vOffsetCrvs)) {
+            Point3d ptInt ;
+            Point3d ptStart, ptEnd ;
+            vOffsetCrvs[c].pCrv->GetStartPoint( ptStart) ;
+            vOffsetCrvs[c].pCrv->GetEndPoint( ptEnd) ;
+            IntersLinePlane( ptStart, ptEnd, plNext, ptInt, false) ;
+            Vector3d vtDir ; vOffsetCrvs[c].pCrv->GetStartDir( vtDir) ;
+            double dLen ; vOffsetCrvs[c].pCrv->GetLength( dLen) ;
+            double dU = ( ptInt - ptStart).Len() / dLen ;
+            if ( vtDir * ( ptInt - ptStart) < 0)
+               dU *= -1 ;
+            if ( dU > 0) {
+               ptPrev = ptInt ;
+               bFound = true ;
+            }
+            else
+               --c ;
+         }
+         // salvo la modifica nel vettore edit
+         int nPrev = c ;
+         vEditInfo[c].nFlag = EditCrvInfo::EditFlag::EDIT ;
+         vEditInfo[c].ptEnd = ptPrev ;
+
+         // tengo solo il punto più esterno
+         double dLen1 = Dist( ptPrev, pt) ;
+         double dLen2 = Dist( ptNext, pt) ;
+         if ( dLen1 > dLen2)
+            vEditInfo[nNext].ptStart = ptPrev ;
+         else
+            vEditInfo[nPrev].ptStart = ptNext ;
+
+         // setto come da cancellare tutti i tratti nel mezzo
+         if ( ! bCheckingStart) {
+            c = nPrev + 1 ;
+            while ( c < nNext) {
+               vEditInfo[c].nFlag = EditCrvInfo::EditFlag::DEL ;
+               ++c ;
+            }
+         }
+         else {
+            c = nPrev + 1 ;
+            while ( c < ssize( vEditInfo)) {
+               vEditInfo[c].nFlag = EditCrvInfo::EditFlag::DEL ;
+               ++c ;
+            }
+            c = 0 ;
+            while ( c < nNext) {
+               vEditInfo[c].nFlag = EditCrvInfo::EditFlag::DEL ;
+               ++c ;
+            }
+         }
+
+         if ( ! bCheckingStart)
+            i = nNext ;
+      }
+   }
+
+   return true ;
+}

PolyLine.cpp

@@ -761,7 +761,7 @@ DouglasPeuckerSimplification( const PNTUVECTOR& vPtU, const double dSqTol, const
 
   // 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) {
+   if (  dMaxSqDist > dSqTol) {
      // inserisco il punto
       vInd.push_back( nMaxInd) ;
      // split
@@ -775,7 +775,7 @@ DouglasPeuckerSimplification( const PNTUVECTOR& vPtU, const double dSqTol, const
 
 //----------------------------------------------------------------------------
 bool
-PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd)
+PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd, double dMaxLen)
 {
   // se non ci sono almeno 3 punti, esco subito
    if ( m_lUPoints.size() < 3)
@@ -792,34 +792,65 @@ PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd)
   // vettore indici dei punti rimanenti
    INTVECTOR vInd ; vInd.reserve( vPtU.size()) ;
 
-  // se aperta
-   if ( ! IsClosed()) {
-     // considero tutti i punti della PolyLine
-      vInd.push_back( 0) ;
-      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, int( vPtU.size()) - 1, vInd))
-         return false ;
-      vInd.push_back( int( vPtU.size()) - 1) ;
-   }
-  // altrimenti chiusa
-   else {
-     // cerco il punto più distante dal primo
-      double dMaxDist = 0. ;
-      int nMaxInd = 0 ;
-      for ( int i = 1 ; i < int( vPtU.size()) ; ++ i) {
-         double dCurrDist = Dist( vPtU[0].first, vPtU[i].first) ;
-         if ( dCurrDist > dMaxDist) {
-            dMaxDist = dCurrDist ;
-            nMaxInd = i ;
-         }
+   if ( dMaxLen > INFINITO - 1) {
+     // se aperta
+      if ( ! IsClosed()) {
+        // considero tutti i punti della PolyLine
+         vInd.push_back( 0) ;
+         if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, int( vPtU.size()) - 1, vInd))
+            return false ;
+         vInd.push_back( int( vPtU.size()) - 1) ;
+      }
+     // altrimenti chiusa
+      else {
+        // cerco il punto più distante dal primo
+         double dMaxDist = 0. ;
+         int nMaxInd = 0 ;
+         for ( int i = 1 ; i < int( vPtU.size()) ; ++ i) {
+            double dCurrDist = Dist( vPtU[0].first, vPtU[i].first) ;
+            if ( dCurrDist > dMaxDist) {
+               dMaxDist = dCurrDist ;
+               nMaxInd = i ;
+            }
+         }
+        // recupero due PolyLine di approssimazione
+         vInd.push_back( 0) ;
+         if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, nMaxInd, vInd))
+            return false ;
+         vInd.push_back( nMaxInd) ;
+         if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, nMaxInd, int( vPtU.size()) - 1, vInd))
+            return false ;
+         vInd.push_back( int( vPtU.size()) - 1) ;
+      }
+   }
+   else {
+      // raggruppo i punti della polyline a gruppi che stanno entro la lunghezza massima e ad ognuno applico Douglas
+      vInd.push_back(0) ;
+
+      int i = 0 ;
+      while ( i < ssize(vPtU) - 1) {
+         int nLast = i + 1 ;
+         while ( nLast < ssize( vPtU) && Dist( vPtU[i].first, vPtU[nLast].first) <= dMaxLen)
+            ++nLast ;
+
+         // l'ultimo punto era oltre il limite
+         --nLast ;
+
+         // sicurezza: almeno un passo avanti
+         if ( nLast == i)
+            nLast = i + 1 ;
+
+         // mantieni l'estremo del tratto
+         if ( vInd.back() != nLast)
+            vInd.push_back( nLast) ;
+
+         // semplifica il tratto interno
+         if ( nLast - i > 1) {
+            if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, i, nLast, vInd))
+               return false ;
+         }
+         i = nLast ;
       }
-     // recupero due PolyLine di approssimazione
-      vInd.push_back( 0) ;
-      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, nMaxInd, vInd))
-         return false ;
-      vInd.push_back( nMaxInd) ;
-      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, nMaxInd, int( vPtU.size()) - 1, vInd))
-         return false ;
-      vInd.push_back( int( vPtU.size()) - 1) ;
    }
 
   // ordino in senso crescente
@@ -1618,6 +1649,9 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
    int nPnt2 = PL2.GetPointNbr() ;
    if ( nPnt1 == 0 || nPnt2 == 0)
       return false ;
+
+   bool bClosed1 = PL1.IsClosed() ;
+   bool bClosed2 = PL2.IsClosed() ;
  
   // indica la presenza di punti interni in comune tra le due polylines
    bCommonInternalPoints = false ;
@@ -1663,6 +1697,10 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
       if ( nMinJ < nLastJ)
          nMinJ = nLastJ ;
 
+     // se la curva è chiusa il primo e l'ultimo punto coincidono, verifico quale conviene considerare
+      if ( bClosed2  &&  nMinJ == nTotP2 - 1  &&  nLastJ == 0)
+         nMinJ = 0 ;
+
      // 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 ;
@@ -1693,6 +1731,9 @@ AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIV
 
       if ( nMinI < nLastI)
          nMinI = nLastI ;
+      
+      if ( bClosed1  &&  nMinI == nTotP1 - 1  &&  nLastI == 0)
+         nMinI = 0 ;
 
       if ( j < nTotP2 - 1  &&  dDist < EPS_SMALL &&  abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
          bCommonInternalPoints = true ;
@@ -1991,17 +2032,11 @@ MatchPolyLinesAddingPoints( const PolyLine& PL1, const PolyLine& PL2, int nType,
    nAddedSpan = 0 ;
    nCrv1 = 0 ;
    nCrv2 = 0 ;
-   bool bLast1 = false ;
-   bool bLast2 = false ;
    while ( nAddedSpan < nPnt) {
-      if ( nCrv1 >= nPnt1) {
+      if ( nCrv1 >= nPnt1)
          nCrv1 = nPnt1 - 1 ;
-         bLast1 = true ;
-      }
-      if ( nCrv2 >= nPnt2) {
+      if ( nCrv2 >= nPnt2)
          nCrv2 = nPnt2 - 1 ;
-         bLast2 = true ;
-      }
       bool bRep1 = vbRep1[nCrv1] ;
       bool bRep2 = vbRep2[nCrv2] ;
       const ICurve* pSubCrv1 = cc1.GetCurve( nCrv1) ;

Polygon3d.cpp

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

ProjectCurveSurf.cpp

@@ -13,12 +13,14 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
+#include <cmath>
 #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/EGkDistPointSurfBz.h"
 #include "/EgtDev/Include/EGkIntersPlanePlane.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
@@ -31,14 +33,6 @@ using namespace std ;
 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
@@ -63,6 +57,7 @@ PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext,
 static bool
 AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
 {
+   const double dSinSmallAngle = sin( 0.5 * DEGTORAD) ;
    for ( int i = 1 ; i < ssize( vPt5ax) ; ++ i) {
      // precedente
       int j = i - 1 ;
@@ -78,20 +73,51 @@ AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
             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) ;
+               double dProjPrev = ( vPt5ax[i].ptP - vPt5ax[j].ptP) * vPt5ax[j].vtDir1 ;
+               double dProjCurr = ( vPt5ax[j].ptP - vPt5ax[i].ptP) * vPt5ax[i].vtDir1 ;
+               bool bConvex = ( abs( dProjCurr) > abs( dProjPrev) ? dProjCurr < 0 : dProjPrev < 0) ;
+               int nPrev = i - 1 ;
+               if ( i < ssize( vPt5ax) - 2  &&  ! AreSameVectorExact(vPt5ax[i - 1].vtDir1, vPt5ax[i - 1].vtDir2)) {
+                  int z = nPrev - 1 ;
+                  // se vtDir1 e vtDir2 sono diverse allora sono su uno spigolo
+                  double dProjPrev2 = ( vPt5ax[z].ptP - vPt5ax[nPrev].ptP) * vPt5ax[nPrev].vtDir2 ;
+                  double dProjCurr2 = ( vPt5ax[i].ptP - vPt5ax[nPrev].ptP) * vPt5ax[nPrev].vtDir1 ;
+                  // se uno dei due è convesso allora considero convesso l'angolo
+                  bConvex = dProjPrev2 < EPS_SMALL  ||  dProjCurr2 < EPS_SMALL ;
+               }
+               bool bValidIntersAfterJ = true ;
+               bool bValidIntersBeforeI = true ;
+               if ( i > 2) {
+                  // verifico che l'intersezione sia tra i e j e non prima di j
+                  int k = i - 2 ;
+                  bValidIntersAfterJ = ( ptInt - vPt5ax[j].ptP) * ( vPt5ax[j].ptP - vPt5ax[k].ptP) > 0 ;
+                  bool bBetweenIAndJ = ( ptInt - vPt5ax[j].ptP) * ( vPt5ax[i].ptP - vPt5ax[j].ptP) > 0 ;
+                  bValidIntersAfterJ = bValidIntersAfterJ && bBetweenIAndJ ;
+               }
+               if ( i < ssize( vPt5ax) - 1) {
+                  // verifico anche che l'intersezione non sia dopo i
+                  int h = i + 1 ;
+                  bValidIntersBeforeI = ( ptInt - vPt5ax[i].ptP) * ( vPt5ax[h].ptP - vPt5ax[i].ptP) < 0 ;
+                  bool bBetweenIAndJ = ( ptInt - vPt5ax[i].ptP) * ( vPt5ax[i].ptP - vPt5ax[j].ptP) < 0 ;
+                  bValidIntersBeforeI = bValidIntersBeforeI && bBetweenIAndJ ;
+               }
+               bool bValidInters = ( bValidIntersAfterJ  &&  bValidIntersBeforeI) ;
               // 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) {
+                  if ( dLen1 > 10 * EPS_SMALL  &&  bValidIntersAfterJ) {
                      Point5ax Pt5ax ;
-                     Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
+                     if ( bValidInters)
+                        Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
+                     else {
+                        Vector3d vtNewLine = vPt5ax[i].ptP - vPt5ax[j].ptP ; vtNewLine.Normalize() ;
+                        Pt5ax.ptP =  vPt5ax[i].ptP - vtNewLine * 2 * EPS_SMALL ;
+                     }
                      Pt5ax.vtDir1 = vPt5ax[j].vtDir1 ;
                      Pt5ax.vtDir2 = vPt5ax[j].vtDir2 ;
+                     Pt5ax.vtDirU = vPt5ax[j].vtDirU ;
+                     Pt5ax.vtDirV = vPt5ax[j].vtDirV ;
                      Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
                      Pt5ax.nFlag = P5AX_CVEX ;
                      vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
@@ -99,11 +125,18 @@ AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
                   }
                   else
                      vPt5ax[j].nFlag = P5AX_CVEX ;
-                  if ( dLen2 > 2 * EPS_SMALL) {
+                  if ( dLen2 > 10 * EPS_SMALL  && bValidIntersBeforeI) {
                      Point5ax Pt5ax ;
-                     Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
+                     if ( bValidInters)
+                        Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
+                     else {
+                        Vector3d vtNewLine = vPt5ax[i].ptP - vPt5ax[j].ptP ; vtNewLine.Normalize() ;
+                        Pt5ax.ptP =  vPt5ax[j].ptP + vtNewLine * 2 * EPS_SMALL ;
+                     }
                      Pt5ax.vtDir1 = vPt5ax[i].vtDir1 ;
                      Pt5ax.vtDir2 = vPt5ax[i].vtDir2 ;
+                     Pt5ax.vtDirU = vPt5ax[i].vtDirU ;
+                     Pt5ax.vtDirV = vPt5ax[i].vtDirV ;
                      Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
                      Pt5ax.nFlag = P5AX_CVEX ;
                      vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
@@ -118,6 +151,8 @@ AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
                   Pt5ax.ptP = ptInt ;
                   Pt5ax.vtDir1 = Media( vPt5ax[i].vtDir1, vPt5ax[j].vtDir1) ; Pt5ax.vtDir1.Normalize() ;
                   Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ; Pt5ax.vtDir2.Normalize() ;
+                  Pt5ax.vtDirU = Media( vPt5ax[i].vtDirU, vPt5ax[j].vtDirU) ; Pt5ax.vtDirU.Normalize() ;
+                  Pt5ax.vtDirV = Media( vPt5ax[i].vtDirV, vPt5ax[j].vtDirV) ; Pt5ax.vtDirV.Normalize() ;
                   Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
                   Pt5ax.nFlag = P5AX_CONC ;
                   vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
@@ -126,6 +161,72 @@ AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
             }
          }
       }
+      else {
+         // guardo se la proiezione il tratto successivo, lungo la normale precedente + maggiore di un angolo minimo ( angolo interno smooth)
+         Vector3d vtDirNext = vPt5ax[i].ptP - vPt5ax[j].ptP ;
+         vtDirNext.Normalize() ;
+         double dProj1 = vtDirNext * vPt5ax[j].vtDir1 ;
+         double dProj2 = ( - vtDirNext) * vPt5ax[i].vtDir1 ;
+         
+         if (  ( abs( dProj1) > abs( dProj2) ? dProj1 > dSinSmallAngle : dProj2 > dSinSmallAngle)) {
+            // se concavo senza spigolo netto segnalo zona concava smooth
+            vPt5ax[i].nFlag = P5AX_SMOOTH_CONC ;
+         }
+      }
+   }
+
+   int i = 0 ;
+   int j = ssize( vPt5ax) - 1 ;
+   bool bClosed = AreSamePointApprox( vPt5ax[i].ptP, vPt5ax[j].ptP) ;
+   // se la curva è chiusa controllo inizio e fine
+   if ( bClosed) {
+      // se normali tra corrente e precedente oltre limite
+      int k = i + 1 ;
+      int z = j - 1 ;
+      double dProjPrev = ( vPt5ax[z].ptP - vPt5ax[j].ptP) * vPt5ax[i].vtDir1 ;
+      double dProjCurr = ( vPt5ax[k].ptP - vPt5ax[i].ptP) * vPt5ax[j].vtDir1 ;
+      if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER) {
+         bool bConvex = ( abs( dProjCurr) > abs( dProjPrev) ? dProjCurr < 0 : dProjPrev < 0) ;
+         if ( i < ssize( vPt5ax) - 2  &&  ! AreSameVectorExact(vPt5ax.back().vtDir1, vPt5ax.back().vtDir2)) {
+            int z = j - 1 ;
+            // se vtDir1 e vtDir2 sono diverse allora sono su uno spigolo
+            double dProjPrev2 = ( vPt5ax[z].ptP - vPt5ax[j].ptP) * vPt5ax[j].vtDir2 ;
+            double dProjCurr2 = ( vPt5ax[i].ptP - vPt5ax[j].ptP) * vPt5ax[j].vtDir1 ;
+            // se uno dei due è convesso allora considero convesso l'angolo
+            bConvex = dProjPrev2 < EPS_SMALL  ||  dProjCurr2 < EPS_SMALL ;
+         }
+         if ( bConvex) {
+            vPt5ax[i].nFlag = P5AX_CVEX ;
+            vPt5ax[i].vtDir2 = vPt5ax[j].vtDir1 ;
+            vPt5ax[j].nFlag = P5AX_CVEX ;
+         }
+         else {
+            vPt5ax[i].nFlag = P5AX_CONC ;
+            vPt5ax[j].nFlag = P5AX_CONC ;
+            Vector3d vtDir1 = Media( vPt5ax[i].vtDir1, vPt5ax[j].vtDir1) ; vtDir1.Normalize() ;
+            Vector3d vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ; vtDir2.Normalize() ;
+            Vector3d vtDirU = Media( vPt5ax[i].vtDirU, vPt5ax[j].vtDirU) ; vtDirU.Normalize() ;
+            Vector3d vtDirV = Media( vPt5ax[i].vtDirV, vPt5ax[j].vtDirV) ; vtDirV.Normalize() ;
+            vPt5ax[i].vtDir1 = vtDir1 ;
+            vPt5ax[j].vtDir1 = vtDir1 ;
+            vPt5ax[i].vtDir2 = vtDir2 ;
+            vPt5ax[j].vtDir2 = vtDir2 ;
+            vPt5ax[i].vtDirU = vtDirU ;
+            vPt5ax[j].vtDirU = vtDirU ;
+            vPt5ax[i].vtDirV = vtDirV ;
+            vPt5ax[j].vtDirV = vtDirV ;
+         }
+      }
+      else if (  abs( dProjPrev) > abs( dProjCurr) ? dProjPrev > dSinSmallAngle : dProjCurr > dSinSmallAngle) {
+         vPt5ax[i].nFlag = P5AX_SMOOTH_CONC ;
+         vPt5ax[j].nFlag = P5AX_SMOOTH_CONC ;
+      }
+   }
+
+   // riscorro tutto il vettore per vedere se ho creato delle zone concave smooth frammentate (separate solo da un tratto non classificato concavo), che quindi uniformo
+   for ( int i = 1 ; i < ssize( vPt5ax) - 1 ; ++ i) {
+      if ( vPt5ax[i].nFlag != P5AX_SMOOTH_CONC  &&  vPt5ax[i-1].nFlag == P5AX_SMOOTH_CONC  &&  vPt5ax[i+1].nFlag == P5AX_SMOOTH_CONC)
+         vPt5ax[i].nFlag = P5AX_SMOOTH_CONC ;
    }
    return true ;
 }
@@ -233,23 +334,55 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
 }
 
 //----------------------------------------------------------------------------
-static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, double dPar, Point5ax& Pt5ax)
+static const SurfTriMesh*
+MyGetAuxSurf( const ISurf* pSrf)
 {
-  // punto sulle supefici a minima distanza
+   if ( pSrf == nullptr)
+      return nullptr ;
+   switch ( pSrf->GetType()) {
+   case SRF_TRIMESH :
+      return GetBasicSurfTriMesh( pSrf) ;
+   case SRF_FLATRGN :
+      return GetBasicSurfFlatRegion( pSrf)->GetAuxSurf() ;
+   case SRF_BEZIER :
+      return GetBasicSurfBezier( pSrf)->GetAuxSurf() ;
+   default :
+      return nullptr ;
+   }
+}
+
+//----------------------------------------------------------------------------
+static bool
+ProjectPointOnSurf( const Point3d& ptP, const CISURFPVECTOR& vpSurf, double dPar, Point5ax& Pt5ax)
+{
+  // punto sulle superfici a minima distanza
    int nSurfMin = -1 ;
-   int nTriaMin ;
+   int nTriaMin = -1 ;
+   double dUMin = -1, dVMin = -1 ;
    Point3d ptMin ;
-   double dMinDist ;
-   for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
+   double dMinDist = NAN ;
+   for ( int i = 0 ; i < ssize( vpSurf) ; ++ 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 ;
+      int nSrfType = ( vpSurf[i] != nullptr ? vpSurf[i]->GetType() : GEO_NONE) ;
+      if ( nSrfType == SRF_TRIMESH  ||  nSrfType == SRF_FLATRGN) {
+         DistPointSurfTm dPS( ptP, *MyGetAuxSurf( vpSurf[i])) ;
+         double dDist ;
+         if ( dPS.GetDist( dDist)  &&  ( nSurfMin == -1  ||  dDist < dMinDist)) {
+            nSurfMin = i ;
+            dPS.GetMinDistPoint( ptMin) ;
+            dPS.GetMinDistTriaIndex ( nTriaMin) ;
+            dMinDist = dDist ;
+         }
+      }
+      else if ( nSrfType == SRF_BEZIER) {
+         DistPointSurfBz dPS( ptP, *GetBasicSurfBezier( vpSurf[i])) ;
+         double dDist ;
+         if ( dPS.GetDist( dDist)  &&  ( nSurfMin == -1  ||  dDist < dMinDist)) {
+            nSurfMin = i ;
+            dPS.GetMinDistPoint( ptMin) ;
+            dPS.GetParamsAtMinDistPoint( dUMin, dVMin) ;
+            dMinDist = dDist ;
+         }
       }
    }
 
@@ -257,19 +390,44 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, double dPar
    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 ;
+     // calcolo gli altri dati
+      int nSrfType = ( vpSurf[nSurfMin] != nullptr ? vpSurf[nSurfMin]->GetType() : GEO_NONE) ;
+      if ( nSrfType == SRF_TRIMESH  ||  nSrfType == SRF_FLATRGN) {
+        // recupero superficie trimesh
+         const SurfTriMesh* pSurfTm = MyGetAuxSurf( vpSurf[nSurfMin]) ;
+        // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
+         Triangle3dEx trTria ;
+         if ( ! pSurfTm->GetTriangle( nTriaMin, trTria))
+            return false ;
+         Vector3d vtN ;
+         if ( ! CalcNormal( ptMin, trTria, vtN))
+            vtN = trTria.GetN() ;
+        // assegno valori al punto 5assi
+         Pt5ax.ptP = ptInt ;
+         Pt5ax.vtDir1 = vtN ;
+         Pt5ax.vtDir2 = vtN ;
+         Pt5ax.vtDirU = V_NULL ;
+         Pt5ax.vtDirV = V_NULL ;
+         Pt5ax.dPar = dPar ;
+         Pt5ax.nFlag = P5AX_STD ;
+      }
+      else if ( nSrfType == SRF_BEZIER) {
+         Point3d ptSB ;
+         Vector3d vtN, vtDerU, vtDerV ;
+         if ( ! GetBasicSurfBezier( vpSurf[nSurfMin])->GetPointNrmD1D2( dUMin, dVMin, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS,
+                                                                        ptSB, vtN, &vtDerU, &vtDerV))
+            return false ;
+         vtDerU.Normalize() ;
+         vtDerV.Normalize() ;
+        // assegno valori al punto 5assi
+         Pt5ax.ptP = ptInt ;
+         Pt5ax.vtDir1 = vtN ;
+         Pt5ax.vtDir2 = vtN ;
+         Pt5ax.vtDirU = vtDerU ;
+         Pt5ax.vtDirV = vtDerV ;
+         Pt5ax.dPar = dPar ;
+         Pt5ax.nFlag = P5AX_STD ;
+      }
      // ritorno con successo
       return true ;
    }
@@ -280,33 +438,8 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, double dPar
 //----------------------------------------------------------------------------
 bool
 ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
+                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax, bool bNormOrTang)
 {
-  // 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) ;
@@ -325,21 +458,118 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
    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) ;
+   double dPar, dParNext ;
+   Point3d ptP, ptPNext ;
+   Vector3d vtDirPrev = V_INVALID ;
+   if ( PL.IsClosed()) {
+      Point3d pt1, pt2 ;
+      PL.GetLastLine( pt1, pt2) ;
+      vtDirPrev = pt2 - pt1 ;
+   }
+   Vector3d vtLast ; PL.GetLastULine( &dPar, &ptP, &dParNext, &ptPNext) ;
+   vtLast = ptPNext - ptP ; vtLast.Normalize() ;
+   bool bFound = PL.GetFirstULine( &dPar, &ptP, &dParNext, &ptPNext) ;
+   Vector3d vtFirst = ptPNext - ptP ; vtFirst.Normalize() ;
+   bool bClosed = PL.IsClosed() ;
+   bool bLast = false ;
+   Vector3d vtNormPrev = V_INVALID ;
+   Point3d ptPrev ;
+   bool bFirst = true ;
    while ( bFound) {
      // se trovo proiezione, la salvo
       Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, dPar, Pt5ax))
+      if ( ProjectPointOnSurf( ptP, vpSurf, dPar, Pt5ax))
          vPt5ax.emplace_back( Pt5ax) ;
-     // passo al successivo
-      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
+      // controllo che la normale trovata sia in linea con la precedente, se i due tratti erano abbastanza allineati
+      bool bRecalc = false ;
+      if ( bFirst)
+         bRecalc = true ;
+      if ( ssize( vPt5ax) > 2) {
+         Point5ax& pt5Curr = vPt5ax.back() ;
+         Point5ax& pt5Prev = vPt5ax.end()[-2] ;
+         Point5ax& pt5PrevPrev = vPt5ax.end()[-3] ;
+         Vector3d vtDirCurr = pt5Curr.ptP - pt5Prev.ptP ; vtDirCurr.Normalize() ;
+         Vector3d vtDirPrev = pt5Prev.ptP - pt5PrevPrev.ptP ; vtDirPrev.Normalize() ;
+         double dProjDir = vtDirCurr * vtDirPrev ;
+         if ( dProjDir > COS_ANG_MAX_CORNER) {
+            double dProjNorm = vPt5ax.back().vtDir1 * vtNormPrev ;
+            if ( dProjNorm < COS_ANG_MAX_CORNER)
+               bRecalc = true ;
+         }
+      }
+      Vector3d vtDirNext = ptPNext - ptP ; vtDirNext.Normalize() ;
+      // se sono arrivato ad uno spigolo tengo la normale appena prima dello spigolo
+      if ( bRecalc) {
+         Point3d ptAlter ;
+         if ( ! bFirst) {
+            Vector3d vtDirPrev = ptP - ptPrev ; vtDirPrev.Normalize() ;
+            ptAlter = ptP - vtDirPrev * 5 * EPS_SMALL ;
+         }
+         else
+            ptAlter = ptP + vtDirNext * 5 * EPS_SMALL ;
+         Point5ax Pt5axRec ;
+         if ( ProjectPointOnSurf( ptAlter, vpSurf, dPar, Pt5axRec)) {
+            // aggiorno solo la vtDir1, la vtDir2 la mantengo con la normale successiva allo spigolo
+            if ( Pt5axRec.vtDir1 * Pt5ax.vtDir1 < COS_ANG_MAX_CORNER)
+               vPt5ax.back().vtDir1 = Pt5axRec.vtDir1 ;
+         }
+      }
+      else if ( ssize( vPt5ax) > 1  &&  vPt5ax.back().vtDir1 * vPt5ax.end()[-2].vtDir1 < COS_ANG_MAX_CORNER) {
+         // se la normale corrente è sufficientemente diversa dalla precedente e i tratti non erano allineati
+         // controllo se il punto precedente erano su uno spigolo, ricalcolando in un punto appena oltre
+         Point3d ptAlter = ptPrev + ( ptP - ptPrev) * 5 * EPS_SMALL ;
+         Point5ax Pt5axRec ;
+         if ( ProjectPointOnSurf( ptAlter, vpSurf, dPar, Pt5axRec)) {
+            // aggiorno solo la vtDir1, la vtDir2 la mantengo con la normale successiva allo spigolo
+            if ( Pt5axRec.vtDir1 * Pt5ax.vtDir1 < COS_ANG_MAX_CORNER)
+               vPt5ax.end()[-2].vtDir1 = Pt5axRec.vtDir1 ;
+         }
+      }
+
+      if ( bLast  &&  bClosed) {
+         // controllo se il punto finale è di spigolo
+         if ( vPt5ax.back().vtDir1 * vPt5ax.front().vtDir1 < COS_ANG_MAX_CORNER) {
+            vPt5ax.back().vtDir2 = vPt5ax.front().vtDir1 ;
+            vPt5ax.front().vtDir2 = vPt5ax.back().vtDir1 ;
+         }
+      }
+      vtNormPrev = vPt5ax.back().vtDir1 ;
+      // se richiesta la tangente anziché la normale allora modifico il vettore associato al punto
+      Vector3d vtDir ;
+      if ( ! bNormOrTang) {
+         Vector3d vtNorm = vPt5ax.back().vtDir1 ;
+         if ( bFirst)
+            vtDir = vtDirNext ;
+         else
+            vtDir = vtDirPrev ;
+         // in caso sia stato superato l'angolo limite dò priorità alla direzione precedente
+         if ( vtDirPrev.IsValid()  &&  (! bFirst  ||  ( bFirst && bClosed))) {
+            double dProj = vtDir * vtDirPrev ;
+            if ( dProj > COS_ANG_MAX_CORNER)
+               vtDir = Media( vtDir, vtDirPrev) ;
+         }
+         vtDirPrev = vtDirNext ;
+         Vector3d vtTang = vtDir ^ vtNorm ; vtTang.Normalize() ;
+         vPt5ax.back().vtDir1 = vtTang ;
+         vPt5ax.back().vtDir2 = vtTang ;
+      }
+      // passo al successivo
+      ptPrev = ptP ;
+      bFound = PL.GetNextULine( &dPar, &ptP, &dParNext, &ptPNext) ;
+      // se sono arrivato alla fine aggiungo l'ultimo punto
+      if ( ! bFound  &&  ! bLast) {
+         bLast = true ;
+         bFound = true ;
+      }
+      if ( bFirst)
+         bFirst = false ;
    }
 
   // se richiesto, inserimento punti intermedi in presenza di spigoli
-   if ( bSharpEdges)
-      AddPointsOnCorners( vPt5ax) ;
+   if ( bSharpEdges) {
+      if ( ! AddPointsOnCorners( vPt5ax))
+         return false ;
+   }
 
   // rimozione punti in eccesso rispetto alle tolleranze
    RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
@@ -354,7 +584,7 @@ typedef std::vector<IntersParLinesSurfTm*> INTPARLINESTMPVECTOR ;
 //----------------------------------------------------------------------------
 static bool
 ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const Frame3d& frRefLine, const INTPARLINESTMPVECTOR& vpIntPLSTM,
-                    double dPar, Point5ax& Pt5ax)
+                    double dPar, bool bFromVsTo, Point5ax& Pt5ax)
 {
   // intersezione retta di proiezione con superfici  (conservo l'intersezione più alta)
    Point3d ptL = GetToLoc( ptP, frRefLine) ;
@@ -363,23 +593,48 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const Frame
    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) {
+        // se dalla direzione
+         if ( bFromVsTo) {
+           // 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 ;
+                  }
+               }
+            }
+         }
+        // altrimenti verso la direzione
+         else {
+           // cerco la prima intersezione valida a partire dalla prima (è la più alta)
+            int nI = 0 ;
+            while ( nI < ssize( vIntRes)  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
+               ++nI ;
+           // se trovata
+            if ( nI < ssize( vIntRes)) {
+               if ( nInd < 0) {
+                  IntRes = vIntRes[nI] ;
+                  nInd = i ;
+               }
+               else {
+                  double dUref = (( IntRes.nILTT == ILTT_SEGM || IntRes.nILTT == ILTT_SEGM_ON_EDGE) ? IntRes.dU : IntRes.dU2) ;
+                  double dU = (( vIntRes[nI].nILTT == ILTT_SEGM || vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE) ? vIntRes[nI].dU : vIntRes[nI].dU2) ;
+                  if ( dU < dUref) {
+                     IntRes = vIntRes[nI] ;
+                     nInd = i ;
+                  }
+               }
             }
          }
       }
@@ -403,6 +658,8 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const Frame
       Pt5ax.ptP = ptInt ;
       Pt5ax.vtDir1 = vtN ;
       Pt5ax.vtDir2 = frRefLine.VersZ() ;
+      Pt5ax.vtDirU = V_NULL ;
+      Pt5ax.vtDirV = V_NULL ;
       Pt5ax.dPar = dPar ;
       Pt5ax.nFlag = P5AX_STD ;
      // ritorno con successo
@@ -414,7 +671,7 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const Frame
 //----------------------------------------------------------------------------
 bool
 ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vector3d& vtDir,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
+                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax)
 {
   // sistemazioni per tipo di superficie
    CISRFTMPVECTOR vpSurfTm ;
@@ -480,7 +737,7 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vect
    while ( bFound) {
      // se trovo proiezione, la salvo
       Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, frRefLine, vpIntPLSTM, dPar, Pt5ax))
+      if ( ProjectPointOnSurf( ptP, vpSurfTm, frRefLine, vpIntPLSTM, dPar, bFromVsTo, Pt5ax))
          vPt5ax.emplace_back( Pt5ax) ;
      // passo al successivo
       bFound = PL.GetNextUPoint( &dPar, &ptP) ;
@@ -502,7 +759,8 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vect
 
 //----------------------------------------------------------------------------
 static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const IGeoPoint3d& gpRef, double dPar, Point5ax& Pt5ax)
+ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const IGeoPoint3d& gpRef, double dPar, bool bFromVsTo,
+                    Point5ax& Pt5ax)
 {
   // punto di riferimento
    Point3d ptMin = gpRef.GetPoint() ;
@@ -517,23 +775,48 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const IGeoP
       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) {
+            // se dal punto
+            if ( bFromVsTo) {
+              // 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 ;
+                     }
+                  }
+               }
+            }
+           // altrimenti verso il punto
+            else {
+              // cerco la prima intersezione valida a partire dalla prima (è la più alta)
+               int nI = 0 ;
+               while ( nI < ssize( vIntRes)  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
+                  ++nI ;
+              // se trovata
+               if ( nI < ssize( vIntRes)) {
+                  if ( nInd < 0) {
+                     IntRes = vIntRes[nI] ;
+                     nInd = i ;
+                  }
+                  else {
+                     double dUref = (( IntRes.nILTT == ILTT_SEGM || IntRes.nILTT == ILTT_SEGM_ON_EDGE) ? IntRes.dU : IntRes.dU2) ;
+                     double dU = (( vIntRes[nI].nILTT == ILTT_SEGM || vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE) ? vIntRes[nI].dU : vIntRes[nI].dU2) ;
+                     if ( dU < dUref) {
+                        IntRes = vIntRes[nI] ;
+                        nInd = i ;
+                     }
+                  }
                }
             }
          }
@@ -557,6 +840,8 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const IGeoP
          Pt5ax.ptP = ptInt ;
          Pt5ax.vtDir1 = vtN ;
          Pt5ax.vtDir2 = vtLine ;
+         Pt5ax.vtDirU = V_NULL ;
+         Pt5ax.vtDirV = V_NULL ;
          Pt5ax.dPar = dPar ;
          Pt5ax.nFlag = P5AX_STD ;
         // ritorno con successo
@@ -569,7 +854,7 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const IGeoP
 //----------------------------------------------------------------------------
 bool
 ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeoPoint3d& gpRef,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
+                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax)
 {
   // sistemazioni per tipo di superficie
    CISRFTMPVECTOR vpSurfTm ;
@@ -620,7 +905,7 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeo
    while ( bFound) {
      // se trovo proiezione, la salvo
       Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, gpRef, dPar, Pt5ax))
+      if ( ProjectPointOnSurf( ptP, vpSurfTm, gpRef, dPar, bFromVsTo, Pt5ax))
          vPt5ax.emplace_back( Pt5ax) ;
      // passo al successivo
       bFound = PL.GetNextUPoint( &dPar, &ptP) ;
@@ -638,7 +923,8 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeo
 
 //----------------------------------------------------------------------------
 static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const ICurve& crRef, double dPar, Point5ax& Pt5ax)
+ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const ICurve& crRef, double dPar, bool bFromVsTo,
+                    Point5ax& Pt5ax)
 {
   // punto a minima distanza
    DistPointCurve dPC( ptP, crRef) ;
@@ -656,23 +942,48 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const ICurv
          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) {
+              // se dalla curva
+               if ( bFromVsTo) {
+                 // 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 ;
+                        }
+                     }
+                  }
+               }
+              // altrimenti verso la curva
+               else {
+                 // cerco la prima intersezione valida a partire dalla prima (è la più alta)
+                  int nI = 0 ;
+                  while ( nI < ssize( vIntRes)  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
+                     ++nI ;
+                 // se trovata
+                  if ( nI < ssize( vIntRes)) {
+                     if ( nInd < 0) {
+                        IntRes = vIntRes[nI] ;
+                        nInd = i ;
+                     }
+                     else {
+                        double dUref = (( IntRes.nILTT == ILTT_SEGM || IntRes.nILTT == ILTT_SEGM_ON_EDGE) ? IntRes.dU : IntRes.dU2) ;
+                        double dU = (( vIntRes[nI].nILTT == ILTT_SEGM || vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE) ? vIntRes[nI].dU : vIntRes[nI].dU2) ;
+                        if ( dU < dUref) {
+                           IntRes = vIntRes[nI] ;
+                           nInd = i ;
+                        }
+                     }
                   }
                }
             }
@@ -695,7 +1006,9 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const ICurv
            // assegno valori al punto 5assi
             Pt5ax.ptP = ptInt ;
             Pt5ax.vtDir1 = vtN ;
-            Pt5ax.vtDir2 = vtLine ;
+            Pt5ax.vtDir2 = ( bFromVsTo ? vtLine : -vtLine) ;
+            Pt5ax.vtDirU = V_NULL ;
+            Pt5ax.vtDirV = V_NULL ;
             Pt5ax.dPar = dPar ;
             Pt5ax.nFlag = P5AX_STD ;
            // ritorno con successo
@@ -709,7 +1022,7 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const ICurv
 //----------------------------------------------------------------------------
 bool
 ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICurve& crRef,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
+                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax)
 {
   // Sistemazioni per tipo di superficie
    CISRFTMPVECTOR vpSurfTm ;
@@ -760,7 +1073,7 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICur
    while ( bFound) {
      // se trovo proiezione, la salvo
       Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, crRef, dPar, Pt5ax))
+      if ( ProjectPointOnSurf( ptP, vpSurfTm, crRef, dPar, bFromVsTo, Pt5ax))
          vPt5ax.emplace_back( Pt5ax) ;
      // passo al successivo
       bFound = PL.GetNextUPoint( &dPar, &ptP) ;
@@ -778,7 +1091,8 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICur
 
 //----------------------------------------------------------------------------
 static bool
-ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const SurfTriMesh& stmRef, double dPar, Point5ax& Pt5ax)
+ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const SurfTriMesh& stmRef, double dPar, bool bFromVsTo,
+                    Point5ax& Pt5ax)
 {
   // punto sulla superficie guida a minima distanza
    DistPointSurfTm dPS( ptP, stmRef) ;
@@ -805,23 +1119,48 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const SurfT
       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) {
+           // se dalla superficie
+            if ( bFromVsTo) {
+              // 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 ;
+                     }
+                  }
+               }
+            }
+           // altrimenti verso la superficie
+            else {
+              // cerco la prima intersezione valida a partire dalla prima (è la più alta)
+               int nI = 0 ;
+               while ( nI < ssize( vIntRes)  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
+                  ++nI ;
+              // se trovata
+               if ( nI < ssize( vIntRes)) {
+                  if ( nInd < 0) {
+                     IntRes = vIntRes[nI] ;
+                     nInd = i ;
+                  }
+                  else {
+                     double dUref = (( IntRes.nILTT == ILTT_SEGM || IntRes.nILTT == ILTT_SEGM_ON_EDGE) ? IntRes.dU : IntRes.dU2) ;
+                     double dU = (( vIntRes[nI].nILTT == ILTT_SEGM || vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE) ? vIntRes[nI].dU : vIntRes[nI].dU2) ;
+                     if ( dU < dUref) {
+                        IntRes = vIntRes[nI] ;
+                        nInd = i ;
+                     }
+                  }
                }
             }
          }
@@ -852,6 +1191,8 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const SurfT
          Pt5ax.ptP = ptInt ;
          Pt5ax.vtDir1 = vtN ;
          Pt5ax.vtDir2 = vtN2 ;
+         Pt5ax.vtDirU = V_NULL ;
+         Pt5ax.vtDirV = V_NULL ;
          Pt5ax.dPar = dPar ;
          Pt5ax.nFlag = P5AX_STD ;
         // ritorno con successo
@@ -864,7 +1205,7 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const SurfT
 //----------------------------------------------------------------------------
 bool
 ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISurf& sfRef,
-                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
+                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax)
 {
   // sistemazioni per tipo di superficie
    CISRFTMPVECTOR vpSurfTm ;
@@ -936,7 +1277,7 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISur
    while ( bFound) {
      // se trovo proiezione, la salvo
       Point5ax Pt5ax ; 
-      if ( ProjectPointOnSurf( ptP, vpSurfTm, *pRefTm, dPar, Pt5ax))
+      if ( ProjectPointOnSurf( ptP, vpSurfTm, *pRefTm, dPar, bFromVsTo, Pt5ax))
          vPt5ax.emplace_back( Pt5ax) ;
      // passo al successivo
       bFound = PL.GetNextUPoint( &dPar, &ptP) ;
@@ -951,3 +1292,132 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISur
 
    return true ;
 }
+
+//----------------------------------------------------------------------------
+bool
+GetCurveOnSurfInfo( const ICurve& crCrv, const ISurfTriMesh& pSurf,
+                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax, bool bNormOrTang)
+{
+   // 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 ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
+   if ( ! crCrv.ApproxWithLimitedLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, MAX_SEG_LEN, PL))
+      return false ;
+
+   PL.RemoveAlignedPoints( dLinTol, false, MAX_SEG_LEN) ;
+
+   // 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, dParNext ;
+   Point3d ptP, ptPNext ;
+   Vector3d vtDirPrev = V_INVALID ;
+   if ( PL.IsClosed()) {
+      Point3d pt1, pt2 ;
+      PL.GetLastLine( pt1, pt2) ;
+      vtDirPrev = pt2 - pt1 ;
+   }
+   Vector3d vtLast ; PL.GetLastULine( &dPar, &ptP, &dParNext, &ptPNext) ;
+   vtLast = ptPNext - ptP ; vtLast.Normalize() ;
+   bool bFound = PL.GetFirstULine( &dPar, &ptP, &dParNext, &ptPNext) ;
+   Vector3d vtFirst = ptPNext - ptP ; vtFirst.Normalize() ;
+   bool bClosed = PL.IsClosed() ;
+   bool bLast = false ;
+   Point3d ptPrev ;
+   bool bFirst = true ;
+   const ICurveComposite* pCC = GetCurveComposite( &crCrv) ;
+   int nTria = -1 ;
+   Triangle3dEx trTria ;
+   while ( bFound) {
+      // se trovo proiezione, la salvo
+      Point5ax Pt5ax ;
+      Pt5ax.ptP = ptP ;
+      Pt5ax.dPar = dPar ;
+      double dDecimal ;
+      bool bJoint = modf( dPar, &dDecimal) == 0.0 ;
+      int nCrv = int( bJoint ? dPar - 1 : dPar) ;
+      if ( nCrv < 0)
+         nCrv = 0 ;
+      int nTriaCurr ; pCC->GetCurveTempProp( nCrv, nTriaCurr, 0) ;
+      if ( nTriaCurr != nTria)
+         pSurf.GetTriangle( nTriaCurr, trTria) ;
+
+      if ( ! CalcNormal( ptP, trTria, Pt5ax.vtDir1))
+         Pt5ax.vtDir1 = trTria.GetN() ;
+      nTria = nTriaCurr ;
+      if ( bJoint) {
+         int nPar = int( dPar) ;
+         if ( bClosed && nPar > pCC->GetCurveCount() - 1)
+            nPar = 0 ;
+         int nTria2 ; pCC->GetCurveTempProp( nPar, nTria2, 0) ;
+         Triangle3dEx trTria2 ; pSurf.GetTriangle( nTria2, trTria2) ;
+         if ( ! CalcNormal( ptP, trTria2, Pt5ax.vtDir2))
+            Pt5ax.vtDir2 = trTria2.GetN() ;
+         nTria = nTria2 ;
+         trTria = trTria2 ;
+      }
+      else
+         Pt5ax.vtDir2 = Pt5ax.vtDir1 ;
+      Pt5ax.vtDirU = V_NULL ;
+      Pt5ax.vtDirV = V_NULL ;
+      Pt5ax.nFlag = P5AX_STD ;
+      vPt5ax.emplace_back( Pt5ax) ;
+
+      Vector3d vtDirNext = ptPNext - ptP ; vtDirNext.Normalize() ;
+      // se richiesta la tangente anziché la normale allora modifico il vettore associato al punto
+      Vector3d vtDir ;
+      if ( ! bNormOrTang) {
+         Vector3d vtNorm = vPt5ax.back().vtDir1 ;
+         if ( bFirst)
+            vtDir = vtDirNext ;
+         else
+            vtDir = vtDirPrev ;
+         // in caso sia stato superato l'angolo limite dò priorità alla direzione precedente
+         bool bEdge = false ;
+         if ( vtDirPrev.IsValid()  &&  (! bFirst  ||  ( bFirst && bClosed))) {
+            double dProj = vtDirNext * vtDirPrev ;
+            bEdge = dProj < COS_ANG_MAX_CORNER ;
+            if ( ! bEdge)
+               vtDir = Media( vtDirNext, vtDirPrev) ;
+         }
+         vtDirPrev = vtDirNext ;
+         bEdge = bEdge  ||  ! AreSameVectorExact( vPt5ax.back().vtDir1, vPt5ax.back().vtDir2) ;
+         Vector3d vtTang = vtDir ^ vtNorm ; vtTang.Normalize() ;
+         vPt5ax.back().vtDir1 = vtTang ;
+         if ( bEdge) {
+            Vector3d vtTang2 = vtDirNext ^ vPt5ax.back().vtDir2 ;
+            vtTang2.Normalize() ;
+            vPt5ax.back().vtDir2 = vtTang2 ;
+         }
+         else
+            vPt5ax.back().vtDir2 = vtTang ;
+      }
+      // passo al successivo
+      ptPrev = ptP ;
+      bFound = PL.GetNextULine( &dPar, &ptP, &dParNext, &ptPNext) ;
+      // se sono arrivato alla fine aggiungo l'ultimo punto
+      if ( ! bFound  &&  ! bLast) {
+         bLast = true ;
+         bFound = true ;
+      }
+      if ( bFirst)
+         bFirst = false ;
+   }
+
+   // se richiesto, inserimento punti intermedi in presenza di spigoli
+   if ( bSharpEdges) {
+      if ( ! AddPointsOnCorners( vPt5ax))
+         return false ;
+   }
+
+   // rimozione punti in eccesso rispetto alle tolleranze
+   RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
+
+   return true ;
+}

RotationMinimizingFrame.cpp

@@ -92,11 +92,18 @@ RotationMinimizingFrame::GetFrameAtParam( const Frame3d& frAct, const double dPa
    Vector3d vtCurrR = frAct.VersX() ;
    Vector3d vtCurrT = frAct.VersZ() ;
 
-  // punto i-esimo sulla curva e suo vettore tangente
+  // punto i-esimo sulla curva e suo vettore tangente medio
+   Point3d ptNextM, ptNextP ;
+   Vector3d vtNextM, vtNextP ;
+   if ( ! m_pCrv->GetPointD1D2( dParNext, ICurve::FROM_MINUS, ptNextM, &vtNextM)  ||
+        ! m_pCrv->GetPointD1D2( dParNext, ICurve::FROM_PLUS, ptNextP, &vtNextP)  ||
+        ! vtNextM.Normalize()  ||  ! vtNextP.Normalize())
+      return false ;
    Point3d ptNext ;
    Vector3d vtNextT ;
-   if ( ! m_pCrv->GetPointD1D2( dParNext, ICurve::FROM_MINUS, ptNext, &vtNextT)  ||
-        ! vtNextT.Normalize())
+   ptNext = Media( ptNextM, ptNextP) ;
+   vtNextT = Media( vtNextM, vtNextP) ;
+   if ( ! vtNextT.Normalize())
       return false ;
 
   // controllo per casi degeneri

SbzFromCurves.cpp

@@ -733,6 +733,42 @@ GetSurfBezierRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, dou
    return Release( pSbz) ;
 }
 
+//-------------------------------------------------------------------------------
+ISurfBezier*
+GetSurfBezierRuledSmooth( const ICurve* pCurve1, const ICurve* pCurve2, BIPNTVECTOR& vSyncLines, double dSampleLen)
+{
+   // verifica parametri
+   if ( pCurve1 == nullptr  ||  pCurve2 == nullptr)
+      return nullptr ;
+
+   // dLinTol servirà quando ci sarà la funzione ApproxWithCurveBezier
+   // se la curva è già una bezier singola la tengo, sennò la converto
+   PtrOwner<ICurveComposite> pCC1( CreateCurveComposite()) ;
+   if ( pCurve1->GetType() != CRV_BEZIER)
+      pCC1->AddCurve( CurveToBezierCurve( pCurve1, 3, false)) ;
+   else
+      pCC1->AddCurve( pCurve1->Clone()) ;
+   if ( IsNull( pCC1)  ||  ! pCC1->IsValid())
+      return nullptr ;
+
+   // se la curva è già una bezier singola la tengo, sennò la converto
+   PtrOwner<ICurveComposite> pCC2( CreateCurveComposite()) ;
+   if ( pCurve2->GetType() != CRV_BEZIER)
+      pCC2->AddCurve( CurveToBezierCurve( pCurve2, 3, false)) ;
+   else
+      pCC2->AddCurve( pCurve2->Clone()) ;
+   if ( IsNull( pCC2)  ||  ! pCC2->IsValid())
+      return nullptr ;
+
+   // creo e setto la superficie trimesh
+   PtrOwner<SurfBezier> pSbz( CreateBasicSurfBezier()) ;
+   if ( IsNull( pSbz)  ||  ! pSbz->CreateSmoothRuledByTwoCurves( pCC1, pCC2, dSampleLen, vSyncLines))
+      return nullptr ;
+
+   // restituisco la superficie
+   return Release( pSbz) ;
+}
+
 //-------------------------------------------------------------------------------
 ISurfBezier*
 GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const BIPNTVECTOR& vCrv, double dLinTol)

StringUtils3d.cpp

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

SurfAux.cpp

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

SurfBezier.h

@@ -116,9 +116,9 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const override ;
       const SurfTriMesh* GetAuxSurf( void) const override ;
       const SurfTriMesh* GetAuxSurfRefined( void) const override ;
-      SurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL, bool bUpdateEdges = false) const override ;
+      SurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 10 * EPS_SMALL, bool bUpdateEdges = false) const override ;
       // funzione per ottenere la suddivisione dello spazio parametrico nelle celle utilizzate per la triangolazione.
-      bool GetLeaves( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const override ;
+      bool GetLeaves( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves, bool bRefined = false) const override ;
       bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const override ;
       // funzioni che servono per ricavare l'immagine nel parametrico di un punto appartenente alla trimesh ausiliaria della superficie di Bezier
       bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL = IntLineTriaType::ILTT_IN) const override ;
@@ -148,11 +148,14 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool CreateByPointCurve( const Point3d& pt, const ICurve* pCurve) override ;
       bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) override ;
       bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3) override ;
-      PNTVECTOR GetAllControlPoints( void) const ;
+      PNTVECTOR GetAllControlPoints( void) const override ;
       bool GetAllPatchesIsocurves( bool bUorV, ICURVEPOVECTOR& vCrv) const ;
       bool CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const BIPNTVECTOR& vCrv) ;
-      bool RemoveCollapsedSpans() override ;
-      bool SwapParameters() ;
+      bool RemoveCollapsedSpans( void) override ;
+      bool SwapParameters( void) ;
+      bool LimitSurfToTrimmedRegion( void) override ;
+      bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen) override ;
+      bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen, BIPNTVECTOR& vSyncLines) override ;
 
    public :                      // IGeoObjRW
       int  GetNgeId( void) const override ;

SurfFlatRegion.cpp

@@ -28,6 +28,13 @@
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
+#define SAVECLASSCRV 0
+#define SAVEADJUSTCRV 0
+#if SAVECLASSCRV || SAVEADJUSTCRV
+std::vector<IGeoObj*> vGeo ;
+#include "/EgtDev/Include/EGkGeoObjSave.h"
+#endif
+
 using namespace std ;
 
 //----------------------------------------------------------------------------
@@ -107,8 +114,20 @@ SurfFlatRegion::AddExtLoop( ICurve* pCrv)
    pMyCrv->SetThickness( 0) ;
   // rimuovo eventuali sovrapposizioni (calcolate nel suo piano)
    ICURVEPLIST CrvLst ;
+
+#if SAVEADJUSTCRV
+   SaveGeoObj( pMyCrv->Clone(), "D:\\Temp\\inters\\CrvCrvInters\\before_adjust.nge") ;
+#endif
+
    if ( ! AdjustLoops( Release( pMyCrv), CrvLst, true))
       return false ;
+
+#if SAVEADJUSTCRV
+   for ( auto& pSingCrv : CrvLst)
+      vGeo.push_back( pSingCrv->Clone()) ;
+   SaveGeoObj( vGeo, "D:\\Temp\\inters\\CrvCrvInters\\after_adjust.nge") ;
+#endif
+
   // aggiungo le singole curve
    int nExtAdded = 0 ;
    bool bOk = true ;
@@ -169,14 +188,18 @@ SurfFlatRegion::AddSimpleExtLoop( ICurve* pCrv, bool& bAdded)
    Vector3d vtExtr ;
    if ( pMyCrv->GetExtrusion( vtExtr)  &&  ! vtExtr.IsSmall())
       pMyCrv->SetExtrusion( Z_AX) ;
-  // verifico non abbia auto-intersezioni che si attraversano o si sovrappongano
-   SelfIntersCurve sInt( *pMyCrv) ;
-   if ( sInt.GetCrossOrOverlapIntersCount() > 0)
-      return false ;
+
   // verifico che sia esterna alle curve esterne degli altri chunk
    bool bOk = true ;
    CRVCVECTOR ccClass ;
    for ( auto i : m_vExtInd) {
+#if SAVEADJUSTCRV
+         vGeo.clear() ;
+         vGeo.push_back( pMyCrv->Clone()) ;
+         vGeo.push_back( m_vpLoop[i]->Clone()) ;
+         SaveGeoObj( vGeo, "D:\\Temp\\inters\\CrvCrvInters\\during_add_simpleExt.nge") ;
+#endif
+
       IntersCurveCurve ccInt( *pMyCrv, *m_vpLoop[i]) ;
       if ( ccInt.GetCrossOrOverlapIntersCount() > 0  ||
            ! ccInt.GetCurveClassification( 0, EPS_SMALL, ccClass)  ||
@@ -216,14 +239,9 @@ SurfFlatRegion::AddSimpleExtLoop( ICurve* pCrv, bool& bAdded)
 bool
 SurfFlatRegion::MyAddExtLoop( ICurve* pCrv)
 {
-   try {
-      m_vpLoop.push_back( pCrv) ;
-      m_vExtInd.push_back( int( m_vpLoop.size()) - 1) ;
-      m_nStatus = OK ;
-   }
-   catch (...) {
-      return false ;
-   }
+   m_vpLoop.push_back( pCrv) ;
+   m_vExtInd.push_back( int( m_vpLoop.size()) - 1) ;
+   m_nStatus = OK ;
 
    return true ;
 }
@@ -304,10 +322,7 @@ SurfFlatRegion::AddSimpleIntLoop( ICurve* pCrv)
   // sistemo il senso di rotazione (deve essere CW -> se N==Z+ area < 0, se N==Z- area > 0)
    if ( ( plPlane.GetVersN().z > 0  &&  dArea > 0)  ||  ( plPlane.GetVersN().z < 0  &&  dArea < 0))
       pMyCrv->Invert() ;
-  // verifico non abbia auto-intersezioni
-   SelfIntersCurve sInt( *pMyCrv) ;
-   if ( sInt.GetCrossOrOverlapIntersCount() > 0)
-      return false ;
+
   // ricerca del chunk in cui andrebbe inserito
    int nChunk = -1 ;
    for ( int i = 0 ; i < int( m_vExtInd.size()) ; ++ i) {
@@ -354,23 +369,18 @@ SurfFlatRegion::AddSimpleIntLoop( ICurve* pCrv)
 bool
 SurfFlatRegion::MyAddIntLoop( ICurve* pCrv, int nChunk)
 {
-   try {
-     // se da aggiungere all'ultimo chunk
-      if ( nChunk == -1)
-         m_vpLoop.push_back( pCrv) ;
-     // altrimenti aggiungo al chunck indicato
-      else {
-         int nLoopCnt = GetLoopCount( nChunk) ;
-         if ( nLoopCnt == 0)
-            return false ;
-         int nOffset = m_vExtInd[nChunk] + nLoopCnt ;
-         m_vpLoop.insert( m_vpLoop.begin() + nOffset, pCrv) ;
-         for ( int i = nChunk + 1 ; i < int( m_vExtInd.size()) ; ++ i)
-            ++ m_vExtInd[i] ;
-      }
-   }
-   catch (...) {
-      return false ;
+   //se da aggiungere all'ultimo chunk
+   if ( nChunk == -1)
+      m_vpLoop.push_back( pCrv) ;
+   //altrimenti aggiungo al chunck indicato
+   else {
+      int nLoopCnt = GetLoopCount( nChunk) ;
+      if ( nLoopCnt == 0)
+         return false ;
+      int nOffset = m_vExtInd[nChunk] + nLoopCnt ;
+      m_vpLoop.insert( m_vpLoop.begin() + nOffset, pCrv) ;
+      for ( int i = nChunk + 1 ; i < int( m_vExtInd.size()) ; ++ i)
+         ++ m_vExtInd[i] ;
    }
 
    return true ;
@@ -1374,6 +1384,15 @@ SurfFlatRegion::MyGetCurveClassification( const ICurve& Crv, double dLenMin, CRV
       for ( int nLoop = 0 ; nLoop < GetLoopCount( nChunk) ; ++ nLoop) {
          const ICurve* pLoop = GetMyLoop( nChunk, nLoop) ;
         // intersezione
+
+#if SAVECLASSCRV
+         //debug
+         vector<IGeoObj*> vGeo ;
+         vGeo.push_back( Crv.Clone()) ;
+         vGeo.push_back( pLoop->Clone()) ;
+         SaveGeoObj( vGeo, "D:\\Temp\\inters\\CrvCrvInters\\crv_and_loop.nge") ;
+#endif
+
          IntersCurveCurve ccInt( Crv, *pLoop) ;
         // classificazione
          CRVCVECTOR ccPart ;
@@ -1537,7 +1556,7 @@ SurfFlatRegion::GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion&
   // classifico il loop esterno del chunk della prima regione rispetto a quello del chunk della seconda
    IntersCurveCurve ccInt( *pCrv1Loc, *pCrv2Loc) ;
    int nClass = ccInt.GetRegionCurveClassification() ;
-   switch ( nClass){
+   switch ( nClass) {
    default :   // CCREGC_NULL
       return REGC_NULL ;
    case CCREGC_IN1 :
@@ -1550,7 +1569,141 @@ SurfFlatRegion::GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion&
       return REGC_OUT ;
    case CCREGC_INTERS :
       return REGC_INTERS ;
-    }
+   }
+}
+
+//----------------------------------------------------------------------------
+bool
+SurfFlatRegion::CheckChunkInterference( int nChunk, const ISurfFlatRegion& Other, int nOthChunk, bool& bInterference) const
+{
+   bInterference = false ;
+  // verifico lo stato e il numero di chunk
+   if ( m_nStatus != OK  ||  m_vpLoop.empty()  ||  nChunk >= GetChunkCount())
+      return false ;
+  // recupero rappresentazione base dell'altra regione
+   const SurfFlatRegion& Reg2 = *GetBasicSurfFlatRegion( &Other) ;
+  // verifico lo stato e il numero di chunk dell'altra regione
+   if ( Reg2.m_nStatus != OK  ||  Reg2.m_vpLoop.empty()  ||  nOthChunk >= Reg2.GetChunkCount())
+      return false ;
+
+  // verifico che le due regioni giacciano in piani paralleli
+   if ( ! AreSameVectorApprox( m_frF.VersZ(), Reg2.m_frF.VersZ()))
+      return false ;
+
+  // classifico il loop esterno del chunk della prima regione rispetto a quello del chunk della seconda
+   int nClass = GetChunkSimpleClassification( nChunk, Other, nOthChunk) ;
+   if ( nClass == REGC_NULL)
+      return false ;
+  // se le regioni non hanno isole, allora ho già identificato se i Chunks fanno interferenza
+   int nLoopCnt = GetLoopCount( nChunk) ;
+   int nOtherLoopCnt = Other.GetLoopCount( nOthChunk) ;
+   if ( nLoopCnt == 1  &&  nOtherLoopCnt == 1) {
+      bInterference = ( nClass != REGC_OUT) ;
+      return true ;
+   }
+
+  // --- a prescindere dalle isole presenti nei 2 Chunks in esame :
+  // se i due loop esterni si intersecano tra loro o sono gli stessi, allora fanno per forza interferenza
+   if ( nClass == REGC_INTERS  ||  nClass == CCREGC_SAME) {
+      bInterference = true ;
+      return true ;
+   }
+  // se invece sono esterni tra loro, allora non c'è interferenza
+   else if ( nClass == REGC_OUT)
+      return true ;
+  // --- Analisi del loop interni :
+  // se la curva esterna corrente è interna alla curva esterna dell'altro chunk
+   else if ( nClass == REGC_IN1) {
+     // se l'altro chunk non ha isole, c'è interferenza (a prescinere da numero di loop interni del primo chunk)
+      if ( nOtherLoopCnt == 1) {
+         bInterference = true ;
+         return true ;
+      }
+     // curva esterna del chunk della prima regione (ovviamente già in locale al riferimento intrinseco)
+      const ICurve* pCrv1Loc = GetMyLoop( nChunk, 0) ;
+     // per ogni loop interno (isole)
+      for ( int i = 1 ; i < nOtherLoopCnt ; ++ i) {
+         const ICurve* pCrv2Loc = nullptr ;
+         PtrOwner<ICurve> pCopyCrv ;
+         if ( AreSameFrame( m_frF, Reg2.m_frF))
+            pCrv2Loc = Reg2.GetMyLoop( nOthChunk, i) ;
+         else {
+            pCopyCrv.Set( Reg2.GetMyLoop( nOthChunk, i)->Clone()) ;
+            if ( IsNull( pCopyCrv))
+               return false ;
+            pCopyCrv->LocToLoc( Reg2.m_frF, m_frF) ;
+            pCrv2Loc = pCopyCrv ;
+         }
+        // classifico il loop esterno del chunk della prima regione rispetto all'interno corrente del chunk della seconda
+         IntersCurveCurve ccInt( *pCrv1Loc, *pCrv2Loc) ;
+         int nInternalClass = ccInt.GetRegionCurveClassification() ;
+        // se le curve non sono classificabili, errore
+         if ( nInternalClass == REGC_NULL)
+            return false ;
+        // se la curva di bordo corrente è interna (le isole girano al contrario) all'isola corrente
+         else if ( nInternalClass == REGC_IN1)
+            ; // non faccio nulla, potrebbe non essere l'isola adatta per la classificazione
+        // se la curva di bordo corrente è esterna (le isole girano al contrario) all'isola corrente, allora non ho interferenza
+         else if ( nInternalClass == REGC_OUT)
+            return true ;
+        // se la curva di bordo corrente interseca l'isola o coincide con essa allora c'è interferenza
+         else if ( nInternalClass == REGC_INTERS  ||  nInternalClass == REGC_SAME) {
+            bInterference = true ;
+            return true ;
+         }
+        // negli altri casi ho un orientamento errato dei loop o delle regioni
+         else
+            return false ;
+      }
+   }
+  // se la curva esterna dell'altro chunk è interna alla curva esterna corrente
+   else if ( nClass == REGC_IN2) {
+     // se l'altro chunk non ha isole, c'è interferenza
+      if ( nLoopCnt == 1) {
+         bInterference = true ;
+         return true ;
+      }
+     // curva esterna del chunk della prima regione (ovviamente già in locale al riferimento intrinseco)
+      const ICurve* pCrv2Loc = Reg2.GetMyLoop( nChunk, 0) ;
+     // per ogni loop interno (isole)
+      for ( int i = 1 ; i < nLoopCnt ; ++ i) {
+         const ICurve* pCrv1Loc = nullptr ;
+         PtrOwner<ICurve> pCopyCrv ;
+         if ( AreSameFrame( Reg2.m_frF, m_frF))
+            pCrv1Loc = GetMyLoop( nOthChunk, i) ;
+         else {
+            pCopyCrv.Set( GetMyLoop( nOthChunk, i)->Clone()) ;
+            if ( IsNull( pCopyCrv))
+               return false ;
+            pCopyCrv->LocToLoc( m_frF, Reg2.m_frF) ;
+            pCrv1Loc = pCopyCrv ;
+         }
+        // classifico il loop esterno del chunk della prima regione rispetto a quello del chunk della seconda
+         IntersCurveCurve ccInt( *pCrv2Loc, *pCrv1Loc) ;
+         int nInternalClass = ccInt.GetRegionCurveClassification() ;
+        // se le curve non sono classificabili, errore
+         if ( nInternalClass == REGC_NULL)
+            return false ;
+        // se la curva di bordo corrente è interna (le isole girano al contrario) all'isola corrente
+         else if ( nInternalClass == REGC_IN1)
+            ; // non faccio nulla, potrebbe non essere l'isola adatta per la classificazione
+        // se la curva di bordo corrente è esterna (le isole girano al contrario) all'isola corrente, allora non ho interferenza
+         else if ( nInternalClass == REGC_OUT)
+            return true ;
+        // se la curva di bordo corrente interseca l'isola o coincide con essa allora c'è interferenza
+         else if ( nInternalClass == REGC_INTERS  ||  nInternalClass == REGC_SAME) {
+            bInterference = true ;
+            return true ;
+         }
+        // negli altri casi ho un orientamento errato dei loop o delle regioni
+         else
+            return false ;
+      }
+   }
+
+  // in questo la curva di bordo è interna ad ogni isola ma interna anche al loop esterno, quindi esiste interferenza
+   bInterference = true ;
+   return true ;
 }
 
 //----------------------------------------------------------------------------

SurfFlatRegion.h

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

SurfFlatRegionBooleans.cpp

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

SurfTriMesh.cpp

@@ -1150,7 +1150,7 @@ SurfTriMesh::MarchOneTria( int& nT, int& nV, int nTimeStamp,
 
 //----------------------------------------------------------------------------
 bool
-SurfTriMesh::GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria) const
+SurfTriMesh::GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria, double dLinTol) const
 {
   // Verifico lo stato
    if ( m_nStatus != OK)
@@ -1163,6 +1163,7 @@ SurfTriMesh::GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR&
 
   // Controlli su tolleranza
    dTol = max( dTol, 100 * EPS_SMALL) ;
+   double dMyLinTol = max( EPS_SMALL, dLinTol) ;
 
   // Determino il riferimento di proiezione
    Frame3d frOCS ; frOCS.Set( ORIG, vtVers) ;
@@ -1182,14 +1183,16 @@ SurfTriMesh::GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR&
              ( ! bAllTria  &&  Tria.GetN() * vtVers > EPS_ZERO))  &&
            Tria.Scale( frOCS, 1, 1, 0)  &&  Tria.GetSqMinHeight() > SQ_EPS_SMALL) {
          PtrOwner<SurfFlatRegion> pSfrTria( GetBasicSurfFlatRegion( GetSurfFlatRegionFromTriangle( Tria))) ;
-         if ( ! IsNull( pSfrTria)) {
+         if ( ! IsNull( pSfrTria)  &&  pSfrTria->IsValid()) {
             if ( bAllTria  &&  Tria.GetN() * vtVers < 0)
                pSfrTria->Invert() ;
             pSfrTria->Offset( dTol, ICurve::OFF_FILLET) ;
             if ( IsNull( pSfr))
                pSfr.Set( pSfrTria) ;
-            else
-               pSfr->Add( *pSfrTria) ;
+            else {
+               if ( ! pSfr->Add( *pSfrTria))
+                  return false ;
+            }
          }
       }
      // passo al successivo
@@ -1201,14 +1204,18 @@ SurfTriMesh::GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR&
       return false ;
 
   // Effettuo contro-offset
-   pSfr->Offset( -dTol, ICurve::OFF_EXTEND) ;
+   if ( ! pSfr->Offset( -dTol, ICurve::OFF_EXTEND))
+      return false ;
 
   // Recupero i contorni della regione
    for ( int i = 0 ; i < pSfr->GetChunkCount() ; ++ i) {
       for ( int j = 0 ; j < pSfr->GetLoopCount( i) ; ++ j) {
          PolyLine PL ;
-         if ( pSfr->ApproxLoopWithLines( i, j, LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
-            vPL.emplace_back( PL) ;
+         if ( ! pSfr->ApproxLoopWithLines( i, j, dMyLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL)) {
+            vPL.clear() ;
+            return false ;
+         }
+         vPL.emplace_back( PL) ;
       }
    }
 
@@ -1217,7 +1224,7 @@ SurfTriMesh::GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR&
 
 //----------------------------------------------------------------------------
 bool
-SurfTriMesh::GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria) const
+SurfTriMesh::GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria, double dLinTol) const
 {
   // Verifico lo stato
    if ( m_nStatus != OK)
@@ -1230,6 +1237,7 @@ SurfTriMesh::GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR&
 
   // Controlli su tolleranza
    dTol = max( dTol, 100 * EPS_SMALL) ;
+   double dMyLinTol = max( EPS_SMALL, dLinTol) ;
 
   // Determino il riferimento di proiezione
    Frame3d frOCS ; frOCS.Set( plPlane.GetPoint(), vtVers) ;
@@ -1253,14 +1261,16 @@ SurfTriMesh::GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR&
            // lo proietto sul piano e creo la regione
             if ( pgTria.Scale( frOCS, 1, 1, 0)) {
                PtrOwner<SurfFlatRegion> pSfrTria( GetBasicSurfFlatRegion( GetSurfFlatRegionFromPolyLine( pgTria.GetPolyLine()))) ;
-               if ( ! IsNull( pSfrTria)) {
+               if ( ! IsNull( pSfrTria)  &&  pSfrTria->IsValid()) {
                   if ( bAllTria  &&  Tria.GetN() * vtVers < 0)
                      pSfrTria->Invert() ;
                   pSfrTria->Offset( dTol, ICurve::OFF_FILLET) ;
                   if ( IsNull( pSfr))
                      pSfr.Set( pSfrTria) ;
-                  else
-                     pSfr->Add( *pSfrTria) ;
+                  else {
+                     if ( ! pSfr->Add( *pSfrTria))
+                        return false ;
+                  }
                }
             }
          }
@@ -1274,14 +1284,18 @@ SurfTriMesh::GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR&
       return true ;
 
   // Effettuo contro-offset
-   pSfr->Offset( -dTol, ICurve::OFF_EXTEND) ;
+   if ( ! pSfr->Offset( -dTol, ICurve::OFF_EXTEND))
+      return false ;
 
   // Recupero i contorni della regione
    for ( int i = 0 ; i < pSfr->GetChunkCount() ; ++ i) {
       for ( int j = 0 ; j < pSfr->GetLoopCount( i) ; ++ j) {
          PolyLine PL ;
-         if ( pSfr->ApproxLoopWithLines( i, j, LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
-            vPL.emplace_back( PL) ;
+         if ( ! pSfr->ApproxLoopWithLines( i, j, dMyLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL)) {
+            vPL.clear() ;
+            return false ;
+         }
+         vPL.emplace_back( PL) ;
       }
    }
 
@@ -3810,12 +3824,19 @@ SurfTriMesh::VerifyConnection( bool bShellsAndParts) const
       BBox3d b3Box ;
       PtrOwner<ISurfTriMesh> pStmShell ;
    } ;
+  // vettore di shell con vettori dei propri triangoli (per accelerare nei casi degeneri)  
+   INTMATRIX mShellTria( m_nShells) ;
+   for ( int i = 0 ; i < ssize( m_vTria) ; ++ i) {
+      if ( m_vTria[i].nShell < m_nShells)
+         mShellTria[m_vTria[i].nShell].push_back( i) ;
+   }
+  // classificazione delle shell
    vector<SHELLINFO> vOuterShells ;
    vector<SHELLINFO> vInnerShells ;
    INTVECTOR vOpenShells ;
    for ( int nSh = 0 ; nSh < m_nShells ; ++ nSh) {
      // se la shell è chiusa
-      if ( IsShellClosed( nSh)) {
+      if ( ssize( mShellTria[nSh]) >= 4  &&  IsShellClosed( nSh)) {
         // creo una superficie clonata dalla shell
          PtrOwner<ISurfTriMesh> pStmShell( CloneShell( nSh)) ;
          if ( IsNull( pStmShell)  ||  ! pStmShell->IsValid())
@@ -3827,7 +3848,9 @@ SurfTriMesh::VerifyConnection( bool bShellsAndParts) const
          BBox3d b3Box ;
          pStmShell->GetLocalBBox( b3Box, BBF_STANDARD) ;
         // la inserisco nel vettore opportuno
-         if ( dVol > 0)
+         if ( abs( dVol) < 1 * 1 * EPS_SMALL)
+            vOpenShells.push_back( nSh) ;
+         else if ( dVol > 0)
             vOuterShells.emplace_back( nSh, dVol, b3Box, Release( pStmShell)) ;
          else
             vInnerShells.emplace_back( nSh, dVol, b3Box, Release( pStmShell)) ;
@@ -3979,6 +4002,7 @@ SurfTriMesh::IsShellClosed( int nShell) const
       return false ;
   // ciclo sui triangoli della shell
    bool bClosed = true ;
+   int nTriaCnt = 0 ;
    for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
      // se triangolo non cancellato e della shell
       if ( m_vTria[i].nIdVert[0] != SVT_DEL  &&  m_vTria[i].nShell == nShell) {
@@ -3989,10 +4013,12 @@ SurfTriMesh::IsShellClosed( int nShell) const
             bClosed = false ;
             break ;  
          }
+         else
+            ++ nTriaCnt ;
       }
    }
   // restituisco il risultato
-   return bClosed ;
+   return ( bClosed  &&  nTriaCnt >= 4) ;
 }
 
 //----------------------------------------------------------------------------
@@ -4415,6 +4441,35 @@ SurfTriMesh::ClonePart( int nPart) const
    return Release( pSurfTM) ;
 }
 
+//----------------------------------------------------------------------------
+bool 
+SurfTriMesh::GetPartAndShellFromFacet( int nFacet, int& nPart, int& nShell) const
+{
+   // l'indice della faccia deve essere nei limiti
+   if ( nFacet < 0  ||  nFacet >= int( m_vFacet.size()))
+      return false ;
+
+   // mi assicuro che siano calcolate il numero di parti e di shell
+   int nParts = GetPartCount() ;
+
+   int nTria = m_vFacet[nFacet] ;
+   nShell = m_vTria[nTria].nShell ;
+
+   // scopro in quale part è la shell
+   int nPartTemp = 0 ;
+   nPart = - 1 ;
+   while ( nPartTemp < nParts  &&  nPart == - 1) {
+      for ( int i : m_vPart[nPartTemp].vShell) {
+         if ( i == nShell) {
+            nPart = nPartTemp ;
+            break ;
+         }
+      }
+      ++nPartTemp ;
+   }
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SurfTriMesh::ResetTFlags( void)

SurfTriMesh.h

@@ -16,6 +16,7 @@
 #include "ObjGraphicsMgr.h"
 #include "DllMain.h"
 #include "GeoObjRW.h"
+#include "GeoConst.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EGkHashGrids3d.h"
 #include "/EgtDev/Include/EGkPointGrid3d.h"
@@ -295,8 +296,8 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       bool GetTriangleSmoothNormals( int nId, TriNormals3d& TNrms) const override ;
       SurfTriMesh* CloneTriangle( int nT) const override ;
       bool GetLoops( POLYLINEVECTOR& vPL) const override ;
-      bool GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const override ;
-      bool GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const override ;
+      bool GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false, double dLinTol = LIN_TOL_STD) const override ;
+      bool GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false, double dLinTol = LIN_TOL_STD) const override ;
       int  GetFacetCount( void) const override ;
       int  GetFacetSize( void) const override
               { return int( m_vFacet.size()) ; }
@@ -347,6 +348,7 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       bool GetPartVolume( int nPart, double& dVolume) const override ;
       bool GetPartLoops( int nPart, POLYLINEVECTOR& vPL) const override ;
       SurfTriMesh* ClonePart( int nPart) const override ;
+      bool GetPartAndShellFromFacet( int nFacet, int& nPart, int& nShell) const override ;
       bool SetTFlag( int nId, int nTFlag) override ;
       bool GetTFlag( int nId, int& nFlag) const override ;
       int  GetMaxTFlag( void) const override 

Tool.h

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

Tree.cpp

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

Tree.h

@@ -23,7 +23,8 @@
 #include <utility>
 
 struct PairHashInt64 {
-   size_t operator()(const std::pair<int64_t, int64_t>& key) const {
+   size_t
+   operator()( const std::pair<int64_t, int64_t>& key) const {
       size_t h1 = std::hash<int64_t>{}(key.first) ;
       size_t h2 = std::hash<int64_t>{}(key.second) ;
       return h1 ^ (h2 << 1);  // Combine hashes
@@ -33,14 +34,20 @@ struct PairHashInt64 {
 //----------------------------------------------------------------------------
 struct Inters {
    int nIn ;
-   PNTVECTOR vpt ;
    int nOut ;
+   PNTVECTOR vpt ;
    bool bCCW ;
    int nChunk ;
    bool bSortedbyStart ;
-   // riordino le intersezioni per lato in senso antiorario dal top
-   // se ho più intersezioni che entrano in un lato le riordino considerando che percorro i lati in senso antiorario a partire da ptTR
-   bool operator < ( Inters& b)
+
+   // nIn e nOut sono flag che indicano da quale lato ho l'ingresso e l'uscita a partire dal lato top in senso antiorario
+   // oltre il 3 sono le celle adiacenti in diagonale al vertice-> 4 corrisponde al ptTl e da lì in senso antiorario
+   // -1 se la curva è sempre dentro la cella
+
+  // riordino le intersezioni per lato in senso antiorario dal top
+  // se ho più intersezioni che entrano in un lato le riordino considerando che percorro i lati in senso antiorario a partire da ptTR
+   bool
+   operator < ( Inters& b)
    {
      // trovo in che ordine stanno i due start, tenendo conto anche della possibilità che siano vertici
       INTVECTOR vEdges = { 7, 0, 4, 1, 5, 2, 6, 3} ;
@@ -75,7 +82,8 @@ struct Inters {
                ( bEqIn  &&  nEdgeIn == 3  &&  vpt[0].y < b.vpt[0].y)) ;
    }
 
-   static bool FirstEncounter( Inters& a, Inters& b)
+   static bool
+   FirstEncounter( Inters& a, Inters& b)
    {
      // riordino in base al lato toccato, o dall'uscita o  dall'ingresso, che viene prima.
      // ottengo l'ordine che avrei percorrendo il bordo da ptTR e considerando i loop che incontro, indipendentemente se li incontro nel punto di uscita o ingresso
@@ -135,18 +143,18 @@ struct Inters {
               ( nPos1 == 3  &&  a.vpt[nFirstA].y < b.vpt[nFirstB].y) ;
    }
 
-   bool operator == ( Inters& b)
+   bool
+   operator == ( Inters& b)
    {
       return AreSamePointExact( vpt[0], b.vpt[0]) ;
    }
-   bool operator != ( Inters& b)
+
+   bool
+   operator != ( Inters& b)
    {
       return ! AreSamePointExact( vpt[0], b.vpt[0]) ;
    }
 } ;
-// nIn e nOut sono flag che indicano da quale lato ho l'ingresso e l'uscita a partire dal lato top in senso antiorario
-// oltre il 3 sono le celle adiacenti in diagonale al vertice-> 4 corrisponde al ptTl e da lì in senso antiorario
-// -1 se la curva è sempre dentro la cella
 
 //----------------------------------------------------------------------------
 class Cell
@@ -160,11 +168,12 @@ class Cell
    //                 |                 |
    //                 |_________________|
    //   Edge 5 ( SW)     Edge 2 (Bottom)     Edge 6 ( SE)
-   public:
-   enum Collapsed { TO_VERIFY = -1,        // da verificare
-                    NO_COLLAPSE = 0,       // non ho coppie di lati collassati
-                    VERT_EDGES = 1,        // coppia di lati verticali(1-3) sono collassati
-                    HORIZ_EDGES  = 2} ;    // coppia di lati verticali(0-2) sono collassati
+
+   public :
+      enum Collapsed { TO_VERIFY = -1,        // da verificare
+                       NO_COLLAPSE = 0,       // non ho coppie di lati collassati
+                       VERT_EDGES = 1,        // coppia di lati verticali(1-3) sono collassati
+                       HORIZ_EDGES  = 2} ;    // coppia di lati verticali(0-2) sono collassati
 
    public :
       ~Cell( void) {}
@@ -336,4 +345,4 @@ class Tree
       INTVECTOR                   m_vnParents ;        // vettore delle celle ottenute dalla divisione preliminare in singole patch
       ICRVCOMPOPOVECTOR           m_vCCLoop2D ;        // vettore che contiene le CurveCompo che rappresentano i loop di trim tenendo conto della divisione in celle
       std::vector<std::pair<BIPNTVECTOR, ChainCurves>>    m_vCEdge2D ;        // vettore che le chain che rappresentano ciò che resta degli edge originali, tenendo conto dei trim.
-} ;
+} ;

VolZmap.cpp

@@ -29,8 +29,21 @@
 #include <thread>
 #include <future>
 
+#define DEBUG_REMOVE_FINS 0
+#if DEBUG_REMOVE_FINS
+   #include "/EgtDev/Include/EGkGeoObjSave.h"
+   #include "/EgtDev/Include/EGkGeoPoint3d.h"
+   #include "/EgtDev/Include/EGkGeoVector3d.h"
+   std::vector<IGeoObj*> VT ;
+   std::vector<Color> VC ;
+#endif
+
 using namespace std ;
 
+#if !defined(_WIN64)
+   int VolZmap::m_nDexelNbr = 0 ;
+#endif
+
 //----------------------------------------------------------------------------
 GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;
 
@@ -55,6 +68,13 @@ VolZmap::VolZmap(void)
 //----------------------------------------------------------------------------
 VolZmap::~VolZmap( void)
 {
+  // Se versione 32-bit aggiorno il numero di Dexel complessivi rimuovendo il numero dei correnti
+   #if !defined(_WIN64)
+      int nDexelNbr = 0 ;
+      for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
+         nDexelNbr += m_nDim[i] ;
+      m_nDexelNbr = max( 0, m_nDexelNbr - nDexelNbr) ;
+   #endif
 }
 
 //----------------------------------------------------------------------------
@@ -75,6 +95,13 @@ VolZmap::Clear( void)
    m_nNumBlock = 0 ;
    m_nConnectedCompoCount = 0 ;
    m_MapFrame.Reset() ;
+  // Se versione 32-bit aggiorno il numero di Dexel complessivi rimuovendo il numero dei correnti
+   #if !defined(_WIN64)
+      int nDexelNbr = 0 ;
+      for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
+         nDexelNbr += m_nDim[i] ;
+      m_nDexelNbr = max( 0, m_nDexelNbr - nDexelNbr) ;
+   #endif
    for ( int i = 0 ; i < N_MAPS ; ++ i) {
       m_nNx[i] = 0 ;
       m_nNy[i] = 0 ;
@@ -1694,16 +1721,15 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
    if ( ! IsValid())
       return false ;
 
-  // creo lo ZMap per i riferimenti degli intervalli sulle griglie
+  // Creo lo ZMap per i riferimenti degli intervalli sulle griglie
    PtrOwner<VolZmap> pZMapCopy( CloneBasicVolZmap( this)) ;
    if ( IsNull( pZMapCopy)  ||  ! pZMapCopy->IsValid())
       return false ;
 
-  // creo uno ZMap per gli intervalli da aggiungere o da rimuovere
+  // Creo uno ZMap per gli intervalli da aggiungere o da rimuovere
    PtrOwner<VolZmap> pZMapExtra( CreateBasicVolZmap()) ;
    if ( IsNull( pZMapExtra)  ||
-        ! pZMapExtra->CreateEmpty( m_MapFrame.Orig(), m_dMaxZ[1] - m_dMinZ[1],
-                                   m_dMaxZ[2] - m_dMinZ[2], m_dMaxZ[0] - m_dMinZ[0],
+        ! pZMapExtra->CreateEmpty( m_MapFrame.Orig(), m_dMaxZ[1] - m_dMinZ[1], m_dMaxZ[2] - m_dMinZ[2], m_dMaxZ[0] - m_dMinZ[0],
                                    m_dStep, IsTriDexel()))
       return false ;
 
@@ -1719,7 +1745,7 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
   // Ciclo sulle griglie
    for ( int nGrid = 0 ; nGrid < pZMapCopy->m_nMapNum ; ++ nGrid) {
      // Ciclo sul numero di dexel presenti nella Copia
-      for ( int nDex = 0 ; nDex < int( pZMapCopy->m_Values[nGrid].size()) ; ++ nDex) {
+      for ( int nDex = 0 ; nDex < ssize( pZMapCopy->m_Values[nGrid]) ; ++ nDex) {
         // Se il dexel corrente non ha sotto-intervalli passo al successivo
          if ( pZMapCopy->m_Values[nGrid][nDex].empty())
             continue ;
@@ -1727,9 +1753,9 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
          int nI = nDex % m_nNx[nGrid] ;
          int nJ = nDex / m_nNx[nGrid] ;
         // Recupero il numero di intervalli presenti nel Dexel corrente
-         int nIntervals = int( pZMapCopy->m_Values[nGrid][nDex].size()) ;
+         int nIntervals = ssize( pZMapCopy->m_Values[nGrid][nDex]) ;
         // Scorro gli intervalli presenti
-         for ( int nInfo = 0 ; nInfo < int( pZMapCopy->m_Values[nGrid][nDex].size()) ; ++ nInfo) {
+         for ( int nInfo = 0 ; nInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nInfo) {
            // Recupero l'intervallo corrente
             Data& Interval = pZMapCopy->m_Values[nGrid][nDex][nInfo] ;
            // --- Se richiesta prima estensione
@@ -1739,57 +1765,54 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
                AddIntervals( nGrid, nI, nJ, Interval.dMin - dToler, Interval.dMin + dToler,
                              Interval.vtMinN, Interval.vtMinN, nToolNum, true) ;
               // Se si sono uniti degli intervalli, potrei dover aggiungere degli spilloni nelle altre due direzioni
-               if ( IsTriDexel()  &&  nIntervals != int( m_Values[nGrid][nDex].size())) {
+               if ( IsTriDexel()  &&  nIntervals != ssize( m_Values[nGrid][nDex])) {
                  // Aggiorno gli intervalli correnti ( dato che il corrente si è unito al precedente)
                  // ( lascio invariato lo ZMapCopy)
-                  nIntervals = int( m_Values[nGrid][nDex].size()) ;
+                  nIntervals = ssize( m_Values[nGrid][nDex]) ;
                   pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
-                                                       pZMapCopy->m_Values[nGrid][nDex][nInfo-1].dMax,
-                                                       Interval.dMin, dToler, true,
-                                                       nToolNum, V_INVALID, V_INVALID) ;
+                                                       pZMapCopy->m_Values[nGrid][nDex][nInfo-1].dMax, Interval.dMin,
+                                                       dToler, true, nToolNum, V_INVALID, V_INVALID) ;
                }
               // *** Estremo superiore -> Intervallo : [ dMax - dToler, dMax + dToler ]
               // Aggiungo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
                AddIntervals( nGrid, nI, nJ, Interval.dMax - dToler, Interval.dMax + dToler,
                              Interval.vtMaxN, Interval.vtMaxN, nToolNum, true) ;
               // Se si sono uniti degli intervalli, potrei dover aggiungere degli spilloni nelle altre due direzioni
-               if ( IsTriDexel()  &&  nIntervals != int( m_Values[nGrid][nDex].size())) {
+               if ( IsTriDexel()  &&  nIntervals != ssize( m_Values[nGrid][nDex])) {
                  // Aggiorno gli intervalli correnti ( dato che il corrente si è unito al successivo)
                  // ( lascio invariato lo ZMapCopy)
-                  nIntervals = int( m_Values[nGrid][nDex].size()) ;
+                  nIntervals = ssize( m_Values[nGrid][nDex]) ;
                   pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
-                                                       Interval.dMax,
-                                                       pZMapCopy->m_Values[nGrid][nDex][nInfo+1].dMin, dToler, true,
-                                                       nToolNum, V_INVALID, V_INVALID) ;
+                                                       Interval.dMax, pZMapCopy->m_Values[nGrid][nDex][nInfo+1].dMin,
+                                                       dToler, true, nToolNum, V_INVALID, V_INVALID) ;
                }
             }
            // --- Se richiesta prima restrizione
             else {
-              // *** Estremo inferiore -> Intervallo : [ dMin - dToler, dMin + dToler ]
-              // Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
-               SubtractIntervals( nGrid, nI, nJ, Interval.dMin - dToler, Interval.dMin + dToler,
-                                  Interval.vtMinN, Interval.vtMinN, nToolNum, true) ;
-              // Se l'intervallo si è annullato, potrei dover sottrarre degli spilloni nelle altre due direzioni
-               if ( IsTriDexel()  &&  nIntervals != int( m_Values[nGrid][nDex].size())) {
-                 // Aggiorno gli intervalli correnti ( lascio invariato lo ZMapCopy)
-                  nIntervals = int( m_Values[nGrid][nDex].size()) ;
-                  pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
-                                                       Interval.dMin,
-                                                       Interval.dMax, dToler, true,
-                                                       Tool::UNDEF, V_INVALID, V_INVALID) ;
+              // Se la lunghezza dell'intervallo non è almeno il doppio della tolleranza
+               double dLen = Interval.dMax - Interval.dMin ;
+               if ( dLen < 2. * ( dToler + EPS_SMALL)) {
+                 // L'intervallo sparisce completamente
+                  SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL,
+                                     Interval.vtMinN, Interval.vtMaxN, nToolNum, true) ;
+                 // Rimuovo le parti di spillone nelle altre dimensioni
+                  if ( IsTriDexel()) {
+                     -- nIntervals ;
+                     pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
+                                                          Interval.dMin, Interval.dMax,
+                                                          dToler, true, Tool::UNDEF, V_INVALID, V_INVALID) ;
+                  }
                }
-              // *** Estremo superiore -> Intervallo : [ dMax - dToler, dMax + dToler ]
-              // Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
-               SubtractIntervals( nGrid, nI, nJ, Interval.dMax - dToler, Interval.dMax + dToler,
-                                  Interval.vtMaxN, Interval.vtMaxN, nToolNum, true) ;
-              // Se l'intervallo si è annullato, potrei dover sottrarre degli spilloni nelle altre due direzioni
-               if ( IsTriDexel()  &&  nIntervals != int( m_Values[nGrid][nDex].size())) {
-                 // Aggiorno gli intervalli correnti ( lascio invariato lo ZMapCopy)
-                  nIntervals = int( m_Values[nGrid][nDex].size()) ;
-                  pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
-                                                       Interval.dMin,
-                                                       Interval.dMax, dToler, true,
-                                                       Tool::UNDEF, V_INVALID, V_INVALID) ;
+              // Se sufficientemente lungo, allora
+               else {
+                 // *** Estremo inferiore -> Intervallo : [ dMin, dMin + dToler ]
+                 // Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
+                  SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMin + dToler,
+                                     Interval.vtMinN, Interval.vtMinN, nToolNum, true) ;
+                 // *** Estremo superiore -> Intervallo : [ dMax - dToler, dMax ]
+                 // Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
+                  SubtractIntervals( nGrid, nI, nJ, Interval.dMax - dToler, Interval.dMax + EPS_SMALL,
+                                     Interval.vtMaxN, Interval.vtMaxN, nToolNum, true) ;
                }
             }
          }
@@ -1799,12 +1822,12 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
   // Ciclo sulle griglie ( uso lo Zmap Corrente, lascio invariato pZMapCopy)
    for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
      // Ciclo sul numero di dexel presenti
-      for ( int nDex = 0 ; nDex < int( m_Values[nGrid].size()) ; ++ nDex) {
+      for ( int nDex = 0 ; nDex < ssize( m_Values[nGrid]) ; ++ nDex) {
         // Se l'intervallo è vuoto, non faccio nulla
          if ( m_Values[nGrid][nDex].empty())
             continue ;
         // Per ogni intervallo ricavato fino ad ora, restringo della tolleranza
-         for ( int nInfo = 0 ; nInfo < int( m_Values[nGrid][nDex].size()) ; ++ nInfo) {
+         for ( int nInfo = 0 ; nInfo < ssize( m_Values[nGrid][nDex]) ; ++ nInfo) {
            // --- Se richiesta prima estensione
             if ( bIsExtensionFirst) {
                m_Values[nGrid][nDex][nInfo].dMin += dToler ;
@@ -1816,7 +1839,7 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
                m_Values[nGrid][nDex][nInfo].dMax += dToler ;
             }
            // Definisco il colore
-            for ( int nOrigInfo = 0 ; nOrigInfo < int( pZMapCopy->m_Values[nGrid][nDex].size()) ; ++ nOrigInfo) {
+            for ( int nOrigInfo = 0 ; nOrigInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nOrigInfo) {
                if ( pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].dMin - m_Values[nGrid][nDex][nInfo].dMin < EPS_SMALL)
                   m_Values[nGrid][nDex][nInfo].nToolMin = pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].nToolMin ;
                if ( pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].dMax - m_Values[nGrid][nDex][nInfo].dMax < EPS_SMALL)
@@ -1830,7 +1853,7 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
   // Ciclo sulle griglie ( uso lo ZmapExtra, lascio invariato pZMapCopy)
    for ( int nGrid = 0 ; nGrid < pZMapExtra->m_nMapNum ; ++ nGrid) {
      // Ciclo sul numero di dexel presenti
-      for ( int nDex = 0 ; nDex < int( pZMapExtra->m_Values[nGrid].size()) ; ++ nDex) {
+      for ( int nDex = 0 ; nDex < ssize( pZMapExtra->m_Values[nGrid]) ; ++ nDex) {
         // Se l'intervallo è vuoto, non faccio nulla
          if ( pZMapExtra->m_Values[nGrid][nDex].empty())
             continue ;
@@ -1838,19 +1861,19 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
          int nI = nDex % m_nNx[nGrid] ;
          int nJ = nDex / m_nNx[nGrid] ;
         // Per ogni intervallo ricavato fino ad ora...
-         for ( int nInfo = 0 ; nInfo < int( pZMapExtra->m_Values[nGrid][nDex].size()) ; ++ nInfo) {
+         for ( int nInfo = 0 ; nInfo < ssize( pZMapExtra->m_Values[nGrid][nDex]) ; ++ nInfo) {
             double dMin = pZMapExtra->m_Values[nGrid][nDex][nInfo].dMin ;
             double dMax = pZMapExtra->m_Values[nGrid][nDex][nInfo].dMax ;
             Vector3d vtNMin = pZMapExtra->m_Values[nGrid][nDex][nInfo].vtMinN ;
             Vector3d vtNMax = pZMapExtra->m_Values[nGrid][nDex][nInfo].vtMaxN ;
            // --- Se richiesta prima estensione
             if ( bIsExtensionFirst) {
-              // ... aggiungo i contributi
-                AddIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, true) ;
+              // Aggiungo i contributi
+               AddIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, true) ;
             }
            // --- Se richiesta prima restrizione
             else {
-              // ... sottraggo i contributi
+              // Sottraggo i contributi
                SubtractIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, true) ;
             }
          }
@@ -1868,6 +1891,187 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+VolZmap::RemoveFins( const Vector3d& vtDir, double dThick)
+{
+  // Verifico la Validità dello ZMap
+   if ( ! IsValid())
+      return false ;
+
+  // Per sicurezza normalizzo la direzione
+   Vector3d vtMyDir = vtDir ;
+   if ( ! vtMyDir.Normalize())
+      return false ;
+   double dMyThick = max( 10. * EPS_SMALL, dThick) ;
+
+  // Creo lo ZMap per i riferimenti degli intervalli sulle griglie
+   PtrOwner<VolZmap> pZMapCopy( CloneBasicVolZmap( this)) ;
+   if ( IsNull( pZMapCopy)  ||  ! pZMapCopy->IsValid())
+      return false ;
+
+  // Creo uno ZMap per gli intervalli da aggiungere e successivamente da rimuovere
+   VolZmap ZMapExtra ;
+   if ( ! ZMapExtra.CreateEmpty( m_MapFrame.Orig(), m_dMaxZ[1] - m_dMinZ[1], m_dMaxZ[2] - m_dMinZ[2], m_dMaxZ[0] - m_dMinZ[0],
+                                  m_dStep, IsTriDexel()))
+      return false ;
+
+   const double FIN_ANG_DEG_TOL = 55. ; // Approssimazione per eccesso dell'angolo massimo possibile tra una direzione generica
+                                        // e un versore della terna globale ( arccos( 1 / sqrt( 3) ~ 54.375)
+   const double COS_FIN_ANG_DEG_TOL = cos( FIN_ANG_DEG_TOL * DEGTORAD) ;
+   const int NUM_TOOL = 1000 ;         // Identificativo Utensile per riconoscere le parti rimosse
+
+  // NB. Tutti i parametri sono sempre presi dalla Copia dello ZMap corrente
+  // Ciclo sulle griglie
+   DBLVECTOR vdThicks ;
+   if ( IsTriDexel())
+      vdThicks = { dThick, dThick, dThick} ;
+   else
+      vdThicks = { dThick} ;
+   for ( int nGrid = 0 ; nGrid < pZMapCopy->m_nMapNum ; ++ nGrid) {
+     // Verifico se l'angolo tra la direzione degli spilloni della griglia corrente è sotto alla tolleranza rispetto alla direzione
+      double dCosDir = ( nGrid == 0 ? vtMyDir.z :
+                       ( nGrid == 1 ? vtMyDir.x :
+                                      vtMyDir.y)) ;
+      if ( abs( dCosDir) < COS_FIN_ANG_DEG_TOL + EPS_ANG_SMALL)
+         continue ;
+     // Aggiorno l'effettivo valore dello spessore da considerare
+      double dCurrThick = dMyThick / abs( dCosDir) ; // (sicuramente esiste, essendo 55deg il limite)
+      vdThicks[nGrid] = dCurrThick ;
+     // Ciclo sul numero di dexel presenti nella Copia
+      for ( int nDex = 0 ; nDex < ssize( pZMapCopy->m_Values[nGrid]) ; ++ nDex) {
+        // Se il dexel corrente non ha sotto-intervalli passo al successivo
+         if ( pZMapCopy->m_Values[nGrid][nDex].empty())
+            continue ;
+        // Indici del dexel
+         int nI = nDex % m_nNx[nGrid] ;
+         int nJ = nDex / m_nNx[nGrid] ;
+        // Scorro gli intervalli presenti
+         for ( int nInfo = 0 ; nInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nInfo) {
+           // Recupero l'intervallo corrente
+            Data& Interval = pZMapCopy->m_Values[nGrid][nDex][nInfo] ;
+           // Se entrambi gli estremi dell'intervallo non sono stati toccati dall'utensile, allora passo al successivo
+            bool bAnalyze = ( ( Interval.nToolMin == 1  &&  Interval.nToolMax == 1)  ||
+                              ( Interval.dMax > m_dMaxZ[nGrid] - EPS_SMALL  ||  Interval.dMin < m_dMinZ[nGrid] + EPS_SMALL)) ;
+            if ( ! bAnalyze)
+               continue ;
+           // Se la lunghezza dell'intervallo è superiore allo spessore richiesto, non faccio nulla
+            double dLen = Interval.dMax - Interval.dMin ;
+            if ( dLen > dCurrThick + EPS_ZERO)
+               continue ;
+           // Se ZMap composto da una sola griglia, elimino il contributo lungo la direzione corrente
+            if ( ! IsTriDexel()) {
+               SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL,
+                                  - Interval.vtMinN, - Interval.vtMaxN, NUM_TOOL, true) ;
+            }
+           // Se Tridexel, aggiungo il contributo del cubetto corrente allo ZMap Extra
+            else
+               ZMapExtra.AddStripInterval( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL, NUM_TOOL) ;
+         }
+      }
+   }
+  // Se non ho aggiunto alcun elemento allo ZMap Extra, non devo fare nulla
+   if ( ! ZMapExtra.IsValid())
+      return true ;
+   #if DEBUG_REMOVE_FINS
+      SaveGeoObj( ZMapExtra.Clone(), "C:\\Temp\\VolZMapSubt0.nge") ;
+   #endif
+
+  // Ciclo sulle griglie dello ZMap Extra
+   for ( int nGrid = 0 ; nGrid < ZMapExtra.m_nMapNum ; ++ nGrid) {
+     // Ciclo sul numero di dexel presenti
+      for ( int nDex = 0 ; nDex < ssize( ZMapExtra.m_Values[nGrid]) ; ++ nDex) {
+        // Se l'intervallo è vuoto, non faccio nulla
+         if ( ZMapExtra.m_Values[nGrid][nDex].empty())
+            continue ;
+        // Indici del dexel
+         int nI = nDex % m_nNx[nGrid] ;
+         int nJ = nDex / m_nNx[nGrid] ;
+        // Scorro i gli Intervalli dello Spillone corrente
+         for ( int nInfo = 0 ; nInfo < ssize( ZMapExtra.m_Values[nGrid][nDex]) ; ++ nInfo) {
+            double dMin = ZMapExtra.m_Values[nGrid][nDex][nInfo].dMin ;
+            double dMax = ZMapExtra.m_Values[nGrid][nDex][nInfo].dMax ;
+            Vector3d vtNMin = ZMapExtra.m_Values[nGrid][nDex][nInfo].vtMinN ;
+            Vector3d vtNMax = ZMapExtra.m_Values[nGrid][nDex][nInfo].vtMaxN ;
+           // sottraggo tali contributi
+            SubtractIntervals( nGrid, nI, nJ, dMin, dMax, - vtNMin, - vtNMax, NUM_TOOL, true) ;
+         }
+      }
+   }
+   if ( ! IsValid())
+      return true ;
+   #if DEBUG_REMOVE_FINS
+      SaveGeoObj( this->Clone(), "C:\\Temp\\VolZMapSubt1.nge") ;
+   #endif
+
+  // Sistemo le Normali sullo ZMap ricavato
+   for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
+     // Ciclo sul numero di dexel presenti
+      for ( int nDex = 0 ; nDex < ssize( m_Values[nGrid]) ; ++ nDex) {
+        // Se l'Intervallo è vuoto non faccio nulla
+         if ( m_Values[nGrid][nDex].empty())
+            continue ;
+        // Indici del dexel
+         int nI = nDex % m_nNx[nGrid] ;
+         int nJ = nDex / m_nNx[nGrid] ;
+        // Scorro gli intervalli dello spillone corrente
+         for ( int nInfo = 0 ; nInfo < ssize( m_Values[nGrid][nDex]) ; ++ nInfo) {
+           // Se intervallo con estremo minimo derivante dalla sottrazione con ZMapExtra, medio le normali
+            int nToolMin = m_Values[nGrid][nDex][nInfo].nToolMin ;
+            if ( nToolMin == NUM_TOOL) {
+              // Recupero il valore minimo, se sul bordo dello ZMap corrente non faccio nulla
+               double dMin = m_Values[nGrid][nDex][nInfo].dMin ;
+               if ( dMin > m_dMinZ[nGrid] + EPS_SMALL) {
+                  Vector3d vtMinN = V_NULL ;
+                  double dZMin = INFINITO ;
+                  if ( ! pZMapCopy->ComputePointAndNormalForRemovingFins( nGrid, nI, nJ, dMin, vtMyDir, dThick, true, 1, vtMinN, dZMin)) {
+                     vtMinN = - ( nGrid == 0 ? m_MapFrame.VersZ() : nGrid == 1 ? m_MapFrame.VersX() : m_MapFrame.VersY()) ;
+                     dZMin = dMin ;
+                  }
+                  m_Values[nGrid][nDex][nInfo].vtMinN = vtMinN ;
+                  m_Values[nGrid][nDex][nInfo].dMin = dZMin ;
+               }
+            }
+           // Se intervallo con estremo massimo derivante dalla sottrazione con ZMapExtra, medio le normali
+            int nToolMax = m_Values[nGrid][nDex][nInfo].nToolMax ;
+            if ( nToolMax == NUM_TOOL) {
+              // Recupero il valore massimo, se sul bordo dello ZMap corrente non faccio nulla
+               double dMax = m_Values[nGrid][nDex][nInfo].dMax ;
+               if ( dMax < m_dMaxZ[nGrid] - EPS_SMALL) {
+                  Vector3d vtMaxN = V_NULL ;
+                  double dZMax = INFINITO ;
+                  if ( ! pZMapCopy->ComputePointAndNormalForRemovingFins( nGrid, nI, nJ, dMax, vtMyDir, dThick, false, 1, vtMaxN, dZMax)) {
+                     vtMaxN = ( nGrid == 0 ? m_MapFrame.VersZ() : nGrid == 1 ? m_MapFrame.VersX() : m_MapFrame.VersY()) ;
+                     dZMax = dMax ;
+                  }
+                  m_Values[nGrid][nDex][nInfo].vtMaxN = vtMaxN ;
+                  m_Values[nGrid][nDex][nInfo].dMax = dZMax ;
+               }
+            }
+         }
+      }
+   }
+
+  // Riassegno il Tool dell'utensile alle nuove parti
+   for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
+     // Ciclo sul numero di dexel presenti
+      for ( int nDex = 0 ; nDex < ssize( m_Values[nGrid]) ; ++ nDex) {
+        // Se l'Intervallo è vuoto non faccio nulla
+         if ( m_Values[nGrid][nDex].empty())
+            continue ;
+        // Scorro gli intervalli dello spillone corrente
+         for ( int nInfo = 0 ; nInfo < ssize( m_Values[nGrid][nDex]) ; ++ nInfo) {
+            if ( m_Values[nGrid][nDex][nInfo].nToolMin == NUM_TOOL)
+               m_Values[nGrid][nDex][nInfo].nToolMin = 1 ;
+            if ( m_Values[nGrid][nDex][nInfo].nToolMax == NUM_TOOL)
+               m_Values[nGrid][nDex][nInfo].nToolMax = 1 ;
+         }
+      }
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)

VolZmap.h

@@ -37,6 +37,19 @@ struct AppliedVector {
    int nPropIndex ;
 } ;
 
+struct IntersToCheck {
+   Point3d ptInters ;
+   Vector3d vtN ;
+   double dU ;
+   int nG ;
+   int nI ;
+   int nJ ;
+   IntersToCheck( const Point3d& _ptI, const Vector3d& _vtN, double _dU, int _nG, int _nI, int _nJ) :
+      ptInters( _ptI), vtN( _vtN), dU( _dU), nG( _nG), nI( _nI), nJ( _nJ) { ;}
+};
+
+typedef std::vector<IntersToCheck> INTTOCHECKVEC ;
+
 //----------------------------------------------------------------------------
 class VolZmap : public IVolZmap, public IGeoObjRW
 {
@@ -81,10 +94,10 @@ class VolZmap : public IVolZmap, public IGeoObjRW
    public :                      // IVolZmap
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
       bool Clear( void) override ;
-      bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) override ;
-      bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) override ;
-      bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) override ;
-      bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0) override ;
+      bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) override ;
+      bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) override ;
+      bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) override ;
+      bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0, int* nError = nullptr, bool bForceClosed = false) override ;
       int  GetBlockCount( void) const override ;
       int  GetBlockUpdatingCounter( int nBlock) const override ;
       bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const override ;
@@ -151,6 +164,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool AddSurfTm( const ISurfTriMesh* pStm) override ;
       bool SubtractSurfTm( const ISurfTriMesh* pStm) override ;
       bool MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum) override ;
+      bool RemoveFins( const Vector3d& vtDir, double dThick) override ;
       bool Offset( double dOffs, int nType) override ;
 
    public :                      // IGeoObjRW
@@ -226,7 +240,16 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       typedef std::unordered_map<int, Voxel> VoxelContainer ;
      // Unordered map per la coerenza topologica
       typedef std::unordered_map<int, bool> InterVoxMatter ;
-      
+      #if !defined(_WIN64)
+        // Numero massimo approssimativo di Dexel per versione 32-bit per evitare Crash con memoria
+         #if defined(_DEBUG)
+            static const int MAX_DEXEL_32_BIT = 3000000 + 1 ;
+         #else
+            static const int MAX_DEXEL_32_BIT = 5000000 + 1 ;
+         #endif
+         static int m_nDexelNbr ;                              // numero corrente di Dexel presenti
+      #endif
+
    private :
       bool CopyFrom( const VolZmap& clSrc) ;
       bool ResetGraphics( void) ;
@@ -262,6 +285,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool UniformIntervalsInVoxel( int nGrid, int nI, int nJ, double dZMin, double dZMax,
                                     double dToler, bool bAdd, int nToolNum, const Vector3d& vtToolMin,
                                     const Vector3d& vtToolMax) ;
+      bool AddStripInterval( int nGrid, int nI, int nJ, double dZMin, double dZMax, int nToolNum) ;
       bool ManageSubIntervalInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, int nK, double& dMin, double& dMax,
                                      Vector3d& vtMin, Vector3d& vtMax) ;
      // Spostamenti utensile
@@ -382,9 +406,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                            double& dU1, double& dU2) const ;
       bool GetDepthWithDexel( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength) const ;
       bool GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength) const ;
-      bool IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
-                               const Frame3d& CylFrame, double dH, double dRad, bool bTapLow, bool bTapUp,
-                               Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) const ;
       bool IntersLineEllipticalCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
                                          const Frame3d& CircFrame, double dRad, double dLongMvLen, double dOrtMvLen,
                                          bool bTapLow, bool bTapUp,
@@ -455,11 +476,14 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool CDeSimpleTorus( const Frame3d& frTorus, double dMaxRad, double dMinRad, bool bPrecise = false) const ;
       // Funzione per crezione solido in parallelo
       bool CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
-                          const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM) ;
+                          const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM, bool bForceClosed) ;
       bool AddMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
                        const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM) ;
       bool SubtractMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
                             const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM) ;
+      bool AdjustDexelThroughCracks( int nG, const Vector3d& vtLen, const INTTOCHECKVEC& vIntToCheck, const Point3d& ptMapOrig,
+                                     const ISurfTriMesh& Surf, const IntersParLinesSurfTm& intPLSTM) ;
+      DBLDBLVECTOR GetNeighbours( int nG, int nI, int nJ, double dPar) ;
      // Funzioni per Offset di superfici
       bool InitVolZMapOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol) ;
       bool InitVolZMapThickeningOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol) ;
@@ -486,6 +510,11 @@ class VolZmap : public IVolZmap, public IGeoObjRW
      // Funzioni per Offset di Zmap
       bool OffsetFillet( double dOffs) ;
       bool OffsetSharped( double dOffs, int nType) ;
+     // Funzione analisi punti/Normali per Alette
+      bool GetLocalPoint( int nGrid, int nI, int nJ, double dZ, Point3d& ptLoc) ;
+      bool ComputePointAndNormalForRemovingFins( int nGrid, int nI, int nJ, double dZ,
+                                                 const Vector3d& vtDir, double dThick, bool bMinVsMax, int nTool,
+                                                 Vector3d& vtN, double& dNewZ) ;
 
    private :
       enum Move5Axis {

VolZmapCalculus.cpp

@@ -2071,127 +2071,6 @@ VolZmap::CDeSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecise)
    return false ;
 }
 
-//----------------------------------------------------------------------------
-// Riferimento con origine nel centro della base e asse di simmetria coincidente con l'asse Z.
-// La funzione restituisce true in caso di intersezione, false altrimenti.
-//----------------------------------------------------------------------------
-bool
-VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
-                             const Frame3d& CylFrame, double dH, double dRad, bool bTapLow, bool bTapUp,
-                             Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) const
-{
-  // Porto la linea nel riferimento del cilindro
-   Point3d ptP = GetToLoc( ptLineSt, CylFrame) ;
-   Vector3d vtV = GetToLoc( vtLineDir, CylFrame) ;
-
-  // Determino le eventuali intersezioni con le due basi a quota minima e massima (solo se linea non parallela ad esse)
-   int nBasInt = 0 ;
-   if ( abs( vtV.z) > EPS_ZERO) {
-      // le linee tangenti al cilindro non sono considerate intersecanti
-      double dEpsRad = ( vtV.IsZeroXY() ? - EPS_SMALL : EPS_SMALL) ;
-      ptInt1 = ptP + ( ( 0 - ptP.z) / vtV.z) * vtV ;
-      if ( ptInt1.x * ptInt1.x + ptInt1.y * ptInt1.y < dRad * dRad + 2 * dRad * dEpsRad) {
-         nBasInt += 1 ;
-         vtN1 = Z_AX ;
-      }
-      ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;  
-      if ( ptInt2.x * ptInt2.x + ptInt2.y * ptInt2.y < dRad * dRad + 2 * dRad * dEpsRad) {
-         nBasInt += 2 ;
-         vtN2 = - Z_AX ;
-      }
-   }
-
-  // Se la linea interseca entrambe le basi, si sono trovate le due intersezioni
-   if ( nBasInt == 3) {
-     // Porto i punti e i versori nel riferimento globale
-      ptInt1.ToGlob( CylFrame) ;
-      vtN1.ToGlob( CylFrame) ;
-      ptInt2.ToGlob( CylFrame) ;
-      vtN2.ToGlob( CylFrame) ;
-     // Trovate intersezioni
-      return true ;
-   }
-   
-  // Determino le intersezioni con la superficie laterale del cilindro
-   DBLVECTOR vdCoeff{ ptP.x * ptP.x + ptP.y * ptP.y - dRad * dRad,
-                      2 * ( ptP.x * vtV.x + ptP.y * vtV.y),
-                      vtV.x * vtV.x + vtV.y * vtV.y} ;
-   DBLVECTOR vdRoots ;
-   int nRoot = PolynomialRoots( 2, vdCoeff, vdRoots) ;
-
-  // Epsilon per piani di tappo
-   double dEpsLow = ( bTapLow ? - EPS_SMALL : EPS_SMALL) ;
-   double dEpsUp = ( bTapUp ? EPS_SMALL : - EPS_SMALL) ;
-
-  // Elimino le soluzioni cha danno intersezioni fuori dai limiti in Z del cilindro
-   if ( nRoot == 2) {
-      double dIntZ2 = ptP.z + vdRoots[1] * vtV.z ;
-      if ( dIntZ2 < 0 + dEpsLow  ||  dIntZ2 > dH + dEpsUp)
-         -- nRoot ;
-   }
-   if ( nRoot >= 1) {
-      double dIntZ1 = ptP.z + vdRoots[0] * vtV.z ;
-      if ( dIntZ1 < 0 + dEpsLow  ||  dIntZ1 > dH + dEpsUp) {
-         if ( nRoot == 2)
-            vdRoots[0] = vdRoots[1] ;
-         -- nRoot ;
-      }
-   }
-
-  // Due soluzioni: la retta interseca due volte la superficie laterale
-   if ( nRoot == 2) {
-     // Punti di intersezione con la superficie del cilindro
-      ptInt1 = ptP + vdRoots[0] * vtV ;
-      ptInt2 = ptP + vdRoots[1] * vtV ;
-     // Determino le normali
-      vtN1.Set( -ptInt1.x, -ptInt1.y, 0) ;
-      vtN1.Normalize() ;
-      vtN2.Set( -ptInt2.x, -ptInt2.y, 0) ;
-      vtN2.Normalize() ;
-     // Porto i punti e i versori nel riferimento globale
-      ptInt1.ToGlob( CylFrame) ;
-      vtN1.ToGlob( CylFrame) ;
-      ptInt2.ToGlob( CylFrame) ;
-      vtN2.ToGlob( CylFrame) ;
-     // Trovate intersezioni
-      return true ;
-   }
-   
-  // Una soluzione : la retta interseca la superficie laterale e un piano
-   else if ( nRoot == 1) {
-     // Se piano superiore
-      if ( nBasInt == 2) {
-        // Punto di intersezione
-         ptInt1 = ptP + vdRoots[0] * vtV ;
-        // Normale alla superficie del cilindro verso l'interno
-         vtN1.Set( -ptInt1.x, -ptInt1.y, 0) ;
-         vtN1.Normalize() ;
-      }
-     // altrimenti piano inferiore
-      else if ( nBasInt == 1) {
-        // Punto di intersezione
-         ptInt2 = ptP + vdRoots[0] * vtV ;
-        // Normale alla superficie del cilindro verso l'interno
-         vtN2.Set( -ptInt2.x, -ptInt2.y, 0) ;
-         vtN2.Normalize() ;
-      }
-     // altrimenti niente
-      else
-         return false ;
-     // Porto i punti e i versori nel riferimento globale
-      ptInt1.ToGlob( CylFrame) ;
-      vtN1.ToGlob( CylFrame) ;
-      ptInt2.ToGlob( CylFrame) ;
-      vtN2.ToGlob( CylFrame) ;
-     // Trovate intersezioni
-      return true ;
-   }
-
-  // Nessuna soluzione : nessuna intersezione 
-   else
-      return false ;
-}
-
 //----------------------------------------------------------------------------
 // Riferimento con origine nel vertice del cono e asse di simmetria coincidente con l'asse Z.
 // La funzione restituisce true in caso di intersezione, false altrimenti.

VolZmapCreation.cpp

@@ -19,6 +19,7 @@
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkStmFromCurves.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
+#include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include <future>
 
@@ -27,8 +28,8 @@ using namespace std ;
 // ------------------------- CREAZIONE MAPPA --------------------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
-bool 
-VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex)
+bool
+VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError)
 {
   // Controlli sull'ammissibilità delle dimensioni lineari del grezzo e del passo
    if ( dStep < EPS_SMALL  ||  dDimX < EPS_SMALL  ||  dDimY < EPS_SMALL  ||  dDimZ < EPS_SMALL)
@@ -51,7 +52,7 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
    m_nNx[0] = max( int( ( dDimX + EPS_SMALL) / m_dStep + 0.5), 1) ;
    m_nNy[0] = max( int( ( dDimY + EPS_SMALL) / m_dStep + 0.5), 1) ;
 
-  // Numero di componenti connesse 
+  // Numero di componenti connesse
    m_nConnectedCompoCount = 1 ;
 
   // Se tridexel
@@ -67,7 +68,7 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
       m_nNx[1] = 0 ;
       m_nNy[1] = 0 ;
       m_nNx[2] = 0 ;
-      m_nNy[2] = 0 ; 
+      m_nNy[2] = 0 ;
    }
 
    // Definisco il numero di blocchi lungo x,y e z
@@ -81,12 +82,24 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
       m_nDim[i] = m_nNx[i] * m_nNy[i] ;
 
+  // Se versione 32-bit controllo di non superare il numero di Dexel massimo
+   #if !defined(_WIN64)
+      for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
+         m_nDexelNbr += m_nDim[i] ;
+      if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
+         Clear() ;
+         if ( nError != nullptr)
+            *nError = 1 ;
+         return false ;
+      }
+   #endif
+
   // Creazione delle celle per ogni mappa
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
       m_Values[i].resize( m_nDim[i]) ;
 
   // Riempimento delle celle
-   for ( int i = 0 ; i < m_nMapNum ; ++ i)
+   for ( int i = 0 ; i < m_nMapNum ; ++ i) {
       for ( int j = 0 ; j < m_nDim[i] ; ++ j) {
 
         // Aggiungo il tratto al dexel vuoto
@@ -98,7 +111,7 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
          switch ( i) {
          case 0 :
             m_Values[i][j][0].vtMinN = - Z_AX ;
-            m_Values[i][j][0].dMax = dDimZ ; 
+            m_Values[i][j][0].dMax = dDimZ ;
             m_Values[i][j][0].vtMaxN = Z_AX ;
             m_Values[i][j][0].nToolMax = 0 ;
             break ;
@@ -113,9 +126,10 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
             m_Values[i][j][0].dMax = dDimY ;
             m_Values[i][j][0].vtMaxN = Y_AX ;
             m_Values[i][j][0].nToolMax = 0 ;
-            break ; 
+            break ;
          }
       }
+   }
 
   // Definizione delle limitazioni iniziali in Z per ogni mappa
    m_dMinZ[0] = 0 ;
@@ -136,7 +150,7 @@ VolZmap::Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, d
 
 //----------------------------------------------------------------------------
 bool 
-VolZmap::CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex)
+VolZmap::CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError)
 {
   // Controlli sull'ammissibilità delle dimensioni lineari del grezzo e del passo
    if ( dStep < EPS_SMALL  ||  dDimX < EPS_SMALL  ||  dDimY < EPS_SMALL  ||  dDimZ < EPS_SMALL)
@@ -187,6 +201,18 @@ VolZmap::CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDi
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
       m_nDim[i] = m_nNx[i] * m_nNy[i] ;
 
+  // Se versione 32-bit controllo di non superare il numero di Dexel massimo
+   #if !defined(_WIN64)
+      for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
+         m_nDexelNbr += m_nDim[i] ;
+      if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
+         Clear() ;
+         if ( nError != nullptr)
+            *nError = 1 ;
+         return false ;
+      }
+   #endif
+
   // Creazione delle celle per ogni mappa
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
       m_Values[i].resize( m_nDim[i]) ;
@@ -210,7 +236,7 @@ VolZmap::CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDi
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) 
+VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex, int* nError)
 {
   // Aggiorno la dimensione della mappa 1 o 3
    m_nMapNum = ( bTriDex ? 3 : 1) ;
@@ -250,14 +276,35 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
       m_nNx[1] = m_nNy[0] ;
       m_nNy[1] = int( ( dDimZ + EPS_SMALL) / m_dStep + 0.5) ;
       m_nDim[1] = m_nNx[1] * m_nNy[1] ;
-      m_Values[1].resize( m_nDim[1]) ;
       m_nNx[2] = m_nNy[1] ;
       m_nNy[2] = m_nNx[0] ;
       m_nDim[2] = m_nNx[2] * m_nNy[2] ;
+     // Se versione 32-bit controllo di non superare il numero di Dexel massimo
+      #if !defined(_WIN64)
+         for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
+            m_nDexelNbr += m_nDim[i] ;
+         if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
+            Clear() ;
+            if ( nError != nullptr)
+               *nError = 1 ;
+            return false ;
+         }
+      #endif
+      m_Values[1].resize( m_nDim[1]) ;
       m_Values[2].resize( m_nDim[2]) ;
    }
-
+  // Se dimensione singola
    else {
+     // Se versione 32-bit controllo di non superare il numero di Dexel massimo
+      #if !defined(_WIN64)
+         m_nDexelNbr += m_nDim[0] ;
+         if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
+            Clear() ;
+            if ( nError != nullptr)
+               *nError = 1 ;
+            return false ;
+         }
+      #endif
       m_nNx[1] = 0 ;
       m_nNy[1] = 0 ;
       m_nDim[1] = 0 ;
@@ -496,7 +543,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
 //----------------------------------------------------------------------------
 bool
 VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
-                        const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM)
+                        const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM, bool bForceClosed)
 {
    if ( nMap < 0  ||  nMap > 2  ||
         nInfI < 0  ||  nInfI > m_nNx[nMap]  ||
@@ -507,6 +554,8 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
 
    double dCosSmall = sin( EPS_ANG_SMALL * DEGTORAD) ;
 
+   INTTOCHECKVEC vIntToCheck ;
+
    // Determinazione e ridimensionamento dei dexel interni alla trimesh
    for ( int i = nInfI ; i < nSupI ; ++ i) {
       for ( int j = nInfJ ; j < nSupJ ; ++ j) {
@@ -538,6 +587,14 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
 
          int nInt = int( IntersectionResults.size()) ;
 
+         if ( nInt == 1) {
+            int nT = IntersectionResults[0].nT ;
+            int nF = Surf.GetFacetFromTria( nT) ;
+            Vector3d vtN ; Surf.GetFacetNormal( nF, vtN) ;
+            vIntToCheck.emplace_back( IntersectionResults[0].ptI, vtN, IntersectionResults[0].dU, nMap, i, j) ;
+            continue ;
+         }
+
          int nPos = j * m_nNx[nMap] + i ;
 
          bool bInside = false ;
@@ -546,6 +603,14 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
 
          for ( int k = 0 ; k < nInt ; ++ k) {
 
+            if ( k > 0) {
+               int z = k - 1 ;
+               // controllo se l'intersezione corrente è coincidente con la precedente, per esempio se ILTT == 4 ( intersezione su un lato di un triangolo, quindi con 2 triangoli)
+               if ( IntersectionResults[k].dU - IntersectionResults[z].dU < EPS_SMALL  &&
+                  IntersectionResults[k].dCosDN - IntersectionResults[z].dCosDN < EPS_SMALL)
+                  continue ;
+            }
+
             int nIntType = IntersectionResults[k].nILTT ;
 
             // Se c'è intersezione
@@ -555,7 +620,12 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
 
                // entro nella superficie trimesh
                if ( dCos < - dCosSmall) {
-
+                  if ( bInside) {
+                     // salvo la precedente, perché vuol dire che manca la sua uscita
+                     // poi procedo con l'intersezione corrente
+                     int z = k - 1 ;
+                     vIntToCheck.emplace_back( IntersectionResults[z].ptI, vtInN, IntersectionResults[z].dU, nMap, i, j) ;
+                  }
                   ptIn = IntersectionResults[k].ptI ;
 
                   int nT = IntersectionResults[k].nT ;
@@ -567,8 +637,7 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
                }
 
                // esco dalla superficie trimesh
-               else if ( dCos > dCosSmall  &&  bInside) {
-
+               else if ( dCos > dCosSmall) {
                   Point3d ptOut = IntersectionResults[k].ptI ;
 
                   int nT = IntersectionResults[k].nT ;
@@ -577,6 +646,13 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
                   Vector3d vtOutN ;
                   Surf.GetFacetNormal( nF, vtOutN) ; 
 
+                  if ( ! bInside) {
+                     // se l'intersezione è uscente, ma non ho un'entrata allora devo salvare l'intersezione corrente, perché è andata persa la sua entrata
+                     // procedo poi con la prossima intersezione
+                     vIntToCheck.emplace_back( IntersectionResults[k].ptI, vtOutN, IntersectionResults[k].dU, nMap, i, j) ;
+                     continue ;
+                  }
+
                   int nCurrentSize = int( m_Values[nMap][nPos].size()) ;
 
                   // Aggiungo un tratto al dexel
@@ -597,6 +673,12 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
          }
       }
    }
+
+   if ( bForceClosed) {
+      if ( ! AdjustDexelThroughCracks( nMap, vtLen, vIntToCheck, ptMapOrig, Surf, intPLSTM))
+         return false ;
+   }
+
    return true ;
 }
 
@@ -788,11 +870,14 @@ VolZmap::SubtractMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ,
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox)
+VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox, int* nError, bool bForceClosed)
 {
   // Se la superficie non è chiusa oppure orientata al contrario non ha senso continuare
    double dVol ;
-   if ( ! Surf.IsClosed()  ||  ! Surf.GetVolume( dVol)  ||  dVol < 0)
+   if ( ( ! Surf.IsClosed()  ||  ! Surf.GetVolume( dVol)  ||  dVol < 0)  &&  ! bForceClosed)
+      return false ;
+
+   if ( bForceClosed  && ! bTriDex)
       return false ;
 
   // Assegno la dimensione della mappa 1 o 3
@@ -838,14 +923,33 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
       m_nNx[1] = m_nNy[0] ;
       m_nNy[1] = int( ( vtLen.z + EPS_SMALL) / m_dStep + 0.5) ;
       m_nDim[1] = m_nNx[1] * m_nNy[1] ;
-      m_Values[1].resize( m_nDim[1]) ;
       m_nNx[2] = m_nNy[1] ;
       m_nNy[2] = m_nNx[0] ;
       m_nDim[2] = m_nNx[2] * m_nNy[2] ;
+      #if !defined(_WIN64)
+         for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
+            m_nDexelNbr += m_nDim[i] ;
+         if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
+            Clear() ;
+            if ( nError != nullptr)
+               *nError = 1 ;
+            return false ;
+         }
+      #endif
+      m_Values[1].resize( m_nDim[1]) ;
       m_Values[2].resize( m_nDim[2]) ;
    }
-
+  // Se a dimensione singola
    else {
+      #if !defined(_WIN64)
+         m_nDexelNbr += m_nDim[0] ;
+         if ( m_nDexelNbr >= MAX_DEXEL_32_BIT) {
+            Clear() ;
+            if ( nError != nullptr)
+               *nError = 1 ;
+            return false ;
+         }
+      #endif
       m_nNx[1] = 0 ;
       m_nNy[1] = 0 ;
       m_nDim[1] = 0 ;
@@ -875,7 +979,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
       IntersParLinesSurfTm intPLSTM( frMapFrame, Surf) ;
 
      // Standarda è multithread
-      constexpr bool MULTITHREAD = true ;
+      constexpr bool MULTITHREAD = false ;
       if ( MULTITHREAD) {
 
          // Numero massimo di thread
@@ -891,7 +995,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
                nInfI = nSupI ;
                nSupI = nInfI + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
                vRes[nThread] = async( launch::async, &VolZmap::CreateMapPart, this, nG,
-                                      nInfI, nSupI, 0, m_nNy[nG], ref( vtLen), ref( ptMapOrig), ref( Surf), ref( intPLSTM)) ;
+                                      nInfI, nSupI, 0, m_nNy[nG], ref( vtLen), ref( ptMapOrig), ref( Surf), ref( intPLSTM), bForceClosed) ;
             }
          }
          else {
@@ -903,7 +1007,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
                nInfJ = nSupJ ;
                nSupJ = nInfJ + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
                vRes[nThread] = async( launch::async, &VolZmap::CreateMapPart, this, nG,
-                                      0, m_nNx[nG], nInfJ, nSupJ, ref( vtLen), ref( ptMapOrig), ref( Surf),ref( intPLSTM)) ;
+                                      0, m_nNx[nG], nInfJ, nSupJ, ref( vtLen), ref( ptMapOrig), ref( Surf),ref( intPLSTM), bForceClosed) ;
             }
          }
        
@@ -922,7 +1026,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
 
      // !!!! NON MULTITHREAD : SOLO PER DEBUG !!!!
       else {
-         CreateMapPart( nG, 0, m_nNx[nG], 0, m_nNy[nG], vtLen, ptMapOrig, Surf, intPLSTM) ;
+         CreateMapPart( nG, 0, m_nNx[nG], 0, m_nNy[nG], vtLen, ptMapOrig, Surf, intPLSTM, bForceClosed) ;
       }
    }
 
@@ -943,3 +1047,315 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
 
    return bCompleted ;
 }
+
+DBLDBLVECTOR
+VolZmap::GetNeighbours( int nG, int nI, int nJ, double dPar)
+{
+   DBLDBLVECTOR vNeigh ;
+   // parto da in basso a sinistra e procedo per righe, saltando il punto corrente
+   if ( nI > 0 && nJ > 0)
+      vNeigh.emplace_back( nI - dPar, nJ - dPar) ;
+   if ( nJ > 0) {
+      vNeigh.emplace_back( nI, nJ - dPar) ;
+      if ( nI < m_nNx[nG] - dPar)
+         vNeigh.emplace_back( nI + dPar, nJ - dPar) ;
+   }
+   // passo alla fila contenente il punto corrente
+   if ( nI > 0)
+      vNeigh.emplace_back( nI - dPar, nJ) ;
+   if ( nI < m_nNx[nG] - dPar)
+      vNeigh.emplace_back( nI + dPar, nJ) ;
+   // passo alla fila successiva a quella del corrente
+   if ( nJ < m_nNy[nG] - dPar) {
+      if ( nI > 0)
+         vNeigh.emplace_back( nI - dPar, nJ + dPar) ;
+      vNeigh.emplace_back( nI, nJ + dPar) ;
+      if ( nI < m_nNx[nG])
+         vNeigh.emplace_back( nI + dPar, nJ + dPar) ;
+   }
+   return vNeigh ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::AdjustDexelThroughCracks( int nG, const Vector3d& vtLen, const INTTOCHECKVEC& vIntToCheck, const Point3d& ptMapOrig,
+                                   const ISurfTriMesh& Surf, const IntersParLinesSurfTm& intPLSTM)
+{
+   double dAngSameFace = 45 ;
+   double dCosSmall = sin( EPS_ANG_SMALL * DEGTORAD) ;
+   // per ogni intersezione segnalata devo cercare sugli spilloni vicini l'intervallo con l'estremo più vicino a questa intersezione
+   // e usare l'altro estremo, insieme a quello degli altri spilloni vicini, per estrapolare quello mancante sullo spillone corrente
+   Vector3d vtAx ;
+   if ( nG == 0)
+      vtAx = Z_AX ;
+   else if ( nG == 1)
+      vtAx = X_AX ;
+   else if ( nG == 2)
+      vtAx = Y_AX ;
+   for ( const auto& itc : vIntToCheck) {
+      int nPos = itc.nJ * m_nNx[nG] + itc.nI ;
+      double dPosRef = itc.ptInters.v[( nG + 2) % 3] ;
+      // controllo se esiste già un intervallo con un estremo quasi coincidente a quello segnalato
+      // ed entrambi sono entrate o uscite
+      bool bNeedToReconstruct = true ;
+      for ( const auto& data: m_Values[nG][nPos]) {
+         if ( (( abs( dPosRef - data.dMin) < 10 * EPS_SMALL  &&  ( itc.vtN * vtAx) * ( data.vtMinN * vtAx) > 0))  ||
+               (( abs( dPosRef - data.dMax) < 10 * EPS_SMALL  &&  ( itc.vtN * vtAx) * ( data.vtMaxN * vtAx) > 0))) {
+            bNeedToReconstruct = false ;
+            break ;
+         }  
+      }
+      if ( ! bNeedToReconstruct)
+         continue ;
+      DBLDBLVECTOR vNeigh = GetNeighbours( nG, itc.nI, itc.nJ, m_dStep) ;
+      PNTVECTOR vNeighInters ;
+      Vector3d vtMeanN = V_NULL ;
+      bool bSearchingInOrOut = itc.vtN * vtAx > 0 ;
+      bool bUseNeighInfo = true ;
+      for ( const auto& [i,j] : vNeigh) {
+         double dMinDist = INFINITO ;
+         double dCorrespInters = INFINITO ;
+         double dNearestPos = NAN ;
+         Vector3d vtNearestN ;
+         int nNeighPos = int( j) * m_nNx[nG] + int( i) ;
+         for ( const auto& data: m_Values[nG][nNeighPos]) {
+            double dDist1 = abs( dPosRef - data.dMin) ;
+            double dDist2 = abs( dPosRef - data.dMax) ;
+            if ( dDist1 < dMinDist  ||  dDist2 < dMinDist) {
+               dMinDist = min( dDist1, dDist2) ;
+                  
+               // se sto cercando un ingresso
+               if ( bSearchingInOrOut) {
+                  if ( data.vtMaxN * vtAx < 0) {
+                     dNearestPos = data.dMax ;
+                     vtNearestN = data.vtMaxN ;
+                     dCorrespInters = data.dMin ;
+                  }
+                  else if ( data.vtMinN * vtAx < 0) {
+                     dNearestPos = data.dMin ;
+                     vtNearestN = data.vtMinN ;
+                     dCorrespInters = data.dMax ;
+                  }
+               }
+               // se sto cercando un'uscita
+               else {
+                  if ( data.vtMaxN * vtAx > 0) {
+                     dNearestPos = data.dMax ;
+                     vtNearestN = data.vtMaxN ;
+                     dCorrespInters = data.dMin ;
+                  }
+                  else if ( data.vtMinN * vtAx > 0) {
+                     dNearestPos = data.dMin ;
+                     vtNearestN = data.vtMinN ;
+                     dCorrespInters = data.dMax ;
+                  }
+               }
+            }
+         }
+         // verifico che il dNearestPos sia effettivamente associato al tratto che sto cercando di ricostruire
+         // e non ad un altro presente sullo spillone corrente
+         bool bAddNearest = true ;
+         for ( const auto& data: m_Values[nG][nPos]) {
+            double dDist1 = abs( dCorrespInters - data.dMin) ;
+            double dDist2 = abs( dCorrespInters - data.dMax) ;
+            if ( dDist1 < dMinDist  ||  dDist2 < dMinDist) {
+               bAddNearest = false ;
+               break ;
+            }
+         }
+
+         if ( bAddNearest  &&  isfinite( dNearestPos)) {
+            // controllo anche che i punti non siano troppo lontani tra loro, altrimenti
+            // il piano calcolato potrebbe essere una media troppo grezza
+            double dMaxDist = 3 * m_dStep ;
+            const bool bTooFar = any_of( vNeighInters.begin(), vNeighInters.end(),
+                                         [ dNearestPos, dMaxDist]( const Point3d& pt) {
+                                            return abs( pt.z - dNearestPos) > dMaxDist ;
+                                         }) ;
+            double dAng ;
+            if ( ! bTooFar) {
+               // controllo anche che gli angoli delle normali non cambino troppo
+               // calcolo l'angolo con la media delle precedenti perché il valore oltre cui
+               // considero le normali diverse è grande
+               vtNearestN.GetAngle( vtMeanN, dAng) ;
+            }
+            bAddNearest = ! bTooFar  &&  dAng < dAngSameFace ;
+            if ( bAddNearest) {
+               double dX = ( i + 0.5) * m_dStep ;
+               double dY = ( j + 0.5) * m_dStep ;
+               vNeighInters.emplace_back( dX, dY, dNearestPos) ;
+               vtMeanN += vtNearestN ;
+            }
+            else {
+               bUseNeighInfo = false ;
+               break ;
+            }
+         }
+      }
+      Point3d ptInt ;
+      // se riesco uso i vicini per calcolare l'intersezione mancante
+      if ( bUseNeighInfo) {
+         // se non ci sono almeno tre punti, non allineati, non riesco a determinare il piano con cui tagliare lo spillone
+         if ( ssize( vNeighInters) < 3)
+            continue ;
+         else if ( ssize( vNeighInters) == 3){
+            // verifico che non siano allineati
+            if ( ( vNeighInters[0].x == vNeighInters[1].x  &&  vNeighInters[0].x ==  vNeighInters[1].x)  ||
+                  ( vNeighInters[0].y == vNeighInters[1].y  &&  vNeighInters[0].y ==  vNeighInters[1].y))
+               continue ;
+         }
+         // se sono più di tre sicuramente non sono allieanti, visto che sono intorno allo spillone corrente
+         vtMeanN.Normalize() ;
+         Plane3d plLoc ;
+         PolyLine PL ; PL.FromPointVector( vNeighInters) ;
+         PL.IsFlat( plLoc, INFINITO) ;
+            
+         // porto anche il punto dell'intersezione nel frame della griglia
+         Point3d ptKnown = itc.ptInters ;
+         Frame3d frGrid ;
+         if ( nG == 0)
+            frGrid.Set( ORIG, Frame3d::TOP) ;
+         else if ( nG == 1)
+            frGrid.Set( ORIG, Frame3d::RIGHT) ;
+         else if ( nG == 2)
+            frGrid.Set( ORIG, Z_AX, X_AX, Y_AX) ;
+         ptKnown.ToLoc( frGrid) ;
+         IntersLinePlane( ptKnown, Z_AX, INFINITO, plLoc, ptInt, false) ;
+      }
+      // altrimenti sposto di poco lo spillone e ricalcolo le intersezioni con la superficie, finché trovo l'intersezione mancante
+      else {
+         bool bFound = false ;
+         DBLVECTOR vSmallStep ;
+         vSmallStep.push_back( Clamp( 0.05 * m_dStep, 50 * EPS_SMALL, 1.)) ;
+         vSmallStep.push_back( Clamp( 0.2 * m_dStep, 50 * EPS_SMALL, 1.)) ;
+         // ciclo una raggiera di spilloni ( a distanza inferiore allo m_dStep) attorno allo spillone
+         // appena trova un'intersezione buona mi fermo
+         // se ciclando la raggiera non trovo un'intersezione valida allora potrei essermi spostato troppo poco dallo spillone originale e essere caduto ancora nella fessura
+         // quindi ciclo nuovamente aumentando un poco la distanza dallo spillone originale ( comunque sempre meno della distanza m_dStep)
+         for ( int c = 0 ; c < ssize( vSmallStep) ; ++c) {
+            DBLDBLVECTOR vSmallMoveNeigh = GetNeighbours( nG, itc.nI, itc.nJ, vSmallStep[c]) ;
+            for ( int n = 0 ; n < 8 ; ++n) {
+               double dX = ( vSmallMoveNeigh[n].first + 0.5) * m_dStep ;
+               double dY = ( vSmallMoveNeigh[n].second + 0.5) * m_dStep ;
+               Point3d ptP0( dX, dY, 0) ;
+               ILSIVECTOR IntersectionResults ;
+               intPLSTM.GetInters( ptP0, vtLen.v[(nG+2)%3], IntersectionResults) ;
+               // intervalli dalle intersezioni
+               vector<Data> vNewIntervals ;
+               bool bInside = false ;
+               Vector3d vtInN ;
+               Point3d ptIn ;
+               for ( int i = 0 ; i < ssize( IntersectionResults) ; ++i) {
+                  // Se c'è intersezione
+                  if ( IntersectionResults[i].nILTT != ILTT_NO) {
+                     if ( i > 0) {
+                        int z = i - 1 ;
+                        // controllo se l'intersezione corrente è coincidente con la precedente, per esempio se ILTT == 4 ( intersezione su un lato di un triangolo, quindi con 2 triangoli)
+                        if ( IntersectionResults[i].dU - IntersectionResults[z].dU < EPS_SMALL  &&
+                           IntersectionResults[i].dCosDN - IntersectionResults[z].dCosDN < EPS_SMALL)
+                           continue ;
+                     }
+                     double dCos = IntersectionResults[i].dCosDN ;
+                     // entro nella superficie trimesh
+                     if ( dCos < - dCosSmall) {
+                        ptIn = IntersectionResults[i].ptI ;
+
+                        int nT = IntersectionResults[i].nT ;
+                        int nF = Surf.GetFacetFromTria( nT) ;
+
+                        Surf.GetFacetNormal( nF, vtInN) ;
+
+                        bInside = true ;
+                     }
+
+                     // esco dalla superficie trimesh
+                     else if ( dCos > dCosSmall  &&  bInside) {
+                        Point3d ptOut = IntersectionResults[i].ptI ;
+
+                        int nT = IntersectionResults[i].nT ;
+                        int nF = Surf.GetFacetFromTria( nT) ;
+
+                        Vector3d vtOutN ;
+                        Surf.GetFacetNormal( nF, vtOutN) ; 
+
+                        // Aggiungo un tratto al dexel
+                        vNewIntervals.emplace_back() ;
+
+                        // Aggiorno dati del tratto di dexel 
+                        vNewIntervals.back().dMin = ptIn.v[(nG+2)%3] - ptMapOrig.v[(nG+2)%3] ;
+                        vNewIntervals.back().dMax = ptOut.v[(nG+2)%3] - ptMapOrig.v[(nG+2)%3] ;
+                        vNewIntervals.back().vtMinN = vtInN ;
+                        vNewIntervals.back().vtMaxN = vtOutN ;
+                        vNewIntervals.back().nToolMin = 0 ;
+                        vNewIntervals.back().nToolMax = 0 ;
+                        vNewIntervals.back().nCompo = 0 ;
+
+                        bInside = false ;
+                     }
+                  } 
+               }
+               // controllo che abbia un intervallo in più rispetto a quelli di prima
+               if ( ssize( vNewIntervals)  ==  ssize( m_Values[nG][nPos]) + 1) {
+                  // dovrei verificare che quello in più sia effettivamente quello ricercato????
+                  double dMinDist = INFINITO ;
+                  for ( const auto& data : vNewIntervals) {
+                     if ( abs( data.dMin - dPosRef) < dMinDist) {
+                        dMinDist = abs( data.dMin - dPosRef) ;
+                        ptInt.Set( itc.nI + 0.5, itc.nJ + 0.5, data.dMax) ;
+                        vtMeanN = data.vtMaxN ;
+                        bFound = true ;
+                     }
+                     if ( abs( data.dMax - dPosRef) < dMinDist) {
+                        dMinDist = abs( data.dMax - dPosRef) ;
+                        ptInt.Set( itc.nI + 0.5, itc.nJ + 0.5, data.dMin) ;
+                        vtMeanN = data.vtMinN ;
+                        bFound = true ;
+                     }
+                  }
+               }
+               if ( bFound)
+                  break ;
+            }
+            if ( bFound)
+               break ;
+         }
+         // se cercando nei d'intorni dello spillone non ho trovato l'intersezione mancante, mi arrendo
+         if ( ! bFound)
+            continue ;
+      }
+         
+      double dMin, dMax ;
+      Vector3d vtMinN, vtMaxN ;
+      if ( itc.dU < ptInt.z) {
+         dMin = itc.dU ;
+         dMax = ptInt.z ;
+         vtMinN = itc.vtN ;
+         vtMaxN = vtMeanN ;
+      }
+      else {
+         dMin = ptInt.z ;
+         dMax = itc.dU ;
+         vtMinN = vtMeanN ;
+         vtMaxN = itc.vtN ;
+      }
+      //// prima di aggiungere il tratto verifico che non si sovrapponga con un tratto già presente
+      //for ( const auto& data: m_Values[nG][nPos]) {
+      //   if ( ( dMin > data.dMin  &&  dMin < data.dMax)  ||
+      //        ( dMax > data.dMin  &&  dMax < data.dMax)  ||
+      //        ( dMin < data.dMin  &&  dMax > data.dMax))
+      //      continue ;
+      //}
+
+      m_Values[nG][nPos].emplace_back() ;
+      m_Values[nG][nPos].back().dMin = dMin;
+      m_Values[nG][nPos].back().dMax = dMax ;
+      m_Values[nG][nPos].back().vtMinN = vtMinN ;
+      m_Values[nG][nPos].back().vtMaxN = vtMaxN ;
+      m_Values[nG][nPos].back().nToolMin = 0 ;
+      m_Values[nG][nPos].back().nToolMax = 0 ;
+      m_Values[nG][nPos].back().nCompo = 0 ;
+      std::sort( m_Values[nG][nPos].begin(), m_Values[nG][nPos].end(), []( Data& a, Data& b) { return a.dMin < b.dMin ;}) ;
+   }
+
+   return true ;
+}

VolZmapOffset.cpp

@@ -21,6 +21,7 @@
 #include "CurveLine.h"
 #include "CurveArc.h"
 #include "GeoConst.h"
+#include "IntersLineCyl.h"
 #include "/EgtDev/Include/EGkStmFromCurves.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
@@ -968,12 +969,13 @@ VolZmap::CreateOffsetCylinderOnEdge( const Point3d& ptP1, const Point3d& ptP2, d
          Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ;
          Point3d ptInt1, ptInt2 ;
          Vector3d vtN1, vtN2 ;
-         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dH, abs( dOffs), true, true,
-                                  ptInt1, vtN1, ptInt2, vtN2)) {
+         double dU1, dU2 ;
+         if ( IntersLineCyl( ptC, Z_AX, CylFrame, dH, abs( dOffs), true, true,
+                             dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, false, false)) {
             if ( dOffs > 0.)
-               AddIntervalsForOffset( nGrid, i, j, ptInt1.z, ptInt2.z, -vtN1, -vtN2, nTool, nTool) ;
+               AddIntervalsForOffset( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nTool, nTool) ;
             else
-               SubtractIntervalsForOffset( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nTool) ;
+               SubtractIntervalsForOffset( nGrid, i, j, ptInt1.z, ptInt2.z, -vtN1, -vtN2, nTool) ;
          }
       }
    }

VolZmapVolume.cpp

@@ -21,6 +21,7 @@
 #include "VolZmap.h"
 #include "GeoConst.h"
 #include "IntersLineBox.h"
+#include "IntersLineCyl.h"
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkSurfBezier.h"
@@ -31,6 +32,13 @@
 #include <future>
 #include <numeric>
 
+#define SAVETRIMMINGTOOL 0
+
+#if SAVETRIMMINGTOOL
+std::vector<IGeoObj*> vGeo ;
+#include "/EgtDev/Include/EGkGeoObjSave.h"
+#endif
+
 using namespace std ;
 
 // ------------------------- OPERAZIONI SU INTERVALLI --------------------------------------------------------------------------------------
@@ -838,6 +846,183 @@ VolZmap::UniformIntervalsInVoxel( int nGrid, int nI, int nJ, double dZMin,
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+VolZmap::AddStripInterval( int nGrid, int nI, int nJ, double dZMin, double dZMax, int nToolNum)
+{
+  // Se non Tridex, esco
+   if ( ! IsTriDexel())
+      return true ;
+
+  // Controllo che il numero di griglia sia entro i limiti
+   if ( nGrid < 0  ||  nGrid > 2)
+      return false ;
+
+  // Controllo che indici nI, nJ siano entro i limiti
+   if ( nI < 0  &&  nI >= m_nNx[nGrid]  &&  nJ < 0  &&  nJ >= m_nNy[nGrid])
+      return false ;
+
+  // Numero di voxel contenuti nel dexel corrente ( uguale per ogni dexel di una specifica griglia)
+   int nVoxNum = int( m_nNy[(( nGrid + 1) % 3)] / m_nDexVoxRatio +
+                    ( m_nNy[(( nGrid + 1) % 3)] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
+
+  // Scorro i Voxel correnti
+   for ( int nVox = - 1 ; nVox < nVoxNum - 1 ; ++ nVox) {
+     // Considero solo i Voxel interni all'intervallo corrente
+      if ( ( nVox + 1) * m_dStep > dZMin  &&  ( nVox - 1) * m_dStep < dZMax) {
+        // Recupero gli indici per la griglia successiva
+         int nMyGrid = ( nGrid + 1) % 3 ;
+         int nMyI = nJ ;
+         int nMyJ = nVox ;
+         int nMyK = nI ;
+         double dMyMinZ = nMyK * m_dStep ;
+         double dMyMaxZ = ( nMyK + 1) * m_dStep ;
+         Vector3d vtMyMaxN = ( nMyGrid == 0 ? m_MapFrame.VersZ() :
+                               nMyGrid == 1 ? m_MapFrame.VersX() :
+                                              m_MapFrame.VersY()) ;
+         Vector3d vtMyMinN = - vtMyMaxN ;
+         AddIntervals( nMyGrid, nMyI, nMyJ, dMyMinZ - EPS_SMALL, dMyMaxZ + EPS_SMALL, vtMyMinN, vtMyMaxN, nToolNum, true) ;
+        // Recupero gli indici della griglia precedente
+         nMyGrid = ( nGrid + 2) % 3 ;
+         nMyI = nVox ;
+         nMyJ = nI ;
+         nMyK = nJ ;
+         dMyMinZ = nMyK * m_dStep ;
+         dMyMaxZ = ( nMyK + 1) * m_dStep ;
+         vtMyMaxN = ( nMyGrid == 0 ? m_MapFrame.VersZ() :
+                      nMyGrid == 1 ? m_MapFrame.VersX() :
+                                     m_MapFrame.VersY()) ;
+         vtMyMinN = - vtMyMaxN ;
+         AddIntervals( nMyGrid, nMyI, nMyJ, dMyMinZ - EPS_SMALL, dMyMaxZ + EPS_SMALL, vtMyMinN, vtMyMaxN, nToolNum, true) ;
+      }
+   }
+  // Aggiungo l'intervallo corrente
+   Vector3d vtMyMaxN = ( nGrid == 0 ? m_MapFrame.VersZ() :
+                         nGrid == 1 ? m_MapFrame.VersX() :
+                                      m_MapFrame.VersY()) ;
+   Vector3d vtMyMinN = - vtMyMaxN ;
+   AddIntervals( nGrid, nI, nJ, dZMin, dZMax, vtMyMinN, vtMyMaxN, nToolNum, true) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::GetLocalPoint( int nGrid, int nI, int nJ, double dZ, Point3d& ptLoc)
+{
+   // Verifico che lo ZMap corrente sia valido
+   if ( ! IsValid())
+      return false ;
+
+  // Controllo che il numero di griglia sia entro i limiti
+   if ( nGrid < 0  ||  nGrid > 2)
+      return false ;
+
+  // Controllo che indici nI, nJ siano entro i limiti
+   if ( nI < 0  &&  nI >= m_nNx[nGrid]  &&  nJ < 0  &&  nJ >= m_nNy[nGrid])
+      return false ;
+
+  // Calcolo il punto
+   ptLoc = m_MapFrame.Orig() ;
+   if ( nGrid == 0)
+      ptLoc += ( ( nI + 0.5) * m_dStep * m_MapFrame.VersX() + ( nJ + 0.5) * m_dStep * m_MapFrame.VersY() + dZ * m_MapFrame.VersZ()) ;
+   else if ( nGrid == 1)
+      ptLoc += ( ( nI + 0.5) * m_dStep * m_MapFrame.VersY() + ( nJ + 0.5) * m_dStep * m_MapFrame.VersZ() + dZ * m_MapFrame.VersX()) ;
+   else
+      ptLoc += ( ( nI + 0.5) * m_dStep * m_MapFrame.VersZ() + ( nJ + 0.5) * m_dStep * m_MapFrame.VersX() + dZ * m_MapFrame.VersY()) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::ComputePointAndNormalForRemovingFins( int nGrid, int nI, int nJ, double dZ,
+                                             const Vector3d& vtDir, double dThick, bool bMinVsMax, int nTool,
+                                             Vector3d& vtN, double& dNewZ)
+{
+  // Verifico che lo ZMap corrente sia valido
+   if ( ! IsValid())
+      return false ;
+
+  // Controllo che il numero di griglia sia entro i limiti
+   if ( nGrid < 0  ||  nGrid > 2)
+      return false ;
+
+  // Inizializzo il vettore da restituire
+   vtN = V_NULL ;
+   dNewZ = INFINITO ;
+
+  // Proietto la direzione lungo la mappa della griglia corrente
+   Vector3d vtDirProj = OrthoCompo( vtDir, ( nGrid == 0 ? m_MapFrame.VersZ() :
+                                             nGrid == 1 ? m_MapFrame.VersX() :
+                                                          m_MapFrame.VersY())) ;
+  // Sposto il punto corrente nella direzione opposta a quella trovata
+   Point3d ptLoc ;
+   if ( ! GetLocalPoint( nGrid, nI, nJ, dZ, ptLoc))
+      return false ;
+   Point3d ptCenterLoc = ptLoc ;
+   ptCenterLoc.Translate( - vtDirProj * dThick) ;
+
+  // Recupero il Box nel punto
+   BBox3d BBoxLoc ; BBoxLoc.Add( ptCenterLoc) ;
+   double dExpandX = ( m_MapFrame.VersX() * X_AX) * dThick * ( vtDirProj * X_AX) ;
+   double dExpandY = ( m_MapFrame.VersY() * Y_AX) * dThick * ( vtDirProj * Y_AX) ;
+   double dExpandZ = ( m_MapFrame.VersZ() * Z_AX) * dThick * ( vtDirProj * Z_AX) ;
+   BBoxLoc.Expand( max( ( m_dStep + EPS_SMALL), dExpandX),
+                   max( ( m_dStep + EPS_SMALL), dExpandY),
+                   max( ( m_dStep + EPS_SMALL), dExpandZ)) ;
+
+  // Porto il Box nel Frame della Mappa corrente
+   BBox3d BBoxInGrid = GetToLoc( BBoxLoc, m_MapFrame) ;
+  // Recupero i suoi estremi
+   Point3d ptBoxLocMax = BBoxInGrid.GetMax() ;
+   Point3d ptBoxLocMin = BBoxInGrid.GetMin() ;
+  // Determino gli intervalli locali in X e Y locali alla Griglia correnti
+   double dMinXLoc = ( nGrid == 0 ? ptBoxLocMin.x : nGrid == 1 ? ptBoxLocMin.y : ptBoxLocMin.z) ;
+   double dMinYLoc = ( nGrid == 0 ? ptBoxLocMin.y : nGrid == 1 ? ptBoxLocMin.z : ptBoxLocMin.x) ;
+   double dMaxXLoc = ( nGrid == 0 ? ptBoxLocMax.x : nGrid == 1 ? ptBoxLocMax.y : ptBoxLocMax.z) ;
+   double dMaxYLoc = ( nGrid == 0 ? ptBoxLocMax.y : nGrid == 1 ? ptBoxLocMax.z : ptBoxLocMax.x) ;
+
+  // Recupero gli Spilloni coinvolti nel Box
+   int nStartI = max( 0, int( dMinXLoc / m_dStep)) ;
+   int nEndI = min( m_nNx[nGrid] - 1, int( dMaxXLoc / m_dStep)) ;
+   int nStartJ = max( 0, int( dMinYLoc / m_dStep)) ;
+   int nEndJ = min( m_nNy[nGrid] - 1, int( dMaxYLoc / m_dStep)) ;
+   double dSqMinDist = INFINITO ;
+   for ( int i = nStartI ; i <= nEndI ; ++ i) {
+      for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
+        // Determino la posizione corrente dello Spillone
+         int nPos = j * m_nNx[nGrid] + i ;
+         vector<Data>& vDexel = m_Values[nGrid][nPos] ;
+        // Scorro i suoi Intervalli
+         for ( int nInterval = 0 ; nInterval < ssize( vDexel) ; ++ nInterval) {
+           // Se l'Intervallo presenta un indice del Tool da evitare, passo al successivo
+            if ( ( bMinVsMax  &&  vDexel[nInterval].nToolMin != nTool)  ||
+                 ( ! bMinVsMax  &&  vDexel[nInterval].nToolMax != nTool))
+               continue ;
+           // Recupero l'estremo da analizzare
+            double dZInterval = ( bMinVsMax ? vDexel[nInterval].dMin : vDexel[nInterval].dMax) ;
+           // Recupero il punto associato
+            Point3d ptInterval ;
+            if ( ! GetLocalPoint( nGrid, i, j, dZInterval, ptInterval))
+               return false ;
+           // Se il punto è dentro nel Box, aggiungo il contributo della normale presente
+            if ( BBoxLoc.Encloses( ptInterval)) {
+               double dCurrSqDist = ( SqDist( ptInterval, ptLoc)) ;
+               if ( dCurrSqDist < dSqMinDist) {
+                  dSqMinDist = dCurrSqDist ;
+                  vtN = ( bMinVsMax ? vDexel[nInterval].vtMinN : vDexel[nInterval].vtMaxN) ;
+                  dNewZ = dZInterval ;
+               }
+            }
+         }
+      }
+   }
+
+   return ( ! vtN.IsSmall()  &&  dZ < INFINITO - 1) ;
+}
+
+
 // ------------------------- BOUNDING BOX --------------------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
@@ -1569,10 +1754,6 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    else if ( n5AxisType == Move5Axis::ACROSS)
       nTotSurf = 2 + nSub * 4 + nSub * 2 + 16 ; // come sopra
 
-   int nSurfInd = 0 ;
-   vector<SurfBezForInters> vSurfBez( nTotSurf) ;
-   double dSide = 0 ;
-
    // punti di riferimento sul tool
    // tip del tool
    Point3d ptP1T ;
@@ -1585,6 +1766,17 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    Vector3d vtDirTip = ptP2T - ptP1T ;
    bool bTopIsPivot = vtDirTop.IsSmall() ;
    bool bTipIsPivot = vtDirTip.IsSmall() ;
+   bool bSmallMovement = vtDirTop.Len() < 10 * EPS_SMALL  &&  vtDirTip.Len() < 10 * EPS_SMALL ;
+   bool bInverse = ! (bTopIsPivot || bTipIsPivot)  &&  vtDirTop * vtDirTip < 0 ;
+
+   if ( bInverse)
+      nTotSurf += 4 ;
+   if ( bSmallMovement)
+      nTotSurf += 2 ;
+
+   int nSurfInd = 0 ;
+   vector<SurfBezForInters> vSurfBez( nTotSurf) ;
+   double dSide = 0 ;
 
    // box dell'intero volume spazzato, nel riferimento object oriented
    BBox3d bbVol ;
@@ -1601,9 +1793,9 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    PNTVECTOR vPntTopStartBack(3) ;
    PNTVECTOR vPntTopEndBack(3) ;
    if ( nSub > 1) {
-      if( bTopIsPivot)
+      if ( bTopIsPivot)
          vtDirTop = vtDirTip ;
-      if( bTipIsPivot)
+      if ( bTipIsPivot)
          vtDirTip = vtDirTop ;
       // determino in che modo collegare il cilindro iniziale con quello finale
       Vector3d vtTopBaseEnd = vtDirTop - (( vtDirTop * vtLe) * vtLe) ;
@@ -1617,10 +1809,10 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
       dSide = ( ptRefEnd - ptRefStart) * vtLs ;
 
       // calcolo anche i vettori per le basi inferiori
-      Vector3d vtTipBaseStart = -( vtLs ^ vtDirTip) ;
+      Vector3d vtTipBaseStart = bInverse ? ( vtLs ^ vtDirTip) : -( vtLs ^ vtDirTip) ;
       vtTipBaseStart.Normalize() ;
       vtTipBaseStart *= dMinRad ;
-      Vector3d vtTipBaseEnd = -( vtLe ^ vtDirTip) ;
+      Vector3d vtTipBaseEnd = bInverse ? ( vtLe ^ vtDirTip) : -( vtLe ^ vtDirTip) ;
       vtTipBaseEnd.Normalize() ;
       vtTipBaseEnd *= dMinRad ;
       // aggiungo il primo punto per ognuno dei gruppi
@@ -1669,22 +1861,44 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    }
 
    vector<PNTVECTOR> vvPtCtrl ;
-   // superficie laterale sinistra
-   CurveLine cLineLeftStart ; cLineLeftStart.Set( vPntTipStartFront.back(), vPntTopStartFront.back()) ;
-   PtrOwner<CurveBezier> cBezLeftStart( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftStart, nDegU, bRat))) ;
-   CurveLine cLineLeftEnd ; cLineLeftEnd.Set( vPntTipEndFront.back(), vPntTopEndFront.back()) ;
-   PtrOwner<CurveBezier> cBezLeftEnd( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftEnd, nDegU, bRat))) ;
-   vvPtCtrl.emplace_back( cBezLeftStart->GetAllControlPoints()) ;
-   PNTVECTOR vPntLeft = cBezLeftEnd->GetAllControlPoints() ;
-   vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntLeft.begin(), vPntLeft.end()) ;
-   // superficie laterale destra
-   CurveLine cLineRightStart ; cLineRightStart.Set( vPntTopStartFront.front(), vPntTipStartFront.front()) ;
-   PtrOwner<CurveBezier> cBezRightStart( GetBasicCurveBezier( LineToBezierCurve( &cLineRightStart, nDegU, bRat))) ;
-   CurveLine cLineRightEnd ; cLineRightEnd.Set( vPntTopEndFront.front(), vPntTipEndFront.front()) ;
-   PtrOwner<CurveBezier> cBezRightEnd( GetBasicCurveBezier( LineToBezierCurve( &cLineRightEnd, nDegU, bRat))) ;
-   vvPtCtrl.emplace_back( cBezRightStart->GetAllControlPoints()) ;
-   PNTVECTOR vPntRight = cBezRightEnd->GetAllControlPoints() ;
-   vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntRight.begin(), vPntRight.end()) ;
+   if ( ! bSmallMovement) {
+      // superficie laterale sinistra
+      CurveLine cLineLeftBottom ; cLineLeftBottom.Set( vPntTipEndFront.back(), vPntTipStartFront.back()) ;
+      if ( ! cLineLeftBottom.IsValid())
+         return false ;
+      if ( bInverse)
+         cLineLeftBottom.Invert() ;
+      PtrOwner<CurveBezier> cBezLeftBottom( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftBottom, nDegU, bRat))) ;
+      if ( IsNull( cBezLeftBottom))
+         return false ;
+      CurveLine cLineLeftTop ; cLineLeftTop.Set( vPntTopEndFront.back(), vPntTopStartFront.back()) ;
+      if ( ! cLineLeftTop.IsValid())
+         return false ;
+      PtrOwner<CurveBezier> cBezLeftTop( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftTop, nDegU, bRat))) ;
+      if ( IsNull( cBezLeftTop))
+         return false ;
+      vvPtCtrl.emplace_back( cBezLeftBottom->GetAllControlPoints()) ;
+      PNTVECTOR vPntLeft = cBezLeftTop->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntLeft.begin(), vPntLeft.end()) ;
+      // superficie laterale destra
+      CurveLine cLineRightBottom ; cLineRightBottom.Set( vPntTipStartFront.front(), vPntTipEndFront.front()) ;
+      if ( ! cLineRightBottom.IsValid())
+         return false ;
+      if ( bInverse)
+         cLineRightBottom.Invert() ;
+      PtrOwner<CurveBezier> cBezRightBottom( GetBasicCurveBezier( LineToBezierCurve( &cLineRightBottom, nDegU, bRat))) ;
+      if ( IsNull( cBezRightBottom))
+         return false ;
+      CurveLine cLineRightTop ; cLineRightTop.Set( vPntTopStartFront.front(), vPntTopEndFront.front()) ;
+      if ( ! cLineRightTop.IsValid())
+         return false ;
+      PtrOwner<CurveBezier> cBezRightTop( GetBasicCurveBezier( LineToBezierCurve( &cLineRightTop, nDegU, bRat))) ;
+      if ( IsNull( cBezRightTop))
+         return false ;
+      vvPtCtrl.emplace_back( cBezRightBottom->GetAllControlPoints()) ;
+      PNTVECTOR vPntRight = cBezRightTop->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntRight.begin(), vPntRight.end()) ;
+   }
    if ( nSub == 1) {
       // superficie inferiore
       vvPtCtrl.emplace_back( PNTVECTOR( { vPntTipStartFront.front(), vPntTipStartFront.back(), vPntTipEndFront.front(), vPntTipEndFront.back() })) ;
@@ -1748,43 +1962,83 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
          if ( ! bTipIsPivot) {
             // inferiori
             if ( dSide > 0) {
-               vvPtCtrl.emplace_back(cBezTipStartF1->GetAllControlPoints());
-               PNTVECTOR vPntTipEnd1 = cBezTipEndF1->GetAllControlPoints();
-               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTipEnd1.begin(), vPntTipEnd1.end());
-               vvPtCtrl.emplace_back(cBezTipStartF2->GetAllControlPoints());
-               PNTVECTOR vPntTipEnd2 = cBezTipEndF2->GetAllControlPoints();
-               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTipEnd2.begin(), vPntTipEnd2.end());
+               PNTVECTOR vPntTipEnd01 = cBezTipStartF1->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.emplace_back( vPntTipEnd01.begin(), vPntTipEnd01.end()) ;
+               else
+                  vvPtCtrl.emplace_back( vPntTipEnd01.rbegin(), vPntTipEnd01.rend()) ;
+               PNTVECTOR vPntTipEnd1 = cBezTipEndF1->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd1.begin(), vPntTipEnd1.end()) ;
+               else
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd1.rbegin(), vPntTipEnd1.rend()) ;
+               PNTVECTOR vPntTipEnd02 = cBezTipStartF2->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.emplace_back( vPntTipEnd02.begin(), vPntTipEnd02.end()) ;
+               else
+                  vvPtCtrl.emplace_back( vPntTipEnd02.rbegin(), vPntTipEnd02.rend()) ;
+               PNTVECTOR vPntTipEnd2 = cBezTipEndF2->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd2.begin(), vPntTipEnd2.end()) ;
+               else
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd2.rbegin(), vPntTipEnd2.rend()) ;
             }
             else {
-               PNTVECTOR vPntTipEnd01 = cBezTipStartB1->GetAllControlPoints();
-               vvPtCtrl.emplace_back(vPntTipEnd01.rbegin(), vPntTipEnd01.rend());
-               PNTVECTOR vPntTipEnd1 = cBezTipEndB1->GetAllControlPoints();
-               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTipEnd1.rbegin(), vPntTipEnd1.rend());
-               PNTVECTOR vPntTipEnd02 = cBezTipStartB2->GetAllControlPoints();
-               vvPtCtrl.emplace_back(vPntTipEnd02.rbegin(), vPntTipEnd02.rend());
-               PNTVECTOR vPntTipEnd2 = cBezTipEndB2->GetAllControlPoints();
-               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTipEnd2.rbegin(), vPntTipEnd2.rend());
+               PNTVECTOR vPntTipEnd01 = cBezTipStartB1->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.emplace_back( vPntTipEnd01.rbegin(), vPntTipEnd01.rend()) ;
+               else
+                  vvPtCtrl.emplace_back( vPntTipEnd01.begin(), vPntTipEnd01.end()) ;
+               PNTVECTOR vPntTipEnd1 = cBezTipEndB1->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd1.rbegin(), vPntTipEnd1.rend()) ;
+               else
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd1.begin(), vPntTipEnd1.end()) ;
+               PNTVECTOR vPntTipEnd02 = cBezTipStartB2->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.emplace_back( vPntTipEnd02.rbegin(), vPntTipEnd02.rend()) ;
+               else
+                  vvPtCtrl.emplace_back( vPntTipEnd02.begin(), vPntTipEnd02.end()) ;
+               PNTVECTOR vPntTipEnd2 = cBezTipEndB2->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd2.rbegin(), vPntTipEnd2.rend()) ;
+               else
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTipEnd2.begin(), vPntTipEnd2.end()) ;
             }
          }
          if ( ! bTopIsPivot) {
             // superiori
             if ( dSide > 0) {
-               vvPtCtrl.emplace_back(cBezTopStartB1->GetAllControlPoints());
-               PNTVECTOR vPntTopEnd1 = cBezTopEndB1->GetAllControlPoints();
-               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTopEnd1.begin(), vPntTopEnd1.end());
-               vvPtCtrl.emplace_back(cBezTopStartB2->GetAllControlPoints());
-               PNTVECTOR vPntTopEnd2 = cBezTopEndB2->GetAllControlPoints();
-               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTopEnd2.begin(), vPntTopEnd2.end());
+               PNTVECTOR vPntTopEnd01 = cBezTopStartB1->GetAllControlPoints() ;
+               vvPtCtrl.emplace_back( vPntTopEnd01.begin(), vPntTopEnd01.end()) ;
+               PNTVECTOR vPntTopEnd1 = cBezTopEndB1->GetAllControlPoints() ;
+               vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd1.begin(), vPntTopEnd1.end()) ;
+               PNTVECTOR vPntTopEnd02 = cBezTopStartB2->GetAllControlPoints() ;
+               vvPtCtrl.emplace_back( vPntTopEnd02.begin(), vPntTopEnd02.end()) ;
+               PNTVECTOR vPntTopEnd2 = cBezTopEndB2->GetAllControlPoints() ;
+               vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd2.begin(), vPntTopEnd2.end()) ;
             }
             else {
-               PNTVECTOR vPntTopEnd01 = cBezTopStartF1->GetAllControlPoints();
-               vvPtCtrl.emplace_back(vPntTopEnd01.rbegin(), vPntTopEnd01.rend());
-               PNTVECTOR vPntTopEnd1 = cBezTopEndF1->GetAllControlPoints();
-               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTopEnd1.rbegin(), vPntTopEnd1.rend());
-               PNTVECTOR vPntTopEnd02 = cBezTopStartF2->GetAllControlPoints();
-               vvPtCtrl.emplace_back(vPntTopEnd02.rbegin(), vPntTopEnd02.rend());
-               PNTVECTOR vPntTopEnd2 = cBezTopEndF2->GetAllControlPoints();
-               vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTopEnd2.rbegin(), vPntTopEnd2.rend());
+               PNTVECTOR vPntTopEnd01 = cBezTopStartF1->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.emplace_back( vPntTopEnd01.rbegin(), vPntTopEnd01.rend()) ;
+               else
+                  vvPtCtrl.emplace_back( vPntTopEnd01.begin(), vPntTopEnd01.end()) ;
+               PNTVECTOR vPntTopEnd1 = cBezTopEndF1->GetAllControlPoints() ;
+               if ( ! bInverse) 
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd1.rbegin(), vPntTopEnd1.rend()) ;
+               else
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd1.begin(), vPntTopEnd1.end()) ;
+               PNTVECTOR vPntTopEnd02 = cBezTopStartF2->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.emplace_back( vPntTopEnd02.rbegin(), vPntTopEnd02.rend()) ;
+               else
+                  vvPtCtrl.emplace_back( vPntTopEnd02.begin(), vPntTopEnd02.end()) ;
+               PNTVECTOR vPntTopEnd2 = cBezTopEndF2->GetAllControlPoints() ;
+               if ( ! bInverse)
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd2.rbegin(), vPntTopEnd2.rend()) ;
+               else
+                  vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTopEnd2.begin(), vPntTopEnd2.end()) ;
             }
          }
          
@@ -1793,36 +2047,74 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
             if ( ! bTipIsPivot) {
                // inferiori
                if ( dSide > 0) {
-                  PNTVECTOR vPntTip01 = cBezTipStartB1->GetAllControlPoints();
-                  vvPtCtrl.emplace_back(vPntTip01.rbegin(), vPntTip01.rend());
-                  PNTVECTOR vPntTip1 = cBezTipEndB1->GetAllControlPoints();
-                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTip1.rbegin(), vPntTip1.rend());
-                  PNTVECTOR vPntTip02 = cBezTipStartB2->GetAllControlPoints();
-                  vvPtCtrl.emplace_back(vPntTip02.rbegin(), vPntTip02.rend());
-                  PNTVECTOR vPntTip2 = cBezTipEndB2->GetAllControlPoints();
-                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTip2.rbegin(), vPntTip2.rend());
+                  PNTVECTOR vPntTip01 = cBezTipStartB1->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.emplace_back( vPntTip01.rbegin(), vPntTip01.rend()) ;
+                  else
+                     vvPtCtrl.emplace_back( vPntTip01.begin(), vPntTip01.end()) ;
+                  PNTVECTOR vPntTip1 = cBezTipEndB1->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.rbegin(), vPntTip1.rend()) ;
+                  else 
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.begin(), vPntTip1.end()) ;
+                  PNTVECTOR vPntTip02 = cBezTipStartB2->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.emplace_back( vPntTip02.rbegin(), vPntTip02.rend()) ;
+                  else
+                     vvPtCtrl.emplace_back( vPntTip02.begin(), vPntTip02.end()) ;
+                  PNTVECTOR vPntTip2 = cBezTipEndB2->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.rbegin(), vPntTip2.rend()) ;
+                  else
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.begin(), vPntTip2.end()) ;
                }
                else {
-                  vvPtCtrl.emplace_back(cBezTipStartF1->GetAllControlPoints());
-                  PNTVECTOR vPntTip1 = cBezTipEndF1->GetAllControlPoints();
-                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTip1.begin(), vPntTip1.end());
-                  vvPtCtrl.emplace_back(cBezTipStartF2->GetAllControlPoints());
-                  PNTVECTOR vPntTip2 = cBezTipEndF2->GetAllControlPoints();
-                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTip2.begin(), vPntTip2.end());
+                  PNTVECTOR vPntTip01 = cBezTipStartF1->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.emplace_back( vPntTip01.begin(), vPntTip01.end()) ;
+                  else
+                     vvPtCtrl.emplace_back( vPntTip01.rbegin(), vPntTip01.rend()) ;
+                  PNTVECTOR vPntTip1 = cBezTipEndF1->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.begin(), vPntTip1.end()) ;
+                  else
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip1.rbegin(), vPntTip1.rend()) ;
+                  PNTVECTOR vPntTip02 = cBezTipStartF2->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.emplace_back( vPntTip02.begin(), vPntTip02.end()) ;
+                  else
+                     vvPtCtrl.emplace_back( vPntTip02.rbegin(), vPntTip02.rend()) ;
+                  PNTVECTOR vPntTip2 = cBezTipEndF2->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.begin(), vPntTip2.end()) ;
+                  else
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTip2.rbegin(), vPntTip2.rend()) ;
                }
             }
             
-            if( ! bTopIsPivot) {
+            if ( ! bTopIsPivot) {
                // superiori
                if ( dSide > 0) {
-                  PNTVECTOR vPntTop01 = cBezTopStartF1->GetAllControlPoints();
-                  vvPtCtrl.emplace_back(vPntTop01.rbegin(), vPntTop01.rend());
-                  PNTVECTOR vPntTop1 = cBezTopEndF1->GetAllControlPoints();
-                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTop1.rbegin(), vPntTop1.rend());
-                  PNTVECTOR vPntTop02 = cBezTopStartF2->GetAllControlPoints();
-                  vvPtCtrl.emplace_back(vPntTop02.rbegin(), vPntTop02.rend());
-                  PNTVECTOR vPntTop2 = cBezTopEndF2->GetAllControlPoints();
-                  vvPtCtrl.back().insert(vvPtCtrl.back().end(), vPntTop2.rbegin(), vPntTop2.rend());
+                  PNTVECTOR vPntTop01 = cBezTopStartF1->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.emplace_back( vPntTop01.rbegin(), vPntTop01.rend()) ;
+                  else
+                     vvPtCtrl.emplace_back( vPntTop01.begin(), vPntTop01.end()) ;
+                  PNTVECTOR vPntTop1 = cBezTopEndF1->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop1.rbegin(), vPntTop1.rend()) ;
+                  else
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop1.begin(), vPntTop1.end()) ;
+                  PNTVECTOR vPntTop02 = cBezTopStartF2->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.emplace_back( vPntTop02.rbegin(), vPntTop02.rend()) ;
+                  else
+                     vvPtCtrl.emplace_back( vPntTop02.begin(), vPntTop02.end()) ;
+                  PNTVECTOR vPntTop2 = cBezTopEndF2->GetAllControlPoints() ;
+                  if ( ! bInverse)
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop2.rbegin(), vPntTop2.rend()) ;
+                  else
+                     vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntTop2.begin(), vPntTop2.end()) ;
                }
                else {
                   vvPtCtrl.emplace_back(cBezTopStartB1->GetAllControlPoints());
@@ -1838,23 +2130,43 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
 
       // chiudo il volume con le superfici verticali e le basi dei tool
 
-      // chiudo il volume con le superici verticali end 1
+      // chiudo il volume con le superici verticali end front 1
       vvPtCtrl.emplace_back( cBezTipEndF1->GetAllControlPoints()) ;
-      PNTVECTOR vPntEnd1 = cBezTopEndF1->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEnd1.begin(), vPntEnd1.end()) ;
-      // chiudo il volume con le superici verticali end 2
+      PNTVECTOR vPntEndF1 = cBezTopEndF1->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEndF1.begin(), vPntEndF1.end()) ;
+      // chiudo il volume con le superici verticali end front 2
       vvPtCtrl.emplace_back( cBezTipEndF2->GetAllControlPoints()) ;
-      PNTVECTOR vPntEnd2 = cBezTopEndF2->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEnd2.begin(), vPntEnd2.end()) ;
+      PNTVECTOR vPntEndF2 = cBezTopEndF2->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEndF2.begin(), vPntEndF2.end()) ;
+      if ( bInverse  ||  bSmallMovement) {
+         // chiudo il volume con le superici verticali end back 1
+         vvPtCtrl.emplace_back( cBezTipEndB1->GetAllControlPoints()) ;
+         PNTVECTOR vPntEndB1 = cBezTopEndB1->GetAllControlPoints() ;
+         vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEndB1.begin(), vPntEndB1.end()) ;
+         // chiudo il volume con le superici verticali end back 2
+         vvPtCtrl.emplace_back( cBezTipEndB2->GetAllControlPoints()) ;
+         PNTVECTOR vPntEndB2 = cBezTopEndB2->GetAllControlPoints() ;
+         vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEndB2.begin(), vPntEndB2.end()) ;
+      }
 
-      // chiudo il volume con le superici verticali start 1
+      // chiudo il volume con le superici verticali start back 1
       vvPtCtrl.emplace_back( cBezTipStartB1->GetAllControlPoints()) ;
-      PNTVECTOR vPntStart1 = cBezTopStartB1->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStart1.begin(), vPntStart1.end()) ;
-      // chiudo il volume con le superfici verticali start 2
+      PNTVECTOR vPntStartB1 = cBezTopStartB1->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStartB1.begin(), vPntStartB1.end()) ;
+      // chiudo il volume con le superfici verticali start back 2
       vvPtCtrl.emplace_back( cBezTipStartB2->GetAllControlPoints()) ;
-      PNTVECTOR vPntStart2 = cBezTopStartB2->GetAllControlPoints() ;
-      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStart2.begin(), vPntStart2.end()) ;
+      PNTVECTOR vPntStartB2 = cBezTopStartB2->GetAllControlPoints() ;
+      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStartB2.begin(), vPntStartB2.end()) ;
+      if ( bInverse   ||  bSmallMovement) {
+         // chiudo il volume con le superici verticali start front 1
+         vvPtCtrl.emplace_back( cBezTipStartF1->GetAllControlPoints()) ;
+         PNTVECTOR vPntStartF1 = cBezTopStartF1->GetAllControlPoints() ;
+         vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStartF1.begin(), vPntStartF1.end()) ;
+         // chiudo il volume con le superfici verticali start front 2
+         vvPtCtrl.emplace_back( cBezTipStartF2->GetAllControlPoints()) ;
+         PNTVECTOR vPntStartF2 = cBezTopStartF2->GetAllControlPoints() ;
+         vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStartF2.begin(), vPntStartF2.end()) ;
+      }
 
       // superfici di base dei tool
       if ( ! ( n5AxisType == Move5Axis::NO_BASE_INTERS  &&  dSide < 0)) {
@@ -1925,7 +2237,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
    }
 
    // inizializzo le superfici bilineari e i parametri per le intersezioni
-   for ( int z = 0 ; z < int( vvPtCtrl.size()) ; ++z) {
+   for ( int z = 0 ; z < ssize( vvPtCtrl) ; ++z) {
       vSurfBez[nSurfInd].sBez.Init( nDegU, nDegV, nSpanU, nSpanV, bRat) ;
       vSurfBez[nSurfInd].sBez.SetControlPoint( 0, vvPtCtrl[z][0]) ;
       vSurfBez[nSurfInd].sBez.SetControlPoint( 1, vvPtCtrl[z][1]) ;
@@ -1936,6 +2248,11 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
       vSurfBez[nSurfInd].sBez.SetControlPoint( 6, vvPtCtrl[z][6]) ;
       vSurfBez[nSurfInd].sBez.SetControlPoint( 7, vvPtCtrl[z][7]) ;
 
+#if SAVETRIMMINGTOOL
+      if ( nGrid == 0)
+         vGeo.push_back( vSurfBez[nSurfInd].sBez.Clone()) ;
+#endif
+
       Vector3d A = vvPtCtrl[z][4] - vvPtCtrl[z][0] ;
       Vector3d B = vvPtCtrl[z][5] - vvPtCtrl[z][1] ;
       Vector3d C = vvPtCtrl[z][6] - vvPtCtrl[z][2] ;
@@ -1984,6 +2301,11 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
       ++ nSurfInd ;
    }
 
+#if SAVETRIMMINGTOOL
+   if ( nGrid == 0)
+      SaveGeoObj( vGeo, "D:\\Temp\\VirtualMilling\\5axisAdvanced\\marmo sottosquadra\\volume.nge") ;
+#endif
+
    // scorro tutti gli spilloni interessati
    int j = 0 ;
    int nLastForwardJ = -1 ;
@@ -2288,7 +2610,15 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co
 
   // Calcolo angoli di rotazione utensile longitudinale e trasversale rispetto al movimento per eventuale suddivisione
    double dAlongAngDeg, dAcrossAngDeg ;
-   GetAlongAcrossRotation( vtDs, vtDe, ptPe - ptPs, dAlongAngDeg, dAcrossAngDeg) ;
+   if ( m_vTool[m_nCurrTool].GetRadius() < 40)
+      GetAlongAcrossRotation( vtDs, vtDe, ptPe - ptPs, dAlongAngDeg, dAcrossAngDeg) ;
+   else {
+      // se è una lama uso un asse diverso per calcolare le rotaziona del vettore tool
+      Vector3d vtAxis = vtDs ^ vtDe ;
+      GetAlongAcrossRotation( vtDs, vtDe, vtAxis, dAlongAngDeg, dAcrossAngDeg) ;
+      swap( dAlongAngDeg, dAcrossAngDeg) ;
+   }
+
 
   // Calcolo numero degli step di movimento
    int nStepCnt = int( max( { abs( dAlongAngDeg) / ANG_ALONG_STEP, abs( dAcrossAngDeg) / ANG_ACROSS_STEP, 1.})) ;
@@ -2397,7 +2727,7 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co
       InitializePointsAndVectors( ptSti, ptEni, vtDSi, vtDEi, ptLs, ptLe, vtLs, vtLe) ;
 
       // Standard è multithread
-      constexpr bool MULTITHREAD = false ;
+      constexpr bool MULTITHREAD = true ;
       if ( MULTITHREAD) {
          // Ciclo sulle mappe
          vector<future<bool>> vRes( m_nMapNum) ;
@@ -5928,7 +6258,8 @@ VolZmap::CompCyl_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, co
          Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ;
          Point3d ptInt1, ptInt2 ;
          Vector3d vtN1, vtN2 ;
-         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dH, dRad, bTapB, bTapT, ptInt1, vtN1, ptInt2, vtN2)) {
+         double dU1, dU2 ;
+         if ( IntersLineCyl( ptC, Z_AX, CylFrame, dH, dRad, bTapB, bTapT, dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, false, true)) {
             SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
          }
       }
@@ -5973,8 +6304,9 @@ VolZmap::CompConus_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE,
          Vector3d vtN1, vtN2 ;
 
         // Cilindro
-         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dH, dMaxRad, true, bTapT,
-                                  ptInt1, vtN1, ptInt2, vtN2)) {
+         double dU1, dU2 ;
+         if ( IntersLineCyl( ptC, Z_AX, CylFrame, dH, dMaxRad, true, bTapT,
+                             dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, false, true)) {
             SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
          }
 
@@ -6153,7 +6485,8 @@ VolZmap::CompCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE,
 
               // Cilindro iniziale
                CylFrame.ChangeOrig( ptITip) ;
-               if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, bTapB, bTapT, ptInt1, vtN1, ptInt2, vtN2)) {
+               double dU1, dU2 ;
+               if ( IntersLineCyl( ptC, Z_AX, CylFrame, dHei, dRad, bTapB, bTapT, dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, false, true)) {
                   SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
                }
 
@@ -6161,7 +6494,7 @@ VolZmap::CompCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE,
               // del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
               // il vettore che congiunge le due origini.
                CylFrame.ChangeOrig( ptITip + vtMove) ;
-               if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, bTapB, bTapT, ptInt1, vtN1, ptInt2, vtN2)) {
+               if ( IntersLineCyl( ptC, Z_AX, CylFrame, dHei, dRad, bTapB, bTapT, dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, false, true)) {
                   SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
                }
 
@@ -6748,7 +7081,8 @@ VolZmap::CompBall_Milling( int nGrid, const Point3d& ptLs, const Point3d& ptLe,
         // Cilindro inviluppo della sfera
          Point3d ptInt1, ptInt2 ;
          Vector3d vtN1, vtN2 ;
-         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLengthPath, dRad, false, false, ptInt1, vtN1, ptInt2, vtN2)) {
+         double dU1, dU2 ;
+         if ( IntersLineCyl( ptC, Z_AX, CylFrame, dLengthPath, dRad, false, false, dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, false, true)) {
             SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
          }
       }
@@ -6896,15 +7230,15 @@ VolZmap::AddingCylinder( int nGrid, const Point3d& ptS, const Point3d& ptE, cons
                                            
          Point3d ptInt1, ptInt2 ;
          Vector3d vtN1, vtN2 ;
-
-         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, true, true,
-                                  ptInt1, vtN1, ptInt2, vtN2)) {
-            AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2, CurrTool.GetToolNum()) ;
+         double dU1, dU2 ;
+         if ( IntersLineCyl( ptC, Z_AX, CylFrame, dHei, dRad, true, true,
+                             dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, false, false)) {
+            AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, CurrTool.GetToolNum()) ;
          }
 
-         if ( IntersLineCylinder( ptC - dLen1 * vtV1, Z_AX, CylFrame, dHei, dRad, true, true,
-                                  ptInt1, vtN1, ptInt2, vtN2)) {
-            AddIntervals( nGrid, i, j, ptInt1.z + dLen1 * vtV1.z, ptInt2.z + dLen1 * vtV1.z, - vtN1, - vtN2, CurrTool.GetToolNum()) ;
+         if ( IntersLineCyl( ptC - dLen1 * vtV1, Z_AX, CylFrame, dHei, dRad, true, true,
+                             dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, false, false)) {
+            AddIntervals( nGrid, i, j, ptInt1.z + dLen1 * vtV1.z, ptInt2.z + dLen1 * vtV1.z, vtN1, vtN2, CurrTool.GetToolNum()) ;
          }
 
          if ( IntersLineMyPolyhedron( ptC, Z_AX, PolyFrame, dLen1, 2 * ( dRad + dMyTol), dHei + 2 * dMyTol, 0,
@@ -7300,8 +7634,9 @@ VolZmap::AddingSphere( int nGrid, const Point3d& ptS, const Point3d& ptE, double
         // Cilindro inviluppo della sfera
          Point3d ptInt1, ptInt2 ;
          Vector3d vtN1, vtN2 ;
-         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLengthPath, dRad, false, false, ptInt1, vtN1, ptInt2, vtN2)) {
-            AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2, CurrTool.GetToolNum()) ;
+         double dU1, dU2 ;
+         if ( IntersLineCyl( ptC, Z_AX, CylFrame, dLengthPath, dRad, false, false, dU1, ptInt1, vtN1, dU2, ptInt2, vtN2, false, false)) {
+            AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, CurrTool.GetToolNum()) ;
          }
       }
    }

Voronoi.cpp

@@ -434,6 +434,7 @@ Voronoi::GetBisectorCurve( int i)
       pLine->Set( ptS, ptE) ;
       pLine->SetTempParam( dParS, 0) ;
       pLine->SetTempParam( dParE, 1) ;
+      pLine->SetTempProp( i) ;
       pLine->ToGlob( m_Frame) ;
       return pLine ;
    }
@@ -454,6 +455,7 @@ Voronoi::GetBisectorCurve( int i)
       pArc->SetC2P( ptC, ptS, ptE) ;
       pArc->SetTempParam( dParS, 0) ;
       pArc->SetTempParam( dParS, 1) ; // dParE = dParS
+      pArc->SetTempProp( i) ;
       pArc->ToGlob( m_Frame) ;
       return pArc ;
    }
@@ -473,7 +475,7 @@ Voronoi::GetBisectorCurve( int i)
       bool bInvert = false ;
       double dPar1, dPar2 ;
       m_vroni->GetApproxedBisectorParams( i, dPar1, dPar2) ;
-      if ( dPar1 > dPar2 + EPS_SMALL)
+      if ( dPar1 > dPar2)
          bInvert = true ;
 
      // punto iniziale
@@ -496,6 +498,11 @@ Voronoi::GetBisectorCurve( int i)
             dParPrev = dPar ;
             nCrvCount ++ ;
          }
+         else if ( ( bInvert  &&  j == 0)  ||  ( ! bInvert  &&  j == nPoints - 1)) {
+           // se estremo devo forzarlo
+            pCompo->ModifyEnd( pt) ;
+            dParPrev = dPar ;
+         }
         // aggiorno per punto successivo
          if ( bInvert)
             j -- ;
@@ -506,6 +513,7 @@ Voronoi::GetBisectorCurve( int i)
      // setto parametri sulla curva
       pCompo->SetTempParam( dParS, 0) ;
       pCompo->SetTempParam( dParPrev, 1) ;
+      pCompo->SetTempProp( i) ;
 
       pCompo->ToGlob( m_Frame) ;
       return pCompo ;
@@ -700,8 +708,8 @@ Voronoi::CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs)
                  // se necessario verifico se dal lato corretto rispetto ai siti di riferimento
                   if ( bLeft  &&  bRight) {
                     // recupero i siti di riferimento
-                     int nOrigCrv1, nOrigSubCrv1, nOrigCrv2, nOrigSubCrv2 ;
-                     m_vroni->GetBisectorSites( i, nOrigCrv1, nOrigSubCrv1, nOrigCrv2, nOrigSubCrv2) ;
+                     int nOrigCrv1, nOrigSubCrv1, nOrigSubPnt1, nOrigCrv2, nOrigSubCrv2, nOrigSubPnt2 ;
+                     m_vroni->GetBisectorSites( i, nOrigCrv1, nOrigSubCrv1, nOrigSubPnt1, nOrigCrv2, nOrigSubCrv2, nOrigSubPnt2) ;
                      if ( nOrigCrv1 != -1) {
                        // verifico il lato rispetto al primo sito
                         pCrv->SetTempProp( nOrigSubCrv1 + 1, 0) ;
@@ -828,10 +836,19 @@ Voronoi::CalcSpecialPointOffset( PNTVECTVECTOR& vResult, double dOffs)
             Point3d ptTemp ;
             Vector3d vtDir ;
             if ( ! pCrv->GetParamAtPoint( pt, dPar, 100 * EPS_SMALL)  ||  ! pCrv->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptTemp, &vtDir))
-               return false ;
+               continue ;
             vtDir.Normalize() ;
 
-            vResult.emplace_back( pt, vtDir) ;
+           // verifico che il punto non sia già stato trovato
+            bool bAdd = true ;
+            for ( int j = 0 ; j < ssize( vResult) ; j ++) {
+               if ( AreSamePointApprox( vResult[j].first, pt)) {
+                  bAdd = false ;
+                  break ;
+               }
+            }
+            if ( bAdd)
+               vResult.emplace_back( pt, vtDir) ;
          }
       }
 
@@ -1014,8 +1031,17 @@ Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs)
          RemoveCurveSmallParts( pCrvOffs, 5 * EPS_SMALL) ;
 
         // aggiungo la curva alla lista degli offset
-         if ( ! IsNull( pCrvOffs) &&  pCrvOffs->IsValid()  &&  pCrvOffs->GetCurveCount() > 0)
+         if ( ! IsNull( pCrvOffs) &&  pCrvOffs->IsValid()  &&  pCrvOffs->GetCurveCount() > 0) {
+           // forzo chiusura
+            if ( ! pCrvOffs->IsClosed()) {
+               Point3d ptS ; pCrvOffs->GetStartPoint( ptS) ;
+               Point3d ptE ; pCrvOffs->GetEndPoint( ptE) ;
+               if ( SqDist( ptS, ptE) > 100. * SQ_EPS_SMALL)
+                  return false ;
+               pCrvOffs->Close() ;
+            }
             OffsList.push_back( Release( pCrvOffs)) ;
+         }
       }
 
      // libero la memoria di vroni dedicata agli offset
@@ -1155,7 +1181,7 @@ Voronoi::AdjustOffsetStart( ICurveComposite* pCrv) const
 
 //---------------------------------------------------------------------------
 bool
-Voronoi::Translate( const Vector3d & vtMove)
+Voronoi::Translate( const Vector3d& vtMove)
 {
    if ( ! IsValid())
       return false ;
@@ -1243,3 +1269,62 @@ Voronoi::CalcLimitOffset( int nCrv, bool bLeft, double& dOffs)
 
    return true ;
 }
+
+//---------------------------------------------------------------------------
+bool 
+Voronoi::GetBisectorPointAtParam( int nCrv, double dPar, Point3d& ptP) 
+{
+   if ( ! IsValid())
+      return false ;
+
+    try {
+       if ( ! m_bVDComputed)
+          CalcVoronoi() ;
+
+      // verifico se il bisettore e il parametri richiesto sono sensati
+       if ( nCrv >= m_vroni->GetNumberOfEdges())
+          return false ;
+       double dParS, dParE ;
+       m_vroni->GetBisectorParams( nCrv, dParS, dParE) ;
+       if ( dParS > dParE)
+          swap( dParS, dParE) ;
+       if ( dPar < dParS  ||  dPar > dParE)
+          return false ;
+
+      // calcolo il punto sul bisettore in corrispondenza dell'offset
+       m_vroni->GetBisectorPointAtParam( nCrv, dPar, ptP.v) ;
+       ptP.ToGlob( m_Frame) ;
+
+       return true ;
+    }
+    catch (...) {
+       LOG_ERROR( GetEGkLogger(), m_vroni->GetExceptionMessage()) ;
+       return false ;
+    }
+
+}
+
+//---------------------------------------------------------------------------
+bool 
+Voronoi::GetBisectorSites( int nCrv, int& nCrv1, int& nSubCrv1, int& nSubPnt1, int& nCrv2, int& nSubCrv2, int& nSubPnt2)
+{
+   if ( ! IsValid())
+      return false ;
+
+   try {
+      if ( ! m_bVDComputed)
+         CalcVoronoi() ;
+
+     // verifico se il bisettore è valido
+      if ( nCrv >= m_vroni->GetNumberOfEdges())
+         return false ;
+
+     // calcolo il punto sul bisettore in corrispondenza dell'offset
+      m_vroni->GetBisectorSites( nCrv, nCrv1, nSubCrv1, nSubPnt1, nCrv2, nSubCrv2, nSubPnt2) ;
+      return true ;
+   }
+   catch (...) {
+      LOG_ERROR( GetEGkLogger(), m_vroni->GetExceptionMessage()) ;
+      return false ;
+   }
+}

Voronoi.h

@@ -60,6 +60,8 @@ class Voronoi
       bool CalcFatCurve( ICURVEPOVECTOR& vOffs, double dOffs, bool bSquareEnds, bool bSquareMids, bool bMergeOnlySameProps = true) ;
       bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide) ;
       bool CalcLimitOffset( int nCrv, bool bLeft, double& dOffs) ;
+      bool GetBisectorPointAtParam( int nCrv, double dPar, Point3d& ptP) ;
+      bool GetBisectorSites( int nCrv, int& nCrv1, int& nSubCrv1, int& nSubPnt1, int& nCrv2, int& nSubCrv2, int& nSubPnt2) ;
 
       bool Translate( const Vector3d& vtMove) ;
       bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg) ;