EgtGeomKernel :

- modifiche a RMF per avere la tangente media sul punto di calcolo (utile solo se la curva non è G1) - modifiche a GetSurfTriMeshSwept per avere RMF anche con curve piane garantendo la retrocompatibilità.
EgtGeomKernel :
2026-05-14 13:02:47 +02:00 · 2026-05-12 09:34:56 +02:00 · 2026-05-08 17:25:32 +02:00 · 2026-05-08 17:23:01 +02:00 · 2026-05-07 14:28:07 +02:00 · 2026-05-07 12:23:08 +02:00
23 changed files with 3335 additions and 785 deletions
@@ -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) ;
@@ -25,19 +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

@@ -1595,8 +1600,10 @@ FitWithBezier( const ICurve* pCrvOrig, const PNTVECTOR& vPnt, DBLVECTOR& vParam,

 //----------------------------------------------------------------------------
 ICurve*
-ApproxCurveWithBezier( const ICurve* pCrv , double dTol)
+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") ;
@@ -1668,6 +1675,10 @@ ApproxCurveWithBezier( const ICurve* pCrv , double dTol)
   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) ;
@@ -1718,7 +1729,11 @@ CalcApproxError( const ICurve* pCrvOri, const ICurve* pCrvNew, double& dErr, int
   // 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 ;
@@ -2687,3 +2702,115 @@ GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol, bool bAllowInvert)
   }
   return true ;
 }
+
+//----------------------------------------------------------------------------
+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) ;
+   // --- 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) ;
+   if ( vtCurr1 * vtCurr2 < COS_ANG_TOL) {
+      // Se fuori dalla tolleranza, recupero il miglior versore tangente sul secondo bordo nell'intervallo successivo di lunghezza ( 2. * dMyDist)
+      pCrvEdge2->GetLengthAtPoint( ptCurr2, dLenCurr2) ;
+      double dLimInfLen2 = Clamp( dLenCurr2 - dMyDist, dLenPrev2, dLen2) ;
+      double dLimSupLen2 = Clamp( dLenCurr2 + dMyDist, dLenPrev2, dLen2) ;
+      // [Controllo migliorabile, magari mendiante metodo di bisezione (?)]
+      const int NUM_STEP = 20 ;
+      double dMinCos = - 1. - EPS_ZERO ;
+      const double DEGTOL = 5. ;
+      for ( int i = 0 ; i <= NUM_STEP ; ++ i) {
+         double dLen = dLimInfLen2 + i * ( dLimSupLen2 - dLimInfLen2) / NUM_STEP ;
+         double dUStep2 ; pCrvEdge2->GetParamAtLength( dLen, dUStep2) ;
+         Point3d ptStep2 ; Vector3d vtStep2 = V_NULL ;
+         pCrvEdge2->GetPointD1D2( dUStep2, ICurve::FROM_MINUS, ptStep2, &vtStep2) ; vtStep2.Normalize() ;
+         double dStepCos2 = vtCurr1 * vtStep2 ;
+         double dAngTol = ( i < NUM_STEP / 2 ? ( 2. * DEGTOL) / NUM_STEP * i :
+            ( - 2. * DEGTOL) / NUM_STEP * ( i - NUM_STEP)) ;
+         double dCosTol = 1. - cos( dAngTol * DEGTORAD) ;
+         if ( dStepCos2 + dCosTol > dMinCos) {
+            ptCurr2 = ptStep2 ;
+            vtCurr2 = vtStep2 ;
+            dUCurr2 = dUStep2 ;
+            dMinCos = dStepCos2 + dCosTol ;
+         }
+      }
+   }
+   return true ;
+}
@@ -35,4 +35,4 @@ 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) ;
+bool GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol, bool bAllowInvert) ;
@@ -1967,7 +1967,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 +2090,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 +2120,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 +2141,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 +3977,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 ;
+}
@@ -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 ;
@@ -156,7 +159,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 +183,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 +217,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} ;
@@ -1,69 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2015-2018
-//----------------------------------------------------------------------------
-// File : EGkCAvSurfFrMove.h      Data : 26.03.2026    Versione : 3.1c6
-// Contenuto : Dichiarazione classe per movimento di superfici flat region
-//             nel loro piano evitando collisioni
-//
-// Modifiche : 26.03.26 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkSurfFlatRegion.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
-
-//----------------------------------------------------------------------------
-// Costanti per info su tipo di Collisione tra regioni piane
-const int CI_NONE = 0 ;                  // non definito
-const int CI_PNT_PNT = 1 ;               // tra punto di mobile e punto di fissa
-const int CI_PNT_LINE = 2 ;              // tra punto di mobile e linea di fissa
-const int CI_LINE_PNT = 3 ;              // tra linea di mobile e punto di fissa
-const int CI_LINE_LINE = 4 ;             // tra linea di mobile e linea di fissa
-
-//----------------------------------------------------------------------------
-struct CollInfo
-{
-   int nType ;                    // tipo di collisione
-   int nChunkM ;                  // indice del chunk della regione mobile
-   int nCrvM ;                    // indice della curva nel loop esterno del chunk
-   int nChunkF ;                  // indice del chunk della regione fissa
-   int nCrvF ;                    // indice della curva nel loop esterno del chunk
-   Point3d ptP1 ;                 // punto di contatto
-   Point3d ptP2 ;                 // se contatto linea-linea, secondo punto di contatto
-   Vector3d vtDirM ;              // se contatto del mobile con linea, sua direzione
-   Vector3d vtDirF ;              // se contatto del fisso con linea, sua direzione
-   // costruttori
-   CollInfo() : nType( CI_NONE), nChunkM( -1), nCrvM( -1), nChunkF( -1), nCrvF( -1),
-                 ptP1(), ptP2(), vtDirM(), vtDirF() {}
-   CollInfo( const CollInfo& Sou) : nType( Sou.nType), nChunkM( Sou.nChunkM), nCrvM( Sou.nCrvM),
-                                    nChunkF( Sou.nChunkF), nCrvF( Sou.nCrvF), ptP1( Sou.ptP1),
-                                    ptP2( Sou.ptP2), vtDirM( Sou.vtDirM), vtDirF( Sou.vtDirF) {}
-} ;
-
-//----------------------------------------------------------------------------
-class CAvSurfFrMove
-{
-   public :
-      EGK_EXPORT CAvSurfFrMove( const ISurfFlatRegion& SfrM, const ISurfFlatRegion& SfrF) ;
-
-   public :
-      EGK_EXPORT bool Translate( const Vector3d& vtDir, double& dLen) ;
-      EGK_EXPORT bool Rotate( const Point3d& ptCen, double& dAng) ;
-      EGK_EXPORT const CollInfo& GetCollInfo()
-                           { return m_CollInfo ; }
-
-   private :
-      const ISurfFlatRegion* m_pRegM ;
-      const ISurfFlatRegion* m_pRegF ;
-      CollInfo m_CollInfo ;
-} ;
@@ -573,6 +573,9 @@
    <ClCompile Include="CAvSurfFrMove.cpp">
      <Filter>File di origine\GeoCollisionAvoid</Filter>
    </ClCompile>
+    <ClCompile Include="Trimming.cpp">
+      <Filter>File di origine\GeoStriping</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="stdafx.h">
@@ -198,13 +198,16 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
              // se coincidono U e ptInt tra A e B
               if ( abs( m_Info[i].IciA[0].dU - m_Info[j].IciB[0].dU) < EPS_SMALL  &&
                    AreSamePointXYEpsilon( m_Info[i].IciA[0].ptI, m_Info[j].IciB[0].ptI, 10 * EPS_SMALL)) {
-                 // se non è alla fine di curva chiusa 
-                  if ( ! bCrvAClosed  ||  abs( m_Info[j].IciA[0].dU - dCrvBSpan) > EPS_SMALL)
-                    // elimino la seconda
-                     EraseOtherInfo( i, j) ;
-                  else
-                    // elimino la prima
+                 // se j è alla fine di curva chiusa
+                 // se j è alla fine di curva chiusa e la prima intersezione è di overlap con partenza dall'inizio ( compreso nel caso precedente)
+                 // oppure se i è all'inizio di curva chiusa e l'intersezione successiva a j è di overlap con lo stesso parametro
+                  if ( bCrvAClosed  &&  (( abs( m_Info[j].IciA[0].dU - dCrvBSpan) < EPS_SMALL)  ||
+                                    ( i == 0  &&  ssize(m_Info) > 2 &&  m_Info[i].IciA[0].dU < EPS_SMALL &&  m_Info[j+1].bOverlap &&  abs( m_Info[j].IciA[0].dU - m_Info[j+1].IciA[0].dU) < EPS_SMALL)))
+                     // elimino la prima
                     EraseCurrentInfo( i, j) ;
+                  else
+                     // elimino la seconda
+                     EraseOtherInfo( i, j) ;
                  break ;
               }
            }
@@ -802,19 +805,36 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
      INTVECTOR vNewOverlap ;
      // salvo eventuali incoerenze col precedente
      for ( int i = bCrvAClosed ? 0 : 1 ; i < m_nNumInters ; ++i) {
-         int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
-         int kj = m_Info[j].bOverlap ? 1 : 0 ;
+         int j = ( i == 0 ? m_nNumInters - 1 : i - 1) ;
+         int kj = ( m_Info[j].bOverlap ? 1 : 0) ;
+         bool bSpike = m_Info[i].bOverlap  &&  m_Info[j].bOverlap  &&  m_Info[i].bCBOverEq != m_Info[j].bCBOverEq ;
+         if ( bSpike) {
+            bSpike = abs( m_Info[i].IciA[0].dU - m_Info[j].IciA[0].dU) < EPS_PARAM || 
+                     abs( m_Info[i].IciA[0].dU - m_Info[j].IciA[1].dU) < EPS_PARAM || 
+                     abs( m_Info[i].IciA[1].dU - m_Info[j].IciA[0].dU) < EPS_PARAM ||
+                     abs( m_Info[i].IciA[1].dU - m_Info[j].IciA[1].dU) < EPS_PARAM ;
+         }
         if ( (m_Info[j].IciA[kj].nNextTy == ICCT_NULL  ||  m_Info[i].IciA[0].nPrevTy  == ICCT_NULL  ||  m_Info[j].IciA[kj].nNextTy != m_Info[i].IciA[0].nPrevTy) &&
               m_Info[j].IciA[kj].nNextTy != ICCT_SPK  &&  m_Info[i].IciA[0].nPrevTy != ICCT_SPK) {
-            vIncoherenceWithPrev.push_back( i) ;
+            if ( vIncoherenceWithPrev.empty() || vIncoherenceWithPrev.back() != i)
+               vIncoherenceWithPrev.push_back( i) ;
+            if ( bSpike) {
+               // se ho uno spike sistemo anche il successivo
+               int k = i == m_nNumInters - 1 ? -1 : i + 1 ;
+               if ( k == -1  &&  bCrvAClosed)
+                  k = 0 ;
+
+               if ( k != -1)
+                  vIncoherenceWithPrev.push_back( k) ;
+            }
            bCoherent = false ;
         }
      }
      // incoerenze sulla curva A
      if ( ! bCoherent) {
         for ( int i : vIncoherenceWithPrev) {
-            int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
-            int kj = m_Info[j].bOverlap ? 1 : 0 ;
+            int j = ( i == 0 ? m_nNumInters - 1 : i - 1) ;
+            int kj = ( m_Info[j].bOverlap ? 1 : 0) ;
            int nType = 0 ;
            CalcSide( j, i, &CCompoA, &CCompoB, true, nType) ;
            if ( nType != ICCT_ON) {
@@ -836,21 +856,38 @@ IntersCrvCompoCrvCompo::IntersCrvCompoCrvCompo( const ICurveComposite& CCompoA,
      vIncoherenceWithPrev.clear() ;
      // salvo eventuali incoerenze col precedente
      for ( int i = bCrvBClosed ? 0 : 1 ; i < m_nNumInters ; ++i) {
-         int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
-         int ki = m_Info[i].bOverlap && ! m_Info[i].bCBOverEq ? 1 : 0 ;
-         int kj = m_Info[j].bOverlap && m_Info[j].bCBOverEq ? 1 : 0 ;
+         int j = ( i == 0 ? m_nNumInters - 1 : i - 1) ;
+         int ki = ( m_Info[i].bOverlap && ! m_Info[i].bCBOverEq ? 1 : 0) ;
+         int kj = ( m_Info[j].bOverlap && m_Info[j].bCBOverEq ? 1 : 0) ;
+         bool bSpike = m_Info[i].bOverlap  &&  m_Info[j].bOverlap  &&  m_Info[i].bCBOverEq != m_Info[j].bCBOverEq ;
+         if ( bSpike) {
+            bSpike = abs( m_Info[i].IciA[0].dU - m_Info[j].IciA[0].dU) < EPS_PARAM || 
+                     abs( m_Info[i].IciA[0].dU - m_Info[j].IciA[1].dU) < EPS_PARAM || 
+                     abs( m_Info[i].IciA[1].dU - m_Info[j].IciA[0].dU) < EPS_PARAM ||
+                     abs( m_Info[i].IciA[1].dU - m_Info[j].IciA[1].dU) < EPS_PARAM ;
+         }
         if ( ( m_Info[j].IciB[kj].nNextTy == ICCT_NULL ||  m_Info[i].IciB[ki].nPrevTy == ICCT_NULL  ||  m_Info[j].IciB[kj].nNextTy != m_Info[i].IciB[ki].nPrevTy)  &&
              m_Info[j].IciB[kj].nNextTy != ICCT_SPK  && m_Info[i].IciB[ki].nPrevTy != ICCT_SPK) {
-            vIncoherenceWithPrev.push_back( i) ;
+            if ( vIncoherenceWithPrev.empty() || vIncoherenceWithPrev.back() != i)
+               vIncoherenceWithPrev.push_back( i) ;
+            if ( bSpike) {
+               // se ho uno spike sistemo anche il successivo
+               int k = ( i == m_nNumInters - 1 ? -1 : i + 1) ;
+               if ( k == -1  &&  bCrvBClosed)
+                  k = 0 ;
+
+               if ( k != -1)
+                  vIncoherenceWithPrev.push_back( k) ;
+            }
            bCoherent = false ;
         }
      }
      // incoerenze sulla curva B
      if ( ! bCoherent) {
         for ( int i : vIncoherenceWithPrev) {
-            int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
-            int ki = m_Info[i].bOverlap && ! m_Info[i].bCBOverEq ? 1 : 0 ;
-            int kj = m_Info[j].bOverlap && m_Info[j].bCBOverEq ? 1 : 0 ;
+            int j = ( i == 0 ? m_nNumInters - 1 : i - 1) ;
+            int ki = ( m_Info[i].bOverlap && !m_Info[i].bCBOverEq ? 1 : 0) ;
+            int kj = ( m_Info[j].bOverlap && m_Info[j].bCBOverEq ? 1 : 0) ;
            int nType = 0 ;
            CalcSide( j, i, &CCompoB, &CCompoA, false, nType) ;
            if ( nType != ICCT_ON) {
@@ -882,13 +919,19 @@ IntersCrvCompoCrvCompo::CalcSide( int j, int i,const ICurve* pThisCrv, const ICu
   const IntCrvCrvInfo& Icci1 = m_Info[j] ;
   const IntCrvCrvInfo& Icci2 = m_Info[i] ;
   // calcolo tra l'intersezione 1 e 2 se la curva sta dentro o fuori
-   int kj = Icci1.bOverlap ? 1 : 0 ;
+   int ki = 0 ;
+   int kj = ( Icci1.bOverlap ? 1 : 0) ;
+   if ( ! bCrvAOrB) {
+      ki = ( m_Info[i].bOverlap && !m_Info[i].bCBOverEq ? 1 : 0) ;
+      kj = ( m_Info[j].bOverlap && m_Info[j].bCBOverEq ? 1 : 0) ;
+   }
+
   double dU = 0 ;
   bool bPrevIsBefore = true ;
   if ( bCrvAOrB) {
      // se precedente minore del successivo faccio la media
-      if ( Icci1.IciA[kj].dU < Icci2.IciA[0].dU)
-         dU = ( Icci2.IciA[0].dU + Icci1.IciA[kj].dU) / 2 ;
+      if ( Icci1.IciA[kj].dU < Icci2.IciA[ki].dU)
+         dU = ( Icci2.IciA[ki].dU + Icci1.IciA[kj].dU) / 2 ;
      // altrimenti guardo tra lo start e il successivo
      else {
         bPrevIsBefore = false ;
@@ -904,8 +947,8 @@ IntersCrvCompoCrvCompo::CalcSide( int j, int i,const ICurve* pThisCrv, const ICu
   }
   else {
      // se precedente minore del successivo faccio la media
-      if ( Icci1.IciB[kj].dU < Icci2.IciB[0].dU)
-         dU = ( Icci2.IciB[0].dU + Icci1.IciB[kj].dU) / 2 ;
+      if ( Icci1.IciB[kj].dU < Icci2.IciB[ki].dU)
+         dU = ( Icci2.IciB[ki].dU + Icci1.IciB[kj].dU) / 2 ;
      // altrimenti guardi tra lo start e il successivo
      else {
         bPrevIsBefore = false ;
@@ -933,24 +976,24 @@ IntersCrvCompoCrvCompo::CalcSide( int j, int i,const ICurve* pThisCrv, const ICu
      bool bIsOn = false ;
      if ( bCrvAOrB) {
         if ( bPrevIsBefore) {
-            vdU[0] = ( 1 - dFactor) * Icci2.IciA[0].dU + dFactor * Icci1.IciA[kj].dU ;
-            vdU[1] = ( 1 - 2 * dFactor) * Icci2.IciA[0].dU + 2 * dFactor * Icci1.IciA[kj].dU ;
+            vdU[0] = ( 1 - dFactor) * Icci2.IciA[ki].dU + dFactor * Icci1.IciA[kj].dU ;
+            vdU[1] = ( 1 - 2 * dFactor) * Icci2.IciA[ki].dU + 2 * dFactor * Icci1.IciA[kj].dU ;
         }
-         else if ( Icci2.IciA[0].dU > 2 * EPS_SMALL){
-            vdU[0] = ( Icci2.IciA[0].dU + 0.) * dFactor ;
-            vdU[1] = ( Icci2.IciA[0].dU + 0.) * 2 * dFactor ;
+         else if ( Icci2.IciA[ki].dU > 2 * EPS_SMALL){
+            vdU[0] = ( Icci2.IciA[ki].dU + 0.) * dFactor ;
+            vdU[1] = ( Icci2.IciA[ki].dU + 0.) * 2 * dFactor ;
         }
         else
            bIsOn = true ;
      }
      else {
         if ( bPrevIsBefore) {
-            vdU[0] = ( 1 - dFactor) * Icci2.IciB[0].dU + dFactor * Icci1.IciB[kj].dU ;
-            vdU[1] = ( 1 - 2 * dFactor) * Icci2.IciB[0].dU + 2 * dFactor * Icci1.IciB[kj].dU ;
+            vdU[0] = ( 1 - dFactor) * Icci2.IciB[ki].dU + dFactor * Icci1.IciB[kj].dU ;
+            vdU[1] = ( 1 - 2 * dFactor) * Icci2.IciB[ki].dU + 2 * dFactor * Icci1.IciB[kj].dU ;
         }
-         else if ( Icci2.IciB[0].dU > 2 * EPS_SMALL) {
-            vdU[0] = ( Icci2.IciB[0].dU + 0.) * dFactor ;
-            vdU[1] = ( Icci2.IciB[0].dU + 0.) * 2 * dFactor ;
+         else if ( Icci2.IciB[ki].dU > 2 * EPS_SMALL) {
+            vdU[0] = ( Icci2.IciB[ki].dU + 0.) * dFactor ;
+            vdU[1] = ( Icci2.IciB[ki].dU + 0.) * 2 * dFactor ;
         }
         else
            bIsOn = true ;
@@ -1019,8 +1062,11 @@ IntersCrvCompoCrvCompo::CalcSide( int j, int i,const ICurve* pThisCrv, const ICu
 bool
 IntersCrvCompoCrvCompo::MergeNewOverlap( int i, bool bCrvAOrB)
 {
+   if ( i >= ssize(m_Info))
+      return false ;
+
   // faccio il merge col precedente
-   int j = i == 0 ? m_nNumInters - 1 : i - 1 ;
+   int j = ( i == 0 ? m_nNumInters - 1 : i - 1) ;
   if ( m_Info[j].bOverlap) {
      m_Info[i].IciA[0] = m_Info[j].IciA[0] ;
      m_Info[i].IciB[0] = m_Info[j].IciB[0] ;
@@ -1159,21 +1205,25 @@ SortGreaterB( const IntCrvCrvInfo& aInfo1, const IntCrvCrvInfo& aInfo2)
   dU1 = aInfo1.IciB[0].dU ;
   if ( aInfo1.bOverlap) {
     // caso normale
-      if ( aInfo1.IciB[0].dU < aInfo1.IciB[1].dU)
+      if ( ( aInfo1.bCBOverEq  &&  aInfo1.IciB[0].dU < aInfo1.IciB[1].dU) || ( ! aInfo1.bCBOverEq  &&  aInfo1.IciB[0].dU > aInfo1.IciB[1].dU))
         dU1 = 0.5 * ( aInfo1.IciB[0].dU + aInfo1.IciB[1].dU) ;
     // a cavallo di fine / inizio
-      else
+      else if ( aInfo1.bCBOverEq)
         dU1 = aInfo1.IciB[0].dU + SPAN_PARAM ;
+      else
+         dU1 = aInfo1.IciB[1].dU + SPAN_PARAM ;
   } 
  // determino il secondo termine del confronto
   dU2 = aInfo2.IciB[0].dU ;
   if ( aInfo2.bOverlap) {
     // caso normale
-      if ( aInfo2.IciB[0].dU < aInfo2.IciB[1].dU)
+      if ( ( aInfo2.bCBOverEq  &&  aInfo2.IciB[0].dU < aInfo2.IciB[1].dU)  ||  ( ! aInfo2.bCBOverEq  &&  aInfo2.IciB[0].dU > aInfo2.IciB[1].dU))
         dU2 = 0.5 * ( aInfo2.IciB[0].dU + aInfo2.IciB[1].dU) ;
     // a cavallo di fine / inizio
-      else
+      else if ( aInfo2.bCBOverEq)
         dU2 = aInfo2.IciB[0].dU + SPAN_PARAM ;
+      else
+         dU2 = aInfo2.IciB[1].dU + SPAN_PARAM ;
   } 

   return ( dU2 > dU1 + EPS_PARAM) ;
@@ -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
@@ -235,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)
@@ -1991,17 +1991,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) ;
@@ -393,7 +393,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) ;
@@ -402,23 +402,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 ;
+                  }
+               }
            }
         }
      }
@@ -455,7 +480,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 ;
@@ -521,7 +546,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) ;
@@ -543,7 +568,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() ;
@@ -558,23 +584,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 ;
+                     }
+                  }
               }
            }
         }
@@ -612,7 +663,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 ;
@@ -663,7 +714,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) ;
@@ -681,7 +732,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) ;
@@ -699,23 +751,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 ;
+                        }
+                     }
                  }
               }
            }
@@ -738,7 +815,7 @@ 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 ;
@@ -754,7 +831,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 ;
@@ -805,7 +882,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) ;
@@ -823,7 +900,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) ;
@@ -850,23 +928,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 ;
+                     }
+                  }
               }
            }
         }
@@ -911,7 +1014,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 ;
@@ -983,7 +1086,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) ;
@@ -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
@@ -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)
@@ -1095,7 +1095,7 @@ GetSurfTriMeshSwept3d( const ICurve* pSect, const ICurve* pGuide, const Vector3d
  // determino se la guida è chiusa
   bool bGuideClosed = pGuide->IsClosed() ;
  // determino algoritmo da usare per calcolare i riferimenti lungo la curva
-   bool bRMF = vtAx.IsSmall() ;
+   bool bRMF = ( ! vtAx.IsValid()  ||  vtAx.IsSmall()) ;

  // riferimento all'inizio della linea guida
   Point3d ptStart ;
@@ -1242,9 +1242,9 @@ GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, const Vector3d&
      if ( pCompo != nullptr  &&  pCompo->IsALine( 10 * EPS_SMALL, ptStart, ptEnd))
         bIsLine = true ;
   }
-  // se la guida è piana
+  // se la guida è piana e il vettore di riferimento è non definito oppure non nullo
   Plane3d plGuide ;
-   if ( pGuide->IsFlat( plGuide, bIsLine, 10 * EPS_SMALL))
+   if ( pGuide->IsFlat( plGuide, bIsLine, 10 * EPS_SMALL)  &&  ( ! vtAx.IsValid()  ||  ! vtAx.IsSmall()))
      return GetSurfTriMeshSweptInPlane( pSect, pGuide, plGuide.GetVersN(), bCapEnds, dLinTol) ;

  // altrimenti swept 3d
@@ -153,6 +153,9 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
      bool CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const BIPNTVECTOR& vCrv) ;
      bool RemoveCollapsedSpans( void) override ;
      bool SwapParameters( void) ;
+      bool LimitSurfToTrimmedRegion( void) override ;
+      bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen) override ;
+      bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen, BIPNTVECTOR& vSyncLines) override ;

   public :                      // IGeoObjRW
      int  GetNgeId( void) const override ;
@@ -352,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) ;
@@ -36,13 +36,13 @@
 #include "/EgtDev/Include/EGkIntersLineBox.h"
 #include "/EgtDev/Include/EGkIntersCurvePlane.h"
 #include "/EgtDev/Include/EGkSurfTriMeshAux.h"
+#include "/EgtDev/Include/EGkRotationMinimizingFrame.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include <thread>
 #include <future>
 #include <numeric>

 // -------------------------- Debug --------------------------------------------
-#define DEBUG 0
 #define DEBUG_BASIC_BORDERS 0
 #define DEBUG_CHAIN_CURVES 0
 #define DEBUG_ANG_APPROX 0
@@ -63,11 +63,12 @@
 #define DEBUG_EDGES 0
 #define DEBUG_SHAPE_STM 0
 #define DEBUG_HOLES 0
+#define DEBUG_SMOOTH_CURVATURE 0
 #if DEBUG_BASIC_BORDERS || DEBUG_CHAIN_CURVES || DEBUG_ANG_APPROX || DEBUG_BEZIER_INTERP || \
    DEBUG_FACE_SEARCH || DEBUG_FACE_SEARCH_TRIA_MODIF || DEBUG_BRK_POINTS || DEBUG_BRK_THICK || \
    DEBUG_BRK || DEBUG_BORDERS_BY_NORMALS || DEBUG_SYNC_POINTS || DEBUG_SYNC_INTERPOLATION || \
    DEBUG_BEZIER_RULED || DEBUG_CURVATURE || DEBUG_SIMPLE_PATCHES || DEBUG_SURF_PATCHES || \
-    DEBUG_RAW_EDGES || DEBUG_EDGES || DEBUG_SHAPE_STM || DEBUG_HOLES || DEBUG
+    DEBUG_RAW_EDGES || DEBUG_EDGES || DEBUG_SHAPE_STM || DEBUG_HOLES || DEBUG_SMOOTH_CURVATURE
   #include "CurveLine.h"
   #include "/EgtDev/Include/EGkGeoObjSave.h"
   #include "/EgtDev/Include/EgtPerfCounter.h"
@@ -284,6 +285,63 @@ GetPointSetByAngTol( const PolyLine& PL, double dAngTol, POLYLINEVECTOR& vPL)
   return true ;
 }

+////-----------------------------------------------------------------------------
+//// Funzione che approssima la curva di bordo per la costruzione della Bezier Ruled mediante
+//// Patches di curve di Bezier
+//static bool
+//ApproxBorder( ICurveComposite* pCrvCompo, double dLinTol, double dAngTol, double dAngTolSplit)
+//{
+//   // N.B.:in futuro bisognerebbe fare l'approssimazione direttamente con le bezier.
+//
+//  // Controllo dei parametri
+//   if ( pCrvCompo == nullptr  ||  ! pCrvCompo->IsValid())
+//      return false ;
+//
+//  // splitto la curva considerando la tolleranza angolare
+//   ICRVCOMPOPOVECTOR vCC ;
+//   SplitCurveCompoByAngTol( pCrvCompo, dAngTolSplit, vCC) ;
+//   #if DEBUG_BEZIER_INTERP
+//      VT.clear() ;
+//      for( int i = 0 ; i < ssize(vCC) ; ++i)
+//         VT.push_back( vCC[i]->Clone()) ;
+//      SaveGeoObj( VT, "D:\\Temp\\trimming\\AngBorderApprox.nge") ;
+//      VT.clear() ;
+//   #endif
+//
+//   pCrvCompo->Clear() ;
+//   
+//  // Ogni PolyLine ricavata viene approssimata con un tratto di Bezier
+//   const double MAXLEN = 1.5 ;
+//   for ( ICurveComposite* pCC : vCC) {
+//     // Se meno di due curve, non la considero ( non dovrebbe mai capitare )
+//      if ( pCC->GetCurveCount() < 2)
+//         continue ;
+//      PolyArc PA ;
+//      if ( ! pCC->ApproxWithArcs( dLinTol, dAngTol, PA))
+//         return false ;
+//      CurveComposite CrvTemp ;
+//      if ( ! CrvTemp.FromPolyArc( PA)  ||  ! CrvTemp.MergeCurves( dLinTol, dAngTol))
+//         return false ;
+//      #if DEBUG_BEZIER_INTERP
+//         VT.emplace_back( CrvTemp->Clone()) ;
+//      #endif
+//     // Converto in Bezier
+//      PtrOwner<ICurve> pCrvBz( CurveToBezierCurve( &CrvTemp)) ;
+//      if ( IsNull( pCrvBz)  ||  ! pCrvBz->IsValid()) {
+//         LOG_ERROR( GetEGkLogger(), "Error : converrting curve to bezier") ;
+//         return false ;
+//      }
+//     // Aggiungo il tratto approssimato alla curva finale complessiva
+//      if ( ! pCrvCompo->AddCurve( Release( pCrvBz)))
+//         return false ;
+//   }
+//   #if DEBUG_BEZIER_INTERP
+//      SaveGeoObj( VT, VC, "D:\\Temp\\trimming\\bezier_edge.nge") ;
+//   #endif
+//
+//   return ( pCrvCompo->IsValid()) ;
+//}
+
 //-----------------------------------------------------------------------------
 // Funzione che approssima la curva di bordo per la costruzione della Bezier Ruled mediante
 // Patches di curve di Bezier
@@ -3838,8 +3896,8 @@ GetTrimmingSurfBzSyncPoints( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
        ! pCompoEdge1->IsValid()  ||  ! pCompoEdge2->IsValid())
      return false ;

-  // Controllo sulla tolleranza lineare
-   double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
+  //// Controllo sulla tolleranza lineare
+   //double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;

   #if DEBUG_SYNC_POINTS
      VT.clear() ; VC.clear() ;
@@ -3850,26 +3908,26 @@ GetTrimmingSurfBzSyncPoints( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
   #endif

  // Definisco la superficie di Bezier rigata
-   PtrOwner<SurfBezier> pSBzRuled( GetBasicSurfBezier( GetSurfBezierRuled( pCompoEdge1, pCompoEdge2, ISurfBezier::RLT_B_MINDIST_PLUS, dMyLinTol))) ;
+   PtrOwner<SurfBezier> pSBzRuled( GetBasicSurfBezier( GetSurfBezierRuledSmooth( pCompoEdge1, pCompoEdge2, vSyncPoints, 20.0))) ;
   if ( IsNull( pSBzRuled)  ||  ! pSBzRuled->IsValid())
      return false ;

-  // Recupero i punti di sincronizzazione e li restituisco
-   ICURVEPOVECTOR vCrv ;
-   pSBzRuled->GetAllPatchesIsocurves( false, vCrv) ;
-   vSyncPoints.reserve( vCrv.size()) ;
-   for ( int i = 0 ; i < ssize( vCrv) ; ++ i) {
-      if ( ! IsNull( vCrv[i])  &&  vCrv[i]->IsValid()) {
-         #if DEBUG_SYNC_POINTS
-            VT.emplace_back( vCrv[i]->Clone()) ;
-            VC.emplace_back( LIME) ;
-         #endif
-         Point3d ptStart ; vCrv[i]->GetStartPoint( ptStart) ;
-         Point3d ptEnd ; vCrv[i]->GetEndPoint( ptEnd) ;
-         if ( ! AreSamePointApprox( ptStart, ptEnd))
-            vSyncPoints.emplace_back( make_pair( ptStart, ptEnd)) ;
-      }
-   }
+  //// Recupero i punti di sincronizzazione e li restituisco
+  // ICURVEPOVECTOR vCrv ;
+  // pSBzRuled->GetAllPatchesIsocurves( false, vCrv) ;
+  // vSyncPoints.reserve( vCrv.size()) ;
+  // for ( int i = 0 ; i < ssize( vCrv) ; ++ i) {
+  //    if ( ! IsNull( vCrv[i])  &&  vCrv[i]->IsValid()) {
+  //       #if DEBUG_SYNC_POINTS
+  //          VT.emplace_back( vCrv[i]->Clone()) ;
+  //          VC.emplace_back( LIME) ;
+  //       #endif
+  //       Point3d ptStart ; vCrv[i]->GetStartPoint( ptStart) ;
+  //       Point3d ptEnd ; vCrv[i]->GetEndPoint( ptEnd) ;
+  //       if ( ! AreSamePointApprox( ptStart, ptEnd))
+  //          vSyncPoints.emplace_back( make_pair( ptStart, ptEnd)) ;
+  //    }
+  // }

   #if DEBUG_SYNC_POINTS
      SaveGeoObj( VT, VC, "C:\\Temp\\BorderSyncPoints.nge") ;
@@ -3900,7 +3958,7 @@ GetTrimmingSyncInterpolation( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,

  // Verifico i valori delle tolleranze
   double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
-   double dMyAngTol = Clamp( dAngTol, EPS_ANG_SMALL, 60.) ;
+   //double dMyAngTol = Clamp( dAngTol, EPS_ANG_SMALL, 60.) ;

  // Verifico le due curve di sincronizzazione abbiano gli estremi sulle due curve di bordo
   Point3d ptS1 ; pSync1->GetStartPoint( ptS1) ;
@@ -4110,7 +4168,8 @@ GetTrimmingRuledBezier( const CISURFPVECTOR& vSurf, const ICurve* pCrvEdge1,

  // Se non ho punti di controllo forzati
   if ( vSyncPoints.empty()) {
-      pSurfBz.Set( GetSurfBezierRuled( pCompoEdge1, pCompoEdge2, ISurfBezier::RLT_B_MINDIST_PLUS, dMyLinTol)) ;
+      BIPNTVECTOR vSyncLines ;
+      pSurfBz.Set( GetSurfBezierRuledSmooth( pCompoEdge1, pCompoEdge2, vSyncLines, 20.0)) ;
      if ( IsNull( pSurfBz)  ||  ! pSurfBz->IsValid()) {
         LOG_ERROR( GetEGkLogger(), "Error in Trimming : Ruled Bezier invalid") ;
         return nullptr ;
@@ -4746,7 +4805,7 @@ GetTrimmingHoleBorders( const CISURFPVECTOR& vpSurf, const Point3d& ptRef, doubl
     // Scorro le curve successive
      for ( int j = i + 1 ; nIndJ == -1 && j < ssize( vHoles) ; ++ j) {
        // Recupero la curva corrente, se non presente allora passo alla successiva
-         if ( IsNull( vHoles[i].pCompoHole))
+         if ( IsNull( vHoles[j].pCompoHole))
            continue ;
        // Se il tipo è differente non possono essere in coppia
         if ( vHoles[i].nType != vHoles[j].nType)
@@ -4841,3 +4900,499 @@ GetTrimmingHoleBorders( const CISURFPVECTOR& vpSurf, const Point3d& ptRef, doubl

   return true ;
 }
+
+
+struct PntInfo{
+   Point3d pt ;
+   double dDist ;
+   Vector3d vtPos ;
+   PntInfo( const Point3d& _pt, double _dDist, const Vector3d& _vtPos) :
+          pt( _pt), dDist( _dDist), vtPos( _vtPos) {;}
+};
+typedef vector<PntInfo> PNTINFOVECTOR ;
+
+//------------------------------------------------------------------------------
+static bool
+FillPntInfo( const PNTVECTOR& vPnt, const ICurveComposite* pCC, PNTINFOVECTOR& vPntInfo)
+{
+   for ( int i = 0 ; i < ssize( vPnt) - 3 ; i+=3) {
+      bool bOk = false ;
+      const ICurveBezier* pSubCrv = GetCurveBezier( pCC->GetCurve( i / 3)) ;
+      for ( int j = i == 0 ? 0 : 1 ; j <= 3 ; ++j) {
+         Point3d pt = pSubCrv->GetControlPoint( j, &bOk) ;
+         double dDist = 0 ;
+         Vector3d vtPos = V_NULL ;
+         if ( j > 0 && j < 3){
+            DistPointCurve dpc( pt, *pSubCrv) ;
+            dpc.GetDist( dDist) ;
+            int nFlag = - 1 ;
+            Point3d ptMinDist ;
+            dpc.GetMinDistPoint( 0., ptMinDist, nFlag) ;
+            vtPos = pt - ptMinDist ;
+         }
+         vPntInfo.emplace_back( pt, dDist, vtPos) ;
+      }
+   }
+   return true ;
+}
+
+//------------------------------------------------------------------------------
+static bool
+RemoveInflexionPoints( PNTVECTOR& vPnt, PNTINFOVECTOR& vPntInfo, PNTINFOVECTOR& vPntRefInfo)
+{
+   // se trovo tre punti di fila che sono dallo stesso lato, opposto a quello degli altri punti attorno, allora cerco di spostarli lungo la
+   // normale alla superficie in modo da evitare cambi di concavità
+   bool bSameSideAsPrev = true ;
+   double dSmallDist = 5 * EPS_SMALL ;
+   for ( int i = 2 ; i < ssize( vPntInfo) - 2 ; ++i) {
+      // se è un punto di split o sta sulla curva vado avanti
+      if ( vPntInfo[i].dDist < dSmallDist)
+         continue ;
+      int nPrev = vPntInfo[i-1].dDist < EPS_ZERO ? i - 2 : i - 1 ;
+      double dProj = vPntInfo[i].vtPos * vPntInfo[nPrev].vtPos ;
+      bSameSideAsPrev = dProj > EPS_ZERO ;
+      if ( abs(dProj) < EPS_ZERO){
+         int nPrevPrev = nPrev - 1 ;
+         dProj = vPntInfo[i].vtPos * vPntInfo[nPrevPrev].vtPos ;
+         bSameSideAsPrev = dProj > EPS_ZERO ;
+      }
+      if ( ! bSameSideAsPrev) {
+         // devo verificare anche che sia diverso anche dal successivo ( o dal quello dopo ancora, se il successivo sta sulla curva)
+         bool bCurrOrPrev = vPntInfo[i+1].dDist < EPS_ZERO ;
+         int nFirst, nSecond, nThird ;
+         if ( bCurrOrPrev) {
+            nFirst = i ;
+            nSecond = i + 1 ;
+            nThird = i + 2 ;
+         }
+         else {
+            nFirst = i - 2 ;
+            nSecond = i - 1 ;
+            nThird = i ;
+         }
+         int nNext = bCurrOrPrev ? i + 2 : i + 1 ;
+         // se il successivo è diverso ho un terzetto anomalo da aggiustare
+         // altrimenti ho un cambio naturale di concavità
+         if ( vPntInfo[i].vtPos * vPntInfo[nNext].vtPos < 0  ||  vPntInfo[nNext].dDist < dSmallDist) {
+            // ruoto il terzetto fino a matchare la tangente sull'altra curva
+            // ruoto il punto solo se non stava già esattamente sulla SubCrv ( che suppongo essere un tratto rettilineo)
+            if ( vPntInfo[nFirst].dDist > dSmallDist) {
+               Vector3d vtCurr = vPntInfo[nSecond].pt - vPntInfo[nFirst].pt ;
+               Vector3d vtRef = vPntRefInfo[nSecond].pt - vPntRefInfo[nFirst].pt ;
+               Vector3d vtAx = vPntRefInfo[nSecond].pt - vPntInfo[nSecond].pt ;
+               bool bDet = false ;
+               double dAng = 0 ; vtCurr.GetRotation(vtRef, vtAx, dAng, bDet) ;
+               if ( abs(dAng) > 170)
+                  dAng = 180 - dAng ;
+               vPnt[nFirst].Rotate( vPnt[nSecond], vtAx, dAng) ;
+            }
+            if ( vPntInfo[nThird].dDist > dSmallDist) {
+               Vector3d vtCurr = vPntInfo[nThird].pt - vPntInfo[nSecond].pt ;
+               Vector3d vtRef = vPntRefInfo[nThird].pt - vPntRefInfo[nSecond].pt ;
+               Vector3d vtAx = vPntRefInfo[nSecond].pt - vPntInfo[nSecond].pt ;
+               bool bDet = false ;
+               double dAng = 0 ; vtCurr.GetRotation(vtRef, vtAx, dAng, bDet) ;
+               if ( abs(dAng) > 170)
+                  dAng = 180 - dAng ;
+               vPnt[nThird].Rotate( vPnt[nSecond], vtAx, dAng) ;
+            }
+            if ( bCurrOrPrev)
+               i += 2 ;
+         }
+      }
+   }
+
+   return true ;
+}
+
+// Funzione per la regolarizzazione delle curve di bordo di una lavorazione di trim
+// Le curve vengono modificate entro una data tolleranza, in modo che 
+ISurfBezier*
+RegolarizeBordersLocallyRMF( const ISurfBezier* pSurfBz, const BIPOINT& bpIsoStart, const BIPOINT& bpIsoEnd, double dTol)
+{
+#if DEBUG_SMOOTH_CURVATURE
+   VT.clear() ;
+#endif
+
+   // prendo per buone le isocurve di inizio e fine tratto e devo identificare tra loro le isocurve che creano troppo twist e che sono da raddrizzare
+   Point3d ptS1 = bpIsoStart.first ;
+   Point3d ptS2 = bpIsoEnd.first ;
+   Vector3d vtDir1 = bpIsoStart.second - ptS1 ;
+   Vector3d vtDir2 = bpIsoEnd.second - ptS2 ;
+
+   int nDegU, nDegV, nSpanU, nSpanV ;
+   bool bRat, bTrimmed ;
+   pSurfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
+   if ( nDegU != 3)
+      return nullptr ;
+   // individuo quali isocurve sono state indicate come inizio e fine
+   PtrOwner<ICurveComposite> pCrv1( pSurfBz->GetSingleEdge3D( false, 2)) ;
+   PtrOwner<ICurveComposite> pCrv2( pSurfBz->GetSingleEdge3D( false, 0)) ;
+   // inverto la curva corrispondente al bordo 2 della bezier per avere le due guide concordi
+   pCrv2->Invert() ;
+   double dParS1 = -1 ; double dParS2 = -1 ; 
+   if ( ! pCrv1->GetParamAtPoint( ptS1, dParS1) ||  ! pCrv1->GetParamAtPoint( ptS2, dParS2))
+      return nullptr ;
+   int nUS1 = int ( dParS1) * nDegU ;
+   int nUS2 = int ( dParS2) * nDegU ;
+   if ( nUS1 > nUS2) {
+      swap( nUS1, nUS2) ;
+      swap( dParS1, dParS2) ;
+      swap( ptS1, ptS2) ;
+      swap( vtDir1, vtDir2) ;
+   }
+   PtrOwner<ICurveComposite> pCrvOrig1( ConvertCurveToComposite( pCrv1->CopyParamRange( dParS1, dParS2))) ;
+   PtrOwner<ICurveComposite> pCrvOrig2( ConvertCurveToComposite( pCrv2->CopyParamRange( dParS1, dParS2))) ;
+
+   /////////////////////// versione con RMF
+   // campiono finemente la prima curva e ottengo il punto che dovrebbe stare sull'altra curva
+   Vector3d vtTang1 ; pCrvOrig1->GetStartDir( vtTang1) ;
+   Frame3d frStart1 ; frStart1.Set( ptS1, vtTang1, vtDir1) ;  // uso la tangente (come z) e l'isocurva in V (come x) per il frame iniziale
+   RotationMinimizingFrame rmf ; rmf.Set( pCrvOrig1, frStart1) ;
+   double dLenTot = 0. ; pCrvOrig1->GetLength( dLenTot) ;
+   double dStep = dLenTot / ceil( dLenTot) ;
+   FRAME3DVECTOR vRMF ;
+   rmf.GetFramesByStep( dStep, true, vRMF) ;
+   PNTVECTOR vPnt1 ;
+   PolyLine PL2 ;
+   double dLenCurr = 0. ;
+   double dWidth = vtDir1.Len() ;
+   for ( int i = 0 ; i < ssize( vRMF) ; ++i) {
+      double dPar ; pCrvOrig1->GetParamAtLength( dLenCurr, dPar) ;
+      Point3d pt0 ; pCrvOrig1->GetPointD1D2( dPar, ICurve::FROM_MINUS, pt0) ;
+      Point3d pt1 = pt0 + vRMF[i].VersX() * dWidth ;
+      vPnt1.push_back( pt1) ;
+      PL2.AddUPoint( i, pt1) ;
+
+      dLenCurr += dStep ;
+   }
+
+   CurveComposite CCToApprox2 ; CCToApprox2.FromPolyLine( PL2) ;
+   Vector3d vtStart2 ; pCrvOrig2->GetStartDir( vtStart2) ;
+   Vector3d vtEnd2 ; pCrvOrig2->GetEndDir( vtEnd2) ;
+   PtrOwner<ICurveComposite> pCC2( ConvertCurveToComposite( ApproxCurveWithBezier( &CCToApprox2, 0.05, vtStart2, vtEnd2))) ;
+   if ( IsNull( pCC2)  ||  ! pCC2->IsValid())
+      return nullptr ;
+
+   // dalla seconda ricostruisco la prima
+   Vector3d vtTang2 ; pCC2->GetStartDir( vtTang2) ;
+   Frame3d frStart2 ; frStart2.Set( bpIsoStart.second, vtTang2, vtDir1) ;  // uso la tangente (come z) e l'isocurva in V (come x) per il frame iniziale
+   RotationMinimizingFrame rmf2 ; rmf2.Set( pCC2, frStart2) ;
+   double dLenTot2 = 0. ; pCC2->GetLength( dLenTot2) ;
+   double dStep2 = dLenTot2 / ceil( dLenTot2) ;
+   FRAME3DVECTOR vRMF2 ;
+   rmf2.GetFramesByStep( dStep2, true, vRMF2) ;
+   PNTVECTOR vPnt0 ;
+   PolyLine PL1 ;
+   double dLenCurr2 = 0. ;
+   for ( int i = 0 ; i < ssize( vRMF2) ; ++i) {
+      double dPar ; pCC2->GetParamAtLength( dLenCurr2, dPar) ;
+      Point3d pt1 ; pCC2->GetPointD1D2( dPar, ICurve::FROM_MINUS, pt1) ;
+      Point3d pt0 = pt1 - vRMF2[i].VersX() * dWidth ;
+      vPnt0.push_back( pt0) ;
+      PL1.AddUPoint( i, pt0) ;
+
+      dLenCurr2 += dStep2 ;
+   }
+
+   CurveComposite CCToApprox1 ; CCToApprox1.FromPolyLine( PL1) ;
+   Vector3d vtStart1 ; pCrvOrig1->GetStartDir( vtStart1) ;
+   Vector3d vtEnd1 ; pCrvOrig1->GetEndDir( vtEnd1) ;
+   PtrOwner<ICurveComposite> pCC1( ConvertCurveToComposite( ApproxCurveWithBezier( &CCToApprox1, 0.05, vtStart1, vtEnd1))) ;
+   if ( IsNull( pCC1)  ||  ! pCC1->IsValid())
+      return nullptr ;
+
+#if DEBUG_SMOOTH_CURVATURE
+   for( int i = 0 ; i < ssize( vPnt1) ; ++i) {
+      PtrOwner<IGeoPoint3d> pPT( CreateGeoPoint3d()) ; pPT->Set( vPnt1[i]) ;
+      VT.push_back( Release( pPT)) ;
+   }
+   for( int i = 0 ; i < ssize( vPnt0) ; ++i) {
+      PtrOwner<IGeoPoint3d> pPT( CreateGeoPoint3d()) ; pPT->Set( vPnt0[i]) ;
+      VT.push_back( Release( pPT)) ;
+   }
+   VT.push_back( pCC1->Clone()) ;
+   VT.push_back( pCC2->Clone()) ;
+   SaveGeoObj( VT, "C:\\Temp\\bezier\\ruled\\smoothness\\regolarized_RMF.nge") ;
+#endif
+
+   // controllo di essere rimasto in tolleranza
+   double dErr = 0 ;
+   CalcApproxError( pCrvOrig1, pCC1, dErr, 20) ;
+   if ( dErr > dTol)
+      return nullptr ;
+   dErr = 0 ;
+   CalcApproxError( pCrvOrig2, pCC2, dErr, 20) ;
+   if ( dErr > dTol)
+      return nullptr ;
+
+   // creo una surf di bezier uguale a quella di partenza, ma a cui cambio la parte da modificare
+   PtrOwner<SurfBezier> pNewSurf( CreateBasicSurfBezier()) ;
+   int nNewCrvs = pCC1->GetCurveCount() ;
+   if ( pCC2->GetCurveCount() != nNewCrvs)
+      return nullptr ;
+   int nDiff = nNewCrvs - pCrvOrig1->GetCurveCount() ;
+   pNewSurf->Init( nDegU, nDegV, nSpanU, nSpanV, bRat) ;
+   // copio la parte uguale
+   for ( int i = 0 ; i < nSpanU * nDegU + 1 ; ++i) {
+      if ( i > nUS1 && i < nUS2)
+         continue ;
+      bool bOk = false ;
+      Point3d pt = pSurfBz->GetControlPoint( i, 0, &bOk) ;
+      int nNewI = i ;
+      if ( i > nUS2)
+         nNewI = i + nDiff ;
+      pNewSurf->SetControlPoint( nNewI, 0, pt) ;
+      pt = pSurfBz->GetControlPoint( i, 1, &bOk) ;
+      pNewSurf->SetControlPoint( nNewI, 1, pt) ;
+   }
+   // aggiungo la parte diversa
+   for ( int i = 0 ; i < nNewCrvs * nDegU + 1 ; ++i) {
+      int nSub = i / 3 ;
+      int nPnt = i % 3 ;
+      if ( nSub == nNewCrvs) {
+         --nSub ;
+         nPnt = 3 ;
+      }
+      const ICurveBezier* pSubCrv1 = GetCurveBezier( pCC1->GetCurve( nSub)) ;
+      Point3d pt = pSubCrv1->GetControlPoint( nPnt) ;
+      int nNewI = i + nUS1 ;
+      pNewSurf->SetControlPoint( nNewI, 0, pt) ;
+      const ICurveBezier* pSubCrv2 = GetCurveBezier( pCC2->GetCurve( nSub)) ;
+      pt = pSubCrv2->GetControlPoint( nPnt) ;
+      pNewSurf->SetControlPoint( nNewI, 1, pt) ;
+   }
+
+   return Release( pNewSurf) ;
+}
+
+//------------------------------------------------------------------------------
+// Funzione per la regolarizzazione delle curve di bordo di una lavorazione di trim
+// Le curve vengono modificate entro una data tolleranza, in modo che 
+ISurfBezier*
+RegolarizeBordersLocally( const ISurfBezier* pSurfBz, const BIPOINT& bpIsoStart, const BIPOINT& bpIsoEnd, double dTol, int nType)
+{
+   if ( nType == RegolarizeType::RMF)
+      return RegolarizeBordersLocallyRMF( pSurfBz, bpIsoStart, bpIsoEnd, dTol) ;
+
+   #if DEBUG_SMOOTH_CURVATURE
+      VT.clear() ;
+   #endif
+
+   // prendo per buone le isocurve di inizio e fine tratto e devo identificare tra loro le isocurve che creano troppo twist e che sono da raddrizzare
+   Point3d ptS1 = bpIsoStart.first ;
+   Point3d ptS2 = bpIsoEnd.first ;
+   Vector3d vtDir1 = bpIsoStart.second - ptS1 ;
+   Vector3d vtDir2 = bpIsoEnd.second - ptS2 ;
+   //double dInterpolateAngTol = 4 ;
+   //double dAngInterp = 0 ;
+   //vtDir1.GetAngle( vtDir2, dAngInterp) ;
+   //bool bInterpolate = dAngInterp > dInterpolateAngTol ;
+
+   int nDegU, nDegV, nSpanU, nSpanV ;
+   bool bRat, bTrimmed ;
+   pSurfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
+   if ( nDegU != 3)
+      return nullptr ;
+   // individuo quali isocurve sono state indicate come inizio e fine
+   PtrOwner<ICurveComposite> pCrv1( pSurfBz->GetSingleEdge3D( false, 2)) ;
+   PtrOwner<ICurveComposite> pCrv2( pSurfBz->GetSingleEdge3D( false, 0)) ;
+   // inverto la curva corrispondente al bordo 2 della bezier per avere le due guide concordi
+   pCrv2->Invert() ;
+   double dParS1 = -1 ; double dParS2 = -1 ; 
+   if ( ! pCrv1->GetParamAtPoint( ptS1, dParS1) ||  ! pCrv1->GetParamAtPoint( ptS2, dParS2))
+      return nullptr ;
+   int nUS1 = int ( dParS1) * nDegU ;
+   int nUS2 = int ( dParS2) * nDegU ;
+   bool bInverted = false ;
+   if ( nUS1 > nUS2) {
+      swap( nUS1, nUS2) ;
+      swap( dParS1, dParS2) ;
+      swap( ptS1, ptS2) ;
+      swap( vtDir1, vtDir2) ;
+      bInverted = true ;
+   }
+   PtrOwner<ICurve> pCrvOrig1( pCrv1->CopyParamRange( dParS1, dParS2)) ;
+   PtrOwner<ICurve> pCrvOrig2( pCrv2->CopyParamRange( dParS1, dParS2)) ;
+   double dLen = 0 ; pCrvOrig1->GetLength( dLen) ;
+
+   ///// versione con correzioni a mano
+   Point3d ptPrevS = ptS1 ;
+   Point3d ptPrevE = ! bInverted ? bpIsoStart.second : bpIsoEnd.second ;
+   Vector3d vtIsoPrev = ptPrevE - ptPrevS ; vtIsoPrev.Normalize() ;
+   Point3d ptBez ; Vector3d vtNCurr ;
+   pSurfBz->GetPointNrmD1D2( dParS1, 0.5, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBez, vtNCurr) ;
+   int nPoints = ( nUS2 - nUS1) * nDegU + 1 ;
+   PNTVECTOR vPnt0 ; vPnt0.reserve( nPoints) ; vPnt0.push_back( ptPrevS) ;
+   PNTVECTOR vPnt1 ; vPnt1.reserve( nPoints) ; vPnt1.push_back( ptPrevE) ;
+   // salvo il secondo punto di controllo della patch
+   bool bOk = false ;
+   Point3d ptSecond1Curr = pSurfBz->GetControlPoint( nUS1 + 1, 0, &bOk) ;
+   vPnt0.push_back( ptSecond1Curr) ;
+   Point3d ptSecond2Curr = pSurfBz->GetControlPoint( nUS1 + 1, 1, &bOk) ;
+   vPnt1.push_back( ptSecond2Curr) ;
+   // scorro le isocurve di separazione tra patch
+   for ( int i = nUS1 + 3 ; i < nUS2 ; i +=3) {
+      // recupero precedente e successivo
+      Point3d ptThird1Prev = pSurfBz->GetControlPoint( i - 1, 0, &bOk) ;
+      Point3d ptThird2Prev = pSurfBz->GetControlPoint( i - 1, 1, &bOk) ;
+      Point3d ptSecond1Next = pSurfBz->GetControlPoint( i + 1, 0, &bOk) ;
+      Point3d ptSecond2Next = pSurfBz->GetControlPoint( i + 1, 1, &bOk) ;
+      // recupero corrente e verifico la torsione
+      Point3d ptCurr1 = pSurfBz->GetControlPoint( i, 0, &bOk) ;
+      Point3d ptCurr2 = pSurfBz->GetControlPoint( i, 1, &bOk) ;
+      Vector3d vtIsoCurr = ptCurr2 - ptCurr1 ;
+      double dDist = vtIsoCurr.Len() ;
+      vtIsoCurr.Normalize() ;
+      //Vector3d vtDirPrev = vtIsoPrev ^ vtNPrev ;
+      Vector3d vtDirCurr = ptSecond1Next - ptCurr1 ; vtDirCurr.Normalize() ;
+      double dLenCurr = 0 ; pCrvOrig1->GetLengthAtParam( i, dLenCurr) ;
+      double dCoeff = dLenCurr / dLen ;
+      Vector3d vtIsoInterp = Media( vtDir1, vtDir2, dCoeff) ; vtIsoInterp.Normalize() ;
+      bool bDet = false ;
+      //double dAng = 0 ; vtIsoCurr.GetRotation( vtIsoPrev, vtDirPrev, dAng, bDet) ;
+      double dAng = 0 ; vtIsoCurr.GetRotation( vtIsoInterp, vtDirCurr, dAng, bDet) ;
+      vtNCurr = vtDirCurr ^ vtIsoCurr ; vtNCurr.Rotate( vtDirCurr, dAng) ;
+      double dSinAngTol = sin( 5 * DEGTORAD) ;
+      Vector3d vtPrev1 = ptCurr1 - ptThird1Prev ; vtPrev1.Normalize() ;
+      Vector3d vtNext1 = ptSecond1Next - ptCurr1 ; vtNext1.Normalize() ;
+      bool bAngularPoint1 = ! AreSameVectorEpsilon( vtPrev1, vtNext1, dSinAngTol) ;
+      Vector3d vtPrev2 = ptCurr2 - ptThird2Prev ; vtPrev2.Normalize() ;
+      Vector3d vtNext2 = ptSecond2Next - ptCurr2 ; vtNext2.Normalize() ;
+      bool bAngularPoint2 = ! AreSameVectorEpsilon( vtPrev2, vtNext2, dSinAngTol) ;
+      if ( abs( dAng) > 0) {
+         // se l'isocurva di separazione dalla patch successiva è torta rispetto alla precedente
+         // allora prendo il penultimo punto della curva precedente, il punto di joint e il secondo della prossima e li sposto lungo la normale della superficie
+         dDist *= dAng * DEGTORAD / 2 ;
+         if ( ! bAngularPoint1) {
+            // se non ho un punto angoloso muovo tutto il terzetto insieme
+            ptThird1Prev -= vtNCurr * dDist ;
+            ptSecond1Next -= vtNCurr * dDist ;
+            ptCurr1 -= vtNCurr * dDist ;
+         }
+         else {
+            // altrimenti sposto solo il punto corrente verso la congiungente tra il precedente e il successivo
+            DistPointLine dpl( ptCurr1, ptThird1Prev, ptSecond1Next, true) ;
+            Point3d ptMinDist ; dpl.GetMinDistPoint( ptMinDist) ;
+            Vector3d vtCorrDir = ptMinDist - ptCurr1 ; vtCorrDir.Normalize() ;
+            double dProjDir = vtNCurr * vtCorrDir ;
+            if ( dProjDir < 0)
+               LOG_ERROR( GetEGkLogger(), "Error : regolarizing crv0 near an angular point") ;
+            double dDistCorr = min( dDist, Dist( ptMinDist, ptCurr1)) ;
+            ptCurr1 -= vtCorrDir * dDistCorr ;
+         }
+         if ( ! bAngularPoint2) {
+            ptThird2Prev += vtNCurr * dDist ;
+            ptSecond2Next += vtNCurr * dDist ;
+            ptCurr2 += vtNCurr * dDist ;
+         }
+         else {
+            // altrimenti sposto solo il punto corrente verso la congiungente tra il precedente e il successivo
+            DistPointLine dpl( ptCurr2, ptThird2Prev, ptSecond2Next, true) ;
+            Point3d ptMinDist ; dpl.GetMinDistPoint( ptMinDist) ;
+            Vector3d vtCorrDir = ptMinDist - ptCurr2 ; vtCorrDir.Normalize() ;
+            double dProjDir = vtNCurr * vtCorrDir ;
+            if ( dProjDir < 0)
+               LOG_ERROR( GetEGkLogger(), "Error : regolarizing crv1 near an angular point") ;
+            double dDistCorr = min( dDist, Dist( ptMinDist, ptCurr2)) ;
+            ptCurr2 += vtCorrDir * dDistCorr ;
+         }
+      }
+      vPnt0.push_back( ptThird1Prev) ;
+      vPnt0.push_back( ptCurr1) ;
+      vPnt0.push_back( ptSecond1Next) ;
+
+      vPnt1.push_back( ptThird2Prev) ;
+      vPnt1.push_back( ptCurr2) ;
+      vPnt1.push_back( ptSecond2Next) ;
+
+      //vtIsoPrev = ptCurr2 - ptCurr1 ; vtIsoPrev.Normalize() ;
+      //vtNPrev = ( ptSecond1Next - ptCurr1) ^ vtIsoPrev ; vtNPrev.Normalize() ;
+   }
+   // aggiungo gli ultimi due punti
+   Point3d ptThird1Prev = pSurfBz->GetControlPoint( nUS2 - 1, 0, &bOk) ;
+   vPnt0.push_back( ptThird1Prev) ;
+   Point3d ptFourth1Curr = pSurfBz->GetControlPoint( nUS2, 0, &bOk) ;
+   vPnt0.push_back( ptFourth1Curr) ;
+   Point3d ptThird2Prev = pSurfBz->GetControlPoint( nUS2 - 1, 1, &bOk) ;
+   vPnt1.push_back( ptThird2Prev) ;
+   Point3d ptFourth2Curr = pSurfBz->GetControlPoint( nUS2, 1, &bOk) ;
+   vPnt1.push_back( ptFourth2Curr) ;
+
+   PtrOwner<ICurveComposite> pCC1( CreateCurveComposite()) ;
+   PtrOwner<ICurveComposite> pCC2( CreateCurveComposite()) ;
+   for ( int i = 0 ; i < ssize( vPnt0) - 3 ; i+=3) {
+      PtrOwner<ICurveBezier> cb1( CreateCurveBezier()) ; cb1->Init( 3, false) ;
+      cb1->SetControlPoint( 0, vPnt0[i]) ;
+      cb1->SetControlPoint( 1, vPnt0[i+1]) ;
+      cb1->SetControlPoint( 2, vPnt0[i+2]) ;
+      cb1->SetControlPoint( 3, vPnt0[i+3]) ;
+      pCC1->AddCurve( Release( cb1)) ;
+
+      PtrOwner<ICurveBezier> cb2( CreateCurveBezier()) ; cb2->Init( 3, false) ;
+      cb2->SetControlPoint( 0, vPnt1[i]) ;
+      cb2->SetControlPoint( 1, vPnt1[i+1]) ;
+      cb2->SetControlPoint( 2, vPnt1[i+2]) ;
+      cb2->SetControlPoint( 3, vPnt1[i+3]) ;
+      pCC2->AddCurve( Release( cb2)) ;
+   }
+
+   ////// N.B.:dovrei tener conto anche della patch PRECEDENTE e SUCCESSIVA a quelle indicate, altrimenti non vedo se ho creato flessi al bordo della zona
+#if DEBUG_SMOOTH_CURVATURE
+   VT.push_back( pCC1->Clone()) ;
+   VT.push_back( pCC2->Clone()) ;
+   SaveGeoObj( VT, "C:\\Temp\\bezier\\ruled\\smoothness\\regolarized_first_step.nge") ;
+#endif
+
+   // ora verifico l'eventuale presenza di cambi di concavità non desiderati
+   // se ne trovo su una curva e non sull'altra allora ruoto il terzetto di punti della curva con flesso in modo
+   // da matchare la tangente dell'altra curva
+   PNTINFOVECTOR vPntInfo1, vPntInfo2 ;
+   FillPntInfo( vPnt0, pCC1, vPntInfo1) ;
+   FillPntInfo( vPnt1, pCC2, vPntInfo2) ;
+
+   RemoveInflexionPoints( vPnt0, vPntInfo1, vPntInfo2) ;
+   RemoveInflexionPoints( vPnt1, vPntInfo2, vPntInfo1) ;
+
+   pCC1->Clear() ;
+   pCC2->Clear() ;
+   for ( int i = 0 ; i < ssize( vPnt0) - 3 ; i+=3) {
+      PtrOwner<ICurveBezier> cb1( CreateCurveBezier()) ; cb1->Init( 3, false) ;
+      cb1->SetControlPoint( 0, vPnt0[i]) ;
+      cb1->SetControlPoint( 1, vPnt0[i+1]) ;
+      cb1->SetControlPoint( 2, vPnt0[i+2]) ;
+      cb1->SetControlPoint( 3, vPnt0[i+3]) ;
+      pCC1->AddCurve( Release( cb1)) ;
+
+      PtrOwner<ICurveBezier> cb2( CreateCurveBezier()) ; cb2->Init( 3, false) ;
+      cb2->SetControlPoint( 0, vPnt1[i]) ;
+      cb2->SetControlPoint( 1, vPnt1[i+1]) ;
+      cb2->SetControlPoint( 2, vPnt1[i+2]) ;
+      cb2->SetControlPoint( 3, vPnt1[i+3]) ;
+      pCC2->AddCurve( Release( cb2)) ;
+   }
+
+   // controllo di essere rimasto in tolleranza
+   double dErr = 0 ;
+   CalcApproxError( pCrvOrig1, pCC1, dErr, 20) ;
+   if ( dErr > dTol)
+      return nullptr ;
+   CalcApproxError( pCrvOrig2, pCC2, dErr, 20) ;
+   if ( dErr > dTol)
+      return nullptr ;
+
+   PtrOwner<ISurfBezier> pNewSurf( pSurfBz->Clone()) ;
+   // aggiorno i punti di controllo della superficie di bezier
+   for ( int i = 0 ; i < ssize( vPnt0) ; ++i) {
+      pNewSurf->SetControlPoint( nUS1 + i, 0, vPnt0[i]) ;
+      pNewSurf->SetControlPoint( nUS1 + i, 1, vPnt1[i]) ;
+   }
+   #if DEBUG_SMOOTH_CURVATURE
+      VT.clear() ;
+      VT.push_back( Release(pCC1)) ;
+      VT.push_back( Release(pCC2)) ;
+      SaveGeoObj( VT, "C:\\Temp\\bezier\\ruled\\smoothness\\regolarized.nge") ;
+   #endif
+
+   return Release( pNewSurf) ;
+}
@@ -1765,10 +1765,13 @@ 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) ;
@@ -1857,26 +1860,44 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
   }

   vector<PNTVECTOR> vvPtCtrl ;
-   // superficie laterale sinistra
-   CurveLine cLineLeftBottom ; cLineLeftBottom.Set( vPntTipEndFront.back(), vPntTipStartFront.back()) ;
-   if ( bInverse)
-      cLineLeftBottom.Invert() ;
-   PtrOwner<CurveBezier> cBezLeftBottom( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftBottom, nDegU, bRat))) ;
-   CurveLine cLineLeftTop ; cLineLeftTop.Set( vPntTopEndFront.back(), vPntTopStartFront.back()) ;
-   PtrOwner<CurveBezier> cBezLeftTop( GetBasicCurveBezier( LineToBezierCurve( &cLineLeftTop, nDegU, bRat))) ;
-   vvPtCtrl.emplace_back( cBezLeftBottom->GetAllControlPoints()) ;
-   PNTVECTOR vPntLeft = cBezLeftTop->GetAllControlPoints() ;
-   vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntLeft.begin(), vPntLeft.end()) ;
-   // superficie laterale destra
-   CurveLine cLineRightBottom ; cLineRightBottom.Set( vPntTipStartFront.front(), vPntTipEndFront.front()) ;
-   if ( bInverse)
-      cLineRightBottom.Invert() ;
-   PtrOwner<CurveBezier> cBezRightBottom( GetBasicCurveBezier( LineToBezierCurve( &cLineRightBottom, nDegU, bRat))) ;
-   CurveLine cLineRightTop ; cLineRightTop.Set( vPntTopStartFront.front(), vPntTopEndFront.front()) ;
-   PtrOwner<CurveBezier> cBezRightTop( GetBasicCurveBezier( LineToBezierCurve( &cLineRightTop, nDegU, bRat))) ;
-   vvPtCtrl.emplace_back( cBezRightBottom->GetAllControlPoints()) ;
-   PNTVECTOR vPntRight = cBezRightTop->GetAllControlPoints() ;
-   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() })) ;
@@ -2116,7 +2137,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
      vvPtCtrl.emplace_back( cBezTipEndF2->GetAllControlPoints()) ;
      PNTVECTOR vPntEndF2 = cBezTopEndF2->GetAllControlPoints() ;
      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntEndF2.begin(), vPntEndF2.end()) ;
-      if ( bInverse) {
+      if ( bInverse  ||  bSmallMovement) {
         // chiudo il volume con le superici verticali end back 1
         vvPtCtrl.emplace_back( cBezTipEndB1->GetAllControlPoints()) ;
         PNTVECTOR vPntEndB1 = cBezTopEndB1->GetAllControlPoints() ;
@@ -2135,7 +2156,7 @@ VolZmap::Comp_5AxisMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
      vvPtCtrl.emplace_back( cBezTipStartB2->GetAllControlPoints()) ;
      PNTVECTOR vPntStartB2 = cBezTopStartB2->GetAllControlPoints() ;
      vvPtCtrl.back().insert( vvPtCtrl.back().end(), vPntStartB2.begin(), vPntStartB2.end()) ;
-      if ( bInverse) {
+      if ( bInverse   ||  bSmallMovement) {
         // chiudo il volume con le superici verticali start front 1
         vvPtCtrl.emplace_back( cBezTipStartF1->GetAllControlPoints()) ;
         PNTVECTOR vPntStartF1 = cBezTopStartF1->GetAllControlPoints() ;
@@ -2215,7 +2236,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]) ;
@@ -1014,8 +1014,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
Author	SHA1	Message	Date
Dario Sassi	2dcaa57aa3	EgtGeomKernel : - modifiche a RMF per avere la tangente media sul punto di calcolo (utile solo se la curva non è G1) - modifiche a GetSurfTriMeshSwept per avere RMF anche con curve piane garantendo la retrocompatibilità.	2026-05-14 13:02:47 +02:00
Riccardo Elitropi	ba7379e752	EgtGeomKernel : - In CalcPocketing aggiunto flag per Conventional Milling.	2026-05-12 09:34:56 +02:00
Daniele Bariletti	6646aee01c	EgtGeomKernel : - estratta funzione per trovare il punto corrispondente sulla seconda curva di una coppia di curve da sincronizzare. - pulizia codice.	2026-05-08 17:25:32 +02:00
Riccardo Elitropi	7f8382f1b8	EgtGeomKernel : - In CalcPocketing correzione entrate per utensili grandi su contorni aperti piccoli.	2026-05-08 17:23:01 +02:00
Daniele Bariletti	4bcdb03598	EgtGeomKernel 3.1e2 : - piccola modifica - cambio versione.	2026-05-07 14:28:07 +02:00
Dario Sassi	68e9be7901	EgtGeomKernel 3.1e1 : - ricompilazione con cambio versione.	2026-05-07 12:23:08 +02:00
Daniele Bariletti	9e3bac4a68	Merge branch 'Trimming'	2026-05-07 11:18:56 +02:00
Daniele Bariletti	1fee7b8e49	Merge branch 'master' into Trimming	2026-05-07 11:18:09 +02:00
Daniele Bariletti	f668d7ac11	EgtGeomKernel : - cambiata distanza di campionamento in trimming.	2026-05-07 11:17:52 +02:00
Daniele Bariletti	4a1c13154f	EgtGeomKernel : - migliorie a regolarize.	2026-05-07 11:16:37 +02:00
Daniele Bariletti	68a9848748	EgtGeomKernel : - miglioramenti alla regolarize.	2026-05-06 12:51:20 +02:00
Daniele Bariletti	f5059166ed	Merge branch 'master' into Trimming	2026-05-05 14:32:25 +02:00
Daniele Bariletti	ad7f209fc9	EgtGeomKernel : - correzione all'autointersezione di curve.	2026-05-05 13:32:25 +02:00
Daniele Bariletti	8b5bfb6e19	EgtGeomKernel : - separazione delle due versioni di regolarize.	2026-05-05 09:11:27 +02:00
Daniele Bariletti	1efd17f6ee	EgtGeomKernel : - pulizia.	2026-04-29 11:23:15 +02:00
Daniele Bariletti	b8caeb49e0	EgtGeomKernel : - miglioria alla regolarize.	2026-04-29 11:17:57 +02:00
Daniele Bariletti	a9fc259745	Merge branch 'master' into Trimming	2026-04-28 12:08:24 +02:00
Daniele Bariletti	bbc98fe282	EgtGeomKernel : - cambiata la chiamata a ModifyJoint - cambiato nome alla ModifySingleCurve - estesa la ModifyJoint con tolleranza - modifiche stilistiche e pulizia codice.	2026-04-28 11:09:34 +02:00
Riccardo Elitropi	a445ddd89b	EgtGeomKernel : - in CalcPocketing aggiunto prototipo per riconoscimento di svuotatura di un foro.	2026-04-28 11:04:42 +02:00
Daniele Bariletti	e874b2eb36	Merge branch 'master' into Trimming	2026-04-27 16:01:59 +02:00
Daniele Bariletti	a45faa4793	EgtGeomKernel : - correzioni e migliorie a Regolarize.	2026-04-27 16:01:00 +02:00
Daniele Bariletti	344f0da7ff	EgtGeomKernel : - tolto flag di debug.	2026-04-27 15:06:27 +02:00
Daniele Bariletti	cea869c6ee	EgtGeomKernel : - correzione al commit precedente.	2026-04-27 15:05:45 +02:00
Daniele Bariletti	8ad2887c38	Merge branch 'master' into Trimming	2026-04-27 15:04:02 +02:00
Daniele Bariletti	2b1d2a512d	EgtGeomKernel : - rimosso flag di debug.	2026-04-27 15:03:49 +02:00
Daniele Bariletti	a55770d702	EgtGeomKernel : - migliorata la Regolarize delle rigate per trimming. - aggiunte funzioni di utilità per le CurveComposite.	2026-04-27 14:58:23 +02:00
Dario Sassi	2e4b1cdd40	EgtGeomKernel : - spostamento di sorgente in cartella filtro.	2026-04-22 18:31:20 +02:00
Daniele Bariletti	3ffc0b40d8	EgtGeomKernel : - tolto flag di debug.	2026-04-22 16:12:30 +02:00
Daniele Bariletti	cd2cde40da	EgtGeomKernel: - correzioni alla regolarize.	2026-04-22 16:11:46 +02:00
Daniele Bariletti	efc656a72c	Merge branch 'Trimming'	2026-04-21 15:05:12 +02:00
Daniele Bariletti	e1eb139aee	Merge branch 'master' into Trimming	2026-04-21 15:04:54 +02:00
Daniele Bariletti	e7d25b2d0e	EgtGeomKernel : - correzioni e migliorie a regolarize dei bordi per trimming.	2026-04-21 15:04:24 +02:00
Riccardo Elitropi	ce05ce577c	EgtGeomKernel 3.1d4 : - In Voronoi migliorati i controlli sulla chiusura delle curve (copyright Sara) - in CalcPocketing corrette le funzioni del calcolo delle Feed e migliorati i controlli sugli ingressi.	2026-04-20 15:05:03 +02:00
Daniele Bariletti	ae2cac48d1	Merge branch 'master' into Trimming	2026-04-17 13:34:47 +02:00
Daniele Bariletti	37e9a05347	EgtGeomKernel : - nuova versione regolarize.	2026-04-17 13:34:17 +02:00
Daniele Bariletti	02cb8a0d3c	EgtGeomKernel : - aggiornamento versione di RuledSmooth. - aggiunta controlli. - prima versione della regolarizzazione di curve bezier composte.	2026-04-16 09:41:22 +02:00
Dario Sassi	6942f5fc23	EgtGeomKernel : - nella proiezione di curve su superfici aggiunto paramtetro bFromVsTo.	2026-04-15 08:54:32 +02:00
Riccardo Elitropi	6c4bf3f05a	EgtGeomKernel : - in CalcPocketing migliorati i controlli per i casi a Trapezio. - in CAvToolTriangle migliorata la creazione del frame Locale in CAvDiskTriangle per direzioni generiche di vDiskAx e vtMove.	2026-04-14 19:07:16 +02:00
Daniele Bariletti	4bc8590ce9	Merge branch 'master' into Trimming	2026-04-14 12:08:17 +02:00
Daniele Bariletti	5b68e33d1f	EgtGeomKernel : - correzione al VM 5 assi.	2026-04-14 11:59:17 +02:00
Daniele Bariletti	a70f7ee9c9	Merge branch 'Trimming' of https://gitlab.steamware.net/egalware-cadcam/libreriebase/EgtGeomKernel into Trimming	2026-04-14 10:56:00 +02:00
Daniele Bariletti	95a070413a	EgtGeomKernel : - miglioria nel posizionamento delle curve di sync.	2026-04-14 10:53:24 +02:00
Riccardo Elitropi	223489e80d	EgtGeomKernel 3.1d3 : - in CalcPocketing piccola modifica alle tolleranze per casi a Trapezio.	2026-04-13 15:26:34 +02:00
Daniele Bariletti	f6a535d94c	EgtGeomKernel : - tolto flag di debug.	2026-04-13 14:29:59 +02:00
Daniele Bariletti	dbc3e7d2bf	Merge branch 'NewRuled'	2026-04-10 18:20:59 +02:00
Daniele Bariletti	a3d44261bb	Merge branch 'master' into NewRuled	2026-04-10 18:20:44 +02:00
Daniele Bariletti	9220fd568f	EgtGeomKernel : - aggiunte funzioni per la creazione delle smooth ruled bezier.	2026-04-10 18:20:22 +02:00
Daniele Bariletti	17346e1b42	EgtGeomKernel : - correzione alla triangolazione bezier.	2026-04-10 15:23:28 +02:00
Daniele Bariletti	c95ef6764d	EgtGeomKernel : - correzione alla triangolazione bezier.	2026-04-10 15:22:44 +02:00
Daniele Bariletti	d0f2d56bdb	EgtGeomKernel : - correzione per split vicini a joint in RuledByIsoParamSet.	2026-04-10 12:35:22 +02:00
Daniele Bariletti	fb037f2f2a	EgtGeomKernel : - correzione per split vicini a joint in RuledByIsoParamSet.	2026-04-10 12:35:07 +02:00
Daniele Bariletti	2d94dddccb	EgtGeomKernel : - correzioni alla RuledByIsoParamSet.	2026-04-10 10:25:04 +02:00
Daniele Bariletti	d2d025a594	EgtGeomKernel : - correzioni alla RuledByIsoParamSet.	2026-04-10 10:23:32 +02:00
Daniele Bariletti	64abf640f6	Merge remote-tracking branch 'origin/HEAD' into NewRuled	2026-04-10 09:34:02 +02:00
Daniele Bariletti	cb2b63320a	EgtGeomKernel : - nuovo paradigma per la bezier ruled.	2026-04-10 09:20:02 +02:00
Riccardo Elitropi	951d3781d6	EgtGeomKernel : - in IntersCurvePlane aggiunta implementazione funzione GetIntCrvPlnInfo.	2026-04-09 19:20:59 +02:00
Daniele Bariletti	27bd0e579e	EgtGeomKernel : - correzione al VM a 5 assi.	2026-04-08 17:08:37 +02:00
Daniele Bariletti	ff7d564de8	Merge branch 'NewRuled'	2026-04-08 13:42:01 +02:00
Daniele Bariletti	a27b9e871a	EgtGeomKernel : - piccola correzione alle rigate.	2026-04-08 13:41:43 +02:00
Daniele Bariletti	eb497cbd39	Merge branch 'master' into NewRuled	2026-04-03 17:27:31 +02:00
Daniele Bariletti	dd3091fc13	EgtGeomKernel : - miglioramento delle rigate con bezier.	2026-04-03 17:27:13 +02:00
Daniele Bariletti	69d463713c	EgtGeomKernel 3.1d2 : - cambio versione.	2026-04-03 16:21:20 +02:00
Daniele Bariletti	5e918ff3aa	Merge branch 'master' of https://gitlab.steamware.net/egalware-cadcam/libreriebase/EgtGeomKernel	2026-04-03 16:19:47 +02:00
Daniele Bariletti	b4522c712d	EgtGeomKernel : - correzione alla IntersCrvCompoCrvCompo.	2026-04-03 16:19:39 +02:00
Riccardo Elitropi	fa9a9e89cb	EgtGeomKernel : - in CalcPocketing aggiunte considerazioni per Lucidature su SmallRad.	2026-04-03 12:52:39 +02:00
Riccardo Elitropi	d51a0d2258	EgtGeomKernel : - in CalcPocketing correzione parametro Invert per Epicicli.	2026-04-03 08:23:13 +02:00
Daniele Bariletti	580230b38b	Merge branch 'master' of https://gitlab.steamware.net/egalware-cadcam/libreriebase/EgtGeomKernel	2026-04-02 18:03:34 +02:00
Daniele Bariletti	4b24906d2e	Merge branch 'NewRuled'	2026-04-02 18:03:26 +02:00
Daniele Bariletti	2094a1cc0d	EgtGeomKernel : - tolto flag di debug.	2026-04-02 18:03:05 +02:00
Daniele Bariletti	b8b639699a	EgtGeomKernel : - correzione alla nuova versione rigate (riconoscimento automtico mismatch).	2026-04-02 18:02:20 +02:00
Riccardo Elitropi	0b86c4f72b	EgtGeomKernel : - in Trimming piccola correzione	2026-04-02 17:29:41 +02:00
Daniele Bariletti	5c93384690	Merge branch 'master' into NewRuled	2026-04-02 16:09:45 +02:00
Daniele Bariletti	b77db4a5bc	Merge branch 'master' of https://gitlab.steamware.net/egalware-cadcam/libreriebase/EgtGeomKernel	2026-04-02 15:14:38 +02:00
Daniele Bariletti	c704d94829	EgtGeomKernel : - piccola aggiunta per la gestione di spike nelle categorizzazioni tra curve.	2026-04-02 15:14:29 +02:00
Riccardo Elitropi	0373021b7a	EgtGeomKernel : - In CalcPocketing piccole correzioni alle curve singole e modifiche stilistiche.	2026-04-02 10:43:37 +02:00
Riccardo Elitropi	6de856b3e1	EgtGeomKernel 3.1d1 : - In CalcPocketing piccola correzione per casi Conformal.	2026-04-01 18:06:00 +02:00
Dario Sassi	a231d8f26c	EgtGeomKernel : - eliminato file inutile.	2026-04-01 10:19:56 +02:00
Riccardo Elitropi	745a7eb38c	EgtGeomKernel : - In PocketingNT ggiunta gestione per Lucidatura.	2026-03-31 18:53:52 +02:00
Daniele Bariletti	78c40ebca7	EgtGeomKernel : - tolto bypass di debug.	2026-03-31 17:26:43 +02:00
Daniele Bariletti	a39af1c3a3	EgtGeomKernel : - gestite superfici con trim molto piccoli rispetto al totale.	2026-03-31 16:19:42 +02:00
Riccardo Elitropi	c2a0f9dff1	Merge commit '6be67258d2ac30e94ee2ed5af4e648ffb62d842d'	2026-03-31 14:27:26 +02:00
Daniele Bariletti	98c576afe0	Merge branch 'master' into NewRuled	2026-02-23 09:12:05 +01:00
Daniele Bariletti	ae8f80d6e9	EgtGeomKernel : - miglioria alla bezier ruled guided.	2026-02-20 14:54:50 +01:00
Daniele Bariletti	9b933bd26d	EgtGeomKernel : - miglioramento dell'approssimazione con curve di bezier.	2026-02-19 18:15:58 +01:00
Daniele Bariletti	baa8736276	Merge branch 'master' into NewRuled	2026-02-19 15:41:12 +01:00
Daniele Bariletti	c75a7e9514	EgtGeomKernel : - migliorie alla rigata bezier. - correzioni alle tolleranze di triangolazione - aggiunta di un parametro alla funzione GetLeaves delle surf bezier.	2026-02-19 11:49:28 +01:00
Daniele Bariletti	233f64e68f	EgtGeomKernel : - correzioni alle rigate bezier.	2026-02-17 14:41:37 +01:00
Daniele Bariletti	da7ebd6f61	EgtGeomKernel : - miglioramenti e correzioni alle rigate con le bezier.	2026-02-16 12:45:50 +01:00
Daniele Bariletti	8db1765505	Merge remote-tracking branch 'origin/master' into NewRuled	2026-02-12 17:00:02 +01:00
Daniele Bariletti	5d2e1ff608	EgtGeomKernel : - tolto un argomento alla funzione ApproxCurveWithBezier.	2026-02-11 16:47:01 +01:00
Daniele Bariletti	a9f8ef2ff3	Merge branch 'master' into NewRuled	2026-02-11 15:58:21 +01:00
Daniele Bariletti	a1c448d8dd	EgtGeomKernel : - tentativo di miglioria alle ruled. Da debuggare.	2026-02-03 16:13:07 +01:00
Daniele Bariletti	25d53338c2	Merge branch 'master' into NewRuled	2026-01-28 15:24:09 +01:00
Riccardo Elitropi	b3ebb35d01	EgtGeomKernel : - aggiunte prime funzioni di Trimming.	2025-12-22 17:15:02 +01:00
Daniele Bariletti	1ad96ce8ca	EgtGeomKernel : - tentativo di miglioramento delle ruled nei punti di mismatch.	2025-12-15 15:08:53 +01:00
Daniele Bariletti	36422c43b3	Merge branch 'master' into NewRuled	2025-12-15 15:07:21 +01:00