Include :

- aggiunta funzione per estendere un gruppo di superfici indicandone il bordo.
Include :
2026-07-22 09:23:27 +02:00 · 2026-07-20 13:09:50 +02:00 · 2026-07-13 08:03:46 +02:00 · 2026-07-08 17:27:24 +02:00 · 2026-07-07 19:34:43 +02:00 · 2026-07-07 09:11:17 +02:00
31 changed files with 420 additions and 96 deletions
@@ -35,20 +35,27 @@ const int SCI_LINE_LINE = 4 ;             // tra linea di mobile e linea di fiss
 struct SCollInfo
 {
   int nType ;                    // tipo di collisione
+
   int nChunkM ;                  // indice del chunk della regione mobile
-   int nCrvM ;                    // indice della curva nel loop esterno del chunk
+   int nLoopM ;                   // indice del loop del chunk della regione mobile
+   int nCrvM ;                    // indice della curva nel loop del chunk
+
   int nChunkF ;                  // indice del chunk della regione fissa
-   int nCrvF ;                    // indice della curva nel loop esterno del chunk
+   int nLoopF ;                   // indice del loop del chunk della regione fissa
+   int nCrvF ;                    // indice della curva nel loop 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
-   SCollInfo() : nType( SCI_NONE), nChunkM( -1), nCrvM( -1), nChunkF( -1), nCrvF( -1),
+   SCollInfo() : nType( SCI_NONE), nChunkM( -1), nLoopM( -1), nCrvM( -1), nChunkF( -1), nLoopF( -1), nCrvF( -1),
                 ptP1(), ptP2(), vtDirM(), vtDirF() {}
-   SCollInfo( const SCollInfo& 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) {} 
+   SCollInfo( const SCollInfo& Sou) : nType( Sou.nType),
+                                      nChunkM( Sou.nChunkM), nLoopM( Sou.nLoopM), nCrvM( Sou.nCrvM),
+                                      nChunkF( Sou.nChunkF), nLoopF( Sou.nLoopF), nCrvF( Sou.nCrvF),
+                                      ptP1( Sou.ptP1), ptP2( Sou.ptP2), vtDirM( Sou.vtDirM), vtDirF( Sou.vtDirF) {}
 } ;

 //----------------------------------------------------------------------------
@@ -67,4 +74,4 @@ class CAvSimpleSurfFrMove
      const ISurfFlatRegion* m_pRegM ;
      const ISurfFlatRegion* m_pRegF ;
      SCollInfo m_SCollInfo ;
-} ;
+} ;
@@ -0,0 +1,41 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2015-2018
+//----------------------------------------------------------------------------
+// File : EGkCAvSurfFrMove.h      Data : 26.03.2026    Versione : 3.1c7
+// 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/EGkCAvSimpleSurfFrMove.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
+
+//----------------------------------------------------------------------------
+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 SCollInfo& GetCollInfo()
+                           { return m_CollInfo ; }
+
+   private :
+      const ISurfFlatRegion* m_pRegM ;
+      const ISurfFlatRegion* m_pRegF ;
+      SCollInfo m_CollInfo ;
+} ;
@@ -25,10 +25,15 @@
 #endif

 //-----------------------------------------------------------------------------
-EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double dStep,
+// Per calcolo percorso di Svuotatura o di Lucidatura
+EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadialOffs, double dStep,
                               double dAngle, double dOpenMinSafe, int nType, bool bSmooth, bool bCalcUnclReg, bool bInvert, bool bAvoidOpt,
-                               bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec, const ISurfFlatRegion* pSfrLimit,
-                               bool bAllOffs, double dMaxOptSize, double dLiTang, int nLiType, ICRVCOMPOPOVECTOR& vCrv) ;
+                               bool bConventionalMilling, bool bAllowZigZagOneWayBorders, bool bOpenOutRaw, bool bCalcFeed, const Point3d& ptEndPrec,
+                               const ISurfFlatRegion* pSfrLimit, bool bAllOffs, double dMaxOptSize,
+                               int nLiType, double dLiTang, double dLiElev, int nLoType, double dLoTang,
+                               bool bPolishing, double dEpicyclesRad, double dEpicyclesDist, bool bContour, ICRVCOMPOPOVECTOR& vCrv) ;
+EGK_EXPORT bool IsPocketingHole( const ISurfFlatRegion* pSfr, double dRad, double dRadialOffs, double dStep, int nType,
+                                 int nLiType, double dLiTang, double dRatioSfrTool) ;
 EGK_EXPORT bool CalcSmoothCurve( ICurveComposite* pCrv, double dRightLen, double dLeftLen, bool bAsParam) ;
 EGK_EXPORT bool CalcZigZagInfill( const ISurfFlatRegion* pSfr, double dStep, bool bSmooth, bool bRemoveOverlapLink,
                                  ICRVCOMPOPOVECTOR& vCrvCompoRes) ;
@@ -45,38 +50,41 @@ enum { POCKET_ZIGZAG = 0,

 // Definizione di lato aperto e lato chiuso
 enum {
-   TEMP_PROP_CLOSE_EDGE = 0,
-   TEMP_PROP_OPEN_EDGE = 1,
-   TEMP_PROP_OPEN_EDGE_IN_RAW = 2
+   TEMP_PROP_CLOSE_EDGE = 0,                    // Lato Chiuso
+   TEMP_PROP_OPEN_EDGE = 1,                     // Lato Aperto
+   TEMP_PROP_OPEN_AS_CLOSE = 2,                 // Lato Aperto da trattare come Chiuso
+   TEMP_PROP_CLOSE_AS_OPEN = 3,                 // Lato Chiuso da trattare come Aperto
+   TEMP_PROP_OPEN_EDGE_IN_RAW = 101             // Lato Aperto interno al Grezzo
 } ;

 // Definizione di curva invalida
 enum {
-   TEMP_PROP_INVALID = - 1
+   TEMP_PROP_INVALID = -1
 } ;

 // Definizione curva di raccordo per smussi
 enum {
-   TEMP_PROP_SMOOTH = - 2
+   TEMP_PROP_SMOOTH = -2
 } ;

 // Definizione tipo di curva per casi speciali
 enum {
-   TEMP_PROP_SINGLE_CURVE = - 3,
-   TEMP_PROP_OPT_TRAPEZOID = - 4,
-   TEMP_PROP_BORDER_CURVE =  - 5,
-   TEMP_PROP_OPT_CIRCLE = - 9
+   TEMP_PROP_SINGLE_CURVE = -3,
+   TEMP_PROP_OPT_TRAPEZOID = -4,
+   TEMP_PROP_BORDER_CURVE =  -5,
+   TEMP_PROP_OPT_CIRCLE = -9,
+   TEMP_PROP_CONTOUR_BORDER = -10
 } ;

 // Definizione tipo di curva per entrate da fuori
 enum {
-   TEMP_PROP_OUT_START = - 6
+   TEMP_PROP_OUT_START = -6
 } ;

 // Definizione di curva attiva/non attiva
 enum {
-   TEMP_PROP_CURVE_ACTIVE = - 7,
-   TEMP_PROP_CURVE_INACTIVE = - 8
+   TEMP_PROP_CURVE_ACTIVE = -7,
+   TEMP_PROP_CURVE_INACTIVE = -8
 } ;

 // Definizione tipo LeadIn
@@ -86,3 +94,9 @@ enum {
   LEAD_IN_ZIGZAG = 2,
   LEAD_IN_HELIX = 3
 } ;
+
+// Definizione tipo LeadOut
+enum {
+   LEAD_OUT_NONE = 0,
+   LEAD_OUT_GLIDE = 1
+} ;
@@ -76,6 +76,7 @@ class __declspec( novtable) ICurve : public IGeoObj
      virtual bool GetAreaXY( double& dArea) const = 0 ; 
      virtual bool GetArea( Plane3d& plPlane, double& dArea) const = 0 ;
      virtual bool ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, PolyLine& PL) const = 0 ;
+      virtual bool ApproxWithLimitedLines( double dLinTol, double dAngTolDeg, int nType, double dMaxLen, PolyLine& PL) const = 0 ;
      virtual bool ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) const = 0 ;
      virtual bool ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) const = 0 ;
      virtual ICurve* CopyParamRange( double dUStart, double dUEnd) const = 0 ;
@@ -45,7 +45,7 @@ struct CNurbsData
   CNurbsData( void) : nDeg( 0), bRat( false), bPeriodic( false), bClosed( false), bClamped( true), bExtraKnotes(false) {}
 } ;

-// N.B. : in caso la curva sia razionale i punti di controllo sono in forma NON OMOGENEA [ x, y, z, w]  ( dove la forma OMOGENEA è [ w*x, w*y, w*z, w])
+// N.B. : in caso la curva sia razionale i punti di controllo sono in forma NON OMOGENEA [ x, y, z, w]  ( dove la forma OMOGENEA � [ w*x, w*y, w*z, w])
 // tutte le operazioni richiedono la forma OMOGENEA, finite le quali posso riportarmi alla forma NON OMOGENEA

 //----------------------------------------------------------------------------
@@ -65,7 +65,7 @@ EGK_EXPORT ICurve* ArcToBezierCurve( const ICurveArc* pArc, int nDeg = 3, bool b
 EGK_EXPORT ICurve* CompositeToBezierCurve( const ICurveComposite* pCrv, int nDeg = 3, bool bMakeRatOrNot = false) ;

 //----------------------------------------------------------------------------
-//! Trasforma una curva bezier in una nuova curva di Bezier semplice o composta della razionalità e  grado desiderato ( minimo 3)
+//! Trasforma una curva bezier in una nuova curva di Bezier semplice o composta della razionalit� e  grado desiderato ( minimo 3)
 EGK_EXPORT ICurve* EditBezierCurve( const ICurveBezier* pCrv, int nDeg = 3, bool bMakeRatOrNot = false, double dTol = 10 * EPS_SMALL) ;

 //----------------------------------------------------------------------------
@@ -77,11 +77,11 @@ EGK_EXPORT ICurve* ApproxBezierWithCubics( const ICurve* pCrv, double dTol) ;
 EGK_EXPORT ICurveBezier* ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen, const Vector3d& vtN) ;

 //----------------------------------------------------------------------------
-//! Campiona una serie di punti dalla curva e li approssima con una o più curve di bezier
-EGK_EXPORT ICurve* ApproxCurveWithBezier( const ICurve* pCrv, double dTol) ;
+//! Campiona una serie di punti dalla curva e li approssima con una o pi� curve di bezier
+EGK_EXPORT ICurve* ApproxCurveWithBezier( const ICurve* pCrv, double dTol, const Vector3d& vtStart = V_NULL, const Vector3d& vtEnd = V_NULL) ;

 //----------------------------------------------------------------------------
-//! Interpola un set di punti e li approssima con una o più curve di bezier cubiche
+//! Interpola un set di punti e li approssima con una o pi� curve di bezier cubiche
 EGK_EXPORT ICurve* InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMaxLen) ;

 //----------------------------------------------------------------------------
@@ -169,5 +169,11 @@ EGK_EXPORT bool CalcFatOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR
 //! Resetta l'oggetto voronoi associato alla curva liberandone la memoria
 EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;

+//----------------------------------------------------------------------------
 //! fa il join delle curve passate in input
-EGK_EXPORT bool GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol = 5 * EPS_SMALL, bool bAllowInvert = false) ;
+EGK_EXPORT bool GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol = 5 * EPS_SMALL, bool bAllowInvert = false, bool bHaltOnFork = false) ;
+
+//----------------------------------------------------------------------------
+//! dato un punto su una curva trova il corrispondente sulla seconda curva
+EGK_EXPORT bool GetIsoPointOnSecondCurve( const ICurve* pCrv1, const ICurve* pCrv2, double dUCurr1, double& dUCurr2, double dMyDist, double dUPrev2,
+                                          double dLenPrev2, double& dLenCurr2, double dLen2) ;
@@ -50,6 +50,7 @@ class __declspec( novtable) ICurveComposite : public ICurve
      virtual bool AddArcTg( const Point3d& ptNew, bool bEndOrStart = true) = 0 ;
      virtual bool AddJoint( double dU) = 0 ;
      virtual bool ModifyJoint( int nU, const Point3d& ptNewJoint) = 0 ;
+      virtual bool ModifyJoint( int nU, const Point3d& ptNewJoint, double dTol) = 0 ;
      virtual bool RemoveJoint( int nU) = 0 ;
      virtual bool MoveCurve( int nCrv, const Vector3d& vtMove) = 0 ;
      virtual bool ModifyCurveToArc( int nCrv, const Point3d& ptMid) = 0 ;
@@ -71,6 +72,7 @@ class __declspec( novtable) ICurveComposite : public ICurve
      virtual bool SetCurveTempParam( int nCrv, double dParam, int nParamInd = 0) = 0 ;
      virtual bool GetCurveTempParam( int nCrv, double& dParam, int nParamInd = 0) const = 0 ;
      virtual bool GetOnlyPoint( Point3d& ptStart) const = 0 ;
+      virtual bool ReplaceSingleCurve( int nSubCrv, ICurve* pNewCurve, double dTolStartEnd, double dTolAlong = INFINITO) = 0 ;
 } ;

 //-----------------------------------------------------------------------------
@@ -23,7 +23,7 @@ class CurveLocal
      CurveLocal( IGeomDB* pGeomDB, int nCrvId, const Frame3d& frLoc)
         : m_pCrv( nullptr), m_pCopy( nullptr)
         { // verifica dei parametri
-            if ( pGeomDB == nullptr  ||  &frLoc == nullptr)
+            if ( pGeomDB == nullptr)
               return ;
           // recupero riferimento della curva
            Frame3d frCrv ;
@@ -76,7 +76,7 @@ class CurveLocal
               return ;
            m_pCrv = m_pCopy ;
         }
-      CurveLocal( CurveLocal&& Other)
+      CurveLocal( CurveLocal&& Other) noexcept
         : m_pCrv( Other.m_pCrv), m_pCopy( Other.m_pCopy)
         { // annullo gli originali
            Other.m_pCrv = nullptr ;
@@ -40,7 +40,8 @@ class CrvPointDiffGeom
      double   dCurv ;

   public :
-      CrvPointDiffGeom( void) { nStatus = NONE ; nFlag = STD ; }
+      CrvPointDiffGeom( void)
+         : nStatus( NONE), nFlag( STD), dU( -1), dCurv( -1) {}
 } ;

 //----------------------------------------------------------------------------
@@ -63,8 +63,8 @@ class DistPointCurve
      EGK_EXPORT bool GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFlag) const ;
      EGK_EXPORT bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const ;
      EGK_EXPORT bool GetParamAtMinDistPoint( double dNearParam, double& dParam, int& nFlag) const ;
-      EGK_EXPORT bool GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide) const ;
-      EGK_EXPORT bool GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide) const ;
+      EGK_EXPORT bool GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide, double dTol = EPS_SMALL) const ;
+      EGK_EXPORT bool GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide, double dTol = EPS_SMALL) const ;
      EGK_EXPORT bool GetMinDistInfo( int nInd, MinDistPCInfo& aInfo) const ;

   private :
@@ -44,7 +44,7 @@ struct IntCrvCrvInfo {
   IntCrvInfo IciB[2] ;     //!< IciB[0] intersez. isolata o inizio overlap, IciB[1] fine overlap 
  // costruttore
   IntCrvCrvInfo( void)
-      : bOverlap( false) {}
+      : bOverlap( false), bCBOverEq( false) {}
 } ;
 //! vettore di IntCrvCrvInfo
 typedef std::vector<IntCrvCrvInfo>  ICCIVECTOR ;
@@ -0,0 +1,31 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2015-2015
+//----------------------------------------------------------------------------
+// File : EGkIntersLineCylinder.h      Data : 08.06.26         Versione : 3.1f1
+// Contenuto : Dichiarazione della classe intersezione linea/cilindro.
+//
+//
+//
+// Modifiche : 08.06.26 DB Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkPoint3d.h"
+#include "/EgtDev/Include/EGkVector3d.h"
+#include "/EgtDev/Include/EGkFrame3d.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
+
+// restituisce true se trova delle soluzioni, altrimenti false
+//-----------------------------------------------------------------------------
+EGK_EXPORT bool IntersLineCyl( const Point3d& ptLineSt, const Vector3d& vtLineDir, const Frame3d& CylFrame, double dH, double dRad,
+                               double& dU1, Point3d& ptInt1, Vector3d& vtN1, double& dU2, Point3d& ptInt2, Vector3d& vtN2) ;
@@ -46,9 +46,9 @@ enum IntLineTriaAuxType { ILTA_NO_TRIA = -1,       // l'intersezione è stata ca
                          ILTA_IN = 5} ;          // intersezione in interno del triangolo

 //-----------------------------------------------------------------------------
-//! dati di intersezione linea - superficie trimesh
+//! dati di intersezione linea - superficie bezier
 struct IntLinSbzInfo {
-   int     nILTA ;          //!< tipo di intersezione linea-triangolo   // se -1 vuol dire che l'intersezione � stata calcolata direttamente, senza usare la trimesh
+   int     nILSB ;          //!< tipo di intersezione linea-bezier
   double  dU ;             //!< parametro sulla linea
   double  dU2 ;            //!< secondo parametro sulla linea
   int     nT ;             //!< indice del triangolo della superficie trimesh  // se -1 vuol dire che l'intersezione � stata calcolata direttamente, senza usare la trimesh
@@ -58,11 +58,11 @@ struct IntLinSbzInfo {
   Point3d ptUV ;            //!< coordinate del punto nello spazio parametrico
   Point3d ptUV2 ;           //!< coordinate del secondo punto nello spazio parametrico
   // costruttori
-   IntLinSbzInfo( void) : nILTA( ILTA_NO), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2(), ptUV(), ptUV2(){}
-   IntLinSbzInfo( int nILT, double dUU, int nTT, double dCos, const Point3d& ptP, const Point3d ptSP)
-      : nILTA( nILT), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2(), ptUV( ptSP), ptUV2() {}
-   IntLinSbzInfo( int nILT, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2, const Point3d& ptSP, const Point3d& ptSP2)
-      : nILTA( nILT), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2), ptUV( ptSP), ptUV2( ptSP2) {}
+   IntLinSbzInfo( void) : nILSB( LSBT_NONE), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2(), ptUV(), ptUV2(){}
+   IntLinSbzInfo( int nILS, double dUU, int nTT, double dCos, const Point3d& ptP, const Point3d ptSP)
+      : nILSB( nILS), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2(), ptUV( ptSP), ptUV2() {}
+   IntLinSbzInfo( int nILS, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2, const Point3d& ptSP, const Point3d& ptSP2)
+      : nILSB( nILS), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2), ptUV( ptSP), ptUV2( ptSP2) {}
 } ;
 //! vettore di IntLinSbzInfo
 typedef std::vector<IntLinSbzInfo>  ILSBIVECTOR ;
@@ -0,0 +1,117 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2026
+//----------------------------------------------------------------------------
+// File : EGkOffsetCurve3d.h      Data : 10.06.26       Versione : 3.1f1
+// Contenuto : Dichiarazione classe per offset di ICurve, per curve 3d.
+//
+//
+// Modifiche : 10.06.26 DB Creazione modulo.
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkFrame3d.h"
+#include "/EgtDev/Include/EGkPoint3d.h"
+#include "/EgtDev/Include/EGkVector3d.h"
+#include "/EgtDev/Include/EGkPolyLine.h"
+#include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EGkCurveComposite.h"
+#include "/EgtDev/Include/EGkProjectCurveSurf.h"
+#include "/EgtDev/Include/EgtPointerOwner.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
+
+//----------------------------------------------------------------------------
+struct OffsetSegm {
+   PtrOwner<ICurve> pCrv ;
+   int nFlag ;  // OffsetCurve3d::AngType
+   int nParent ;
+   OffsetSegm( ICurve* _pCrv, int _nFlag, int _nParent) :
+      nFlag( _nFlag), nParent( _nParent) { pCrv.Set( _pCrv); } ;
+} ;
+
+typedef std::vector<OffsetSegm> OFFSETSEGVEC ;
+
+enum OFFTYPE {
+   GEOM = 0,
+   PLANECUT = 1,
+};
+
+struct EditCrvInfo {
+   enum EditFlag {
+      NOEDIT = 0,
+      DEL = 1,
+      EDIT = 2
+   };
+   int nId = -1 ;
+   int nFlag = 0 ;
+   Point3d ptStart = P_INVALID ;
+   Point3d ptEnd = P_INVALID ;
+   EditCrvInfo( int _nId, int _nFlag) : nId( _nId), nFlag( _nFlag) { ;}
+   EditCrvInfo( int _nId, int _nFlag, const Point3d& _ptStart, const Point3d& _ptEnd) :
+      nId( _nId), nFlag( _nFlag), ptStart( _ptStart), ptEnd( _ptEnd) { ;}
+};
+
+typedef std::vector<EditCrvInfo> EDITCRVINFOVEC ;
+
+struct Cyl {
+   Cyl( void): frCyl( GLOB_FRM), dH( 0.), dRad( 0.) {;} ;
+   Cyl( const Frame3d& _frCyl, double _dH, double _dRad, double _dLinTol) :
+      frCyl( _frCyl), dH( _dH), dRad( _dRad) { ;}
+   Cyl( const Point3d& _ptBase, const Vector3d& vtZ, double _dH, double _dRad, double _dLinTol) :
+      dH( _dH), dRad( _dRad){
+      frCyl.Set( _ptBase, vtZ); }
+public :
+   Frame3d frCyl ;
+public:
+   double dH ;
+   double dRad ;
+};
+
+typedef std::vector<Cyl> CYLVECT ;
+
+
+EGK_EXPORT bool CalcAdjustConcavePartsInPath( const ICurveComposite* pCrv, const OFFSETSEGVEC& vOffsetCrvs, double dRad, EDITCRVINFOVEC& vEditInfo) ;
+EGK_EXPORT bool CalcAdjustConcavePartsPlaneCut( const ICurveComposite* pCrv, const PNT5AXVECTOR& vPnt5Ax, const OFFSETSEGVEC& vOffsetCrvs,
+                                                double dRad, EDITCRVINFOVEC& vEditInfo) ;
+EGK_EXPORT bool IsPointInsideCylinder( const Point3d& ptTest, const Cyl& offCyl, double dLinTol) ;
+
+//----------------------------------------------------------------------------
+class OffsetCurve3d
+{
+public :
+   enum AngType { ANG_STR = 1 ,               // angolo piatto ( quindi tratto in continuità col precedente)
+                  ANG_CVEX = 2 ,              // su angolo convesso
+                  ANG_CONC = 3 ,              // in angolo concavo
+                  ANG_BEFORE_CONC = 4 ,       // adiacente ad angolo concavo
+                  ANG_AFTER_CONC = 5 ,        // adiacente ad angolo concavo
+                  ANG_SMOOTH_CONC = 6         // zona concava curva, senza spigolo netto
+                  };
+
+public :
+   EGK_EXPORT OffsetCurve3d(): m_dLinTol( 10 * EPS_SMALL) {} ;
+   EGK_EXPORT OffsetCurve3d( double dLinTol) : m_dLinTol( dLinTol) {} ;
+   EGK_EXPORT ~OffsetCurve3d( void) ;
+
+public :
+   EGK_EXPORT bool Reset( void) ;
+   EGK_EXPORT bool Make( const PNT5AXVECTOR& vPnt5Ax, double dDist, int nType) ;
+   EGK_EXPORT int GetCurveCount( void) { return int( m_CrvLst.size()) ; }
+   EGK_EXPORT ICurve* GetCurve( void) ;
+   EGK_EXPORT ICurve* GetLongerCurve( void) ;
+   EGK_EXPORT ICurve* GetShorterCurve( void) ;
+   EGK_EXPORT double GetLinTol( void) const { return m_dLinTol ; }
+   EGK_EXPORT void SetLinTol( double dTol) { m_dLinTol = dTol ; }
+
+private :
+   ICURVEPLIST m_CrvLst ;
+   double m_dLinTol ;
+} ;
@@ -108,7 +108,7 @@ class PolyLine
      EGK_EXPORT bool GetMaxDistanceFromLine( const Point3d& ptLine, const Vector3d& vtLine, double dLen,
                                              double& dMaxDist,  bool bIsSegment = true) const ;
      EGK_EXPORT bool AdjustForMaxSegmentLen( double dMaxLen) ;
-      EGK_EXPORT bool RemoveAlignedPoints( double dToler = EPS_SMALL, bool bStartEnd = true) ;
+      EGK_EXPORT bool RemoveAlignedPoints( double dToler = EPS_SMALL, bool bStartEnd = true, double dMaxLen = INFINITO) ;
      EGK_EXPORT bool ApproxOnSide( const Vector3d& vtN, bool bLeftSide, double dToler = EPS_SMALL) ;
      EGK_EXPORT bool MakeConvex( const Vector3d& vtN,  bool bLeftSide) ;
      EGK_EXPORT bool Invert( bool bInvertU = true) ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2023-2023
+//  EgalTech 2023-2026
 //----------------------------------------------------------------------------
-// File : EGkProjectCurveSurfTm.h     Data : 31.08.23      Versione : 2.5h3
+// File : EGkProjectCurveSurfTm.h     Data : 14.04.26      Versione : 3.1d3
 // Contenuto : Dichiarazione funzioni proiezione curve su superficie Trimesh.
 //
 //
@@ -16,6 +16,7 @@
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkSurf.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"

 //----------------------- Macro per import/export ----------------------------
 #undef EGK_EXPORT
@@ -25,6 +26,17 @@
   #define EGK_EXPORT __declspec( dllimport)
 #endif

+enum P5AxAng {    // Tipologia di punto
+                  P5AX_TO_DELETE = -1 ,        // da cancellare
+                  P5AX_OUT = 0 ,               // aggiunto prima di inizio o dopo fine
+                  P5AX_STD = 1 ,               // standard
+                  P5AX_CVEX = 2 ,              // su angolo convesso
+                  P5AX_CONC = 3 ,              // in angolo concavo
+                  P5AX_BEFORE_CONC = 4 ,       // adiacente ad angolo concavo
+                  P5AX_AFTER_CONC = 5 ,        // adiacente ad angolo concavo
+                  P5AX_SMOOTH_CONC = 6         // zona concava curva, senza spigolo netto
+               };
+
 //----------------------------------------------------------------------------
 // Definizione di Punto 5assi e sue raccolte
 struct Point5ax {
@@ -49,16 +61,19 @@ typedef std::vector<Point5ax>        PNT5AXVECTOR ;    // vettore di Punti 5assi
 //----------------------------------------------------------------------------
 // Proiezione di una curva su una o più superfici a distanza minima
 EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici lungo la direzione data
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax, bool bNormOrTang = true) ;
+// Proiezione di una curva su una o più superfici lungo la direzione data (da o verso)
 EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vector3d& vtDir,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici in direzione del punto
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una o più superfici in direzione del punto (da o verso)
 EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeoPoint3d& gpRef,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici in direzione della curva
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una o più superfici in direzione della curva (da o verso)
 EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICurve& crRef,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici in direzione della superficie
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una o più superfici in direzione della superficie (da o verso)
 EGK_EXPORT 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) ;
+// Proiezione di una curva su una o più superfici in direzione della superficie (da o verso)
+EGK_EXPORT bool GetCurveOnSurfInfo( const ICurve& crCrv, const ISurfTriMesh& pSurf,
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax, bool bNormOrTang = true) ;
@@ -44,6 +44,7 @@ EGK_EXPORT ISurfBezier* GetSurfBezierByScrewing( const ICurve* pCurve, const Poi
 //EGK_EXPORT ISurfBezier* GetSurfBezierTransSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierRuled( const Point3d& ptP, const ICurve* pCurve, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfBezier* GetSurfBezierRuledSmooth( const ICurve* pCurve1, const ICurve* pCurve2, BIPNTVECTOR& vSyncLines, double dSampleLen = 10) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const BIPNTVECTOR& vCrv, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierSkinned( const CICURVEPVECTOR& vCrv, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtNorm, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
@@ -46,14 +46,28 @@ typedef std::vector<SelData>  SELVECTOR ;   // vettore di SelData
 typedef std::list<SelData>    SELLIST ;     // lista di SelData

 //----------------------------------------------------------------------------
-// Conversione di SelData da e verso stringhe
+// Conversione di SelData da e verso stringhe (Id,Sub)
 inline bool FromString( const std::string& sVal, SelData& Val)
      { return FromString( sVal, Val.v) ; }
 inline const std::string ToString( const SelData& Val, int nPrec = 1)
      { return ToString( Val.v, nPrec) ; }

 //----------------------------------------------------------------------------
-// Conversione di vettori di SelData da e verso stringhe
+// Conversione di SelData da e verso stringhe utente (Id:Sub oppure Id)
+inline bool FromUiString( const std::string& sVal, SelData& Val)
+      { std::string sId , sSub ;
+        SplitFirst( sVal, ":", sId, sSub) ;
+        Val = { GDB_ID_NULL, SEL_SUB_ALL} ;
+        FromString( sSub, Val.nSub) ;
+        return FromString( sId, Val.nId) ; }
+inline const std::string ToUiString( const SelData& Val, int nPrec = 1)
+      { if ( Val.nSub != SEL_SUB_ALL)
+           return ToString( Val.nId, nPrec) + ":" + ToString( Val.nSub, nPrec) ;
+        else
+           return ToString( Val.nId, nPrec) ; }
+
+//----------------------------------------------------------------------------
+// Conversione di vettori di SelData da e verso stringhe (Id1,Sub1,Id2,Sub2,...)
 inline bool FromString( const std::string& sVal, SELVECTOR& vVal)
      { INTVECTOR vI ;
        if ( ! FromString( sVal, vI)  ||  ( vI.size() % 2) != 0)
@@ -69,3 +83,23 @@ inline const std::string ToString( const SELVECTOR& vVal, int nPrec = 1)
        if ( ! sDest.empty())
           sDest.pop_back() ;
        return sDest ; }
+
+//----------------------------------------------------------------------------
+// Conversione di vettori di SelData da e verso stringhe utente (Id1:Sub1,Id2,...)
+inline bool FromUiString( const std::string& sVal, SELVECTOR& vVal)
+      { STRVECTOR vsTokens ;
+        Tokenize( sVal, ",", vsTokens) ;
+        vVal.reserve( vsTokens.size()) ;
+        for ( const auto& sToken : vsTokens) {
+           SelData Val ;
+           if ( FromUiString( sToken, Val))
+              vVal.emplace_back( Val) ;
+        }
+        return true ; }
+inline const std::string ToUiString( const SELVECTOR& vVal, int nPrec = 1)
+      { std::string sDest ; sDest.reserve( 2 * 8 * vVal.size()) ;
+        for ( const auto& Val : vVal)
+           sDest += ToUiString( Val, nPrec) + "," ;
+        if ( ! sDest.empty())
+           sDest.pop_back() ;
+        return sDest ; }
@@ -48,3 +48,5 @@ EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ISurfFlatRegion* pSfrSect, c
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshTransSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRuled( const Point3d& ptP, const ICurve* pCurve, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfTriMesh* GetSurfExtension( const ISurfTriMesh* pSrfTM, double dExtLen, int nLoop, int nSubCrv, int nType, double dLinTol) ;
+EGK_EXPORT ISurfTriMesh* GetSurfExtensionFromMany( CISURFPVECTOR vpSurf, double dExtLen, const ICurve* pCrv, ICurve*& pOffEdge, int nType, double dLinTol) ;
@@ -102,6 +102,10 @@ class __declspec( novtable) ISurfBezier : public ISurf
      virtual bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) = 0 ;
      virtual bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3 = true) = 0 ;
      virtual bool RemoveCollapsedSpans() = 0 ;
+      virtual PNTVECTOR GetAllControlPoints( void) const = 0 ;
+      virtual bool LimitSurfToTrimmedRegion( void) = 0 ;
+      virtual bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen) = 0 ;
+      virtual bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen, BIPNTVECTOR& vSyncLines) = 0 ;
 } ;

 //-----------------------------------------------------------------------------
@@ -52,7 +52,8 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
      virtual bool GetChunkCentroid( int nChunk, Point3d& ptCen) const = 0 ;
      virtual bool GetChunkArea( int nChunk, double& dArea) const = 0 ;
      virtual bool GetChunkPerimeter( int nChunk, double& dLen) const = 0 ;
-      virtual int  GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion& Other, int nOthChunk) const ;   // compare only outsides
+      virtual int  GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion& Other, int nOthChunk) const = 0 ;   // compare only outsides
+      virtual bool CheckChunkInterference( int nChunk, const ISurfFlatRegion& Other, int nOthChunk, bool& bInterference) const = 0 ;
      virtual bool GetChunkMaxOffset( int nChunk, double& dOffs) const = 0 ;
      virtual int  GetLoopCount( int nChunk) const = 0 ;
      virtual int  GetLoopCurveCount( int nChunk, int nLoop) const = 0 ;
@@ -23,7 +23,7 @@ class SurfLocal
      SurfLocal( IGeomDB* pGeomDB, int nSrfId, const Frame3d& frLoc)
         : m_pSrf( nullptr), m_pCopy( nullptr)
         { // verifica dei parametri
-            if ( pGeomDB == nullptr  ||  &frLoc == nullptr)
+            if ( pGeomDB == nullptr)
               return ;
           // recupero riferimento della superficie
            Frame3d frSrf ;
@@ -48,7 +48,7 @@ class SurfLocal
      SurfLocal( const ISurf* pSurf, const Frame3d& frSrf, const Frame3d& frLoc)
         : m_pSrf( nullptr), m_pCopy( nullptr)
         { // verifica dei parametri
-            if ( pSurf == nullptr  ||  &frSrf == nullptr  ||  &frLoc == nullptr)
+            if ( pSurf == nullptr)
               return ;
           // assegno la superficie originale
            m_pSrf = pSurf ;
@@ -76,7 +76,7 @@ class SurfLocal
               return ;
            m_pSrf = m_pCopy ;
         }
-      SurfLocal( SurfLocal&& Other)
+      SurfLocal( SurfLocal&& Other) noexcept
         : m_pSrf( Other.m_pSrf), m_pCopy( Other.m_pCopy)
         { // annullo gli originali
            Other.m_pSrf = nullptr ;
@@ -88,8 +88,8 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
      virtual bool GetTriangleSmoothNormals( int nId, TriNormals3d& TNrms) const = 0 ;
      virtual ISurfTriMesh* CloneTriangle( int nTria) const = 0 ;
      virtual bool GetLoops( POLYLINEVECTOR& vPL) const = 0 ;
-      virtual bool GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const = 0 ;
-      virtual bool GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const = 0 ;
+      virtual bool GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false, double dLinTol = 100. * EPS_SMALL) const = 0 ;
+      virtual bool GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false, double dLinTol = 100. * EPS_SMALL) const = 0 ;
      virtual int  GetFacetCount( void) const = 0 ;
      virtual int  GetFacetSize( void) const = 0 ;
      virtual int  GetFacetFromTria( int nT) const = 0 ;
@@ -138,6 +138,7 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
      virtual bool GetPartLoops( int nPart, POLYLINEVECTOR& vPL) const = 0 ;
      virtual bool RemovePart( int nPart) = 0 ;
      virtual ISurfTriMesh* ClonePart( int nPart) const = 0 ;
+      virtual bool GetPartAndShellFromFacet( int nFacet, int& nPart, int& nShell) const = 0 ;
      virtual bool SetTFlag( int nId, int nTFlag) = 0 ;
      virtual bool GetTFlag( int nId, int& nFlag) const = 0 ;
      virtual int  GetMaxTFlag( void) const = 0 ;
@@ -30,6 +30,9 @@
 typedef std::vector<ISURFPOVECTOR> ISURFPOMATRIX ;
 typedef std::vector<ICRVCOMPOPOVECTOR> ICRVCOMPOPOMATRIX ;

+enum RegolarizeType { STD = 0,  // standard, con modifiche dirette ai punti di controllo
+                      RMF = 1}; // ricostruendo le curve usando il rotation minimizing frame
+
 //-----------------------------------------------------------------------------
 EGK_EXPORT bool GetTrimmingStmAdjTria( const ISurfTriMesh* pStm, int nStartTria, const Point3d& ptStartTria,
                                       double dAngTol, double dSize, double dSizeTol, ISurfTriMesh* pStmAdjTria) ;
@@ -56,3 +59,5 @@ EGK_EXPORT bool GetTrimmingSyncInterpolation( const ICurve* pCrvEdge1, const ICu
 EGK_EXPORT bool GetTrimmingHoleBorders( const CISURFPVECTOR& vpSurf, const Point3d& ptRef, double dSurfLinTol,
                                        double dSurfAngTol, double dEdgeLinTol, double dEdgeAngTol,
                                        double dEdgeThick, ICRVCOMPOPOVECTOR& vHoleBorders) ;
+EGK_EXPORT ISurfBezier* RegolarizeBordersLocally( const ISurfBezier* pSurfBz, const BIPOINT& bpIsoStart,
+                                                  const BIPOINT& bpIsoEnd, double dTol, int nType = RegolarizeType::STD) ;
@@ -29,10 +29,10 @@ class __declspec( novtable) IVolZmap : public IGeoObj
   public :
      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
      virtual bool Clear( void) = 0 ;
-      virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) = 0 ;
-      virtual bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) = 0 ;
-      virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) = 0 ;
-      virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0) = 0 ;
+      virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) = 0 ;
+      virtual bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) = 0 ;
+      virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) = 0 ;
+      virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0, int* nError = nullptr, bool bForceClosed = false) = 0 ;
      virtual int  GetBlockCount( void) const = 0 ;
      virtual int  GetBlockUpdatingCounter( int nBlock) const = 0 ;
      virtual bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const = 0 ;
@@ -94,6 +94,7 @@ class __declspec( novtable) IVolZmap : public IGeoObj
      virtual bool AddSurfTm( const ISurfTriMesh* pStm) = 0 ;
      virtual bool SubtractSurfTm( const ISurfTriMesh* pStm) = 0 ;
      virtual bool MakeUniform( double dToler, bool bIsExtensionFirst = true, int nToolNum = 0) = 0 ;
+      virtual bool RemoveFins( const Vector3d& vtDir, double dThick) = 0 ;
      virtual bool Offset( double dOffs, int nType) = 0 ;
 } ;

@@ -297,6 +297,8 @@ EIN_EXPORT int  __stdcall EgtCreatePolygonFromApothem( int nParentId, int nNumSi
                                                       const double ptMid[3], int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreatePolygonFromSide( int nParentId, int nNumSides, const double ptIni[3],
                                                    const double ptFin[3], int nRefType) ;
+EIN_EXPORT int  __stdcall EgtSurfBezierGetCurveU( int nSurfId, double dU, int nDestGroup) ;
+EIN_EXPORT int  __stdcall EgtSurfBezierGetCurveV( int nSurfId, double dV, int nDestGroup) ;

 // GeomDB Create Surf
 EIN_EXPORT int  __stdcall EgtCreateSurfFrRectangle( int nParentId, const double ptIni[3], const double ptCross[3], int nRefType) ;
@@ -634,6 +636,9 @@ EIN_EXPORT int  __stdcall EgtExtractSurfTmLoops( int nId, int nDestGrpId, int* p
 EIN_EXPORT int  __stdcall EgtExtractSurfTmFacetLoops( int nId, int nFacet, int nDestGrpId, int* pnCount) ;
 EIN_EXPORT int  __stdcall EgtCopySurfTmFacet( int nId, int nFacet, int nDestGrpId) ;
 EIN_EXPORT int  __stdcall EgtExtractSurfTmTriaLoop( int nId, int nT, int nDestGrpId) ;
+EIN_EXPORT BOOL __stdcall EgtSurfBezierParamsFromPoint( int nSurfId, const double ptOnSurf[3], int nRefId, double* pdU, double* pdV) ;
+EIN_EXPORT BOOL __stdcall EgtSurfBezierGetPointNrmD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
+                                                      double ptP[3], double vtNorm[3], double vtDerU[3], double vtDerV[3]) ;
 EIN_EXPORT int  __stdcall EgtExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount) ;

 // Geo Snap Vector/Point/Frame
@@ -945,6 +950,7 @@ EIN_EXPORT BOOL __stdcall EgtSetMachiningGeometry( int nNumId, const int nIds[],
 EIN_EXPORT BOOL __stdcall EgtPreviewMachining( BOOL bRecalc) ;
 EIN_EXPORT BOOL __stdcall EgtApplyMachining( BOOL bRecalc) ;
 EIN_EXPORT BOOL __stdcall EgtUpdateMachining( void) ;
+EIN_EXPORT BOOL __stdcall EgtChangePreviewMachiningToolShow( int nLookFlag) ;
 EIN_EXPORT BOOL __stdcall EgtPreparePreviewMachiningTool( void) ;
 EIN_EXPORT BOOL __stdcall EgtRemovePreviewMachiningTool( void) ;
 EIN_EXPORT int  __stdcall EgtGetPreviewMachiningToolStepCount( void) ;
@@ -1030,6 +1036,7 @@ EIN_EXPORT BOOL __stdcall EgtSetGridGeoAdv( double dSnapStep, int nMinLineSstep,
 EIN_EXPORT BOOL __stdcall EgtSetGridColor( const int nMinCol[4], const int nMajCol[4]) ;
 EIN_EXPORT BOOL __stdcall EgtResize( int nW, int nH) ;
 EIN_EXPORT BOOL __stdcall EgtDraw( void) ;
+EIN_EXPORT BOOL __stdcall EgtRedraw( void) ;
 EIN_EXPORT BOOL __stdcall EgtSelect( int nWinX, int nWinY, int nSelW, int nSelH, int* pnSel) ;
 EIN_EXPORT BOOL __stdcall EgtSetObjFilterForSelWin( BOOL bZerodim, BOOL bCurve, BOOL bSurf, BOOL bVolume, BOOL bExtra) ;
 EIN_EXPORT BOOL __stdcall EgtUnselectableAdd( int nId) ;
@@ -85,6 +85,7 @@ class __declspec( novtable) IMachMgr
      virtual int  GetNextRawPart( int nId) const = 0 ;
      virtual bool IsRawPart( int nId) const = 0 ;
      virtual int  AddRawPart( const Point3d& ptOrig, double dLen, double dWidth, double dHeight, Color cCol) = 0 ;
+      virtual int  AddRawPart( int nCrvSrfId, double dOverMat, Color cCol) = 0 ;
      virtual int  AddRawPartWithPart( int nPartId, int nCrvSrfId, double dOverMat, Color cCol) = 0 ;
      virtual bool ModifyRawPart( int nRawId, const Point3d& ptOrig, double dLen, double dWidth, double dHeight, Color cCol) = 0 ;
      virtual bool ModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dHeight, Color cCol) = 0 ;
@@ -266,6 +267,7 @@ class __declspec( novtable) IMachMgr
      virtual bool RemoveMachiningPreview( void) = 0 ;
      virtual bool MachiningApply( bool bRecalc, bool bPostApply = true) = 0 ;
      virtual bool MachiningUpdate( bool bPostApply = true) = 0 ;
+      virtual bool ChangePreviewMachiningToolShow( int nLookFlag) = 0 ;
      virtual bool PreparePreviewMachiningTool( void) const = 0 ;
      virtual bool RemovePreviewMachiningTool( void) const = 0 ;
      virtual int  GetPreviewMachiningToolStepCount( void) const = 0 ; 
@@ -289,6 +291,9 @@ class __declspec( novtable) IMachMgr
      virtual bool GetClEntAxesStatus( int nEntId, int& nStatus) const = 0 ;
      virtual bool GetClEntAxesMask( int nEntId, int& nMask) const = 0 ;
      virtual bool GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const = 0 ;
+      virtual bool GetClEntTDir( int nEntId, Vector3d& vtTDir) const = 0 ;
+      virtual bool GetClEntCDir( int nEntId, Vector3d& vtCDir) const = 0 ;
+      virtual bool GetClEntADir( int nEntId, Vector3d& vtADir) const = 0 ;
     // Simulation
      virtual bool SimInit( void) = 0 ;
      virtual bool SimStart( bool bFirst) = 0 ;
@@ -336,6 +341,7 @@ class __declspec( novtable) IMachMgr
      virtual bool GetNearestAngleInStroke( int nInd, double dAngRef, double& dAng) const = 0 ;
      virtual bool LimitAngleToStroke( int nInd, double& dAng) const = 0 ;
      virtual bool VerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) const = 0 ;
+      virtual bool VerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, bool bClear, int& nStat) const = 0 ;
      virtual std::string GetOutstrokeInfo( bool bMM = true) const = 0 ;
     // Machine
      virtual int  GetBaseId( const std::string& sBase) const = 0 ;
@@ -301,12 +301,10 @@ enum { SAWROU_HS_LEFT = 1,
       SAWROU_HS_RIGHT = 2} ;
 // Tipo di lavorazione a step
 enum { SAWROU_ST_ZIGZAG = 0,
-       SAWROU_ST_ONEWAY = 1,
-       SAWROU_ST_ZCONST = 2} ;
+       SAWROU_ST_ONEWAY = 1} ;
 // Tipo di attacco/uscita/link
 enum { SAWROU_LL_CENT = 0,
-       SAWROU_LL_OUT = 1,
-       SAWROU_LL_INT = 2} ;
+       SAWROU_LL_OUT = 1} ;

 //----------------------------------------------------------------------------
 // Parametri per finitura con lama
@@ -318,7 +316,9 @@ enum { SAWFIN_ST_ZIGZAG = 0,
       SAWFIN_ST_ONEWAY = 1} ;
 // Sottotipo di lavorazione
 enum { SAWFIN_SUB_ALONG = 0,
-       SAWFIN_SUB_ACROSS = 1} ;
+       SAWFIN_SUB_ACROSS = 1,
+       SAWFIN_SUB_ALONG_5A = 2,
+       SAWFIN_SUB_SECTION = 3} ;
 // Tipo di attacco/uscita/link
 enum { SAWFIN_LL_STD = 0,
       SAWFIN_LL_CENT = 1,
@@ -27,7 +27,7 @@ static std::string KEY_NUM = "NUM" ;
 // Chiave per stato di aggiornamento di lavorazione
 static std::string KEY_STAT = "STAT" ;
 // Chiave per elenco identificativi non lavorati
-static std::string KEY_SKIPS = "SKIPS" ; 
+static std::string KEY_SKIPS = "SKIPS" ;
 // Sottogruppi delle lavorazioni
 static std::string MCH_AUX = "AUX" ;
 static std::string MCH_AUXVIEW = "AVIEW" ;
@@ -37,6 +37,7 @@ static std::string MCH_ST = "ST" ;
 static std::string MCH_ST_DBL = "STDBL" ;
 static std::string MCH_CL = "CL" ;
 static std::string MCH_DBL = "DBL" ;
+static std::string MCH_HOME = "HOME" ;
 static std::string MCH_PATH = "P" ;
 // Nomi di entità CL speciali
 static std::string MCH_CL_CLIMB = "CLIMB" ;
@@ -50,7 +51,7 @@ static std::string MCH_CL_AGB_DWN = "AGBD" ;
 static std::string MCH_CL_AGB_IN = "AGBI" ;
 static std::string MCH_CL_AGB_OUT = "AGBO" ;
 static std::string MCH_CL_AGB_UP = "AGBU" ;
-static std::string MCH_CL_DBP = "DBP" ;
+static std::string MCH_CL_PARALLEL_DBL = "DBP" ;
 // Nomi di entità di preview
 static std::string MCH_PV_CUT = "CUT" ;
 static std::string MCH_PV_PRE_CUT = "PRC" ;
@@ -114,6 +115,8 @@ static std::string KEY_MMAX = "MMAX" ;
 // Chiavi info in gruppo CL per punti assi minimo e massimo di ingombro di tutta la lavorazione
 static std::string KEY_MAXMIN = "MAXMIN" ;
 static std::string KEY_MAXMAX = "MAXMAX" ;
+// Chiave info in gruppo CL per indicare il tipo di catena cinematica
+static std::string KEY_KINTYPE = "KINTYPE" ;
 // Chiave info in sottogruppo di CL per uscite attivate (per forature con gang drill)
 static std::string KEY_DRACEX = "DRACEX" ;
 // Chiave info in sottogruppo di testa per abilitarne visualizzazione in Preview (0/1 default) 
@@ -351,6 +351,9 @@ EXE_EXPORT int  ExeCreatePolygonFromSide( int nParentId, int nNumSides, const Po
                                          const Point3d& ptFin, int nRefType) ;
 EXE_EXPORT int  ExeCreateCirclesAlongCurve( int nParentId, int nCrvId, double dOffset, double dOverlap,
                                            double dStartAdd, double dEndAdd, double dDiam, int* pnCount) ;
+EXE_EXPORT int  ExeOffsetCurveAdv( int nId, double dDist, int nType, int* pnCount, double dLinTol = 10 * EPS_SMALL) ;
+EXE_EXPORT int  ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, bool bSquareMids, int* pnCount) ;
+EXE_EXPORT int  ExeOffsetCurve3d( int nId, int nSurfId, double dDist, int nType, int* pnCount, double dLinTol = 10 * EPS_SMALL) ;

 // GeomDB Create Surf
 EXE_EXPORT int  ExeCreateSurfFlatRegion( int nParentId, const INTVECTOR& vCrvIds, int* pnCount) ;
@@ -429,6 +432,10 @@ EXE_EXPORT int  ExeCreateSurfBzRuledGuided( int nParentId, int nCrvId1, int nCrv
 EXE_EXPORT int  ExeCreateSurfBzSkinned( int nParentId, const INTVECTOR& nCrvId1, bool bCapEnds, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfBzSwept( int nParentId, int nSectId, int nGuideId, const Vector3d& vtAx,
                                      bool bCapEnds, double dLinTol, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfExtension( int nParentId, int nSurfId, double dExtLen, int nCrv, int nSubCrv,
+                                        int nType, double dLinTol) ;
+EXE_EXPORT int  ExeCreateSurfExtensionFromMany( int nParentId, const INTVECTOR& vSurfId, double dExtLen, int nCrvId,
+                                                bool bDrawOffEdge, int* pnCount, int nType, double dLinTol) ;

 // GeomDB Create Volume
 EXE_EXPORT int  ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX,
@@ -436,7 +443,7 @@ EXE_EXPORT int  ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dD
 EXE_EXPORT int  ExeCreateVolZmapEmpty( int nParentId, const Point3d& ptIni, double dDimX,
                                       double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
 EXE_EXPORT int  ExeCreateVolZmapByRegionExtrusion( int nParentId, int nSfrId, double dDimZ, double dPrec, bool bTriDex) ;
-EXE_EXPORT int  ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDex, double dExtraBox = 0) ;
+EXE_EXPORT int  ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDex, double dExtraBox = 0, bool bForceClosed = false) ;

 // GeomDB PartLayer
 EXE_EXPORT bool ExeIsPart( int nPartId) ;
@@ -571,6 +578,7 @@ EXE_EXPORT bool ExeGetInfo( int nId, const std::string& sKey, STRVECTOR& vsInfo)
 EXE_EXPORT bool ExeExistsInfo( int nId, const std::string& sKey) ;
 EXE_EXPORT bool ExeRemoveInfo( int nId, const std::string& sKey) ;
 EXE_EXPORT bool ExeGetAllInfo( int nId, STRVECTOR& vsInfo) ;
+EXE_EXPORT bool ExeCopyAllInfoFrom( int nId, int nSouId) ;
 EXE_EXPORT bool ExeSetTextureName( int nId, const std::string& sTxrName) ;
 EXE_EXPORT bool ExeSetTextureFrame( int nId, const Frame3d& frTxrRef, int nRefType) ;
 EXE_EXPORT bool ExeRemoveTextureData( int nId) ;
@@ -612,8 +620,6 @@ EXE_EXPORT int  ExeSplitText( int nId, int* pnCount) ;
 // GeomDb Curve Modify
 EXE_EXPORT bool ExeInvertCurve( const INTVECTOR& vIds) ;
 EXE_EXPORT bool ExeOffsetCurve( int nId, double dDist, int nType) ;
-EXE_EXPORT int  ExeOffsetCurveAdv( int nId, double dDist, int nType, int* pnCount, double dLinTol = 10 * EPS_SMALL) ;
-EXE_EXPORT int  ExeCurveMedialAxis( int nId) ;
 EXE_EXPORT bool ExeApproxCurve( int nId, int nApprType, double dLinTol, double dMaxSegmLen = INFINITO) ;
 EXE_EXPORT bool ExeProjectCurveOnPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, int nRefType) ;
 EXE_EXPORT bool ExeChangeClosedCurveStart( int nId, double dU) ;
@@ -667,17 +673,14 @@ EXE_EXPORT bool ExeMergeCurvesInCurveCompo( int nId, double dLinTol, bool bStart
 EXE_EXPORT bool ExeRemoveCurveCompoUndercutOnY( int nId, double dLinTol) ;
 EXE_EXPORT bool ExeCurveCompoSetTempProp( int nId, int nCrv, int nProp, int nPropInd = 0) ;
 EXE_EXPORT bool ExeCurveCompoSetTempParam( int nId, int nCrv, double dParam, int nParamInd = 0) ;
-EXE_EXPORT bool ExeChainCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType) ;
-EXE_EXPORT bool ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType) ;
+EXE_EXPORT bool ExeChainCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType, double dToler = 10 * EPS_SMALL) ;
+EXE_EXPORT bool ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType, double dToler = 10 * EPS_SMALL) ;
 EXE_EXPORT bool ExeProjectCurveOnSurf( int nCurveId, const INTVECTOR& vnSurfId, int nDestGrpId,
                                       double dLinTol, double dMaxSegmLen) ;
 EXE_EXPORT bool ExeProjectCurveOnSurfDir( int nCurveId, const INTVECTOR& vnSurfId, const Vector3d& vtProj, int nDestGrpId,
-                                          double dLinTol, double dMaxSegmLen, bool bDirFromProj, int nRefType) ;
+                                          double dLinTol, double dMaxSegmLen, bool bDirFromProj, bool bFromVsTo, int nRefType) ;
 EXE_EXPORT bool ExeProjectCurveOnSurfExt( int nCurveId, const INTVECTOR& vnSurfId, int nGuideId, int nDestGrpId,
-                                          double dLinTol, double dMaxSegmLen, bool bDirFromGuide) ;
-EXE_EXPORT int  ExeCurveGetVoronoi( const INTVECTOR& vIds, int nDestGrpId, int nBound, int* pnCount) ;
-EXE_EXPORT int  ExeCurveGetMedialAxis( const INTVECTOR& vIds, int nDestGrpId, int nSide, int* pnCount) ;
-EXE_EXPORT int  ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, bool bSquareMids, int* pnCount) ;
+                                          double dLinTol, double dMaxSegmLen, bool bDirFromGuide, bool bFromVsTo) ;
 EXE_EXPORT bool ExeCurveBezierIncreaseDegree( int nCrvId) ;
 EXE_EXPORT bool ExeCurveBezierDecreaseDegree( int nCrvId, double dTol = 100) ;
 EXE_EXPORT bool ExeCurveBezierApproxToNonRat( int nCrvId, double dTol = 10 * EPS_SMALL) ;
@@ -702,7 +705,6 @@ EXE_EXPORT bool ExeSurfTmRemoveFacet( int nId, int nFacet) ;
 EXE_EXPORT bool ExeSurfTmSwapFacets( int nId, int nFacet1, int nFacet2) ;
 EXE_EXPORT bool ExeSurfTmRemovePart( int nId, int nPart) ;
 EXE_EXPORT bool ExeCutSurfTmPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
-EXE_EXPORT bool ExeCutSurfBzPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
 EXE_EXPORT bool ExeCutSurfTmClosedCurve( int nSurfId, int nCurveId, bool bSaveOnEq) ;
 EXE_EXPORT bool ExeSurfTmAdd( int nId1, int nId2, bool bTwoColors = false) ;
 EXE_EXPORT bool ExeSurfTmSubtract( int nId1, int nId2, bool bTwoColors = false) ;
@@ -717,13 +719,16 @@ EXE_EXPORT bool ExeSurfTmGetTriaColor( int nId, int nTria, int& nColor) ;
 EXE_EXPORT bool ExeSurfTmResetTwoColors( int nId) ;
 EXE_EXPORT bool ExeSurfTmSetShowEdges( int nId, bool bShow) ;
 EXE_EXPORT bool ExeSurfTmGetShowEdges( int nId, bool& bShow) ;
-EXE_EXPORT bool ExeSurfBzTrim( int nId, int nCutterId) ;
 EXE_EXPORT bool ExeSurfTmSetSmoothAng( int nId, double dAngDeg) ;
+EXE_EXPORT bool ExeSurfTmGetSmoothAng( int nId, double& dAngDeg) ;
+EXE_EXPORT bool ExeCutSurfBzPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
+EXE_EXPORT bool ExeSurfBzTrim( int nId, int nCutterId) ;

 // GeomDb Volume Modify
 EXE_EXPORT int  ExeExplodeVolume( int nId, int* pnCount) ;
 EXE_EXPORT bool ExeVolZmapChangeResolution( int nId, int nNewRes) ;
 EXE_EXPORT bool ExeVolZmapSetShowEdges( int nId, bool bShow) ;
+EXE_EXPORT bool ExeVolZmapGetShowEdges( int nId, bool& bShow) ;
 EXE_EXPORT bool ExeRemoveVolZmapPart( int nId, int nPart) ;
 EXE_EXPORT bool ExeVolZmapSetStdTool( const INTVECTOR& vIds, const std::string& sToolName,
                                      double dLen, double dDiam, double dCornR, double dCutterH, int nFlag, bool bFirst) ;
@@ -746,8 +751,9 @@ EXE_EXPORT bool ExeVolZmapMillingStep( int nId, const Point3d& ptPs, const Vecto
                                                const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe, int nRefType) ;
 EXE_EXPORT bool ExeCutVolZmapPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, int nRefType) ;
 EXE_EXPORT bool ExeUpdateVolZmapByAddingSurfTm( int nVolZmapId, int nStmId) ;
-EXE_EXPORT bool ExeUniformVolZmap( int nVolZmapId, double dToler, bool bExtensionFirst, int nToolNum) ;
+EXE_EXPORT bool ExeVolZmapMakeUniform( int nVolZmapId, double dToler, bool bExtensionFirst, int nToolNum) ;
 EXE_EXPORT bool ExeVolZMapOffset( int nId, double dDist, int nType) ;
+EXE_EXPORT bool ExeVolZMapRemoveFins( int nVolZMapId, const Vector3d& vtDir, double dThick, int nRefType) ;

 // GeomDB Get
 EXE_EXPORT bool ExeTextNormVersor( int nId, int nRefId, Vector3d& vtNorm) ;
@@ -757,7 +763,7 @@ EXE_EXPORT bool ExeTextGetHeight( int nId, double& dH) ;
 EXE_EXPORT bool ExeTextGetItalic( int nId, bool& bItl) ;

 // GeomDb Get Pocketing
-EXE_EXPORT bool ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId, int& nFirstId, int& nCrvCount) ;
+EXE_EXPORT bool ExePocketing( int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId, int& nFirstId, int& nCrvCount) ;
 EXE_EXPORT int  ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, bool bRemoveOverlapLink,int* pnCount) ;

 // GeomDb Curve Get
@@ -796,6 +802,9 @@ EXE_EXPORT bool ExeCurveCompoGetTempParam( int nId, DBLVECTOR& vParam, int nPara
 EXE_EXPORT int  ExeShowCurveBezierControlPoints( int nCrvId, int nDestGrpId, int* pnCount) ;
 EXE_EXPORT int  ExeCopyCompoSubCurve( int nCrvId, int nSubCrvToCopy, int nDestGrpId) ;
 EXE_EXPORT int  ExeCopyParamRange( int nCrvId, double dUStart, double dUEnd, int nDestGrpId) ;
+EXE_EXPORT int  ExeCurveGetVoronoi( const INTVECTOR& vIds, int nDestGrpId, int nBound, int* pnCount) ;
+EXE_EXPORT int  ExeCurveMedialAxis( int nId) ;
+EXE_EXPORT int  ExeCurveGetMedialAxis( const INTVECTOR& vIds, int nDestGrpId, int nSide, int* pnCount) ;

 // GeomDb Surf Get
 EXE_EXPORT bool ExeSurfArea( int nId, double& dArea) ;
@@ -807,12 +816,14 @@ EXE_EXPORT bool ExeSurfFrChunkMaxOffset( int nId, int nChunk, double& dMaxOffset
 EXE_EXPORT bool ExeSurfFrTestExternal( int nId1, int nId2, double dMinDist) ;
 EXE_EXPORT int  ExeSurfFrChunkCount( int nId) ;
 EXE_EXPORT int  ExeSurfFrChunkSimpleClassify( int nId1, int nChunk1, int nId2, int nChunk2, double dToler = 0) ;
+EXE_EXPORT int  ExeSurfFlatRegionInterference( int nId1, int nChunk1, int nId2, int nChunk2, double dToler = 0) ;
 EXE_EXPORT bool ExeSurfFrChunkCenter( int nId, int nChunk, int nRefId, Point3d& ptCen, Vector3d& vtN) ;
 EXE_EXPORT int  ExeExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount) ;
 EXE_EXPORT int  ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, int* pnCount) ;
 EXE_EXPORT int  ExeSurfTmVertexCount( int nId) ;
 EXE_EXPORT int  ExeSurfTmFacetCount( int nId) ;
 EXE_EXPORT int  ExeSurfTmPartCount( int nId) ;
+EXE_EXPORT bool ExeSurfTmGetPartAndShellFromFacet( int nSurfTm, int nFacet, int& nPart, int& nShell) ;
 EXE_EXPORT bool ExeSurfTmGetVertex( int nId, int nVert, int nRefId, Point3d& ptVert) ;
 EXE_EXPORT bool ExeSurfTmGetNearestVertex( int nId, const Point3d& ptNear, int nRefId, int& nVert, Point3d& ptVert) ;
 EXE_EXPORT bool ExeSurfTmTriangleNormVersor( int nId, int nTria, int nRefId, Vector3d& vtNorm) ;
@@ -853,10 +864,10 @@ EXE_EXPORT bool ExeSurfBezierGetPointD1( int nSurfId, double dU, double dV, int
                                         Point3d& ptP, Vector3d& vtDerU, Vector3d& vtDerV) ;
 EXE_EXPORT bool ExeSurfBezierGetPointNrmD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
                                            Point3d& ptP, Vector3d& vtN, Vector3d& vtDerU, Vector3d& vtDerV) ;
+EXE_EXPORT bool ExeSurfBezierParamsFromPoint( int nSurfId, const Point3d& ptOnSurf, int nRefId, double& dU, double& dV) ;
+EXE_EXPORT bool ExeSurfBezierGetInfo( int nSurfId, int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) ;
 EXE_EXPORT int  ExeSurfBezierGetCurveU( int nSurfId, double dV, int nDestGrpId) ;
 EXE_EXPORT int  ExeSurfBezierGetCurveV( int nSurfId, double dU, int nDestGrpId) ;
-EXE_EXPORT bool ExeSurfBezParamsFromPoint( int nSurfId, const Point3d& ptOnSurf, int nDestGrpId) ;
-EXE_EXPORT bool ExeSurfBezierGetInfo( int nSurfId, int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) ;
 EXE_EXPORT int  ExeSurfBezierGetControlCurveU( int nSurfId, int nIndV, int nDestGrpId) ;
 EXE_EXPORT int  ExeSurfBezierGetControlCurveV( int nSurfId, int nIndU, int nDestGrpId) ;
 EXE_EXPORT int  ExeExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount) ;
@@ -922,7 +933,7 @@ EXE_EXPORT bool ExePointSurfBzDist( const Point3d& ptP, int nSbzId, int nRefType
                                    double* pdDist, Point3d& ptMin, Vector3d& vtN) ;
 
 // Geo Intersect
-EXE_EXPORT bool ExeLineCurveInters( const Point3d& ptP, const Vector3d& vtDir, const int nId, const int nRefType,
+EXE_EXPORT bool ExeLineCurveInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
                                    INTDBLVECTOR& vInters) ;
 EXE_EXPORT bool ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, const BBox3d& b3Box,
                                  INTDBLVECTOR& vInters) ;
@@ -932,7 +943,7 @@ EXE_EXPORT bool ExeLineSurfBzInters( const Point3d& ptP, const Vector3d& vtDir,
                                     INTDBLVECTOR& vInters) ;
 EXE_EXPORT bool ExeLineVolZmapInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
                                      INTDBLVECTOR& vInters) ;
-EXE_EXPORT int  ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, const int nId, const int nDestGrpId, const int nRefType,
+EXE_EXPORT int  ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType,
                                     int* pnCount) ;
 EXE_EXPORT int  ExePlaneBoxInters( const Point3d& ptOn, const Vector3d& vtN, const BBox3d& b3Box, int nDestGrpId, int nRefType,
                                   int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
@@ -942,9 +953,9 @@ EXE_EXPORT int  ExeParPlanesSurfTmInters( const Point3d& ptOn, const Vector3d& v
                                          int* pnGrpCount) ;
 EXE_EXPORT int  ExePlaneVolZmapInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType,
                                       int* pnCount) ;
-EXE_EXPORT int  ExeCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId,
+EXE_EXPORT int  ExeCurveCurveInters( int nId1, int nId2, int nDestGrpId,
                                     int* pnPntCount, int* pnCrvCount, bool bOnly3D = false) ;
-EXE_EXPORT int  ExeCurveSurfTmInters( const int nCrvId, const int nStmId, const int nDestGrpId,
+EXE_EXPORT int  ExeCurveSurfTmInters( int nCrvId, int nStmId, int nDestGrpId,
                                      int* pnPntCount, int* pnCrvCount) ;
 EXE_EXPORT int  ExeSurfTmSurfTmInters( int nId1, int nId2, int nDestGrpId, double dToler,
                                       int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
@@ -1092,7 +1103,8 @@ EXE_EXPORT int  ExeGetFirstRawPart( void) ;
 EXE_EXPORT int  ExeGetNextRawPart( int nRawId) ;
 EXE_EXPORT bool ExeIsRawPart( int nRawId) ;
 EXE_EXPORT int  ExeAddRawPart( Point3d ptOrig, double dLength, double dWidth, double dHeight, Color cCol) ;
-EXE_EXPORT int  ExeAddRawPartWithPart( int nPartId, int nCrvId, double dOverMat, Color cCol) ;
+EXE_EXPORT int  ExeAddRawPartGen( int nCrvSrfId, double dOverMat, Color cCol) ;
+EXE_EXPORT int  ExeAddRawPartWithPart( int nPartId, int nCrvSrfId, double dOverMat, Color cCol) ;
 EXE_EXPORT bool ExeModifyRawPart( int nRawId, Point3d ptOrig, double dLength, double dWidth, double dHeight, Color cCol) ;
 EXE_EXPORT bool ExeModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dHeight, Color cCol) ;
 EXE_EXPORT bool ExeModifyRawPartSize( int nRawId, double dLength, double dWidth, double dHeight) ;
@@ -1270,6 +1282,7 @@ EXE_EXPORT bool ExeSetMachiningGeometry( const SELVECTOR& vIds) ;
 EXE_EXPORT bool ExePreviewMachining( bool bRecalc) ;
 EXE_EXPORT bool ExeApplyMachining( bool bRecalc, bool bPostApply = true) ;
 EXE_EXPORT bool ExeUpdateMachining( bool bPostApply = true) ;
+EXE_EXPORT bool ExeChangePreviewMachiningToolShow( int nLookFlag) ;
 EXE_EXPORT bool ExePreparePreviewMachiningTool( void) ;
 EXE_EXPORT bool ExeRemovePreviewMachiningTool( void) ;
 EXE_EXPORT int  ExeGetPreviewMachiningToolStepCount( void) ;
@@ -1297,7 +1310,9 @@ EXE_EXPORT bool ExeGetClEntFeed( int nEntId, double& dFeed) ;
 EXE_EXPORT bool ExeGetClEntAxesStatus( int nEntId, int& nStatus) ;
 EXE_EXPORT bool ExeGetClEntAxesMask( int nEntId, int& nMask) ;
 EXE_EXPORT bool ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) ;
-
+EXE_EXPORT bool ExeGetClEntTDir( int nEntId, Vector3d& vtTDir) ;
+EXE_EXPORT bool ExeGetClEntCDir( int nEntId, Vector3d& vtCDir) ;
+EXE_EXPORT bool ExeGetClEntADir( int nEntId, Vector3d& vtADir) ;
 // Simulation
 EXE_EXPORT bool ExeSimInit( void) ;
 EXE_EXPORT bool ExeSimStart( bool bFirst) ;
@@ -1359,6 +1374,7 @@ EXE_EXPORT bool ExeGetCalcTipFromPositions( double dX, double dY, double dZ, con
 EXE_EXPORT bool ExeGetCalcToolDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) ;
 EXE_EXPORT bool ExeGetCalcAuxDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) ;
 EXE_EXPORT bool ExeVerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) ;
+EXE_EXPORT bool ExeVerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, int& nStat) ;
 EXE_EXPORT bool ExeGetOutstrokeInfo( std::string& sInfo) ;
 // Machine Move
 EXE_EXPORT bool ExeSetAxisPos( const std::string& sAxis, double dVal, double* pdNewVal = nullptr) ;
@@ -1394,6 +1410,7 @@ EXE_EXPORT bool ExeSetCameraType( bool bOrthoOrPersp, bool bRedraw) ;
 EXE_EXPORT bool ExeSetZoomType( int nMode, bool bRedraw) ;
 EXE_EXPORT bool ExeResize( int nW, int nH) ;
 EXE_EXPORT bool ExeDraw( void) ;
+EXE_EXPORT bool ExeRedraw( void) ;
 EXE_EXPORT bool ExeSelect( int nWinX, int nWinY, int nSelW, int nSelH, int* pnSel) ;
 EXE_EXPORT bool ExeSetObjFilterForSelWin( bool bZerodim, bool bCurve, bool bSurf, bool bVolume, bool bExtra) ;
 EXE_EXPORT bool ExeUnselectableRemove( int nId) ;
@@ -1524,6 +1541,13 @@ EXE_EXPORT bool ExeTrimmingInterpolateSyncLines( int nParentId, int nSync1Id, in
 EXE_EXPORT bool ExeTrimmingGetSurfBzSyncPoints( int nParentId, int nEdge1Id, int nEdge2Id, double dLinTol,
                                                double dAngTol, int nLineNbr, bool bShowOnCorners,
                                                int& nFirstId, int& nCount) ;
+EXE_EXPORT bool ExeTrimmingGetToolOrientationLines( int nParentId, int nMainEdgeId, int nOtherEdgeId, bool bMainIsFirstBorder, int nSyncLayerId,
+                                                    int nLineSId, int nLineEId, bool bShorterSide, double dThetaStart, double dPhiStart,
+                                                    double dThetaEnd, double dPhiEnd, double dInterpLenS, double dInterpLenE, double dLinTol,
+                                                    int& nInterpStartId, int& nStartId, int& nEndId, int& nInterpEndId) ;
+EXE_EXPORT bool Exe5AxTrimmingModifyToolDir( int nCrvId, int nPathId, int nTrimLayId, const INTVECTOR& vnOrientingId, const INTVECTOR& vnOrientingISId,
+                                             const INTVECTOR& vnOrientingSId, const INTVECTOR& vnOrientingEId, const INTVECTOR& vnOrientingIEId) ;
 EXE_EXPORT bool ExeTrimmingGetHoleBorder( int nParentId, const INTVECTOR& vSurfIds, const INTVECTOR& vOtherSurfIds,
                                          double dSurfLinTol, double dSurfAngTol, double dEdgeLinTol, double dEdgeAngTol,
                                          double dEdgeThick, int& nFirstId, int& nCount) ;
+EXE_EXPORT int ExeRegolarizeSurfaceLocally( int nParentId, int nSurfId, int nSyncStartId, int nSyncEndId, double dLinTol, int nType) ;
@@ -27,7 +27,7 @@

 //----------------------------------------------------------------------------
 const int KEY_BASELIB_PROD = 207 ;
-const int KEY_BASELIB_VER = 3103 ;
+const int KEY_BASELIB_VER = 3107 ;
 const int KEY_BASELIB_LEV = 1 ;

 //----------------------------------------------------------------------------
@@ -21,7 +21,7 @@ class PtrOwner
   public :
      explicit PtrOwner( void) : m_pT( nullptr) {}
      explicit PtrOwner( T* pT) : m_pT( pT) {}
-      PtrOwner( PtrOwner<T>&& RPT) : m_pT( Release( RPT)) {}
+      PtrOwner( PtrOwner<T>&& RPT) noexcept : m_pT( Release( RPT)) {}
      PtrOwner( const PtrOwner<T>& RPT) = delete ;
      ~PtrOwner( void) { Reset() ; }
      bool Set( T* pT) { Reset() ; m_pT = pT ; return ( m_pT != nullptr) ; }
Author	SHA1	Message	Date
Daniele Bariletti	e88b315214	Include : - aggiunta funzione per estendere un gruppo di superfici indicandone il bordo.	2026-07-22 09:23:27 +02:00
Daniele Bariletti	409c28e65a	Include : - aggiunto parametro alla chiamata a CreateFromTriMesh.	2026-07-20 13:09:50 +02:00
Riccardo Elitropi	403f7963fe	Include : - in EMkMachiningConst aggiunta costante per finitura con lama "Along5A".	2026-07-13 08:03:46 +02:00
Daniele Bariletti	a15889c841	Include : - aggiunta nuova modalità per l'approssimazione curve.	2026-07-08 17:27:24 +02:00
Dario Sassi	190cd9e032	Include : - per SelData e SELVECTOR aggiunte funzioni FromUiString e ToUiString.	2026-07-07 19:34:43 +02:00
Daniele Bariletti	c668a261d9	Include : - aggiunta enum e funzione per gestione spigoli.	2026-07-07 09:11:17 +02:00
Dario Sassi	29f7dc30cc	Include : - aggiornamento codice di protezione mensile delle librerie.	2026-07-03 18:39:46 +02:00
Riccardo Elitropi	e044937600	Include : - in EMkMachiningConst rimozione dei parametri SAWROU_ST_ZCONST e SAWROU_LL_INT per SawRoughing.	2026-07-03 12:28:44 +02:00
Daniele Bariletti	a43137a214	Include : - piccola correzione.	2026-06-30 15:51:05 +02:00
Daniele Bariletti	e6a94e077e	Merge branch 'master' of https://gitlab.steamware.net/egalware-cadcam/libreriebase/Include	2026-06-30 15:49:31 +02:00
Daniele Bariletti	6701dbef5c	Include : - aggiunta funzione per ottenre le normali di una superficie a partire da una curva già sulla superficie.	2026-06-30 15:49:28 +02:00
Riccardo Elitropi	e78f76d0e7	Include : - in EGkCalcPocketing aggiunto parametro per considerare le curve di lato chiuso come curve di lato aperto.	2026-06-30 12:32:12 +02:00
Riccardo Elitropi	333258cb2d	Include : - in EGkSurfTriMesh aggiunto parametro Opzionale di tolleranza lineare ai metodi di Silhouette.	2026-06-25 11:06:11 +02:00
Daniele Bariletti	4967285c97	Include : - cambiata chiamata all' offset3d. - aggiunta funzione per l'estensione di una superficie in tangenza. - creato enum per angoli di una curva proiettata su superficie.	2026-06-24 15:16:08 +02:00
Riccardo Elitropi	015edcaed7	Include : - In CalcPocketing aggiunto parametro.	2026-06-19 08:52:12 +02:00
Daniele Bariletti	4908b84afc	Include : - esposte funzioni per l'offset3d. - spostate struct e enum nell'header.	2026-06-18 16:22:26 +02:00
Riccardo Elitropi	dba5445b7a	Include : - in CalcPocketing aggiunto enum per TempProp.	2026-06-18 10:57:11 +02:00
SaraP	7d180c6e10	Include : - modificato prototipo.	2026-06-15 09:57:34 +02:00
Daniele Bariletti	216173ca33	Include : - spostate le funzioni di offset di categoria. - aggiunta la funzione per l'offset 3d delle curve.	2026-06-15 08:40:52 +02:00
Dario Sassi	ce08e8b327	Include : - eliminata costante MCH_FRAME = "FRAME".	2026-06-10 14:41:30 +02:00
Riccardo Elitropi	1b322858a5	Include : - aggiunta stringa per nome del gruppo contenente il frame di riferimento per le lavorazioni di finitura.	2026-06-10 12:23:44 +02:00
Daniele Bariletti	d02ff5a603	Include : - aggiunta funzione IntersLineCyl.	2026-06-09 12:28:59 +02:00
Dario Sassi	8aa1ea9f35	Include : - aggiornamento codice di protezione mensile delle librerie.	2026-06-08 14:59:13 +02:00
Daniele Bariletti	7cf6e9dc0c	Merge branch '5AxTrimming'	2026-05-26 11:28:55 +02:00
Dario Sassi	8e6e110b9a	Include : - eliminata costante non più utilizzata.	2026-05-25 07:36:47 +02:00
Daniele Bariletti	73fa43d0dc	Include : - aggiunto argomento alla ExeTrimmingGetToolOrientationLines.	2026-05-22 10:45:22 +02:00
Daniele Bariletti	3593d770ef	Include : - aggiunta gestione dell'ordine delle curve di bordo nella TrimmingGetToolOrientationLines .	2026-05-19 17:29:33 +02:00
Daniele Bariletti	67ebd35a0e	Merge branch 'master' into 5AxTrimming	2026-05-19 16:42:51 +02:00
Daniele Bariletti	5f233a571d	Include : - aggiunta funzione per copiare le info da un oggetto ad un altro.	2026-05-19 16:42:40 +02:00
Riccardo Elitropi	8fdc7dd552	Include (5AxTrimming) : - prima versione per Linee di Orientamento utensile.	2026-05-15 18:02:35 +02:00
Dario Sassi	bcf2cee00b	Include : - aggioramento prototipi.	2026-05-15 11:43:52 +02:00
Riccardo Elitropi	6857a19789	Include : - In EGkCalcPocketing aggiunto parametro a CalcPocketing per ToolCompensation - om EMkMachiningGeoConst aggiunta Info "TRC".	2026-05-14 15:29:47 +02:00
SaraP	5a3661a61d	Include : - aggiornamento prototipi.	2026-05-12 15:08:50 +02:00
Riccardo Elitropi	5b7e1a4702	Include : - in CalcPocketing aggiunto flag per Conventional Milling.	2026-05-11 10:05:34 +02:00
Daniele Bariletti	fa9976ddfb	Include : - esposta funzione per trovare il punto corrispondente sulla seconda curva di una coppia di curve da sincronizzare.	2026-05-08 17:23:39 +02:00
Daniele Bariletti	93d6077de6	Include : - aggiunto enum per trimming - aggiunto argomento a RegolarizeLocally	2026-05-07 11:28:20 +02:00
Dario Sassi	513ab88c6e	Include : - aggiornamento codice di protezione mansile delle librerie	2026-05-05 09:07:33 +02:00
Riccardo Elitropi	02208b5259	Include : - in MachiningGeoConst aggiunta costante MCH_HOME.	2026-04-30 16:37:53 +02:00
Daniele Bariletti	de9e442be8	Include : - modifiche alla chiamata di ModifyJoint. - cambio nome alla ModifySingleCurve.	2026-04-28 11:06:55 +02:00
Riccardo Elitropi	3d3b0a569c	Include : - In EGkCalcPocketing aggiunto prototipo per svuotature di fori.	2026-04-28 11:02:55 +02:00
Daniele Bariletti	903d20744c	Include : - aggiunte funzioni di utilità per le CurveComposite.	2026-04-27 14:59:09 +02:00
Daniele Bariletti	cf26040cc5	Merge branch 'master' of https://gitlab.steamware.net/egalware-cadcam/libreriebase/Include	2026-04-22 16:45:36 +02:00
Daniele Bariletti	082a2831df	Include : - aggiornamento prototipi.	2026-04-22 16:45:28 +02:00
Riccardo Elitropi	717267e832	Include : - modifica alla costante per nome entità CamData in Drilling in Doppio in Parallelo.	2026-04-22 13:11:56 +02:00
Daniele Bariletti	abd033342b	Include : - aggiunte funzioni per la regolarizzazione dei bordi di una surf di trimming. -	2026-04-21 15:08:56 +02:00
Dario Sassi	7b3aeb6c4c	Include : - aggiornamento prototipi.	2026-04-19 10:52:31 +02:00
Dario Sassi	707e8f089a	Include : - aggiornamento prototipi.	2026-04-15 08:55:04 +02:00
Daniele Bariletti	f91035138c	Include : - aggiunte funzioni per la creazione di smooth ruled bezier.	2026-04-10 18:18:30 +02:00
Dario Sassi	f5fb14805b	Include : - aggiornamento prototipi.	2026-04-08 19:23:15 +02:00
Dario Sassi	e587f78c21	Include : - aggiornamento codice di protezione mansile delle librerie.	2026-04-01 10:23:29 +02:00
Riccardo Elitropi	32fecb707c	Include : - in CalcPocketing aggiunti parametri per gestione lucidature.	2026-03-31 18:50:52 +02:00
Daniele Bariletti	707c01e3e3	Include : - aggiunta funzione di utilità per le bezier.	2026-03-31 16:20:24 +02:00
Riccardo Elitropi	27095ab86b	Merge commit 'a11da73e368f70969ffdd3e8d3acc6988ff6aa06'	2026-03-31 14:33:00 +02:00
Riccardo Elitropi	a11da73e36	Include (Nst_SurfFr) : - modifica stilistica.	2026-03-31 14:32:41 +02:00
Riccardo Elitropi	ca5efc44a9	Include (Nst_SurfFr) : - aggiornamento prototipi.	2026-03-30 18:14:56 +02:00
Riccardo Elitropi	4352332d54	Include (Nst_SurfFr) : - primo commit per CAv tra Regioni Piane con loop interni e Interferenza tra Regioni Piane.	2026-03-27 18:32:58 +01:00
Daniele Bariletti	0b155ef732	Merge branch 'master' of https://gitlab.steamware.net/egaltech/Include	2026-03-26 12:41:00 +01:00
Daniele Bariletti	71e670357b	Include : - aggiornamento prototipi.	2026-03-26 12:40:51 +01:00
Dario Sassi	41f2151748	Include : - aggiornamento prototipi.	2026-03-25 16:39:15 +01:00
Riccardo Elitropi	28ae97ae20	Include : - modificati prototipi per funzioni di creazione Zmap per versioni a 32Bit.	2026-03-24 16:00:07 +01:00
Dario Sassi	cac25dd095	Include : - aggiornamento prototipi.	2026-03-20 09:04:43 +01:00
Dario Sassi	2eccae4b92	Include : cambio nome funzioni da EraseFins a RemoveFins.	2026-03-19 19:29:02 +01:00
Riccardo Elitropi	fac9c9cbc7	Include : - aggiunti prototipi funzione EraseFins per gli Zmap.	2026-03-19 18:47:03 +01:00
Riccardo Elitropi	c879b37f7d	Include : - in MachMgr ed ExeExecutor aggiunte funzioni per ottenere vTDir, vCDir e vADir dalle entità CamData.	2026-03-18 16:22:37 +01:00
Daniele Bariletti	a6c5a4e6ca	Merge branch 'master' of https://gitlab.steamware.net/egaltech/Include	2026-03-16 17:00:28 +01:00
Daniele Bariletti	b6a535a3b7	Include : - aggiunto parametro alla GetSide della DistPointCurve.	2026-03-16 17:00:20 +01:00
Dario Sassi	84ae21db77	Include : - aggiornamento prototipi.	2026-03-13 13:36:31 +01:00
Daniele Bariletti	89d62ea86a	Include : - cambio restituzione valori per ExeSurfBezParamsFromPoint.	2026-03-12 18:13:30 +01:00
Daniele Bariletti	4e4ac1353e	Include : - aggiunte funzioni per l'analisi di una surf di bezier.	2026-03-11 16:08:12 +01:00
Daniele Bariletti	f24ca04620	Include : - modifica alla chiamata LUA per EgtSurfBezParamsFromPoint - resa disponibile interfaccia per ExeSurfBezParamsFromPoint.	2026-03-10 17:34:01 +01:00
Daniele Bariletti	6819363068	Include : - piccola correzione.	2026-03-05 09:11:35 +01:00
Daniele Bariletti	bd01cb72fd	Include : - piccola correzione.	2026-03-04 15:33:47 +01:00
Daniele Bariletti	32cba3873e	Merge branch 'master' of https://gitlab.steamware.net/egaltech/Include	2026-03-04 15:29:22 +01:00
Daniele Bariletti	ee7aabb242	Include : - aggiunta funzione per chiedere a che part appartiene una faccia di una trimesh.	2026-03-04 15:29:15 +01:00
Dario Sassi	552c408827	Include : - aggiornamento prototipi.	2026-03-03 18:33:07 +01:00
Riccardo Elitropi	8bd32361be	Merge commit '4833024c3e984fbeaad901a9e37eb09e9e862823'	2026-03-03 17:16:42 +01:00