Include:

- aggiunta funzione per una trimesh più fine per le bezier.

EBsAPI.h

@@ -0,0 +1,57 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2025
+//----------------------------------------------------------------------------
+// File : EBsAPI.h            Data : 24.01.25            Versione : 2.7a1
+// Contenuto : API (application programming interface).
+//
+//
+//
+// Modifiche : 05.10.24 DS Creazione modulo.
+//             24.01.25 DS Aggiunta gestione messaggi.
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#define NOMINMAX
+#include <windows.h>
+
+//----------------------- Macro per import/export ----------------------------
+#undef EGTBASIS_EXPORT
+#if defined( I_AM_EGTBASIS)            // da definirsi solo nella DLL
+   #define EGTBASIS_EXPORT __declspec( dllexport)
+#else
+   #define EGTBASIS_EXPORT __declspec( dllimport)
+#endif
+
+//-----------------------------------------------------------------------------
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// API
+// Protezione
+EGTBASIS_EXPORT BOOL __stdcall EgtSetKey( const wchar_t* wsKey) ;
+EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyLevel( int nProd, int nVer, int nLev, int* pnKLev) ;
+EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyOptions( int nProd, int nVer, int nLev, unsigned int* pnOpt1, unsigned int* pnOpt2) ;
+EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyLeftDays( int* pnLeftDays) ;
+EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyAssLeftDays( int* pnAssLeftDays) ;
+EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyOptLeftDays( int* pnOptLeftDays) ;
+// Liberazione memoria blocchi dati ritornati (di solito per stringhe)
+EGTBASIS_EXPORT BOOL __stdcall EgtFreeMemory( void* pMem) ;
+// Messaggi
+EGTBASIS_EXPORT BOOL __stdcall EgtLoadMessages( const wchar_t* wsMsgFilePath) ;
+EGTBASIS_EXPORT const wchar_t* __stdcall EgtGetMsg( int nMsg) ;
+// Logger
+EGTBASIS_EXPORT BOOL __stdcall EgtInitLogger( int nDebug, const wchar_t* wsLogFile) ;
+EGTBASIS_EXPORT BOOL __stdcall EgtOutLog( const wchar_t* wsMsg, int nDebugLevel) ;
+
+// Ini File
+EGTBASIS_EXPORT BOOL __stdcall EgtGetStringUtf8FromIni( const wchar_t* wsSec, const wchar_t* wsKey,
+                                                        const wchar_t* wsDef, wchar_t*& wsVal, const wchar_t* wsIniFile) ;
+EGTBASIS_EXPORT BOOL __stdcall EgtWriteStringUtf8ToIni( const wchar_t* wsSec, const wchar_t* wsKey,
+                                                        const wchar_t* wsVal, const wchar_t* wsIniFile) ;
+
+#ifdef __cplusplus
+}
+#endif

EExImport3MF.h

@@ -29,10 +29,13 @@ class __declspec( novtable) IImport3MF
 {
    public :
       virtual ~IImport3MF( void) {} 
-      virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup) = 0 ;
+      virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup, int nFlag = 0) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------
 extern "C" {
    EEX_EXPORT IImport3MF* CreateImport3MF( void) ;
 }
+
+enum EIm3MFFlag { EI3FLAG_NONE =          0x0000,
+                  EI3FLAG_KEEP_GROUPS =   0x0001} ;

EExImportBtl.h

@@ -37,5 +37,6 @@ class __declspec( novtable) IImportBtl
 //-----------------------------------------------------------------------------
 extern "C" {
    EEX_EXPORT bool SetBtlAuxDir( const std::string& sBtlAuxDir) ;
+   EEX_EXPORT bool SetBtlLuaData( const std::string& sLuaLibsDir, const std::string& sLuaLastRequire) ;
    EEX_EXPORT IImportBtl* CreateImportBtl( void) ;
 }

EExImportOff.h

@@ -0,0 +1,38 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EExImportOff.h          Data : 28.11.24          Versione : 2.6k2
+// Contenuto : Dichiarazione della interfaccia IImportOff.
+//
+//
+//
+// Modifiche : 28.11.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkGeomDB.h"
+#include <string>
+
+//----------------------- Macro per import/export ----------------------------
+#undef EEK_EXPORT
+#if defined( I_AM_EEX)            // da definirsi solo nella DLL
+   #define EEX_EXPORT __declspec( dllexport)
+#else
+   #define EEX_EXPORT __declspec( dllimport)
+#endif
+
+//-----------------------------------------------------------------------------
+class __declspec( novtable) IImportOff
+{
+   public :
+      virtual ~IImportOff( void) {} 
+      virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup, double dScaleFactor = 1) = 0 ;
+} ;
+
+//-----------------------------------------------------------------------------
+extern "C" {
+   EEX_EXPORT IImportOff* CreateImportOff( void) ;
+}

EExImportPly.h

@@ -0,0 +1,38 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2025-2025
+//----------------------------------------------------------------------------
+// File : EExImportPly.h          Data : 28.02.25          Versione : 2.7b2
+// Contenuto : Dichiarazione della interfaccia IImportPly.
+//
+//
+//
+// Modifiche : 28.02.25 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkGeomDB.h"
+#include <string>
+
+//----------------------- Macro per import/export ----------------------------
+#undef EEK_EXPORT
+#if defined( I_AM_EEX)            // da definirsi solo nella DLL
+   #define EEX_EXPORT __declspec( dllexport)
+#else
+   #define EEX_EXPORT __declspec( dllimport)
+#endif
+
+//-----------------------------------------------------------------------------
+class __declspec( novtable) IImportPly
+{
+   public :
+      virtual ~IImportPly( void) {} 
+      virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup, double dScaleFactor = 1) = 0 ;
+} ;
+
+//-----------------------------------------------------------------------------
+extern "C" {
+   EEX_EXPORT IImportPly* CreateImportPly( void) ;
+}

EGkCAvSilhouetteSurfTm.h

@@ -0,0 +1,42 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EGkCAvSilhouetteSurfTm.h      Data : 08.06.24      Versione : 2.6f2
+// Contenuto : Dichiarazione della funzione calcolo silhouette.
+//
+//
+//
+// Modifiche : 08.06.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkSurfTriMesh.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
+ 
+//-----------------------------------------------------------------------------
+EGK_EXPORT bool CAvSilhouetteSurfTm( const ISurfTriMesh& Stm, const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL) ;
+
+//-----------------------------------------------------------------------------
+class __declspec( novtable) ICAvParSilhouettesSurfTm
+{
+   public :
+      virtual ~ICAvParSilhouettesSurfTm( void) {}
+      virtual bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol) = 0 ;
+      virtual bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol,
+                            double dSideAng, double dDiam, double dCornRad, double dMaxMat, double dOffsR,
+                            double dMaxDepth) = 0 ;
+      virtual bool GetSilhouette( double dLevel, POLYLINEVECTOR& vPL) = 0 ;
+} ;
+
+//-----------------------------------------------------------------------------
+EGK_EXPORT ICAvParSilhouettesSurfTm* CreateCAvParSilhouettesSurfTm( void) ;

EGkCAvToolSurfTm.h

@@ -23,6 +23,8 @@
    #define EGK_EXPORT __declspec( dllimport)
 #endif
 
+class ICurveComposite ;
+
 //-----------------------------------------------------------------------------
 class __declspec( novtable) ICAvToolSurfTm {
    public :
@@ -35,9 +37,17 @@ class __declspec( novtable) ICAvToolSurfTm {
       virtual bool SetGenTool( const ICurveComposite* pToolOutline) = 0 ;
       virtual double GetToolRadius( void) const = 0 ;
       virtual double GetToolHeight( void) const = 0 ;
+      virtual double GetToolTipHeight( void) const = 0 ;
+      virtual double GetToolTipRadius( void) const = 0 ;
+      virtual double GetToolCornRadius( void) const = 0 ;
       virtual const ICurveComposite& GetToolOutline( bool bApprox = false) const = 0 ;
-      virtual bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist) = 0 ;
-      virtual bool TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol) = 0 ;
+      virtual bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
+                                 double& dTotDist, Vector3d* pvtTriaN = nullptr) const = 0 ;
+      virtual bool TestPositionAdv( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
+                                 double& dTotDist, VCT3DVECTOR& vVtN) const = 0 ;
+      virtual bool TestSeries( PNTUVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff = 1) = 0 ;
+      virtual bool TestSeriesAdv( PNTUVVECTVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff = 1) = 0 ;
+      virtual bool TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol, double dProgCoeff = 1) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkCDeBoxClosedSurfTm.h

@@ -1,12 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2016-2020
+//  EgalTech 2016-2024
 //----------------------------------------------------------------------------
-// File : EGkCDeBoxClosedSurfTm.h      Data : 09.01.20    Versione : 2.2a2
+// File : EGkCDeBoxClosedSurfTm.h      Data : 24.03.24    Versione : 2.6c2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             BoundingBox e Closed SurfTriMesh.
 //
 // Modifiche : 05.10.16 DS Creazione modulo.
 //             09.01.20 DS Cambio nome alla funzione e cambio parametri.
+//             24.03.24 DS Aggiunta TestBoxSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -32,3 +33,8 @@
 // - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 EGK_EXPORT bool CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTriMesh& Stm, double dSafeDist) ;
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il box e la superficie : restituisce true in caso di interferenza.
+//----------------------------------------------------------------------------
+EGK_EXPORT bool TestBoxSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTriMesh& Stm, double dSafeDist) ;

EGkCDeClosedSurfTmClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : EGkCDeClosedSurfTmClosedSurfTm.h  Data : 15.02.24  Versione : 2.6b2
+// File : EGkCDeClosedSurfTmClosedSurfTm.h  Data : 24.03.24  Versione : 2.6c2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             SurfTm e SurfTm.
 //
 // Modifiche : 13.11.20 LM Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestSurfTmSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -30,3 +30,8 @@
 // - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 EGK_EXPORT bool CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist) ;
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra le due superfici : restituisce true in caso di interferenza.
+//----------------------------------------------------------------------------
+EGK_EXPORT bool TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist) ;

EGkCDeConeFrustumClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : EGkCDeConeFrustumClosedSurfTm.h   Data : 15.02.24  Versione : 2.6b2
+// File : EGkCDeConeFrustumClosedSurfTm.h   Data : 24.03.24  Versione : 2.6c2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             Cone e Closed SurfTriMesh.
 //
 // Modifiche : 09.11.20 LM Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestConeFrustumSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -30,4 +30,10 @@
 // - true in caso di collisione o inconsistenza dei parametri di input
 // - false in caso di assenza di collisione.
 EGK_EXPORT bool CDeConeFrustumClosedSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                                            const ISurfTriMesh& Stm, double dSafeDist) ;
+                                            const ISurfTriMesh& Stm, double dSafeDist) ;
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il tronco di cono e la superficie : restituisce true in caso di interferenza.
+//----------------------------------------------------------------------------
+EGK_EXPORT bool TestConeFrustumSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
+                                       const ISurfTriMesh& Stm, double dSafeDist) ;

EGkCDeConvexTorusClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : EGkCDeConvexTorusTria.h      Data : 18.11.20    Versione : 
+// File : EGkCDeConvexTorusTria.h      Data : 24.03.24    Versione : 2.6c2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             toro convesso e SurfTriMesh.
 //
 // Modifiche : 18.11.20 LM Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestConvexTorusSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -33,3 +33,9 @@
 //----------------------------------------------------------------------------
 EGK_EXPORT bool CDeConvexTorusClosedSurfTm( const Frame3d& frTorus, double dRad1, double dRad2, 
                                             const ISurfTriMesh& tmSurf, double dSafeDist) ;
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il toro convesso e la superficie : restituisce true in caso di interferenza
+//----------------------------------------------------------------------------
+EGK_EXPORT bool TestConvexTorusSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
+                                       const ISurfTriMesh& Stm, double dSafeDist) ;

EGkCDeCylClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : EGkCDeCylClosedSurfTm.h      Data : 09.01.20    Versione : 2.2a2
+// File : EGkCDeCylClosedSurfTm.h      Data : 24.03.24    Versione : 2.6c2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             Cylinder e Closed SurfTriMesh.
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestCylSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -31,3 +31,8 @@
 // - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 EGK_EXPORT bool CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMesh& Stm, double dSafeDist) ;
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il cilindro e la superficie : restituisce true in caso di interferenza.
+//----------------------------------------------------------------------------
+EGK_EXPORT bool TestCylSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMesh& Stm, double dSafeDist) ;

EGkCDeRectPrismoidClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : EGkCDeRectPrismoidClosedSurfTm.h      Data : 09.11.20    Versione : 
+// File : EGkCDeRectPrismoidClosedSurfTm.h  Data : 24.03.24  Versione : 2.6c2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             prismoide a basi rettangolari e Closed SurfTriMesh.
 //
 // Modifiche : 09.11.20 LM Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestRectPrismoidSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -32,4 +32,11 @@
 //----------------------------------------------------------------------------
 EGK_EXPORT bool CDeRectPrismoidClosedSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
                                              double dLenghtTopX, double dLenghtTopY, double dHeight,
-                                             const ISurfTriMesh& Stm, double dSafeDist) ;
+                                             const ISurfTriMesh& Stm, double dSafeDist) ;
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il Prismoide a basi rettangolari e la superficie : restituisce true in caso di interferenza.
+//----------------------------------------------------------------------------
+EGK_EXPORT bool TestRectPrismoidSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
+                                        double dLenghtTopX, double dLenghtTopY, double dHeight,
+                                        const ISurfTriMesh& Stm, double dSafeDist) ;

EGkCDeSpheClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : EGkCDeSpheClosedSurfTm.h      Data : 09.01.20    Versione : 2.2a2
+// File : EGkCDeSpheClosedSurfTm.h      Data : 24.03.24    Versione : 2.6c2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             Sphere e Closed SurfTriMesh.
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestSpheSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -28,3 +28,8 @@
 // - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 EGK_EXPORT bool CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, double dSafeDist) ;
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra la sfera e la superficie : restituisce true in caso di interferenza
+//----------------------------------------------------------------------------
+EGK_EXPORT bool TestSpheSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, double dSafeDist) ;

EGkCalcPocketing.h

@@ -25,7 +25,53 @@
 #endif
 
 //-----------------------------------------------------------------------------
-EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dStep, double dAngle, int nType,
-                               bool bSmooth, ICRVCOMPOPOVECTOR& vCrv) ;
+EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double dStep,
+                               double dAngle, double dOpenMinSafe, int nType, bool bSmooth, bool bInvert, bool bAvoidOpt,
+                               bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec, const ISurfFlatRegion* pSfrLimit,
+                               bool bAllOffs, ICRVCOMPOPOVECTOR& vCrv) ;
 EGK_EXPORT bool CalcZigZagInfill( const ISurfFlatRegion* pSfr, double dStep, bool bSmooth, bool bRemoveOverlapLink,
                                   ICRVCOMPOPOVECTOR& vCrvCompoRes) ;
+
+//-----------------------------------------------------------------------------
+// Sottotipo di lavorazione
+enum { POCKET_ZIGZAG = 0,
+       POCKET_ONEWAY = 1,
+       POCKET_SPIRALIN = 2,
+       POCKET_SPIRALOUT = 3,
+       POCKET_CONFORMAL_ZIGZAG = 4,
+       POCKET_CONFORMAL_ONEWAY = 5
+} ;
+
+// Definizione di lato aperto e lato chiuso
+enum {
+   TEMP_PROP_CLOSE_EDGE = 0,
+   TEMP_PROP_OPEN_EDGE = 1
+} ;
+
+// Definizione di curva invalida
+enum {
+   TEMP_PROP_INVALID = - 1
+} ;
+
+// Definizione curva di raccordo per smussi
+enum {
+   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,
+} ;
+
+// Definizione tipo di curva per entrate da fuori
+enum {
+   TEMP_PROP_OUT_START = - 6
+} ;
+
+// Definizione di curva attiva/non attiva
+enum {
+   TEMP_PROP_CURVE_ACTIVE = - 7,
+   TEMP_PROP_CURVE_INACTIVE = - 8
+} ;

EGkColor.h

@@ -108,6 +108,7 @@ class Color
 const Color WHITE( 255, 255, 255) ;
 const Color LGRAY( 192, 192, 192) ;
 const Color GRAY( 128, 128, 128) ;
+const Color DGRAY( 64, 64, 64) ;
 const Color BLACK( 0, 0, 0) ;
 const Color RED( 255, 0, 0) ;
 const Color MAROON( 128, 0, 0) ;

EGkCurveAux.h

@@ -15,6 +15,8 @@
 
 #include "/EgtDev/Include/EGkCurveComposite.h"
 
+class ICurveBezier ;
+class ICurveLine ;
 
 //----------------------- Macro per import/export ----------------------------
 #undef EGK_EXPORT
@@ -44,9 +46,53 @@ struct CNurbsData
 // 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
 
+//----------------------------------------------------------------------------
+//! Trasforma una linea in una nuova curva di Bezier semplice
+EGK_EXPORT ICurve* CurveToBezierCurve( const ICurve* pCrv, int nDeg = 3, bool bMakeRatOrNot = true) ;
+
+//----------------------------------------------------------------------------
+//! Trasforma una linea in una nuova curva di Bezier semplice
+EGK_EXPORT ICurveBezier* LineToBezierCurve( const ICurveLine* pLine, int nDeg = 3, bool bMakeRatOrNot = true) ;
+
 //----------------------------------------------------------------------------
 //! Trasforma un arco in una nuova curva di Bezier semplice o composta
-EGK_EXPORT ICurve* ArcToBezierCurve( const ICurve* pArc) ;
+EGK_EXPORT ICurve* ArcToBezierCurve( const ICurve* pArc, int nDeg = 3, bool bMakeRatOrNot = true) ;
+
+//----------------------------------------------------------------------------
+//! Trasforma una curva compo in una nuova curva di Bezier semplice o composta
+EGK_EXPORT ICurve* CompositeToBezierCurve( const ICurveComposite* pCrvCompo, int nDeg = 3, bool bMakeRatOrNot = true) ;
+
+//----------------------------------------------------------------------------
+//! 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* pCrvBezier, int nDeg = 3, bool bMakeRatOrNot = true, double dTol = 10 * EPS_SMALL) ;
+
+//----------------------------------------------------------------------------
+//! Approssima una bezier con una serie di bezier cubiche
+EGK_EXPORT ICurve* ApproxBezierWithCubics( const ICurveBezier* pCrvBezier, double dTol) ;
+
+//----------------------------------------------------------------------------
+//! Approssima una bezier con una serie di bezier cubiche
+EGK_EXPORT ICurveBezier* ApproxArcCurveBezierWithSingleCubic( const ICurveBezier* pCrvBezier, const Point3d& ptCen) ;
+
+//----------------------------------------------------------------------------
+//! Campiona una serie di punti dalla curva e li approssima con una o più curve di bezier
+EGK_EXPORT ICurve* ApproxCurveWithBezier( const ICurve*, double dTol) ;
+
+//----------------------------------------------------------------------------
+//! Interpola un set di punti e li approssima con una o più curve di bezier cubiche
+EGK_EXPORT ICurve* InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dTol) ;
+
+//----------------------------------------------------------------------------
+//! Aumento il grado della curva di Bezier
+EGK_EXPORT ICurveBezier* BezierIncreaseDegree( const ICurveBezier* pCrvBezier) ;
+
+//----------------------------------------------------------------------------
+//! Riduco il grado della curva di Bezier
+EGK_EXPORT ICurveBezier* BezierDecreaseDegree( const ICurveBezier* pCrvBezier, double dTol) ;
+
+//----------------------------------------------------------------------------
+//! Misura l'errore di approsimazione tra la curva originale e quella modificata
+EGK_EXPORT bool CalcBezierApproxError( const ICurveBezier* pCrvOri, const ICurveBezier* pCrvNew, double& dErr, int nPoints = 20) ;
 
 //----------------------------------------------------------------------------
 //! Trasforma una curva in una nuova curva semplice o composta senza archi (solo linee o curve di Bezier)
@@ -80,17 +126,31 @@ EGK_EXPORT ICurve* ProjectCurveOnPlane( const ICurve& crCrv, const Plane3d& plPl
 EGK_EXPORT bool AdjustCurveSlope( ICurveComposite* pCrv, double dNini, double dNfin) ;
 
 //----------------------------------------------------------------------------
-//! Calcolo del diagramma di Voronoi della curva, nei TempParam dei risultati la distanza
+//! Calcolo del diagramma di Voronoi della curva/e, nei TempParam dei risultati la distanza
 //! Per nBound tenere valore di default. 
 EGK_EXPORT bool CalcCurveVoronoiDiagram( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nBound = 3) ;
+EGK_EXPORT bool CalcCurvesVoronoiDiagram( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, int nBound = 3) ;
 
 //----------------------------------------------------------------------------
-//! Calcolo del Medial Axis della curva (sottoinsieme del diagramma di Voronoi), nei TempParam dei risultati la distanza
+//! Calcolo del Medial Axis della curva/e (sottoinsieme del diagramma di Voronoi), nei TempParam dei risultati la distanza
 const int WMAT_BOTHSIDES = 0 ;
 const int WMAT_LEFT = 1 ;
 const int WMAT_RIGHT = 2 ;
 EGK_EXPORT bool CalcCurveMedialAxis( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nSide) ;
+EGK_EXPORT bool CalcCurvesMedialAxis( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, int nSide) ;
 
 //----------------------------------------------------------------------------
 //! Calcola l'offset completo di una curva
 EGK_EXPORT bool CalcCurveFatCurve( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dRadius, bool bSquareEnds, bool bSquareMids) ;
+
+//----------------------------------------------------------------------------
+//! Calcola, nel caso di curve chiuse, il valore limite di offset ( in valore assoluto) che fa sparire la curva
+EGK_EXPORT bool CalcCurveLimitOffset( const ICurve& crvC, double& dOffs) ;
+
+//----------------------------------------------------------------------------
+//! Calcola, se possibile, le curve di offset del valore richiesto come curve singole
+EGK_EXPORT bool CalcCurveSingleCurvesOffset( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dOffs) ;
+
+//----------------------------------------------------------------------------
+//! Resetta l'oggetto voronoi associato alla curva liberandone la memoria
+EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;

EGkCurveBezier.h

@@ -16,6 +16,7 @@
 #include "/EgtDev/Include/EGkCurve.h"
 
 class ICurveArc ;
+class ICurveLine ;
 
 //----------------------------------------------------------------------------
 class __declspec( novtable) ICurveBezier : public ICurve
@@ -27,7 +28,9 @@ class __declspec( novtable) ICurveBezier : public ICurve
       virtual bool Init( int nDeg, bool bIsRational) = 0 ;
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl) = 0 ;
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) = 0 ;
+      virtual bool SetControlWeight( int nInd, double dW) = 0 ;
       virtual bool FromArc( const ICurveArc& crArc) = 0 ;
+      virtual bool FromLine( const ICurveLine& crLine) = 0 ;
       virtual int  GetDegree( void) const = 0 ;
       virtual bool IsRational( void) const = 0 ;
       virtual bool IsAPoint( void) const = 0 ;
@@ -35,6 +38,10 @@ class __declspec( novtable) ICurveBezier : public ICurve
       virtual double GetControlWeight( int nInd, bool* pbOk = NULL) const = 0 ;
       virtual bool GetControlPolygonLength( double& dLen) const = 0 ;
       virtual int  GetSingularParam( double& dPar) const = 0 ;
+      virtual bool MakeRational( void) = 0 ;
+      virtual bool MakeRationalStandardForm( void) = 0 ;
+      virtual bool MakeNonRational( double dTol) = 0 ;
+      virtual bool IsALine( void) const = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkCurveComposite.h

@@ -70,6 +70,8 @@ class __declspec( novtable) ICurveComposite : public ICurve
       virtual bool GetCurveTempProp( int nCrv, int& nProp, int nPropInd = 0) const = 0 ;
       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 FromPoint( Point3d& ptStart) = 0 ;
+      virtual bool GetOnlyPoint( Point3d& ptStart) const = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------
@@ -108,6 +110,8 @@ inline ICurveComposite* ConvertCurveToComposite( IGeoObj* pGObj)
                     int nProp = pCrv->GetTempProp( i) ;
                     if ( nProp != 0)
                        pCrvCo->SetTempProp( nProp, i) ;
+                    double dParam = pCrv->GetTempParam( i) ;
+                    pCrvCo->SetTempParam( dParam, i) ;
                  }
                  pCrvCo->AddCurve( pCrv) ;
                  return pCrvCo ;

EGkDistLineLine.h

@@ -0,0 +1,60 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2020-2024
+//----------------------------------------------------------------------------
+// File : EGkDistLineLine.h      Data : 10.05.24         Versione : 2.6e31
+// Contenuto : Dichiarazione della classe distanza fra elementi lineari.
+//
+//
+//
+// Modifiche : 06.11.20 LM Creazione modulo.
+//             10.05.24 DS Portata in Include.
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkPoint3d.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 DistLineLine
+{
+   public :
+      EGK_EXPORT DistLineLine( const Point3d& ptSt1, const Point3d& ptEn1,
+                               const Point3d& ptSt2, const Point3d& ptEn2,
+                               bool bIsSegment1 = true, bool bIsSegment2 = true) ;
+      EGK_EXPORT DistLineLine( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
+                               const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
+                               bool bIsSegment1 = true, bool bIsSegment2 = true) ;
+
+   public :
+      EGK_EXPORT bool GetSqDist( double& dSqDist) const ;
+      EGK_EXPORT bool GetDist( double& dDist) const ;
+      EGK_EXPORT bool IsEpsilon( double dTol) const
+                         { double dSqDist ; return ( GetSqDist( dSqDist)  &&  ( dSqDist < SQ_EPS_ZERO  ||  dSqDist < dTol * dTol)) ; }
+      EGK_EXPORT bool IsSmall( void) const
+                         { return IsEpsilon( EPS_SMALL) ; }
+      EGK_EXPORT bool IsZero( void) const
+                         { return IsEpsilon( EPS_ZERO) ;  }
+      EGK_EXPORT bool GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2) const ;
+      EGK_EXPORT bool GetPositionsAtMinDistPoints( double& dPos1, double& dPos2) const ;
+
+   private :
+      void Calculate( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
+                      const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
+                      bool bIsSegment1, bool bIsSegment2) ;
+   private:
+      double  m_dSqDist ;
+      mutable double  m_dDist ;
+      double  m_dPos1 ;
+      double  m_dPos2 ;
+      Point3d m_ptMinDist1 ;
+      Point3d m_ptMinDist2 ;
+} ;

EGkDistPointCurve.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2014
+//  EgalTech 2013-2024
 //----------------------------------------------------------------------------
-// File : EGkDistPointCurve.h     Data : 02.01.14        Versione : 1.5a1
+// File : EGkDistPointCurve.h     Data : 20.05.24        Versione : 2.6e5
 // Contenuto : Dichiarazione della classe distanza punto da Curva.
 //
 //
@@ -68,7 +68,6 @@ class DistPointCurve
       EGK_EXPORT bool GetMinDistInfo( int nInd, MinDistPCInfo& aInfo) const ;
 
    private :
-      DistPointCurve( void) ;
       void LineCalculate( const Point3d& ptP, const ICurve& Curve, bool bIsSegment) ;
       void ArcCalculate( const Point3d& ptP, const ICurve& Curve) ;
       void CrvBezierCalculate( const Point3d& ptP, const ICurve& Curve) ;

EGkDistPointLine.h

@@ -0,0 +1,65 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2013-2024
+//----------------------------------------------------------------------------
+// File : EGkDistPointLine.h      Data : 20.05.24          Versione : 2.6e5
+// Contenuto : Dichiarazione della classe distanza punto da linea/segmento.
+//
+//
+//
+// Modifiche : 30.12.12 DS Creazione modulo.
+//             20.05.24 DS Pubblicato in Include.
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkPoint3d.h"
+#include "/EgtDev/Include/EGkCurveLine.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 DistPointLine
+{
+   friend class DistPointCurve ;
+
+   public :
+      EGK_EXPORT DistPointLine( const Point3d& ptP,
+                                const ICurveLine& crvLine, bool bIsSegment = true) ;
+      EGK_EXPORT DistPointLine( const Point3d& ptP,
+                                const Point3d& ptIni, const Point3d& ptFin, bool bIsSegment = true) ;
+      EGK_EXPORT DistPointLine( const Point3d& ptP,
+                                const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment = true) ;
+
+   public :
+      EGK_EXPORT bool GetSqDist( double& dSqDist) const ;
+      EGK_EXPORT bool GetDist( double& dDist) const ;
+      EGK_EXPORT bool IsEpsilon( double dTol) const
+                         { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
+      EGK_EXPORT bool IsSmall( void) const
+                         { return IsEpsilon( EPS_SMALL) ; }
+      EGK_EXPORT bool IsZero( void) const
+                         { return IsEpsilon( EPS_ZERO) ; }
+      EGK_EXPORT int  GetNbrMinDist( void) const
+                         { return (( m_dSqDist < 0) ? 0 : 1) ; }
+      EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDist) const ;
+      EGK_EXPORT bool GetParamAtMinDistPoint( double& dParam) const ;
+
+   private :
+      void Calculate( const Point3d& ptP,
+                      const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment) ;
+
+   private :
+      double  m_dSqDist ;
+      mutable double  m_dDist ;
+      double  m_dParam ;
+      Point3d m_ptMinDist ;
+} ;
+

EGkDistPointSurfFr.h

@@ -0,0 +1,72 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EGkDistPointSurfFr.h     Data : 18.07.24        Versione : 2.6g5
+// Contenuto : Dichiarazione della classe distanza Punto da FlatRegion.
+//
+//
+//
+// Modifiche : 18.07.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkSurfFlatRegion.h"
+
+//----------------------- Macro per import/export ----------------------------
+#undef EGK_EXPORT
+#if defined( I_AM_EGK)            // da definirsi solo nella DLL
+   #define EGK_EXPORT __declspec( dllexport)
+#else
+   #define EGK_EXPORT __declspec( dllimport)
+#endif
+
+//----------------------------------------------------------------------------
+// Calcola la distanza tra punto e Flat Region.
+// Risultati :
+// - distanza
+// - punto sulla superficie a minima distanza
+// - indici del chunk e del loop e parametro del punto di frontiera a minima distanza
+// - indicazione se il punto passato è sul bordo (PRS_ON), interno (PRS_IN) o esterno (PRS_OUT) alla regione.
+// Note :
+// - nel caso di più punti di frontiera vicini, ne viene calcolato solo uno
+// - se il punto non giace nel piano della Regione 
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+enum PrSide { PRS_IN = -1, PRS_ON = 0, PRS_OUT = +1} ;
+// Corrispondono a MDS_LEFT, MDS_ON e MDS_RIGHT per giacitura punto rispetto a curva.
+
+//----------------------------------------------------------------------------
+class DistPointSurfFr
+{
+   public :
+      EGK_EXPORT DistPointSurfFr( const Point3d& ptP, const ISurfFlatRegion& frSurf) ;
+
+   public :
+      EGK_EXPORT bool GetDist( double& dDist) const ;
+      EGK_EXPORT bool GetDistOnRegionPlane( double& dDist) const ;
+      EGK_EXPORT bool GetPointAtMinDist( Point3d& ptMinDistPoint) const ;
+      EGK_EXPORT bool GetParamAtMinDist( int& nMinChunk, int& nMinLoop, double& dMinPar) const ;
+      EGK_EXPORT bool GetSideAtMinDist( int& nSide) const ;
+
+   private :
+      void Calculate( const Point3d& ptP, const ISurfFlatRegion& frSurf) ;
+
+   private :
+      double  m_dDist ;
+      double  m_dDistOnPlane ;
+      int     m_nMinChunk ;
+      int     m_nMinLoop ;
+      double  m_dMinPar ;
+      Point3d m_ptMinDistPoint ;
+      int     m_nSide ;
+} ;
+
+//----------------------------------------------------------------------------
+// Verifica velocizzata
+EGK_EXPORT bool IsPointInsideSurfFr( const Point3d& ptP, const ISurfFlatRegion* pSfr, double dMinDist, bool& bInside, int& nChunk) ;
+inline bool IsPointInsideSurfFr( const Point3d& ptP, const ISurfFlatRegion* pSfr, double dMinDist, bool& bInside)
+               { int nChunk ; return IsPointInsideSurfFr( ptP, pSfr, dMinDist, bInside, nChunk) ;}

EGkDistPointSurfTm.h

@@ -29,7 +29,8 @@
 // - distanza
 // - punto sulla superficie a minima distanza
 // - indice del triangolo su cui giace il punto
-// - indicazione se il punto di riferimento è dalla parte interna o esterna della superficie.
+// - indicazione se il punto di riferimento è dalla parte interna o esterna della superficie ( se chiusa ).
+// - indicazione se il punto di riferimento è a destra o sinistra della superficie ( se aperta )
 //----------------------------------------------------------------------------
 class DistPointSurfTm
 {
@@ -47,7 +48,9 @@ class DistPointSurfTm
       EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDistPoint) const ;
       EGK_EXPORT bool GetMinDistTriaIndex( int& nMinDistTriaIndex) const ;
       EGK_EXPORT bool IsPointInside( void) const
-                        { return m_bIsInside ; }
+                        { return ( m_bIsInside  &&  m_bIsSurfClosed) ; }
+      EGK_EXPORT bool IsPointOnLeftSide( void) const
+                        { return m_bIsInside ;}
 
    private :
       void Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf) ;
@@ -57,6 +60,7 @@ class DistPointSurfTm
       Point3d m_ptMinDistPoint ;
       int     m_nMinDistTriaIndex ;
       bool    m_bIsInside ;
+      bool    m_bIsSurfClosed ;
 } ;
 
 //----------------------------------------------------------------------------

EGkExtDimension.h

@@ -36,8 +36,11 @@ class __declspec( novtable) IExtDimension : public IGeoObj
                               const Vector3d& vtN, const std::string& sText) = 0 ;
       virtual bool SetDiametral( const Point3d& ptCen, const Point3d& ptPos,
                                  const Vector3d& vtN, const std::string& sText) = 0 ;
-      virtual bool SetAngular( const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptV, const Point3d& ptPos,
-                               const Vector3d& vtN, const std::string& sText ) = 0 ;
+      virtual bool SetAngular( const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
+                               const Vector3d& vtN, const std::string& sText) = 0 ;
+      virtual bool SetAngularEx( const Point3d& ptV1, const Point3d& ptP1,
+                                 const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptPos,
+                                 const Vector3d& vtN, const std::string& sText) = 0 ;
       virtual const Vector3d& GetNormVersor( void) const = 0 ;
       virtual const Vector3d& GetDirVersor( void) const = 0 ;
       virtual const std::string& GetText( void) const = 0 ;
@@ -55,6 +58,7 @@ class __declspec( novtable) IExtDimension : public IGeoObj
       virtual double GetTextHeight( void) const = 0 ;
       virtual bool GetMidPoint( Point3d& ptMid) const = 0 ;
       virtual bool GetCenterPoint( Point3d& ptCen) const = 0 ;
+      virtual const std::string& GetSubType( void) const = 0 ;
       virtual bool ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const = 0 ;
 } ;
 

EGkFrame3d.h

@@ -116,11 +116,22 @@ operator/( const Frame3d& frRef, const Frame3d& frDest)
    return frNew ;
 }
 
+//----------------------------------------------------------------------------
+//! Restituisce il frame inverso di quello passato
+//----------------------------------------------------------------------------
+inline const Frame3d 
+GetInvert( const Frame3d& frRef)
+{
+   Frame3d frNew = GLOB_FRM ;
+   frNew.ToLoc( frRef) ;
+   return frNew ;
+}
+
 //----------------------------------------------------------------------------
 //! Restituisce una copia in locale del frame passato
 //----------------------------------------------------------------------------
 inline const Frame3d 
-GetToLoc ( const Frame3d& frRef, const Frame3d& frDest)
+GetToLoc( const Frame3d& frRef, const Frame3d& frDest)
 {
    Frame3d frNew = frRef ;
    frNew.ToLoc( frDest) ;

EGkGdbConst.h

@@ -58,7 +58,8 @@ enum GdbStatus { GDB_ST_OFF = 0,
 
 //----------------- Costanti marcatura oggetti del DB geometrico ---------------
 enum GdbMark { GDB_MK_OFF = 0,
-               GDB_MK_ON =  1} ;
+               GDB_MK_ON =  1,
+               GDB_MK_ON_2 = 2} ;
 
 //----------------- Costante per numero proprietà temporanee -------------------
 const int GDB_NUM_TEMP_PROP = 2 ;
@@ -88,3 +89,4 @@ const std::string GDB_SI_DUPLIST = "!DLST" ;         // Duplo Vettore Id entit
 const std::string GDB_SI_DUPMODIF = "!DMOD" ;        // Flag di sorgente per duplo modificato
 const std::string GDB_SI_DUPLOCKED = "!DLOK" ;       // Flag di duplo bloccato (da non aggiornare seguendo originale)
 const std::string GDB_SI_DUPTOUPDATE = "!DTUP" ;     // Flag di duplo da aggiornare quando sbloccato
+const std::string GDB_SI_SHOWEDGES = "!SEDG" ;       // Flag per forzare visualizzazione spigoli vivi anche in shading

EGkGdbFunct.h

@@ -80,7 +80,7 @@ CalcMark( int nObjMark, int nParentMark)
    if ( nObjMark == GDB_MK_OFF  &&  nParentMark == GDB_MK_OFF)
       return GDB_MK_OFF ;
 
-   return GDB_MK_ON ;
+   return ( nParentMark != GDB_MK_OFF ? nParentMark : nObjMark) ;
 }
 // ovviamente la marcatura si combina con lo stato, nel senso che un oggetto 
 // non visibile non viene nemmeno marcato

EGkGdbIterator.h

@@ -104,7 +104,7 @@ class __declspec( novtable) IGdbIterator
       virtual bool RevertStatus( void) = 0 ;
       virtual bool GetStatus( int& nStat) const = 0 ;
       virtual bool GetCalcStatus( int& nStat) const = 0 ;
-      virtual bool SetMark( void) = 0 ;
+      virtual bool SetMark(  int nMark = GDB_MK_ON) = 0 ;
       virtual bool ResetMark( void) = 0 ;
       virtual bool GetMark( int& nMark) const = 0 ;
       virtual bool GetCalcMark( int& nMark) const = 0 ;

EGkGeoCollection.h

@@ -15,6 +15,7 @@
 
 #include "/EgtDev/Include/EGkPoint3d.h"
 #include "/EgtDev/Include/EGkBBox3d.h"
+#include "/EgtDev/Include/EGkFrame3d.h"
 #include "/EgtDev/Include/EGkCurvePointDiffGeom.h"
 #include "/EgtDev/Include/EgtNumCollection.h"
 
@@ -52,6 +53,12 @@ typedef std::list<CrvPointDiffGeom>    CPDGLIST ;     // lista di CrvPointDiffGe
 typedef std::vector<Vector3d>  VCT3DVECTOR ;   // vettore di vettori 3d
 typedef std::list<Vector3d>    VCT3DLIST ;     // lista di vettori 3d
 
+//----------------------------------------------------------------------------
+// Raccolte di Frame3d
+typedef std::vector<Frame3d>  FRAME3DVECTOR ;                   // vettore di riferimenti 3d
+typedef std::list<Frame3d>    FRAME3DLIST ;                     // lista di riferimenti 3d
+typedef std::vector<std::pair<Frame3d,int>>  FRAME3DIVECTOR ;   // vettore di riferimenti 3d e Id
+
 //----------------------------------------------------------------------------
 // Raccolte di BBox3d
 typedef std::vector<BBox3d>  BOXVECTOR ;                   // vettore di bounding box 3d
@@ -63,3 +70,15 @@ typedef std::vector<std::pair<BBox3d,int>>  BOXIVECTOR ;   // vettore di boundin
 typedef std::pair<Point3d,Vector3d> PNTVECT ;        // coppia punto, vettore
 typedef std::vector<PNTVECT>        PNTVECTVECTOR ;  // vettore di coppie punto, vettore
 typedef std::list<PNTVECT>          PNTVECTLIST ;    // lista di coppie punto, vettore
+
+//----------------------------------------------------------------------------
+// Raccolte di coppie Point3d,Bool
+typedef std::pair<Point3d, bool>  PNTBOOL ;           // coppia punto, bool
+typedef std::vector<PNTBOOL>      PNTBOOLVECTOR ;     // vettore di coppie punto, bool
+typedef std::list<PNTBOOL>        PNTBOOLLIST ;       // lista di coppie punto, bool
+
+//----------------------------------------------------------------------------
+// Raccolte di triplette Point3d,dU,vector<Vector3d>
+typedef std::tuple<Point3d, double, VCT3DVECTOR> PNTUVVECT ;       // tripletta punto, parametro, vettore di Vector3d
+typedef std::vector<PNTUVVECT>                   PNTUVVECTVECTOR ; // vettore di triplette punto, parametro, vettore di Vector3d
+typedef std::list<PNTUVVECT>                     PNTUVVECTLIST ;   // lista di triplette punto, parametro, vettore di Vector3d

EGkGeoObjSave.h

@@ -15,13 +15,14 @@
 
 #include "/EgtDev/Include/EGkGeomDB.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
+#include "/EgtDev/Include/EGkSurfFlatRegion.h"
 
 
 //----------------------------------------------------------------------------
 bool
 SaveGeoObj( IGeoObj* pGObj, const std::string& sFile, int nFlag = GDB_SV_BIN)
 {
-  // verifico validità oggetto
+  // verifico validità oggetto
    if ( pGObj == nullptr  ||  ! pGObj->IsValid())
       return false ;
   // creo GeomDB temporaneo
@@ -47,7 +48,7 @@ bool
 SaveGeoObj( std::vector<IGeoObj*> vpGObj, const std::string& sFile, int nFlag = GDB_SV_BIN)
 {
    for ( int i = 0 ; i < int( vpGObj.size()); ++i) {
-     // verifico validità oggetto
+     // verifico validità oggetto
       if ( vpGObj[i] == nullptr  ||  ! vpGObj[i]->IsValid() )
          return false ;
    }
@@ -74,5 +75,182 @@ SaveGeoObj( std::vector<IGeoObj*> vpGObj, const std::string& sFile, int nFlag =
    for ( int i = 0 ; i < int( vIds.size()); ++i)
       bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr ) && bOk ;
 
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SaveGeoObj( std::vector<std::vector<IGeoObj*>> vvpGObj, std::vector<Color> vCol,
+            const std::string& sFile, int nFlag = GDB_SV_BIN)
+{
+  // verifico validità oggetti
+   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++ i) {
+      for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j) {
+         if ( vvpGObj[i][j] == nullptr  ||  ! vvpGObj[i][j]->IsValid())
+            return false ;
+      }
+   }
+   if ( int( vCol.size()) <= int( vvpGObj.size())) {
+      for ( int i = int( vCol.size()) ; i < int( vvpGObj.size()) ; ++ i)
+         vCol.push_back( BLACK) ;
+   }
+   else
+      return false ;
+
+  // creo GeomDB temporaneo
+   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
+   if ( IsNull( pGeomDB))
+      return false ;
+   INTVECTOR vIds ;
+   int nLayId = 0 ;
+
+  // creo il part
+   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
+
+  // per ogni elemento i-esimo, creo un layer
+   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++i) {
+     // creo il layer
+      nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
+      pGeomDB->SetMaterial( nLayId, vCol[i]) ;
+
+      for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j ) {
+        // inserisco gli oggetti corrispondenti
+         int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vvpGObj[i][j]) ;
+         vIds.push_back( nId) ;
+         if ( nId == GDB_ID_NULL)
+            return false ;
+      }
+   }
+
+  // eseguo il salvataggio
+   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
+  // rimuovo l'oggetto dal GeomDB
+   for ( int i = 0 ; i < int( vIds.size()) ; ++i)
+      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr) && bOk ;
+
+   return bOk ;
+}
+
+bool SaveSfrBooleans( const ISurfFlatRegion* pSfrA, const ISurfFlatRegion* pSfrB,
+                      const std::string& sFile, int nFlag = GDB_SV_BIN,
+                      Color cColA = Color( 0., .5, .75, .5), Color cColB = Color( 0., .5, 0., .5))
+{
+  // verifico validità superfici
+   if ( pSfrA == nullptr  ||  ! pSfrA->IsValid()  ||
+        pSfrB == nullptr  ||  ! pSfrB->IsValid())
+      return false ;
+  // creo GeomDB temporaneo
+   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
+   if ( IsNull( pGeomDB))
+      return false ;
+  // inserisco le superfici nel GeomDB (sotto pezzo/layer)
+   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
+   int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
+   int nIdSfrA = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, static_cast<IGeoObj*>( CloneSurfFlatRegion( pSfrA))) ;
+   if ( nIdSfrA == GDB_ID_NULL)
+      return false ;
+   pGeomDB->SetMaterial( nIdSfrA, cColA) ;
+   int nIdSfrB = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, static_cast<IGeoObj*>( CloneSurfFlatRegion( pSfrB))) ;
+   if ( nIdSfrB == GDB_ID_NULL)
+      return false ;
+   pGeomDB->SetMaterial( nIdSfrB, cColB) ;
+  // vettor di indici aggiunti
+   INTVECTOR vIds = { nIdSfrA, nIdSfrB} ;
+  // eseguo il salvataggio
+   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
+  // rimuovo l'oggetto dal GeomDB
+   for ( int i = 0 ; i < int( vIds.size()) ; ++i)
+      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr)  &&  bOk ;
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SaveGeoObj( std::vector<std::vector<IGeoObj*>> vvpGObj, std::vector<std::vector<Color>> vvCol,
+            const std::string& sFile, int nFlag = GDB_SV_BIN)
+{
+  // verifico validità oggetti
+   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++ i) {
+      for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j) {
+         if ( vvpGObj[i][j] == nullptr  ||  ! vvpGObj[i][j]->IsValid())
+            return false ;
+      }
+   } 
+
+  // creo GeomDB temporaneo
+   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
+   if ( IsNull( pGeomDB))
+      return false ;
+   INTVECTOR vIds ;
+
+   // creo il part
+   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
+
+   // per ogni elemento i-esimo, creo un layer
+   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++i) {
+      // creo il layer
+      int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
+      for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j ) {
+        // inserisco gli oggetti corrispondenti
+         int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vvpGObj[i][j]) ;
+         if ( nId == GDB_ID_NULL)
+            return false ;
+        // setto il colore ( se definito)
+         if ( i < int( vvCol.size()) && j < int( vvCol[i].size()))
+            pGeomDB->SetMaterial( nId, vvCol[i][j]) ;
+         vIds.push_back( nId) ;        
+      }
+   }
+
+  // eseguo il salvataggio
+   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
+  // rimuovo l'oggetto dal GeomDB
+   for ( int i = 0 ; i < int( vIds.size()) ; ++i)
+      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr) && bOk ;
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SaveGeoObj( std::vector<IGeoObj*> vpGObj, std::vector<Color> vCol,
+            const std::string& sFile, int nFlag = GDB_SV_BIN)
+{
+  // verifico validità oggetti
+   if ( int( vpGObj.size()) != int( vCol.size()))
+      return false ;
+
+  // creo GeomDB temporaneo
+   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
+   if ( IsNull( pGeomDB))
+      return false ;
+   INTVECTOR vIds ;
+
+   // creo il part
+   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ; 
+  // creo il layer
+   int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
+
+  // scorro gli elementi da visualizzare
+   for ( int i = 0 ; i < int( vpGObj.size()) ; ++ i) {
+      if ( vpGObj[i] == nullptr  ||  ! vpGObj[i]->IsValid())
+         continue ;
+     // inserisco gli oggetti corrispondenti
+      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vpGObj[i]) ;
+      if ( nId == GDB_ID_NULL)
+         return false ;
+     // setto il colore
+      pGeomDB->SetMaterial( nId, vCol[i]) ;
+     // aggiungo l'Id ottenuto
+      vIds.push_back( nId) ;
+   }
+
+  // eseguo il salvataggio
+   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
+  // rimuovo l'oggetto dal GeomDB
+   for ( int i = 0 ; i < int( vIds.size()) ; ++i)
+      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr) && bOk ;
+
    return bOk ;
 }

EGkGeomDB.h

@@ -134,7 +134,7 @@ class __declspec( novtable) IGeomDB
       virtual bool RevertStatus( int nId) = 0 ;
       virtual bool GetStatus( int nId, int& nStat) const = 0 ;
       virtual bool GetCalcStatus( int nId, int& nStat) const = 0 ;
-      virtual bool SetMark( int nId) = 0 ;
+      virtual bool SetMark( int nId, int nMark = GDB_MK_ON) = 0 ;
       virtual bool ResetMark( int nId) = 0 ;
       virtual bool GetMark( int nId, int& nMark) const = 0 ;
       virtual bool GetCalcMark( int nId, int& nMark) const = 0 ;

EGkHashGrids1d.h

@@ -56,11 +56,11 @@ private :
    typedef std::list<ObjData> ObjList ; 
    typedef std::vector<ObjData*> PtrObjVector ;
    typedef std::unordered_map<int,ObjData*> IntPObjUmap ;
+   typedef std::list<HashGrid1d*> GridList ;
 
 private :
-   typedef std::list<HashGrid1d*> GridList ;  // Tipo per lista di hash grid
-
-private :
+   HashGrids1d( const HashGrids1d&) = delete ;
+   HashGrids1d& operator=( const HashGrids1d&) = delete ;
    void addGrid( ObjData& obj) ;
    void addList( ObjData& obj) ;
 

EGkHashGrids2d.h

@@ -56,11 +56,11 @@ class HashGrids2d
       typedef std::list<ObjData> ObjList ; 
       typedef std::vector<ObjData*> PtrObjVector ;
       typedef std::unordered_map<int,ObjData*> IntPObjUmap ;
+      typedef std::list<HashGrid2d*> GridList ;
 
    private :
-      typedef std::list<HashGrid2d*> GridList ;  // Tipo per lista di hash grid
-
-   private :
+      HashGrids2d( const HashGrids2d&) = delete ;
+      HashGrids2d& operator=( const HashGrids2d&) = delete ;
       void addGrid( ObjData& obj) ;
       void addList( ObjData& obj) ;
 

EGkHashGrids3d.h

@@ -56,11 +56,11 @@ class HashGrids3d
       typedef std::list<ObjData> ObjList ; 
       typedef std::vector<ObjData*> PtrObjVector ;
       typedef std::unordered_map<int,ObjData*> IntPObjUmap ;
+      typedef std::list<HashGrid3d*> GridList ;
 
    private :
-      typedef std::list<HashGrid3d*> GridList ;  // Tipo per lista di hash grid
-
-   private :
+      HashGrids3d( const HashGrids3d&) = delete ;
+      HashGrids3d& operator=( const HashGrids3d&) = delete ;
       void addGrid( ObjData& obj) ;
       void addList( ObjData& obj) ;
 

EGkIntersLineSurfBez.h

@@ -0,0 +1,79 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024
+//----------------------------------------------------------------------------
+// File : EGkIntersLineSurfBez.h      Data : 06.02.24         Versione : 2.6b1
+// Contenuto : Dichiarazione della classe intersezione Linea/SurfTriMesh.
+//
+//
+//
+// Modifiche : 06.02.24 DB Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
+#include "/EgtDev/Include/EGkIntersLineTria.h"
+#include "/EgtDev/Include/EGkHashGrids2d.h"
+#include "/EgtDev/Include/EGkSurfBezier.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
+
+//-----------------------------------------------------------------------------
+//! dati di intersezione linea - superficie trimesh
+struct IntLinSbzInfo {
+   int     nILTT ;          //!< tipo di intersezione linea-triangolo
+   double  dU ;             //!< parametro sulla linea
+   double  dU2 ;            //!< secondo parametro sulla linea
+   int     nT ;             //!< indice del triangolo della superficie trimesh
+   double  dCosDN ;         //!< coseno dell'angolo tra la direzione della linea e la normale del triangolo
+   Point3d ptI ;            //!< punto di intersezione
+   Point3d ptI2 ;           //!< secondo punto di intersezione (termine di tratto sovrapposto)
+   Point3d ptUV ;            //!< coordinate del punto nello spazio parametrico
+   Point3d ptUV2 ;           //!< coordinate del secondo punto nello spazio parametrico
+   // costruttori
+   IntLinSbzInfo( void) : nILTT( ILTT_NO), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2(), ptUV(), ptUV2(){}
+   IntLinSbzInfo( int nIL, double dUU, int nTT, double dCos, const Point3d& ptP, const Point3d ptSP)
+      : nILTT( nIL), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2(), ptUV( ptSP), ptUV2() {}
+   IntLinSbzInfo( int nIL, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2, const Point3d& ptSP, const Point3d& ptSP2)
+      : nILTT( nIL), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2), ptUV( ptSP), ptUV2( ptSP2) {}
+} ;
+//! vettore di IntLinSbzInfo
+typedef std::vector<IntLinSbzInfo>  ILSBIVECTOR ;
+
+//-----------------------------------------------------------------------------
+// Costanti tipo intersezione Linea SurfTriMesh dopo filtraggio
+enum LSBiType { LSBT_NONE =  0,
+                LSBT_IN =  1,
+                LSBT_OUT = 2,
+                LSBT_TG_INI = 3,
+                LSBT_TG_FIN = 4,
+                LSBT_TOUCH = 5} ;
+
+//-----------------------------------------------------------------------------
+EGK_EXPORT bool IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfBezier* pSBz,
+                                  ILSBIVECTOR& vInfo, bool bFinite = true) ;
+
+//-----------------------------------------------------------------------------
+class IntersParLinesSurfBz
+{
+public :
+   EGK_EXPORT IntersParLinesSurfBz( const Frame3d& frLines, const ISurfBezier& SBz) ;
+   EGK_EXPORT bool GetInters( const Point3d& ptL, double dLen, ILSBIVECTOR& vInfo, bool bFinite = true) const ;
+
+private :
+   bool                m_bOk ;
+   const Frame3d       m_frLines ;
+   const ISurfBezier*  m_pSBz ;
+   HashGrids2d         m_HGrids ;
+} ;
+
+//-----------------------------------------------------------------------------
+EGK_EXPORT bool FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters) ;

EGkLuaAux.h

@@ -1,13 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2015
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkLuaAux.h       Data : 21.03.15        Versione : 1.6c6
+// File : EGkLuaAux.h       Data : 08.05.24        Versione : 2.6e2
 // Contenuto : Funzioni per gestione parametri geometrici con LUA.
 //
 //
 //
 // Modifiche : 21.03.15 DS Creazione modulo.
-//
+//             14.04.24 DS Aggiunta gestione Quaternion.
+//             08.05.24 DS Aggiunta LuaSetParam per VCT3DVECTOR.
 //
 //----------------------------------------------------------------------------
 
@@ -17,6 +18,7 @@
 #include "/EgtDev/Include/EGkPoint3d.h"
 #include "/EgtDev/Include/EGkFrame3d.h"
 #include "/EgtDev/Include/EGkBBox3d.h"
+#include "/EgtDev/Include/EGkQuaternion.h"
 #include "/EgtDev/Include/EGkColor.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
 #include "/EgtDev/Include/EGkSelection.h"
@@ -25,12 +27,16 @@
 //----------------------------------------------------------------------------
 inline bool
 LuaGetParam( lua_State* L, int nInd, Vector3d& vtPar)
-{  return LuaGetParam( L, nInd, vtPar.v) ; }
+{
+   return LuaGetParam( L, nInd, vtPar.v) ;
+}
 
 //----------------------------------------------------------------------------
 inline bool
 LuaGetParam( lua_State* L, int nInd, Point3d& ptPar)
-{  return LuaGetParam( L, nInd, ptPar.v) ; }
+{
+   return LuaGetParam( L, nInd, ptPar.v) ;
+}
 
 //----------------------------------------------------------------------------
 inline bool
@@ -114,6 +120,13 @@ LuaGetParam( lua_State* L, int nInd, BBox3d& b3Par)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+inline bool
+LuaGetParam( lua_State* L, int nInd, Quaternion& qtPar)
+{
+   return LuaGetParam( L, nInd, qtPar.v) ;
+}
+
 //----------------------------------------------------------------------------
 inline bool
 LuaGetParam( lua_State* L, int nInd, Color& colPar)
@@ -264,6 +277,33 @@ LuaSetParam( lua_State* L, const Vector3d& vtPar)
    return true ;
 }
 
+//-------------------------------------------------------------------------------
+inline bool
+LuaSetParam( lua_State* L, const VCT3DVECTOR& vPar)
+{
+   try {
+     // recupero dimensione vettore
+      int nDim = int( vPar.size()) ;
+     // creo tavola principale
+      lua_createtable( L, nDim, 0) ;
+     // creo e inserisco tavola per ogni componente
+      for ( int i = 1 ; i <= nDim ; ++ i) {
+        // creo tavola componente
+         lua_createtable( L, 3, 0) ;
+         for ( int j = 1 ; j <= 3 ; ++ j) {
+            lua_pushnumber( L, vPar[i-1].v[j-1]) ;
+            lua_rawseti( L, -2, j) ;
+         }
+         // la metto nel vettore
+         lua_rawseti( L, -2, i) ;
+      }
+   }
+   catch( ...) {
+      return false ;
+   }
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 inline bool
 LuaSetParam( lua_State* L, const Point3d& ptPar)
@@ -369,6 +409,23 @@ LuaSetParam( lua_State* L, const BBox3d& b3Par)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+inline bool
+LuaSetParam( lua_State* L, const Quaternion& qtPar)
+{
+   try {
+      lua_createtable( L, 4, 0) ;
+      for ( int i = 1 ; i <= 4 ; ++ i) {
+         lua_pushnumber( L, qtPar.v[i-1]) ;
+         lua_rawseti( L, -2, i) ;
+      }
+   }
+   catch( ...) {
+      return false ;
+   }
+   return true ;
+}
+
 //-------------------------------------------------------------------------------
 inline bool
 LuaSetParam( lua_State* L, const Color& colPar)

EGkOffsetCurve.h

@@ -1,12 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2019
+//  EgalTech 2015-2025
 //----------------------------------------------------------------------------
-// File : EGkOffsetCurve.h       Data : 24.06.19       Versione : 2.1f2
+// File : EGkOffsetCurve.h       Data : 08.04.25       Versione : 2.7d1
 // Contenuto : Dichiarazione classe per offset di ICurve.
 //
 //
 // Modifiche : 23.09.15 DS Creazione modulo.
 //             24.06.19 DS Agg. GetShorterCurve.
+//             08.04.25 SP Agg. GetPointOffset.
 //
 //----------------------------------------------------------------------------
 
@@ -37,10 +38,13 @@ class OffsetCurve
       EGK_EXPORT ICurve* GetCurve( void) ;
       EGK_EXPORT ICurve* GetLongerCurve( void) ;
       EGK_EXPORT ICurve* GetShorterCurve( void) ;
+      EGK_EXPORT bool GetPointOffset( Point3d& ptOffs, Vector3d& vtOut) ;
       EGK_EXPORT double GetLinTol( void) const { return m_dLinTol ; }
       EGK_EXPORT void SetLinTol( double dTol) { m_dLinTol = dTol ; }
 
    private :
       ICURVEPLIST m_CrvLst ;
+      Point3d m_ptOffs = P_INVALID ;
+      Vector3d m_vtOut = V_INVALID ;
       double m_dLinTol ;
 } ;

EGkPoint3d.h

@@ -323,7 +323,16 @@ DirDist( const Point3d& ptP1, const Point3d& ptP2, Vector3d& vtDir, double& dDis
 inline bool
 AreSamePointEpsilon( const Point3d& ptP1, const Point3d& ptP2, double dToler)
 {
-   return ( SqDist( ptP1, ptP2) < ( dToler * dToler)) ;
+   double dX = ptP1.x - ptP2.x ;
+   if ( abs( dX) > dToler)
+      return false ;
+   double dY = ptP1.y - ptP2.y ;
+   if ( abs( dY) > dToler)
+      return false ;
+   double dZ = ptP1.z - ptP2.z ;
+   if ( abs( dZ) > dToler)
+      return false ;
+   return ( ( dX * dX + dY * dY + dZ * dZ) < ( dToler * dToler)) ;
 }
 
 //----------------------------------------------------------------------------
@@ -341,7 +350,16 @@ AreSamePointXYEpsilon( const Point3d& ptP1, const Point3d& ptP2, double dToler)
 inline bool
 AreSamePointApprox( const Point3d& ptP1, const Point3d& ptP2)
 {
-   return ( SqDist( ptP1, ptP2) < SQ_EPS_SMALL) ;
+   double dX = ptP1.x - ptP2.x ;
+   if ( abs( dX) > EPS_SMALL)
+      return false ;
+   double dY = ptP1.y - ptP2.y ;
+   if ( abs( dY) > EPS_SMALL)
+      return false ;
+   double dZ = ptP1.z - ptP2.z ;
+   if ( abs( dZ) > EPS_SMALL)
+      return false ;
+   return ( ( dX * dX + dY * dY + dZ * dZ) < SQ_EPS_SMALL) ;
 }
 
 //----------------------------------------------------------------------------
@@ -359,7 +377,16 @@ AreSamePointXYApprox( const Point3d& ptP1, const Point3d& ptP2)
 inline bool
 AreSamePointExact( const Point3d& ptP1, const Point3d& ptP2)
 {
-   return ( SqDist( ptP1, ptP2) < SQ_EPS_ZERO) ;
+   double dX = ptP1.x - ptP2.x ;
+   if ( abs( dX) > EPS_ZERO)
+      return false ;
+   double dY = ptP1.y - ptP2.y ;
+   if ( abs( dY) > EPS_ZERO)
+      return false ;
+   double dZ = ptP1.z - ptP2.z ;
+   if ( abs( dZ) > EPS_ZERO)
+      return false ;
+   return ( ( dX * dX + dY * dY + dZ * dZ) < SQ_EPS_ZERO) ;
 }
 
 //----------------------------------------------------------------------------

EGkPolyLine.h

@@ -113,6 +113,7 @@ class PolyLine
       EGK_EXPORT bool MakeConvex( const Vector3d& vtN,  bool bLeftSide) ;
       EGK_EXPORT bool Invert( bool bInvertU = true) ;
       EGK_EXPORT bool Flatten( double dZ = 0) ;
+      EGK_EXPORT bool FlattenInAutoPlane( double dToler = 10 * EPS_SMALL) ;
       EGK_EXPORT bool GetConvexHullXY( PNTVECTOR& vConvHull) const ;
       EGK_EXPORT bool GetMinAreaRectangleXY( Point3d& ptCen, Vector3d& vtAx, double& dLen, double& dHeight) const ;
       EGK_EXPORT bool Trim( const Plane3d& plPlane, bool bInVsOut = true) ;
@@ -126,6 +127,7 @@ class PolyLine
       bool MyChangeStart( int nPos) ;
       bool MyApproxOnSide( const Vector3d& vtN, bool bLeftSide, double dToler = EPS_SMALL) ;
       bool MyMakeConvex( const Vector3d& vtN,  bool bLeftSide) ;
+      bool MyRemoveSamePoints( double dToler = EPS_SMALL) ;
 
    private :
       int      m_nRejected ;                       // numero punti rifiutati perchè coincidenti

EGkProjectCurveSurf.h

@@ -0,0 +1,56 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : EGkProjectCurveSurfTm.h     Data : 31.08.23      Versione : 2.5h3
+// Contenuto : Dichiarazione funzioni proiezione curve su superficie Trimesh.
+//
+//
+//
+// Modifiche : 31.08.23 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
+#include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EGkSurf.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
+
+//----------------------------------------------------------------------------
+// Definizione di Punto 5assi e sue raccolte
+struct Point5ax {
+   Point3d  ptP ;
+   Vector3d vtDir1 ;
+   Vector3d vtDir2 ;
+   double   dPar ;
+   int      nFlag ;
+   Point5ax( void) : ptP(), vtDir1(), vtDir2(), dPar(), nFlag() {} ;
+   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, double dU, int nData)
+      : ptP( ptBase), vtDir1( vtTool), vtDir2(), dPar( dU), nFlag( nData) {} ;
+   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2, double dU, int nData)
+      : ptP( ptBase), vtDir1( vtTool), vtDir2( vtTool2), dPar( dU), nFlag( nData) {} ;
+} ; 
+typedef std::vector<Point5ax>        PNT5AXVECTOR ;    // vettore di Punti 5assi
+
+//----------------------------------------------------------------------------
+// Proiezione di una curva su una superficie TriMesh lungo la direzione data.
+EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const ISurf& sfSurf, const Vector3d& vtDir,
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una superficie TriMesh in direzione del punto
+EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const ISurf& sfSurf, const IGeoPoint3d& gpRef,
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una superficie TriMesh in direzione della curva
+EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const ISurf& sfSurf, const ICurve& crRef,
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una superficie TriMesh in direzione della superficie
+EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const ISurf& sfSurf, const ISurf& sfRef,
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;

EGkProjectCurveSurfTm.h

@@ -1,43 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : EGkProjectCurveSurfTm.h     Data : 31.08.23      Versione : 2.5h3
-// Contenuto : Dichiarazione funzioni proiezione curve su superficie Trimesh.
-//
-//
-//
-// Modifiche : 31.08.23 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkSurfTriMesh.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
-
-//----------------------------------------------------------------------------
-// Definizione di Punto 5assi e sue raccolte
-struct Point5ax {
-   Point3d  ptP ;
-   Vector3d vtDir ;
-   double   dPar ;
-   int      nFlag ;
-   Point5ax( void) : ptP(), vtDir(), dPar(), nFlag() {} ;
-   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, double dU, int nData)
-      : ptP( ptBase), vtDir( vtTool), dPar( dU), nFlag( nData) {} ;
-} ; 
-typedef std::vector<Point5ax>        PNT5AXVECTOR ;    // vettore di Punti 5assi
-
-//----------------------------------------------------------------------------
-// Proiezione di una curva su una superficie TriMesh lungo la direzione data.
-EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir,
-                                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;

EGkQuaternion.h

@@ -0,0 +1,174 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EGkQuaternion.h          Data : 13.04.243         Versione : 2.6d4
+// Contenuto : Dichiarazione della classe Quaternion.
+//
+//
+//
+// Modifiche : 31.12.13 DS Creazione modulo.
+//
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#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
+
+//-----------------------------------------------------------------------------
+class EGK_EXPORT Quaternion
+{
+   public :
+      Quaternion( double dW = 0, double dX = 0, double dY = 0, double dZ = 0) : w( dW), x( dX), y( dY), z( dZ) {}
+
+   public :
+      bool IsValid( void) const
+             { return ( std::isfinite( w)  &&  std::isfinite( x)  &&  std::isfinite( y)  &&  std::isfinite( z)) ; }
+      bool IsSmall( void) const
+             { return ( ( w * w + x * x + y * y + z * z) < SQ_EPS_SMALL) ; }
+      bool IsZero( void) const
+             { return ( ( w * w + x * x + y * y + z * z) < SQ_EPS_ZERO) ; }
+      bool IsUnit( void) const
+             { return ( abs( w - 1) < EPS_ZERO  &&  ( x * x + y * y + z * z) < SQ_EPS_ZERO) ; }
+      double SqLen( void) const
+             { return ( w * w + x * x + y * y + z * z) ; }
+      double Len( void) const ;
+      bool Normalize( double dEps = EPS_SMALL) ;
+      bool IsNormalized( void) const
+             { return ( abs( 1.0 - ( w * w + x * x + y * y + z * z)) < ( 2 * EPS_ZERO)) ; }
+      Quaternion& operator +=( const Quaternion& qtQ)
+             { w += qtQ.w ; x += qtQ.x ; y += qtQ.y ; z += qtQ.z ; return *this ; }
+      Quaternion& operator -=( const Quaternion& qtQ)
+             { w -= qtQ.w ;  x -= qtQ.x ; y -= qtQ.y ; z -= qtQ.z ; return *this ; }
+      Quaternion& operator *=( double dMul)
+             { w *= dMul ; x *= dMul ; y *= dMul ; z *= dMul ; return *this ; }
+      Quaternion& operator /=( double dDiv)
+             { double dMul = 1 / dDiv ; w *= dMul ; x *= dMul ; y *= dMul ; z *= dMul ; return *this ; }
+
+   public :
+      union {
+         struct {
+            double w ;
+            double x ;
+            double y ;
+            double z ;
+         } ;
+         double v[4] ;
+      } ;
+} ;
+
+//----------------------------------------------------------------------------
+// Quaternioni notevoli
+//----------------------------------------------------------------------------
+// Quaternione non valido
+const Quaternion Q_INVALID( NAN, NAN, NAN, NAN) ;
+// Quaternione unità
+const Quaternion Q_UNIT( 1, 0, 0, 0) ;
+// Quaternione nullo
+const Quaternion Q_NULL( 0, 0, 0, 0) ;
+
+//----------------------------------------------------------------------------
+// Definizione da rotazione definita con asse e angolo e inverso
+//----------------------------------------------------------------------------
+EGK_EXPORT Quaternion FromAxisAngle( const Vector3d& vtAx, double dAngDeg) ;
+EGK_EXPORT bool ToAxisAngle( const Quaternion& qtQ, Vector3d& vtAx, double& dAngDeg) ;
+
+//----------------------------------------------------------------------------
+// Definizione da parte rotazione di un sistema di riferimento e inverso
+//----------------------------------------------------------------------------
+EGK_EXPORT Quaternion FromFrame( const Frame3d& frRef) ;
+EGK_EXPORT bool ToFrame( const Quaternion& qtQ, Frame3d& frRef) ;
+
+//----------------------------------------------------------------------------
+// Coniugato di un quaternione
+//----------------------------------------------------------------------------
+inline const Quaternion 
+Conjugate( const Quaternion& qtQ)
+{
+   return ( Quaternion( qtQ.w, -qtQ.x, -qtQ.y, -qtQ.z)) ; 
+}
+
+//----------------------------------------------------------------------------
+// Opposto di un quaternione
+//----------------------------------------------------------------------------
+inline const Quaternion 
+operator-( const Quaternion& qtQ)
+{
+   return ( Quaternion( -qtQ.w, - qtQ.x, - qtQ.y, - qtQ.z)) ; 
+}
+
+//----------------------------------------------------------------------------
+// Somma di due quaternioni
+//----------------------------------------------------------------------------
+inline const Quaternion 
+operator+( const Quaternion& qtQ1, const Quaternion& qtQ2)
+{
+   return ( Quaternion( qtQ1.w + qtQ2.w, qtQ1.x + qtQ2.x, qtQ1.y + qtQ2.y, qtQ1.z + qtQ2.z)) ; 
+}
+
+//----------------------------------------------------------------------------
+// Sottrazione di due quaternioni
+//----------------------------------------------------------------------------
+inline const Quaternion 
+operator-( const Quaternion& qtQ1, const Quaternion& qtQ2)
+{
+   return ( Quaternion( qtQ1.w - qtQ2.w, qtQ1.x - qtQ2.x, qtQ1.y - qtQ2.y, qtQ1.z - qtQ2.z)) ; 
+}
+
+//----------------------------------------------------------------------------
+//  Prodotto di un quaternione con uno scalare
+//----------------------------------------------------------------------------
+inline const Quaternion 
+operator*( const Quaternion& qtQ, double dMul)
+{
+   return ( Quaternion( qtQ.w * dMul, qtQ.x * dMul, qtQ.y * dMul, qtQ.z * dMul)) ; 
+}
+
+//----------------------------------------------------------------------------
+//  Prodotto di uno scalare con un quaternione
+//----------------------------------------------------------------------------
+inline const Quaternion 
+operator*( double dMul, const Quaternion& qtQ)
+{
+   return ( Quaternion( qtQ.w * dMul, qtQ.x * dMul, qtQ.y * dMul, qtQ.z * dMul)) ; 
+}
+
+//----------------------------------------------------------------------------
+//  Divisione con uno scalare
+//----------------------------------------------------------------------------
+inline const Quaternion 
+operator/( const Quaternion& qtQ, double dDiv)
+{
+   double dMul = 1 / dDiv ;
+   return ( Quaternion( qtQ.w * dMul, qtQ.x * dMul, qtQ.y * dMul, qtQ.z * dMul)) ; 
+}
+
+//----------------------------------------------------------------------------
+// Prodotto scalare due quaternioni
+//----------------------------------------------------------------------------
+inline double 
+Scalar( const Quaternion& qtQ1, const Quaternion& qtQ2)
+{
+   return ( qtQ1.w * qtQ2.w + qtQ1.x * qtQ2.x + qtQ2.y * qtQ2.y + qtQ1.z * qtQ2.z) ; 
+}
+
+//----------------------------------------------------------------------------
+// Prodotto di due quaternioni
+//----------------------------------------------------------------------------
+inline const Quaternion
+operator*( const Quaternion& qtQ1, const Quaternion& qtQ2)
+{
+   return ( Quaternion( qtQ1.w * qtQ2.w - qtQ1.x * qtQ2.x - qtQ1.y * qtQ2.y - qtQ1.z * qtQ2.z,
+                        qtQ1.w * qtQ2.x + qtQ1.x * qtQ2.w + qtQ1.y * qtQ2.z - qtQ1.z * qtQ2.y,
+                        qtQ1.w * qtQ2.y + qtQ1.y * qtQ2.w + qtQ1.z * qtQ2.x - qtQ1.x * qtQ2.z,
+                        qtQ1.w * qtQ2.z + qtQ1.z * qtQ2.w + qtQ1.x * qtQ2.y - qtQ1.y * qtQ2.x)) ;
+}

EGkRotationMinimizingFrame.h

@@ -0,0 +1,50 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EGkRotationMinimizingFrame.h    Data : 05.04.24   Versione : 2.6d1
+// Contenuto : Dichiarazione della classe RotationMinimizingFrame.
+//
+//
+//
+// Modifiche : 05.04.24 RE Creazione modulo.
+
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EGkGeoCollection.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 EGK_EXPORT RotationMinimizingFrame
+{
+   public :
+      RotationMinimizingFrame( void)
+         : m_pCrv( nullptr), m_Frame0() {}
+      ~RotationMinimizingFrame( void)
+         { Clear() ; }
+      bool Set( const ICurve* pCrv, const Frame3d& fr_Start) ;
+
+   public :
+      bool GetFramesByStep( double dStep, bool bUniform, FRAME3DVECTOR& vRMFrames) ;
+      bool GetFramesBySplit( int nIntervals, FRAME3DVECTOR& vRMFrames) ;
+      bool GetFramesByTolerance( double dTol, FRAME3DVECTOR& vRMFrames) ;
+   
+   private :
+      bool Clear( void) ;
+      bool IsValid( void) ;
+      bool GetFrameAtParam( const Frame3d& frAct, const double dParNext, Frame3d& frNext) ;
+   
+   private :
+      ICurve* m_pCrv ;           // curva per il calcolo del rotation Xplane frame
+      Frame3d m_Frame0 ;         // frame iniziale della curva
+} ;

EGkRotationXplaneFrame.h

@@ -0,0 +1,51 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EGkRotationXplaneFrame.h      Data : 05.04.24     Versione : 2.6d1
+// Contenuto : Dichiarazione della classe RotationXplaneFrame.
+//
+//
+//
+// Modifiche : 05.04.24 DS Creazione modulo.
+
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EGkGeoCollection.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 EGK_EXPORT RotationXplaneFrame
+{
+   public :
+      RotationXplaneFrame( void)
+         : m_pCrv( nullptr), m_vtNorm(), m_vtNearX() {}
+      ~RotationXplaneFrame( void)
+         { Clear() ; }
+      bool Set( const ICurve* pCrv, const Vector3d& vtNorm, const Vector3d& vtNearX = V_NULL) ;
+
+   public :
+      bool GetFramesByStep( double dStep, bool bUniform, FRAME3DVECTOR& vRXFrames) ;
+      bool GetFramesBySplit( int nIntervals, FRAME3DVECTOR& vRXFrames) ;
+      bool GetFramesByTolerance( double dTol, FRAME3DVECTOR& vRXFrames) ;
+   
+   private :
+      bool Clear( void) ;
+      bool IsValid( void) ;
+      bool GetFrameAtParam( const Frame3d& frAct, const double dParNext, Frame3d& frNext) ;
+   
+   private :
+      ICurve*  m_pCrv ;         // curva per il calcolo del rotation Xplane frame
+      Vector3d m_vtNorm ;       // vettore normale al piano in cui deve sempre giacere l'asse X
+      Vector3d m_vtNearX ;      // vettore a cui deve essere il più vicino possibile la direzione X iniziale
+} ;

EGkSbzFromCurves.h

@@ -0,0 +1,49 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EGkSbzFromCurves.h   Data : 07.05.24       Versione : 2.6d2
+// Contenuto : Prototipi funzioni di creazione TriMesh a partire da curve.
+//
+//
+//
+// Modifiche : 07.05.24 DB Creazione modulo.
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EGkSurfFlatRegion.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
+#include "/EgtDev/Include/EGkSurfBezier.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
+
+////----------------------------------------------------------------------------
+//enum RS_CAP { RSCAP_NONE = 0, RSCAP_FLAT = 1, RSCAP_ROUND = 2, RSCAP_BEVEL = 3} ;
+
+//----------------------------------------------------------------------------
+EGK_EXPORT ISurfBezier* GetSurfBezierByFlatContour( const ICurve* pCurve, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfBezier* GetSurfBezierByRegion( const CICURVEPVECTOR& vpCurve, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfBezier* GetSurfBezierByExtrusion( const ICurve* pCurve, const Vector3d& vtExtr,
+                                                   bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
+//EGK_EXPORT ISurfBezier* GetSurfBezierByRegionExtrusion( const CICURVEPVECTOR& vpCurve, const Vector3d& vtExtr,
+//                                                   double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfBezier* GetSurfBezierByRevolve( const ICurve* pCurve, const Point3d& ptAx,
+                                                   const Vector3d& vtAx, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfBezier* GetSurfBezierByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vector3d& vtAx,
+                                                   double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
+//EGK_EXPORT ISurfBezier* GetSurfBezierRectSwept( double dDimH, double dDimV, double dBevelH, double dBevelV,
+//                                                   const ICurve* pGuide, int nCapType, double dLinTol = 10 * EPS_SMALL) ;
+//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* 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) ;
+EGK_EXPORT ISurfBezier* GetSurfBezierSwept3d( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtNorm, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;

EGkSbzStandard.h

@@ -0,0 +1,27 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024
+//----------------------------------------------------------------------------
+// File : EGkSbzStandard.h   Data : 14.02.24       Versione : 2.6b2
+// Contenuto : Dichiarazione funzioni per creazione superfici Sbz
+//             standard : Box, Pyramid, Cylinder, Sphere, Cone.
+//
+//
+// Modifiche : 14.02.24 DB Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkSurfBezier.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
+
+//----------------------------------------------------------------------------
+EGK_EXPORT ISurfBezier* GetSurfBezierSphere( const Point3d& ptCenter, double dR) ;

EGkSelection.h

@@ -36,6 +36,8 @@ struct SelData {
       : nId( nI), nSub( SEL_SUB_ALL) {}
    SelData( int nI, int nS)
       : nId( nI), nSub( nS) {}
+   bool operator == ( const SelData& other) const
+         { return ( nId == other.nId  &&  nSub == other.nSub) ; }
 } ;
 
 //----------------------------------------------------------------------------

EGkSfrCreate.h

@@ -35,6 +35,8 @@ EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromFatCurve( ICurve* pCrv, double
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromTriangle( const Triangle3d& Tria) ;
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromPolyLine( const PolyLine& ContourPolyLine) ;
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromPolyLineVector( const POLYLINEVECTOR& vContoursPolyLineVec) ;
+EGK_EXPORT bool CalcRegionPolyLines( const POLYLINEVECTOR& vPL, Vector3d& vtN, INTMATRIX& vnPLIndMat, BOOLVECTOR& vbInvert) ;  // la funzione restituisce una matrice con la struttura dei chunk e un vettore che indica se invertire le polyline
+
 
 //----------------------------------------------------------------------------
 class SurfFlatRegionByContours

EGkStmFromCurves.h

@@ -1,8 +1,8 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkStmFromCurves.h   Data : 27.02.24       Versione : 2.6b4
-// Contenuto : Dichiarazione della classe StmFromTriangleSoup.
+// File : EGkStmFromCurves.h   Data : 27.02.24       Versione : 2.6d1
+// Contenuto : Prototipi funzioni di creazione TriMesh a partire da curve.
 //
 //
 //
@@ -41,8 +41,10 @@ EGK_EXPORT ISurfTriMesh* GetSurfTriMeshByScrewing( const ICurve* pCurve, const P
                                                    double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRectSwept( double dDimH, double dDimV, double dBevelH, double dBevelV,
                                                   const ICurve* pGuide, int nCapType, double dLinTol = 10 * EPS_SMALL) ;
-EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL, Vector3d* vtStatic = nullptr) ;
-EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ISurfFlatRegion* pSfrSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL, Vector3d* vtStatic = nullptr) ;
+EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtAx,
+                                              bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ISurfFlatRegion* pSfrSect, const ICurve* pGuide, const Vector3d& vtAx,
+                                              bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 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) ;

EGkStmStandard.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2015
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkStmStandard.h   Data : 31.03.15       Versione : 1.6c7
+// File : EGkStmStandard.h   Data : 04.12.24       Versione : 2.6l2
 // Contenuto : Dichiarazione funzioni per creazione superfici Stm
 //             standard : Box, Pyramid, Cylinder, Sphere, Cone.
 //
 //
 // Modifiche : 31.03.15 DS Creazione modulo.
-//
+//             04.12.24 DS Aggiunta GetSurfTriMeshEmpty.
 //
 //----------------------------------------------------------------------------
 
@@ -24,10 +24,13 @@
 #endif
 
 //----------------------------------------------------------------------------
+EGK_EXPORT ISurfTriMesh* GetSurfTriMeshEmpty( void) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshBox( double dDimX, double dDimY, double dHeight, bool bRegular = false) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshPyramid( double dDimX, double dDimY, double dHeight) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshCylinder( double dRadius, double dHeight, double dLinTol) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshCone( double dRadius, double dHeight, double dLinTol) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSphere( double dRadius, double dLinTol) ;
+EGK_EXPORT ISurfTriMesh* GetSurfTriMeshPyramidFrustum( double dBaseDimX, double dBaseDimY, double dTopDimX, double dTopDimY, double dHeight) ;
+EGK_EXPORT ISurfTriMesh* GetSurfTriMeshConeFrustum( double dBaseRad, double dTopRad, double dHeight, double dLinTol) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshPlaneInBox( const Plane3d& plPlane, const BBox3d& b3Box, bool bOnEq = false, bool bOnCt = false) ;
 

EGkSurfAux.h

@@ -15,6 +15,7 @@
 
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkSurf.h"
+#include "/EgtDev/Include/EGkSurfFlatRegion.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
 
 
@@ -59,3 +60,8 @@ struct SNurbsSurfData
 //! Trasforma una superficie Nurbs standard in una nuova superficie di Bezier semplice o composta
 EGK_EXPORT bool NurbsSurfaceCanonicalize( SNurbsSurfData& snData) ;
 EGK_EXPORT ISurf* NurbsToBezierSurface( const SNurbsSurfData& snData) ;
+//! Per rendere uniforme lo spazio parametrico passando da Nurbs a MultiBezier
+EGK_EXPORT bool MakeUniform( ISurfFlatRegion*& pSfr, bool& bRescaled, const DBLVECTOR& vU0, const DBLVECTOR& vV0,
+                             int nDegU, int nDegV, double dScaleU, double dScaleV, bool bRetry) ;
+//! Per identificare su che edge è il punto
+EGK_EXPORT bool OnWhichEdge( double u0, double u1, double v0, double v1, const Point3d& ptToAssign, int& nEdge) ;

EGkSurfBezier.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+// EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : EGkSurfBezier.h      Data : 22.03.20          Versione : 2.2c3
+// File : EGkSurfBezier.h      Data : 10.04.24          Versione : 2.6d2
 // Contenuto : Dichiarazione della interfaccia ISurfBezier.
 //
 //
@@ -14,6 +14,7 @@
 #pragma once
 
 #include "/EgtDev/Include/EGkSurf.h"
+#include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 class PolyLine ;
@@ -27,7 +28,16 @@ class __declspec( novtable) ISurfBezier : public ISurf
    public :
       enum Side { FROM_MINUS = -1,     // da valori inferiori del parametro
                   FROM_PLUS  = 1} ;    // da valori superiori del parametro
-   public :                      // IGeoObj
+public :
+   enum RuledType { RLT_B_ISOPAR = 0,            // con parametrizzazione simile tra le due curve
+                    RLT_B_MINDIST = 1,           // con distanza minima tra le due curve, usando start e end delle curve presenti
+                    RLT_B_MINDIST_PLUS = 2,      // con distanza minima tra le due curve, aggiungendo punti lungo le curve dove necessario
+                    RLT_B_LENPAR = 3} ;          // aggiungo punti alla curve in modo da matchare meglio le sottocurve, inoltre parametrizzo le curve in base alla lunghezza e non al numero di curve
+   enum Is_Planar { NOT_CALCULATED = -1,
+                   NOT_PLANAR_SURF = 0 ,
+                   PLANAR_SURF = 1};
+
+public :                      // IGeoObj
       ISurfBezier* Clone( void) const override = 0 ;
    public :
       virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
@@ -36,7 +46,7 @@ class __declspec( novtable) ISurfBezier : public ISurf
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl) = 0 ;
       virtual bool SetControlPoint( int nIndU, int nIndV, const Point3d& ptCtrl, double dW) = 0 ;
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) = 0 ;
-      virtual bool SetTrimRegion( const ISurfFlatRegion& sfrTrimReg) = 0 ;
+      virtual bool SetTrimRegion( ISurfFlatRegion& sfrTrimReg, bool bIntersectOrSubtrct = true) = 0 ;
       virtual ISurfFlatRegion* GetTrimRegion( void) const = 0 ;
       virtual bool GetInfo( int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) const = 0 ;
       virtual const Point3d& GetControlPoint( int nIndU, int nIndV, bool* pbOk) const = 0 ;
@@ -44,6 +54,7 @@ class __declspec( novtable) ISurfBezier : public ISurf
       virtual double GetControlWeight( int nIndU, int nIndV, bool* pbOk) const = 0 ;
       virtual double GetControlWeight( int nInd, bool* pbOk) const = 0 ;
       virtual bool IsAPoint( void) const = 0 ;
+      virtual bool GetPoint( double dU, double dV, Side nUs, Side nVs, Point3d& ptPos) const = 0;
       virtual bool GetPointD1D2( double dU, double dV, Side nUs, Side nVs,
                                  Point3d& ptPos,
                                  Vector3d* pvtDerU = nullptr, Vector3d* pvtDerV = nullptr,
@@ -58,7 +69,28 @@ class __declspec( novtable) ISurfBezier : public ISurf
       virtual bool GetControlCurveOnU( int nIndV, PolyLine& plCtrlU) const = 0 ;
       virtual bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const = 0 ;
       virtual const ISurfTriMesh* GetAuxSurf( void) const = 0 ;
+      virtual const ISurfTriMesh* GetAuxSurfRefined( void) const = 0 ;
+      virtual ISurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL) const = 0 ;
       virtual bool GetLeaves ( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const = 0 ;
+      virtual bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const = 0 ;
+      virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL) const = 0 ;
+      virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL, const Point3d& ptIPrev, bool* bTroughEdge = nullptr) const = 0 ;
+      virtual bool UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d& ptIPrev, bool* bTroughEdge = nullptr, const Plane3d* plCut = nullptr) const = 0 ;
+      virtual bool UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& vpCC, const Plane3d* pPlCut) const = 0 ;
+      // taglio la parte della superficie dalla parte positiva del versore del piano.
+      // Il booleano indica se tenere eventuali triangoli della trimesh ausiliaria che sono coplanari ed equiversi al piano di taglio
+      virtual bool Cut( const Plane3d& plPlane, bool bSaveOnEq) = 0 ;
+      virtual bool IncreaseUV( double& dU, double dx, bool bUOrV, double* dUVCopy = nullptr, bool bModifyOrig = true) const = 0 ;
+      virtual bool IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bModifyOrig) const = 0 ;
+      virtual bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const = 0 ;
+      virtual bool IsPlanar( void) const = 0 ;
+      virtual bool CreateByFlatContour( const PolyLine& PL) = 0 ;
+      virtual bool CreateByRegion( const POLYLINEVECTOR& vPL) = 0 ;
+      virtual bool CreateByExtrusion( const ICurve* pCrv, const Vector3d& vtExtr, bool bDeg3OrDeg2 = false) = 0 ;
+      virtual bool CreateByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vector3d& vtAx, double dAngRotDeg, double dMove) = 0 ;
+      virtual bool CreateByPointCurve( const Point3d& pt, const ICurve* pCurve) = 0 ;
+      virtual bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) = 0 ;
+      virtual bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3 = true) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkSurfFlatRegion.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2015
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkSurfFlatRegion.h      Data : 05.08.15          Versione : 1.6h2
+// File : EGkSurfFlatRegion.h      Data : 18.07.24          Versione : 2.6g5
 // Contenuto : Dichiarazione della interfaccia ISurfFlatRegion.
 //
 //
@@ -27,7 +27,7 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
       ISurfFlatRegion* Clone( void) const override = 0 ;
    public :
       virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
-      virtual bool Clear( void) ;
+      virtual bool Clear( void) = 0 ;
       virtual bool AddExtLoop( const ICurve& cCrv) = 0 ;
       virtual bool AddExtLoop( ICurve* pCrv) = 0 ;
       virtual bool AddIntLoop( const ICurve& cCrv) = 0 ;
@@ -40,17 +40,30 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
       virtual bool GetGrossArea( double& dArea) const = 0 ;
       virtual const Point3d& GetPlanePoint( void) const = 0 ;
       virtual const Vector3d& GetNormVersor( void) const = 0 ;
+      virtual bool CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound = 3) const = 0 ;
+      virtual void ResetVoronoiObject( void) const = 0 ;
+      virtual bool GetMaxOffset( double& dOffs) const = 0 ;
+      virtual bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide = 1) const = 0 ;
+      virtual const ISurfTriMesh* GetAuxSurf( void) const = 0 ;
+      virtual bool GetCurveClassification( const ICurve& Crv, double dLenMin, CRVCVECTOR& ccClass) const = 0 ;
       virtual int  GetChunkCount( void) const = 0 ;
+      virtual ISurfFlatRegion* CloneChunk( int nChunk) const = 0 ;
+      virtual bool EraseChunk(int nChunk) = 0 ;
+      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 bool GetChunkMaxOffset( int nChunk, double& dOffs) const = 0 ;
       virtual int  GetLoopCount( int nChunk) const = 0 ;
+      virtual int  GetLoopCurveCount( int nChunk, int nLoop) const = 0 ;
       virtual ICurve* GetLoop( int nChunk, int nLoop) const = 0 ;   // nChunk 0-based, nLoop 0-based (1°esterno, successivi interni) 
       virtual bool ApproxLoopWithLines( int nChunk, int nLoop, double dLinTol, double dAngTolDeg, int nType, PolyLine& PL) const = 0 ;
-      virtual const ISurfTriMesh* GetAuxSurf( void) const = 0 ;
-      virtual ISurfFlatRegion* CloneChunk( int nChunk) const = 0 ;
-      virtual bool GetChunkCentroid( int nChunk, Point3d& ptCen) const ;
-      virtual bool GetCurveClassification( const ICurve& Crv, double dLenMin, CRVCVECTOR& ccClass) const = 0 ;
-      virtual int  GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion& Other, int nOthChunk) const ;   // compare only outsides
-      virtual bool CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound = 3) const = 0 ;
-      virtual bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide = 1) const = 0 ;
+      virtual bool SetCurveTempProp( int nChunk, int nLoop, int nCrv, int nProp, int nPropInd = 0) = 0 ;
+      virtual bool GetCurveTempProp( int nChunk, int nLoop, int nCrv, int& nProp, int nPropInd = 0) const = 0 ;
+      virtual bool ResetAllCurveTempProps( void) = 0 ;
+      virtual bool SetCurveTempParam( int nChunk, int nLoop, int nCrv, double dParam, int nParamInd = 0) = 0 ;
+      virtual bool GetCurveTempParam( int nChunk, int nLoop, int nCrv, double& dParam, int nParamInd = 0) const = 0 ;
+      virtual bool ResetAllCurveTempParams( void) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkSurfLocal.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2017-2017
+//  EgalTech 2017-2024
 //----------------------------------------------------------------------------
-// File : EGkSurfLocal.h           Data : 29.03.17         Versione : 1.8c3
+// File : EGkSurfLocal.h           Data : 08.04.24         Versione : 2.6d2
 // Contenuto : Classe gestione superfici nel locale desiderato.
 //
 //
@@ -45,6 +45,25 @@ class SurfLocal
             m_pCopy->LocToLoc( frSrf, frLoc) ;
             m_pSrf = m_pCopy ;
          }
+      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)
+               return ;
+           // assegno la superficie originale
+            m_pSrf = pSurf ;
+           // se i riferimenti coincidono non devo fare altro
+            if ( AreSameFrame( frSrf, frLoc))
+               return ;
+           // copio la superficie e la porto in locale
+            m_pCopy = m_pSrf->Clone() ;
+            if ( m_pCopy == nullptr) {
+               m_pSrf = nullptr ;
+               return ;
+            }
+            m_pCopy->LocToLoc( frSrf, frLoc) ;
+            m_pSrf = m_pCopy ;
+         }
       SurfLocal( const SurfLocal& Other)
          : m_pSrf( nullptr), m_pCopy( nullptr)
          { // se non devo clonare

EGkSurfTriMesh.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2025
 //----------------------------------------------------------------------------
-// File : EGkSurfTriMesh.h      Data : 10.12.23          Versione : 2.5l2
+// File : EGkSurfTriMesh.h      Data : 28.03.25          Versione : 2.7c4
 // Contenuto : Dichiarazione della interfaccia ISurfTriMesh.
 //
 //
@@ -43,13 +43,14 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual void SetLinearTolerance( double dLinTol) = 0 ;
       virtual void SetBoundaryAngle( double dBoundaryAngDeg) = 0 ;
       virtual void SetSmoothAngle( double dSmoothAngDeg) = 0 ;
+      virtual void SetShowEdges( bool bShow) = 0 ;
       virtual int  AddVertex( const Point3d& ptVert, double dU = -1, double dV = -1) = 0 ;
       virtual bool MoveVertex( int nInd, const Point3d& ptNewVert) = 0 ;
       virtual int  AddTriangle( const int nIdVert[3], int nTFlag = 0) = 0 ;
       virtual bool RemoveTriangle( int nId) = 0 ;
       virtual bool AdjustTopology( void) = 0 ;
       virtual bool CreateByFlatContour( const PolyLine& PL) = 0 ;
-      virtual bool CreateByRegion( const POLYLINEVECTOR& vPL) = 0 ;
+      virtual bool CreateByPolygonWithHoles( const POLYLINEVECTOR& vPL) = 0 ;
       virtual bool CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr) = 0 ;
       virtual bool CreateByPointCurve( const Point3d& ptP, const PolyLine& PL) = 0 ;
       virtual bool CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nRuledType) = 0 ;
@@ -67,6 +68,7 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual int  GetTriangleSize( void) const = 0 ;
       virtual double GetLinearTolerance( void) const = 0 ;
       virtual double GetSmoothAngle( void) const = 0 ;
+      virtual bool GetShowEdges( void) const = 0 ;
       virtual bool GetVertex( int nId, Point3d& ptP) const = 0 ;
       virtual bool GetVertexParam( int nId, double& dU, double& dV) const = 0 ;
       virtual int  GetFirstVertex( Point3d& ptP) const = 0 ;
@@ -87,6 +89,7 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       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 int  GetFacetCount( void) const = 0 ;
       virtual int  GetFacetSize( void) const = 0 ;
       virtual int  GetFacetFromTria( int nT) const = 0 ;
@@ -121,9 +124,18 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual bool Repair( double dMaxEdgeLen = MAX_EDGE_LEN_STD) = 0 ;
       virtual bool GetAllTriaOverlapBox( const BBox3d& b3Box, INTVECTOR& vT) const = 0 ;
       virtual const BBox3d& GetAllTriaBox( void) const = 0 ;
+      virtual int  GetShellCount( void) const = 0 ;
+      virtual bool GetShellArea( int nShell, double& dArea) const = 0 ;
+      virtual bool RemoveShell( int nShell) = 0 ;
+      virtual ISurfTriMesh* CloneShell( int nShell) const = 0 ;
       virtual int  GetPartCount( void) const = 0 ;
+      virtual bool GetPartArea( int nPart, double& dArea) const = 0 ;
+      virtual bool GetPartVolume( int nPart, double& dVolume) const = 0 ;
+      virtual bool GetPartLoops( int nPart, POLYLINEVECTOR& vPL) const = 0 ;
       virtual bool RemovePart( int nPart) = 0 ;
       virtual ISurfTriMesh* ClonePart( int nPart) 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 ;
       virtual bool ResetTFlags( void) = 0 ;
 } ;

EGkTriangle3d.h

@@ -455,6 +455,13 @@ CalcNormal( const Point3d& ptP, const Triangle3d& Tria, const TriNormals3d& Tnor
    return vtNorm.Normalize( EPS_ZERO) ;
 }
 
+//----------------------------------------------------------------------------
+inline bool
+CalcNormal( const Point3d& ptP, const Triangle3dEx& Tria, Vector3d& vtNorm)
+{
+   return CalcNormal( ptP, Tria, Tria.GetTriNormals(), vtNorm) ;
+}
+
 //----------------------------------------------------------------------------
 enum TriangleType { OPEN = -1, EXACT = 0, CLOSED = 1 };
 

EGkVector3d.h

@@ -45,7 +45,7 @@ class EGK_EXPORT Vector3d
       void Set( double dX, double dY, double dZ) { x = dX ; y = dY ; z = dZ ; }
 
    public :
-      //! Verifica la validità delle coordinate del vettore
+      //! Verifica la validità delle coordinate del vettore
       bool IsValid( void) const
              { return ( std::isfinite( x)  &&  std::isfinite( y)  &&  std::isfinite( z)) ; }
       //! Quadrato della lunghezza del vettore
@@ -58,58 +58,70 @@ class EGK_EXPORT Vector3d
              { return ( x * x + y * y ) ; }
       //! Lunghezza del vettore nel piano XY
       double LenXY( void) const ;
-      //! Verifica se il vettore è quasi nullo
+      //! Verifica se il vettore è quasi nullo
       bool IsSmall( void) const
              { return ( ( x * x + y * y + z * z) < SQ_EPS_SMALL) ; }
-      //! Verifica se il vettore è esattamente nullo
+      //! Verifica se il vettore è esattamente nullo
       bool IsZero( void) const
              { return ( ( x * x + y * y + z * z) < SQ_EPS_ZERO) ; }
-      //! Verifica se il vettore è quasi nullo nel piano XY
+      //! Verifica se il vettore è quasi nullo nel piano XY
       bool IsSmallXY( void) const
              { return ( ( x * x + y * y) < SQ_EPS_SMALL) ; }
-      //! Verifica se il vettore è esattamente nullo nel piano XY
+      //! Verifica se il vettore è esattamente nullo nel piano XY
       bool IsZeroXY( void) const
              { return ( ( x * x + y * y) < SQ_EPS_ZERO) ; }
-      //! Verifica se il vettore è normalizzato (è un versore)
+      //! Verifica se il vettore è normalizzato (è un versore)
       bool IsNormalized( void) const
              { return ( abs( 1.0 - (x * x + y * y + z * z)) < ( 2 * EPS_ZERO)) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con X+
+      //! Verifica se il vettore è parallelo ed equiverso con X+
       bool IsXplus( void) const
              { double dMO = std::max( abs( y), abs( z)) ;
                return ( x > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  x > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con X-
+      //! Verifica se il vettore è parallelo ed equiverso con X-
       bool IsXminus( void) const
              { double dMO = std::max( abs( y), abs( z)) ;
                return ( x < -EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  x < -KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo a X
+      //! Verifica se il vettore è parallelo a X
       bool IsX( void) const
              { double dMO = std::max( abs( y), abs( z)) ;
                return ( abs( x) > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  abs( x) > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con Y+
+      //! Verifica se il vettore è circa parallelo a x
+      bool IsXEpsilon( double dToler) const
+             { double dMO = std::max( abs( y), abs( z)) ;
+               return ( abs( x) > dToler  &&  dMO < 10 * dToler  &&  abs( x) > KV_BIG * dMO) ; }
+      //! Verifica se il vettore è parallelo ed equiverso con Y+
       bool IsYplus( void) const
              { double dMO = std::max( abs( z), abs( x)) ;
                return ( y > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  y > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con Y-
+      //! Verifica se il vettore è parallelo ed equiverso con Y-
       bool IsYminus( void) const
              { double dMO = std::max( abs( z), abs( x)) ;
                return ( y < -EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  y < -KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo a Y
+      //! Verifica se il vettore è parallelo a Y
       bool IsY( void) const
              { double dMO = std::max( abs( z), abs( x)) ;
                return ( abs( y) > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  abs( y) > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con Z+
+      //! Verifica se il vettore è circa parallelo a y
+      bool IsYEpsilon( double dToler) const
+             { double dMO = std::max( abs( z), abs( x)) ;
+               return ( abs( y) > dToler  &&  dMO < 10 * dToler  &&  abs( y) > KV_BIG * dMO) ; }
+      //! Verifica se il vettore è parallelo ed equiverso con Z+
       bool IsZplus( void) const
              { double dMO = std::max( abs( x), abs( y)) ;
                return ( z > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  z > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con Z-
+      //! Verifica se il vettore è parallelo ed equiverso con Z-
       bool IsZminus( void) const
              { double dMO = std::max( abs( x), abs( y)) ;
                return ( z < -EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  z < -KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo a Z
+      //! Verifica se il vettore è parallelo a Z
       bool IsZ( void) const
              { double dMO = std::max( abs( x), abs( y)) ;
                return ( abs( z) > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  abs( z) > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è generico
+      //! Verifica se il vettore è circa parallelo a Z
+      bool IsZEpsilon( double dToler) const
+             { double dMO = std::max( abs( x), abs( y)) ;
+               return ( abs( z) > dToler  &&  dMO < 10 * dToler  &&  abs( z) > KV_BIG * dMO) ; }
+      //! Verifica se il vettore è generico
       bool IsGeneric( void) const
              { return ( ! IsX()  &&  ! IsY()  &&  ! IsZ()) ; }
       //! Somma sul posto con altro vettore
@@ -193,12 +205,12 @@ EGK_EXPORT Vector3d FromSpherical( double dLen, double dAngVertDeg, double dAngO
 EGK_EXPORT Vector3d FromPolar( double dLen, double dAngDeg) ;
 
 //----------------------------------------------------------------------------
-//! Definizione come più verticale dei vettori ortogonali a quello ricevuto
+//! Definizione come più verticale dei vettori ortogonali a quello ricevuto
 //----------------------------------------------------------------------------
 EGK_EXPORT Vector3d FromUprightOrtho( const Vector3d& vtV) ;
 
 //----------------------------------------------------------------------------
-//! Definizione come ortogonale al primo ricevuto, orizzontale e più vicino al secondo
+//! Definizione come ortogonale al primo ricevuto, orizzontale e più vicino al secondo
 //----------------------------------------------------------------------------
 EGK_EXPORT Vector3d FromNearestHorizontalOrtho( const Vector3d& vtV, const Vector3d& vtNear) ;
 
@@ -429,6 +441,17 @@ AreOrthoExact( const Vector3d& vtV1, const Vector3d& vtV2)
    return ( abs( vtV1 * vtV2) < COS_ORTO_ANG_ZERO) ;
 }
 
+//----------------------------------------------------------------------------
+//! Restituisce una copia ruotata del vettore passato
+//----------------------------------------------------------------------------
+inline const Vector3d
+GetRotate( const Vector3d& vtV, const Vector3d& vtAx, double dAngDeg)
+{
+   Vector3d vtW = vtV ;
+   vtW.Rotate( vtAx, dAngDeg) ;
+   return vtW ;
+}
+
 //----------------------------------------------------------------------------
 //! Restituisce una copia in locale del vettore passato
 //----------------------------------------------------------------------------

EGkVolZmap.h

@@ -1,14 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2023
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkVolZmap.h      Data : 12.09.23          Versione : 2.5i1
+// File : EGkVolZmap.h      Data : 22.04.24          Versione : 2.6d4
 // Contenuto : Dichiarazione della interfaccia IVolZmap.
 //
 //
 //
 // Modifiche : 22.01.15 DS Creazione modulo.
 //             12.09.23 DS Aggiunto metodo IsTriDexel.
-//
+//             09.03.24 DS Aggiunti SetShowEdges e GetShowEdges.
 //
 //----------------------------------------------------------------------------
 
@@ -27,9 +27,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 dPrec, bool bTriDex) = 0 ;
-      virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec, bool bTriDex) = 0 ;
-      virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bTriDex) = 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) = 0 ;
       virtual int  GetBlockCount( void) const = 0 ;
       virtual int  GetBlockUpdatingCounter( int nBlock) const = 0 ;
       virtual bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const = 0 ;
@@ -39,6 +40,8 @@ class __declspec( novtable) IVolZmap : public IGeoObj
       virtual bool GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const = 0 ;
       virtual int  GetResolution( void) const = 0 ;
       virtual bool ChangeResolution( int nDexvoxRatio) = 0 ;
+      virtual void SetShowEdges( bool bShow) = 0 ;
+      virtual bool GetShowEdges( void) const = 0 ;
       virtual bool SetToolTolerances( double dLinTol, double dAngTolDeg = 90) = 0 ;
       virtual bool SetStdTool( const std::string& sToolName,
                                double dH, double dR, double dCornR, double dCutterH, int nFlag, bool bFirst) = 0 ;
@@ -52,6 +55,8 @@ class __declspec( novtable) IVolZmap : public IGeoObj
                                     double dH, double dW, double dTh, double dRc, int nFlag, bool bFirst) = 0 ;
       virtual bool SetChiselTool( const std::string& sToolName,
                                   double dH, double dW, double dTh, int nFlag, bool bFirst) = 0 ;
+      virtual bool SetAdditiveTool( const std::string& sToolName,
+                                    double dH, double dR, double dRc, int nFlag, bool bFirst) = 0 ;
       virtual int  GetToolCount( void) const = 0 ;
       virtual bool SetCurrTool( int nCurrTool) = 0 ;
       virtual bool ResetTools( void) = 0 ;
@@ -83,6 +88,8 @@ class __declspec( novtable) IVolZmap : public IGeoObj
       virtual IVolZmap* ClonePart( int nPart) const = 0 ;
       virtual bool RemovePart( int nPart) = 0 ;
       virtual int  GetPartMinDistFromPoint( const Point3d& ptP) const = 0 ;
+      virtual bool AddSurfTm( const ISurfTriMesh* pStm) = 0 ;
+      virtual bool MakeUniform( double dToler) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGnLuaAux.h

@@ -229,7 +229,11 @@ LuaGetTabFieldParam( lua_State* L, int nInd, const char* szField, T& Val)
 {
    if ( ! lua_istable( L, nInd))
       return false ;
-   lua_getfield( L, nInd, szField) ;
+   int nField ;
+   if ( FromString( szField, nField))
+      lua_rawgeti( L, nInd, nField) ;
+   else
+      lua_getfield( L, nInd, szField) ;
    bool bOk = LuaGetParam( L, -1, Val) ;
    lua_pop( L, 1) ;
    return bOk ;
@@ -323,6 +327,24 @@ LuaSetParam( lua_State* L, const std::string& sPar)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+inline bool
+LuaSetParam( lua_State* L, const BOOLVECTOR& vPar)
+{
+   try {
+      int nSize = int( vPar.size()) ;
+      lua_createtable( L, nSize, 0) ;
+      for ( int i = 1 ; i <= nSize ; ++ i) {
+         lua_pushboolean( L, ( vPar[i-1] ? 1 : 0)) ;
+         lua_rawseti( L, -2, i) ;
+      }
+   }
+   catch( ...) {
+      return false ;
+   }
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 inline bool
 LuaSetParam( lua_State* L, const INTVECTOR& vPar)
@@ -444,7 +466,11 @@ LuaSetTabFieldParam( lua_State* L, int nInd, const char* szField)
    if ( ! LuaSetParam( L))
       return false ;
    int nPos = ( nInd > 0 ? nInd : nInd - 1) ;
-   lua_setfield( L, nPos, szField) ;
+   int nField ;
+   if ( FromString( szField, nField))
+      lua_rawseti( L, nPos, nField) ;
+   else
+      lua_setfield( L, nPos, szField) ;
    return true ;
 }
 
@@ -465,7 +491,11 @@ LuaSetTabFieldParam( lua_State* L, int nInd, const char* szField, const T& Val)
    if ( ! LuaSetParam( L, Val))
       return false ;
    int nPos = ( nInd > 0 ? nInd : nInd - 1) ;
-   lua_setfield( L, nPos, szField) ;
+   int nField ;
+   if ( FromString( szField, nField))
+      lua_rawseti( L, nPos, nField) ;
+   else
+      lua_setfield( L, nPos, szField) ;
    return true ;
 }
 
@@ -493,11 +523,29 @@ LuaGetGlobVar( lua_State* L, const std::string& sVar, T& Val)
    }
   // altrimenti campo di tabella
    else {
-      std::string sTab, sField ;
-      SplitFirst( sVar, ".", sTab, sField) ;
-      lua_getglobal( L, sTab.c_str()) ;
-      bool bOk = LuaGetTabFieldParam( L, -1, sField.c_str(), Val) ;
-      lua_pop( L, 1) ;
+      STRVECTOR vsTokens ;
+      Tokenize( sVar, ".", vsTokens) ;
+      int nTokenCnt = int( vsTokens.size()) ;
+      if ( nTokenCnt < 2)
+         return false ;
+      if ( lua_getglobal( L, vsTokens[0].c_str()) != LUA_TTABLE) {
+         lua_pop( L, 1) ;
+         return false ;
+      }
+      for ( int nInd = 1 ; nInd <= nTokenCnt - 2 ; ++ nInd) {
+         bool bOk ;
+         int nField ;
+         if ( FromString( vsTokens[nInd], nField))
+            bOk = ( lua_rawgeti( L, -1, nField) == LUA_TTABLE) ;
+         else
+            bOk = ( lua_getfield( L, -1, vsTokens[nInd].c_str()) == LUA_TTABLE) ;
+         if ( ! bOk) {
+            lua_pop( L, nInd + 1) ;
+            return false ;
+         }
+      }
+      bool bOk = LuaGetTabFieldParam( L, -1, vsTokens[nTokenCnt-1].c_str(), Val) ;
+      lua_pop( L, nTokenCnt - 1) ;
       return bOk ;
    }
 }
@@ -518,11 +566,30 @@ LuaSetGlobVar( lua_State* L, const std::string& sVar, const T& Val)
    }
   // altrimenti campo di tabella
    else {
-      std::string sTab, sField ;
-      SplitFirst( sVar, ".", sTab, sField) ;
-      lua_getglobal( L, sTab.c_str()) ;
-      bool bOk = LuaSetTabFieldParam( L, -1, sField.c_str(), Val) ;
-      lua_pop( L, 1) ;
+      STRVECTOR vsTokens ;
+      Tokenize( sVar, ".", vsTokens) ;
+      int nTokenCnt = int( vsTokens.size()) ;
+      if ( nTokenCnt < 2)
+         return false ;
+      if ( lua_getglobal( L, vsTokens[0].c_str()) != LUA_TTABLE) {
+         lua_pop( L, 1) ;
+         return false ;
+      }
+      for ( int nInd = 1 ; nInd <= nTokenCnt - 2 ; ++ nInd) {
+         int nField ;
+         bool bNumber = FromString( vsTokens[nInd], nField) ;
+         if ( ( bNumber ? lua_rawgeti( L, -1, nField) : lua_getfield( L, -1, vsTokens[nInd].c_str())) != LUA_TTABLE) {
+            lua_pop( L, 1) ;
+            lua_newtable( L) ;
+            lua_pushvalue( L, -1) ;
+            if ( bNumber)
+               lua_rawseti( L, -3, nField) ;
+            else
+               lua_setfield( L, -3, vsTokens[nInd].c_str()) ;
+         }
+      }
+      bool bOk = LuaSetTabFieldParam( L, -1, vsTokens[nTokenCnt-1].c_str(), Val) ;
+      lua_pop( L, nTokenCnt - 1) ;
       return bOk ;
    }
 }
@@ -542,10 +609,29 @@ LuaResetGlobVar( lua_State* L, const std::string& sVar)
    }
   // altrimenti campo di tabella
    else {
-      std::string sTab, sField ;
-      SplitFirst( sVar, ".", sTab, sField) ;
-      lua_getglobal( L, sTab.c_str()) ;
-      bool bOk = LuaSetTabFieldParam( L, -1, sField.c_str()) ;
+      STRVECTOR vsTokens ;
+      Tokenize( sVar, ".", vsTokens) ;
+      int nTokenCnt = int( vsTokens.size()) ;
+      if ( nTokenCnt < 2)
+         return false ;
+      if ( lua_getglobal( L, vsTokens[0].c_str()) != LUA_TTABLE) {
+         lua_pop( L, 1) ;
+         return false ;
+      }
+      for ( int nInd = 1 ; nInd <= nTokenCnt - 2 ; ++ nInd) {
+         int nField ;
+         bool bNumber = FromString( vsTokens[nInd], nField) ;
+         if ( ( bNumber ? lua_rawgeti( L, -1, nField) : lua_getfield( L, -1, vsTokens[nInd].c_str())) != LUA_TTABLE) {
+            lua_pop( L, 1) ;
+            lua_newtable( L) ;
+            lua_pushvalue( L, -1) ;
+            if ( bNumber)
+               lua_rawseti( L, -3, nField) ;
+            else
+               lua_setfield( L, -3, vsTokens[nInd].c_str()) ;
+         }
+      }
+      bool bOk = LuaSetTabFieldParam( L, -1, vsTokens[nTokenCnt-1].c_str()) ;
       lua_pop( L, 1) ;
       return bOk ;
    }

EGnStringUtils.h

@@ -15,8 +15,10 @@
 
 #include "/EgtDev/Include/EgtStringBase.h"
 #include "/EgtDev/Include/EgtNumCollection.h"
+#include "/EgtDev/Extern/fast_float/fast_float.h"
 #include <algorithm>
 #include <array>
+#include <charconv>
 
 //----------------------- Macro per import/export -----------------------------
 #undef EGN_EXPORT
@@ -123,20 +125,16 @@ ValidateDxfName( std::string& sName, bool bAdvanced)
 }
 
 //----------------------------------------------------------------------------
+#define FAST_FLOAT_FMT     fast_float::chars_format::general | fast_float::chars_format::allow_leading_plus | fast_float::chars_format::skip_white_space
+#define FAST_FLOAT_OPTS    fast_float::parse_options( FAST_FLOAT_FMT)
 inline bool
 FromString( const std::string& sVal, int& nVal)
-      { const char* pStart = sVal.c_str() ;
-        char* pStop ;
-        errno = 0 ;
-        nVal = strtol( pStart, &pStop, 10) ;
-        return ( pStop != pStart  &&  errno == 0) ; }
+      { auto answer = fast_float::from_chars_advanced( sVal.data(), sVal.data() + sVal.size(), nVal, FAST_FLOAT_OPTS) ;
+        return ( answer.ec == std::errc()  &&  answer.ptr != sVal.data()) ; }
 inline bool
 FromString( const std::string& sVal, unsigned int& nVal)
-      { const char* pStart = sVal.c_str() ;
-        char* pStop ;
-        errno = 0 ;
-        nVal = strtoul( pStart, &pStop, 10) ;
-        return ( pStop != pStart  &&  errno == 0) ; }
+      { auto answer = fast_float::from_chars_advanced( sVal.data(), sVal.data() + sVal.size(), nVal, FAST_FLOAT_OPTS) ;
+        return ( answer.ec == std::errc()  &&  answer.ptr != sVal.data()) ; }
 inline bool
 FromString( const std::string& sVal, bool& bVal)
       { int nTmp ;
@@ -146,94 +144,87 @@ FromString( const std::string& sVal, bool& bVal)
         return true ; }
 inline bool
 FromString( const std::string& sVal, double& dVal)
-      { const char* pStart = sVal.c_str() ;
-        char* pStop ;
-        errno = 0 ;
-        dVal = strtod( pStart, &pStop) ;
-        return ( pStop != pStart  &&  errno == 0) ; }
+      { auto answer = fast_float::from_chars( sVal.data(), sVal.data() + sVal.size(), dVal, FAST_FLOAT_FMT) ;
+        return ( answer.ec == std::errc()  &&  answer.ptr != sVal.data()) ; }
 template <size_t size>
 bool FromString( const std::string& sVal, int (&nVal)[size])
-      { const char* pStart = sVal.c_str() ;
-        char* pStop ;
-        errno = 0 ;
+      { const char* pFirst = sVal.data() ;
         for ( int i = 0 ; i < size ; ++ i) {
-           nVal[i] = strtol( pStart, &pStop, 10) ;
-           if ( ( i < size - 1  &&  *pStop != ',')  ||  errno != 0)
+           auto answer = fast_float::from_chars_advanced( pFirst, sVal.data() + sVal.size(), nVal[i], FAST_FLOAT_OPTS) ;
+           if ( answer.ec != std::errc()  ||  ( i < size - 1  &&  answer.ptr[0] != ','))
               return false ;
-           pStart = pStop + 1 ;
+           pFirst = answer.ptr + 1 ;
         }
-        return ( errno == 0) ;
+        return true ;
       }
 template <size_t size>
 bool FromString( const std::string& sVal, double (&dVal)[size])
-      { const char* pStart = sVal.c_str() ;
-        char* pStop ;
-        errno = 0 ;
+      { const char* pFirst = sVal.data() ;
         for ( int i = 0 ; i < size ; ++ i) {
-           dVal[i] = strtod( pStart, &pStop) ;
-           if ( ( i < size - 1  &&  *pStop != ',')  ||  errno != 0)
+           auto answer = fast_float::from_chars( pFirst, sVal.data() + sVal.size(), dVal[i], FAST_FLOAT_FMT) ;
+           if ( answer.ec != std::errc()  ||  ( i < size - 1  &&  answer.ptr[0] != ','))
               return false ;
-           pStart = pStop + 1 ;
+           pFirst = answer.ptr + 1 ;
         }
-        return ( errno == 0) ;
+        return true ;
       }
 template <size_t size>
 bool FromString( const std::string& sVal, std::array<double,size>& dVal)
-      { const char* pStart = sVal.c_str() ;
-        char* pStop ;
-        errno = 0 ;
+      { const char* pFirst = sVal.data() ;
         for ( int i = 0 ; i < size ; ++ i) {
-           dVal[i] = strtod( pStart, &pStop) ;
-           if ( ( i < size - 1  &&  *pStop != ',')  ||  errno != 0)
+           auto answer = fast_float::from_chars( pFirst, sVal.data() + sVal.size(), dVal[i], FAST_FLOAT_FMT) ;
+           if ( answer.ec != std::errc()  ||  ( i < size - 1  &&  answer.ptr[0] != ','))
               return false ;
-           pStart = pStop + 1 ;
+           pFirst = answer.ptr + 1 ;
         }
-        return ( errno == 0) ;
+        return true ;
       }
 EGN_EXPORT bool FromString( const std::string& sVal, INTVECTOR& vnVal) ;
 EGN_EXPORT bool FromString( const std::string& sVal, DBLVECTOR& vdVal) ;
 EGN_EXPORT bool FromString( const std::string& sVal, STRVECTOR& vsVal) ;
 
 //----------------------------------------------------------------------------
+EGN_EXPORT const std::string ToStringAdv( int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr) ;
 inline const std::string
-ToString( int nVal, int nPrec = 1, int nRadix = 10)
+ToString( int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
       {
+        // se necessario processing avanzato
+         if ( nPrec > 1  ||  nRadix < 6)
+            return ToStringAdv( nVal, nPrec, nRadix, pnErr) ;
         // eseguo conversione
-         char szBuff[24] ;
-         int nErr = _itoa_s( nVal, szBuff, nRadix) ;
-        // se errore, ritorno stringa opportuna
-         if ( nErr != 0) {
-            _ASSERT( 0) ;
+         const int nBuffSize = 16 ;
+         char szBuff[nBuffSize]{} ;
+         auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
+         if ( Res.ec != std::errc()) {
+            if ( pnErr != nullptr)
+               *pnErr = int( Res.ec) ;
             return "#Error" ;
          }
-        // verifico lunghezza minima
-         int  nLen = (int) strlen( szBuff) ;
-         if ( nLen >= nPrec)
-            return szBuff ;
-        // porto la stringa alla minima lunghezza
-         std::string sBuff( szBuff)  ;
-         sBuff.insert( 0, ( nPrec - nLen), '0') ;
-         return sBuff ;
+        // gestione codice di errore
+         if ( pnErr != nullptr)
+            *pnErr = 0 ;
+         return szBuff ;
       }
+EGN_EXPORT const std::string ToStringAdv( unsigned int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr) ;
 inline const std::string
-ToString( unsigned int nVal, int nPrec = 1, int nRadix = 10)
+ToString( unsigned int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
       {
+        // se necessario processing avanzato
+         if ( nPrec > 1  ||  nRadix < 6)
+            return ToStringAdv( nVal, nPrec, nRadix, pnErr) ;
         // eseguo conversione
-         char szBuff[24] ;
-         int nErr = _ultoa_s( nVal, szBuff, nRadix) ;
-        // se errore, ritorno stringa opportuna
-         if ( nErr != 0) {
-            _ASSERT( 0) ;
+         const int nBuffSize = 16 ;
+         char szBuff[nBuffSize]{} ;
+         auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
+         if ( Res.ec != std::errc()) {
+            if ( pnErr != nullptr)
+               *pnErr = int( Res.ec) ;
             return "#Error" ;
          }
-        // verifico lunghezza minima
-         int  nLen = (int) strlen( szBuff) ;
-         if ( nLen >= nPrec)
-            return szBuff ;
-        // porto la stringa alla minima lunghezza
-         std::string sBuff( szBuff)  ;
-         sBuff.insert( 0, ( nPrec - nLen), '0') ;
-         return sBuff ;
+        // gestione codice di errore
+         if ( pnErr != nullptr)
+            *pnErr = 0 ;
+         return szBuff ;
       }
 template <size_t size>
 const std::string ToString( const int (&nVal)[size], int nPrec = 1)

EGrScene.h

@@ -75,6 +75,8 @@ class IEGrScene
       virtual bool ZoomChange( double dCoeff) = 0 ;
       virtual bool ZoomOnPoint( const Point3d& ptWin, double dCoeff) = 0 ;
       virtual bool ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2) = 0 ;
+      virtual bool SetCameraType( bool bOrthoOrPersp) = 0 ;
+      virtual bool SetZoomType( int nZoomMode) = 0 ;
      // ShowMode
       virtual bool SetShowMode( int nShowMode) = 0 ;
       virtual int  GetShowMode( void) const = 0 ;
@@ -90,6 +92,7 @@ class IEGrScene
       virtual bool SetExtension( const BBox3d& b3Ext) = 0 ;
       virtual bool UpdateExtension( void) = 0 ;
       virtual bool SetMark( Color colMark) = 0 ;
+      virtual bool SetMark2( Color colMark) = 0 ;
       virtual bool SetSelSurf( Color colSelSurf) = 0 ;
       virtual bool SetLineWidth( int nW) = 0 ;
      // Grid
@@ -170,6 +173,9 @@ enum CameraDir { CT_NONE = 0,
                  CT_ISO_NE = 9,
                  CT_ISO_NW = 10,
                  CT_CPLANE = 11} ;
+//------------------------ Costanti per tipologia di zoom nel caso prospettico ---------------------
+enum PerspZoom  { ZT_STD = 0,
+                  ZT_DOLLY = 1} ;
 //------------------------ Costanti per tipo di visualizzazione --------------
 enum ShowMode { SM_WIREFRAME = 0,
                 SM_HIDDENLINE = 1,

EInAPI.h

@@ -59,6 +59,7 @@ EIN_EXPORT BOOL __stdcall EgtGetKeyOptions( int nProd, int nVer, int nLev, unsig
 EIN_EXPORT BOOL __stdcall EgtGetKeyLeftDays( int* pnLeftDays) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyAssLeftDays( int* pnAssLeftDays) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyOptLeftDays( int* pnOptLeftDays) ;
+EIN_EXPORT BOOL __stdcall EgtGetNetHwKey( void) ;
 EIN_EXPORT BOOL __stdcall EgtGetOsInfo( wchar_t*& wsOs) ;
 EIN_EXPORT BOOL __stdcall EgtGetCpuInfo( wchar_t*& wsCpu) ;
 EIN_EXPORT BOOL __stdcall EgtGetMemoryInfo( wchar_t*& wsMem) ;
@@ -115,10 +116,12 @@ EIN_EXPORT BOOL __stdcall EgtImportCsf( const wchar_t* wsFilePath) ;
 EIN_EXPORT BOOL __stdcall EgtImportDxf( const wchar_t* wsFilePath, double dScaleFactor) ;
 EIN_EXPORT BOOL __stdcall EgtImportPnt( const wchar_t* wsFilePath, int nFlag) ;
 EIN_EXPORT BOOL __stdcall EgtImportStl( const wchar_t* wsFilePath, double dScaleFactor) ;
-EIN_EXPORT BOOL __stdcall EgtImport3MF( const wchar_t* wsFilePath) ;
+EIN_EXPORT BOOL __stdcall EgtImportOff( const wchar_t* wsFilePath, double dScaleFactor) ;
+EIN_EXPORT BOOL __stdcall EgtImportPly( const wchar_t* wsFilePath, double dScaleFactor) ;
+EIN_EXPORT BOOL __stdcall EgtImport3MF( const wchar_t* wsFilePath, int nFlag) ;
 EIN_EXPORT BOOL __stdcall EgtImport3dm( const wchar_t* wsFilePath) ;
 EIN_EXPORT BOOL __stdcall EgtAdvancedImportIsEnabled( void) ;
-EIN_EXPORT BOOL __stdcall EgtAdvancedImport( const wchar_t* wsFilePath, double dLinToler) ;
+EIN_EXPORT BOOL __stdcall EgtAdvancedImport( const wchar_t* wsFilePath, double dLinToler, int nFlag) ;
 EIN_EXPORT BOOL __stdcall EgtExportDxf( int nId, const wchar_t* wsFilePath, int nFlag, int nFilter) ;
 EIN_EXPORT BOOL __stdcall EgtExportStl( int nId, const wchar_t* wsFilePath, int nFilter) ;
 EIN_EXPORT BOOL __stdcall EgtExport3MF( int nId, const wchar_t* wsFilePath, int nFilter) ;
@@ -211,6 +214,15 @@ EIN_EXPORT int  __stdcall EgtCreateVerticalDimension( int nParentId, const doubl
                                                       const double ptDim[3], const wchar_t* wsText, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateAlignedDimension( int nParentId, const double ptP1[3], const double ptP2[3],
                                                      const double ptDim[3], const wchar_t* wsText, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateAngularDimension( int nParentId, const double ptV[3], const double ptP1[3], const double ptP2[3],
+                                                     const double ptDim[3], const wchar_t* wsText, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateAngularDimensionEx( int nParentId, const double ptV1[3], const double ptP1[3],
+                                                       const double ptV2[3], const double ptP2[3], const double ptDim[3],
+                                                       const wchar_t* wsText, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateDiametralDimension( int nParentId, int nCrvId, const double ptDim[3],
+                                                       const wchar_t* wsText, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateRadialDimension( int nParentId, int nCrvId, const double ptDim[3],
+                                                    const wchar_t* wsText, int nRefType) ;
 
 // GeomDB Create Curve
 EIN_EXPORT int  __stdcall EgtCreateLine( int nParentId,
@@ -242,6 +254,8 @@ EIN_EXPORT int  __stdcall EgtCreateArcC2PEx( int nParentId, const double ptCen[3
                                              const double ptNearEnd[3], int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateArc3P( int nParentId, const double ptP1[3],
                                           const double ptP2[3], const double ptP3[3], int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateArc2PR( int nParentId, const double ptStart[3], const double ptEnd[3],
+                                           double dRad, BOOL bCCW, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateArc2PD( int nParentId, const double ptStart[3], const double ptEnd[3],
                                            double dDirSDeg, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateArc2PDEx( int nParentId, const double ptStart[3],
@@ -306,9 +320,10 @@ EIN_EXPORT int  __stdcall EgtCreateSurfTmByRevolve( int nParentId, int nCrvId,
                                                     const double ptAx[3], const double vtAx[3],
                                                     BOOL bCapEnds, double dLinTol, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateSurfTmByScrewing( int nParentId, int nCrvId,
-                                               const double ptAx[3], const double vtAx[3],
-                                               double dAngRotDeg, double dMove, BOOL bCapEnds, double dLinTol, int nRefType) ;
-EIN_EXPORT int  __stdcall EgtCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, BOOL bCapEnds, double dLinTol) ;
+                                                     const double ptAx[3], const double vtAx[3],
+                                                     double dAngRotDeg, double dMove, BOOL bCapEnds, double dLinTol, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, const double vtAx[3],
+                                                BOOL bCapEnds, double dLinTol, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateSurfTmRuled( int nParentId, int nPntOrCrvId1, int nCrvId2, int nType, double dLinTol) ;
 EIN_EXPORT int  __stdcall EgtCreateSurfTmByTriangles( int nParentId, int nNumId, const int nIds[], BOOL bErase) ;
 EIN_EXPORT int  __stdcall EgtCreateSurfTmBySewing( int nParentId, int nNumId, const int nIds[], BOOL bErase) ;
@@ -400,7 +415,7 @@ EIN_EXPORT BOOL __stdcall EgtSetStatus( int nId, int nStat) ;
 EIN_EXPORT BOOL __stdcall EgtRevertStatus( int nId) ;
 EIN_EXPORT BOOL __stdcall EgtGetStatus( int nId, int* pnStat) ;
 EIN_EXPORT BOOL __stdcall EgtGetCalcStatus( int nId, int* pnStat) ;
-EIN_EXPORT BOOL __stdcall EgtSetMark( int nId) ;
+EIN_EXPORT BOOL __stdcall EgtSetMark( int nId, int nMark) ;
 EIN_EXPORT BOOL __stdcall EgtResetMark( int nId) ;
 EIN_EXPORT BOOL __stdcall EgtGetMark( int nId, BOOL* pnMark) ;
 EIN_EXPORT BOOL __stdcall EgtGetCalcMark( int nId, BOOL* pnMark) ;
@@ -434,6 +449,7 @@ EIN_EXPORT BOOL __stdcall EgtGetInfoBBox( int nId, const wchar_t* wsKey,
                                           double ptMin[3], double ptMax[3]) ;
 EIN_EXPORT BOOL __stdcall EgtGetInfoFrame( int nId, const wchar_t* wsKey, double ptOrig[3],
                                            double vtX[3], double vtY[3], double vtZ[3]) ;
+EIN_EXPORT BOOL __stdcall EgtGetAllInfo( int nId, wchar_t*& wsInfos) ;
 EIN_EXPORT BOOL __stdcall EgtExistsInfo( int nId, const wchar_t* wsKey) ;
 EIN_EXPORT BOOL __stdcall EgtRemoveInfo( int nId, const wchar_t* wsKey) ;
 EIN_EXPORT BOOL __stdcall EgtSetTextureName( int nId, const wchar_t* wsTxrName) ;
@@ -529,6 +545,8 @@ EIN_EXPORT BOOL __stdcall EgtSurfFrAdd( int nId1, int nId2) ;
 EIN_EXPORT BOOL __stdcall EgtSurfFrSubtract( int nId1, int nId2) ;
 EIN_EXPORT BOOL __stdcall EgtSurfFrIntersect( int nId1, int nId2) ;
 EIN_EXPORT BOOL __stdcall EgtSurfFrOffset( int nId, double dDist, int nType) ;
+EIN_EXPORT BOOL __stdcall EgtSurfTmMoveVertex( int nId, int nVert, const double ptNewVert[3], int nRefType, BOOL bUpdate) ;
+EIN_EXPORT BOOL __stdcall EgtSurfTmMoveFacet( int nId, int nFacet, const double vtMove[3], int nRefType, BOOL bUpdate) ;
 EIN_EXPORT int  __stdcall EgtSurfTmToTriangles( int nId, int* pnCount) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmRemoveFacet( int nId, int nFacet) ;
 EIN_EXPORT BOOL __stdcall EgtCutSurfTmPlane( int nId, const double ptOn[3], const double vtN[3], BOOL bSaveOnEq, int nRefType) ;
@@ -536,6 +554,7 @@ EIN_EXPORT BOOL __stdcall EgtCutSurfTmClosedCurve( int nSurfId, int nCurveId, BO
 EIN_EXPORT BOOL __stdcall EgtSurfTmAdd( int nId1, int nId2, BOOL bTwoColors) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmSubtract( int nId1, int nId2, BOOL bTwoColors) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmIntersect( int nId1, int nId2, BOOL bTwoColors) ;
+EIN_EXPORT BOOL __stdcall EgtSurfTmSetFaceColor( int nId, int nFacet, int nColor) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmResetTwoColors( int nId) ;
 EIN_EXPORT int  __stdcall EgtSurfTmSplit( int nId, int nSplitterId, int* pnCount) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmCut( int nId, int nCutterId, BOOL bInVsOut, BOOL bSaveOnEq) ;
@@ -559,6 +578,9 @@ EIN_EXPORT BOOL __stdcall EgtCurveParamAtLength( int nId, double dLen, double* p
 EIN_EXPORT BOOL __stdcall EgtCurveLengthAtPoint( int nId, const double ptOn[3], double dExtend, double* pdLen) ;
 EIN_EXPORT BOOL __stdcall EgtCurveIsClosed( int nId) ;
 EIN_EXPORT BOOL __stdcall EgtCurveIsFlat( int nId, BOOL bUseExtrusion, double dToler, double vtN[3], double* pdDist) ;
+EIN_EXPORT BOOL __stdcall EgtCurveIsACircle( int nId, double dToler, double ptC[3], double vtN[3], double* pdRad, BOOL* pbCCW) ;
+EIN_EXPORT BOOL __stdcall EgtCurveIsARectangle( int nId, double dToler, double ptP[3], double vtL1[3], double vtL2[3]) ;
+EIN_EXPORT BOOL __stdcall EgtCurveIsATrapezoid( int nId, double dToler, double ptP[3], double vtB1[3], double vtL1[3], double vtB2[3]) ;
 EIN_EXPORT BOOL __stdcall EgtCurveAreaXY( int nId, double* pdArea) ;
 EIN_EXPORT BOOL __stdcall EgtCurveArea( int nId, double vtN[3], double* pdDist, double* pdArea) ;
 EIN_EXPORT BOOL __stdcall EgtCurveNearestExtremityToPoint( int nId, const double ptP[3], BOOL* pbStart) ;
@@ -574,6 +596,8 @@ EIN_EXPORT BOOL __stdcall EgtArcAngCenter( int nId, double* pdAngDeg) ;
 EIN_EXPORT BOOL __stdcall EgtArcDeltaN( int nId, double* pdDeltaN) ;
 EIN_EXPORT BOOL __stdcall EgtArcNormVersor( int nId, int nRefId, double vtNorm[3]) ;
 EIN_EXPORT BOOL __stdcall EgtCurveCompoCenter( int nId, int nSimpCrv, int nRefId, double ptCen[3]) ;
+EIN_EXPORT BOOL __stdcall EgtCopyCompoSubCurve( int nId, int nSubCrvToCopy, int nParentId) ;
+EIN_EXPORT BOOL __stdcall EgtCopyParamRange( int nId, double dUStart, double dUEnd, int nParentId) ;
 
 // GeomDb Surf Get
 EIN_EXPORT BOOL __stdcall EgtSurfArea( int nId, double* pdArea) ;
@@ -583,10 +607,13 @@ EIN_EXPORT BOOL __stdcall EgtSurfFrNormVersor( int nId, int nRefId, double vtNor
 EIN_EXPORT BOOL __stdcall EgtSurfFrGrossArea( int nId, double* pdArea) ;
 EIN_EXPORT int  __stdcall EgtSurfFrChunkCount( int nId) ;
 EIN_EXPORT int  __stdcall EgtSurfFrChunkSimpleClassify( int nId1, int nChunk1, int nId2, int nChunk2, double dToler) ;
+EIN_EXPORT BOOL __stdcall EgtSurfFrChunkCenter( int nId, int nChunk, int nRefId, double ptCen[3], double vtNorm[3]) ;
 EIN_EXPORT int  __stdcall EgtExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount) ;
 EIN_EXPORT int  __stdcall EgtSurfTmPartCount( int nId) ;
 EIN_EXPORT int  __stdcall EgtSurfTmFacetCount( int nId) ;
 EIN_EXPORT int  __stdcall EgtSurfTmFacetFromTria( int nId, int nT) ;
+EIN_EXPORT BOOL __stdcall EgtSurfTmGetVertex( int nId, int nVert, int nRefId, double ptVert[3]) ;
+EIN_EXPORT BOOL __stdcall EgtSurfTmGetNearestVertex( int nId, const double ptNear[3], int nRefId, int* pnVert, double ptVert[3]) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmFacetNearestEndPoint( int nId, int nFacet, const double ptNear[3], int nRefId,
                                                          double ptEnd[3], double vtNorm[3]) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmFacetNearestMidPoint( int nId, int nFacet, const double ptNear[3], int nRefId,
@@ -778,7 +805,10 @@ EIN_EXPORT BOOL __stdcall EgtGetTableArea( int nInd, double ptMin[3], double ptM
 EIN_EXPORT BOOL __stdcall EgtGetTableAreaOffset( int nInd, double ptMinOffs[3], double ptMaxOffs[3]) ;
 EIN_EXPORT BOOL __stdcall EgtChangeTable( const wchar_t* wsTable, BOOL bUpdateDisp) ;
 EIN_EXPORT BOOL __stdcall EgtShowOnlyTable( BOOL bVal) ;
+EIN_EXPORT BOOL __stdcall EgtMoveDispAxis( const wchar_t* wsName, double dPos) ;
+EIN_EXPORT BOOL __stdcall EgtRemoveDispAxis( const wchar_t* wsName) ;
 EIN_EXPORT int  __stdcall EgtAddFixture( const wchar_t* wsName, const double ptPos[3], double dAngRotDeg, double dMov) ;
+EIN_EXPORT BOOL __stdcall EgtKeepAllDispAxes( int nSouPhase) ;
 EIN_EXPORT BOOL __stdcall EgtKeepFixture( int nFxtId, int nSouPhase) ;
 EIN_EXPORT BOOL __stdcall EgtRemoveFixture( int nFxtId) ;
 EIN_EXPORT BOOL __stdcall EgtVerifyFixture( int nFxtId) ;
@@ -786,7 +816,9 @@ EIN_EXPORT int  __stdcall EgtGetFirstFixture( void) ;
 EIN_EXPORT int  __stdcall EgtGetNextFixture( int nFxtId) ;
 EIN_EXPORT BOOL __stdcall EgtMoveFixture( int nFxtId, const double vtMove[3]) ;
 EIN_EXPORT BOOL __stdcall EgtRotateFixture( int nFxtId, double dDeltaAngDeg) ;
+EIN_EXPORT BOOL __stdcall EgtSetFixtureLink( int nFxtId, const wchar_t* wsTaLink) ;
 EIN_EXPORT BOOL __stdcall EgtMoveFixtureMobile( int nFxtId, double dDeltaMov) ;
+EIN_EXPORT BOOL __stdcall EgtSetFixtureMobile( int nFxtId, double dMov) ;
 // Tools DataBase
 EIN_EXPORT BOOL __stdcall EgtTdbGetToolNewName( const wchar_t* wsName, wchar_t*& wsNewName) ;
 EIN_EXPORT BOOL __stdcall EgtTdbAddTool( const wchar_t* wsName, int nType) ;
@@ -910,7 +942,8 @@ EIN_EXPORT BOOL __stdcall EgtApplyMachining( BOOL bRecalc) ;
 EIN_EXPORT BOOL __stdcall EgtUpdateMachining( void) ;
 EIN_EXPORT BOOL __stdcall EgtPreparePreviewMachiningTool( void) ;
 EIN_EXPORT BOOL __stdcall EgtRemovePreviewMachiningTool( void) ;
-EIN_EXPORT int  __stdcall EgtPreviewMachiningTool( int nEntId, int nFlag) ;
+EIN_EXPORT int  __stdcall EgtGetPreviewMachiningToolStepCount( void) ;
+EIN_EXPORT int  __stdcall EgtPreviewMachiningTool( int nEntId, int nStep) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachiningParamBool( int nType, BOOL* pbVal) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachiningParamInt( int nType, int* pnVal) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachiningParamDouble( int nType, double* pdVal) ;
@@ -942,8 +975,14 @@ EIN_EXPORT int  __stdcall EgtGetTableId( const wchar_t* wsTable) ;
 EIN_EXPORT int  __stdcall EgtGetAxisId( const wchar_t* wsAxis) ;
 EIN_EXPORT int  __stdcall EgtGetHeadId( const wchar_t* wsHead) ;
 EIN_EXPORT int  __stdcall EgtGetHeadExitCount( const wchar_t* wsHead) ;
+EIN_EXPORT BOOL __stdcall EgtGetAxisType( const wchar_t* wsAxis, BOOL* pbLinear) ;
+EIN_EXPORT BOOL __stdcall EgtGetAxisDir( const wchar_t* wsAxis, double vtDir[3]) ;
 EIN_EXPORT BOOL __stdcall EgtGetAxisInvert( const wchar_t* wsAxis, BOOL* pbInvert) ;
 EIN_EXPORT BOOL __stdcall EgtGetAxisOffset( const wchar_t* wsAxis, double* pdOffset) ;
+EIN_EXPORT BOOL __stdcall EgtGetAxisPos( const wchar_t* wsAxis, double* pdVal) ;
+EIN_EXPORT BOOL __stdcall EgtGetAxisMin( const wchar_t* wsAxis, double* pdMin) ;
+EIN_EXPORT BOOL __stdcall EgtGetAxisMax( const wchar_t* wsAxis, double* pdMax) ;
+EIN_EXPORT BOOL __stdcall EgtGetAxisHomePos( const wchar_t* wsAxis, double* pdHome) ;
 EIN_EXPORT BOOL __stdcall EgtGetAllHeadsNames( wchar_t*& wsNames) ;
 EIN_EXPORT BOOL __stdcall EgtGetAllTablesNames( wchar_t*& wsNames) ;
 // Machine Calc
@@ -951,19 +990,17 @@ EIN_EXPORT BOOL __stdcall EgtSetCalcTool( const wchar_t* wsTool, const wchar_t*
 EIN_EXPORT BOOL __stdcall EgtGetCalcTool( wchar_t*& wsTool, wchar_t*& wsHead, int* pnExit) ;
 EIN_EXPORT BOOL __stdcall EgtGetCalcAngles( const double vtDirT[3], const double vtDirA[3],
                                             int* pnStat, double* pdAngA1, double* pdAngB1, double* pdAngA2, double* pdAngB2) ;
-EIN_EXPORT BOOL __stdcall EgtGetCalcPositions( const double ptP[3], double dAngA, double dAngB,
+EIN_EXPORT BOOL __stdcall EgtGetCalcAnglesEx( const double vtDirT[3], const double vtDirA[3],
+                                              int* pnStat, double*& vAngs1, double*& vAngs2, int* pnCount) ;
+EIN_EXPORT BOOL __stdcall EgtGetCalcPositions( const double ptP[3], int nCount, const double dAngs[],
                                                int* pnStat, double* pdX, double* pdY, double* pdZ) ;
-EIN_EXPORT BOOL __stdcall EgtGetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
+EIN_EXPORT BOOL __stdcall EgtGetCalcTipFromPositions( double dX, double dY, double dZ, int nCount, const double dAngs[],
                                                       BOOL bBottom, double ptTip[3]) ;
-EIN_EXPORT BOOL __stdcall EgtGetCalcToolDirFromAngles( double dAngA, double dAngB, double vtDir[3]) ;
+EIN_EXPORT BOOL __stdcall EgtGetCalcToolDirFromAngles( int nCount, const double dAngs[], double vtDir[3]) ;
 EIN_EXPORT BOOL __stdcall EgtVerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int* pnStat) ;
 EIN_EXPORT BOOL __stdcall EgtGetOutstrokeInfo( wchar_t*& wsInfo) ;
 // Machine Move
 EIN_EXPORT BOOL __stdcall EgtSetAxisPos( const wchar_t* wsAxis, double dVal) ;
-EIN_EXPORT BOOL __stdcall EgtGetAxisPos( const wchar_t* wsAxis, double* pdVal) ;
-EIN_EXPORT BOOL __stdcall EgtGetAxisMin( const wchar_t* wsAxis, double* pdMin) ;
-EIN_EXPORT BOOL __stdcall EgtGetAxisMax( const wchar_t* wsAxis, double* pdMax) ;
-EIN_EXPORT BOOL __stdcall EgtGetAxisHomePos( const wchar_t* wsAxis, double* pdHome) ;
 EIN_EXPORT BOOL __stdcall EgtLoadTool( const wchar_t* wsHead, int nExit, const wchar_t* wsTool) ;
 EIN_EXPORT BOOL __stdcall EgtResetHeadSet( const wchar_t* wsHead) ;
 EIN_EXPORT BOOL __stdcall EgtSetMachineLook( int nFlag) ;
@@ -973,7 +1010,7 @@ EIN_EXPORT BOOL __stdcall EgtInitScene( HWND hWnd, int nDriver, BOOL b2Buff, int
 EIN_EXPORT BOOL __stdcall EgtGetSceneInfo( wchar_t*& wsInfo) ;
 EIN_EXPORT BOOL __stdcall EgtSetBackground( const int nTopCol[4], const int nBottomCol[4], BOOL bRedraw) ;
 EIN_EXPORT BOOL __stdcall EgtSetLineAttribs( int nWidth) ;
-EIN_EXPORT BOOL __stdcall EgtSetMarkAttribs( const int MarkCol[4]) ;
+EIN_EXPORT BOOL __stdcall EgtSetMarkAttribs( const int MarkCol[4], const int Mark2Col[4]) ;
 EIN_EXPORT BOOL __stdcall EgtSetSelSurfAttribs( const int SelSurfCol[4]) ;
 EIN_EXPORT BOOL __stdcall EgtSetGeoLineAttribs( const int GlCol[4]) ;
 EIN_EXPORT BOOL __stdcall EgtSetGeoTriaAttribs( const int GtCol[4]) ;
@@ -1038,6 +1075,8 @@ EIN_EXPORT BOOL __stdcall EgtGetTextureDimensions( const wchar_t* wsName, double
 EIN_EXPORT BOOL __stdcall EgtChangeTextureDimensions( const wchar_t* wsName, double dDimX, double dDimY) ;
 EIN_EXPORT BOOL __stdcall EgtGetImage( int nShowMode, const int TopCol[4], const int BottomCol[4],
                                        int nWidth, int nHeight, const wchar_t* wsName) ;
+EIN_EXPORT BOOL __stdcall EgtSetCameraType( BOOL bOrthoOrPersp, BOOL bRedraw) ;
+EIN_EXPORT BOOL __stdcall EgtSetZoomType( int nZoomType, BOOL bRedraw) ;
 
 // Image
 EIN_EXPORT BOOL __stdcall EgtGetImagePixels( const wchar_t* wsFile, int* pnPixelX, int* pnPixelY) ;

EMkDispositionConst.h

@@ -30,5 +30,7 @@ enum RawPartCenterPos { MCH_CE_TC = 1,          // top center
 
 //------------------------ Costanti per fixtures ------------------------------
 static std::string FXT_MOBILE = "MOBILE" ;      // gruppo parte mobile
+static std::string FXT_MOB_MINPOS = "MINPOS" ;  // posizione minima della parte mobile
+static std::string FXT_MOB_MAXPOS = "MAXPOS" ;  // posizione massima della parte mobile
 static std::string FXT_MOB_CPOS = "CPOS" ;      // posizione corrente della parte mobile
 static std::string FXT_MOB_MOVEDIR = "MDIR" ;   // direzione di movimento della parte mobile (default Z di gruppo)

EMkMachMgr.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2023
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EMkMachMgr.h           Data : 28.10.23          Versione : 2.5j4
+// File : EMkMachMgr.h           Data : 25.11.24          Versione : 2.6k5
 // Contenuto : Dichiarazione della interfaccia IMachMgr.
 //
 //
@@ -15,6 +15,10 @@
 //             21.09.22 DS Aggiunta in interfaccia GetAxisOffset.
 //             25.08.23 DS Aggiunta in interfaccia CopyMachGroup.
 //             28.10.23 DS Aggiunte in interfaccia GetClEntAxesVal, GetToolSetupPosInCurrSetup e GetAllCurrAxesName.
+//             30.03.24 DS Aggiunte in interfaccia GetAllAxesNames e GetCalcTable.
+//             02.04.24 DS Aggiunta in interfaccia GetClEntAxesMask.
+//             22.04.24 DS Aggiunta in interfaccia GetExitId.
+//             25.11.24 DS Aggiunta in interfaccia GetMachiningSkippedGeometry.
 //
 //----------------------------------------------------------------------------
 
@@ -114,6 +118,9 @@ class __declspec( novtable) IMachMgr
       virtual bool GetTableAreaOffset( int nInd, BBox3d& b3Area) const = 0 ;
       virtual bool ChangeTable( const std::string& sTable, bool bUpdateDisp) = 0 ;
       virtual bool ShowOnlyTable( bool bVal) = 0 ;
+      virtual bool MoveDispAxis( const std::string& sName, double dPos) = 0 ;
+      virtual bool RemoveDispAxis( const std::string& sName) = 0 ;
+      virtual bool KeepAllDispAxes( int nSouPhase) = 0 ;
       virtual int  AddFixture( const std::string& sName, const Point3d& ptPos, double dAngRotDeg, double dMov) = 0 ;
       virtual bool KeepFixture( int nFxtId, int nSouPhase) = 0 ;
       virtual bool RemoveFixture( int nFxtId) = 0 ;
@@ -122,7 +129,9 @@ class __declspec( novtable) IMachMgr
       virtual int  GetNextFixture( int nFxtId) const = 0 ;
       virtual bool MoveFixture( int nId, const Vector3d& vtMove) = 0 ;
       virtual bool RotateFixture( int nId, double dDeltaAngDeg) = 0 ;
+      virtual bool SetFixtureLink( int nId, const std::string& sTaLink) = 0 ;
       virtual bool MoveFixtureMobile( int nId, double dDeltaMov) = 0 ;
+      virtual bool SetFixtureMobile( int nId, double dMov) = 0 ;
      // Tools DataBase
       virtual bool TdbGetToolNewName( std::string& sName) const = 0 ;
       virtual bool TdbAddTool( const std::string& sName, int nType) = 0 ;
@@ -237,6 +246,7 @@ class __declspec( novtable) IMachMgr
       virtual int  GetPhaseDisposition( int nPhase) const = 0 ;
       virtual bool DispositionSpecialApply( int nId, bool bRecalc) = 0 ;
       virtual bool DispositionSpecialUpdate( int nId) = 0 ;
+      virtual bool GetDispositionToolData( int nId, std::string& sName, std::string& sHead, int& nExit, std::string& sTcPos) = 0 ;
      // Operations : machinings
       virtual int  AddMachining( const std::string& sName, const std::string& sMachining) = 0 ;
       virtual int  AddMachining( const std::string& sName, int nMchType, const std::string& sTool) = 0 ;
@@ -256,12 +266,14 @@ class __declspec( novtable) IMachMgr
       virtual bool MachiningUpdate( bool bPostApply = true) = 0 ;
       virtual bool PreparePreviewMachiningTool( void) const = 0 ;
       virtual bool RemovePreviewMachiningTool( void) const = 0 ;
-      virtual int  PreviewMachiningTool( int nEntId, int nFlag) const = 0 ;
+      virtual int  GetPreviewMachiningToolStepCount( void) const = 0 ; 
+      virtual int  PreviewMachiningTool( int nEntId, int nStep) const = 0 ;
       virtual bool GetMachiningParam( int nType, bool& bVal) const = 0 ;
       virtual bool GetMachiningParam( int nType, int& nVal) const = 0 ;
       virtual bool GetMachiningParam( int nType, double& dVal) const = 0 ;
       virtual bool GetMachiningParam( int nType, std::string& sVal) const = 0 ;
       virtual bool GetMachiningGeometry( SELVECTOR& vIds) const = 0 ;
+      virtual bool GetMachiningSkippedGeometry( SELVECTOR& vIds) const = 0 ;
       virtual bool IsMachiningEmpty( void) const = 0 ;
       virtual bool GetMachiningStartPoint( Point3d& ptStart) const = 0 ;
       virtual bool GetMachiningEndPoint( Point3d& ptEnd) const = 0 ;
@@ -269,6 +281,8 @@ class __declspec( novtable) IMachMgr
       virtual bool GetClEntMove( int nEntId, int& nMove) const = 0 ;
       virtual bool GetClEntFlag( int nEntId, int& nFlag, int& nFlag2) const = 0 ;
       virtual bool GetClEntIndex( int nEntId, int& nIndex) const = 0 ;
+      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 ;
      // Simulation
       virtual bool SimInit( void) = 0 ;
@@ -288,9 +302,10 @@ class __declspec( novtable) IMachMgr
      // Machine Calc
       virtual bool SetCalcTable( const std::string& sTable) = 0 ;
       virtual bool SetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) = 0 ;
-      virtual bool GetAllCurrAxesName( STRVECTOR& vAxName) const = 0 ;
+      virtual bool GetAllCurrAxesNames( STRVECTOR& vAxName) const = 0 ;
       virtual bool SetRotAxisBlock( const std::string& sAxis, double dVal) = 0 ;
       virtual bool GetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) const = 0 ;
+      virtual bool GetCalcTable( std::string& sTable) const = 0 ;
       virtual bool GetCalcTool( std::string& sTool) const = 0 ;
       virtual bool GetCalcHead( std::string& sHead) const = 0 ;
       virtual bool GetCalcExit( int& nExit) const = 0 ;
@@ -318,9 +333,11 @@ class __declspec( novtable) IMachMgr
       virtual int  GetAxisId( const std::string& sAxis) const = 0 ;
       virtual int  GetHeadId( const std::string& sHead) const = 0 ;
       virtual int  GetHeadExitCount( const std::string& sHead) const = 0 ;
+      virtual int  GetExitId( const std::string& sHead, int nExit) const = 0 ;
       virtual int  GetTcPosId( const std::string& sTcPos) const = 0 ;
       virtual bool GetAxisToken( const std::string& sAxis, std::string& sToken) const = 0 ;
       virtual bool GetAxisType( const std::string& sAxis, bool& bLinear) const = 0 ;
+      virtual bool GetAxisDir( const std::string& sAxis, Vector3d& vtDir) const = 0 ;
       virtual bool GetAxisInvert( const std::string& sAxis, bool& bInvert) const = 0 ;
       virtual bool GetAxisOffset( const std::string& sAxis, double& dOffset) const = 0 ;
       virtual bool SetAxisPos( const std::string& sAxis, double dVal, double* pdNewVal = nullptr) = 0 ;
@@ -331,6 +348,7 @@ class __declspec( novtable) IMachMgr
       virtual bool ResetAxisPos( const std::string& sAxis) = 0 ;
       virtual bool ResetAllAxesPos( void) = 0 ;
       virtual bool GetAllTablesNames( STRVECTOR& vNames) const = 0 ;
+      virtual bool GetAllAxesNames( STRVECTOR& vNames) const = 0 ;
       virtual bool GetAllHeadsNames( STRVECTOR& vNames) const = 0 ;
       virtual bool GetAllTcPosNames( STRVECTOR& vNames) const = 0 ;
       virtual bool LoadTool( const std::string& sHead, int nExit, const std::string& sTool) = 0 ;

EMkMachiningConst.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2023
+//  EgalTech 2015-2025
 //----------------------------------------------------------------------------
-// File : EmkMachiningConst.h     Data : 06.09.23      Versione : 2.5i1
+// File : EmkMachiningConst.h     Data : 20.01.25      Versione : 2.7a1
 // Contenuto : Costanti delle lavorazioni.      
 //
 //
@@ -13,6 +13,9 @@
 //             09.11.20 DS Agg. MPA_SIDEANGFEED e MPA_STEPLAST.
 //             04.02.22 DS Agg. MPA_EPICYCLESRAD e MPA_EPICYCLESDIST.
 //             06.09.23 DS Agg. 5AxMachining.
+//             29.03.24 DS Agg. MGP_APPROXLINTOL.
+//             04.12.24 ES Agg. SURFFIN_SUB_Z_CONST e SURFFIN_SUB_OPTIMAL.
+//             20.01.25 ES Agg. SURFFIN_SUB_PROJECT.
 //
 //----------------------------------------------------------------------------
 
@@ -39,7 +42,8 @@ enum MgpType { MGP_NONE =                             0,
                MGP_EXTSAWARCMINRAD =    ( MGP_DOU +  4),
                MGP_INTSAWARCMAXSIDEANG =( MGP_DOU +  5),
                MGP_SAFEAGGRBOTTZ =      ( MGP_DOU +  6),
-               MGP_MAXDEPTHSAFE =       ( MGP_DOU +  7)} ;
+               MGP_MAXDEPTHSAFE =       ( MGP_DOU +  7),
+               MGP_APPROXLINTOL =       ( MGP_DOU +  8)} ;
 
 //----------------------------------------------------------------------------
 // Costanti per tipologia di split arcs
@@ -64,7 +68,7 @@ enum MachiningType {
    MT_SURFROUGHING = OPER_SURFROUGHING,
    MT_SURFFINISHING = OPER_SURFFINISHING,
    MT_WATERJETTING = OPER_WATERJETTING,
-   MT_5AXMACHINING = OPER_5AXMACHINING
+   MT_FIVEAXISMILLING = OPER_FIVEAXISMILLING
 } ;
 
 //----------------------------------------------------------------------------
@@ -154,6 +158,7 @@ enum MpaType { MPA_NONE =                         0,
                MPA_STEPLAST =        ( MPA_DOU + 51),      // per tagli con lama
                MPA_EPICYCLESRAD =    ( MPA_DOU + 52),      // per svuotature con epicicli
                MPA_EPICYCLESDIST =   ( MPA_DOU + 53),      // per svuotature con epicicli
+               MPA_SUBSTEP =         ( MPA_DOU + 54),      // per sgrossature superfici
                MPA_NAME =            ( MPA_STR +  0),
                MPA_TOOL =            ( MPA_STR +  1),
                MPA_DEPTH_STR =       ( MPA_STR +  2),
@@ -322,7 +327,9 @@ enum { SAWFIN_LL_STD = 0,
 enum { POCKET_SUB_ZIGZAG = 0,
        POCKET_SUB_ONEWAY = 1,
        POCKET_SUB_SPIRALIN = 2,
-       POCKET_SUB_SPIRALOUT = 3} ;
+       POCKET_SUB_SPIRALOUT = 3,
+       POCKET_SUB_CONFORMAL_ZIGZAG = 4,
+       POCKET_SUB_CONFORMAL_ONEWAY = 5} ;
 // Tipo di attacco
 enum { POCKET_LI_NONE = 0,
        POCKET_LI_GLIDE = 1,
@@ -361,20 +368,38 @@ enum { MORTISE_PLUNGE_STEP = 0,
        MORTISE_PLUNGE_START_END = 3,
        MORTISE_PLUNGE_START_TO_END = 4} ;
 
+//----------------------------------------------------------------------------
+// Parametri per sgrossatura superfici
+// Sottotipo di lavorazione
+enum { SURFROU_SUB_ZIGZAG = 0,
+       SURFROU_SUB_ONEWAY = 1, 
+       SURFROU_SUB_SPIRALIN = 2,
+       SURFROU_SUB_SPIRALOUT = 3,
+       SURFROU_SUB_CONFORMAL_ZIGZAG = 4,
+       SURFROU_SUB_CONFORMAL_ONEWAY = 5} ;
+// Tipo di attacco
+enum { SURFROU_LI_NONE = 0,
+       SURFROU_LI_GLIDE = 1,
+       SURFROU_LI_ZIGZAG = 2,
+       SURFROU_LI_HELIX = 3} ;
+// Tipo di uscita
+enum { SURFROU_LO_NONE = 0,
+       SURFROU_LO_GLIDE = 1} ;
+
 //----------------------------------------------------------------------------
 // Parametri per finitura superfici
 // Sottotipo di lavorazione
 enum { SURFFIN_SUB_ZIGZAG = 0,
        SURFFIN_SUB_ONEWAY = 1, 
        SURFFIN_SUB_SPIRALIN = 2,
-       SURFFIN_SUB_SPIRALOUT = 3} ;
+       SURFFIN_SUB_SPIRALOUT = 3,
+       SURFFIN_SUB_Z_CONST = 4,
+       SURFFIN_SUB_OPTIMAL = 5,
+       SURFFIN_SUB_PROJECT = 6} ;
 // Tipo di attacco
 enum { SURFFIN_LI_NONE = 0,
        SURFFIN_LI_LINEAR = 1,
        SURFFIN_LI_TANGENT = 2} ;
-// Tipo di link
-enum { SURFFIN_LL_STD = 0,
-       SURFFIN_LL_CENT = 1} ;
 // Tipo di uscita
 enum { SURFFIN_LO_NONE = 0,
        SURFFIN_LO_LINEAR = 1,
@@ -393,7 +418,8 @@ enum { WJET_EC_NONE = 0,
        WJET_EC_LOOP = 2} ;
 // Comportamento su angolo interno
 enum { WJET_IC_NONE = 0,
-       WJET_IC_SLOW = 1} ;
+       WJET_IC_SLOW = 1,
+       WJET_IC_SLOW_FULL = 2} ;
 // Tipo di attacco
 enum { WJET_LI_NONE = 0,
        WJET_LI_LINEAR = 1,

EMkMachiningGeoConst.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2016-2016
+//  EgalTech 2016-2024
 //----------------------------------------------------------------------------
-// File : EmkMachiningGeoConst.h     Data : 06.01.16      Versione : 1.6l6
+// File : EmkMachiningGeoConst.h     Data : 25.11.24      Versione : 2.6k5
 // Contenuto : Costanti per le geometrie delle lavorazioni.      
 //
 //
@@ -26,6 +26,8 @@ static std::string KEY_STRAIGHT = "STR" ;
 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" ; 
 // Sottogruppi delle lavorazioni
 static std::string MCH_AUX = "AUX" ;
 static std::string MCH_AUXVIEW = "AVIEW" ;
@@ -35,17 +37,19 @@ static std::string MCH_ST = "ST" ;
 static std::string MCH_CL = "CL" ;
 static std::string MCH_DBL = "DBL" ;
 static std::string MCH_PATH = "P" ;
-// Nomi di entità CL speciali
+// Nomi di entità CL speciali
 static std::string MCH_CL_CLIMB = "CLIMB" ;
 static std::string MCH_CL_RISE = "RISE" ;
 static std::string MCH_CL_HOME = "HOME" ;
+static std::string MCH_CL_SAFEIN = "SI" ;
 static std::string MCH_CL_LEADIN = "LI" ;
 static std::string MCH_CL_LEADOUT = "LO" ;
+static std::string MCH_CL_SAFEOUT = "SO" ;
 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" ;
-// Nomi di entità di preview
+// Nomi di entità di preview
 static std::string MCH_PV_CUT = "CUT" ;
 static std::string MCH_PV_PRE_CUT = "PRC" ;
 static std::string MCH_PV_POST_CUT = "POC" ;
@@ -60,6 +64,8 @@ static std::string MCH_PV_DOWN_RCUT = "DRCUT" ;
 static std::string MCH_PV_DOWN_RRCUT = "DRRCUT" ;
 static std::string MCH_PV_DOWN_RLICUT = "DRLICUT" ;
 static std::string MCH_PV_DOWN_RLOCUT = "DRLOCUT" ;
+static std::string MCH_PV_UP_RAWCUT = "RUPCUT" ;
+static std::string MCH_PV_DOWN_RAWCUT = "RDWNCUT" ;
 // Chiave info con WidthT, DeltaTi, DeltaT, ExtraCut e RawBottomHeight lama in Preview
 static std::string MCH_PV_KEY_WT = "WT" ;
 static std::string MCH_PV_KEY_DTI = "DTI" ;
@@ -68,10 +74,10 @@ static std::string MCH_PV_KEY_EC = "EC" ;
 static std::string MCH_PV_KEY_RBH = "RBH" ;
 // Chiave info per rinvio a preview spostato nel pezzo in Preview
 static std::string MCH_PV_KEY_RELOCATE = "PvId" ;
-// Chiave info per angoli in XY con entità successiva e precedente
+// Chiave info per angoli in XY con entità successiva e precedente
 static std::string MCH_KEY_NEXTANG = "NextAng" ;
 static std::string MCH_KEY_PREVANG = "PrevAng" ;
-// Chiave info per direzione libera in XY all'inizio e alla fine dell'entità (in assenza infinito)
+// Chiave info per direzione libera in XY all'inizio e alla fine dell'entità (in assenza infinito)
 static std::string MCH_KEY_START_FREELEN = "SFL" ;
 static std::string MCH_KEY_END_FREELEN = "EFL" ;
 // Angolo esterno minimo per calcolare la direzione libera sull'arco
@@ -106,6 +112,10 @@ 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 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) 
+static std::string KEY_PREVIEWSHOW = "PreviewShow" ;
 
 //----------------- Costanti posizione per preview utensile in lavorazione ------
 enum MchToolShow { MCH_TPM_CURR = 0,

EMkOperationConst.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2023
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EmkOperationConst.h     Data : 06.09.23     Versione : 2.5i1
+// File : EmkOperationConst.h     Data : 22.05.24     Versione : 2.6e5
 // Contenuto : Costanti delle operazioni.      
 //
 //
@@ -19,21 +19,21 @@
 #pragma once
 
 //------------------------ Costanti per tipo Operazioni -----------------------
-enum OperType { OPER_NULL =                0,      // nulla
-                OPER_DISP =          0x000100,     // disposizione
-                OPER_DRILLING =      0x000200,     // foratura
-                OPER_SAWING =        0x000400,     // taglio di lama
-                OPER_MILLING =       0x000800,     // fresatura
-                OPER_POCKETING =     0x001000,     // svuotatura
-                OPER_MORTISING =     0x002000,     // mortasatura
-                OPER_SAWROUGHING =   0x004000,     // sgrossatura con lama
-                OPER_SAWFINISHING =  0x008000,     // finitura con lama
-                OPER_GENMACHINING =  0x010000,     // lavorazione generica
-                OPER_CHISELING =     0x020000,     // scalpellatura
-                OPER_SURFROUGHING =  0x040000,     // sgrossatura superficie
-                OPER_SURFFINISHING = 0x080000,     // finitura superficie
-                OPER_WATERJETTING =  0x100000,     // taglio water jet
-                OPER_5AXMACHINING =  0x200000} ;   // lavorazione 5 assi
+enum OperType { OPER_NULL =                  0,      // nulla
+                OPER_DISP =            0x000100,     // disposizione
+                OPER_DRILLING =        0x000200,     // foratura
+                OPER_SAWING =          0x000400,     // taglio di lama
+                OPER_MILLING =         0x000800,     // fresatura
+                OPER_POCKETING =       0x001000,     // svuotatura
+                OPER_MORTISING =       0x002000,     // mortasatura
+                OPER_SAWROUGHING =     0x004000,     // sgrossatura con lama
+                OPER_SAWFINISHING =    0x008000,     // finitura con lama
+                OPER_GENMACHINING =    0x010000,     // lavorazione generica
+                OPER_CHISELING =       0x020000,     // scalpellatura
+                OPER_SURFROUGHING =    0x040000,     // sgrossatura superficie
+                OPER_SURFFINISHING =   0x080000,     // finitura superficie
+                OPER_WATERJETTING =    0x100000,     // taglio water jet
+                OPER_FIVEAXISMILLING = 0x200000} ;   // lavorazione 5 assi
 // Controllo tipo valido
 bool inline IsValidDispositionType( int nType)
 {
@@ -53,5 +53,5 @@ bool inline IsValidMachiningType( int nType)
             nType == OPER_SURFROUGHING  ||
             nType == OPER_SURFFINISHING  ||
             nType == OPER_WATERJETTING  ||
-            nType == OPER_5AXMACHINING) ;
+            nType == OPER_FIVEAXISMILLING) ;
 }

EMkToolConst.h

@@ -122,3 +122,10 @@ const std::string TTH_BASE = "B" ;                      // posizione base portau
 const std::string TTH_LEN = "H" ;                       // lunghezza portautensile da naso mandrino
 const std::string TTH_DIAM = "D" ;                      // diametro massimo portautensile
 const std::string TTH_STEM_DIAM = "D_STEM" ;            // diametro massimo gambo utensile
+const std::string TTH_TYPE = "TYPE" ;                   // stringa tipo di portautensile
+const std::string TTH_TYPE_STD = "Std" ;                // tipo standard (default)
+const std::string TTH_TYPE_FLOAT = "Float" ;            // tipo flottante
+
+//----------------------------------------------------------------------------
+// Costanti per nomi di parti di utensile
+const std::string TNA_TOOL_START = "Tool_" ;            // inizio nome delle geometrie che costituiscono il vero utensile

EXeConst.h

@@ -13,6 +13,7 @@
 
 #pragma once
 
+#include <string>
 
 //----------------- Costanti per tipo di file ----------------------------------
 enum FileType { FT_NULL =  0,
@@ -28,8 +29,10 @@ enum FileType { FT_NULL =  0,
                 FT_SVG =  18,
                 FT_BTLX = 19,
                 FT_3MF =  20,
-                FT_OBJ = 21,
-                FT_3DM = 22 ,
+                FT_OBJ =  21,
+                FT_3DM =  22,
+                FT_OFF =  23,
+                FT_PLY =  24,
                 FT_IGES = 31,
                 FT_STEP = 32,
                 FT_ACIS = 33,

EXeExecutor.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EXcExecutor.h          Data : 09.01.24          Versione : 2.5l6
+// File : EXcExecutor.h          Data : 30.03.24          Versione : 2.6d1
 // Contenuto : Interfaccia Executor.
 //
 //
@@ -64,6 +64,7 @@ EXE_EXPORT bool ExeGetKeyOptions( int nProd, int nVer, int nLev, unsigned int& n
 EXE_EXPORT bool ExeGetKeyLeftDays( int& nLeftDays) ;
 EXE_EXPORT bool ExeGetKeyAssLeftDays( int& nAssLeftDays) ;
 EXE_EXPORT bool ExeGetKeyOptLeftDays( int& nOptLeftDays) ;
+EXE_EXPORT bool ExeGetNetHwKey( void) ;
 EXE_EXPORT bool ExeGetOsInfo( std::string& sOs) ;
 EXE_EXPORT bool ExeGetCpuInfo( std::string& sCpu) ;
 EXE_EXPORT bool ExeGetMemoryInfo( std::string& sMem) ;
@@ -123,10 +124,12 @@ EXE_EXPORT bool ExeImportCsf( const std::string& sFilePath) ;
 EXE_EXPORT bool ExeImportDxf( const std::string& sFilePath, double dScaleFactor) ;
 EXE_EXPORT bool ExeImportPnt( const std::string& sFilePath, int nFlag) ;
 EXE_EXPORT bool ExeImportStl( const std::string& sFilePath, double dScaleFactor) ;
-EXE_EXPORT bool ExeImport3MF( const std::string& sFilePath) ;
+EXE_EXPORT bool ExeImportOff( const std::string& sFilePath, double dScaleFactor) ;
+EXE_EXPORT bool ExeImportPly( const std::string& sFilePath, double dScaleFactor) ;
+EXE_EXPORT bool ExeImport3MF( const std::string& sFilePath, int nFlag = 0) ;
 EXE_EXPORT bool ExeImport3dm( const std::string& sFilePath) ;
 EXE_EXPORT bool ExeAdvancedImportIsEnabled( void) ;
-EXE_EXPORT bool ExeAdvancedImport( const std::string& sFilePath, double dToler = 0.1) ;
+EXE_EXPORT bool ExeAdvancedImport( const std::string& sFilePath, double dToler = 0.1, int nFlag = 0) ;
 EXE_EXPORT bool ExeExportDxf( int nId, const std::string& sFilePath, int nFlag = 1, int nFilter = 393) ;
 EXE_EXPORT bool ExeExportStl( int nId, const std::string& sFilePath, int nFilter = 393) ;
 EXE_EXPORT bool ExeExport3MF( int nId, const std::string& sFilePath, int nFilter = 393) ;
@@ -233,8 +236,11 @@ EXE_EXPORT int  ExeCreateAlignedDimension( int nParentId, const Point3d& ptP1, c
                                            const Point3d& ptDim, const std::string& sText, int nRefType) ;
 EXE_EXPORT int  ExeCreateRadialDimension( int nParentId, int nCrvId, const Point3d& ptDim, const std::string& sText, int nRefType) ;
 EXE_EXPORT int  ExeCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim, const std::string& sText, int nRefType) ;
-EXE_EXPORT int  ExeCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2,
+EXE_EXPORT int  ExeCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2,
                                             const Point3d& ptDim, const std::string& sText, int nRefType) ;
+EXE_EXPORT int  ExeCreateAngularDimensionEx( int nParentId, const Point3d& ptV1, const Point3d& ptP1,
+                                             const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptDim,
+                                             const std::string& sText, int nRefType) ;
 EXE_EXPORT int  ExeCreateAngularDimensionFromLines( int nParentId, const INTVECTOR vLineIds, const Point3d& ptDim,
                                                     const std::string& sText, int nRefType) ;
 EXE_EXPORT int  ExeCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDim,
@@ -271,6 +277,8 @@ EXE_EXPORT int  ExeCreateArcC2PEx( int nParentId, const Point3d& ptCen,
                                    const Point3d& ptNearEnd, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc3P( int nParentId, const Point3d& ptP1,
                                 const Point3d& ptP2, const Point3d& ptP3, int nRefType) ;
+EXE_EXPORT int  ExeCreateArc2PR( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
+                                 double dRad, bool bCCW, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc2PB( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
                                  double dBulge, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc2PD( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
@@ -317,6 +325,8 @@ 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  ExeCreateCurveBezierForm( int nParentId, int nCrvId, int nDeg) ;
+
 // GeomDB Create Surf
 EXE_EXPORT int  ExeCreateSurfFlatRegion( int nParentId, const INTVECTOR& vCrvIds, int* pnCount) ;
 EXE_EXPORT int  ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquaredEnds, bool bSquaredMids, double dLinTol) ;
@@ -325,6 +335,7 @@ EXE_EXPORT int  ExeCreateSurfFrRectangle3P( int nParentId, const Point3d& ptIni,
                                             const Point3d& ptCross, const Point3d& ptDir, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfFrStadium( int nParentId, const Point3d& ptIni, const Point3d& ptCross, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfFrDisk( int nParentId, const Point3d& ptOrig, double dRad, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfTmEmpty( int nParentId) ;
 EXE_EXPORT int  ExeCreateSurfTmPlaneInBBox( int nParentId, const Point3d& ptP, const Vector3d& vtN, const BBox3d& b3Box, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfTmConvexHullInBBox( int nParentId, int nId, const BBox3d& b3Box, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfTmBBox( int nParentId, const BBox3d& b3Box, bool bRegular, int nRefType) ;
@@ -338,8 +349,13 @@ EXE_EXPORT int  ExeCreateSurfTmCone( int nParentId, const Point3d& ptOrig, const
                                      double dRad, double dHeight, double dLinTol, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfTmSphere( int nParentId, const Point3d& ptOrig,
                                        double dRad, double dLinTol, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfTmPyramidFrustum( int nParentId, double dBaseDimX, double dBaseDimY,
+                                               double dTopDimX, double dTopDimY, double dHeight) ;
+EXE_EXPORT int  ExeCreateSurfTmConeFrustum( int nParentId, double dBaseRad, double dTopRad, double dHeight, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmTriangle( int nParentId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptP3, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfTmRectangle( int nParentId, const Point3d& ptO, const Point3d& ptL, const Point3d& ptT, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfTmByPolygon( int nParentId, const PolyLine& PL, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfTmByPolygonWithHoles( int nParentId, const POLYLINEVECTOR& vPL, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfTmByFlatContour( int nParentId, int nCrvId, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmByRegion( int nParentId, const INTVECTOR& vCrvIds, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmByExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vector3d& vtExtr,
@@ -354,22 +370,45 @@ EXE_EXPORT int  ExeCreateSurfTmByScrewing( int nParentId, int nCrvId,
                                            double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfTmRectSwept( int nParentId, double dDimH, double dDimV, double dBevelH, double dBevelV,
                                           int nGuideId, int nCapType, double dLinTol) ;
-EXE_EXPORT int  ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol, Vector3d* vtStatic = nullptr) ;
+EXE_EXPORT int  ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, const Vector3d& vtAx,
+                                      bool bCapEnds, double dLinTol, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfTmTransSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrCrvId2, int nType, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmByTriangles( int nParentId, const INTVECTOR& vIds, bool bErase) ;
 EXE_EXPORT int  ExeCreateSurfTmBySewing( int nParentId, const INTVECTOR& vIds, bool bErase) ;
-EXE_EXPORT int  ExeCreateSurfTmBySurfBezier( int nParentId, int nSbezId) ;
 EXE_EXPORT int  ExeCreateSurfTmByVolZmap( int nParentId, int nZmapId, int nPart) ;
 EXE_EXPORT int  ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTVECTOR& vPnt, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTUVECTOR& vPntW, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBezierLeaves( int nParentId, int nSurfBzId, int nTextHeight = 50, bool bShowTrim = false, int* pnCount = nullptr) ;
+EXE_EXPORT int  ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfBezierTria2D( int nParentId, int nSurfBzId, int nTextHeight, bool bShowTrim, int* pnCount) ;
+EXE_EXPORT int  ExeCreateSurfBzByFlatContour( int nParentId, int nCrvId, double dLinTol) ;
+EXE_EXPORT int  ExeCreateSurfBzByRegion( int nParentId, const INTVECTOR& vCrvId, double dLinTol) ;
+EXE_EXPORT int  ExeCreateSurfBzByExtrusion( int nParentId, int nCrvId, const Vector3d& vtExtr, bool bCapEnds,
+                                            double dLinTol, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfBzByRegionExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vector3d& vtExtr, bool bCapEnds,
+                                                  double dLinTol, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfBzByScrewing( int nParentId, int nCrvId,
+                                           const Point3d& ptAx, const Vector3d& vtAx,
+                                           double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfBzByRevolve( int nParentId, int nCrvId,
+                                           const Point3d& ptAx, const Vector3d& vtAx,
+                                           bool bCapEnds, double dLinTol, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfBzByPointCurve( int nParentId, int nCrvId, const Point3d& ptAx, bool bCapEnds, double dLinTol, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfBzRuled( int nParentId, int nCrvId1, int nCrvId2, int nRuledType, bool bCapEnds, double dLinTol) ;
+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) ;
 
 // GeomDB Create Volume
 EXE_EXPORT int  ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX,
                                    double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
+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) ;
+EXE_EXPORT bool ExeUpdateVolZmapByAddingSurfTm( int nVolZmapId, int nStmId) ;
+EXE_EXPORT bool ExeUniformVolZmap( int nVolZmapId, double dToler) ;
 
 // GeomDB PartLayer
 EXE_EXPORT bool ExeIsPart( int nPartId) ;
@@ -429,6 +468,8 @@ EXE_EXPORT int  ExeGetFirstNameInGroup( int nGroupId, const std::string& sName)
 EXE_EXPORT int  ExeGetNextName( int nId, const std::string& sName) ;
 EXE_EXPORT int  ExeGetLastNameInGroup( int nGroupId, const std::string& sName) ;
 EXE_EXPORT int  ExeGetPrevName( int nId, const std::string& sName) ;
+EXE_EXPORT bool ExeGetNameInGroup( int nGroupId, const std::string& sName, INTVECTOR& vIds) ;
+EXE_EXPORT bool ExeGetInfoInGroup( int nGroupId, const std::string& sKey, INTVECTOR& vIds) ;
 EXE_EXPORT bool ExeGetBBox( int nId, int nFlag, BBox3d& b3Box) ;
 EXE_EXPORT bool ExeGetBBoxGlob( int nId, int nFlag, BBox3d& b3Box) ;
 EXE_EXPORT bool ExeGetBBoxRef( int nId, int nFlag, const Frame3d& frRef, BBox3d& b3Box) ;
@@ -460,7 +501,7 @@ EXE_EXPORT bool ExeSetStatus( const INTVECTOR& vIds, int nStat) ;
 EXE_EXPORT bool ExeRevertStatus( int nId) ;
 EXE_EXPORT bool ExeGetStatus( int nId, int* pnStat) ;
 EXE_EXPORT bool ExeGetCalcStatus( int nId, int* pnStat) ;
-EXE_EXPORT bool ExeSetMark( int nId) ;
+EXE_EXPORT bool ExeSetMark( int nId, int nMark = 1) ;
 EXE_EXPORT bool ExeResetMark( int nId) ;
 EXE_EXPORT bool ExeGetMark( int nId, int* pnMark) ;
 EXE_EXPORT bool ExeGetCalcMark( int nId, int* pnMark) ;
@@ -504,6 +545,7 @@ EXE_EXPORT bool ExeSetTextureFrame( int nId, const Frame3d& frTxrRef, int nRefTy
 EXE_EXPORT bool ExeRemoveTextureData( int nId) ;
 EXE_EXPORT bool ExeGetTextureName( int nId, std::string& sTxrName) ;
 EXE_EXPORT bool ExeGetTextureFrame( int nId, int nRefId, Frame3d& frTxrRef) ;
+EXE_EXPORT bool ExeSetStipple( int nId, int nFactor, int nPattern) ;
 
 // GeomDb Obj Selection
 EXE_EXPORT bool ExeSetObjFilterForSelect( bool bZerodim, bool bCurve, bool bSurf, bool bVolume, bool bExtra) ;
@@ -591,46 +633,63 @@ EXE_EXPORT bool ExeModifyCurveCompoCurveToLine( int nId, int nCrv) ;
 EXE_EXPORT int  ExeExplodeCurveCompo( int nId, int* pnCount) ;
 EXE_EXPORT bool ExeMergeCurvesInCurveCompo( int nId, double dLinTol, bool bStartEnd) ;
 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 ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId,
-                                         double dLinTol, double dMaxSegmLen, int nRefType) ;
-EXE_EXPORT int  ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) ;
-EXE_EXPORT int  ExeCurveGetMedialAxis( int nId, int nDestGrpId, int nSide, int* pnCount) ;
+EXE_EXPORT bool ExeProjectCurveOnSurf( int nCurveId, int nSurfTmId, const Vector3d& vtProj, int nDestGrpId,
+                                       double dLinTol, double dMaxSegmLen, bool bDirFromProj, int nRefType) ;
+EXE_EXPORT bool ExeProjectCurveOnSurfExt( int nCurveId, int nSurfTmId, 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) ;
+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) ;
+EXE_EXPORT bool ExeCurveBezierApproxWithCubicBeziers( int nCrvId, double dTol = 10 * EPS_SMALL) ;
 
 // GeomDb Surf Modify
 EXE_EXPORT bool ExeInvertSurface( const INTVECTOR& vIds) ;
 EXE_EXPORT int  ExeExplodeSurface( int nId, int* pnCount) ;
-EXE_EXPORT bool ExeApproxSurface( int nId, double dLinTol) ;
+EXE_EXPORT bool ExeApproxSurface( int nId, double dLinTol, double dTriaMinSide = 100 * EPS_SMALL) ;
 EXE_EXPORT bool ExeSurfFrAdd( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrSubtract( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrIntersect( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrOffset( int nId, double dDist, int nType) ;
 EXE_EXPORT bool ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewId) ;
+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 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) ;
 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) ;
 EXE_EXPORT bool ExeSurfTmIntersect( int nId1, int nId2, bool bTwoColors = false) ;
-EXE_EXPORT bool ExeSurfTmResetTwoColors( int nId) ;
 EXE_EXPORT int  ExeSurfTmSplit( int nId, int nSplitterId, int* pnCount) ;
 EXE_EXPORT bool ExeSurfTmCut( int nId, int nCutterId, bool bInVsOut, bool bSaveOnEq) ;
 EXE_EXPORT bool ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId,
                                                        INTVECTOR vSurfsId, bool bOCFlag,
                                                        bool& bExistProjection, int& nNewId, int& nNewFaceNbr) ;
+EXE_EXPORT bool ExeSurfTmSetFaceColor( int nId, int nFacet, int nColor) ;
+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) ;
 
 // 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 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) ;
@@ -643,6 +702,8 @@ EXE_EXPORT bool ExeVolZmapSetMortiserTool( const INTVECTOR& vIds, const std::str
                                            double dLen, double dWidth, double dThick, double dCornR, int nFlag, bool bFirst) ;
 EXE_EXPORT bool ExeVolZmapSetChiselTool( const INTVECTOR& vIds, const std::string& sToolName,
                                          double dLen, double dWidth, double dThick, int nFlag, bool bFirst) ;
+EXE_EXPORT bool ExeVolZmapSetAdditiveTool( const INTVECTOR& vIds, const std::string& sToolName,
+                                           double dLen, double dDiam, double dCornR, int nFlag, bool bFirst) ;
 EXE_EXPORT bool ExeVolZmapResetTools( const INTVECTOR& vIds) ;
 EXE_EXPORT int  ExeVolZmapGetToolOutline( int nId, int nDestGrpId, bool bApprox = false) ;
 EXE_EXPORT bool ExeVolZmapMillingStep( int nId, const Point3d& ptPs, const Vector3d& vtDs,
@@ -665,6 +726,7 @@ EXE_EXPORT int ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep,
 // GeomDb Curve Get
 EXE_EXPORT bool ExeCurveDomain( int nId, double* pdStart, double* pdEnd) ;
 EXE_EXPORT bool ExeCurveLength( int nId, double* pdLen) ;
+EXE_EXPORT bool ExeCurveLengthAtParam( int nId, double dPar, double* pdLen) ;
 EXE_EXPORT bool ExeCurveParamAtLength( int nId, double dLen, double* pdPar) ;
 EXE_EXPORT bool ExeCurveParamAtPoint( int nId, const Point3d& pt, double dTol, int nRefType, double* pdPar) ;
 EXE_EXPORT bool ExeCurveLengthAtPoint( int nId, const Point3d& ptOn, double dExtend, double* pdLen) ;
@@ -675,6 +737,7 @@ EXE_EXPORT bool ExeCurveIsARectangle( int nId, Point3d& ptP, Vector3d& vtL1, Vec
 EXE_EXPORT bool ExeCurveIsATrapezoid( int nId, Point3d& ptP, Vector3d& vtB1, Vector3d& vtL1, Vector3d& vtB2, double dToler = EPS_SMALL) ;
 EXE_EXPORT bool ExeCurveAreaXY( int nId, double& dArea) ;
 EXE_EXPORT bool ExeCurveArea( int nId, Plane3d& Plane, double& dArea) ;
+EXE_EXPORT bool ExeCurveMaxOffset( int nId, double& dMaxOffset) ;
 EXE_EXPORT bool ExeCurveNearestExtremityToPoint( int nId, const Point3d& ptP, bool& bStart) ;
 EXE_EXPORT bool ExeCurveExtrusion( int nId, int nRefId, Vector3d& vtExtr) ;
 EXE_EXPORT bool ExeCurveThickness( int nId, double* pdThick) ;
@@ -691,6 +754,11 @@ EXE_EXPORT bool ExeCurveCompoCenter( int nId, int nSimpCrv, int nRefId, Point3d&
 EXE_EXPORT bool ExeCurveCompoRadius( int nId, int nSimpCrv, double& dRad) ;
 EXE_EXPORT bool ExeCurveCompoAngCenter( int nId, int nSimpCrv, double& dAngCen) ;
 EXE_EXPORT bool ExeCurveCompoNormVersor( int nId, int nSimpCrv, int nRefId, Vector3d& vtNorm) ;
+EXE_EXPORT bool ExeCurveCompoGetTempProp( int nId, INTVECTOR& vProp, int nPropInd) ;
+EXE_EXPORT bool ExeCurveCompoGetTempParam( int nId, DBLVECTOR& vParam, int nParamInd) ;
+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) ;
 
 // GeomDb Surf Get
 EXE_EXPORT bool ExeSurfArea( int nId, double& dArea) ;
@@ -698,9 +766,11 @@ EXE_EXPORT bool ExeSurfIsClosed( int nId) ;
 EXE_EXPORT bool ExeSurfVolume( int nId, double& dVol) ;
 EXE_EXPORT bool ExeSurfFrNormVersor( int nId, int nRefId, Vector3d& vtNorm) ;
 EXE_EXPORT bool ExeSurfFrGrossArea( int nId, double& dArea) ;
+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 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) ;
@@ -708,6 +778,7 @@ EXE_EXPORT int  ExeSurfTmFacetCount( int nId) ;
 EXE_EXPORT int  ExeSurfTmPartCount( int nId) ;
 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) ;
 EXE_EXPORT int  ExeSurfTmFacetFromTria( int nId, int nT) ;
 EXE_EXPORT bool ExeSurfTmFacetAdjacencies( int nId, int nFacet, INTMATRIX& vAdj) ;
 EXE_EXPORT bool ExeSurfTmFacetNearestEndPoint( int nId, int nFacet, const Point3d& ptNear, int nRefId,
@@ -726,12 +797,16 @@ EXE_EXPORT bool ExeSurfTmFacetOppositeSideEx( int nId, int nFacet, const Vector3
 EXE_EXPORT bool ExeSurfTmFacetsContact( int nId, int nF1, int nF2, int nRefId, bool& bAdjac, Point3d& ptP1, Point3d& ptP2, double& dAng) ;
 EXE_EXPORT int  ExeExtractSurfTmLoops( int nId, int nDestGrpId, int* pnCount) ;
 EXE_EXPORT int  ExeGetSurfTmSilhouette( int nId, const Vector3d& vtDir, double dToler, int nDestGrpId, int nRefType, int* pnCount, bool bAllTria = false) ;
+EXE_EXPORT int  ExeGetSurfTmParSilhouettes( const INTVECTOR& vIds, const Point3d& ptOn, const Vector3d& vtN, const DBLVECTOR& vdDist,
+                                            double dToler, int nDestGrpId, int nRefType, int* pnCount) ;
 EXE_EXPORT int  ExeExtractSurfTmFacetLoops( int nId, int nFacet, int nDestGrpId, int* pnCount) ;
 EXE_EXPORT int  ExeCopySurfTmFacet( int nId, int nFacet, int nDestGrpId) ;
 EXE_EXPORT bool ExeSurfTmGetAllVertInFacet( int nId, int nFacet, INTVECTOR& vVert) ;
 EXE_EXPORT bool ExeSurfTmGetFacetBBox( int nId, int nFacet, int nFlag, BBox3d& b3Box) ;
 EXE_EXPORT bool ExeSurfTmGetFacetBBoxGlob( int nId, int nFacet, int nFlag, BBox3d& b3Box) ;
 EXE_EXPORT bool ExeSurfTmGetFacetBBoxRef( int nId, int nFacet, int nFlag, const Frame3d& frRef, BBox3d& b3Box) ;
+EXE_EXPORT bool ExeSurfTmGetFacetOutlineInfo( int nId, int nFacet, int nRefId,
+                                              int& nStatus, BOOLVECTOR& vbOpen, INTVECTOR& vnAdj, DBLVECTOR& vdLen, VCT3DVECTOR& vvtNorm, DBLVECTOR& vdElev) ;
 EXE_EXPORT int  ExeSurfTmGetEdges( int nId, int nDestGrpId, bool bSmoothAng, int* pnCount) ;
 EXE_EXPORT bool ExeSurfBezierGetPoint( int nSurfId, double dU, double dV, int nRefId, Point3d& ptP) ;
 EXE_EXPORT bool ExeSurfBezierGetPointD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
@@ -744,6 +819,7 @@ EXE_EXPORT bool ExeSurfBezierGetInfo( int nSurfId, int& nDegU, int& nDegV, int&
 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) ;
+EXE_EXPORT int  ExeShowSurfBezierControlPoints( int nSrfId, int nDestGrpId, int* pnCount) ;
 
 // GeomDb Volume Get
 EXE_EXPORT bool ExeVolZmapVolume( int nId, double& dVol) ;
@@ -809,6 +885,8 @@ EXE_EXPORT bool ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, con
                                   INTDBLVECTOR& vInters) ;
 EXE_EXPORT bool ExeLineSurfTmInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
                                      INTDBLVECTOR& vInters) ;
+EXE_EXPORT bool ExeLineSurfBzInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
+                                     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,
@@ -838,6 +916,16 @@ EXE_EXPORT int  ExeCDeConeSolid( const Frame3d& frCone, double dR1, double dR2,
 EXE_EXPORT int  ExeCDeSpheSolid( const Point3d& ptCen, double dR, int nSolidId, double dSafeDist, int nRefType) ;
 EXE_EXPORT int  ExeCDeSolidSolid( int nSolid1Id, int nSolid2Id, double dSafeDist) ;
 
+// Test Interference
+EXE_EXPORT int  ExeTestBoxSurface( const Frame3d& frBox, const Vector3d& vtDiag, int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestRectPrismoidSurface( const Frame3d& frPrismoid, double dBaseLenX, double dBaseLenY,
+                                            double dTopLenX, double dTopLenY, double dHeight,
+                                            int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestCylSurface( const Frame3d& frCyl, double dR, double dH, int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestConeSurface( const Frame3d& frCone, double dR1, double dR2, double dH, int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestSpheSurface( const Point3d& ptCen, double dR, int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestSurfaceSurface( int nSurf1Id, int nSurf2Id, double dSafeDist) ;
+
 // Maximum Filler
 EXE_EXPORT bool ExeMaxFillerStart( void) ;
 EXE_EXPORT bool ExeMaxFillerAddPart( int nPartId, double dLen) ;
@@ -992,6 +1080,9 @@ EXE_EXPORT bool ExeGetTableArea( int nInd, BBox3d& b3Area) ;
 EXE_EXPORT bool ExeGetTableAreaOffset( int nInd, BBox3d& b3AreaOffs) ;
 EXE_EXPORT bool ExeChangeTable( const std::string& sTable, bool bUpdateDisp) ;
 EXE_EXPORT bool ExeShowOnlyTable( bool bVal) ;
+EXE_EXPORT bool ExeMoveDispAxis( const std::string& sName, double dPos) ;
+EXE_EXPORT bool ExeRemoveDispAxis( const std::string& sName) ;
+EXE_EXPORT bool ExeKeepAllDispAxes( int nSouPhase) ;
 EXE_EXPORT int  ExeAddFixture( const std::string& sName, const Point3d& ptPos, double dAngRotDeg, double dMov) ;
 EXE_EXPORT bool ExeKeepFixture( int nFxtId, int nSouPhase) ;
 EXE_EXPORT bool ExeRemoveFixture( int nFxtId) ;
@@ -1000,7 +1091,9 @@ EXE_EXPORT int  ExeGetFirstFixture( void) ;
 EXE_EXPORT int  ExeGetNextFixture( int nFxtId) ;
 EXE_EXPORT bool ExeMoveFixture( int nFxtId, const Vector3d& vtMove) ;
 EXE_EXPORT bool ExeRotateFixture( int nFxtId, double dDeltaAngDeg) ;
+EXE_EXPORT bool ExeSetFixtureLink( int nFxtId, const std::string& sTaLink) ;
 EXE_EXPORT bool ExeMoveFixtureMobile( int nFxtId, double dDeltaMove) ;
+EXE_EXPORT bool ExeSetFixtureMobile( int nFxtId, double dMove) ;
 // Tools Database
 EXE_EXPORT bool ExeTdbGetToolNewName( std::string& sName) ;
 EXE_EXPORT bool ExeTdbAddTool( const std::string& sName, int nType) ;
@@ -1032,6 +1125,7 @@ EXE_EXPORT bool ExeTdbGetCurrToolValInNotes( int nType, const std::string& sKey,
 EXE_EXPORT bool ExeTdbGetCurrToolMaxDepth( double& dMaxDepth) ;
 EXE_EXPORT bool ExeTdbGetCurrToolThDiam( double& dThDiam) ;
 EXE_EXPORT bool ExeTdbGetCurrToolThLength( double& dThLen) ;
+EXE_EXPORT bool ExeTdbCurrToolIsStandardDraw( bool& bStandard) ;
 EXE_EXPORT int  ExeTdbCurrToolDraw( int nGenCtx, int nToolCtx) ;
 EXE_EXPORT bool ExeTdbReload( void) ;
 EXE_EXPORT bool ExeTdbSave( void) ;
@@ -1113,6 +1207,7 @@ EXE_EXPORT bool ExeRemoveOperationHome( int nId) ;
 EXE_EXPORT int  ExeGetPhaseDisposition( int nPhase) ;
 EXE_EXPORT bool ExeSpecialApplyDisposition( int nId, bool bRecalc) ;
 EXE_EXPORT bool ExeSpecialUpdateDisposition( int nId) ;
+EXE_EXPORT bool ExeGetDispositionToolData( int nId, std::string& sName, std::string& sHead, int& nExit, std::string& sTcPos) ;
 // Machinings
 EXE_EXPORT int  ExeAddMachining( const std::string& sName, const std::string& sMachining) ;
 EXE_EXPORT int  ExeAddMachining( const std::string& sName, int nMchType, const std::string& sTool) ;
@@ -1130,12 +1225,14 @@ EXE_EXPORT bool ExeApplyMachining( bool bRecalc, bool bPostApply = true) ;
 EXE_EXPORT bool ExeUpdateMachining( bool bPostApply = true) ;
 EXE_EXPORT bool ExePreparePreviewMachiningTool( void) ;
 EXE_EXPORT bool ExeRemovePreviewMachiningTool( void) ;
-EXE_EXPORT int  ExePreviewMachiningTool( int nEntId, int nFlag) ;
+EXE_EXPORT int  ExeGetPreviewMachiningToolStepCount( void) ;
+EXE_EXPORT int  ExePreviewMachiningTool( int nEntId, int nStep) ;
 EXE_EXPORT bool ExeGetMachiningParam( int nType, bool& bVal) ;
 EXE_EXPORT bool ExeGetMachiningParam( int nType, int& nVal) ;
 EXE_EXPORT bool ExeGetMachiningParam( int nType, double& dVal) ;
 EXE_EXPORT bool ExeGetMachiningParam( int nType, std::string& sVal) ;
 EXE_EXPORT bool ExeGetMachiningGeometry( SELVECTOR& vIds) ;
+EXE_EXPORT bool ExeGetMachiningSkippedGeometry( SELVECTOR& vIds) ;
 EXE_EXPORT bool ExeIsMachiningEmpty( void) ;
 EXE_EXPORT bool ExeGetMachiningStartPoint( Point3d& ptStart) ;
 EXE_EXPORT bool ExeGetMachiningEndPoint( Point3d& ptEnd) ;
@@ -1147,6 +1244,8 @@ EXE_EXPORT bool ExeUpdateAllMachiningsEx( bool bStopOnFirstErr, std::string& sEr
 EXE_EXPORT bool ExeGetClEntMove( int nEntId, int& nMove) ;
 EXE_EXPORT bool ExeGetClEntFlag( int nEntId, int& nFlag, int& nFlag2) ;
 EXE_EXPORT bool ExeGetClEntIndex( int nEntId, int& nIndex) ;
+EXE_EXPORT bool ExeGetClEntAxesStatus( int nEntId, int& nStatus) ;
+EXE_EXPORT bool ExeGetClEntAxesMask( int nEntId, int& nMask) ;
 EXE_EXPORT bool ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) ;
 
 // Simulation
@@ -1171,20 +1270,24 @@ EXE_EXPORT int  ExeGetTableId( const std::string& sTable) ;
 EXE_EXPORT int  ExeGetAxisId( const std::string& sAxis) ;
 EXE_EXPORT int  ExeGetHeadId( const std::string& sHead) ;
 EXE_EXPORT int  ExeGetHeadExitCount( const std::string& sHead) ;
+EXE_EXPORT int  ExeGetExitId( const std::string& sHead, int nExit) ;
 EXE_EXPORT int  ExeGetTcPosId( const std::string& sTcPos) ;
 EXE_EXPORT bool ExeGetAxisToken( const std::string& sAxis, std::string& sToken) ;
 EXE_EXPORT bool ExeGetAxisType( const std::string& sAxis, bool& bLinear) ;
+EXE_EXPORT bool ExeGetAxisDir( const std::string& sAxis, Vector3d& vtDir) ;
 EXE_EXPORT bool ExeGetAxisInvert( const std::string& sAxis, bool& bInvert) ;
 EXE_EXPORT bool ExeGetAxisOffset( const std::string& sAxis, double& dOffset) ;
 EXE_EXPORT bool ExeGetAllTablesNames( STRVECTOR& vNames) ;
+EXE_EXPORT bool ExeGetAllAxesNames( STRVECTOR& vNames) ;
 EXE_EXPORT bool ExeGetAllHeadsNames( STRVECTOR& vNames) ;
 EXE_EXPORT bool ExeGetAllTcPosNames( STRVECTOR& vNames) ;
 // Machine Calc
 EXE_EXPORT bool ExeSetCalcTable( const std::string& sTable) ;
 EXE_EXPORT bool ExeSetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) ;
-EXE_EXPORT bool ExeGetAllCurrAxesName( STRVECTOR& vAxName) ;
 EXE_EXPORT bool ExeSetRotAxisBlock( const std::string& sAxis, double dVal) ;
+EXE_EXPORT bool ExeGetCalcTable( std::string& sTable) ;
 EXE_EXPORT bool ExeGetCalcTool( std::string& sTool, std::string& sHead, int& nExit) ;
+EXE_EXPORT bool ExeGetAllCurrAxesNames( STRVECTOR& vAxName) ;
 EXE_EXPORT bool ExeGetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) ;
 EXE_EXPORT bool ExeGetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                                   int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) ;
@@ -1221,7 +1324,7 @@ EXE_EXPORT bool ExeGetSceneInfo( std::string& sInfo) ;
 EXE_EXPORT bool ExeSetBackground( Color TopCol, Color BottomCol, bool bRedraw) ;
 EXE_EXPORT bool ExeGetBackground( Color& TopCol, Color& BottomCol) ;
 EXE_EXPORT bool ExeSetLineAttribs( int nWidth) ;
-EXE_EXPORT bool ExeSetMarkAttribs( Color MarkCol) ;
+EXE_EXPORT bool ExeSetMarkAttribs( Color MarkCol, Color Mark2Col) ;
 EXE_EXPORT bool ExeSetSelSurfAttribs( Color SelSurfCol) ;
 EXE_EXPORT bool ExeSetGeoLineAttribs( Color GlCol) ;
 EXE_EXPORT bool ExeSetGeoTriaAttribs( Color GtCol) ;
@@ -1289,6 +1392,8 @@ EXE_EXPORT bool ExeGetTextureDimensions( const std::string& sName, double& dDimX
 EXE_EXPORT bool ExeChangeTextureDimensions( const std::string& sName, double dDimX, double dDimY) ;
 EXE_EXPORT bool ExeGetImage( int nShowMode, Color colBackTop, Color colBackBottom,
                              int nWidth, int nHeight, const std::string& sFile) ;
+EXE_EXPORT bool ExeSetCameraType( bool bOrthoOrPersp, bool bRedraw) ;
+EXE_EXPORT bool ExeSetZoomType( int nMode, bool bRedraw) ;
 
 // Image
 EXE_EXPORT bool ExeGetImagePixels( const std::string& sFile, int& nPixelX, int& nPixelY) ;

EgtBase64.h

@@ -101,9 +101,9 @@ B64Decode( const std::string& sB64Sou, std::string& sDest)
       if ( p != nullptr)
          nVal = char( p - EncB64) ;
       in[phase] = (( c < 43 || c > 122) ? -1 : (int) DecB64[ c - 43]) ;
-		if ( in[phase] != 0 )
-		   in[phase] = ((in[phase] == (int)'$') ? -1 : in[phase] - 62) ;
-		if ( in[phase] != -1 ) {
+      if ( in[phase] != 0 )
+         in[phase] = ((in[phase] == (int)'$') ? -1 : in[phase] - 62) ;
+      if ( in[phase] != -1 ) {
          phase = (phase + 1) % 4 ;
          if ( phase == 0) {
             decodeblock( in, sDest) ;

EgtKeyCodes.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2025
 //----------------------------------------------------------------------------
-// File : EgtKeyCodes.h       Data : 16.01.24        Versione : 2.6a1
+// File : EgtKeyCodes.h       Data : 04.03.25        Versione : 2.7a3
 // Contenuto : Costanti per codici di protezione librerie di base.
 //
 //
@@ -18,6 +18,7 @@
 //             01.01.22 DS Passaggio a versione 24.
 //             01.01.23 DS Passaggio a versione 25.
 //             16.01.24 DS Passaggio a versione 26.
+//             07.01.25 DS Passaggio a versione 27.
 //
 //----------------------------------------------------------------------------
 
@@ -25,7 +26,7 @@
 
 //----------------------------------------------------------------------------
 const int KEY_BASELIB_PROD = 207 ;
-const int KEY_BASELIB_VER = 2603 ;
+const int KEY_BASELIB_VER = 2704 ;
 const int KEY_BASELIB_LEV = 1 ;
 
 //----------------------------------------------------------------------------

SELkKeyProc.h

@@ -44,3 +44,4 @@ const int KEY_ERR_VER = 5 ;
 const int KEY_ERR_LEV = 6 ;
 const int KEY_ERR_WRONG_TIME = 7 ;
 const int KEY_ERR_TIME = 8 ;
+const int KEY_ERR_NETKEY_NOTFOUND = 9 ;

SELkLockId.h

@@ -23,6 +23,8 @@ bool SetLockType( int nType) ;
 bool SetNetHwKey( bool bNetHwKey, int nUserId, const std::string& sAddrPort) ;
 // Libero chiave di rete (da eseguire al termine del programma)
 bool CloseNetHwKey( void) ;
+// Chiave di rete non trovata (il dispositivo non risponde)
+bool NotFoundNetHwKey( void) ;
 // Recupero l'identificativo in chiaro della protezione
 bool GetLockId( std::string& sLockId) ;
 // Recupero l'identificativo cifrato della protezione