Include :

- aggiunto prototipo.

EGkCalcPocketing.h

@@ -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
+} ;

EGkCurve.h

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

EGkCurveAux.h

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

EGkCurveComposite.h

@@ -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 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkIntersLineCylinder.h

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

EGkOffsetCurve3d.h

@@ -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 ;
+} ;

EGkPolyLine.h

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

EGkProjectCurveSurf.h

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

EGkSbzFromCurves.h

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

EGkSelection.h

@@ -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 ; }

EGkStmFromCurves.h

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

EGkSurfBezier.h

@@ -103,6 +103,9 @@ class __declspec( novtable) ISurfBezier : public ISurf
       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 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkSurfFlatRegion.h

@@ -32,6 +32,7 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
       virtual bool AddExtLoop( ICurve* pCrv) = 0 ;
       virtual bool AddIntLoop( const ICurve& cCrv) = 0 ;
       virtual bool AddIntLoop( ICurve* pCrv) = 0 ;
+      virtual bool Cut( const Plane3d& plPlane) = 0 ;
       virtual bool Add( const ISurfFlatRegion& Other) = 0 ;
       virtual bool Subtract( const ISurfFlatRegion& Other) = 0 ;
       virtual bool Intersect( const ISurfFlatRegion& Other) = 0 ;

EGkSurfTriMesh.h

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

EGkTrimming.h

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

EGkVolZmap.h

@@ -32,7 +32,7 @@ class __declspec( novtable) IVolZmap : public IGeoObj
       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) = 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 ;

EInAPI.h

@@ -1036,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) ;

EMkMachMgr.h

@@ -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 ;
@@ -290,9 +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& vTDir) const = 0 ;
-      virtual bool GetClEntCDir( int nEntId, Vector3d& vCDir) const = 0 ;
-      virtual bool GetClEntADir( int nEntId, Vector3d& vADir) 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 ;

EMkMachiningConst.h

@@ -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,

EMkMachiningGeoConst.h

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

EXeExecutor.h

@@ -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) ;
@@ -695,6 +698,7 @@ EXE_EXPORT bool ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewI
 EXE_EXPORT bool ExeSurfFrEraseChunk( int nId, int nChunk) ;
 EXE_EXPORT bool ExeSurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double& dLen, int nRefType) ;
 EXE_EXPORT bool ExeSurfFrRotateSimpleNoCollision( int nId1, int nId2, const Point3d& ptCen, double& dAngDeg, int nRefType) ;
+EXE_EXPORT bool ExeCutSurfFrPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bInVsOut, int nRefType) ;
 EXE_EXPORT bool ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType, bool bUpdate) ;
 EXE_EXPORT bool ExeSurfTmMoveFacet( int nId, int nFacet, const Vector3d& vtMove, int nRefType, bool bUpdate) ;
 EXE_EXPORT int  ExeSurfTmToTriangles( int nId, int* pnCount) ;
@@ -702,7 +706,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 +720,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) ;
@@ -797,6 +803,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) ;
@@ -1095,7 +1104,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) ;
@@ -1301,9 +1311,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& vTDir) ;
-EXE_EXPORT bool ExeGetClEntCDir( int nEntId, Vector3d& vCDir) ;
-EXE_EXPORT bool ExeGetClEntADir( int nEntId, Vector3d& vADir) ;
+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) ;
@@ -1401,6 +1411,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) ;
@@ -1531,6 +1542,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) ;

EgtKeyCodes.h

@@ -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 ;
 
 //----------------------------------------------------------------------------