Merge commit '9144694734e55e22ee227a51ec928897e760ad79' into ExtDimension_Angular

- aggiornamento prototipi

EE3DllMain.h

@@ -1,73 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : EE3DllMain.h          Data : 14.11.23          Versione : 2.5k2
-// Contenuto : Prototipi funzioni generali della DLL.
-//
-//
-//
-// Modifiche : 14.11.23 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include <string>
-
-class ILogger ;
-
-//----------------------- Macro per import/export ----------------------------
-#undef EE3_EXPORT
-#if defined( I_AM_EE3)            // da definirsi solo nella DLL
-   #define EE3_EXPORT __declspec( dllexport)
-#else
-   #define EE3_EXPORT __declspec( dllimport)
-#endif
-
-//-----------------------------------------------------------------------------
-// E' necessaria l'interfaccia in C per caricare queste funzioni dinamicamente
-extern "C" {
-   // restituisce la versione della Dll
-   EE3_EXPORT const char* GetEE3Version( void) ;
-   // permette di impostare il logger per la Dll
-   EE3_EXPORT void SetEE3Logger( ILogger* pLogger) ;
-   // imposta la chiave di protezione
-   EE3_EXPORT void SetEE3Key( const std::string& sKey) ;
-   // imposta se chiave hardware di rete
-   EE3_EXPORT void SetEE3NetHwKey( bool bNetHwKey) ;
-}
-
-
-//-----------------------------------------------------------------------------
-#include "/EgtDev/Include/EGnStringUtils.h"
-#include "/EgtDev/Include/EgtILogger.h"
-#include "/EgtDev/Include/EgtKeyCodes.h"
-#include "/EgtDev/Include/SELkKeyProc.h"
-
-//-----------------------------------------------------------------------------
-// Test della chiave per caricare la DLL
-inline bool
-TestKeyForEE3( const std::string& sKey, int nKeyOpt, ILogger* pLogger)
-{
-  // verifico la chiave e le opzioni
-   unsigned int nOpt1, nOpt2 ;
-   int nOptExpDays ;
-   int nRet = GetKeyOptions( sKey, KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
-                             nOpt1, nOpt2, nOptExpDays) ;
-   if ( nRet != KEY_OK  &&  ! EqualNoCase( sKey, "EE3Base")) {
-      if ( nRet != KEY_OK) {
-         std::string sErr = "Error on Key (EE3/" + ToString( nRet) + ")" ;
-         LOG_ERROR( pLogger, sErr.c_str()) ;
-         return false ;
-      }
-      if ( ( nOpt1 & ( KEYOPT_EEX_INPBASE|KEYOPT_EEX_EXPBASE)) == 0  ||
-           ( nKeyOpt != 0  &&  ( nOpt1 & nKeyOpt) == 0)  ||
-           nOptExpDays < GetCurrDay()) {
-         std::string sErr = "Warning on Key (EE3/OPT)" ;
-         LOG_ERROR( pLogger, sErr.c_str()) ;
-         return false ;
-      }
-   }
-   return true ;
-}

EE3Export3dm.h

@@ -1,40 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023
-//----------------------------------------------------------------------------
-// File : EE3Export3dm.h          Data : 21.09.23          Versione :
-// Contenuto : Dichiarazione della interfaccia IExport3dm.
-//
-//
-//
-// Modifiche : 21.09.23 DB Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkGeomDB.h"
-#include "/EgtDev/Include/EExExportConst.h"
-#include <string>
-
-//----------------------- Macro per import/export ----------------------------
-#undef EE3_EXPORT
-#if defined( I_AM_EE3)            // da definirsi solo nella DLL
-#define EE3_EXPORT __declspec( dllexport)
-#else
-#define EE3_EXPORT __declspec( dllimport)
-#endif
-
-//-----------------------------------------------------------------------------
-class __declspec( novtable) IExport3dm
-{
-public :
-   virtual ~IExport3dm( void) {}
-   virtual bool SetOptions( int nFilter) = 0 ;
-   virtual bool Export( IGeomDB* pGDB, int nId, const std::string& sFile) = 0 ;
-} ;
-
-//-----------------------------------------------------------------------------
-extern "C" {
-   EE3_EXPORT IExport3dm* CreateExport3dm(void) ;
-}

EE3Import3dm.h

@@ -1,39 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023
-//----------------------------------------------------------------------------
-// File : EE3Import3dm.h          Data : 26.06.23          Versione : 2.5f1
-// Contenuto : Dichiarazione della interfaccia IImport3dm.
-//
-//
-//
-// Modifiche : 26.06.23 DB Creazione modulo.
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkGeomDB.h"
-#include <string>
-
-//----------------------- Macro per import/export ----------------------------
-#undef EE3_EXPORT
-#if defined( I_AM_EE3)            // da definirsi solo nella DLL
-#define EE3_EXPORT __declspec( dllexport)
-#else
-#define EE3_EXPORT __declspec( dllimport)
-#endif
-
-//-----------------------------------------------------------------------------
-class __declspec( novtable) IImport3dm
-{
-public :
-   virtual ~IImport3dm( void) {} 
-   virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup,
-                        double dTextHeight = 2.0, double dExtLine = 5.0, double dArrLen = 5.0, double dTextDist = 2.0,
-                        bool bLenIsMM = true, int nDecDig = -2, std::string sFont = "ModernPropS.Nfe") = 0 ;
-} ;
-
-//-----------------------------------------------------------------------------
-extern "C" {
-   EE3_EXPORT IImport3dm* CreateImport3dm( void) ;
-}

EGkArcSpecial.h

@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2022
 //----------------------------------------------------------------------------
-// File : EGkArcSpecial.h       Data : 04.08.23         Versione : 2.5h1
+// File : EGkArcSpecial.h       Data : 20.12.22         Versione : 2.4l3
 // Contenuto : Dichiarazione funzioni per calcolo speciale archi.
 //
 //
 //
 // Modifiche : 12.06.14 DS Creazione modulo.
 //             20.12.22 DS Aggiunta GetArc2PCN.
-//             04.08.23 DS Aggiunta GetArc2PNB.
 //
 //----------------------------------------------------------------------------
 
@@ -28,6 +27,5 @@
 //----------------------------------------------------------------------------
 EGK_EXPORT ICurve* GetArc2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStartDeg) ;
 EGK_EXPORT ICurve* GetArc2PVN( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDirS, const Vector3d& vtN) ;
-EGK_EXPORT ICurve* GetArc2PNB( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtN, double dBulge) ;
 EGK_EXPORT ICurve* GetArc3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d& ptEnd, bool bCirc) ;
 EGK_EXPORT ICurveArc* GetArc2PCN( const Point3d& ptStart, const Point3d& ptEnd, const Point3d& ptNearCen, const Vector3d& vtN) ;

EGkBBox3d.h

@@ -1,14 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2023
+//  EgalTech 2013-2022
 //----------------------------------------------------------------------------
-// File : EGkBBox3d.h              Data : 12.05.23          Versione : 2.5e3
+// File : EGkBBox3d.h              Data : 17.08.22          Versione : 2.4h1
 // Contenuto : Dichiarazione della classe axis aligned bounding box BBox3d.
 //
 //
 //
 // Modifiche : 14.01.13 DS Creazione modulo.
 //             17.08.22 DS Aggiunte GetDimX, GetDimY, GetDimZ.
-//             12.05.23 DS Aggiunta Overlaps con Box su riferimento.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -90,11 +90,10 @@ class EGK_EXPORT BBox3d
       bool EnclosesXY( const Point3d& ptP) const ;
       bool Encloses( const BBox3d& b3Box) const ;
       bool EnclosesXY( const BBox3d& b3Box) const ;
-      bool Overlaps( const BBox3d& b3Box) const ;
-      bool OverlapsXY( const BBox3d& b3Box) const ;
-      bool Overlaps( const Frame3d& frBox, const BBox3d& b3Box) const ;
-      bool FindIntersection( const BBox3d& b3Box, BBox3d& b3Int) const ;
-      bool FindIntersectionXY( const BBox3d& b3Box, BBox3d& b3Int) const ;
+      bool Overlaps( const BBox3d& b3B) const ;
+      bool OverlapsXY( const BBox3d& b3B) const ;
+      bool FindIntersection( const BBox3d& b3B, BBox3d& b3Int) const ;
+      bool FindIntersectionXY( const BBox3d& b3B, BBox3d& b3Int) const ;
       double SqDistFromPoint( const Point3d& ptP) const ;
       double SqDistFromPointXY( const Point3d& ptP) const ;
       double DistFromPoint( const Point3d& ptP) const
@@ -127,36 +126,3 @@ class EGK_EXPORT BBox3d
       Point3d m_ptMin ;
       Point3d m_ptMax ;
 } ;
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia in locale del box passato
-//----------------------------------------------------------------------------
-inline const BBox3d
-GetToLoc( const BBox3d& b3Box, const Frame3d& frRef)
-{
-   BBox3d b3New = b3Box ;
-   b3New.ToLoc( frRef) ;
-   return b3New ;
-}
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia in globale del box passato
-//----------------------------------------------------------------------------
-inline const BBox3d
-GetToGlob( const BBox3d& b3Box, const Frame3d& frRef)
-{
-   BBox3d b3New = b3Box ;
-   b3New.ToGlob( frRef) ;
-   return b3New ;
-}
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia dal primo al secondo riferimento del box passato
-//----------------------------------------------------------------------------
-inline const BBox3d
-GetLocToLoc( const BBox3d& b3Box, const Frame3d& frOri, const Frame3d& frDest)
-{
-   BBox3d b3New = b3Box ;
-   b3New.LocToLoc( frOri, frDest) ;
-   return b3New ;
-}

EGkCDeBoxClosedSurfTm.h

@@ -1,13 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2016-2024
+//  EgalTech 2016-2020
 //----------------------------------------------------------------------------
-// File : EGkCDeBoxClosedSurfTm.h      Data : 24.03.24    Versione : 2.6c2
+// File : EGkCDeBoxClosedSurfTm.h      Data : 09.01.20    Versione : 2.2a2
 // 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.
 //
 //----------------------------------------------------------------------------
 
@@ -25,16 +24,4 @@
 #endif
 
 //----------------------------------------------------------------------------
-// Il sistema di riferimento è allineato con il box e ha origine in un suo vertice.
-// La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL.
-// Il sistema di riferimento del box è riferito a quello della superficie.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - 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) ;
+EGK_EXPORT bool CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, const ISurfTriMesh& Stm) ;

EGkCDeClosedSurfTmClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EGkCDeClosedSurfTmClosedSurfTm.h  Data : 24.03.24  Versione : 2.6c2
+// File :      EGkCDeSurfTmSurfTm.h      Data : 13.11.20    Versione : 
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             SurfTm e SurfTm.
 //
 // Modifiche : 13.11.20 LM Creazione modulo.
-//             24.03.24 DS Aggiunta TestSurfTmSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -23,15 +23,8 @@
 #endif
 
 //----------------------------------------------------------------------------
+// La funzione restituisce true in caso di collisone, false in caso di assenza
+// di collisione o inconsistenza dei parametri di input.
 // Le due superfici devono essere espresse nel medesimo sistema di riferimento.
 // La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - 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) ;
+EGK_EXPORT bool CDeClosedSurfTmClosedSurfTm( const SurfTriMesh& SurfA, const SurfTriMesh& SurfB, double dSafeDist) ;

EGkCDeConeFrustumClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EGkCDeConeFrustumClosedSurfTm.h   Data : 24.03.24  Versione : 2.6c2
+// File : EGkCDeConeFrustumClosedSurfTm.h      Data : 09.11.20    Versione : 
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             Cone e Closed SurfTriMesh.
 //
 // Modifiche : 09.11.20 LM Creazione modulo.
-//             24.03.24 DS Aggiunta TestConeFrustumSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -23,17 +23,8 @@
 #endif
 
 //----------------------------------------------------------------------------
-// Il sistema di riferimento deve avere l'asse di simmetria del cono come asse Z e origine nel centro della base.
-// La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL.
-// Il sistema di riferimento del cono è riferito a quello della superficie.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
+// Il sisitema di riferimento deve avere l'asse di simmetria del cono come asse Z e origine nel centro della base.
+// La distanza di sicurezza ha effetto solo se maggiore di epsilon, altrimenti è ignorata ed è ininfluente.
+// Il sistema di riferimento del cono deve essere immerso in quello della superficie.
 EGK_EXPORT bool CDeConeFrustumClosedSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                                            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) ;
+                                            double dSafeDist, const ISurfTriMesh& Stm) ;

EGkCDeConvexTorusClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EGkCDeConvexTorusTria.h      Data : 24.03.24    Versione : 2.6c2
+// File : EGkCDeConvexTorusTria.h      Data : 18.11.20    Versione : 
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             toro convesso e SurfTriMesh.
 //
 // Modifiche : 18.11.20 LM Creazione modulo.
-//             24.03.24 DS Aggiunta TestConvexTorusSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -24,18 +24,9 @@
 #endif
 
 //----------------------------------------------------------------------------
-// Il toro convesso è il disco solido limitato dalla sola parte esterna del toro.
+// Il toro convesso è il disco limitato dalla sola parte esterna del toro.
 // Raggio principale R1, raggio secondario R2.
 // Il toro è posto nel piano XY del suo riferimento, centrato sull'origine.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
-//----------------------------------------------------------------------------
-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) ;
+// La funzione restituisce true in caso di collisione.
+EGK_EXPORT bool CDeConvexTorusClosedSurfTm( const Frame3d& frTorusFrame, double dRad1, double dRad2, 
+                                            double dSafeDist, const ISurfTriMesh& tmSurf) ;

EGkCDeCylClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EGkCDeCylClosedSurfTm.h      Data : 24.03.24    Versione : 2.6c2
+// File : EGkCDeCylClosedSurfTm.h      Data : 09.01.20    Versione : 2.2a2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             Cylinder e Closed SurfTriMesh.
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
-//             24.03.24 DS Aggiunta TestCylSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -23,16 +23,4 @@
 #endif
 
 //----------------------------------------------------------------------------
-// Il sistema di riferimento deve avere l'asse di simmetria del cilindro come asse Z e origine nel centro della base.
-// La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL, altrimenti è ignorata ed è ininfluente.
-// Il sistema di riferimento del cilindro è riferito a quello della superficie.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - 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) ;
+EGK_EXPORT bool CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, double dSafeDist, const ISurfTriMesh& Stm) ;

EGkCDeRectPrismoidClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EGkCDeRectPrismoidClosedSurfTm.h  Data : 24.03.24  Versione : 2.6c2
+// File : EGkCDeRectPrismoidClosedSurfTm.h      Data : 09.11.20    Versione : 
 // 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.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -26,17 +26,6 @@
 // Il sistema di riferimento deve avere l'origine nel centro della Base, asse X lungo
 // un segmento della stessa e asse Z ortogonale alle basi e diretto verso la base Top.
 // Il sistema di riferimento della piramide deve essere immerso in quello della superficie.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
-//----------------------------------------------------------------------------
 EGK_EXPORT bool CDeRectPrismoidClosedSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
                                              double dLenghtTopX, double dLenghtTopY, double dHeight,
-                                             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) ;
+                                             double dSafeDist, const ISurfTriMesh& Stm) ;

EGkCDeSpheClosedSurfTm.h

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EGkCDeSpheClosedSurfTm.h      Data : 24.03.24    Versione : 2.6c2
+// File : EGkCDeSpheClosedSurfTm.h      Data : 09.01.20    Versione : 2.2a2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             Sphere e Closed SurfTriMesh.
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
-//             24.03.24 DS Aggiunta TestSpheSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -23,13 +23,4 @@
 #endif
 
 //----------------------------------------------------------------------------
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - 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) ;
+EGK_EXPORT bool CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, double dSafeDist, const ISurfTriMesh& Stm) ;

EGkCalcPocketing.h

@@ -1,31 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : EGkCalcPocketing.h      Data : 16.11.23       Versione : 2.5j1
-// Contenuto : Calcolo dei percorsi elementari di pocketing.
-//
-//
-//
-// Modifiche : 16.11.23 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkCurveComposite.h"
-#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
-
-//-----------------------------------------------------------------------------
-EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dStep, double dAngle, int nType,
-                               bool bSmooth, ICRVCOMPOPOVECTOR& vCrv) ;
-EGK_EXPORT bool CalcZigZagInfill( const ISurfFlatRegion* pSfr, double dStep, bool bSmooth, bool bRemoveOverlapLink,
-                                  ICRVCOMPOPOVECTOR& vCrvCompoRes) ;

EGkChainCurves.h

@@ -16,6 +16,7 @@
 
 #include "/EgtDev/Include/EGkPointGrid3d.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
+#include <unordered_set>
 
 class IGeomDB ;
 
@@ -58,6 +59,7 @@ class ChainCurves
       EGK_EXPORT bool GetForkIds( INTVECTOR& vForkIds) ;
 
    private :
+      typedef std::unordered_set<int> INTUSET ;
       struct CrvData {
          int nId ;
          Point3d  ptStart ;
@@ -90,7 +92,7 @@ class ChainCurves
    private :
       bool           m_bAllowInvert ;
       double         m_dToler ;
-      INTUNORDSET    m_sCrvId ;
+      INTUSET        m_sCrvId ;
       CRVDATAVECTOR  m_vCrvData ;
       PointGrid3d    m_PointGrid ;
       bool           m_bFromNear ;

EGkColor.h

@@ -108,7 +108,6 @@ 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) ;

EGkCurve.h

@@ -31,7 +31,6 @@ class __declspec( novtable) ICurve : public IGeoObj
                     PP_END = 3} ;      // punto coincidente con la fine
       enum ApprLineType { APL_STD = 0,              // approssimazione standard
                           APL_SPECIAL = 10,         // come STD, per composite conserva estremi di curve componenti
-                          APL_SPECIAL_INT = 20,     // come SPECIAL, per composite anche almeno un interno di componenti non rettilinei
                           APL_LEFT = 1,             // linee sempre a sinistra
                           APL_LEFT_CONVEX = 11,     // linee sempre a sinistra convesse
                           APL_RIGHT = 2,            // linee sempre a destra

EGkCurveAux.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : EGkCurveAux.h         Data : 28.01.24          Versione : 2.6a2
+// File : EGkCurveAux.h         Data : 23.05.14          Versione : 1.5e9
 // Contenuto : Dichiarazione funzioni ausiliarie per ICurve.
 //
 //
@@ -32,18 +32,14 @@ struct CNurbsData
    bool      bRat ;           // flag di curva razionale (pesi non tutti unitari)
    bool      bPeriodic ;      // flag per segnalare vettore dei nodi periodico
    bool      bClosed ;        // flag di curva chiusa
-   bool      bClamped ;       // flag di curva clamped
    bool      bExtraKnotes ;   // flag per segnalare presenza di nodi extra all'inizio e fine (totale 2)
    DBLVECTOR vU ;             // vettore dei nodi
    PNTVECTOR vCP ;            // vettore dei punti di controllo
    DBLVECTOR vW ;             // vettore dei pesi
 
-   CNurbsData( void) : nDeg( 0), bRat( false), bPeriodic( false), bClosed( false), bClamped( true), bExtraKnotes(false) {}
+   CNurbsData( void) : nDeg( 0), bRat( false), bPeriodic( false), bClosed( false), bExtraKnotes( false) {}
 } ;
 
-// N.B. : in caso la curva sia razionale i punti di controllo sono in forma NON OMOGENEA [ x, y, z, w]  ( dove la forma OMOGENEA è [ w*x, w*y, w*z, w])
-// tutte le operazioni richiedono la forma OMOGENEA, finite le quali posso riportarmi alla forma NON OMOGENEA
-
 //----------------------------------------------------------------------------
 //! Trasforma un arco in una nuova curva di Bezier semplice o composta
 EGK_EXPORT ICurve* ArcToBezierCurve( const ICurve* pArc) ;
@@ -78,23 +74,3 @@ EGK_EXPORT ICurve* ProjectCurveOnPlane( const ICurve& crCrv, const Plane3d& plPl
 //----------------------------------------------------------------------------
 //! Uniforma la pendenza di una composita tra quota iniziale e finale assegnate
 EGK_EXPORT bool AdjustCurveSlope( ICurveComposite* pCrv, double dNini, double dNfin) ;
-
-//----------------------------------------------------------------------------
-//! Calcolo del diagramma di Voronoi della curva, nei TempParam dei risultati la distanza
-//! Per nBound tenere valore di default. 
-EGK_EXPORT bool CalcCurveVoronoiDiagram( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nBound = 3) ;
-
-//----------------------------------------------------------------------------
-//! Calcolo del Medial Axis della curva (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) ;
-
-//----------------------------------------------------------------------------
-//! Calcola l'offset completo di una curva
-EGK_EXPORT bool CalcCurveFatCurve( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dRadius, bool bSquareEnds, bool bSquareMids) ;
-
-//----------------------------------------------------------------------------
-//! Resetta l'oggetto voronoi associato alla curva liberandone la memoria
-EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;

EGkCurveByApprox.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2023
+//  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : EGkCurveByApprox.h      Data : 28.07.23       Versione : 2.5g3
+// File : EGkCurveByApprox.h      Data : 23.07.15       Versione : 1.6g7
 // Contenuto : Dichiarazione della classe CurveByApprox.
 //
 //
 //
 // Modifiche : 23.07.15 DS Creazione modulo.
-//             28.07.23 DS GetArcs e GetArcsCorner.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -35,11 +35,10 @@ class CurveByApprox
       EGK_EXPORT bool Reset( void) ;
       EGK_EXPORT bool AddPoint( const Point3d& ptP) ;
       EGK_EXPORT ICurve* GetCurve( int nType, double dLinTol, double dAngTolDeg, double dLinFea) ;
-      EGK_EXPORT bool GetArcs( double dLinTol, double dAngTolDeg, PolyArc& PA) ;
-      EGK_EXPORT bool GetArcsCorner( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) ;
+      EGK_EXPORT bool GetArcs( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) ;
 
    public :
-      enum TYPE { ARCS = 0, ARCS_CORNER = 1, CUBIC_BEZIERS = 2} ;
+      enum TYPE { ARCS_CORNER = 1, CUBIC_BEZIERS = 2} ;
 
    private :
       bool CalcParameterization( void) ;

EGkCurveComposite.h

@@ -41,7 +41,7 @@ class __declspec( novtable) ICurveComposite : public ICurve
       virtual const ICurve* GetLastCurve( void) const = 0 ;
       virtual const ICurve* GetPrevCurve( void) const = 0 ;
       virtual bool IsParamAtJoint( double dU) const = 0 ;
-      virtual ICurve* RemoveFirstOrLastCurve( bool bLast = true) = 0 ;
+      virtual ICurve* RemoveFirstOrLastCurve(  bool bLast = true) = 0 ;
       virtual bool ChangeStartPoint( double dU) = 0 ;
       virtual bool AddPoint( const Point3d& ptStart) = 0 ;
       virtual bool AddLine( const Point3d& ptNew, bool bEndOrStart = true) = 0 ;
@@ -58,7 +58,6 @@ class __declspec( novtable) ICurveComposite : public ICurve
       virtual bool ArcsBezierCurvesToArcsPerpExtr( double dLinTol, double dAngTolDeg) = 0 ;
       virtual bool StraightArcsToLines( double dLinTol, double dAngTolDeg) = 0 ;
       virtual bool MergeCurves( double dLinTol, double dAngTolDeg, bool bStartEnd = true, bool bNeedSameProp = false) = 0 ;
-      virtual bool RemoveSmallParts( double dLinTol, double dAngTolDeg) = 0 ;
       virtual bool RemoveSmallDefects( double dLinTol, double dAngTolDeg, bool bAlsoSpikes = false) = 0 ;
       virtual bool RemoveUndercutOnY( double dLinTol, double dAngTolDeg) = 0 ;
       virtual bool IsAPoint( void) const = 0 ;
@@ -68,10 +67,6 @@ class __declspec( novtable) ICurveComposite : public ICurve
       virtual bool IsATrapezoid( double dLinTol, Point3d& ptP, Vector3d& vtB1, Vector3d& vtL1, Vector3d& vtB2) const = 0 ;
       virtual bool SetCurveTempProp( int nCrv, int nProp, int nPropInd = 0) = 0 ;
       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 ;
 } ;
 
 //-----------------------------------------------------------------------------
@@ -89,31 +84,6 @@ inline ICurveComposite* GetCurveComposite( IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_COMPO)
                     return nullptr ;
                  return (static_cast<ICurveComposite*>(pGObj)) ; }
-inline ICurveComposite* ConvertCurveToComposite( IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  ( pGObj->GetType() & GEO_CURVE) == 0) {
-                    delete pGObj ;
-                    return nullptr ;
-                 }
-                 ICurveComposite* pCrvCo = CreateCurveComposite() ;
-                 if ( pCrvCo == nullptr) {
-                    delete pGObj ;
-                    return nullptr ;
-                 }
-                 ICurve* pCrv = static_cast<ICurve*>( pGObj) ;
-                 Vector3d vtExtr ;
-                 if ( pCrv->GetExtrusion( vtExtr)  &&  ! vtExtr.IsSmall())
-                    pCrvCo->SetExtrusion( vtExtr) ;
-                 double dThick ;
-                 if ( pCrv->GetThickness( dThick)  &&  abs( dThick) > EPS_SMALL)
-                    pCrvCo->SetThickness( dThick) ;
-                 for ( int i = 0 ; i < 2 ; ++ i) {
-                    int nProp = pCrv->GetTempProp( i) ;
-                    if ( nProp != 0)
-                       pCrvCo->SetTempProp( nProp, i) ;
-                 }
-                 pCrvCo->AddCurve( pCrv) ;
-                 return pCrvCo ;
-               }
 
 //----------------------------------------------------------------------------
 // Raccolte di puntatori a ICurveComposite

EGkCurveLine.h

@@ -45,10 +45,3 @@ inline ICurveLine* GetCurveLine( IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_LINE)
                    return nullptr ;
                  return (static_cast<ICurveLine*>(pGObj)) ; }
-
-//----------------------------------------------------------------------------
-// Raccolte di puntatori a ICurveLine
-typedef std::vector<const ICurveLine*>    CICRVLINEVECTOR ;    // vettore di puntatori a const ICurveLine
-typedef std::vector<ICurveLine*>          ICRVLINEPVECTOR ;    // vettore di puntatori a ICurveLine
-typedef std::list<ICurveLine*>            ICRVLINEPLIST ;      // lista di puntatori a ICurveLine
-typedef std::vector<PtrOwner<ICurveLine>> ICRVLINEPOVECTOR ;   // vettore di puntatori esclusivi a ICurveLine

EGkDistPointCurve.h

@@ -49,23 +49,22 @@ class DistPointCurve
       // Il flag bIsSegment vale solo per linee.
 
    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 (int) m_Info.size() ; }
-      EGK_EXPORT bool GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const ;
-      EGK_EXPORT bool GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFlag) const ;
-      EGK_EXPORT bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const ;
-      EGK_EXPORT bool GetParamAtMinDistPoint( double dNearParam, double& dParam, int& nFlag) const ;
-      EGK_EXPORT bool GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide) const ;
-      EGK_EXPORT bool GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide) const ;
-      EGK_EXPORT bool GetMinDistInfo( int nInd, MinDistPCInfo& aInfo) const ;
+      EGK_EXPORT bool GetSqDist( double& dSqDist) ;
+      EGK_EXPORT bool GetDist( double& dDist) ;
+      EGK_EXPORT bool IsEpsilon( double dTol)
+                        { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
+      EGK_EXPORT bool IsSmall( void)
+                        { return IsEpsilon( EPS_SMALL) ; }
+      EGK_EXPORT bool IsZero( void)
+                        { return IsEpsilon( EPS_ZERO) ; }
+      EGK_EXPORT int  GetNbrMinDist( void) { return (int) m_Info.size() ; }
+      EGK_EXPORT bool GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) ;
+      EGK_EXPORT bool GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFlag) ;
+      EGK_EXPORT bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) ;
+      EGK_EXPORT bool GetParamAtMinDistPoint( double dNearParam, double& dParam, int& nFlag) ;
+      EGK_EXPORT bool GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide) ;
+      EGK_EXPORT bool GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide) ;
+      EGK_EXPORT bool GetMinDistInfo( int nInd, MinDistPCInfo& aInfo) ;
 
    private :
       DistPointCurve( void) ;

EGkDistPointSurfTm.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2018-2023
+//  EgalTech 2018-2018
 //----------------------------------------------------------------------------
-// File : EGkDistPointSurfTm.h     Data : 06.07.23        Versione : 2.5g1
+// File : EGkDistPointTria.h     Data : 11.12.18        Versione : 1.9l2
 // Contenuto : Dichiarazione della classe distanza Punto da Trimesh.
 //
 //
 //
 // Modifiche : 06.12.18 LM Creazione modulo.
-//             06.07.23 DS Aggiunta GetSurfTmNearestVertex.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -23,13 +23,6 @@
    #define EGK_EXPORT __declspec( dllimport)
 #endif
 
-//----------------------------------------------------------------------------
-// Calcola la distanza tra punto e superficie trimesh.
-// Risultati :
-// - 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.
 //----------------------------------------------------------------------------
 class DistPointSurfTm
 {
@@ -37,16 +30,16 @@ class DistPointSurfTm
       EGK_EXPORT DistPointSurfTm( const Point3d& ptP, const ISurfTriMesh& tmSurf) ;
 
    public :
-      EGK_EXPORT bool GetDist( double& dDist) const ;
-      EGK_EXPORT bool IsEpsilon( double dTol) const
+      EGK_EXPORT bool GetDist( double& dDist) ;
+      EGK_EXPORT bool IsEpsilon( double dTol)
                        { return ( m_dDist >= 0.  &&  ( m_dDist < EPS_ZERO || m_dDist < dTol)) ; }
-      EGK_EXPORT bool IsSmall( void) const
+      EGK_EXPORT bool IsSmall( void)
                        { return IsEpsilon( EPS_SMALL) ; }
-      EGK_EXPORT bool IsZero( void) const
+      EGK_EXPORT bool IsZero( void)
                        { return IsEpsilon( EPS_ZERO) ; }
-      EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDistPoint) const ;
-      EGK_EXPORT bool GetMinDistTriaIndex( int& nMinDistTriaIndex) const ;
-      EGK_EXPORT bool IsPointInside( void) const
+      EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDistPoint) ;
+      EGK_EXPORT bool GetMinDistTriaIndex( int& nMinDistTriaIndex) ;
+      EGK_EXPORT bool IsPointInside( void)
                         { return m_bIsInside ; }
 
    private :
@@ -58,8 +51,3 @@ class DistPointSurfTm
       int     m_nMinDistTriaIndex ;
       bool    m_bIsInside ;
 } ;
-
-//----------------------------------------------------------------------------
-// Calcola l'indice del vertice della superficie a minima distanza dal punto di riferimento.
-//----------------------------------------------------------------------------
-EGK_EXPORT int GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf) ;

EGkDllMain.h

@@ -47,4 +47,4 @@ EGK_EXPORT const std::string& GetNfeFontDir( void) ;
 // restituisce il nome del font di default
 EGK_EXPORT const std::string& GetDefaultFont( void) ;
 // imposto il gestore eventi
-EGK_EXPORT bool SetEGkProcessEvents( pfProcEvents pFun) ;
+EGK_EXPORT bool SetEGkProcessEvents( pfProcEvents pFun) ;

EGkExtDimension.h

@@ -36,11 +36,8 @@ 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& 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 bool SetAngular( const Point3d& ptP1, const Point3d& ptV, 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 ;
@@ -58,7 +55,6 @@ 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

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2023
+//  EgalTech 2013-2014
 //----------------------------------------------------------------------------
-// File : EGkFrame3d.h             Data : 20.07.23          Versione : 2.5g2
+// File : EGkFrame3d.h             Data : 30.05.14          Versione : 1.5e10
 // Contenuto : Dichiarazione della classe Reference Frame 3d.
 //
 //
@@ -56,23 +56,23 @@ class EGK_EXPORT Frame3d
       bool ToLoc( const Frame3d& frRef) ;
       bool LocToLoc( const Frame3d& frOri, const Frame3d& frDest) ;
       Frame3d& operator*=( const Frame3d& frRef)
-               { ToGlob( frRef) ; return *this ; }
+               { this->ToGlob( frRef) ; return *this ;}
       Frame3d& operator/=( const Frame3d& frRef)
-               { ToLoc( frRef) ; return *this ; }
+               { this->ToLoc( frRef) ; return *this ;}
       bool IsValid( void) const
                { return ( m_nType != ERR) ; }
       int GetType( void) const
-               { return m_nType ; }
+               { return m_nType ;}
       int GetZType( void) const
-               { return m_nZType ; }
+               { return m_nZType ;}
       const Point3d& Orig( void) const
-               { return m_ptOrig ; }
+               { return m_ptOrig ;}
       const Vector3d& VersX( void) const
-               { return m_vtVersX ; }
+               { return m_vtVersX ;}
       const Vector3d& VersY( void) const
-               { return m_vtVersY ; }
+               { return m_vtVersY ;}
       const Vector3d& VersZ( void) const
-               { return m_vtVersZ ; }
+               { return m_vtVersZ ;}
       bool GetRotationsCAC1( double& dAngC, double& dAngA, double& dAngC1) const ;
       bool GetFixedAxesRotationsABC( double& dAngADeg, double& dAngBDeg, double& dAngCDeg) const ;
 
@@ -97,56 +97,23 @@ const Frame3d GLOB_FRM ;
 //----------------------------------------------------------------------------
 // Prodotto di due frame (porta il primo dal secondo nel globale)
 //----------------------------------------------------------------------------
-inline const Frame3d 
-operator*( const Frame3d& frRef, const Frame3d& frOri)
+inline Frame3d 
+operator*( const Frame3d& frRef1, const Frame3d& frRef2)
 {
-   Frame3d frNew = frRef ;
-   frNew.ToGlob( frOri) ;
-   return frNew ;
+   Frame3d frRefR = frRef1 ;
+   frRefR.ToGlob( frRef2) ;
+   return frRefR ;
 }
 
 //----------------------------------------------------------------------------
 // Divisione di due frame (porta il primo dal globale nel secondo)
 //----------------------------------------------------------------------------
-inline const Frame3d 
-operator/( const Frame3d& frRef, const Frame3d& frDest)
+inline Frame3d 
+operator/( const Frame3d& frRef1, const Frame3d& frRef2)
 {
-   Frame3d frNew = frRef ;
-   frNew.ToLoc( frDest) ;
-   return frNew ;
-}
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia in locale del frame passato
-//----------------------------------------------------------------------------
-inline const Frame3d 
-GetToLoc ( const Frame3d& frRef, const Frame3d& frDest)
-{
-   Frame3d frNew = frRef ;
-   frNew.ToLoc( frDest) ;
-   return frNew ;
-}
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia in globale del frame passato
-//----------------------------------------------------------------------------
-inline const Frame3d 
-GetToGlob( const Frame3d& frRef, const Frame3d& frOri)
-{
-   Frame3d frNew = frRef ;
-   frNew.ToGlob( frOri) ;
-   return frNew ;
-}
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia dal primo al secondo riferimento del frame passato
-//----------------------------------------------------------------------------
-inline const Frame3d
-GetLocToLoc( const Frame3d& frRef, const Frame3d& frOri, const Frame3d& frDest)
-{
-   Frame3d frNew = frRef ;
-   frNew.LocToLoc( frOri, frDest) ;
-   return frNew ;
+   Frame3d frRefR = frRef1 ;
+   frRefR.ToLoc( frRef2) ;
+   return frRefR ;
 }
 
 //----------------------------------------------------------------------------
@@ -167,12 +134,3 @@ AreSameFrame( const Frame3d& frRef1, const Frame3d& frRef2)
       return false ;
    return true ;
 }
-
-//----------------------------------------------------------------------------
-// Verifica se il riferimento coincide con quello globale (o identità)
-//----------------------------------------------------------------------------
-inline bool
-IsGlobFrame( const Frame3d& frRef)
-{
-   return AreSameFrame( frRef, GLOB_FRM) ;
-}

EGkGdbConst.h

@@ -88,4 +88,3 @@ 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

EGkGdbIterator.h

@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2013-2023
 //----------------------------------------------------------------------------
-// File : EGkGdbIterator.h        Data : 09.07.23          Versione : 2.5g1
+// File : EGkGdbIterator.h        Data : 29.01.23          Versione : 2.5a2
 // Contenuto : Dichiarazione della interfaccia IGdbIterator.
 //
 //
 //
 // Modifiche : 04.12.13 DS Creazione modulo.
 //             29.01.23 DS Aggiunte GetAllInfo e CopyAllInfoFrom.
-//             09.07.23 DS Aggiunte SetStipple e GetStipple.
 //
 //----------------------------------------------------------------------------
 
@@ -145,9 +144,6 @@ class __declspec( novtable) IGdbIterator
       virtual bool RemoveInfo( const std::string& sKey) = 0 ;
       virtual bool GetAllInfo( STRVECTOR& vsInfo) const = 0 ;
       virtual bool CopyAllInfoFrom( const IGdbIterator& iIter) = 0 ;
-     // Stipple
-      virtual bool SetStipple( int nFactor, int nPattern) = 0 ;
-      virtual bool GetStipple( int& nFactor, int& nPattern) const = 0 ;
      // TextureData
       virtual bool SetTextureName( const std::string& sTxrName) = 0 ;
       virtual bool SetTextureFrame( const Frame3d& frTxrRef) = 0 ;

EGkGeoCollection.h

@@ -15,7 +15,6 @@
 
 #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"
 
@@ -33,15 +32,15 @@ typedef std::list<POINTI>      PNTILIST ;    // lista di coppie punto, intero
 
 //----------------------------------------------------------------------------
 // Raccolte di coppie Point3d,dU
-typedef std::pair<Point3d,double> POINTU ;       // coppia punto, parametro (o altro)
-typedef std::vector<POINTU>       PNTUVECTOR ;   // vettore di coppie punto, parametro
-typedef std::list<POINTU>         PNTULIST ;     // lista di coppie punto, parametro
+typedef std::pair<Point3d,double> POINTU ;  // coppia punto, parametro (o altro)
+typedef std::vector<POINTU>  PNTUVECTOR ;   // vettore di coppie punto, parametro
+typedef std::list<POINTU>    PNTULIST ;     // lista di coppie punto, parametro
 
 //----------------------------------------------------------------------------
 // Raccolte di coppie Point3d,Point3d
-typedef std::pair<Point3d,Point3d> BIPOINT ;      // coppia punto1, punto2
-typedef std::vector<BIPOINT>       BIPNTVECTOR ;  // vettore di coppie punto1, punto2
-typedef std::list<BIPOINT>         BIPNTLIST ;    // lista di coppie punto1, punto2
+typedef std::pair<Point3d,Point3d> BIPOINT ;  // coppia punto1, punto2
+typedef std::vector<BIPOINT>   BIPNTVECTOR ;  // vettore di coppie punto1, punto2
+typedef std::list<BIPOINT>     BIPNTLIST ;    // lista di coppie punto1, punto2
 
 //----------------------------------------------------------------------------
 // Raccolte di Punti di curva con loro geometria differenziale
@@ -53,20 +52,8 @@ 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
 typedef std::list<BBox3d>    BOXLIST ;                     // lista di bounding box 3d
 typedef std::vector<std::pair<BBox3d,int>>  BOXIVECTOR ;   // vettore di bounding box 3d e Id
-
-//----------------------------------------------------------------------------
-// Raccolte di coppie Point3d,Vector3d
-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

EGkGeoObj.h

@@ -56,8 +56,6 @@ class __declspec( novtable) IGeoObj
       virtual const IObjGraphics* GetObjGraphics( void) const = 0 ;
       virtual void SetTempProp( int nProp, int nPropInd = 0) = 0 ;
       virtual int  GetTempProp( int nPropInd = 0) const = 0 ;
-      virtual void SetTempParam( double dParam, int nParamInd = 0) = 0 ;
-      virtual double GetTempParam( int nParamInd = 0) const = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkGeoObjSave.h

@@ -39,40 +39,5 @@ SaveGeoObj( IGeoObj* pGObj, const std::string& sFile, int nFlag = GDB_SV_BIN)
   // rimuovo l'oggetto dal GeomDB
    bOk = ( pGeomDB->RemoveGeoObjAndErase( nId) != nullptr) && bOk ;
 
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-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
-      if ( vpGObj[i] == nullptr  ||  ! vpGObj[i]->IsValid() )
-         return false ;
-   }
-  // creo GeomDB temporaneo
-   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
-   if ( IsNull( pGeomDB))
-      return false ;
-   INTVECTOR vIds ;
-   int nLayId = 0 ;
-   for ( int i = 0 ; i < int( vpGObj.size()); ++i) {
-     // inserisco l'oggetto nel GeomDB (sotto pezzo/layer)
-      if ( i == 0) {
-         int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-         nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-      }
-      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vpGObj[i]) ;
-      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 ;
 }

EGkGeomDB.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2013-2023
 //----------------------------------------------------------------------------
-// File : EGkGeomDB.h           Data : 09.07.23          Versione : 2.5g1
+// File : EGkGeomDB.h           Data : 29.01.23          Versione : 2.5a
 // Contenuto : Dichiarazione della interfaccia IGeomDB.
 //
 //
@@ -12,7 +12,6 @@
 //             30.05.14 DS Agg. metodi di Shear.
 //             03.12.14 DS Aggiunta gestione riferimento di griglia.
 //             29.01.23 DS Aggiunta GetAllInfo.
-//             09.07.23 DS Aggiunte DumpStipple, SetStipple e GetStipple.
 //
 //----------------------------------------------------------------------------
 
@@ -180,10 +179,6 @@ class __declspec( novtable) IGeomDB
       virtual bool RemoveInfo( int nId, const std::string& sKey) = 0 ;
       virtual bool GetAllInfo( int nId, STRVECTOR& vsInfo) const = 0 ;
       virtual bool CopyAllInfoFrom( int nId, int nSouId) = 0 ;
-     // Stipple (significativo solo per curve)
-      virtual bool DumpStipple( int nId, std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const = 0 ;
-      virtual bool SetStipple( int nId, int nFactor, int nPattern) = 0 ;
-      virtual bool GetStipple( int nId, int& nFactor, int& nPattern) const = 0 ;
      // TextureData
       virtual bool DumpTextureData( int nId, std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const = 0 ;
       virtual bool SetTextureName( int nId, const std::string& sTxrName) = 0 ;

EGkIntersCurveSurfTm.h

@@ -1,63 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EGkIntersCurveSurfTm.h      Data : 23.02.24        Versione : 2.6b4
-// Contenuto : Dichiarazione della classe intersezione Curva/SurfTriMesh.
-//
-//
-//
-// Modifiche : 23.02.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkSurfTriMesh.h"
-#include "/EgtDev/Include/EGkIntersLineTria.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 curva - superficie trimesh
-struct IntCrvStmInfo {
-   int     nILTT ;          //!< tipo di intersezione curva-triangolo
-   double  dU ;             //!< parametro sulla curva (non distanza)
-   double  dU2 ;            //!< secondo parametro sulla curva (non distanza)
-   int     nT ;             //!< indice del triangolo della superficie trimesh
-   double  dCosDN ;         //!< coseno dell'angolo tra la direzione della curva e la normale del triangolo
-   Point3d ptI ;            //!< punto di intersezione
-   Point3d ptI2 ;           //!< secondo punto di intersezione (termine di tratto sovrapposto)
-  // costruttori
-   IntCrvStmInfo( void) : nILTT( ILTT_NO), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2() {}
-   IntCrvStmInfo( int nIL, double dUU, int nTT, double dCos, const Point3d& ptP)
-      : nILTT( nIL), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2() {}
-   IntCrvStmInfo( int nIL, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2)
-      : nILTT( nIL), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2) {}
-} ;
-//! vettore di IntCrvStmInfo
-typedef std::vector<IntCrvStmInfo>  ICSIVECTOR ;
-
-//-----------------------------------------------------------------------------
-// Costanti tipo intersezione filtrata Curva-Superficie
-enum CSiType { CSIT_NONE =  0,
-               CSIT_OUT_IN =  1,
-               CSIT_IN_OUT = 2,
-               CSIT_IN_IN = 3,
-               CSIT_OUT_OUT = 4,
-               CSIT_IN_ON = 5,
-               CSIT_ON_IN = 6,
-               CSIT_OUT_ON = 7,
-               CSIT_ON_OUT = 8} ;
-
-//-----------------------------------------------------------------------------
-EGK_EXPORT bool IntersCurveSurfTm( const ICurve& Curve, const ISurfTriMesh& Stm, double dLinTol, ICSIVECTOR& vInfo) ;
-EGK_EXPORT bool IntersCurveSurfTmExt( const ICurve& Curve, const ISurfTriMesh& Stm, double dLinTol, INTDBLVECTOR& vInters) ;
-EGK_EXPORT bool FilterCurveSurfTmInters( const ICurve& Curve, const ICSIVECTOR& vInfo, INTDBLVECTOR& vInters) ;

EGkIntersLineSurfBez.h

@@ -1,79 +0,0 @@
-//----------------------------------------------------------------------------
-//  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) ;

EGkIntersLineSurfTm.h

@@ -29,14 +29,14 @@
 //! dati di intersezione linea - superficie trimesh
 struct IntLinStmInfo {
    int     nILTT ;          //!< tipo di intersezione linea-triangolo
-   double  dU ;             //!< distanza sulla linea
-   double  dU2 ;            //!< seconda distanza sulla linea
+   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)
   // costruttori
-   IntLinStmInfo( void) : nILTT( ILTT_NO), dU( 0), dU2( 0), nT( 0), dCosDN( 0), ptI(), ptI2() {}
+   IntLinStmInfo( void) : nILTT( ILTT_NO), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2() {}
    IntLinStmInfo( int nIL, double dUU, int nTT, double dCos, const Point3d& ptP)
       : nILTT( nIL), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2() {}
    IntLinStmInfo( int nIL, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2)
@@ -45,15 +45,6 @@ struct IntLinStmInfo {
 //! vettore di IntLinStmInfo
 typedef std::vector<IntLinStmInfo>  ILSIVECTOR ;
 
-//-----------------------------------------------------------------------------
-// Costanti tipo intersezione Linea SurfTriMesh dopo filtraggio
-enum LSiType { LST_NONE =  0,
-               LST_IN =  1,
-               LST_OUT = 2,
-               LST_TG_INI = 3,
-               LST_TG_FIN = 4,
-               LST_TOUCH = 5} ;
-
 //-----------------------------------------------------------------------------
 EGK_EXPORT bool IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfTriMesh& Stm,
                                   ILSIVECTOR& vInfo, bool bFinite = true) ;
@@ -71,6 +62,3 @@ class IntersParLinesSurfTm
       const ISurfTriMesh* m_pSTm ;
       HashGrids2d         m_HGrids ;
 } ;
-
-//-----------------------------------------------------------------------------
-EGK_EXPORT bool FilterLineSurfTmInters( const ILSIVECTOR& vInfo, INTDBLVECTOR& vInters) ;

EGkIntersLineTria.h

@@ -23,6 +23,12 @@
    #define EGK_EXPORT __declspec( dllimport)
 #endif
 
+//-----------------------------------------------------------------------------
+EGK_EXPORT int IntersLineTria( const Point3d& ptL1, const Point3d& ptL2, const Triangle3d& trTria,
+                               Point3d& ptInt, Point3d& ptInt2, bool bFinite = true) ;
+EGK_EXPORT int IntersLineTria( const Point3d& ptL, const Vector3d& vtL, double dLen, const Triangle3d& trTria,
+                               Point3d& ptInt, Point3d& ptInt2, bool bFinite = true) ;
+
 //-----------------------------------------------------------------------------
 // Tipo di intersezione linea-triangolo
 enum IntLineTriaType { ILTT_NO = 0,            // non c'è intersezione
@@ -31,9 +37,3 @@ enum IntLineTriaType { ILTT_NO = 0,            // non c'
                        ILTT_VERT = 3,          // intersezione coincide con un vertice
                        ILTT_EDGE = 4,          // intersezione coincide con interno di un lato
                        ILTT_IN = 5} ;          // intersezione in interno del triangolo
-
-//-----------------------------------------------------------------------------
-EGK_EXPORT int IntersLineTria( const Point3d& ptL1, const Point3d& ptL2, const Triangle3d& trTria,
-                               Point3d& ptInt, Point3d& ptInt2, bool bFinite = true) ;
-EGK_EXPORT int IntersLineTria( const Point3d& ptL, const Vector3d& vtL, double dLen, const Triangle3d& trTria,
-                               Point3d& ptInt, Point3d& ptInt2, bool bFinite = true) ;

EGkIntersLineVolZmap.h

@@ -1,62 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EGkIntersLineVolZmap.h      Data : 22.02.24     Versione : 2.6b4
-// Contenuto : Dichiarazione prototipi intersezione Linea/VolZmap.
-//
-//
-//
-// Modifiche : 22.02.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkVolZmap.h"
-#include "/EgtDev/Include/EGkIntersLineTria.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 - volume Zmap
-struct IntLineZmapInfo {
-   int        nILTT ;       // Tipo di intersezione linea-triangolo
-   double     dU ;          // Distanza sulla linea
-   double     dU2 ;         // Seconda distanza sulla linea
-   int        nVox ;        // Indice del voxel del triangolo 
-   int        nBlock ;      // Indice del blocco del triangolo
-   Triangle3d trTria ;      // Triangolo 
-   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)
-  // Costruttori
-   IntLineZmapInfo( void)
-          : nILTT( ILTT_NO), dU( 0), dU2( 0), nVox( -1), nBlock( -1), trTria(), dCosDN( 0), ptI(), ptI2() {}
-   IntLineZmapInfo( int nIL, double dUU, int nVx, int nBl, Triangle3d& trTr, double dCos, const Point3d& ptP)
-          : nILTT( nIL), dU( dUU), dU2( 0), nVox( nVx), nBlock( nBl), dCosDN( dCos), trTria( trTr), ptI( ptP), ptI2() {}
-   IntLineZmapInfo( int nIL, double dUU, double dUU2, int nVx, int nBl, Triangle3d& trTr, double dCos,
-                    const Point3d& ptP, const Point3d& ptP2)
-          : nILTT( nIL), dU( dUU), dU2( dUU2), nVox( nVx), nBlock( nBl), trTria( trTr), dCosDN( dCos), ptI( ptP), ptI2( ptP2) {}
-} ;
-// Vettore di IntLineZmapInfo
-typedef std::vector<IntLineZmapInfo>    ILZIVECTOR ;
-
-//-----------------------------------------------------------------------------
-// Costanti tipo intersezione Linea VolZmap dopo filtraggio
-enum LZiType { LZT_NONE =  0,
-               LZT_IN =  1,
-               LZT_OUT = 2,
-               LZT_TG_INI = 3,
-               LZT_TG_FIN = 4,
-               LZT_TOUCH = 5} ;
-
-//-----------------------------------------------------------------------------
-EGK_EXPORT bool IntersLineVolZmap( const Point3d& ptL, const Vector3d& vtL, const IVolZmap& Vzm, ILZIVECTOR& vInfo) ;
-EGK_EXPORT bool FilterLineVolZmapInters( const ILZIVECTOR& vInfo, INTDBLVECTOR& vInters) ;

EGkIntersPlaneSurfTm.h

@@ -32,13 +32,13 @@ EGK_EXPORT bool IntersPlaneSurfTm( const Plane3d& plPlane, const ISurfTriMesh& S
 //-----------------------------------------------------------------------------
 class IntersParPlanesSurfTm
 {
-   public :
-      EGK_EXPORT IntersParPlanesSurfTm( const Frame3d& frPlanes, const ISurfTriMesh& Stm) ;
-      EGK_EXPORT bool GetInters( double dDist, PNTVECTOR& vPnt, BIPNTVECTOR& vBpt, TRIA3DVECTOR& vTria) const ;
+public :
+   EGK_EXPORT IntersParPlanesSurfTm( const Frame3d& frPlanes, const ISurfTriMesh& Stm) ;
+   EGK_EXPORT bool GetInters( double dDist, PNTVECTOR& vPnt, BIPNTVECTOR& vBpt, TRIA3DVECTOR& vTria) const ;
 
-   private :
-      bool                m_bOk ;
-      const Frame3d       m_frPlanes ;
-      const ISurfTriMesh* m_pSTm ;
-      HashGrids1d         m_HGrids ;
+private :
+   bool                m_bOk ;
+   const Frame3d       m_frPlanes ;
+   const ISurfTriMesh* m_pSTm ;
+   HashGrids1d         m_HGrids ;
 } ;

EGkIntersPlaneVolZmap.h

@@ -1,27 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EGkIntersPlaneVolZmap.h      Data : 22.02.24     Versione : 2.6b4
-// Contenuto : Dichiarazione prototipi intersezione Piano/VolZmap.
-//
-//
-//
-// Modifiche : 22.02.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkVolZmap.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 IntersPlaneVolZmap( const Plane3d& plPlane, const IVolZmap& Vzm, ICURVEPOVECTOR& vpLoop) ;

EGkLuaAux.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : EGkLuaAux.h       Data : 14.04.24        Versione : 2.6d4
+// File : EGkLuaAux.h       Data : 21.03.15        Versione : 1.6c6
 // Contenuto : Funzioni per gestione parametri geometrici con LUA.
 //
 //
 //
 // Modifiche : 21.03.15 DS Creazione modulo.
-//             14.04.24 DS Aggiunta gestione Quaternion.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -17,7 +17,6 @@
 #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"
@@ -26,16 +25,12 @@
 //----------------------------------------------------------------------------
 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
@@ -119,13 +114,6 @@ 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)
@@ -381,23 +369,6 @@ 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

@@ -26,8 +26,6 @@
 class OffsetCurve
 {
    public :
-      EGK_EXPORT OffsetCurve(): m_dLinTol( 10 * EPS_SMALL) {} ;
-      EGK_EXPORT OffsetCurve( double dLinTol) : m_dLinTol( dLinTol) {} ;
       EGK_EXPORT ~OffsetCurve( void) ;
 
    public :
@@ -37,10 +35,7 @@ class OffsetCurve
       EGK_EXPORT ICurve* GetCurve( void) ;
       EGK_EXPORT ICurve* GetLongerCurve( void) ;
       EGK_EXPORT ICurve* GetShorterCurve( void) ;
-      EGK_EXPORT double GetLinTol( void) const { return m_dLinTol ; }
-      EGK_EXPORT void SetLinTol( double dTol) { m_dLinTol = dTol ; }
 
    private :
       ICURVEPLIST m_CrvLst ;
-      double m_dLinTol ;
 } ;

EGkPlane3d.h

@@ -38,16 +38,6 @@ class Plane3d
                   m_dDist = ( ptP - ORIG) * m_vtN ;
                   return true ;
                }
-      bool Set( const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptP3)
-               { if ( AreSamePointApprox( ptP1, ptP2)  ||
-                      AreSamePointApprox( ptP2, ptP3)  ||
-                      AreSamePointApprox( ptP3, ptP1)) {
-                    m_vtN = V_NULL ;
-                    return false ;
-                 }
-                 Vector3d vtN = ( ptP2 - ptP1) ^ ( ptP3 - ptP2) ;
-                 return Set( ptP1, vtN) ;
-               }
       void Reset( void)
                { m_vtN = V_NULL ;
                  m_dDist = 0 ;

EGkPoint3d.h

@@ -1,13 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2023
+//  EgalTech 2013-2022
 //----------------------------------------------------------------------------
-// File : EGkPoint3d.h           Data : 23.08.23          Versione : 2.5h2
+// File : EGkPoint3d.h           Data : 22.08.224          Versione : 2.4h2
 // Contenuto : Dichiarazione della classe Punto 3d.
 //
 //
 //
 // Modifiche : 30.12.12 DS Creazione modulo.
-//             23.08.23 DS Aggiunto P_INVALID.
 //
 //
 //----------------------------------------------------------------------------
@@ -43,9 +42,6 @@ class EGK_EXPORT Point3d
       void Set( double dX, double dY, double dZ) { x = dX ; y = dY ; z = dZ ;}
 
    public :
-      //! Verifica la validità delle coordinate del punto
-      bool IsValid( void) const
-             { return ( std::isfinite( x)  &&  std::isfinite( y)  &&  std::isfinite( z)) ; }
       //! Verifica se il punto è quasi l'origine
       bool IsSmall( void) const
              { return ( ( x * x + y * y + z * z) < SQ_EPS_SMALL) ; }
@@ -54,19 +50,19 @@ class EGK_EXPORT Point3d
              { return ( ( x * x + y * y + z * z) < SQ_EPS_ZERO) ; }
       //! Somma sul posto con un vettore
       Point3d& operator +=( const Vector3d& vtV)
-             { x += vtV.x ; y += vtV.y ; z += vtV.z ; return *this ; }
+             { this->x += vtV.x ; this->y += vtV.y ; this->z += vtV.z ; return *this ; }
       //! Sottrazione sul posto con un vettore
       Point3d& operator -=( const Vector3d& vtV)
-             { x -= vtV.x ; y -= vtV.y ; z -= vtV.z ; return *this ; }
+             { this->x -= vtV.x ; this->y -= vtV.y ; this->z -= vtV.z ; return *this ; }
       //! Somma sul posto con un altro punto (valida solo se equivalente ad una combinazione baricentrica)
       Point3d& operator +=( const Point3d& ptP)
-             { x += ptP.x ; y += ptP.y ; z += ptP.z ; return *this ; }
+             { this->x += ptP.x ; this->y += ptP.y ; this->z += ptP.z ; return *this ; }
       //! Moltiplicazione sul posto con un numero
       Point3d& operator *=( double dMul)
-             { x *= dMul ; y *= dMul ; z *= dMul ; return *this ; }
+             { this->x *= dMul ; this->y *= dMul ; this->z *= dMul ; return *this ; }
       //! Divisione sul posto con un numero
       Point3d& operator /=( double dDiv)
-             { double dMul = 1 / dDiv ; x *= dMul ; y *= dMul ; z *= dMul ; return *this ; }
+             { double dMul = 1 / dDiv ; this->x *= dMul ; this->y *= dMul ; this->z *= dMul ; return *this ; }
       //! Traslazione dato il vettore di movimento
       void Translate( const Vector3d& vtMove) ;
       //! Rotazione attorno ad un asse per un punto, dato l'angolo in gradi
@@ -100,15 +96,13 @@ class EGK_EXPORT Point3d
 //----------------------------------------------------------------------------
 // Punti notevoli
 //----------------------------------------------------------------------------
-//! Punto non valido
-const Point3d P_INVALID( NAN, NAN, NAN) ;
 //! Punto origine
 const Point3d ORIG( 0, 0, 0) ;
 
 //----------------------------------------------------------------------------
 //! Somma di due punti (valida solo se equivalente ad una combinazione baricentrica)
 //----------------------------------------------------------------------------
-inline const Point3d 
+inline Point3d 
 operator+( const Point3d& ptP1, const Point3d& ptP2)
 {
    return Point3d( ptP1.x + ptP2.x, ptP1.y + ptP2.y, ptP1.z + ptP2.z) ; 
@@ -117,16 +111,16 @@ operator+( const Point3d& ptP1, const Point3d& ptP2)
 //----------------------------------------------------------------------------
 //! Somma di un punto e un vettore
 //----------------------------------------------------------------------------
-inline const Point3d 
+inline Point3d 
 operator+( const Point3d& ptP1, const Vector3d& vtV2)
 {
    return Point3d( ptP1.x + vtV2.x, ptP1.y + vtV2.y, ptP1.z + vtV2.z) ; 
 }
 
 //----------------------------------------------------------------------------
-//! Opposto di un punto, genera un vettore
+//! Opposto di un punto
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 operator-( const Point3d& ptP)
 {
    return Vector3d( - ptP.x, - ptP.y, - ptP.z) ; 
@@ -135,7 +129,7 @@ operator-( const Point3d& ptP)
 //----------------------------------------------------------------------------
 //! Differenza di due punti, genera un vettore
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 operator-( const Point3d& ptP1, const Point3d& ptP2)
 {
    return Vector3d( ptP1.x - ptP2.x, ptP1.y - ptP2.y, ptP1.z - ptP2.z) ; 
@@ -144,7 +138,7 @@ operator-( const Point3d& ptP1, const Point3d& ptP2)
 //----------------------------------------------------------------------------
 //! Sottrazione di un punto e un vettore
 //----------------------------------------------------------------------------
-inline const Point3d 
+inline Point3d 
 operator-( const Point3d& ptP1, const Vector3d& vtV2)
 {
    return Point3d( ptP1.x - vtV2.x, ptP1.y - vtV2.y, ptP1.z - vtV2.z) ; 
@@ -153,7 +147,7 @@ operator-( const Point3d& ptP1, const Vector3d& vtV2)
 //----------------------------------------------------------------------------
 //! Prodotto con uno scalare
 //----------------------------------------------------------------------------
-inline const Point3d 
+inline Point3d 
 operator*( const Point3d& ptP, double dMul)
 {
    return Point3d( ptP.x * dMul, ptP.y * dMul, ptP.z * dMul) ; 
@@ -162,7 +156,7 @@ operator*( const Point3d& ptP, double dMul)
 //----------------------------------------------------------------------------
 //! Prodotto di uno scalare con un punto
 //----------------------------------------------------------------------------
-inline const Point3d 
+inline Point3d 
 operator*( double dMul, const Point3d& ptP)
 {
    return Point3d( ptP.x * dMul, ptP.y * dMul, ptP.z * dMul) ; 
@@ -171,7 +165,7 @@ operator*( double dMul, const Point3d& ptP)
 //----------------------------------------------------------------------------
 //! Divisione per uno scalare
 //----------------------------------------------------------------------------
-inline const Point3d 
+inline Point3d 
 operator/( const Point3d& ptP, double dDiv)
 {
    double dMul ;
@@ -183,7 +177,7 @@ operator/( const Point3d& ptP, double dDiv)
 //----------------------------------------------------------------------------
 //! Somma mediata di due punti (baricentrica)
 //----------------------------------------------------------------------------
-inline const Point3d 
+inline Point3d 
 Media( const Point3d& ptP1, const Point3d& ptP2, double dCoeff = 0.5)
 {
    return Point3d( ( 1 - dCoeff) * ptP1.x + dCoeff * ptP2.x,
@@ -374,7 +368,7 @@ AreSamePointXYExact( const Point3d& ptP1, const Point3d& ptP2)
 //----------------------------------------------------------------------------
 //! Restituisce una copia in locale del punto passato
 //----------------------------------------------------------------------------
-inline const Point3d
+inline Point3d
 GetToLoc( const Point3d& ptP, const Frame3d& frRef)
 {
    Point3d ptQ = ptP ;
@@ -385,7 +379,7 @@ GetToLoc( const Point3d& ptP, const Frame3d& frRef)
 //----------------------------------------------------------------------------
 //! Restituisce una copia in globale del punto passato
 //----------------------------------------------------------------------------
-inline const Point3d
+inline Point3d
 GetToGlob( const Point3d& ptP, const Frame3d& frRef)
 {
    Point3d ptQ = ptP ;
@@ -396,7 +390,7 @@ GetToGlob( const Point3d& ptP, const Frame3d& frRef)
 //----------------------------------------------------------------------------
 //! Restituisce una copia dal primo al secondo riferimento del punto passato
 //----------------------------------------------------------------------------
-inline const Point3d
+inline Point3d
 GetLocToLoc( const Point3d& ptP, const Frame3d& frOri, const Frame3d& frDest)
 {
    Point3d ptQ = ptP ;

EGkPolyLine.h

@@ -116,11 +116,6 @@ class PolyLine
       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) ;
-      EGK_EXPORT void SetTempProp( int nProp, int nPropInd = 0)
-                          { if ( nPropInd >= 0  &&  nPropInd < 2)
-                               m_nTempProp[nPropInd] = nProp ; } 
-      EGK_EXPORT int  GetTempProp( int nPropInd = 0) const
-                          { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    private :
       bool MyChangeStart( int nPos) ;
@@ -128,17 +123,15 @@ class PolyLine
       bool MyMakeConvex( const Vector3d& vtN,  bool bLeftSide) ;
 
    private :
-      int      m_nRejected ;                       // numero punti rifiutati perchè coincidenti
-      int      m_nTempProp[2] ;                    // vettore proprietà temporanee
-      PNTULIST m_lUPoints ;                        // lista dei punti
-      mutable PNTULIST::const_iterator m_iter ;    // iteratore corrente
+      int      m_nRejected ;
+      PNTULIST m_lUPoints ;
+      mutable PNTULIST::const_iterator m_iter ;
 } ;
 
 //----------------------------------------------------------------------------
 // Raccolte di PolyLine
-typedef std::vector<PolyLine>        POLYLINEVECTOR ;   // vettore di PolyLine
-typedef std::list<PolyLine>          POLYLINELIST ;     // lista di PolyLine
-typedef std::vector<POLYLINEVECTOR>  POLYLINEMATRIX ;   // matrice di PolyLine
+typedef std::vector<PolyLine>  POLYLINEVECTOR ;   // vettore di PolyLine
+typedef std::list<PolyLine>    POLYLINELIST ;     // lista di PolyLine
 
 //----------------------------------------------------------------------------
 EGK_EXPORT bool DistPointPolyLine( const Point3d& ptP, const PolyLine& plPoly, double& dDist) ;

EGkPolygon3d.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2023
+//  EgalTech 2015-2020
 //----------------------------------------------------------------------------
-// File : EGkPolygon3d.h         Data : 17.12.23          Versione : 2.5l3
+// File : Polygon3d.h           Data : 02.10.20          Versione : 2.2j1
 // Contenuto : Dichiarazione della classe Polygon3d (poligono nello spazio).
 //
 //
@@ -58,7 +58,7 @@ class Polygon3d
       EGK_EXPORT bool ToGlob( const Frame3d& frRef) ;
       EGK_EXPORT bool ToLoc( const Frame3d& frRef) ;
       EGK_EXPORT bool LocToLoc( const Frame3d& frOri, const Frame3d& frDest) ;
-      EGK_EXPORT bool GetLocalBBox( BBox3d& b3Loc) const ;
+
       EGK_EXPORT bool IsValid( void) const
                             { return ! m_Plane.GetVersN().IsSmall() ; }
       EGK_EXPORT const Plane3d& GetPlane( void) const

EGkPolygonElevation.h

@@ -1,32 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : EGkPolygonElevation.h           Data : 02.10.20          Versione : 2.2j1
-// Contenuto : Dichiarazione della classe Polygon3d (poligono nello spazio).
-//
-//
-//
-// Modifiche : 30.08.15 DS Creazione modulo.
-//             19.06.19 DS Aggiunta GetVertices.
-//             23.07.19 DS Aggiunte Offset e Invert.
-//             02.10.20 DS A FromPlaneTrimmedWithBox aggiunto parametro dToler.
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkPolygon3d.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
-
-
-//----------------------------------------------------------------------------
-EGK_EXPORT bool PolygonElevationInBBox( const Polygon3d& pgFacet, const BBox3d& b3Box, bool bAcceptOutFacet, double& dElev) ;
-EGK_EXPORT bool PolygonElevationInClosedSurfTm( const Polygon3d& pgFacet, const ISurfTriMesh& CldStm, bool bAcceptOutFacet, double& dElev) ;

EGkProjectCurveSurfTm.h

@@ -1,53 +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/EGkGeoPoint3d.h"
-#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 ;
-   Vector3d vtDir2 ;
-   double   dPar ;
-   int      nFlag ;
-   Point5ax( void) : ptP(), vtDir(), vtDir2(), dPar(), nFlag() {} ;
-   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, double dU, int nData)
-      : ptP( ptBase), vtDir( vtTool), vtDir2(), dPar( dU), nFlag( nData) {} ;
-   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2, double dU, int nData)
-      : ptP( ptBase), vtDir( 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 ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir,
-                                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
-EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const IGeoPoint3d& gpRef,
-                                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
-EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ICurve& crRef,
-                                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
-EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ISurfTriMesh& tmRef,
-                                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;

EGkQuaternion.h

@@ -1,174 +0,0 @@
-//----------------------------------------------------------------------------
-//  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

@@ -1,50 +0,0 @@
-//----------------------------------------------------------------------------
-//  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

@@ -1,51 +0,0 @@
-//----------------------------------------------------------------------------
-//  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
-} ;

EGkSbzStandard.h

@@ -1,27 +0,0 @@
-//----------------------------------------------------------------------------
-//  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* CreateBezierSphere( const Point3d& ptCenter, double dR) ;

EGkSfrCreate.h

@@ -30,7 +30,7 @@ EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionRectangle( double dWidth, double dL
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionStadium( double dWidth, double dLen) ;
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionDisk( double dRadius) ;
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromFatCurve( ICurve* pCrv, double dRadius,
-                                                           bool bSquareEnds, bool bSquareMids, double dOffsLinTol = 10 * EPS_SMALL) ;
+                                                           bool bSquareEnds, bool bSquareMids) ;
 // NB : la curva ingrassata non deve autointersecarsi
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromTriangle( const Triangle3d& Tria) ;
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromPolyLine( const PolyLine& ContourPolyLine) ;

EGkStmFromCurves.h

@@ -1,20 +1,19 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : EGkStmFromCurves.h   Data : 27.02.24       Versione : 2.6d1
-// Contenuto : Prototipi funzioni di creazione TriMesh a partire da curve.
+// File : EGkStmFromCurves.h   Data : 01.02.15       Versione : 1.6b1
+// Contenuto : Dichiarazione della classe StmFromTriangleSoup.
 //
 //
 //
 // Modifiche : 19.05.14 DS Creazione modulo.
-//             27.02.24 DS Aggiunta GetSurfTriMeshTransSwept.
+//
 //
 //----------------------------------------------------------------------------
 
 #pragma once
 
 #include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkSurfFlatRegion.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 
 //----------------------- Macro per import/export ----------------------------
@@ -40,11 +39,7 @@ EGK_EXPORT ISurfTriMesh* GetSurfTriMeshByRevolve( const ICurve* pCurve, const Po
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vector3d& vtAx,
                                                    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, 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) ;
+                                                  const ICurve* pGuide, int nCapType, double dLinTol) ;
+EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( 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) ;

EGkStmFromTriangleSoup.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : EGkStmFromTriangleSoup.h   Data : 07.05.23       Versione : 2.5e2
+// File : EGkStmFromTriangleSoup.h   Data : 19.05.14       Versione : 1.5e7
 // Contenuto : Dichiarazione della classe StmFromTriangleSoup.
 //
 //
@@ -35,14 +35,12 @@ class StmFromTriangleSoup
       EGK_EXPORT ~StmFromTriangleSoup( void) ;
       EGK_EXPORT bool Start( int nBuckets = GRID_STD_BUCKETS) ;
       EGK_EXPORT bool AddTriangle( const Triangle3d& Tria) ;
-      EGK_EXPORT bool AddTriangle( const Point3d& ptP0, const Point3d& ptP1, const Point3d& ptP2,
-                                   double dU0 = -1, double dV0 = -1, double dU1 = -1, double dV1 = -1, double dU2 = -1, double dV2 = -1) ;
-      EGK_EXPORT bool AddSurfTriMesh( const ISurfTriMesh& stmSource) ;
+      EGK_EXPORT bool AddTriangle( const Point3d& ptP0, const Point3d& ptP1, const Point3d& ptP2) ;
       EGK_EXPORT bool End( void) ;
       EGK_EXPORT ISurfTriMesh* GetSurf( void) ;
 
    private :
-      inline int AddVertex( const Point3d& ptP, double dU = -1, double dV = -1) ;
+      inline int AddVertex( const Point3d& ptP) ;
 
    private :
       ISurfTriMesh* m_pSTM ;

EGkSubtractProjectedFacesOnStmFace.h

@@ -1,29 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : EGkSubtractProjectedFacesOnStmFace.h      Data : 26.09.23       Versione : 2.5j1
-// Contenuto : Dichiarazione della funzione per proiettare facce di TriMesh su una superficie di TriMesh.
-//
-//
-//
-// Modifiche : 26.09.23 RE 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 SubtractProjectedFacesOnStmFace( const ISurfTriMesh& Stm, int nFaceInd, ISURFTMPOVECTOR& vStmOthers,
-                                                 bool bOCFlag, bool& bExistProjection, ISurfTriMesh*& pStmRes,
-                                                 int& nNewFaceNbr) ;

EGkSurfAux.h

@@ -1,67 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : EGkSurfAux.h         Data : 09.08.23          Versione :
-// Contenuto : Dichiarazione funzioni ausiliarie per ISurf.
-//
-//
-//
-// Modifiche : 09.08.23 DB Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkCurveComposite.h"
-#include "/EgtDev/Include/EGkSurf.h"
-#include "/EgtDev/Include/EGkSurfFlatRegion.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
-
-//----------------------------------------------------------------------------
-//! Struttura dati per superficie Nurbs
-struct SNurbsSurfData
-{
-   int       nDegU ;           // grado in U
-   int       nDegV ;           // grado in V
-   bool      bRat ;           // flag di superficie razionale (pesi non tutti unitari)
-   bool      bPeriodicU ;      // flag per segnalare vettore dei nodi periodico in U
-   bool      bPeriodicV ;      // flag per segnalare vettore dei nodi periodico in V
-   bool      bClosedU ;        // flag di superficie chiusa sul parametro U
-   bool      bClosedV ;        // flag di superficie chiusa sul parametro V
-   bool      bClampedU ;        // flag di superficie clamped sul parametro U
-   bool      bClampedV ;        // flag di superficie clamped sul parametro V
-   bool      bExtraKnotes ;   // flag per segnalare presenza di nodi extra all'inizio e fine (totale 2)
-   DBLVECTOR vU ;             // vettore dei nodi in U
-   DBLVECTOR vV ;             // vettore dei nodi in V
-   int       nCPU ;           // numero di punti di controllo in U
-   int       nCPV ;           // numero di punti di controllo in V
-   PNTVECTOR vCP ;            // vettore dei punti di controllo
-   PNTMATRIX mCP ;            // matrice dei punti di controllo
-   DBLMATRIX mW ;             // matrice dei pesi
-
-   SNurbsSurfData( void) : nDegU( 0), nDegV( 0), bRat( false), bPeriodicU( false), bPeriodicV( false), bClosedU( false), bClosedV( false),
-                           bClampedU( false), bClampedV( false), bExtraKnotes(false) {}
-} ;
-
-// N.B. : in caso la superficie 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 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-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EGkSurfBezier.h      Data : 10.04.24          Versione : 2.6d2
+// File : EGkSurfBezier.h      Data : 22.03.20          Versione : 2.2c3
 // Contenuto : Dichiarazione della interfaccia ISurfBezier.
 //
 //
@@ -14,7 +14,6 @@
 #pragma once
 
 #include "/EgtDev/Include/EGkSurf.h"
-#include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 class PolyLine ;
@@ -37,8 +36,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( ISurfFlatRegion& sfrTrimReg, bool bIntersectOrSubtrct = true) = 0 ;
-      virtual ISurfFlatRegion* GetTrimRegion( void) const = 0 ;
+      virtual bool SetTrimRegion( const ISurfFlatRegion& sfrTrimReg) = 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 ;
       virtual const Point3d& GetControlPoint( int nInd, bool* pbOk) const = 0 ;
@@ -59,21 +57,6 @@ 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 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 ;
-      // funzione da chiamare per calcolare i poli della superficie. NECESSARIO se si vuole tagliare la superficie con un piano
-      virtual bool CalcPoles( void) ;
-      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 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkSurfFlatRegion.h

@@ -36,7 +36,6 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
       virtual bool Subtract( const ISurfFlatRegion& Other) = 0 ;
       virtual bool Intersect( const ISurfFlatRegion& Other) = 0 ;
       virtual bool Offset( double dDist, int nType) = 0 ;
-      virtual ISurfFlatRegion* CreateOffsetSurf( double dDist, int nType) const = 0 ;
       virtual bool GetGrossArea( double& dArea) const = 0 ;
       virtual const Point3d& GetPlanePoint( void) const = 0 ;
       virtual const Vector3d& GetNormVersor( void) const = 0 ;
@@ -49,9 +48,7 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
       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 void ResetVoronoiObject( void) const = 0 ;
+      virtual bool GetZigZagInfill( double dSideStep, bool bAllowStepCorrection, bool bInvert, ICRVCOMPOPOVECTOR& vpCrvs) const = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------
@@ -85,9 +82,3 @@ const int REGC_IN2 = 2 ;               //!< La seconda regione
 const int REGC_SAME = 3 ;              //!< Le due regioni coincidono
 const int REGC_OUT = 4 ;               //!< Le due regioni sono esterne
 const int REGC_INTERS = 5 ;            //!< Le due regioni si intersecano
-
-//-----------------------------------------------------------------------------
-// Costanti per zona calcolo medial axis della regione
-const int WMAT_IN_OUT = 0 ;
-const int WMAT_IN = 1 ;
-const int WMAT_OUT = 2 ;

EGkSurfLocal.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2017-2024
+//  EgalTech 2017-2017
 //----------------------------------------------------------------------------
-// File : EGkSurfLocal.h           Data : 08.04.24         Versione : 2.6d2
+// File : EGkSurfLocal.h           Data : 29.03.17         Versione : 1.8c3
 // Contenuto : Classe gestione superfici nel locale desiderato.
 //
 //
@@ -45,25 +45,6 @@ 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-2024
+//  EgalTech 2014-2022
 //----------------------------------------------------------------------------
-// File : EGkSurfTriMesh.h      Data : 05.03.24          Versione : 2.6c2
+// File : EGkSurfTriMesh.h      Data : 10.10.22          Versione : 2.4i4
 // Contenuto : Dichiarazione della interfaccia ISurfTriMesh.
 //
 //
@@ -43,9 +43,7 @@ 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  AddVertex( const Point3d& ptVert) = 0 ;
       virtual int  AddTriangle( const int nIdVert[3], int nTFlag = 0) = 0 ;
       virtual bool RemoveTriangle( int nId) = 0 ;
       virtual bool AdjustTopology( void) = 0 ;
@@ -68,9 +66,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 ;
       virtual int  GetNextVertex( int nId, Point3d& ptP) const = 0 ;
       virtual bool GetTriangle( int nId, int nIdVert[3]) const = 0 ;
@@ -88,12 +84,11 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual bool GetTriangleSmoothNormals( int nId, TriNormals3d& TNrms) const = 0 ;
       virtual ISurfTriMesh* CloneTriangle( int nTria) const = 0 ;
       virtual bool GetLoops( POLYLINEVECTOR& vPL) const = 0 ;
-      virtual bool GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const = 0 ;
+      virtual bool GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL) const = 0 ;
       virtual int  GetFacetCount( void) const = 0 ;
       virtual int  GetFacetSize( void) const = 0 ;
       virtual int  GetFacetFromTria( int nT) const = 0 ;
       virtual bool GetAllTriaInFacet( int nF, INTVECTOR& vT) const = 0 ;
-      virtual bool GetAllVertInFacet( int nF, INTVECTOR& vVert) const = 0 ;
       virtual bool GetFacetLoops( int nF, POLYLINEVECTOR& vPL) const = 0 ;
       virtual bool GetFacetAdjacencies( int nF, INTMATRIX& vAdj) const = 0 ;
       virtual bool GetFacetNearestEndPoint( int nF, const Point3d& ptNear, Point3d& ptEnd, Vector3d& vtN) const = 0 ;
@@ -107,11 +102,6 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual bool SwapFacets( int nF1, int nF2) = 0 ;
       virtual bool GetFacetLocalBBox( int nF, BBox3d& b3Loc, int nFlag = BBF_STANDARD) const = 0 ;
       virtual bool GetFacetBBox( int nF, const Frame3d& frRef, BBox3d& b3Ref, int nFlag = BBF_STANDARD) const = 0 ;
-      virtual int  GetEdgeCount( void) const = 0 ;
-      virtual int  GetEdgeSize( void) const = 0 ;
-      virtual bool GetEdge( int nInd, int& nV1, int& nV2, int& nFl, int& nFr, double& dAng) const = 0 ;
-      virtual bool GetEdge( int nInd, Point3d& ptP1, Point3d& ptP2, double& dAng) const = 0 ;
-      virtual bool GetEdges( ICURVEPOVECTOR& vpCurve) const = 0 ;
       virtual bool Cut( const Plane3d& plPlane, bool bSaveOnEq) = 0 ;
       virtual bool GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq) = 0 ;
       virtual bool Add( const ISurfTriMesh& Other) = 0 ;

EGkVector3d.h

@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2023
+//  EgalTech 2013-2022
 //----------------------------------------------------------------------------
-// File : EGkVector3d.h          Data : 23.08.23          Versione : 2.5h2
+// File : EGkVector3d.h          Data : 27.08.22          Versione : 2.4h2
 // Contenuto : Dichiarazione della classe Vettore 3d.
 //
 //
 //
 // Modifiche : 31.12.13 DS Creazione modulo.
 //             14.12.19 DS Aggiunti confronti con Epsilon.
-//             23.08.23 DS Aggiunto V_INVALID.
 //
 //----------------------------------------------------------------------------
 
@@ -45,9 +44,6 @@ 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
-      bool IsValid( void) const
-             { return ( std::isfinite( x)  &&  std::isfinite( y)  &&  std::isfinite( z)) ; }
       //! Quadrato della lunghezza del vettore
       double SqLen( void) const
              { return ( x * x + y * y + z * z) ; }
@@ -85,10 +81,6 @@ class EGK_EXPORT Vector3d
       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 è circa parallelo a x
-      bool IsXEpsilon( double dToll) const
-             { double dMO = std::max( abs( y), abs( z)) ;
-               return ( abs( x) > dToll  &&  dMO < 10 * dToll  &&  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)) ;
@@ -101,10 +93,6 @@ class EGK_EXPORT Vector3d
       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 è circa parallelo a y
-      bool IsYEpsilon( double dToll) const
-             { double dMO = std::max( abs( z), abs( x)) ;
-               return ( abs( y) > dToll  &&  dMO < 10 * dToll  &&  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)) ;
@@ -117,30 +105,26 @@ class EGK_EXPORT Vector3d
       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 è circa parallelo a Z
-      bool IsZEpsilon( double dToll) const
-             { double dMO = std::max( abs( x), abs( y)) ;
-               return ( abs( z) > dToll  &&  dMO < 10 * dToll  &&  abs( z) > KV_BIG * dMO) ; }
       //! Verifica se il vettore è generico
       bool IsGeneric( void) const
              { return ( ! IsX()  &&  ! IsY()  &&  ! IsZ()) ; }
       //! Somma sul posto con altro vettore
       Vector3d& operator +=( const Vector3d& vtV)
-             { x += vtV.x ; y += vtV.y ; z += vtV.z ; return *this ; }
+             { this->x += vtV.x ; this->y += vtV.y ; this->z += vtV.z ; return *this ; }
       //! Sottrazione sul posto con altro vettore
       Vector3d& operator -=( const Vector3d& vtV)
-             { x -= vtV.x ; y -= vtV.y ; z -= vtV.z ; return *this ; }
+             { this->x -= vtV.x ; this->y -= vtV.y ; this->z -= vtV.z ; return *this ; }
       //! Moltiplicazione sul posto con un numero
       Vector3d& operator *=( double dMul)
-             { x *= dMul ; y *= dMul ; z *= dMul ; return *this ; }
+             { this->x *= dMul ; this->y *= dMul ; this->z *= dMul ; return *this ; }
       //! Divisione sul posto con un numero
       Vector3d& operator /=( double dDiv)
-             { double dMul = 1 / dDiv ; x *= dMul ; y *= dMul ; z *= dMul ; return *this ; }
+             { double dMul = 1 / dDiv ; this->x *= dMul ; this->y *= dMul ; this->z *= dMul ; return *this ; }
       //! Ritorna la rappresentazione in coordinate sferiche
       void ToSpherical( double* pdLen, double* pdAngVertDeg, double* pdAngOrizzDeg) const ;
       //! Inversione del vettore
       void Invert( void)
-             { x = -x ; y = -y ; z = -z ; }
+             { x = - x ; y = - y ; z = - z ; }
       //! Normalizzazione del vettore (trasformazione in versore)
       bool Normalize( double dEps = EPS_SMALL) ;
       //! Rotazione attorno ad un asse, dato l'angolo in gradi
@@ -183,8 +167,6 @@ class EGK_EXPORT Vector3d
 //----------------------------------------------------------------------------
 // Vettori notevoli
 //----------------------------------------------------------------------------
-//! Vettore non valido
-const Vector3d V_INVALID( NAN, NAN, NAN) ;
 //! Vettore nullo
 const Vector3d V_NULL( 0, 0, 0) ;
 //! Versore asse X
@@ -217,7 +199,7 @@ EGK_EXPORT Vector3d FromNearestHorizontalOrtho( const Vector3d& vtV, const Vecto
 //----------------------------------------------------------------------------
 //! Opposto di un vettore
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 operator-( const Vector3d& vtV)
 {
    return ( Vector3d( - vtV.x, - vtV.y, - vtV.z)) ; 
@@ -226,7 +208,7 @@ operator-( const Vector3d& vtV)
 //----------------------------------------------------------------------------
 //! Somma di due vettori
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 operator+( const Vector3d& vtV1, const Vector3d& vtV2)
 {
    return ( Vector3d( vtV1.x + vtV2.x, vtV1.y + vtV2.y, vtV1.z + vtV2.z)) ; 
@@ -235,7 +217,7 @@ operator+( const Vector3d& vtV1, const Vector3d& vtV2)
 //----------------------------------------------------------------------------
 //! Sottrazione di due vettori
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 operator-( const Vector3d& vtV1, const Vector3d& vtV2)
 {
    return ( Vector3d( vtV1.x - vtV2.x, vtV1.y - vtV2.y, vtV1.z - vtV2.z)) ; 
@@ -244,7 +226,7 @@ operator-( const Vector3d& vtV1, const Vector3d& vtV2)
 //----------------------------------------------------------------------------
 //! Prodotto con uno scalare
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 operator*( const Vector3d& vtV, double dMul)
 {
    return ( Vector3d( vtV.x * dMul, vtV.y * dMul, vtV.z * dMul)) ; 
@@ -253,7 +235,7 @@ operator*( const Vector3d& vtV, double dMul)
 //----------------------------------------------------------------------------
 //! Prodotto di uno scalare con un vettore
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 operator*( double dMul, const Vector3d& vtV)
 {
    return ( Vector3d( vtV.x * dMul, vtV.y * dMul, vtV.z * dMul)) ; 
@@ -262,7 +244,7 @@ operator*( double dMul, const Vector3d& vtV)
 //----------------------------------------------------------------------------
 //! Divisione con uno scalare
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 operator/( const Vector3d& vtV, double dDiv)
 {
    double dMul = 1 / dDiv ;
@@ -290,7 +272,7 @@ ScalarXY( const Vector3d& vtV1, const Vector3d& vtV2)
 //----------------------------------------------------------------------------
 //! Prodotto vettoriale
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 operator^( const Vector3d& vtV1, const Vector3d& vtV2)
 {
    return ( Vector3d( vtV1.y * vtV2.z - vtV1.z * vtV2.y,
@@ -310,7 +292,7 @@ CrossXY( const Vector3d& vtV1, const Vector3d& vtV2)
 //----------------------------------------------------------------------------
 //! Somma mediata di due vettori (baricentrica)
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 Media( const Vector3d& vtV1, const Vector3d& vtV2, double dCoeff = 0.5)
 {
    return ( Vector3d( ( 1 - dCoeff) * vtV1.x + dCoeff * vtV2.x,
@@ -321,7 +303,7 @@ Media( const Vector3d& vtV1, const Vector3d& vtV2, double dCoeff = 0.5)
 //----------------------------------------------------------------------------
 //! Restituisce il componente del vettore parallelo a quello di riferimento
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 ParallCompo( const Vector3d& vtV, const Vector3d& vtRef)
 {
    if ( vtRef.IsNormalized())
@@ -333,7 +315,7 @@ ParallCompo( const Vector3d& vtV, const Vector3d& vtRef)
 //----------------------------------------------------------------------------
 //! Restituisce il componente del vettore ortogonale a quello di riferimento
 //----------------------------------------------------------------------------
-inline const Vector3d 
+inline Vector3d 
 OrthoCompo( const Vector3d& vtV, const Vector3d& vtRef)
 {
    if ( vtRef.IsNormalized())
@@ -444,7 +426,7 @@ AreOrthoExact( const Vector3d& vtV1, const Vector3d& vtV2)
 //----------------------------------------------------------------------------
 //! Restituisce una copia in locale del vettore passato
 //----------------------------------------------------------------------------
-inline const Vector3d
+inline Vector3d
 GetToLoc( const Vector3d& vtV, const Frame3d& frRef)
 {
    Vector3d vtW = vtV ;
@@ -455,7 +437,7 @@ GetToLoc( const Vector3d& vtV, const Frame3d& frRef)
 //----------------------------------------------------------------------------
 //! Restituisce una copia in globale del vettore passato
 //----------------------------------------------------------------------------
-inline const Vector3d
+inline Vector3d
 GetToGlob( const Vector3d& vtV, const Frame3d& frRef)
 {
    Vector3d vtW = vtV ;
@@ -466,7 +448,7 @@ GetToGlob( const Vector3d& vtV, const Frame3d& frRef)
 //----------------------------------------------------------------------------
 //! Restituisce una copia dal primo al secondo riferimento del vettore passato
 //----------------------------------------------------------------------------
-inline const Vector3d
+inline Vector3d
 GetLocToLoc( const Vector3d& vtV, const Frame3d& frOri, const Frame3d& frDest)
 {
    Vector3d vtW = vtV ;

EGkVolZmap.h

@@ -1,23 +1,48 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2020
 //----------------------------------------------------------------------------
-// File : EGkVolZmap.h      Data : 09.03.24          Versione : 2.6c2
+// File : EGkVolZmap.h      Data : 12.05.19          Versione : 2.2k1
 // 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.
+//
 //
 //----------------------------------------------------------------------------
 
 #pragma once
 
 #include "/EgtDev/Include/EGkGeoObj.h"
+#include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
+#include "/EgtDev/Include/EGkTriangle3d.h"
+#include "/EgtDev/Include/EGkIntersLineTria.h"
+
+// ------------------------- STRUTTURE -----------------------------------------------------------
+// Informazioni su intersezione linea - volume Zmap
+struct IntLineZmapInfo {
+   int     nILTT ;          // Tipo di intersezione linea-triangolo
+   double  dU ;             // Parametro sulla linea
+   double  dU2 ;            // Secondo parametro sulla linea
+   int     nVox ;           // Indice del voxel del triangolo 
+   int     nBlock ;         // Indice del blocco del triangolo
+   Point3d ptI ;            // Punto di intersezione
+   Point3d ptI2 ;           // Secondo punto di intersezione (termine di tratto sovrapposto)
+   Triangle3d trTria ;      // Triangolo 
+  // Costruttori
+   IntLineZmapInfo( void)
+          : nILTT( ILTT_NO), dU( 0), dU2( 0), nVox( -1), nBlock( -1), ptI(), ptI2(), trTria() {}
+   IntLineZmapInfo( int nIL, double dUU, int nVx, int nBl, const Point3d& ptP, Triangle3d& trTr)
+          : nILTT( nIL), dU( dUU), dU2( 0), nVox( nVx), nBlock( nBl), ptI( ptP), ptI2(), trTria( trTr) {}
+   IntLineZmapInfo( int nIL, double dUU, double dUU2, int nVx, int nBl,
+                    const Point3d& ptP, const Point3d& ptP2, Triangle3d& trTr)
+          : nILTT( nIL), dU( dUU), dU2( dUU2), nVox( nVx), nBlock( nBl), ptI( ptP), ptI2( ptP2), trTria( trTr) {}
+} ;
+// Vettore di IntLineZmapInfo
+typedef std::vector<IntLineZmapInfo>    ILZIVECTOR ;
 
 //----------------------------------------------------------------------------
 class __declspec( novtable) IVolZmap : public IGeoObj
@@ -27,9 +52,7 @@ class __declspec( novtable) IVolZmap : public IGeoObj
    public :
       virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Clear( void) = 0 ;
-      virtual bool IsEmpty( void) = 0 ;
       virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dPrec, bool bTriDex) = 0 ;
-      virtual bool CreateEmptyMap( const Point3d& ptO, double dLengthX, double dLengthY, double dLengthZ, double dStep, 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 int  GetBlockCount( void) const = 0 ;
@@ -37,12 +60,9 @@ class __declspec( novtable) IVolZmap : public IGeoObj
       virtual bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const = 0 ;
       virtual bool GetEdges( ICURVEPOVECTOR& vpCurve) const = 0 ;
       virtual bool GetVolume( double& dVol) const = 0 ;
-      virtual bool IsTriDexel( void) const = 0 ;
       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 ;
@@ -67,17 +87,19 @@ class __declspec( novtable) IVolZmap : public IGeoObj
                                 const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
                                 const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) = 0 ;
       virtual bool GetDepth( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength, bool bExact) const = 0 ;
-      virtual bool CDeBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool CDeSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool CDeCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool CDeConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop, double dHeight,
-                                   double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool CDeRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
-                                    double dLenghtTopX, double dLenghtTopY, double dHeight,
-                                    double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool CDeTorus( const Frame3d& frTorus, double dRadMax, double dRadMin,
-                             double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool CDeSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const = 0 ;
+      virtual bool GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) const = 0 ;
+      virtual bool AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool AvoidSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool AvoidCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool AvoidConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop, double dHeight,
+                                     double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool AvoidRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
+                                      double dLenghtTopX, double dLenghtTopY, double dHeight,
+                                      double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool AvoidTorus( const Frame3d& frTorus, double dRadMax, double dRadMin,
+                               double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool AvoidSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecise = false) const = 0 ;
       virtual bool Cut( const Plane3d& plPlane) = 0 ;
       virtual bool Compact( void) = 0 ;
       virtual int  GetPartCount( void) const = 0 ;
@@ -86,8 +108,7 @@ class __declspec( novtable) IVolZmap : public IGeoObj
       virtual bool GetPartBBox( int nPart, const Frame3d& frRef, BBox3d& b3Ref, int nFlag = BBF_STANDARD) const = 0 ;
       virtual IVolZmap* ClonePart( int nPart) const = 0 ;
       virtual bool RemovePart( int nPart) = 0 ;
-      virtual int GetPartMinDistFromPoint( const Point3d& ptP) const = 0 ;
-      virtual bool AddSrfTm( const ISurfTriMesh* pStm) = 0 ;
+      virtual int  GetPartMinDistFromPoint( const Point3d& ptP) const = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGnDllMain.h

@@ -28,9 +28,3 @@ class ILogger ;
 EGN_EXPORT const char* GetEGnVersion( void) ;
 // permette di impostare il logger per la Dll
 EGN_EXPORT void SetEGnLogger( ILogger* pLogger) ;
-// imposta la chiave di protezione
-EGN_EXPORT void SetEGnKey( const std::string& sKey) ;
-// imposta il tipo di chiave di protezione
-EGN_EXPORT void SetEGnKeyType( int nType) ;
-// imposta se chiave hardware di rete
-EGN_EXPORT void SetEGnNetHwKey( bool bNetHwKey) ;

EGnGetKeyData.h

@@ -1,36 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : EGnGetKeyData.h        Data : 29.05.23          Versione : 2.5e3
-// Contenuto : Prototipo funzioni gestione dati chiavi di protezione.
-//
-//
-//
-// Modifiche : 29.05.23 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#define NOMINMAX
-#include <windows.h>
-#include <string>
-
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGN_EXPORT
-#if defined( I_AM_EGN)            // da definirsi solo nella DLL
-   #define EGN_EXPORT __declspec( dllexport)
-#else
-   #define EGN_EXPORT __declspec( dllimport)
-#endif
-
-//-----------------------------------------------------------------------------
-EGN_EXPORT bool SetEGnKeyLevel( int nRet, int nKeyLev, int nKeyExpDays) ;
-EGN_EXPORT int  GetEGnKeyLevel( int nProd, int nVer, int nLev, int& nKeyLev, int& nKeyExpDays) ;
-EGN_EXPORT bool SetEGnKeyOptions( int nRet, int nKeyOpt1, int nKeyOpt2, int nKeyOptExpDays) ;
-EGN_EXPORT int  GetEGnKeyOptions( int nProd, int nVer, int nLev, unsigned int& nKeyOpt1, unsigned int& nKeyOpt2, int& nKeyOptExpDays) ;
-// Interpretazione della stringa di LockId
-EGN_EXPORT bool GetLockIdStringInfo( const std::string& sLockId, int& nKeyType, bool& bNetKey, int& nUserId) ;
-EGN_EXPORT bool GetLockIdStringNetData( const std::string& sLockId, std::string& sAddrPort) ;

EGnStringUtils.h

@@ -196,11 +196,11 @@ EGN_EXPORT bool FromString( const std::string& sVal, STRVECTOR& vsVal) ;
 
 //----------------------------------------------------------------------------
 inline const std::string
-ToString( int nVal, int nPrec = 1, int nRadix = 10)
+ToString( int nVal, int nPrec = 1)
       {
         // eseguo conversione
          char szBuff[24] ;
-         int nErr = _itoa_s( nVal, szBuff, nRadix) ;
+         int nErr = _itoa_s( nVal, szBuff, 10) ;
         // se errore, ritorno stringa opportuna
          if ( nErr != 0) {
             _ASSERT( 0) ;
@@ -216,11 +216,11 @@ ToString( int nVal, int nPrec = 1, int nRadix = 10)
          return sBuff ;
       }
 inline const std::string
-ToString( unsigned int nVal, int nPrec = 1, int nRadix = 10)
+ToString( unsigned int nVal, int nPrec = 1)
       {
         // eseguo conversione
          char szBuff[24] ;
-         int nErr = _ultoa_s( nVal, szBuff, nRadix) ;
+         int nErr = _ui64toa_s( nVal, szBuff, 24, 10) ;
         // se errore, ritorno stringa opportuna
          if ( nErr != 0) {
             _ASSERT( 0) ;
@@ -245,7 +245,7 @@ const std::string ToString( const int (&nVal)[size], int nPrec = 1)
 inline const std::string
 ToString( bool bVal)
       { return std::string( ( bVal ? "1" : "0")) ; }
-EGN_EXPORT const std::string ToString( double dVal, int nPrec = 6, int* pnErr = nullptr) ;
+EGN_EXPORT const std::string ToString( double dVal, int nPrec = 6) ;
 template <size_t size>
 const std::string ToString( const double (&dVal)[size], int nPrec = 6)
       { std::string sDest ; sDest.reserve( 14 * size) ;

EGrScene.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2024
+//  EgalTech 2014-2022
 //----------------------------------------------------------------------------
-// File : EGrScene.h          Data : 16.02.24           Versione : 2.6b4
+// File : EGrScene.h          Data : 22.10.22           Versione : 2.4j1
 // Contenuto : Dichiarazione della interfaccia IEGrScene per scena OpenGL.
 //
 //
 //
 // Modifiche : 13.02.14 DS Creazione modulo.
-//             16.02.24 DS Aggiunte Set/Get CameraDirOrizzOffset.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -57,12 +57,10 @@ class IEGrScene
       virtual void Destroy( void) = 0 ;
      // Camera
       virtual bool SetCenter( const Point3d& ptCenter) = 0 ;
-      virtual bool SetCameraDirOrizzOffset( int nRightStepOffset = 0)  = 0 ;
       virtual bool SetCamera( double dAngVertDeg, double dAngOrizzDeg, double dDist) = 0 ;
       virtual bool SetCamera( int nDir, double dDist = 0) = 0 ;
       virtual const Point3d& GetCenter( void) const = 0 ;
       virtual Point3d GetProjectedCenter( void) const = 0 ;
-      virtual int  GetCameraDirOrizzOffset( void) const = 0 ;
       virtual void GetCamera( double* pdAngVertDeg, double* pdAngOrizzDeg, double* pdDist = nullptr) const = 0 ;
       virtual int  GetCameraDir( void) const = 0 ;
       virtual const Vector3d& GetCameraUp( void) const = 0 ;
@@ -95,8 +93,6 @@ class IEGrScene
      // Grid
       virtual bool SetGridShow( bool bShowGrid, bool bShowFrame) = 0 ;
       virtual bool SetGridGeo( double dSnapStep, int nMinLineSstep, int nMajLineSstep, int nExtSstep) = 0 ;
-      virtual bool SetGridGeoAdv( double dSnapStep, int nMinLineSstep, int nMajLineSstep,
-                                  double dXmin, double dXmax, double dYmin, double dYmax) = 0 ;
       virtual bool SetGridColor( Color colMinLine, Color colMajLine) = 0 ;
       virtual void GetGridParam( double& dSnapStep, int& nExtStep) const = 0 ;
       virtual bool GetShowGrid( void) = 0 ;

EInAPI.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2024
+//  EgalTech 2014-2022
 //----------------------------------------------------------------------------
-// File : EInAPI.h          Data : 09.01.24          Versione : 2.5l6
+// File : EInAPI.h          Data : 06.05.22          Versione : 2.4e1
 // Contenuto : API (application programming interface).
 //
 //
@@ -34,8 +34,6 @@ extern "C" {
 // General
 EIN_EXPORT BOOL __stdcall EgtInit( int nDebug, const wchar_t* wsLogFile, const wchar_t* wsLogMsg) ;
 EIN_EXPORT BOOL __stdcall EgtExit( void) ;
-typedef bool (__stdcall * pfOnTerminateProcess) ( int) ;
-EIN_EXPORT BOOL __stdcall EgtSetOnTerminateProcess( pfOnTerminateProcess pFun) ;
 EIN_EXPORT BOOL __stdcall EgtSetUserLevel( int nUserLev) ;
 EIN_EXPORT int  __stdcall EgtGetUserLevel( void) ;
 EIN_EXPORT BOOL __stdcall EgtSetKey( const wchar_t* wsKey) ;
@@ -52,14 +50,11 @@ EIN_EXPORT void __stdcall EgtDisableCommandLogger( void) ;
 EIN_EXPORT BOOL __stdcall EgtGetVersionInfo( wchar_t*& wsVer) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyInfo( wchar_t*& wsKey) ;
 EIN_EXPORT BOOL __stdcall EgtSetLockType( int nType) ;
-EIN_EXPORT BOOL __stdcall EgtSetLockId( const wchar_t* wsLockId) ;
 EIN_EXPORT BOOL __stdcall EgtSetNetHwKey( BOOL bNetHwKey) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyLevel( int nProd, int nVer, int nLev, int* pnKLev) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyOptions( int nProd, int nVer, int nLev, unsigned int* pnOpt2) ;
 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) ;
@@ -117,13 +112,11 @@ EIN_EXPORT BOOL __stdcall EgtImportDxf( const wchar_t* wsFilePath, double dScale
 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 EgtImport3dm( const wchar_t* wsFilePath) ;
 EIN_EXPORT BOOL __stdcall EgtAdvancedImportIsEnabled( void) ;
-EIN_EXPORT BOOL __stdcall EgtAdvancedImport( const wchar_t* wsFilePath, double dLinToler, int nFlag) ;
+EIN_EXPORT BOOL __stdcall EgtAdvancedImport( const wchar_t* wsFilePath, double dLinToler) ;
 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) ;
-EIN_EXPORT BOOL __stdcall EgtExport3dm( int nId, const wchar_t* wsFilePath, int nFilter) ;
 EIN_EXPORT BOOL __stdcall EgtExportSvg( int nId, const wchar_t* wsFilePath, int nFilter) ;
 EIN_EXPORT BOOL __stdcall EgtSetThreeJSLibDir( const wchar_t* wsThreeJSLibDir) ;
 EIN_EXPORT BOOL __stdcall EgtExportThreeJS( int nId, const wchar_t* wsFilePath, int nFilter) ;
@@ -212,15 +205,6 @@ 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,
@@ -316,10 +300,9 @@ 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, const double vtAx[3],
-                                                BOOL bCapEnds, double dLinTol, int nRefType) ;
+                                               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) ;
 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) ;
@@ -351,8 +334,6 @@ EIN_EXPORT BOOL __stdcall EgtSelectPathObjs( int nId, BOOL bHaltOnFork) ;
 EIN_EXPORT int  __stdcall EgtDuploNew( int nSouId) ;
 EIN_EXPORT BOOL __stdcall EgtDuploCount( int nSouId, int* pnCount) ;
 EIN_EXPORT BOOL __stdcall EgtDuploList( int nSouId, int*& vInd, int* pnCount) ;
-EIN_EXPORT BOOL __stdcall EgtDuploInRawCount( int nSouId, int* pnCount) ;
-EIN_EXPORT BOOL __stdcall EgtDuploWithoutRawList( int*& vInd, int* pnCount) ;
 EIN_EXPORT BOOL __stdcall EgtDuploSetModified( int nSouId) ;
 EIN_EXPORT BOOL __stdcall EgtDuploGetModified( int nSouId, BOOL* pbModif) ;
 EIN_EXPORT BOOL __stdcall EgtDuploSetLocked( int nDupId) ;
@@ -540,8 +521,6 @@ 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) ;
@@ -600,8 +579,6 @@ EIN_EXPORT int  __stdcall EgtExtractSurfFrChunkLoops( int nId, int nChunk, int n
 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,
@@ -738,9 +715,7 @@ EIN_EXPORT int  __stdcall EgtGetLastMachGroup( void) ;
 EIN_EXPORT int  __stdcall EgtGetPrevMachGroup( int nId) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachGroupNewName( const wchar_t* wsName, wchar_t*& wsNewName) ;
 EIN_EXPORT int  __stdcall EgtAddMachGroup( const wchar_t* wsName, const wchar_t* wsMachineName) ;
-EIN_EXPORT int  __stdcall EgtCopyMachGroup( const wchar_t* wsSouName, const wchar_t* wsName) ;
 EIN_EXPORT BOOL __stdcall EgtRemoveMachGroup( int nMGroupId) ;
-EIN_EXPORT BOOL __stdcall EgtChangeMachGroupName( int nMGroupInd, const wchar_t* wsNewName) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachGroupName( int nMGroupId, wchar_t*& wsName) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachGroupMachineName( int nMGroupId, wchar_t*& wsMachineName) ;
 EIN_EXPORT int  __stdcall EgtGetMachGroupId( const wchar_t* wsName) ;
@@ -966,13 +941,11 @@ 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 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[],
+EIN_EXPORT BOOL __stdcall EgtGetCalcPositions( const double ptP[3], double dAngA, double dAngB,
                                                int* pnStat, double* pdX, double* pdY, double* pdZ) ;
-EIN_EXPORT BOOL __stdcall EgtGetCalcTipFromPositions( double dX, double dY, double dZ, int nCount, const double dAngs[],
+EIN_EXPORT BOOL __stdcall EgtGetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
                                                       BOOL bBottom, double ptTip[3]) ;
-EIN_EXPORT BOOL __stdcall EgtGetCalcToolDirFromAngles( int nCount, const double dAngs[], double vtDir[3]) ;
+EIN_EXPORT BOOL __stdcall EgtGetCalcToolDirFromAngles( double dAngA, double dAngB, 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
@@ -998,8 +971,6 @@ EIN_EXPORT BOOL __stdcall EgtSetWinRectAttribs( BOOL bOutline, const int WrCol[4
 EIN_EXPORT BOOL __stdcall EgtSetGlobFrameShow( BOOL bShow) ;
 EIN_EXPORT BOOL __stdcall EgtSetGridShow( BOOL bShowGrid, BOOL bShowFrame) ;
 EIN_EXPORT BOOL __stdcall EgtSetGridGeo( double dSnapStep, int nMinLineSstep, int nMajLineSstep, int nExtSstep) ;
-EIN_EXPORT BOOL __stdcall EgtSetGridGeoAdv( double dSnapStep, int nMinLineSstep, int nMajLineSstep,
-                                            double dXmin, double dXmax, double dYmin, double dYmax) ;
 EIN_EXPORT BOOL __stdcall EgtSetGridColor( const int nMinCol[4], const int nMajCol[4]) ;
 EIN_EXPORT BOOL __stdcall EgtResize( int nW, int nH) ;
 EIN_EXPORT BOOL __stdcall EgtDraw( void) ;

EMkMachMgr.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2022
 //----------------------------------------------------------------------------
-// File : EMkMachMgr.h           Data : 02.04.24          Versione : 2.6d1
+// File : EMkMachMgr.h           Data : 21.09.22          Versione : 2.4i4
 // Contenuto : Dichiarazione della interfaccia IMachMgr.
 //
 //
@@ -13,10 +13,6 @@
 //             10.11.20 DS Portate in interfaccia funzioni di calcolo con vettori di angoli.
 //             13.01.21 DS Aggiunte in interfaccia GetCalcHead e GetCalcExit.
 //             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.
 //
 //----------------------------------------------------------------------------
 
@@ -61,9 +57,7 @@ class __declspec( novtable) IMachMgr
       virtual int  GetPrevMachGroup( int nId) const = 0 ;
       virtual bool GetMachGroupNewName( std::string& sName) const = 0 ;
       virtual int  AddMachGroup( const std::string& sName, const std::string& sMachineName) = 0 ;
-      virtual int  CopyMachGroup( const std::string& sSouName, const std::string& sName) = 0 ;
       virtual bool RemoveMachGroup( int nId) = 0 ;
-      virtual bool ChangeMachGroupName( int nId, const std::string& sNewName) = 0 ;
       virtual std::string GetMachGroupName( int nId) const = 0 ;
       virtual std::string GetMachGroupMachineName( int nId) const = 0 ;
       virtual int  GetMachGroupId( const std::string& sName) const = 0 ;
@@ -170,7 +164,6 @@ class __declspec( novtable) IMachMgr
       virtual bool ImportSetup( const std::string& sName) = 0 ;
       virtual bool VerifyCurrSetup( STRVECTOR& vsErrors) = 0 ;
       virtual bool FindToolInCurrSetup( const std::string& sTool) = 0 ;
-      virtual bool GetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) = 0 ;
       virtual bool GetToolsInCurrSetupPos( const std::string& sTcPos, STRVECTOR& vsTools) = 0 ;
       virtual bool UpdateCurrSetup( void) = 0 ;
       virtual bool EraseCurrSetup( void) = 0 ;
@@ -206,7 +199,7 @@ class __declspec( novtable) IMachMgr
       virtual bool MdbToBeImported( const std::string& sFile, STRVECTOR& vsMachiningsNames, INTVECTOR& vMachiningsTypes) const = 0 ;
       virtual bool MdbImport( const std::string& sFile, const STRVECTOR& vsMachiningsToImport, const STRVECTOR& vsMachiningsNames, 
                               STRVECTOR& vsImported) = 0 ;
-     // Operations : general
+      // Operations : general
       virtual int  GetOperationCount( void) const = 0 ;
       virtual int  GetFirstOperation( void) const = 0 ;
       virtual int  GetNextOperation( int nId) const = 0 ;
@@ -269,10 +262,8 @@ class __declspec( novtable) IMachMgr
       virtual bool GetMachiningEndPoint( Point3d& ptEnd) const = 0 ;
      // CL Entities Interrogations
       virtual bool GetClEntMove( int nEntId, int& nMove) const = 0 ;
-      virtual bool GetClEntFlag( int nEntId, int& nFlag, int& nFlag2) const = 0 ;
+      virtual bool GetClEntFlag( int nEntId, int& nFlag) const = 0 ;
       virtual bool GetClEntIndex( int nEntId, int& nIndex) 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 ;
       virtual bool SimStart( bool bFirst) = 0 ;
@@ -291,10 +282,8 @@ 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 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 ;
@@ -335,7 +324,6 @@ 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-2024
+//  EgalTech 2015-2022
 //----------------------------------------------------------------------------
-// File : EmkMachiningConst.h     Data : 29.03.24      Versione : 2.6di1
+// File : EmkMachiningConst.h     Data : 04.02.22      Versione : 2.4b1
 // Contenuto : Costanti delle lavorazioni.      
 //
 //
@@ -12,8 +12,6 @@
 //             03.06.20 DS Agg. MPA_TABMIN e MPA_TABMAX.
 //             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.
 //
 //----------------------------------------------------------------------------
 
@@ -40,8 +38,7 @@ 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_APPROXLINTOL =       ( MGP_DOU +  8)} ;
+               MGP_MAXDEPTHSAFE =       ( MGP_DOU +  7)} ;
 
 //----------------------------------------------------------------------------
 // Costanti per tipologia di split arcs
@@ -65,8 +62,7 @@ enum MachiningType {
    MT_CHISELING = OPER_CHISELING,
    MT_SURFROUGHING = OPER_SURFROUGHING,
    MT_SURFFINISHING = OPER_SURFFINISHING,
-   MT_WATERJETTING = OPER_WATERJETTING,
-   MT_5AXMACHINING = OPER_5AXMACHINING
+   MT_WATERJETTING = OPER_WATERJETTING
 } ;
 
 //----------------------------------------------------------------------------

EMkMachiningGeoConst.h

@@ -33,9 +33,8 @@ static std::string MCH_TABS = "TABS" ;
 static std::string MCH_PV = "PV" ;
 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" ;
@@ -45,7 +44,7 @@ static std::string MCH_CL_AGB_DWN = "AGBD" ;
 static std::string MCH_CL_AGB_IN = "AGBI" ;
 static std::string MCH_CL_AGB_OUT = "AGBO" ;
 static std::string MCH_CL_AGB_UP = "AGBU" ;
-// 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,8 +59,6 @@ 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" ;
@@ -70,10 +67,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
@@ -108,8 +105,6 @@ 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 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-2019
 //----------------------------------------------------------------------------
-// File : EmkOperationConst.h     Data : 06.09.23     Versione : 2.5i1
+// File : EmkOperationConst.h     Data : 08.07.19     Versione : 2.1g2
 // Contenuto : Costanti delle operazioni.      
 //
 //
@@ -12,7 +12,6 @@
 //             03.02.17 DS Agg. Chiseling.
 //             25.05.19 DS Agg. SurfRoughing e SurfFinishing.
 //             08.07.19 DS Agg. WaterJetting.
-//             06.09.23 DS Agg. 5AxMachining.
 //
 //----------------------------------------------------------------------------
 
@@ -32,8 +31,7 @@ enum OperType { OPER_NULL =                0,      // nulla
                 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
+                OPER_WATERJETTING =  0x100000} ;   // taglio water jet
 // Controllo tipo valido
 bool inline IsValidDispositionType( int nType)
 {
@@ -52,6 +50,5 @@ bool inline IsValidMachiningType( int nType)
             nType == OPER_CHISELING  ||
             nType == OPER_SURFROUGHING  ||
             nType == OPER_SURFFINISHING  ||
-            nType == OPER_WATERJETTING  ||
-            nType == OPER_5AXMACHINING) ;
+            nType == OPER_WATERJETTING ) ;
 }

EMkSimuGenConst.h

@@ -35,8 +35,7 @@ enum SimCollObjType { MCH_SIM_COB_NULL = 0,
                       MCH_SIM_COB_BOX = 1,
                       MCH_SIM_COB_CYL = 2,
                       MCH_SIM_COB_SPHE = 3,
-                      MCH_SIM_COB_CONE = 4,
-                      MCH_SIM_COB_POLY = 101} ;
+                      MCH_SIM_COB_CONE = 4} ;
 
 //------------------------ Stato di visualizzazione della macchina ------------
 enum MachLook { MCH_LOOK_NONE = -1,

ENkDijkstra.h

@@ -1,39 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : ENkDijkstra.h      Data : 08.02.24        Versione : 2.6b1
-// Contenuto : Classe per calcolo del percorso a peso minimo su un grafo orientato.
-//
-//
-// Modifiche : 02.02.2024 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EgtNumCollection.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef ENK_EXPORT
-#if defined( I_AM_ENK)            // da definirsi solo nella DLL
-   #define ENK_EXPORT __declspec( dllexport)
-#else
-   #define ENK_EXPORT __declspec( dllimport)
-#endif
-
-//----------------------------------------------------------------------------
-class __declspec( novtable) IDijkstra
-{
-   public :
-      virtual ~IDijkstra( void) {}
-      virtual bool SetGraph( DBLMATRIX AdjMatrix, int nDestInd = -1) = 0 ;
-      virtual bool GetPath( INTVECTOR& vNodePath) = 0 ;
-} ;
-
-//-----------------------------------------------------------------------------
-ENK_EXPORT IDijkstra* CreateDijkstra( void) ;
-
-//-----------------------------------------------------------------------------
-// costante per arco non presente
-const double WEIGHT_NO_ADJ = 1073741823U ;

EXeConst.h

@@ -29,7 +29,6 @@ enum FileType { FT_NULL =  0,
                 FT_BTLX = 19,
                 FT_3MF =  20,
                 FT_OBJ = 21,
-                FT_3DM = 22 ,
                 FT_IGES = 31,
                 FT_STEP = 32,
                 FT_ACIS = 33,
@@ -67,16 +66,13 @@ enum ApprType{ APP_LINES = 0,                // come ICurve::APL_STD
                APP_RIGHT_CONVEX_LINES = 12,  // come ICurve::APL_RIGHT_CONVEX
                APP_ARCS = 3} ;
 
-//----------------- Costanti tipo punto intersezione Linea Curva ---------------
-enum CLiType { CLT_NONE =  0,
-               CLT_IN =  1,
-               CLT_OUT = 2,
-               CLT_TOUCH_IN = 3,
-               CLT_TOUCH_OUT = 4,
-               CLT_TGINI_IN = 5,
-               CLT_TGFIN_IN = 6,
-               CLT_TGINI_OUT = 7,
-               CLT_TGFIN_OUT = 8} ;
+//----------------- Costanti tipo punto intersezione Linea SurfTriMesh ---------
+enum SLiType { SLT_NONE =  0,
+               SLT_IN =  1,
+               SLT_OUT = 2,
+               SLT_TG_INI = 3,
+               SLT_TG_FIN = 4,
+               SLT_TOUCH = 5} ;
 
 //----------------- Costanti tipo di costruzione di superficie rigata ----------
 enum RuledType{ RUL_TYPE_ISOPAR = 0,          // come ISurfTrimesh::RLT_ISOPAR

EXeExecutor.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2022
 //----------------------------------------------------------------------------
-// File : EXcExecutor.h          Data : 30.03.24          Versione : 2.6d1
+// File : EXcExecutor.h          Data : 06.05.22          Versione : 2.4e1
 // Contenuto : Interfaccia Executor.
 //
 //
@@ -37,8 +37,6 @@ class LuaMgr ;
 // General
 EXE_EXPORT bool ExeInit( int nDebug, const std::string& sLogFile, const std::string& sLogMsg) ;
 EXE_EXPORT bool ExeExit( void) ;
-EXE_EXPORT bool ExeSetOnTerminateProcess( pfOnTerminateProcess pFun) ;
-EXE_EXPORT bool ExeOnTerminateProcess( int nExitCode) ;
 EXE_EXPORT int  ExeGetDebugLevel( void) ;
 EXE_EXPORT bool ExeSetUserLevel( int nUserLev) ;
 EXE_EXPORT int  ExeGetUserLevel( void) ;
@@ -57,14 +55,11 @@ EXE_EXPORT bool ExeGetExecutableVersion( std::string& sVer) ;
 EXE_EXPORT bool ExeGetVersionInfo( std::string& sVer, const char* szNewLine) ;
 EXE_EXPORT bool ExeGetKeyInfo( std::string& sKey) ;
 EXE_EXPORT bool ExeSetLockType( int nType) ;
-EXE_EXPORT bool ExeSetLockId( const std::string& sLockId) ;
-EXE_EXPORT bool ExeSetNetHwKey( bool bNetHwKey, int nUserId = 0, const std::string& sAddrPort = "") ;
+EXE_EXPORT bool ExeSetNetHwKey( bool bNetHwKey) ;
 EXE_EXPORT bool ExeGetKeyLevel( int nProd, int nVer, int nLev, int& nKLev) ;
 EXE_EXPORT bool ExeGetKeyOptions( int nProd, int nVer, int nLev, unsigned int& nOpt2) ;
 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) ;
@@ -125,13 +120,11 @@ 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 ExeImport3dm( const std::string& sFilePath) ;
 EXE_EXPORT bool ExeAdvancedImportIsEnabled( void) ;
-EXE_EXPORT bool ExeAdvancedImport( const std::string& sFilePath, double dToler = 0.1, int nFlag = 0) ;
+EXE_EXPORT bool ExeAdvancedImport( const std::string& sFilePath, double dToler = 0.1) ;
 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) ;
-EXE_EXPORT bool ExeExport3dm( int nId, const std::string& sFilePath, int nFilter = 393) ;
 EXE_EXPORT bool ExeExportSvg( int nId, const std::string& sFilePath, int nFilter = 393) ;
 EXE_EXPORT bool ExeSetThreeJSLibDir( const std::string & sThreeJSLibDir) ;
 EXE_EXPORT bool ExeExportThreeJS( int nId, const std::string& sFilePath, int nFilter = 393) ;
@@ -234,17 +227,12 @@ 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& ptV, const Point3d& ptP1, const Point3d& ptP2,
+EXE_EXPORT int  ExeCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptV, 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,
                                                   const std::string& sText, int nRefType) ;
-EXE_EXPORT int  ExeCreateAngularDimensionFromCircle( int nParentId, int nCrvId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptDim,
-                                                     const std::string& sText, int nRefType) ;
 
 // GeomDB Create Curve
 EXE_EXPORT int  ExeCreateLine( int nParentId, const Point3d& ptIni, const Point3d& ptFin, int nRefType) ;
@@ -275,8 +263,6 @@ 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  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,
                                  double dDirSDeg, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc2PDEx( int nParentId, const Point3d& ptStart,
@@ -323,7 +309,7 @@ EXE_EXPORT int  ExeCreateCirclesAlongCurve( int nParentId, int nCrvId, double dO
                                             double dStartAdd, double dEndAdd, double dDiam, int* pnCount) ;
 // 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) ;
+EXE_EXPORT int  ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquared) ;
 EXE_EXPORT int  ExeCreateSurfFrRectangle( int nParentId, const Point3d& ptIni, const Point3d& ptCross, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfFrRectangle3P( int nParentId, const Point3d& ptIni,
                                             const Point3d& ptCross, const Point3d& ptDir, int nRefType) ;
@@ -342,8 +328,6 @@ 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  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  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,
@@ -358,27 +342,20 @@ 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, 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  ExeCreateSurfTmSwept( 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) ;
 
 // 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 ) ;
+                                   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 nParentId, int nZmapId, int nStmId) ;
 
 // GeomDB PartLayer
 EXE_EXPORT bool ExeIsPart( int nPartId) ;
@@ -396,7 +373,6 @@ EXE_EXPORT int  ExeGetFirstLayer( int nPartId, bool bOnlyVisible) ;
 EXE_EXPORT int  ExeGetNextLayer( int nId, bool bOnlyVisible) ;
 EXE_EXPORT int  ExeGetLastLayer( int nPartId, bool bOnlyVisible) ;
 EXE_EXPORT int  ExeGetPrevLayer( int nId, bool bOnlyVisible) ;
-EXE_EXPORT bool ExeIsGhostPart( int nGhostId) ;
 EXE_EXPORT int  ExeGetFirstGhostPart( void) ;
 EXE_EXPORT int  ExeGetNextGhostPart( int nId) ;
 EXE_EXPORT bool ExeEraseEmptyParts( void) ;
@@ -408,8 +384,6 @@ EXE_EXPORT bool ExeSelectPathObjs( int nId, bool bHaltOnFork) ;
 EXE_EXPORT int  ExeDuploNew( int nSouId) ;
 EXE_EXPORT bool ExeDuploCount( int nSouId, int& nCount) ;
 EXE_EXPORT bool ExeDuploList( int nSouId, INTVECTOR& vnRef) ;
-EXE_EXPORT bool ExeDuploInRawCount( int nSouId, int& nCount) ;
-EXE_EXPORT bool ExeDuploWithoutRawList( INTVECTOR& vnRef) ;
 EXE_EXPORT bool ExeDuploSetModified( int nSouId) ;
 EXE_EXPORT bool ExeDuploGetModified( int nSouId, bool& bModif) ;
 EXE_EXPORT bool ExeDuploSetLocked( int nDupId) ;
@@ -548,9 +522,9 @@ EXE_EXPORT int  ExeSplitText( int nId, int* pnCount) ;
 // GeomDb Curve Modify
 EXE_EXPORT bool ExeInvertCurve( const INTVECTOR& vIds) ;
 EXE_EXPORT bool ExeOffsetCurve( int nId, double dDist, int nType) ;
-EXE_EXPORT int  ExeOffsetCurveAdv( int nId, double dDist, int nType, int* pnCount, double dLinTol = 10 * EPS_SMALL) ;
+EXE_EXPORT int  ExeOffsetCurveAdv( int nId, double dDist, int nType, int* pnCount) ;
 EXE_EXPORT int  ExeCurveMedialAxis( int nId) ;
-EXE_EXPORT bool ExeApproxCurve( int nId, int nApprType, double dLinTol, double dMaxSegmLen = INFINITO) ;
+EXE_EXPORT bool ExeApproxCurve( int nId, int nApprType, double dLinTol) ;
 EXE_EXPORT bool ExeProjectCurveOnPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, int nRefType) ;
 EXE_EXPORT bool ExeChangeClosedCurveStart( int nId, double dU) ;
 EXE_EXPORT bool ExeChangeClosedCurveStartPoint( int nId, const Point3d& ptP, int nRefType) ;
@@ -602,50 +576,33 @@ EXE_EXPORT bool ExeMergeCurvesInCurveCompo( int nId, double dLinTol, bool bStart
 EXE_EXPORT bool ExeRemoveCurveCompoUndercutOnY( int nId, double dLinTol) ;
 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 bool ExeProjectCurveOnSurfTmExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
-                                            double dLinTol, double dMaxSegmLen, bool bDirFromGuide) ;
-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 int  ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, bool bSquareMids, int* pnCount) ;
 
 // 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, double dTriaMinSide = 100 * EPS_SMALL) ;
+EXE_EXPORT bool ExeApproxSurface( int nId, double dLinTol) ;
 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 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 ExeSurfTmResetTwoColors( int nId) ;
-EXE_EXPORT bool ExeSurfTmSetShowEdges( int nId, bool bShow) ;
-EXE_EXPORT bool ExeSurfBzTrim( int nId, int nCutterId) ;
 
 // GeomDb Volume Modify
 EXE_EXPORT int  ExeExplodeVolume( int nId, int* pnCount) ;
 EXE_EXPORT bool ExeVolZmapChangeResolution( int nId, int nNewRes) ;
-EXE_EXPORT bool ExeVolZmapSetShowEdges( int nId, bool bShow) ;
 EXE_EXPORT bool 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) ;
@@ -673,10 +630,6 @@ EXE_EXPORT bool ExeTextGetFont( int nId, std::string& sFont) ;
 EXE_EXPORT bool ExeTextGetHeight( int nId, double& dH) ;
 EXE_EXPORT bool ExeTextGetItalic( int nId, bool& bItl) ;
 
-// GeomDb Get Pocketing
-EXE_EXPORT bool ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId, int& nFirstId, int& nCrvCount) ;
-EXE_EXPORT int ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, bool bRemoveOverlapLink,int* pnCount) ;
-
 // GeomDb Curve Get
 EXE_EXPORT bool ExeCurveDomain( int nId, double* pdStart, double* pdEnd) ;
 EXE_EXPORT bool ExeCurveLength( int nId, double* pdLen) ;
@@ -717,12 +670,10 @@ EXE_EXPORT bool ExeSurfFrTestExternal( int nId1, int nId2, double dMinDist) ;
 EXE_EXPORT int  ExeSurfFrChunkCount( int nId) ;
 EXE_EXPORT int  ExeSurfFrChunkSimpleClassify( int nId1, int nChunk1, int nId2, int nChunk2, double dToler = 0) ;
 EXE_EXPORT int  ExeExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount) ;
-EXE_EXPORT int  ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, int* pnCount) ;
-EXE_EXPORT int  ExeSurfTmVertexCount( int nId) ;
-EXE_EXPORT int  ExeSurfTmFacetCount( int nId) ;
+EXE_EXPORT int  ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bStepCorrection, 
+                                          bool bInvert, int* pnCount) ;
 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 int  ExeSurfTmFacetCount( int nId) ;
 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,
@@ -732,22 +683,18 @@ EXE_EXPORT bool ExeSurfTmFacetNearestMidPoint( int nId, int nFacet, const Point3
 EXE_EXPORT bool ExeSurfTmFacetCenter( int nId, int nFacet, int nRefId, Point3d& ptCen, Vector3d& vtN) ;
 EXE_EXPORT bool ExeSurfTmFacetNormVersor( int nId, int nFacet, int nRefId, Vector3d& vtNorm) ;
 EXE_EXPORT bool ExeSurfTmFacetMinAreaRectangle( int nId, int nFacet, int nRefId, Frame3d& frRect, double& dDimX, double& dDimY) ;
-EXE_EXPORT bool ExeSurfTmFacetElevationInBBox( int nId, int nFacet, const BBox3d& b3Box, bool bAcceptOutFacet, int nRefId, double& dElev) ;
-EXE_EXPORT bool ExeSurfTmFacetElevationInClosedSurfTm( int nFacetStmId, int nFacet, int nClosedStmId, bool bAcceptOutFacet, double& dElev) ;
 EXE_EXPORT bool ExeSurfTmFacetOppositeSide( int nId, int nFacet, const Vector3d& vtDir, int nRefId,
                                             Point3d& ptP1, Point3d& ptP2) ;
 EXE_EXPORT bool ExeSurfTmFacetOppositeSideEx( int nId, int nFacet, const Vector3d& vtDir, int nRefId,
                                               Point3d& ptP1, Point3d& ptPm, Point3d& ptP2, Vector3d& vtIn1, Vector3d& vtOut2, double& dLen, double& dWidth) ;
 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  ExeGetSurfTmSilhouette( int nId, const Vector3d& vtDir, 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 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,
                                          Point3d& ptP, Vector3d& vtDerU, Vector3d& vtDerV) ;
@@ -818,32 +765,21 @@ EXE_EXPORT bool ExePointSurfTmDist( const Point3d& ptP, int nStmId, int nRefType
                                     double* pdDist, Point3d& ptMin, int* pnTria) ;
  
 // Geo Intersect
-EXE_EXPORT bool ExeLineCurveInters( const Point3d& ptP, const Vector3d& vtDir, const int nId, const int nRefType,
-                                    INTDBLVECTOR& vInters) ;
-EXE_EXPORT bool ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, const BBox3d& b3Box,
-                                  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,
-                                     int* pnCount) ;
+EXE_EXPORT bool ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, const BBox3d& b3Box, INTDBLVECTOR& vInters) ;
 EXE_EXPORT int  ExePlaneBoxInters( const Point3d& ptOn, const Vector3d& vtN, const BBox3d& b3Box, int nDestGrpId, int nRefType,
                                    int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
+EXE_EXPORT bool ExeLineSurfTmInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType, INTDBLVECTOR& vInters) ;
 EXE_EXPORT int  ExePlaneSurfTmInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType, double dToler,
                                       int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
-EXE_EXPORT int  ExeParPlanesSurfTmInters( const Point3d& ptOn, const Vector3d& vtN, const DBLVECTOR& vdDist, int nId, int nDestGrpId, int nRefType, double dToler,
-                                          int* pnGrpCount) ;
-EXE_EXPORT int  ExePlaneVolZmapInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType,
-                                       int* pnCount) ;
-EXE_EXPORT int  ExeCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId,
-                                     int* pnPntCount, int* pnCrvCount) ;
-EXE_EXPORT int  ExeCurveSurfTmInters( const int nCrvId, const int nStmId, const int nDestGrpId,
-                                      int* pnPntCount, int* pnCrvCount) ;
+EXE_EXPORT int ExeParPlanesSurfTmInters( const Point3d& ptOn, const Vector3d& vtN, const DBLVECTOR& vdDist, int nId, int nDestGrpId, int nRefType, double dToler,
+                                         int* pnGrpCount) ;
 EXE_EXPORT int  ExeSurfTmSurfTmInters( int nId1, int nId2, int nDestGrpId, double dToler,
                                        int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
+EXE_EXPORT int ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, const int nId, const int nDestGrpId, const int nRefType, int* pnCount) ;
+EXE_EXPORT int ExeCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId, int* pnPntCount, int* pnCrvCount) ;
+EXE_EXPORT bool ExeLineVolZmapInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType, INTDBLVECTOR& vInters) ;
+EXE_EXPORT int  ExePlaneVolZmapInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType,
+                                       int* pnCount) ;
 
 // Collision Detection
 EXE_EXPORT int  ExeCDeBoxSolid( const Frame3d& frBox, const Vector3d& vtDiag, int nSolidId, double dSafeDist, int nRefType) ;
@@ -853,17 +789,6 @@ EXE_EXPORT int  ExeCDeRectPrismoidSolid( const Frame3d& frPrismoid, double dBase
 EXE_EXPORT int  ExeCDeCylSolid( const Frame3d& frCyl, double dR, double dH, int nSolidId, double dSafeDist, int nRefType) ;
 EXE_EXPORT int  ExeCDeConeSolid( const Frame3d& frCone, double dR1, double dR2, double dH, int nSolidId, double dSafeDist, int nRefType) ;
 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) ;
@@ -939,7 +864,6 @@ EXE_EXPORT bool ExeCAvSetAdvTool( double dToolLen, double dToolDiam, double dTip
 EXE_EXPORT bool ExeCAvSetSawTool( double dToolLen, double dToolDiam, double dThickness, double dStemDiam, double dToolCornR) ;
 EXE_EXPORT bool ExeCAvSetGenTool( int nToolSectId) ;
 EXE_EXPORT int  ExeCAvGetToolOutline( int nDestGrpId, bool bApprox = false) ;
-EXE_EXPORT double ExeCAvToolPosBox( const Point3d& ptP, const Vector3d& vtAx, const BBox3d& b3Box, const Vector3d& vtMove) ;
 EXE_EXPORT double ExeCAvToolPosStm( const Point3d& ptP, const Vector3d& vtAx, int nSurfTmId, const Vector3d& vtMove, int nRefType) ;
 EXE_EXPORT bool ExeCAvToolPathStm( int nCrvId, const Vector3d& vtAx, int nSurfTmId, const Vector3d& vtMove, double dLinTol, int nRefType) ;
 
@@ -964,9 +888,7 @@ EXE_EXPORT int  ExeGetLastMachGroup( void) ;
 EXE_EXPORT int  ExeGetPrevMachGroup( int nId) ;
 EXE_EXPORT bool ExeGetMachGroupNewName( std::string& sName) ;
 EXE_EXPORT int  ExeAddMachGroup( const std::string& sName, const std::string& sMachineName) ;
-EXE_EXPORT int  ExeCopyMachGroup( const std::string& sSouName, const std::string& sName) ;
 EXE_EXPORT bool ExeRemoveMachGroup( int nMGroupId) ;
-EXE_EXPORT bool ExeChangeMachGroupName( int nId, const std::string& sNewName) ;
 EXE_EXPORT bool ExeGetMachGroupName( int nId, std::string& sName) ;
 EXE_EXPORT bool ExeGetMachGroupMachineName( int nId, std::string& sMachineName) ;
 EXE_EXPORT int  ExeGetMachGroupId( const std::string& sName) ;
@@ -1073,7 +995,6 @@ EXE_EXPORT bool ExeGetDefaultSetupName( std::string& sName) ;
 EXE_EXPORT bool ExeImportSetup( const std::string& sName) ;
 EXE_EXPORT bool ExeVerifyCurrSetup( STRVECTOR& vsErrors) ;
 EXE_EXPORT bool ExeFindToolInCurrSetup( const std::string& sTool) ;
-EXE_EXPORT bool ExeGetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) ;
 EXE_EXPORT bool ExeGetToolsInCurrSetupPos( const std::string& sTcPos, STRVECTOR& vsTools) ;
 EXE_EXPORT bool ExeUpdateCurrSetup( void) ;
 EXE_EXPORT bool ExeEraseCurrSetup( void) ;
@@ -1172,11 +1093,8 @@ EXE_EXPORT bool ExeUpdateAllMachinings( bool bStopOnFirstErr, std::string& sErrL
 EXE_EXPORT bool ExeUpdateAllMachiningsEx( bool bStopOnFirstErr, std::string& sErrList, std::string& sWarnList) ;
 // CL Entities Interrogations
 EXE_EXPORT bool ExeGetClEntMove( int nEntId, int& nMove) ;
-EXE_EXPORT bool ExeGetClEntFlag( int nEntId, int& nFlag, int& nFlag2) ;
+EXE_EXPORT bool ExeGetClEntFlag( int nEntId, int& nFlag) ;
 EXE_EXPORT bool ExeGetClEntIndex( int nEntId, int& nIndex) ;
-EXE_EXPORT bool ExeGetClEntAxesMask( int nEntId, int& nMask) ;
-EXE_EXPORT bool ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) ;
-
 // Simulation
 EXE_EXPORT bool ExeSimInit( void) ;
 EXE_EXPORT bool ExeSimStart( bool bFirst) ;
@@ -1205,16 +1123,13 @@ EXE_EXPORT bool ExeGetAxisType( const std::string& sAxis, bool& bLinear) ;
 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 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) ;
@@ -1259,8 +1174,6 @@ EXE_EXPORT bool ExeSetWinRectAttribs( bool bOutline, Color WrCol) ;
 EXE_EXPORT bool ExeSetGlobFrameShow( bool bShow) ;
 EXE_EXPORT bool ExeSetGridShow( bool bShowGrid, bool bShowFrame) ;
 EXE_EXPORT bool ExeSetGridGeo( double dSnapStep, int nMinLineSstep, int nMajLineSstep, int nExtSstep) ;
-EXE_EXPORT bool ExeSetGridGeoAdv( double dSnapStep, int nMinLineSstep, int nMajLineSstep,
-                                  double dXmin, double dXmax, double dYmin, double dYmax) ;
 EXE_EXPORT bool ExeSetGridColor( Color colMin, Color colMaj) ;
 EXE_EXPORT bool ExeResize( int nW, int nH) ;
 EXE_EXPORT bool ExeDraw( void) ;
@@ -1296,13 +1209,11 @@ EXE_EXPORT bool ExeResetGeoTria( bool bRedraw) ;
 EXE_EXPORT bool ExeSetWinRect( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw) ;
 EXE_EXPORT bool ExeResetWinRect( bool bRedraw) ;
 EXE_EXPORT bool ExeZoomWin( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw) ;
-EXE_EXPORT bool ExeSetViewOrizzOffsStep( int nDirOffsStep = 0) ;
 EXE_EXPORT bool ExeSetView( int nDir, bool bRedraw) ;
 EXE_EXPORT bool ExeSetGenericView( double dAngVertDeg, double dAngHorizDeg, bool bRedraw) ;
 EXE_EXPORT bool ExeSetViewCenter( const Point3d& ptP, bool bRedraw) ;
 EXE_EXPORT bool ExePanView( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw) ;
 EXE_EXPORT bool ExeRotateView( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw) ;
-EXE_EXPORT bool ExeGetViewOrizzOffsStep( int* pnDirOffsStep) ;
 EXE_EXPORT bool ExeGetView( int* pnDir) ;
 EXE_EXPORT bool ExeGetGenericView( double* pdAngVertDeg, double* pdAngHorizDeg) ;
 EXE_EXPORT bool ExeGetViewUp( Vector3d& vtUp) ;

EgtExecMgr.h

@@ -37,7 +37,7 @@ class ExecManager
              { return m_pExecMap.insert( std::pair< std::string, Exec>( sName, eFunc)).second ; }
 
       int Execute( T& Executor, const std::string& sCmd1, const std::string& sCmd2, const STRVECTOR& vsParams)
-             { const auto Iter = m_pExecMap.find( sCmd1) ;
+             { KeyExecMap::iterator Iter = m_pExecMap.find( sCmd1) ;
                if ( Iter != m_pExecMap.end()  &&  (Iter->second) != nullptr) {
                   if ( ( Executor.*(Iter->second))( sCmd2, vsParams))
                      return ER_OK ;

EgtFunPtrType.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech    2018-2023
+//  EgalTech    2018-2018
 //----------------------------------------------------------------------------
-// File : EgtFunPtrType.h      Data : 23.11.23          Versione : 2.5k5
+// File : EgtFunPtrType.h      Data : 19.07.18          Versione : 1.9g2
 // Contenuto : Dichiarazione tipi puntatori a funzione.
 //
 //
 //
 // Modifiche : 19.07.18 DS Creazione modulo.
-//             23.11.23 DS Aggiunta pfOnTerminateProcess.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -16,6 +16,5 @@
 #include <string>
 
 //----------------------------------------------------------------------------
-typedef bool (__stdcall * pfOnTerminateProcess) ( int) ;
-typedef int (__stdcall * pfProcEvents) ( int, int) ;
+typedef int (__stdcall * pfProcEvents) (int, int) ;
 typedef bool (__stdcall * pfOutText) ( const std::string&) ;

EgtKeyCodes.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2023
 //----------------------------------------------------------------------------
-// File : EgtKeyCodes.h       Data : 16.01.24        Versione : 2.6a1
+// File : EgtKeyCodes.h       Data : 01.01.23        Versione : 2.5a1
 // Contenuto : Costanti per codici di protezione librerie di base.
 //
 //
@@ -17,7 +17,6 @@
 //             01.01.21 DS Nuova gestione KEY_BASELIB_VER con versione prodotto e mese.
 //             01.01.22 DS Passaggio a versione 24.
 //             01.01.23 DS Passaggio a versione 25.
-//             16.01.24 DS Passaggio a versione 26.
 //
 //----------------------------------------------------------------------------
 
@@ -25,7 +24,7 @@
 
 //----------------------------------------------------------------------------
 const int KEY_BASELIB_PROD = 207 ;
-const int KEY_BASELIB_VER = 2604 ;
+const int KEY_BASELIB_VER = 2504 ;
 const int KEY_BASELIB_LEV = 1 ;
 
 //----------------------------------------------------------------------------

EgtLogger.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech    2013-2023
+//  EgalTech    2013-2013
 //----------------------------------------------------------------------------
-// File : EgtLogger.h      Data : 15.12.23          Versione : 2.5l3
+// File : EgtLogger.h      Data : 06.12.13          Versione : 1.4a4
 // Contenuto : Classi per logger.
 //
 //
 //
 // Modifiche : 06.12.13 DS Creazione modulo.
-//             15.12.23 DS Ora default è thread safe.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -76,7 +76,7 @@ namespace egtlogger
          } ;
 
       public :
-         Logger( LogLevel nLevel, const char* szName, bool bThreadSafe = true,
+         Logger( LogLevel nLevel, const char* szName, bool bThreadSafe = false,
                  int nLoggableItems = LI_DATETIME | LI_LOGGERNAME | LI_LOGGERLEVEL | LI_FUNCTION | LI_LINENUMBER) 
             : m_nLevel( nLevel), m_name( szName), m_threadProtect( bThreadSafe), m_loggableItem( nLoggableItems)
          {}
@@ -109,7 +109,8 @@ namespace egtlogger
          
          void ClearOutputStreams( void)
          {
-            for ( auto iter = m_outputStreams.cbegin() ; iter < m_outputStreams.cend() ; ++iter) {
+            std::vector<StreamInfo>::iterator iter ;
+            for ( iter = m_outputStreams.begin(); iter < m_outputStreams.end() ; ++iter) {
                if ( iter->bOwned)
                   delete iter->pStream ;
             }
@@ -126,7 +127,8 @@ namespace egtlogger
          {
             m_threadProtect.Lock() ;
 
-            for ( auto iter = m_outputStreams.cbegin() ; iter < m_outputStreams.cend() ; ++iter) {
+            std::vector<StreamInfo>::iterator iter ;
+            for ( iter = m_outputStreams.begin() ; iter < m_outputStreams.end() ; ++iter) {
                if ( nLevel < iter->nLevel)
                   continue ;
 

EgtNumUtils.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2016-2023
+//  EgalTech 2016-2018
 //----------------------------------------------------------------------------
-// File : EgtNumUtils.h       Data : 16.08.23         Versione : 2.5h2
+// File : EgtNumUtils.h       Data : 05.11.16         Versione : 1.6w1
 // Contenuto : Funzioni numeriche di base.       
 //
 //
@@ -17,14 +17,14 @@
 inline
 int Clamp( int nVal, int nMin, int nMax)
 {
-   return ( nVal < nMin ? nMin : ( nVal > nMax ? nMax : nVal)) ;
+   return ( nVal < nMin ? nMin : nMax < nVal ? nMax : nVal) ;
 }
 
 //----------------------------------------------------------------------------
 inline
 double Clamp( double dVal, double dMin, double dMax)
 {
-   return ( dVal < dMin ? dMin : ( dVal > dMax ? dMax : dVal)) ;
+   return ( dVal < dMin ? dMin : dMax < dVal ? dMax : dVal) ;
 }
 
 //----------------------------------------------------------------------------

SELkKeyProc.h

@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2024
+//  EgalTech 2014-2015
 //----------------------------------------------------------------------------
-// File : SELkKeyProc.h           Data : 25.01.24          Versione : 2.6a1
+// File : SELkKeyProc.h           Data : 27.07.15          Versione : 1.6g1
 // Contenuto : Dichiarazione funzioni per la gestione della chiave.
 //
 //
 //
 // Modifiche : 10.09.14 DS Creazione modulo.
 //             27.02.15 DS Agg. gestione chiavi hardware OxySec.
-//             25.01.24 DS Agg. GetKeyLevelEx per scadenza assistenza.
 //
 //----------------------------------------------------------------------------
 
@@ -26,12 +25,9 @@ bool ReadKey( const std::string& sKey, const std::string& sScramKey,
 int VerifyKey( const std::string& sKey, int nProd, int nVer, int nLev) ;
 int GetKeyLevel( const std::string& sKey, int nProd, int nVer, int nLev,
                  int& nKLev, int& nKExpDays) ;
-int GetKeyLevelEx( const std::string& sKey, int nProd, int nVer, int nLev,
-                   int& nKLev, int& nKExpDays, int& nKAssExpDays) ;
 int GetKeyOptions( const std::string& sKey, int nProd, int nVer, int nLev,
                    unsigned int& nKOpt1, unsigned int& nKOpt2, int& nKOptExpDays) ;
 int GetCurrDay( void) ;
-int GetMinDay( void) ;
 
 //-------------------------- Constants ----------------------------------------
 // Codici di ritorno
@@ -44,4 +40,3 @@ 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

@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2022
 //----------------------------------------------------------------------------
-// File : SELkLockId.cpp       Data : 30.05.23          Versione : 2.5e5
+// File : SELkLockId.cpp       Data : 16.05.22          Versione : 2.4e3
 // Contenuto : Dichiarazione funzioni per gestione/calcolo Id protezione,
 //             da macchina o da chiave hardware.
 //
 //
 // Modifiche : 10.09.14 DS Creazione modulo.
 //             16.05.22 DS Aggiunta gestione chiave di rete.
-//             30.05.23 DS Aggiunta gestione utente di rete e rilascio chiave di rete.
 //
 //----------------------------------------------------------------------------
 
@@ -17,14 +16,10 @@
 #include <string>
 
 //-------------------------------------------------------------------------------
-// Imposto il tipo di protezione ammessa (ANY, HW, SW)
+// Imposto il tipo di protezione
 bool SetLockType( int nType) ;
-// Imposto chiave di rete, identificativo utente (0-9) e indirizzo
-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) ;
+// Forzo chiave di rete (se prevista protezione hardware)
+bool SetNetHwKey( bool bNetHwKey) ;
 // Recupero l'identificativo in chiaro della protezione
 bool GetLockId( std::string& sLockId) ;
 // Recupero l'identificativo cifrato della protezione