Include :

- altra prova commit.
Include :
2022-06-06 10:51:02 +02:00 · 2022-06-06 10:47:54 +02:00
167 changed files with 830 additions and 5166 deletions
@@ -1,57 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2025
-//----------------------------------------------------------------------------
-// File : EBsAPI.h            Data : 24.01.25            Versione : 2.7a1
-// Contenuto : API (application programming interface).
-//
-//
-//
-// Modifiche : 05.10.24 DS Creazione modulo.
-//             24.01.25 DS Aggiunta gestione messaggi.
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#define NOMINMAX
-#include <windows.h>
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGTBASIS_EXPORT
-#if defined( I_AM_EGTBASIS)            // da definirsi solo nella DLL
-   #define EGTBASIS_EXPORT __declspec( dllexport)
-#else
-   #define EGTBASIS_EXPORT __declspec( dllimport)
-#endif
-
-//-----------------------------------------------------------------------------
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// API
-// Protezione
-EGTBASIS_EXPORT BOOL __stdcall EgtSetKey( const wchar_t* wsKey) ;
-EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyLevel( int nProd, int nVer, int nLev, int* pnKLev) ;
-EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyOptions( int nProd, int nVer, int nLev, unsigned int* pnOpt1, unsigned int* pnOpt2) ;
-EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyLeftDays( int* pnLeftDays) ;
-EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyAssLeftDays( int* pnAssLeftDays) ;
-EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyOptLeftDays( int* pnOptLeftDays) ;
-// Liberazione memoria blocchi dati ritornati (di solito per stringhe)
-EGTBASIS_EXPORT BOOL __stdcall EgtFreeMemory( void* pMem) ;
-// Messaggi
-EGTBASIS_EXPORT BOOL __stdcall EgtLoadMessages( const wchar_t* wsMsgFilePath) ;
-EGTBASIS_EXPORT const wchar_t* __stdcall EgtGetMsg( int nMsg) ;
-// Logger
-EGTBASIS_EXPORT BOOL __stdcall EgtInitLogger( int nDebug, const wchar_t* wsLogFile) ;
-EGTBASIS_EXPORT BOOL __stdcall EgtOutLog( const wchar_t* wsMsg, int nDebugLevel) ;
-
-// Ini File
-EGTBASIS_EXPORT BOOL __stdcall EgtGetStringUtf8FromIni( const wchar_t* wsSec, const wchar_t* wsKey,
-                                                        const wchar_t* wsDef, wchar_t*& wsVal, const wchar_t* wsIniFile) ;
-EGTBASIS_EXPORT BOOL __stdcall EgtWriteStringUtf8ToIni( const wchar_t* wsSec, const wchar_t* wsKey,
-                                                        const wchar_t* wsVal, const wchar_t* wsIniFile) ;
-
-#ifdef __cplusplus
-}
-#endif
@@ -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 ;
-}
@@ -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) ;
-}
@@ -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) ;
-}
@@ -1,27 +1,23 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2026
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EExBeamConst.h          Data : 23.01.26          Versione : 3.1a2
+// File : EExBeamConst.h          Data : 30.08.20          Versione : 2.2i1
 // Contenuto : Dichiarazione delle costanti per travi e pareti con BTL.
 //
 //
 //
 // Modifiche : 30.08.20 DS Creazione modulo.
-//             04.04.22 DS Aggiunto EIBFLAG_TRIM_WITH_OUTLINE.
-//             23.01.26 DS Aggiunto EIBFLAG_PARTOFFSET.
+//
 //
 //----------------------------------------------------------------------------

 #pragma once

 //-----------------------------------------------------------------------------
-enum EImBtlFlag { EIBFLAG_NONE =              0x0000,
-                  EIBFLAG_FLAT_POS =          0x0001,         // pezzi di piatto (prevale sul successivo)
-                  EIBFLAG_VERT_POS =          0x0002,         // pezzi in verticale
-                  EIBFLAG_SPECIAL_TRIM =      0x0004,         // trim speciale per pareti
-                  EIBFLAG_TS3_POS =           0x0008,         // pezzi come in TechnoEssetre (prevale sui precedenti POS)
-                  EIBFLAG_SORT =              0x0010,         // ordina i pezzi nel DB in base al nome
-                  EIBFLAG_USEUATTR =          0x0020,         // utilizza i parametri utente U per modificare la geometria delle features
-                  EIBFLAG_OUTL_FLAT_POS =     0x0040,         // pezzi secondo outline o di piatto (prevale sui precedenti POS)
-                  EIBFLAG_TRIM_WITH_OUTLINE = 0x0080,         // esegui il trim delle feature con l'outline (se presente)
-                  EIBFLAG_PARTOFFSET =        0x0100} ;       // gestione geometrica del PARTOFFSET
+enum EImBtlFlag { EIBFLAG_NONE =          0x0000,
+                  EIBFLAG_FLAT_POS =      0x0001,             // pezzi di piatto (prevale sul successivo)
+                  EIBFLAG_VERT_POS =      0x0002,             // pezzi in verticale
+                  EIBFLAG_SPECIAL_TRIM =  0x0004,             // trim speciale per pareti
+                  EIBFLAG_TS3_POS =       0x0008,             // pezzi come in TechnoEssetre (prevale sui precedenti POS)
+                  EIBFLAG_SORT =          0x0010,             // ordina i pezzi nel DB in base al nome
+                  EIBFLAG_USEUATTR =      0x0020} ;           // utilizza i parametri utente U per modificare la geometria delle features
@@ -1,22 +1,20 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2022
+//  EgalTech 2020-2021
 //----------------------------------------------------------------------------
-// File : EExBeamMgr.h          Data : 06.07.22          Versione : 2.4g2
+// File : EExBeamMgr.h          Data : 01.06.21          Versione : 2.2f1
 // Contenuto : Dichiarazione della interfaccia IBeamMgr.
 //
 //
 //
 // Modifiche : 30.08.20 DS Creazione modulo.
 //             01.06.21 DS Aggiunti parametri vsUAtt per Process.
-//             06.07.22 DS Aggiunta GetSideData.
 //
 //----------------------------------------------------------------------------

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include "/EgtDev/Include/EExBeamConst.h"
-#include "/EgtDev/Include/EgtFunPtrType.h"
 #include <string>

 //----------------------- Macro per import/export ----------------------------
@@ -34,7 +32,6 @@ class __declspec( novtable) IBeamMgr
      virtual ~IBeamMgr( void) {} 

      virtual bool Init( IGeomDB* pGDB, int nFlag = 0) = 0 ;
-      virtual bool SetFlag( int nFlag) = 0 ;
      virtual int  CreatePart( void) = 0 ;
      virtual bool SetPart( int nPartId) = 0 ;
      virtual bool ErasePart( void) = 0 ;
@@ -43,24 +40,17 @@ class __declspec( novtable) IBeamMgr
      virtual bool SetPartName( const std::string& sName) = 0 ;
      virtual bool SetPartCount( int nCount) = 0 ;
      virtual bool SetPartBox( double dLength, double dHeight, double dWidth, bool bUpdate = true) = 0 ;
-      virtual bool GetSideData( int nSide, Frame3d& frRef, double& dLength, double& dWidth, double& dHeight) = 0 ;
-      virtual bool ShowFacesName( bool bShow) = 0 ;
-      virtual bool ShowLoadingSide( bool bShow, bool bFromLeft) = 0 ;
      virtual int  AddProcess( int nGroup, int nProc, int nSide, const std::string& sDes, int nProcId,
-                               const Frame3d& frRef, const DBLVECTOR& vdPar, const std::string& sPar, const STRVECTOR& vsUAtt,
-                               int nCrvId, int nCrv2Id, bool bUpdate = true) = 0 ;
+                               const Frame3d& frRef, const DBLVECTOR& vdPar, const std::string& sPar, const STRVECTOR& vsUAtt, bool bUpdate = true) = 0 ;
      virtual int  ModifyProcess( int nGeomId, int nGroup, int nProc, int nSide, const std::string& sDes, int nProcId,
-                                  const Frame3d& frRef, const DBLVECTOR& vdPar, const std::string& sPar, const STRVECTOR& vsUAtt,
-                                  int nCrvId, int nCrv2Id, bool bUpdate = true) = 0 ;
+                                  const Frame3d& frRef, const DBLVECTOR& vdPar, const std::string& sPar, const STRVECTOR& vsUAtt, bool bUpdate = true) = 0 ;
      virtual bool EraseProcess( int nGeomId, bool bUpdate = true) = 0 ;
      virtual bool EnableProcess( int nGeomId, bool bEnable, bool bUpdate = true) = 0 ;
-      virtual bool CalcAllSolids( bool bShow, bool bRecalc, pcfProcEvents pFun = nullptr) = 0 ;
-      virtual bool ShowAllSolids( bool bShow, pcfProcEvents pFun = nullptr) = 0 ;
      virtual bool CalcSolid( int nPartId, bool bRecalc = false) = 0 ;
      virtual int  GetSolid( int nPartId) const = 0 ;
      virtual bool ShowSolid( int nPartId, bool bShow) = 0 ;
-      virtual bool GetBuildingIsOn( int nAssGrpId) const = 0 ;
-      virtual bool ShowBuilding( int nAssGrpId, bool bShow) = 0 ;
+      virtual bool GetBuildingIsOn( void) const = 0 ;
+      virtual bool ShowBuilding( bool bShow) = 0 ;

 } ;

@@ -34,8 +34,6 @@ extern "C" {
   EEX_EXPORT void SetEExLogger( ILogger* pLogger) ;
   // imposta la chiave di protezione
   EEX_EXPORT void SetEExKey( const std::string& sKey) ;
-   // imposta se chiave hardware di rete
-   EEX_EXPORT void SetEExNetHwKey( bool bNetHwKey) ;
 }


@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGnCmdExecutor.h"
+#include "/EgtDev/Include/EgnCmdExecutor.h"

 class IGeomDB ;

@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include "/EgtDev/Include/EExExportConst.h"
 #include <string>

@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include "/EgtDev/Include/EExExportConst.h"
 #include <string>

@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include "/EgtDev/Include/EExExportConst.h"
 #include <string>

@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include "/EgtDev/Include/EExExportConst.h"
 #include <string>

@@ -1,42 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2022-2022
-//----------------------------------------------------------------------------
-// File : EExExportThreeJS.h         Data : 22.10.22         Versione : 2.4j1
-// Contenuto : Dichiarazione della interfaccia IExportStl.
-//
-//
-//
-// Modifiche : 22.10.22 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkGeomDB.h"
-#include "/EgtDev/Include/EExExportConst.h"
-#include <string>
-#include "/EgtDev/Include/EGrScene.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EEK_EXPORT
-#if defined( I_AM_EEX)            // da definirsi solo nella DLL
-#define EEX_EXPORT __declspec( dllexport)
-#else
-#define EEX_EXPORT __declspec( dllimport)
-#endif
-
-//-----------------------------------------------------------------------------
-class __declspec( novtable) IExportThreeJS
-{
-public:
-    virtual ~IExportThreeJS( void) {}
-    virtual bool SetOptions( int nFilter) = 0 ;
-    virtual bool Export( IGeomDB* pGDB, int nId, IEGrScene* pScene, bool bUdm, const std::string& sFile) = 0 ;
-} ;
-
-//-----------------------------------------------------------------------------
-extern "C" {
-    EEX_EXPORT bool SetThreeJSLibDir( const std::string& sThreeJSLibDir) ;
-    EEX_EXPORT IExportThreeJS* CreateExportThreeJS( void) ;
-}
@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include <string>

 //----------------------- Macro per import/export ----------------------------
@@ -29,13 +29,10 @@ class __declspec( novtable) IImport3MF
 {
   public :
      virtual ~IImport3MF( void) {} 
-      virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup, int nFlag = 0) = 0 ;
+      virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup) = 0 ;
 } ;

 //-----------------------------------------------------------------------------
 extern "C" {
   EEX_EXPORT IImport3MF* CreateImport3MF( void) ;
 }
-
-enum EIm3MFFlag { EI3FLAG_NONE =          0x0000,
-                  EI3FLAG_KEEP_GROUPS =   0x0001} ;
@@ -37,6 +37,5 @@ class __declspec( novtable) IImportBtl
 //-----------------------------------------------------------------------------
 extern "C" {
   EEX_EXPORT bool SetBtlAuxDir( const std::string& sBtlAuxDir) ;
-   EEX_EXPORT bool SetBtlLuaData( const std::string& sLuaLibsDir, const std::string& sLuaLastRequire) ;
   EEX_EXPORT IImportBtl* CreateImportBtl( void) ;
 }
@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include <string>

 //----------------------- Macro per import/export ----------------------------
@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include <string>

 //----------------------- Macro per import/export ----------------------------
@@ -14,7 +14,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include <string>


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

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include <string>

 //----------------------- Macro per import/export ----------------------------
@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
 #include <string>

 //----------------------- Macro per import/export ----------------------------
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : EGkAngle.h           Data : 10.02.23          Versione : 2.5b1
+// File : EGkAngle.h           Data : 14.07.14          Versione : 1.5g2
 // Contenuto : Dichiarazione funzioni per gestione angoli.
 //
 //
@@ -27,6 +27,3 @@ EGK_EXPORT double AngleNearAngle( double dAngDeg, double dAngRefDeg) ;
 EGK_EXPORT double DiffAngle( double dAng1Deg, double dAng2Deg) ;
 EGK_EXPORT double MediaAngle( double dAng1Deg, double dAng2Deg, double dCoeff) ;
 EGK_EXPORT bool AngleInSpan( double dAngDeg, double dAngRefDeg, double dAngSpanDeg) ;
-EGK_EXPORT bool AngleInRange( double dAngDeg, double dAngMinDeg, double dAngMaxDeg) ;
-EGK_EXPORT bool AdjustAngleInSpan( double& dAngDeg, double dAngRefDeg, double dAngSpanDeg) ;
-EGK_EXPORT bool AdjustAngleInRange( double& dAngDeg, double dAngMinDeg, double dAngMaxDeg) ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : EGkArcCenTgCurvePnt.h       Data : 15.03.15       Versione : 1.6c2
+// File : EgkArcCenTgCurvePnt.h       Data : 15.03.15       Versione : 1.6c2
 // Contenuto : Dichiarazione funzioni per calcolo arco dati centro,
 //             tangente a curva e punto vicino a finale.
 //
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : EGkArcPntDirTgCurve.h       Data : 13.03.15       Versione : 1.6c2
+// File : EgkArcPntDirTgCurve.h       Data : 13.03.15       Versione : 1.6c2
 // Contenuto : Dichiarazione funzioni per calcolo arco dato punto iniziale
 //             direzione e tangente a curva.
 //
@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2015
 //----------------------------------------------------------------------------
-// File : EGkArcSpecial.h       Data : 04.08.23         Versione : 2.5h1
+// File : EGkArcSpecial.h       Data : 15.03.15         Versione : 1.6c2
 // 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,4 @@
 //----------------------------------------------------------------------------
 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) ;
@@ -1,22 +1,19 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2023
+//  EgalTech 2013-2014
 //----------------------------------------------------------------------------
-// File : EGkBBox3d.h              Data : 12.05.23          Versione : 2.5e3
+// File : EGkBBox3d.h              Data : 14.01.14          Versione : 1.5a4
 // 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.
+//
 //
 //----------------------------------------------------------------------------

 #pragma once

-#include "/EgtDev/Include/EGkPoint3d.h"
-#include "/EgtDev/Include/EGkFrame3d.h"
-#include <vector>
+#include "/EgtDev/Include/EGKPoint3d.h"

 //----------------------- Macro per import/export ----------------------------
 #undef EGK_EXPORT
@@ -49,7 +46,7 @@ class EGK_EXPORT BBox3d
              { m_ptMin = Point3d( +INFINITO, +INFINITO, +INFINITO) ;
                m_ptMax = Point3d( -INFINITO, -INFINITO, -INFINITO) ; }
      void Set( const Point3d& ptP)
-               { m_ptMin = ptP ; m_ptMax = ptP ; }
+              { m_ptMin = ptP ; m_ptMax = ptP ; }
      void Set( double dX, double dY, double dZ)
              { m_ptMin = Point3d( dX, dY, dZ) ; m_ptMax = m_ptMin ; }
      void Set( const Point3d& ptP1, const Point3d& ptP2) ;
@@ -67,8 +64,6 @@ class EGK_EXPORT BBox3d
      void Add( const Point3d& ptP) ;
      void Add( double dX, double dY, double dZ) ;
      void Add( const BBox3d& b3B) ;
-      void Add( const std::vector<Point3d>& vPnt) { for ( const Point3d& pt: vPnt){
-                                                         Add( pt) ; }}
      void Expand( double dDelta) ;
      void Expand( double dDeltaX, double dDeltaY, double dDeltaZ) ;
      const Point3d& GetMin( void) const
@@ -77,9 +72,6 @@ class EGK_EXPORT BBox3d
              { return m_ptMax ; }
      bool GetMinMax( Point3d& ptMin, Point3d& ptMax) const ;
      bool GetMinDim( Point3d& ptMin, double& dDimX, double& dDimY, double& dDimZ) const ;
-      double GetDimX( void) const ;
-      double GetDimY( void) const ;
-      double GetDimZ( void) const ;
      bool GetCenterExtent( Point3d& ptCenter, Vector3d& vtExtent) const ;
      bool GetCenter( Point3d& ptCenter) const ;
      bool GetRadius( double& dRad) const ;
@@ -94,11 +86,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
@@ -131,42 +122,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 ;
-}
-
-//----------------------------------------------------------------------------
-inline bool Overlaps( const BBox3d& bbA, const Frame3d& frA, const BBox3d& bbB, const Frame3d& frB)
-{
-   return bbA.Overlaps( GetToLoc( frB, frA), bbB) ;
-}
@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EgkCurve.h"

 //----------------------- Macro per import/export ----------------------------
 #undef EGK_EXPORT
@@ -1,42 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EGkCAvSilhouetteSurfTm.h      Data : 08.06.24      Versione : 2.6f2
-// Contenuto : Dichiarazione della funzione calcolo silhouette.
-//
-//
-//
-// Modifiche : 08.06.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkSurfTriMesh.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
- 
-//-----------------------------------------------------------------------------
-EGK_EXPORT bool CAvSilhouetteSurfTm( const ISurfTriMesh& Stm, const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL) ;
-
-//-----------------------------------------------------------------------------
-class __declspec( novtable) ICAvParSilhouettesSurfTm
-{
-   public :
-      virtual ~ICAvParSilhouettesSurfTm( void) {}
-      virtual bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol) = 0 ;
-      virtual bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol,
-                            double dSideAng, double dDiam, double dCornRad, double dMaxMat, double dOffsR,
-                            double dMaxDepth) = 0 ;
-      virtual bool GetSilhouette( double dLevel, POLYLINEVECTOR& vPL) = 0 ;
-} ;
-
-//-----------------------------------------------------------------------------
-EGK_EXPORT ICAvParSilhouettesSurfTm* CreateCAvParSilhouettesSurfTm( void) ;
@@ -35,27 +35,20 @@ const int SCI_LINE_LINE = 4 ;             // tra linea di mobile e linea di fiss
 struct SCollInfo
 {
   int nType ;                    // tipo di collisione
-
   int nChunkM ;                  // indice del chunk della regione mobile
-   int nLoopM ;                   // indice del loop del chunk della regione mobile
-   int nCrvM ;                    // indice della curva nel loop del chunk
-
+   int nCrvM ;                    // indice della curva nel loop esterno del chunk
   int nChunkF ;                  // indice del chunk della regione fissa
-   int nLoopF ;                   // indice del loop del chunk della regione fissa
-   int nCrvF ;                    // indice della curva nel loop del chunk
-
+   int nCrvF ;                    // indice della curva nel loop esterno del chunk
   Point3d ptP1 ;                 // punto di contatto
   Point3d ptP2 ;                 // se contatto linea-linea, secondo punto di contatto
   Vector3d vtDirM ;              // se contatto del mobile con linea, sua direzione
   Vector3d vtDirF ;              // se contatto del fisso con linea, sua direzione
-
   // costruttori
-   SCollInfo() : nType( SCI_NONE), nChunkM( -1), nLoopM( -1), nCrvM( -1), nChunkF( -1), nLoopF( -1), nCrvF( -1),
+   SCollInfo() : nType( SCI_NONE), nChunkM( -1), nCrvM( -1), nChunkF( -1), nCrvF( -1),
                 ptP1(), ptP2(), vtDirM(), vtDirF() {}
-   SCollInfo( const SCollInfo& Sou) : nType( Sou.nType),
-                                      nChunkM( Sou.nChunkM), nLoopM( Sou.nLoopM), nCrvM( Sou.nCrvM),
-                                      nChunkF( Sou.nChunkF), nLoopF( Sou.nLoopF), nCrvF( Sou.nCrvF),
-                                      ptP1( Sou.ptP1), ptP2( Sou.ptP2), vtDirM( Sou.vtDirM), vtDirF( Sou.vtDirF) {}
+   SCollInfo( const SCollInfo& Sou) : nType( Sou.nType), nChunkM( Sou.nChunkM), nCrvM( Sou.nCrvM),
+                                      nChunkF( Sou.nChunkF), nCrvF( Sou.nCrvF), ptP1( Sou.ptP1),
+                                      ptP2( Sou.ptP2), vtDirM( Sou.vtDirM), vtDirF( Sou.vtDirF) {} 
 } ;

 //----------------------------------------------------------------------------
@@ -74,4 +67,4 @@ class CAvSimpleSurfFrMove
      const ISurfFlatRegion* m_pRegM ;
      const ISurfFlatRegion* m_pRegF ;
      SCollInfo m_SCollInfo ;
-} ;
+} ;
@@ -1,41 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2015-2018
-//----------------------------------------------------------------------------
-// File : EGkCAvSurfFrMove.h      Data : 26.03.2026    Versione : 3.1c7
-// Contenuto : Dichiarazione classe per movimento di superfici flat region
-//             nel loro piano evitando collisioni
-//
-// Modifiche : 26.03.26 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkCAvSimpleSurfFrMove.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
-
-//----------------------------------------------------------------------------
-class CAvSurfFrMove
-{
-   public :
-      EGK_EXPORT CAvSurfFrMove( const ISurfFlatRegion& SfrM, const ISurfFlatRegion& SfrF) ;
-
-   public :
-      EGK_EXPORT bool Translate( const Vector3d& vtDir, double& dLen) ;
-      EGK_EXPORT bool Rotate( const Point3d& ptCen, double& dAng) ;
-      EGK_EXPORT const SCollInfo& GetCollInfo()
-                           { return m_CollInfo ; }
-
-   private :
-      const ISurfFlatRegion* m_pRegM ;
-      const ISurfFlatRegion* m_pRegF ;
-      SCollInfo m_CollInfo ;
-} ;
@@ -23,8 +23,6 @@
   #define EGK_EXPORT __declspec( dllimport)
 #endif

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

 //-----------------------------------------------------------------------------
@@ -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) ;
@@ -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,16 +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.
-// Se richiesta verifica inclusione se una delle due è chiusa controlla l'inclusione dell'altra. 
-//----------------------------------------------------------------------------
-EGK_EXPORT bool TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist, bool bTestEnclosion = false) ;
+EGK_EXPORT bool CDeClosedSurfTmClosedSurfTm( const SurfTriMesh& SurfA, const SurfTriMesh& SurfB, double dSafeDist) ;
@@ -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) ;
@@ -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) ;
@@ -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) ;
@@ -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) ;
@@ -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) ;
@@ -1,99 +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
-
-//-----------------------------------------------------------------------------
-// Per calcolo percorso di Svuotatura o di Lucidatura
-EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadialOffs, double dStep,
-                               double dAngle, double dOpenMinSafe, int nType, bool bSmooth, bool bCalcUnclReg, bool bInvert, bool bAvoidOpt,
-                               bool bConventionalMilling, bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec,
-                               const ISurfFlatRegion* pSfrLimit, bool bAllOffs, double dMaxOptSize,
-                               int nLiType, double dLiTang, double dLiElev, int nLoType, double dLoTang,
-                               bool bPolishing, double dEpicyclesRad, double dEpicyclesDist, ICRVCOMPOPOVECTOR& vCrv) ;
-EGK_EXPORT bool IsPocketingHole( const ISurfFlatRegion* pSfr, double dRad, double dRadialOffs, double dStep, int nType,
-                                 int nLiType, double dLiTang, double dRatioSfrTool) ;
-EGK_EXPORT bool CalcSmoothCurve( ICurveComposite* pCrv, double dRightLen, double dLeftLen, bool bAsParam) ;
-EGK_EXPORT bool CalcZigZagInfill( const ISurfFlatRegion* pSfr, double dStep, bool bSmooth, bool bRemoveOverlapLink,
-                                  ICRVCOMPOPOVECTOR& vCrvCompoRes) ;
-
-//-----------------------------------------------------------------------------
-// Sottotipo di lavorazione
-enum { POCKET_ZIGZAG = 0,
-       POCKET_ONEWAY = 1,
-       POCKET_SPIRALIN = 2,
-       POCKET_SPIRALOUT = 3,
-       POCKET_CONFORMAL_ZIGZAG = 4,
-       POCKET_CONFORMAL_ONEWAY = 5
-} ;
-
-// Definizione di lato aperto e lato chiuso
-enum {
-   TEMP_PROP_CLOSE_EDGE = 0,
-   TEMP_PROP_OPEN_EDGE = 1,
-   TEMP_PROP_OPEN_EDGE_IN_RAW = 2
-} ;
-
-// Definizione di curva invalida
-enum {
-   TEMP_PROP_INVALID = - 1
-} ;
-
-// Definizione curva di raccordo per smussi
-enum {
-   TEMP_PROP_SMOOTH = - 2
-} ;
-
-// Definizione tipo di curva per casi speciali
-enum {
-   TEMP_PROP_SINGLE_CURVE = - 3,
-   TEMP_PROP_OPT_TRAPEZOID = - 4,
-   TEMP_PROP_BORDER_CURVE =  - 5,
-   TEMP_PROP_OPT_CIRCLE = - 9
-} ;
-
-// Definizione tipo di curva per entrate da fuori
-enum {
-   TEMP_PROP_OUT_START = - 6
-} ;
-
-// Definizione di curva attiva/non attiva
-enum {
-   TEMP_PROP_CURVE_ACTIVE = - 7,
-   TEMP_PROP_CURVE_INACTIVE = - 8
-} ;
-
-// Definizione tipo LeadIn
-enum {
-   LEAD_IN_NONE = 0,
-   LEAD_IN_GLIDE = 1,
-   LEAD_IN_ZIGZAG = 2,
-   LEAD_IN_HELIX = 3
-} ;
-
-// Definizione tipo LeadOut
-enum {
-   LEAD_OUT_NONE = 0,
-   LEAD_OUT_GLIDE = 1
-} ;
@@ -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 ;
@@ -1,28 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2022-202
-//----------------------------------------------------------------------------
-// File : EGkCircle2Pe.h       Data : 18.08.22       Versione : 2.4h2
-// Contenuto : Dichiarazione funzioni per calcolo circonferenze per 2 punti
-//             diametrali.
-//
-//
-// Modifiche : 18.08.22 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkCurveArc.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 ICurveArc* GetCircle2P( const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtN) ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : EGkCircleCenTgCurve.h       Data : 12.03.15       Versione : 1.6c2
+// File : EgkCircleCenTgCurve.h       Data : 12.03.15       Versione : 1.6c2
 // Contenuto : Dichiarazione funzioni per calcolo circonferenze di centro
 //             dato tangenti a curve.
 //
@@ -60,10 +60,6 @@ class Color
            { m_Col[ALPHA] = (( nAlpha < 0) ? 0 : (( nAlpha > MAX_ALPHA) ? MAX_ALPHA : nAlpha)) ; }
      void SetAlpha( double dAlpha)
            { m_Col[ALPHA] = (( dAlpha < 0) ? 0 : (( dAlpha > 1) ? MAX_ALPHA : int( lround( dAlpha * MAX_ALPHA)))) ; }
-      void Intensify( double dCoeff)
-            { Set( int( m_Col[RED] * dCoeff), int( m_Col[GREEN] * dCoeff), int( m_Col[BLUE] * dCoeff), m_Col[ALPHA]) ;
-              if ( dCoeff > 1  &&  m_Col[RED] < 64  &&  m_Col[GREEN] < 64  &&  m_Col[BLUE] < 64)
-                 Set( 64, 64, 64, m_Col[ALPHA]) ; }
      int GetIntRed( void) const
            { return m_Col[RED] ; }
      int GetIntGreen( void) const
@@ -108,7 +104,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) ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : EGkCurve.h         Data : 06.05.14          Versione : 1.5e3
+// File : EgkCurve.h         Data : 06.05.14          Versione : 1.5e3
 // Contenuto : Dichiarazione della interfaccia ICurve.
 //
 //
@@ -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
@@ -80,7 +79,7 @@ class __declspec( novtable) ICurve : public IGeoObj
      virtual bool ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) const = 0 ;
      virtual ICurve* CopyParamRange( double dUStart, double dUEnd) const = 0 ;
      virtual bool Invert( void) = 0 ;
-      virtual bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) = 0 ;
+      virtual bool SimpleOffset( double dDist, int nType = OFF_FILLET) = 0 ;
      virtual bool SetExtrusion( const Vector3d& vtExtr) = 0 ;
      virtual bool SetThickness( double dThick) = 0 ;
      virtual bool ModifyStart( const Point3d& ptNewStart) = 0 ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : EGkCurveArc.h       Data : 22.11.13          Versione : 1.3a1
+// File : EgkCurveArc.h       Data : 22.11.13          Versione : 1.3a1
 // Contenuto : Dichiarazione della interfaccia ICurveArc.
 //
 //
@@ -55,7 +55,7 @@ class __declspec( novtable) ICurveArc : public ICurve
      virtual bool ChangeDeltaN( double dNewDeltaN) = 0 ;
      virtual bool ChangeAngCenter( double dNewAngCenDeg) = 0 ;
      virtual bool ChangeStartPoint( double dU) = 0 ;
-      virtual bool ExtendedOffset( double dDist) = 0 ;
+      virtual bool ExtendedOffset( double dDist, int nType = OFF_FILLET) = 0 ;
      virtual bool ToExplementary( void) = 0 ;
      virtual bool Flip( void) = 0 ;
 } ;
@@ -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.
 //
 //
@@ -15,10 +15,6 @@

 #include "/EgtDev/Include/EGkCurveComposite.h"

-class ICurveBezier ;
-class ICurveLine ;
-class ICurveArc ;
-class ICurveComposite ;

 //----------------------- Macro per import/export ----------------------------
 #undef EGK_EXPORT
@@ -36,65 +32,17 @@ 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 una curva in una nuova curva di Bezier semplice
-EGK_EXPORT ICurve* CurveToBezierCurve( const ICurve* pCrv, int nDeg = 3, bool bMakeRatOrNot = false) ;
-
-//----------------------------------------------------------------------------
-//! Trasforma una linea in una nuova curva di Bezier semplice
-EGK_EXPORT ICurveBezier* LineToBezierCurve( const ICurveLine* pCrvLine, int nDeg = 3, bool bMakeRatOrNot = false) ;
-
 //----------------------------------------------------------------------------
 //! Trasforma un arco in una nuova curva di Bezier semplice o composta
-EGK_EXPORT ICurve* ArcToBezierCurve( const ICurveArc* pArc, int nDeg = 3, bool bMakeRatOrNot = true) ;
-
-//----------------------------------------------------------------------------
-//! Trasforma una curva compo in una nuova curva di Bezier semplice o composta
-EGK_EXPORT ICurve* CompositeToBezierCurve( const ICurveComposite* pCrv, int nDeg = 3, bool bMakeRatOrNot = false) ;
-
-//----------------------------------------------------------------------------
-//! Trasforma una curva bezier in una nuova curva di Bezier semplice o composta della razionalit� e  grado desiderato ( minimo 3)
-EGK_EXPORT ICurve* EditBezierCurve( const ICurveBezier* pCrv, int nDeg = 3, bool bMakeRatOrNot = false, double dTol = 10 * EPS_SMALL) ;
-
-//----------------------------------------------------------------------------
-//! Approssima una bezier con una serie di bezier cubiche
-EGK_EXPORT ICurve* ApproxBezierWithCubics( const ICurve* pCrv, double dTol) ;
-
-//----------------------------------------------------------------------------
-//! Approssima una bezier con una serie di bezier cubiche
-EGK_EXPORT ICurveBezier* ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen, const Vector3d& vtN) ;
-
-//----------------------------------------------------------------------------
-//! Campiona una serie di punti dalla curva e li approssima con una o pi� curve di bezier
-EGK_EXPORT ICurve* ApproxCurveWithBezier( const ICurve* pCrv, double dTol, const Vector3d& vtStart = V_NULL, const Vector3d& vtEnd = V_NULL) ;
-
-//----------------------------------------------------------------------------
-//! Interpola un set di punti e li approssima con una o pi� curve di bezier cubiche
-EGK_EXPORT ICurve* InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMaxLen) ;
-
-//----------------------------------------------------------------------------
-//! Aumento il grado della curva di Bezier
-EGK_EXPORT ICurveBezier* BezierIncreaseDegree( const ICurveBezier* pCrvBezier) ;
-
-//----------------------------------------------------------------------------
-//! Riduco il grado della curva di Bezier
-EGK_EXPORT ICurveBezier* BezierDecreaseDegree( const ICurveBezier* pCrvBezier, double dTol) ;
-
-//----------------------------------------------------------------------------
-//! Misura l'errore di approsimazione tra la curva originale e quella modificata
-EGK_EXPORT bool CalcApproxError( const ICurve* pCrvOri, const ICurve* pCrvNew, double& dErr, int nPoints = 20) ;
+EGK_EXPORT ICurve* ArcToBezierCurve( const ICurve* pArc) ;

 //----------------------------------------------------------------------------
 //! Trasforma una curva in una nuova curva semplice o composta senza archi (solo linee o curve di Bezier)
@@ -126,54 +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/e, nei TempParam dei risultati la distanza
-//! Per nBound tenere valore di default. 
-EGK_EXPORT bool CalcCurveVoronoiDiagram( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nBound = 3) ;
-EGK_EXPORT bool CalcCurvesVoronoiDiagram( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, int nBound = 3) ;
-
-//----------------------------------------------------------------------------
-//! Calcolo del Medial Axis della curva/e (sottoinsieme del diagramma di Voronoi), nei TempParam dei risultati la distanza
-const int WMAT_BOTHSIDES = 0 ;
-const int WMAT_LEFT = 1 ;
-const int WMAT_RIGHT = 2 ;
-EGK_EXPORT bool CalcCurveMedialAxis( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nSide) ;
-EGK_EXPORT bool CalcCurvesMedialAxis( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, int nSide) ;
-
-//----------------------------------------------------------------------------
-//! Calcola l'offset completo di una curva
-EGK_EXPORT bool CalcCurveFatCurve( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dRadius, bool bSquareEnds, bool bSquareMids,
-                                   bool bMergeOnlySameProps = true) ;
-
-//----------------------------------------------------------------------------
-//! Calcola, nel caso di curve chiuse, il valore limite di offset ( in valore assoluto) che fa sparire la curva
-EGK_EXPORT bool CalcCurveLimitOffset( const ICurve& crvC, double& dOffs) ;
-
-//----------------------------------------------------------------------------
-//! Calcola, se possibile, le curve di offset del valore richiesto come curve singole
-EGK_EXPORT bool CalcCurveSingleCurvesOffset( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dOffs) ;
-
-//----------------------------------------------------------------------------
-//! Calcola, se possibile, le curve di offset dato un vettore di curve aperte/chiuse
-EGK_EXPORT bool CalcOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR& vCrvs, double dOffs,
-                                  int nType = ICurve::OFF_FILLET) ;
-
-//----------------------------------------------------------------------------
-//! Calcola, se possibile, le fat curve di offset dato un vettore di curve aperte/chiuse
-EGK_EXPORT bool CalcFatOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR& vCrvs, double dOffs,
-                                     bool bSquareEnds, bool bSquareMids,
-                                     bool bMergeOnlySameProps = true) ;
-
-//----------------------------------------------------------------------------
-//! Resetta l'oggetto voronoi associato alla curva liberandone la memoria
-EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;
-
-//----------------------------------------------------------------------------
-//! fa il join delle curve passate in input
-EGK_EXPORT bool GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol = 5 * EPS_SMALL, bool bAllowInvert = false) ;
-
-//----------------------------------------------------------------------------
-//! dato un punto su una curva trova il corrispondente sulla seconda curva
-EGK_EXPORT bool GetIsoPointOnSecondCurve( const ICurve* pCrv1, const ICurve* pCrv2, double dUCurr1, double& dUCurr2, double dMyDist, double dUPrev2,
-                                          double dLenPrev2, double& dLenCurr2, double dLen2) ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : EGkCurveBezier.h      Data : 22.11.13          Versione : 1.3a1
+// File : EgkCurveBezier.h      Data : 22.11.13          Versione : 1.3a1
 // Contenuto : Dichiarazione della interfaccia ICurveBezier.
 //
 //
@@ -16,7 +16,6 @@
 #include "/EgtDev/Include/EGkCurve.h"

 class ICurveArc ;
-class ICurveLine ;

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

 //-----------------------------------------------------------------------------
@@ -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) ;
@@ -36,7 +36,7 @@ class CurveByInterp

   public :
      enum METHOD { BESSEL = 1, AKIMA = 2, AKIMA_CORNER = 3} ;
-      enum TYPE { BIARCS = 1, CUBIC_BEZIERS = 2, CUBIC_BEZIERS_LONG = 3} ;
+      enum TYPE { BIARCS = 1, CUBIC_BEZIERS = 2} ;

   private :
      bool CalcAkimaTangents( bool bDetectCorner) ;
@@ -1,15 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2022
+//  EgalTech 2013-2021
 //----------------------------------------------------------------------------
-// File : EGkCurveComposite.h      Data : 24.03.22        Versione : 2.4c2
+// File : EgkCurveComposite.h      Data : 03.04.21        Versione : 2.3g2
 // Contenuto : Dichiarazione della interfaccia ICurveComposite.
 //
 //
 //
 // Modifiche : 22.11.13 DS Creazione modulo.
 //             21.07.21 LM Aggiunto parametro opzionale a Set/GetCurveTempProp.
-//             23.01.22 DS Aggiunti metodi IsARectangle e IsATrapezoid.
-//             24.03.22 DS Aggiunto metodo AddLineTg.
 //
 //----------------------------------------------------------------------------

@@ -41,38 +39,27 @@ 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 ;
-      virtual bool AddLineTg( double dLen, bool bEndOrStart = true) = 0 ;
-      virtual bool AddArc2P( const Point3d& ptOther, const Point3d& ptNew, bool bEndOrStart = true) = 0 ;
      virtual bool AddArcTg( const Point3d& ptNew, bool bEndOrStart = true) = 0 ;
+      virtual bool AddArc2P( const Point3d& ptOther, const Point3d& ptNew, bool bEndOrStart = true) = 0 ;
      virtual bool AddJoint( double dU) = 0 ;
      virtual bool ModifyJoint( int nU, const Point3d& ptNewJoint) = 0 ;
-      virtual bool ModifyJoint( int nU, const Point3d& ptNewJoint, double dTol) = 0 ;
      virtual bool RemoveJoint( int nU) = 0 ;
      virtual bool MoveCurve( int nCrv, const Vector3d& vtMove) = 0 ;
      virtual bool ModifyCurveToArc( int nCrv, const Point3d& ptMid) = 0 ;
      virtual bool ModifyCurveToLine( int nCrv) = 0 ;
      virtual bool ArcsToBezierCurves( void) = 0 ;
      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 ;
      virtual bool IsALine( double dLinTol, Point3d& ptStart, Point3d& ptEnd) const = 0 ;
      virtual bool IsACircle( double dLinTol, Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const = 0 ;
-      virtual bool IsARectangle( double dLinTol, Point3d& ptP, Vector3d& vtL1, Vector3d& vtL2) const = 0 ;
-      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 GetOnlyPoint( Point3d& ptStart) const = 0 ;
-      virtual bool ReplaceSingleCurve( int nSubCrv, ICurve* pNewCurve, double dTolStartEnd, double dTolAlong = INFINITO) = 0 ;
 } ;

 //-----------------------------------------------------------------------------
@@ -90,39 +77,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 = GetCurveComposite( pGObj) ;
-                 if ( pCrvCo != nullptr) {
-                    return pCrvCo ;
-                 }
-                 else {
-                    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) ;
-                    double dParam = pCrv->GetTempParam( i) ;
-                    pCrvCo->SetTempParam( dParam, i) ;
-                 }
-                 pCrvCo->AddCurve( pCrv) ;
-                 return pCrvCo ;
-               }

 //----------------------------------------------------------------------------
 // Raccolte di puntatori a ICurveComposite
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : EGkCurveLine.h       Data : 22.11.13          Versione : 1.3a1
+// File : EgkCurveLine.h       Data : 22.11.13          Versione : 1.3a1
 // Contenuto : Dichiarazione della interfaccia ICurveLine.
 //
 //
@@ -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
@@ -14,7 +14,7 @@
 #pragma once

 #include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDEv/Include/EGkGeomDB.h"
+#include "/EgtDEv/Include/EgkGeomDB.h"

 //-----------------------------------------------------------------------------
 class CurveLocal
@@ -23,7 +23,7 @@ class CurveLocal
      CurveLocal( IGeomDB* pGeomDB, int nCrvId, const Frame3d& frLoc)
         : m_pCrv( nullptr), m_pCopy( nullptr)
         { // verifica dei parametri
-            if ( pGeomDB == nullptr)
+            if ( pGeomDB == nullptr  ||  &frLoc == nullptr)
               return ;
           // recupero riferimento della curva
            Frame3d frCrv ;
@@ -76,7 +76,7 @@ class CurveLocal
               return ;
            m_pCrv = m_pCopy ;
         }
-      CurveLocal( CurveLocal&& Other) noexcept
+      CurveLocal( CurveLocal&& Other)
         : m_pCrv( Other.m_pCrv), m_pCopy( Other.m_pCopy)
         { // annullo gli originali
            Other.m_pCrv = nullptr ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : EGkCurvePointDiffGeom.h     Data : 26.12.13        Versione : 1.4l4
+// File : EgkCurvePointDiffGeom.h     Data : 26.12.13        Versione : 1.4l4
 // Contenuto : Tipi generali per calcoli geometrici.       
 //
 //
@@ -40,8 +40,7 @@ class CrvPointDiffGeom
      double   dCurv ;

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

 //----------------------------------------------------------------------------
@@ -1,60 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2020-2024
-//----------------------------------------------------------------------------
-// File : EGkDistLineLine.h      Data : 10.05.24         Versione : 2.6e31
-// Contenuto : Dichiarazione della classe distanza fra elementi lineari.
-//
-//
-//
-// Modifiche : 06.11.20 LM Creazione modulo.
-//             10.05.24 DS Portata in Include.
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkPoint3d.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
-
-//----------------------------------------------------------------------------
-class DistLineLine
-{
-   public :
-      EGK_EXPORT DistLineLine( const Point3d& ptSt1, const Point3d& ptEn1,
-                               const Point3d& ptSt2, const Point3d& ptEn2,
-                               bool bIsSegment1 = true, bool bIsSegment2 = true) ;
-      EGK_EXPORT DistLineLine( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
-                               const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
-                               bool bIsSegment1 = true, bool bIsSegment2 = true) ;
-
-   public :
-      EGK_EXPORT bool GetSqDist( double& dSqDist) const ;
-      EGK_EXPORT bool GetDist( double& dDist) const ;
-      EGK_EXPORT bool IsEpsilon( double dTol) const
-                         { double dSqDist ; return ( GetSqDist( dSqDist)  &&  ( dSqDist < SQ_EPS_ZERO  ||  dSqDist < dTol * dTol)) ; }
-      EGK_EXPORT bool IsSmall( void) const
-                         { return IsEpsilon( EPS_SMALL) ; }
-      EGK_EXPORT bool IsZero( void) const
-                         { return IsEpsilon( EPS_ZERO) ;  }
-      EGK_EXPORT bool GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2) const ;
-      EGK_EXPORT bool GetPositionsAtMinDistPoints( double& dPos1, double& dPos2) const ;
-
-   private :
-      void Calculate( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
-                      const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
-                      bool bIsSegment1, bool bIsSegment2) ;
-   private:
-      double  m_dSqDist ;
-      mutable double  m_dDist ;
-      double  m_dPos1 ;
-      double  m_dPos2 ;
-      Point3d m_ptMinDist1 ;
-      Point3d m_ptMinDist2 ;
-} ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2024
+//  EgalTech 2013-2014
 //----------------------------------------------------------------------------
-// File : EGkDistPointCurve.h     Data : 20.05.24        Versione : 2.6e5
+// File : EGkDistPointCurve.h     Data : 02.01.14        Versione : 1.5a1
 // Contenuto : Dichiarazione della classe distanza punto da Curva.
 //
 //
@@ -49,25 +49,25 @@ 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, double dTol = EPS_SMALL) const ;
-      EGK_EXPORT bool GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide, double dTol = EPS_SMALL) const ;
-      EGK_EXPORT bool GetMinDistInfo( int nInd, MinDistPCInfo& aInfo) const ;
+      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) ;
      void LineCalculate( const Point3d& ptP, const ICurve& Curve, bool bIsSegment) ;
      void ArcCalculate( const Point3d& ptP, const ICurve& Curve) ;
      void CrvBezierCalculate( const Point3d& ptP, const ICurve& Curve) ;
@@ -1,65 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2013-2024
-//----------------------------------------------------------------------------
-// File : EGkDistPointLine.h      Data : 20.05.24          Versione : 2.6e5
-// Contenuto : Dichiarazione della classe distanza punto da linea/segmento.
-//
-//
-//
-// Modifiche : 30.12.12 DS Creazione modulo.
-//             20.05.24 DS Pubblicato in Include.
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkPoint3d.h"
-#include "/EgtDev/Include/EGkCurveLine.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
-
-
-//-----------------------------------------------------------------------------
-class DistPointLine
-{
-   friend class DistPointCurve ;
-
-   public :
-      EGK_EXPORT DistPointLine( const Point3d& ptP,
-                                const ICurveLine& crvLine, bool bIsSegment = true) ;
-      EGK_EXPORT DistPointLine( const Point3d& ptP,
-                                const Point3d& ptIni, const Point3d& ptFin, bool bIsSegment = true) ;
-      EGK_EXPORT DistPointLine( const Point3d& ptP,
-                                const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment = true) ;
-
-   public :
-      EGK_EXPORT bool GetSqDist( double& dSqDist) const ;
-      EGK_EXPORT bool GetDist( double& dDist) const ;
-      EGK_EXPORT bool IsEpsilon( double dTol) const
-                         { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
-      EGK_EXPORT bool IsSmall( void) const
-                         { return IsEpsilon( EPS_SMALL) ; }
-      EGK_EXPORT bool IsZero( void) const
-                         { return IsEpsilon( EPS_ZERO) ; }
-      EGK_EXPORT int  GetNbrMinDist( void) const
-                         { return (( m_dSqDist < 0) ? 0 : 1) ; }
-      EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDist) const ;
-      EGK_EXPORT bool GetParamAtMinDistPoint( double& dParam) const ;
-
-   private :
-      void Calculate( const Point3d& ptP,
-                      const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment) ;
-
-   private :
-      double  m_dSqDist ;
-      mutable double  m_dDist ;
-      double  m_dParam ;
-      Point3d m_ptMinDist ;
-} ;
-
@@ -1,67 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2018-2023
-//----------------------------------------------------------------------------
-// File : EgkDistPointSurfBz.cpp     Data : 29.10.25        Versione : 2.7j3
-// Contenuto : Dichiarazione della classe distanza Punto da superficie di Bezier.
-//
-//
-//
-// Modifiche : 29.10.25 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
-
-//----------------------------------------------------------------------------
-// Calcola la distanza tra punto e superficie bezier.
-// Risultati :
-// - distanza
-// - punto sulla superficie a minima distanza
-// - corrispettivo punto nello spazio parametrico
-// - normale alla superficie in quel punto
-// - indicazione se il punto di riferimento è dalla parte interna o esterna della superficie ( se chiusa ).
-// - indicazione se il punto di riferimento è a destra o sinistra della superficie ( se aperta )
-//----------------------------------------------------------------------------
-class DistPointSurfBz
-{
-   public :
-      EGK_EXPORT DistPointSurfBz( const Point3d& ptP, const ISurfBezier& srfBz) ;
-
-   public :
-      EGK_EXPORT bool GetDist( double& dDist) const ;
-      EGK_EXPORT bool IsEpsilon( double dTol) const
-                       { return ( m_dDist >= 0.  &&  ( m_dDist < EPS_ZERO || m_dDist < dTol)) ; }
-      EGK_EXPORT bool IsSmall( void) const
-                       { return IsEpsilon( EPS_SMALL) ; }
-      EGK_EXPORT bool IsZero( void) const
-                       { return IsEpsilon( EPS_ZERO) ; }
-      EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDistPoint) const ;
-      EGK_EXPORT bool GetParamsAtMinDistPoint( double& dU, double& dV) const ;
-      EGK_EXPORT bool GetNorm( Vector3d& vtN) const ;
-      EGK_EXPORT bool IsPointInside( void) const
-                        { return ( m_bIsInside  &&  m_bIsSurfClosed) ; }
-      EGK_EXPORT bool IsPointOnLeftSide( void) const
-                        { return m_bIsInside ;}
-
-   private :
-      void Calculate( const Point3d& ptP, const ISurfBezier& srfBz) ;
-
-   private :
-      double   m_dDist ;                   // Minima distanza del punto dalla superficie
-      Point3d  m_ptMinDistPoint ;          // Punto sulla superficie a minima distanza
-      Point3d  m_ptParam ;                 // punto corrispondente nello spazio parametrico (x->U, y->V)
-      Vector3d m_vtN ;                     // normale alla superficie nel punto a minima distanza
-      bool     m_bIsInside ;               // Flag per punto interno o esterno alla superficie ( se chiusa )
-      bool     m_bIsSurfClosed ;           // Flag per superficie aperta o chiusa
-} ;
@@ -1,72 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EGkDistPointSurfFr.h     Data : 18.07.24        Versione : 2.6g5
-// Contenuto : Dichiarazione della classe distanza Punto da FlatRegion.
-//
-//
-//
-// Modifiche : 18.07.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkSurfFlatRegion.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
-
-//----------------------------------------------------------------------------
-// Calcola la distanza tra punto e Flat Region.
-// Risultati :
-// - distanza
-// - punto sulla superficie a minima distanza
-// - indici del chunk e del loop e parametro del punto di frontiera a minima distanza
-// - indicazione se il punto passato è sul bordo (PRS_ON), interno (PRS_IN) o esterno (PRS_OUT) alla regione.
-// Note :
-// - nel caso di più punti di frontiera vicini, ne viene calcolato solo uno
-// - se il punto non giace nel piano della Regione 
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-enum PrSide { PRS_IN = -1, PRS_ON = 0, PRS_OUT = +1} ;
-// Corrispondono a MDS_LEFT, MDS_ON e MDS_RIGHT per giacitura punto rispetto a curva.
-
-//----------------------------------------------------------------------------
-class DistPointSurfFr
-{
-   public :
-      EGK_EXPORT DistPointSurfFr( const Point3d& ptP, const ISurfFlatRegion& frSurf) ;
-
-   public :
-      EGK_EXPORT bool GetDist( double& dDist) const ;
-      EGK_EXPORT bool GetDistOnRegionPlane( double& dDist) const ;
-      EGK_EXPORT bool GetPointAtMinDist( Point3d& ptMinDistPoint) const ;
-      EGK_EXPORT bool GetParamAtMinDist( int& nMinChunk, int& nMinLoop, double& dMinPar) const ;
-      EGK_EXPORT bool GetSideAtMinDist( int& nSide) const ;
-
-   private :
-      void Calculate( const Point3d& ptP, const ISurfFlatRegion& frSurf) ;
-
-   private :
-      double  m_dDist ;
-      double  m_dDistOnPlane ;
-      int     m_nMinChunk ;
-      int     m_nMinLoop ;
-      double  m_dMinPar ;
-      Point3d m_ptMinDistPoint ;
-      int     m_nSide ;
-} ;
-
-//----------------------------------------------------------------------------
-// Verifica velocizzata
-EGK_EXPORT bool IsPointInsideSurfFr( const Point3d& ptP, const ISurfFlatRegion* pSfr, double dMinDist, bool& bInside, int& nChunk) ;
-inline bool IsPointInsideSurfFr( const Point3d& ptP, const ISurfFlatRegion* pSfr, double dMinDist, bool& bInside)
-               { int nChunk ; return IsPointInsideSurfFr( ptP, pSfr, dMinDist, bInside, nChunk) ;}
@@ -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,14 +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 ( se chiusa ).
-// - indicazione se il punto di riferimento è a destra o sinistra della superficie ( se aperta )
 //----------------------------------------------------------------------------
 class DistPointSurfTm
 {
@@ -38,34 +30,24 @@ 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 GetMinDistTriaIndices( INTVECTOR& vMinDistTriaIndex) const ;
-      EGK_EXPORT bool IsPointInside( void) const
-                        { return ( m_bIsInside  &&  m_bIsSurfClosed) ; }
-      EGK_EXPORT bool IsPointOnLeftSide( void) const
-                        { return m_bIsInside ;}
+      EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDistPoint) ;
+      EGK_EXPORT bool GetMinDistTriaIndex( int& nMinDistTriaIndex) ;
+      EGK_EXPORT bool IsPointInside( void)
+                        { return m_bIsInside ; }

   private :
      void Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf) ;

   private :
-      double  m_dDist ;                   // Minima distanza del punto dalla superficie
-      Point3d m_ptMinDistPoint ;          // Punto sulla superficie a minima distanza
-      int     m_nMinDistTriaIndex ;       // Triangolo utilizzato per calcolare il punto a minima distanza
-      INTVECTOR m_vnMinDistTriaIndex ;    // Indici dei triangoli a minima distanza
-      bool    m_bIsInside ;               // Flag per punto interno o esterno alla superficie ( se chiusa )
-      bool    m_bIsSurfClosed ;           // Flag per superficie aperta o chiusa
+      double  m_dDist ;
+      Point3d m_ptMinDistPoint ;
+      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) ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2025
+//  EgalTech 2014-2020
 //----------------------------------------------------------------------------
-// File : EGkDllMain.h          Data : 11.09.25          Versione : 2.7i2
+// File : EgkDllMain.h          Data : 19.09.20          Versione : 2.2i2
 // Contenuto : Prototipi funzioni generali della DLL. 
 //
 //
@@ -9,7 +9,6 @@
 // Modifiche : 21.11.13 DS Creazione modulo.
 //             13.01.15 DS Agg. funzioni Get sui font.
 //             19.09.20 DS Agg. funzione SetEGkDebugLev.
-//             11.09.25 DS Agg. funzione SetDefaultFont.
 //
 //----------------------------------------------------------------------------

@@ -39,15 +38,11 @@ EGK_EXPORT void SetEGkLogger( ILogger* pLogger) ;
 EGK_EXPORT void SetEGkKey( const std::string& sKey) ;
 // imposta il tipo di chiave di protezione
 EGK_EXPORT void SetEGkKeyType( int nType) ;
-// imposta se chiave hardware di rete
-EGK_EXPORT void SetEGkNetHwKey( bool bNetHwKey) ;
 // permette di inizializzare il font manager
 EGK_EXPORT void InitFontManager( const std::string& sNfeFontDir, const std::string& sDefaultFont) ;
-// imposta il font di default
-EGK_EXPORT void SetDefaultFont( const std::string& sDefaultFont) ;
 // restituisce il direttorio dei font proprietari (Nfe)
 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( psfProcEvents pFun) ;
+EGK_EXPORT bool SetEGkProcessEvents( pfProcEvents pFun) ;
@@ -32,15 +32,6 @@ class __declspec( novtable) IExtDimension : public IGeoObj
                             int nDecDigit, const std::string& sFont, double dTextHeight) = 0 ;
      virtual bool SetLinear( const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
                              const Vector3d& vtN, const Vector3d& vtDir, const std::string& sText) = 0 ;
-      virtual bool SetRadial( const Point3d& ptCen, const Point3d& ptPos,
-                              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 const Vector3d& GetNormVersor( void) const = 0 ;
      virtual const Vector3d& GetDirVersor( void) const = 0 ;
      virtual const std::string& GetText( void) const = 0 ;
@@ -58,7 +49,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 ;
 } ;

@@ -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.
 //
 //
@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkPoint3d.h"
+#include "/EgtDev/Include/EGKPoint3d.h"

 //----------------------- Macro per import/export ----------------------------
 #undef EGK_EXPORT
@@ -30,8 +30,8 @@ class EGK_EXPORT Frame3d
      enum Type { ERR = 0, TOP = 1, BOTTOM = 2, FRONT = 3,
                  BACK = 4, LEFT = 5, RIGHT = 6, GEN = 7} ;
   public :
-      Frame3d( bool bGlob = true)
-         : m_nType( bGlob ? TOP : ERR), m_nZType( bGlob ? TOP : ERR), m_ptOrig( ORIG),
+      Frame3d( void)
+         : m_nType( TOP), m_nZType( TOP), m_ptOrig( ORIG),
           m_vtVersX( X_AX), m_vtVersY( Y_AX), m_vtVersZ( Z_AX) {}
      Frame3d( const Point3d& ptOrig)
         : m_nType( TOP), m_nZType( TOP), m_ptOrig( ptOrig),
@@ -43,7 +43,7 @@ class EGK_EXPORT Frame3d
      bool Set( const Point3d& ptOrig, const Vector3d& vtDirZ, const Vector3d& vtNearDirX) ;
      bool Set( const Point3d& ptOrig, Type nType) ;
      bool Set( const Point3d& ptOrig, double dAngCDeg, double dAngADeg, double dAngC1Deg) ;
-      bool Reset( bool bGlob = true) ;
+      bool Reset( void) ;
      bool ChangeOrig( const Point3d& ptOrig) ;
      bool Translate( const Vector3d& vtMove) ;
      bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg) ;
@@ -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,67 +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 il frame inverso di quello passato
-//----------------------------------------------------------------------------
-inline const Frame3d 
-GetInvert( const Frame3d& frRef)
-{
-   Frame3d frNew = GLOB_FRM ;
-   frNew.ToLoc( frRef) ;
-   return frNew ;
-}
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia in locale del frame passato
-//----------------------------------------------------------------------------
-inline const Frame3d 
-GetToLoc( const Frame3d& frRef, const Frame3d& frDest)
-{
-   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 ;
 }

 //----------------------------------------------------------------------------
@@ -178,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) ;
-}
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2013-2014
 //----------------------------------------------------------------------------
-// File : EGkGdbConst.h           Data : 17.06.14          Versione : 1.5f5
+// File : EgkGdbConst.h           Data : 17.06.14          Versione : 1.5f5
 // Contenuto : Costanti generali per DB geometrico.       
 //
 //
@@ -34,8 +34,7 @@ enum GdbInsPos { GDB_FIRST_SON = 0,
 //----------------- Costanti tipo salvataggio del DB geometrico ----------------
 enum GdbSave { GDB_SV_TXT =  0,
               GDB_SV_BIN =  1,
-               GDB_SV_CMPTXT = 2,
-               GDB_SV_CMPBIN = 3} ;
+               GDB_SV_CMPTXT = 2} ;

 //----------------- Costanti tipo oggetti del DB geometrico --------------------
 enum GdbType { GDB_TY_NONE =  0,
@@ -59,8 +58,7 @@ enum GdbStatus { GDB_ST_OFF = 0,

 //----------------- Costanti marcatura oggetti del DB geometrico ---------------
 enum GdbMark { GDB_MK_OFF = 0,
-               GDB_MK_ON =  1,
-               GDB_MK_ON_2 = 2} ;
+               GDB_MK_ON =  1} ;

 //----------------- Costante per numero proprietà temporanee -------------------
 const int GDB_NUM_TEMP_PROP = 2 ;
@@ -85,9 +83,7 @@ const std::string GDB_SI_LIST = "!LST" ;             // Vettore Id entit
 const std::string GDB_SI_COPY = "!COP" ;             // Id entità
 const std::string GDB_SI_MGRPONLY = "!MGO" ;         // Id entità
 const std::string GDB_SI_DRAWMODE = "!DRM" ;         // Flag
-const std::string GDB_SI_DUPSOU = "!DSOU" ;          // Duplo Id entità originale
-const std::string GDB_SI_DUPLIST = "!DLST" ;         // Duplo Vettore Id entità duplicate
-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
+const std::string GDB_SI_DUPSOU = "!DSOU" ;          // Id entità
+const std::string GDB_SI_DUPLIST = "!DLST" ;         // Vettore Id entità
+const std::string GDB_SI_DUPMODIF = "!DMOD" ;        // Flag
+      
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : EGkGdbExecutor.h       Data : 25.11.13        Versione : 1.3a1
+// File : EgkGdbExecutor.h       Data : 25.11.13        Versione : 1.3a1
 // Contenuto : Dichiarazione della interfaccia IGdbExecutor.
 //
 //
@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGnCmdExecutor.h"
+#include "/EgtDev/Include/EgnCmdExecutor.h"

 class IGeomDB ;

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : EGkGdbFunct.h          Data : 13.03.14          Versione : 1.5c6
+// File : EgkGdbFunct.h          Data : 13.03.14          Versione : 1.5c6
 // Contenuto : Funzioni generali per DB geometrico.       
 //
 //
@@ -80,7 +80,7 @@ CalcMark( int nObjMark, int nParentMark)
   if ( nObjMark == GDB_MK_OFF  &&  nParentMark == GDB_MK_OFF)
      return GDB_MK_OFF ;

-   return ( nParentMark != GDB_MK_OFF ? nParentMark : nObjMark) ;
+   return GDB_MK_ON ;
 }
 // ovviamente la marcatura si combina con lo stato, nel senso che un oggetto 
 // non visibile non viene nemmeno marcato
@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2023
+//  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : EGkGdbIterator.h        Data : 09.07.23          Versione : 2.5g1
+// File : EGkGdbIterator.h        Data : 04.12.13          Versione : 1.4a3
 // 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.
+//
 //
 //----------------------------------------------------------------------------

@@ -104,7 +103,7 @@ class __declspec( novtable) IGdbIterator
      virtual bool RevertStatus( void) = 0 ;
      virtual bool GetStatus( int& nStat) const = 0 ;
      virtual bool GetCalcStatus( int& nStat) const = 0 ;
-      virtual bool SetMark(  int nMark = GDB_MK_ON) = 0 ;
+      virtual bool SetMark( void) = 0 ;
      virtual bool ResetMark( void) = 0 ;
      virtual bool GetMark( int& nMark) const = 0 ;
      virtual bool GetCalcMark( int& nMark) const = 0 ;
@@ -143,11 +142,6 @@ class __declspec( novtable) IGdbIterator
      virtual bool GetInfo( const std::string& sKey, STRVECTOR& vsInfo) const = 0 ;
      virtual bool ExistsInfo( const std::string& sKey) const = 0 ;
      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 ;
@@ -162,4 +156,4 @@ class __declspec( novtable) IGdbIterator
 } ;

 //-----------------------------------------------------------------------------
-EGK_EXPORT IGdbIterator* CreateGdbIterator( IGeomDB* pGDB = nullptr) ;
+EGK_EXPORT IGdbIterator* CreateGdbIterator( IGeomDB* pGDB = nullptr) ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2014-2019
 //----------------------------------------------------------------------------
-// File : EGkGeoCollection.h       Data : 05.11.19          Versione : 2.1k1
+// File : EgkGeoCollection.h       Data : 05.11.19          Versione : 2.1k1
 // Contenuto : Raccolte di oggetti geometrici.       
 //
 //
@@ -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"

@@ -24,24 +23,18 @@
 typedef std::vector<Point3d>   PNTVECTOR ;   // vettore di punti
 typedef std::list<Point3d>     PNTLIST ;     // lista di punti
 typedef std::vector<PNTVECTOR> PNTMATRIX ;   // matrice di punti
-                                             
-//----------------------------------------------------------------------------
-// Raccolte di coppie Point3d,int
-typedef std::pair<Point3d,int> POINTI ;      // coppia punto, intero
-typedef std::vector<POINTI>    PNTIVECTOR ;  // vettore di coppie punto, intero
-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,32 +46,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
-
-//----------------------------------------------------------------------------
-// Raccolte di coppie Point3d,Bool
-typedef std::pair<Point3d, bool>  PNTBOOL ;           // coppia punto, bool
-typedef std::vector<PNTBOOL>      PNTBOOLVECTOR ;     // vettore di coppie punto, bool
-typedef std::list<PNTBOOL>        PNTBOOLLIST ;       // lista di coppie punto, bool
-
-//----------------------------------------------------------------------------
-// Raccolte di triplette Point3d,dU,vector<Vector3d>
-typedef std::tuple<Point3d, double, VCT3DVECTOR> PNTUVVECT ;       // tripletta punto, parametro, vettore di Vector3d
-typedef std::vector<PNTUVVECT>                   PNTUVVECTVECTOR ; // vettore di triplette punto, parametro, vettore di Vector3d
-typedef std::list<PNTUVVECT>                     PNTUVVECTLIST ;   // lista di triplette punto, parametro, vettore di Vector3d
@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2025
+//  EgalTech 2013-2019
 //----------------------------------------------------------------------------
-// File : EGkGeoConst.h           Data : 22.11.25          Versione : 2.7k4
+// File : EgkGeoConst.h           Data : 23.11.19          Versione : 2.1k5
 // Contenuto : Costanti generali per calcoli geometrici.       
 //
 //
 //
 // Modifiche : 04.01.12 DS Creazione modulo.
 //             23.11.19 DS Aggiunta costante EPS_TRIA_H.
-//             22.11.25 DS Aggiunta costante PREC_SCALE_COEFF.
 //
 //----------------------------------------------------------------------------

@@ -34,9 +33,6 @@ const double SQ_EPS_ZERO = EPS_ZERO * EPS_ZERO ;
 const double INFINITO = 1e10 ;
 const double SQ_INFINITO = INFINITO * INFINITO ;

-// coefficiente componente di vettore largamente predominante
-const double KV_BIG = 1e5 ; 
-
 // conversione da gradi a radianti e viceversa
 const double PIGRECO  = 3.14159265358979323846 ;
 const double DEGTORAD = PIGRECO / 180. ;
@@ -60,6 +56,3 @@ const double SQRT2   = 1.41421356237309504880 ;
 const double SQRT1_2 = 1 / SQRT2 ;
 const double SQRT3   = 1.73205080756887729353 ;
 const double SQRT1_3 = 1 / SQRT3 ;
-
-// coefficiente di scalatura per aumentare precisione dei calcoli
-const double PREC_SCALE_COEFF = 1024 ;
@@ -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 ;
 } ;

 //-----------------------------------------------------------------------------
@@ -1,13 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2017-2022
+//  EgalTech 2017-2017
 //----------------------------------------------------------------------------
-// File : EGkGeoObjSave.h        Data : 25.04.22         Versione : 2.4d4
+// File : EGkGeoObjSave.h        Data : 30.10.17         Versione : 1.8j5
 // Contenuto : Funzione per salvare su file un Oggetto Geometrico. 
 //
 //
 //
 // Modifiche : 30.10.17 DS Creazione modulo.
-//             25.04.22 DS Aggiunti controlli.
 //
 //----------------------------------------------------------------------------

@@ -15,16 +14,12 @@

 #include "/EgtDev/Include/EGkGeomDB.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EGkSurfFlatRegion.h"


 //----------------------------------------------------------------------------
 bool
 SaveGeoObj( IGeoObj* pGObj, const std::string& sFile, int nFlag = GDB_SV_BIN)
 {
-  // verifico validità oggetto
-   if ( pGObj == nullptr  ||  ! pGObj->IsValid())
-      return false ;
  // creo GeomDB temporaneo
   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
   if ( IsNull( pGeomDB))
@@ -40,217 +35,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 ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SaveGeoObj( std::vector<std::vector<IGeoObj*>> vvpGObj, std::vector<Color> vCol,
-            const std::string& sFile, int nFlag = GDB_SV_BIN)
-{
-  // verifico validità oggetti
-   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++ i) {
-      for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j) {
-         if ( vvpGObj[i][j] == nullptr  ||  ! vvpGObj[i][j]->IsValid())
-            return false ;
-      }
-   }
-   if ( int( vCol.size()) <= int( vvpGObj.size())) {
-      for ( int i = int( vCol.size()) ; i < int( vvpGObj.size()) ; ++ i)
-         vCol.push_back( BLACK) ;
-   }
-   else
-      return false ;
-
-  // creo GeomDB temporaneo
-   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
-   if ( IsNull( pGeomDB))
-      return false ;
-   INTVECTOR vIds ;
-   int nLayId = 0 ;
-
-  // creo il part
-   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-
-  // per ogni elemento i-esimo, creo un layer
-   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++i) {
-     // creo il layer
-      nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-      pGeomDB->SetMaterial( nLayId, vCol[i]) ;
-
-      for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j ) {
-        // inserisco gli oggetti corrispondenti
-         int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vvpGObj[i][j]) ;
-         vIds.push_back( nId) ;
-         if ( nId == GDB_ID_NULL)
-            return false ;
-      }
-   }
-
-  // eseguo il salvataggio
-   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
-  // rimuovo l'oggetto dal GeomDB
-   for ( int i = 0 ; i < int( vIds.size()) ; ++i)
-      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr) && bOk ;
-
-   return bOk ;
-}
-
-bool SaveSfrBooleans( const ISurfFlatRegion* pSfrA, const ISurfFlatRegion* pSfrB,
-                      const std::string& sFile, int nFlag = GDB_SV_BIN,
-                      Color cColA = Color( 0., .5, .75, .5), Color cColB = Color( 0., .5, 0., .5))
-{
-  // verifico validità superfici
-   if ( pSfrA == nullptr  ||  ! pSfrA->IsValid()  ||
-        pSfrB == nullptr  ||  ! pSfrB->IsValid())
-      return false ;
-  // creo GeomDB temporaneo
-   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
-   if ( IsNull( pGeomDB))
-      return false ;
-  // inserisco le superfici nel GeomDB (sotto pezzo/layer)
-   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-   int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-   int nIdSfrA = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, static_cast<IGeoObj*>( CloneSurfFlatRegion( pSfrA))) ;
-   if ( nIdSfrA == GDB_ID_NULL)
-      return false ;
-   pGeomDB->SetMaterial( nIdSfrA, cColA) ;
-   int nIdSfrB = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, static_cast<IGeoObj*>( CloneSurfFlatRegion( pSfrB))) ;
-   if ( nIdSfrB == GDB_ID_NULL)
-      return false ;
-   pGeomDB->SetMaterial( nIdSfrB, cColB) ;
-  // vettor di indici aggiunti
-   INTVECTOR vIds = { nIdSfrA, nIdSfrB} ;
-  // eseguo il salvataggio
-   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
-  // rimuovo l'oggetto dal GeomDB
-   for ( int i = 0 ; i < int( vIds.size()) ; ++i)
-      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr)  &&  bOk ;
-
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SaveGeoObj( std::vector<std::vector<IGeoObj*>> vvpGObj, std::vector<std::vector<Color>> vvCol,
-            const std::string& sFile, int nFlag = GDB_SV_BIN)
-{
-  // verifico validità oggetti
-   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++ i) {
-      for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j) {
-         if ( vvpGObj[i][j] == nullptr  ||  ! vvpGObj[i][j]->IsValid())
-            return false ;
-      }
-   } 
-
-  // creo GeomDB temporaneo
-   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
-   if ( IsNull( pGeomDB))
-      return false ;
-   INTVECTOR vIds ;
-
-   // creo il part
-   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-
-   // per ogni elemento i-esimo, creo un layer
-   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++i) {
-      // creo il layer
-      int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-      for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j ) {
-        // inserisco gli oggetti corrispondenti
-         int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vvpGObj[i][j]) ;
-         if ( nId == GDB_ID_NULL)
-            return false ;
-        // setto il colore ( se definito)
-         if ( i < int( vvCol.size()) && j < int( vvCol[i].size()))
-            pGeomDB->SetMaterial( nId, vvCol[i][j]) ;
-         vIds.push_back( nId) ;        
-      }
-   }
-
-  // eseguo il salvataggio
-   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
-  // rimuovo l'oggetto dal GeomDB
-   for ( int i = 0 ; i < int( vIds.size()) ; ++i)
-      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr) && bOk ;
-
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SaveGeoObj( std::vector<IGeoObj*> vpGObj, std::vector<Color> vCol,
-            const std::string& sFile, int nFlag = GDB_SV_BIN)
-{
-  // verifico validità oggetti
-   if ( int( vpGObj.size()) != int( vCol.size()))
-      return false ;
-
-  // creo GeomDB temporaneo
-   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
-   if ( IsNull( pGeomDB))
-      return false ;
-   INTVECTOR vIds ;
-
-   // creo il part
-   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ; 
-  // creo il layer
-   int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-
-  // scorro gli elementi da visualizzare
-   for ( int i = 0 ; i < int( vpGObj.size()) ; ++ i) {
-      if ( vpGObj[i] == nullptr  ||  ! vpGObj[i]->IsValid())
-         continue ;
-     // inserisco gli oggetti corrispondenti
-      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vpGObj[i]) ;
-      if ( nId == GDB_ID_NULL)
-         return false ;
-     // setto il colore
-      pGeomDB->SetMaterial( nId, vCol[i]) ;
-     // aggiungo l'Id ottenuto
-      vIds.push_back( nId) ;
-   }
-
-  // eseguo il salvataggio
-   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
-  // rimuovo l'oggetto dal GeomDB
-   for ( int i = 0 ; i < int( vIds.size()) ; ++i)
-      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr) && bOk ;
-
   return bOk ;
 }
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2023
+//  EgalTech 2013-2014
 //----------------------------------------------------------------------------
-// File : EGkGeomDB.h           Data : 09.07.23          Versione : 2.5g1
+// File : EGkGeomDB.h           Data : 03.12.14          Versione : 1.5k1
 // Contenuto : Dichiarazione della interfaccia IGeomDB.
 //
 //
@@ -11,8 +11,6 @@
 //             21.05.14 DS Agg. GotoFirst/Next/Last/Prev.
 //             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.
 //
 //----------------------------------------------------------------------------

@@ -134,7 +132,7 @@ class __declspec( novtable) IGeomDB
      virtual bool RevertStatus( int nId) = 0 ;
      virtual bool GetStatus( int nId, int& nStat) const = 0 ;
      virtual bool GetCalcStatus( int nId, int& nStat) const = 0 ;
-      virtual bool SetMark( int nId, int nMark = GDB_MK_ON) = 0 ;
+      virtual bool SetMark( int nId) = 0 ;
      virtual bool ResetMark( int nId) = 0 ;
      virtual bool GetMark( int nId, int& nMark) const = 0 ;
      virtual bool GetCalcMark( int nId, int& nMark) const = 0 ;
@@ -178,12 +176,7 @@ class __declspec( novtable) IGeomDB
      virtual bool GetInfo( int nId, const std::string& sKey, STRVECTOR& vsInfo) const = 0 ;
      virtual bool ExistsInfo( int nId, const std::string& sKey) const = 0 ;
      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 ;
@@ -1,76 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2015-2018
-//----------------------------------------------------------------------------
-// File : EGkHashGrids1d.h        Data : 02.05.21          Versione : 2.4e1
-// Contenuto : Dichiarazione della classe HashGrids1d.
-//
-//
-//
-// Modifiche : 04.07.15 DS Creazione modulo.
-//            
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "EgtDev/Include/EGkBBox3d.h"
-#include "EgtDev/Include/EgtNumCollection.h"
-#include <unordered_map>
-
-//----------------------- 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 HashGrids1d
-{
-public :
-   EGK_EXPORT HashGrids1d( void) ;
-   EGK_EXPORT ~HashGrids1d( void) ;
-   EGK_EXPORT void SetActivationGrid( bool bActivate) ;
-   EGK_EXPORT bool Add( int nObjId, const BBox3d& box) ;
-   EGK_EXPORT bool Modify( int nObjId, const BBox3d& box) ;
-   EGK_EXPORT bool Remove( int nObjId) ;
-   EGK_EXPORT bool Update( void) ;
-   EGK_EXPORT bool Find( const BBox3d& b3Test, INTVECTOR& vnIds) const ;
-   EGK_EXPORT void Clear( void) ;
-
-   friend class HashGrid1d ;
-
-private :
-   struct ObjData {
-      int         nId ;
-      BBox3d      box ;
-      HashGrid1d* pHGrid ;
-      size_t      nHash ;
-      size_t      nCellId ;
-      ObjData( void)
-         : nId( -1), box(), pHGrid( nullptr), nHash( 0), nCellId( 0) {}
-      ObjData( int nI, const BBox3d& bb, HashGrid1d* pHG, size_t nH, size_t nCI)
-         : nId( nI), box( bb), pHGrid( pHG), nHash( nH), nCellId( nCI) {}
-   } ;
-   typedef std::list<ObjData> ObjList ; 
-   typedef std::vector<ObjData*> PtrObjVector ;
-   typedef std::unordered_map<int,ObjData*> IntPObjUmap ;
-   typedef std::list<HashGrid1d*> GridList ;
-
-private :
-   HashGrids1d( const HashGrids1d&) = delete ;
-   HashGrids1d& operator=( const HashGrids1d&) = delete ;
-   void addGrid( ObjData& obj) ;
-   void addList( ObjData& obj) ;
-
-private :
-   ObjList      m_ObjsList ;     // Lista degli oggetti
-   IntPObjUmap  m_ObjsMap ;      // Map da Id a PtrObj
-   PtrObjVector m_objsToAdd ;    // Vettore di puntatori agli oggetti da inserire
-   PtrObjVector m_nonGridObjs ;  // Vettore di puntatori agli oggetti non assegnati alle griglie (per dimensioni o perchè pochi)
-   GridList     m_GridList ;     // Lista delle griglie di dimensione fissa ( in ordine crescente di dimensione di cella) 
-   bool         m_bActivate ;    // Flag che abilita l'attivazione delle griglie
-   bool         m_bGridActive ;  // Flag di attivazione delle griglie
-   BBox3d       m_b3Objs ;       // Box totale di tutti gli oggetti inseriti
-} ;
@@ -56,11 +56,11 @@ class HashGrids2d
      typedef std::list<ObjData> ObjList ; 
      typedef std::vector<ObjData*> PtrObjVector ;
      typedef std::unordered_map<int,ObjData*> IntPObjUmap ;
-      typedef std::list<HashGrid2d*> GridList ;

   private :
-      HashGrids2d( const HashGrids2d&) = delete ;
-      HashGrids2d& operator=( const HashGrids2d&) = delete ;
+      typedef std::list<HashGrid2d*> GridList ;  // Tipo per lista di hash grid
+
+   private :
      void addGrid( ObjData& obj) ;
      void addList( ObjData& obj) ;

@@ -56,11 +56,11 @@ class HashGrids3d
      typedef std::list<ObjData> ObjList ; 
      typedef std::vector<ObjData*> PtrObjVector ;
      typedef std::unordered_map<int,ObjData*> IntPObjUmap ;
-      typedef std::list<HashGrid3d*> GridList ;

   private :
-      HashGrids3d( const HashGrids3d&) = delete ;
-      HashGrids3d& operator=( const HashGrids3d&) = delete ;
+      typedef std::list<HashGrid3d*> GridList ;  // Tipo per lista di hash grid
+
+   private :
      void addGrid( ObjData& obj) ;
      void addList( ObjData& obj) ;

@@ -1,109 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025
-//----------------------------------------------------------------------------
-// File : EGkIntersCurvePlane.h     Data : 07.11.25        Versione : 2.7k1
-// Contenuto : Dichiarazione della classe intersezione curva-piano.
-//
-//
-//
-// Modifiche : 07.11.25 DB Creazione modulo.
-//             
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkPoint3d.h"
-#include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkIntersCurves.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
-
-//-----------------------------------------------------------------------------
-// Tipo di intersezione
-// nulla
-// puntiforme
-// sovrapposizione
-
-// Costanti per tipo di approccio/allontanamento dall'intersezione
-const int ICPT_NULL = 0 ;              //!< Approccio/allontanamento non definito
-const int ICPT_IN = 1 ;                //!< Approccio/allontanamento interno
-const int ICPT_OUT = 2 ;               //!< Approccio/allontanamento esterno
-const int ICPT_ON = 3 ;                //!< Approccio/allontanamento sovrapposto
-
-//! dati di intersezione tra una curva e un piano
-struct IntCrvPlnInfo {
-   bool bOverlap ;          //!< intersezione con overlap
-   IntCrvInfo Ici[2] ;     //!< Ici[0] intersez. isolata o inizio overlap, Ici[1] fine overlap 
-  // costruttore
-   IntCrvPlnInfo( void)
-      : bOverlap( false) {}
-} ;
-//! vettore di IntCrvPlnInfo
-typedef std::vector<IntCrvPlnInfo>  ICPIVECTOR ;
-
-//-----------------------------------------------------------------------------
-//! Classificazione di parti di curva rispetto ad un piano
-struct CrvPlaneClass {
-   double dParS ;
-   double dParE ;
-   int    nClass ;
-  // costruttori
-   CrvPlaneClass( void)
-      : dParS( 0), dParE( 0), nClass( 0) {}
-   CrvPlaneClass( double dPS, double dPE, int nC)
-      : dParS( dPS), dParE( dPE), nClass( nC) {}
-} ;
-//! Vettore di CrvPlaneClass
-typedef std::vector<CrvPlaneClass>  CRVPLNCVECTOR ;
-
-//-----------------------------------------------------------------------------
-// Costanti per classe parti di curva rispetto ad un piano
-const int CRVPLN_NULL = 0 ;              //!< Parte di curva non classificabile
-const int CRVPLN_IN = 1 ;                //!< Parte di curva interna ( dal lato negativo della normale)
-const int CRVPLN_OUT = 2 ;               //!< Parte di curva esterna ( dal lato positivo della normale)
-const int CRVPLN_ON = 3 ;                //!< Parte di curva sovrapposta al piano
-
-//-----------------------------------------------------------------------------
-//! Classe per calcolo intersezione tra una curve e un piano, nel riferimento locale del piano
-class IntersCurvePlane
-{
-   public :
-      //! Le intersezioni sono calcolate nel piano XY locale.<br>
-      EGK_EXPORT IntersCurvePlane( const ICurve& CurveA, const Point3d& ptOrig, const Vector3d& vtN) ;
-
-   public :
-      //! Indica la presenza di intersezioni con sovrapposizioni
-      EGK_EXPORT bool GetOverlaps( void) ;
-      //! Restituisce il numero di intersezioni (intersezioni doppie coincidenti e sovrapposte contano uno)
-      EGK_EXPORT int  GetIntersCount( void) ;
-      //! Restituisce informazioni sull'intersezione di indice nInd ( 0 based)
-      EGK_EXPORT bool GetIntCrvPlnInfo( int nInd, IntCrvPlnInfo& aInfo) ;
-      //! Restituisce il punto di intersezione più vicino al punto passato
-      EGK_EXPORT bool GetIntersPointNearTo( const Point3d& ptNear, Point3d& ptI, double& dParam) ;
-      //! Restituisce la classificazione di una curva rispetto al piano
-      EGK_EXPORT bool GetCurveClassification( double dLenMin, CRVPLNCVECTOR& ccClass) ;
-
-   private :
-      IntersCurvePlane( void) ;
-      bool CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Curve, int nCrv = 0) ;
-      bool IsArcToApprox( const ICurve& Curve) ;
-      bool AdjustIntersParams( bool bAdjCrv) ;
-      bool CalcCurveClassification( const ICurve* pCurve, const ICPIVECTOR& Info, double dLenMin, CRVPLNCVECTOR& ccClass) ;
-      bool CalcCurveInOrOut( const ICurve* pCurve, CRVPLNCVECTOR& ccClass) ;
-      void OrderAndCompleteIntersections() ;
-
-   private :
-      int                  m_nIntersType ;
-      int                  m_nIntersCount ;
-      ICPIVECTOR           m_Info ;
-      const ICurve*        m_pCurve ;    // puntatore alla curva
-      Plane3d              m_plPlane ;
-} ;
@@ -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) ;
@@ -44,7 +44,7 @@ struct IntCrvCrvInfo {
   IntCrvInfo IciB[2] ;     //!< IciB[0] intersez. isolata o inizio overlap, IciB[1] fine overlap 
  // costruttore
   IntCrvCrvInfo( void)
-      : bOverlap( false), bCBOverEq( false) {}
+      : bOverlap( false) {}
 } ;
 //! vettore di IntCrvCrvInfo
 typedef std::vector<IntCrvCrvInfo>  ICCIVECTOR ;
@@ -115,20 +115,16 @@ class IntersCurveCurve
      EGK_EXPORT bool GetOverlaps( void) ;
      //! Restituisce il numero di intersezioni (intersezioni doppie coincidenti e sovrapposte contano uno)
      EGK_EXPORT int  GetIntersCount( void) ;
-      //! Restituisce il numero di intersezioni in 3D ( filtrando le intersezioni)
-      EGK_EXPORT int  GetInters3DCount( void) ;
      //! Restituisce il numero di intersezioni in cui la curva si attraversa
      EGK_EXPORT int  GetCrossIntersCount( void) ;
      //! Restituisce il numero di intersezioni in cui la curva si attraversa o si sovrappone
      EGK_EXPORT int  GetCrossOrOverlapIntersCount( void) ;
      //! Restituisce informazioni sull'intersezione di indice nInd ( 0 based)
      EGK_EXPORT bool GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
-      //! Restituisce informazioni sulla i-esima intersezione 3D ( 0 based)
-      EGK_EXPORT bool GetInt3DCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
      //! Restituisce il punto di intersezione più vicino al punto passato
      EGK_EXPORT bool GetIntersPointNearTo( int nCrv, const Point3d& ptNear, Point3d& ptI) ;
      //! Restituisce la classificazione di una curva rispetto all'altra ( nCrv=0 -> CurvaA, nCrv=1 -> CurvaB)
-      EGK_EXPORT bool GetCurveClassification( int nCrv, double dLenMin, CRVCVECTOR& ccClass) ;
+      EGK_EXPORT bool GetCurveClassification( int nCrv, CRVCVECTOR& ccClass) ;
      //! Restituisce la classificazione di curve chiuse secondo le regole delle regioni
      EGK_EXPORT int  GetRegionCurveClassification( void) ;

@@ -146,7 +142,7 @@ class IntersCurveCurve
      void CrvCompoCrvCompoCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
      bool AdjustIntersParams( bool bAdjCrvA, bool bAdjCrvB) ;
      bool SwapInfoAB( ICCIVECTOR& Info, int IndCrvOrd) ;
-      bool CalcCurveClassification( const ICurve* pCurve, const ICCIVECTOR& Info, double dLenMin, CRVCVECTOR& ccClass) ;
+      bool CalcCurveClassification( const ICurve* pCurve, const ICCIVECTOR& Info, CRVCVECTOR& ccClass) ;
      bool CalcCurveInOrOut( const ICurve* pCurveA, const ICurve* pCurveB, CRVCVECTOR& ccClass) ;
      bool GetCurveOutClass( const ICurve* pCurve, int& nClass) ;

@@ -1,8 +1,8 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2022
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EGkIntersLineBox.h      Data : 08.01.22         Versione : 2.4a3
-// Contenuto : Dichiarazione delle funzioni intersezione linea/box.
+// File : EGkIntersLineBox.h      Data : 07.05.20         Versione : 2.2e1
+// Contenuto : Dichiarazione della classe intersezione linea/box.
 //
 //
 //
@@ -32,11 +32,9 @@ EGK_EXPORT bool IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double d

 //-----------------------------------------------------------------------------
 // Tipo di intersezione linea-box
-enum IntLineBoxType { ILBT_NONE =  0,                 // non è intersezione
+enum IntLineBoxType { ILBT_NONE =  0,                 // non è intersezione
                      ILBT_IN =  1,                   // ingresso nel box
                      ILBT_OUT = 2,                   // uscita dal box
                      ILBT_TG_INI = 3,                // ingresso tangente in una faccia del box
                      ILBT_TG_FIN = 4,                // uscita tangente da una faccia del box
-                      ILBT_TOUCH = 5,                 // contatto su uno spigolo o su un vertice del box
-                      ILBT_INSIDE = 6,                // contenimento nel box
-                      ILBT_TG_INSIDE = 7} ;              // contenimento su faccia del box
+                      ILBT_TOUCH = 5} ;               // contatto su uno spigolo o su un vertice del box
@@ -1,89 +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
-
-//-----------------------------------------------------------------------------
-// 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} ;
-
-//-----------------------------------------------------------------------------
-// Tipo di intersezione linea-triangolo ausiliario (della trimesh ausilaria)
-enum IntLineTriaAuxType { ILTA_NO_TRIA = -1,       // l'intersezione è stata calcolata direttamente con la superficie bezier
-                          ILTA_NO = 0,            // non c'è intersezione
-                          ILTA_SEGM = 1,          // una parte di linea appartiene all'interno del triangolo
-                          ILTA_SEGM_ON_EDGE = 2,  // una parte di linea appartiene ad un lato del triangolo
-                          ILTA_VERT = 3,          // intersezione coincide con un vertice
-                          ILTA_EDGE = 4,          // intersezione coincide con interno di un lato
-                          ILTA_IN = 5} ;          // intersezione in interno del triangolo
-
-//-----------------------------------------------------------------------------
-//! dati di intersezione linea - superficie bezier
-struct IntLinSbzInfo {
-   int     nILSB ;          //!< tipo di intersezione linea-bezier
-   double  dU ;             //!< parametro sulla linea
-   double  dU2 ;            //!< secondo parametro sulla linea
-   int     nT ;             //!< indice del triangolo della superficie trimesh  // se -1 vuol dire che l'intersezione � stata calcolata direttamente, senza usare la trimesh
-   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) : nILSB( LSBT_NONE), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2(), ptUV(), ptUV2(){}
-   IntLinSbzInfo( int nILS, double dUU, int nTT, double dCos, const Point3d& ptP, const Point3d ptSP)
-      : nILSB( nILS), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2(), ptUV( ptSP), ptUV2() {}
-   IntLinSbzInfo( int nILS, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2, const Point3d& ptSP, const Point3d& ptSP2)
-      : nILSB( nILS), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2), ptUV( ptSP), ptUV2( ptSP2) {}
-} ;
-//! vettore di IntLinSbzInfo
-typedef std::vector<IntLinSbzInfo>  ILSBIVECTOR ;
-
-//-----------------------------------------------------------------------------
-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) ;
@@ -29,31 +29,21 @@
 //! 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
-   int     nStm ;           //!< indice della superficie TriMesh di intersezione
+   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), nStm( 0), nT( 0), dCosDN( 0), ptI(), ptI2() {}
-   IntLinStmInfo( int nIL, double dUU, int nSurfTm, int nTT, double dCos, const Point3d& ptP)
-      : nILTT( nIL), dU( dUU), dU2( 0), nStm( nSurfTm), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2() {}
-   IntLinStmInfo( int nIL, double dUU, double dUU2, int nSurfTm, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2)
-      : nILTT( nIL), dU( dUU), dU2( dUU2), nStm( nSurfTm), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2) {}
+   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)
+      : nILTT( nIL), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2) {}
 } ;
 //! 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} ;
+typedef std::vector<IntLinStmInfo>  ILSIVECTOR ;

 //-----------------------------------------------------------------------------
 EGK_EXPORT bool IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfTriMesh& Stm,
@@ -64,19 +54,11 @@ class IntersParLinesSurfTm
 {
   public :
      EGK_EXPORT IntersParLinesSurfTm( const Frame3d& frLines, const ISurfTriMesh& Stm) ;
-      EGK_EXPORT IntersParLinesSurfTm( const Frame3d& frLines, const CISURFTMPVECTOR& vStm) ;
      EGK_EXPORT bool GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vInfo, bool bFinite = true) const ;

-   private :
-      int GetSurfInd( int nT) const ;
-
   private :
      bool                m_bOk ;
-      const Frame3d       m_frLines ;     // direzione della linea come versore Z
-      CISURFTMPVECTOR     m_vpSTm ;       // vettore delle superfici con cui calcolare le intersezioni con le linee
-      INTVECTOR           m_vBaseInd ;    // [0, nTriaStm0, nTriaStm0 + nTriaStm1, nTriaStm0 + nTriaStm1 + nTriaStm2, ...]
-      HashGrids2d         m_HGrids ;      // HasGrid di ottimizzazione per ricerca triangoli
+      const Frame3d       m_frLines ;
+      const ISurfTriMesh* m_pSTm ;
+      HashGrids2d         m_HGrids ;
 } ;
-
-//-----------------------------------------------------------------------------
-EGK_EXPORT bool FilterLineSurfTmInters( const ILSIVECTOR& vInfo, INTDBLVECTOR& vInters) ;
@@ -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) ;
@@ -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) ;
@@ -1,19 +1,18 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2022
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EGkIntersPlaneBox.h      Data : 09.01.22         Versione : 2.4a3
+// File : EGkIntersPlaneBox.h      Data : 08.05.20         Versione : 2.2e1
 // Contenuto : Dichiarazione della classe intersezione piano/box.
 //
 //
 //
 // Modifiche : 08.05.20 DS Creazione modulo.
-//             09.01.22 DS Aggiunta TestIntersPlaneBox.
+//
 //
 //----------------------------------------------------------------------------

 #pragma once

-#include "/EgtDev/Include/EGkPlane3d.h"
 #include "/EgtDev/Include/EGkBBox3d.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"

@@ -26,6 +25,5 @@
 #endif

 //-----------------------------------------------------------------------------
-EGK_EXPORT bool TestIntersPlaneBox( const Plane3d& plPlane, const BBox3d& b3Box) ;
-EGK_EXPORT bool IntersPlaneBox( const Plane3d& plPlane, const BBox3d& b3Box,
+EGK_EXPORT bool IntersPlaneBox( const Point3d& ptOn, const Vector3d& vtN, const BBox3d& b3Box,
                                PNTVECTOR& vPnt, BIPNTVECTOR& vBpt, TRIA3DVECTOR& vTria) ;
@@ -14,7 +14,6 @@
 #pragma once

 #include "/EgtDev/Include/EGkSurfTriMesh.h"
-#include "/EgtDev/Include/EGkHashGrids1d.h"

 //----------------------- Macro per import/export ----------------------------
 #undef EGK_EXPORT
@@ -27,18 +26,3 @@
 //-----------------------------------------------------------------------------
 EGK_EXPORT bool IntersPlaneSurfTm( const Plane3d& plPlane, const ISurfTriMesh& Stm,
                                   PNTVECTOR& vPnt, BIPNTVECTOR& vBpt, TRIA3DVECTOR& vTria) ;
-
-
-//-----------------------------------------------------------------------------
-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 ;
-
-   private :
-      bool                m_bOk ;
-      const Frame3d       m_frPlanes ;
-      const ISurfTriMesh* m_pSTm ;
-      HashGrids1d         m_HGrids ;
-} ;
@@ -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) ;
@@ -32,17 +32,16 @@ EGK_EXPORT int IntersTriaTria( const Triangle3d& trTria1, const Triangle3d& trTr

 //-----------------------------------------------------------------------------
 // Tipo di intersezione triangolo-triangolo  
-enum IntTriaTriaType { ITTT_NO = 0,                // non c'è intersezione
-                       ITTT_OVERLAPS = 1,          // i triangoli si sovrappongono (i triangoli del poligono sono in vTria)
-                       ITTT_VERT_VERT = 2,         // intersezione coppia di vertici
-                       ITTT_VERT_EDGE = 3,         // vertice del primo su lato del secondo
-                       ITTT_EDGE_VERT = 4,         // vertice del secondo su lato del primo
-                       ITTT_VERT_INT = 5,          // vertice del primo nell'interno del secondo
-                       ITTT_INT_VERT = 6,          // vertice del secondo nell'interno del primo
-                       ITTT_EDGE_EDGE_PNT = 7,     // punto sull'intersezione di due lati
-                       ITTT_EDGE_EDGE_SEG = 8,     // sovrapposizione di lati
-                       ITTT_EDGE_INT = 9,          // lato del primo nell'interno del secondo
-                       ITTT_INT_EDGE = 10,         // lato del secondo nell'interno del primo
-                       ITTT_INT_INT_SEG = 11,      // segmento all'interno di entrambi i triangoli
-                       ITTT_COUNTER_OVERLAPS = 12  // triangoli sovrapposti controversi (i triangoli del poligono sono in vTria)
+enum IntTriaTriaType { ITTT_NO = 0,            // non c'è intersezione
+                       ITTT_OVERLAPS = 1,      // i triangoli si sovrappongono (i triangoli del poligono sono in vTria)
+                       ITTT_VERT_VERT = 2,     // intersezione coppia di vertici
+                       ITTT_VERT_EDGE = 3,     // vertice del primo su lato del secondo
+                       ITTT_EDGE_VERT = 4,     // vertice del secondo su lato del primo
+                       ITTT_VERT_INT = 5,      // vertice del primo nell'interno del secondo
+                       ITTT_INT_VERT = 6,      // vertice del secondo nell'interno del primo
+                       ITTT_EDGE_EDGE_PNT = 7, // punto sull'intersezione di due lati
+                       ITTT_EDGE_EDGE_SEG = 8, // sovrapposizione di lati
+                       ITTT_EDGE_INT = 9,      // lato del primo nell'interno del secondo
+                       ITTT_INT_EDGE = 10,     // lato del secondo nell'interno del primo
+                       ITTT_INT_INT_SEG = 11,  // segmento all'interno di entrambi i triangoli
                     } ;
@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : EGkLuaAux.h       Data : 08.05.24        Versione : 2.6e2
+// 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.
-//             08.05.24 DS Aggiunta LuaSetParam per VCT3DVECTOR.
+//
 //
 //----------------------------------------------------------------------------

@@ -18,25 +17,20 @@
 #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"
-#include "/EgtDev/Include/EGnLuaAux.h"
+#include "/EgtDev/Include/EgnLuaAux.h"

 //----------------------------------------------------------------------------
 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
@@ -120,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)
@@ -277,60 +264,6 @@ LuaSetParam( lua_State* L, const Vector3d& vtPar)
   return true ;
 }

-//-------------------------------------------------------------------------------
-inline bool
-LuaSetParam( lua_State* L, const PNTVECTOR& vPar)
-{
-   try {
-     // recupero dimensione vettore
-      int nDim = int( vPar.size()) ;
-     // creo tavola principale
-      lua_createtable( L, nDim, 0) ;
-     // creo e inserisco tavola per ogni componente
-      for ( int i = 1 ; i <= nDim ; ++ i) {
-        // creo tavola componente
-         lua_createtable( L, 3, 0) ;
-         for ( int j = 1 ; j <= 3 ; ++ j) {
-            lua_pushnumber( L, vPar[i-1].v[j-1]) ;
-            lua_rawseti( L, -2, j) ;
-         }
-        // la metto nel vettore
-         lua_rawseti( L, -2, i) ;
-      }
-   }
-   catch( ...) {
-      return false ;
-   }
-   return true ;
-}
-
-//-------------------------------------------------------------------------------
-inline bool
-LuaSetParam( lua_State* L, const VCT3DVECTOR& vPar)
-{
-   try {
-     // recupero dimensione vettore
-      int nDim = int( vPar.size()) ;
-     // creo tavola principale
-      lua_createtable( L, nDim, 0) ;
-     // creo e inserisco tavola per ogni componente
-      for ( int i = 1 ; i <= nDim ; ++ i) {
-        // creo tavola componente
-         lua_createtable( L, 3, 0) ;
-         for ( int j = 1 ; j <= 3 ; ++ j) {
-            lua_pushnumber( L, vPar[i-1].v[j-1]) ;
-            lua_rawseti( L, -2, j) ;
-         }
-         // la metto nel vettore
-         lua_rawseti( L, -2, i) ;
-      }
-   }
-   catch( ...) {
-      return false ;
-   }
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 inline bool
 LuaSetParam( lua_State* L, const Point3d& ptPar)
@@ -436,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)
@@ -1,27 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2022-2022
-//----------------------------------------------------------------------------
-// File : MedialAxis.h           Data : 22.08.22         Versione : 2.4h2
-// Contenuto : Dichiarazione funzione calcolo MedialAxis principale.
-//
-//
-//
-// Modifiche : 22.08.22 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkCurve.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 CurveSimpleMedialAxis( const ICurve* pCrv, PolyLine& PL) ;
@@ -1,30 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025-2025
-//----------------------------------------------------------------------------
-// File : MultiGeomDB.h       Data : 22.12.25          Versione : 2.7l3
-// Contenuto : Dichiarazione delle funzioni tra due GeomDB.
-//
-//
-//
-// Modifiche : 08.10.25 DB Creazione modulo.
-//             22.12.25 DS Aggiunta funzione DuplicateGeomDB.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkGeomDB.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 int  Copy( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter = GDB_LAST_SON) ;
-EGK_EXPORT int  CopyGlob( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter = GDB_LAST_SON) ;
-EGK_EXPORT bool DuplicateGeomDB( IGeomDB* pSouGeomDB, IGeomDB* pDestGeomDB, bool bSkipTemp = false) ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2014-2019
 //----------------------------------------------------------------------------
-// File : EGkObjGraphics.h       Data : 08/03/19        Versione : 2.1c1
+// File : EgkObjGraphics.h       Data : 08/03/19        Versione : 2.1c1
 // Contenuto : Dichiarazione della interfaccia IObjGraphics.
 //
 //
@@ -1,13 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2025
+//  EgalTech 2015-2019
 //----------------------------------------------------------------------------
-// File : EGkOffsetCurve.h       Data : 08.04.25       Versione : 2.7d1
+// File : EGkOffsetCurve.h       Data : 24.06.19       Versione : 2.1f2
 // Contenuto : Dichiarazione classe per offset di ICurve.
 //
 //
 // Modifiche : 23.09.15 DS Creazione modulo.
 //             24.06.19 DS Agg. GetShorterCurve.
-//             08.04.25 SP Agg. GetPointOffset.
 //
 //----------------------------------------------------------------------------

@@ -27,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 :
@@ -38,13 +35,7 @@ class OffsetCurve
      EGK_EXPORT ICurve* GetCurve( void) ;
      EGK_EXPORT ICurve* GetLongerCurve( void) ;
      EGK_EXPORT ICurve* GetShorterCurve( void) ;
-      EGK_EXPORT bool GetPointOffset( Point3d& ptOffs, Vector3d& vtOut) ;
-      EGK_EXPORT double GetLinTol( void) const { return m_dLinTol ; }
-      EGK_EXPORT void SetLinTol( double dTol) { m_dLinTol = dTol ; }

   private :
      ICURVEPLIST m_CrvLst ;
-      Point3d m_ptOffs = P_INVALID ;
-      Vector3d m_vtOut = V_INVALID ;
-      double m_dLinTol ;
 } ;
@@ -8,7 +8,6 @@
 //
 // Modifiche : 08.04.14 DS Creazione modulo.
 //             25.02.15 DS Agg. PointInPlane*.
-//             05.09.25 RE Agg. funzioni di confronto tra due piani
 //
 //----------------------------------------------------------------------------

@@ -39,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 ;
@@ -155,27 +144,3 @@ PointInPlaneExact( const Point3d& ptP, const Plane3d& plPlane)
 {
   return ( abs( (( ptP - ORIG) * plPlane.GetVersN()) - plPlane.GetDist()) < EPS_ZERO) ;
 }
-
-//-----------------------------------------------------------------------------
-inline bool
-AreSamePlaneEpsilon( const Plane3d& plPlaneA, const Plane3d& plPlaneB, double dToler)
-{
-   return ( AreSameVectorEpsilon( plPlaneA.GetVersN(), plPlaneB.GetVersN(), dToler)  &&
-            PointInPlaneEpsilon( plPlaneA.GetPoint(), plPlaneB, dToler)) ;
-}
-
-//-----------------------------------------------------------------------------
-inline bool
-AreSamePlaneApprox( const Plane3d& plPlaneA, const Plane3d& plPlaneB)
-{
-   return ( AreSameVectorApprox( plPlaneA.GetVersN(), plPlaneB.GetVersN())  &&
-            PointInPlaneApprox( plPlaneA.GetPoint(), plPlaneB)) ;
-}
-
-//-----------------------------------------------------------------------------
-inline bool
-AreSamePlaneExact( const Plane3d& plPlaneA, const Plane3d& plPlaneB)
-{
-   return ( AreSameVectorExact( plPlaneA.GetVersN(), plPlaneB.GetVersN())  &&
-            PointInPlaneExact( plPlaneA.GetPoint(), plPlaneB)) ;
-}
@@ -1,13 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2023
+//  EgalTech 2013-2014
 //----------------------------------------------------------------------------
-// File : EGkPoint3d.h           Data : 23.08.23          Versione : 2.5h2
+// File : EGkPoint3d.h           Data : 30.05.14          Versione : 1.5e10
 // 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,
@@ -323,16 +317,7 @@ DirDist( const Point3d& ptP1, const Point3d& ptP2, Vector3d& vtDir, double& dDis
 inline bool
 AreSamePointEpsilon( const Point3d& ptP1, const Point3d& ptP2, double dToler)
 {
-   double dX = ptP1.x - ptP2.x ;
-   if ( abs( dX) > dToler)
-      return false ;
-   double dY = ptP1.y - ptP2.y ;
-   if ( abs( dY) > dToler)
-      return false ;
-   double dZ = ptP1.z - ptP2.z ;
-   if ( abs( dZ) > dToler)
-      return false ;
-   return ( ( dX * dX + dY * dY + dZ * dZ) < ( dToler * dToler)) ;
+   return ( SqDist( ptP1, ptP2) < ( dToler * dToler)) ;
 }

 //----------------------------------------------------------------------------
@@ -350,16 +335,7 @@ AreSamePointXYEpsilon( const Point3d& ptP1, const Point3d& ptP2, double dToler)
 inline bool
 AreSamePointApprox( const Point3d& ptP1, const Point3d& ptP2)
 {
-   double dX = ptP1.x - ptP2.x ;
-   if ( abs( dX) > EPS_SMALL)
-      return false ;
-   double dY = ptP1.y - ptP2.y ;
-   if ( abs( dY) > EPS_SMALL)
-      return false ;
-   double dZ = ptP1.z - ptP2.z ;
-   if ( abs( dZ) > EPS_SMALL)
-      return false ;
-   return ( ( dX * dX + dY * dY + dZ * dZ) < SQ_EPS_SMALL) ;
+   return ( SqDist( ptP1, ptP2) < SQ_EPS_SMALL) ;
 }

 //----------------------------------------------------------------------------
@@ -377,16 +353,7 @@ AreSamePointXYApprox( const Point3d& ptP1, const Point3d& ptP2)
 inline bool
 AreSamePointExact( const Point3d& ptP1, const Point3d& ptP2)
 {
-   double dX = ptP1.x - ptP2.x ;
-   if ( abs( dX) > EPS_ZERO)
-      return false ;
-   double dY = ptP1.y - ptP2.y ;
-   if ( abs( dY) > EPS_ZERO)
-      return false ;
-   double dZ = ptP1.z - ptP2.z ;
-   if ( abs( dZ) > EPS_ZERO)
-      return false ;
-   return ( ( dX * dX + dY * dY + dZ * dZ) < SQ_EPS_ZERO) ;
+   return ( SqDist( ptP1, ptP2) < SQ_EPS_ZERO) ;
 }

 //----------------------------------------------------------------------------
@@ -397,36 +364,3 @@ AreSamePointXYExact( const Point3d& ptP1, const Point3d& ptP2)
 {
   return ( SqDistXY( ptP1, ptP2) < SQ_EPS_ZERO) ;
 }
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia in locale del punto passato
-//----------------------------------------------------------------------------
-inline const Point3d
-GetToLoc( const Point3d& ptP, const Frame3d& frRef)
-{
-   Point3d ptQ = ptP ;
-   ptQ.ToLoc( frRef) ;
-   return ptQ ;
-}
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia in globale del punto passato
-//----------------------------------------------------------------------------
-inline const Point3d
-GetToGlob( const Point3d& ptP, const Frame3d& frRef)
-{
-   Point3d ptQ = ptP ;
-   ptQ.ToGlob( frRef) ;
-   return ptQ ;
-}
-
-//----------------------------------------------------------------------------
-//! Restituisce una copia dal primo al secondo riferimento del punto passato
-//----------------------------------------------------------------------------
-inline const Point3d
-GetLocToLoc( const Point3d& ptP, const Frame3d& frOri, const Frame3d& frDest)
-{
-   Point3d ptQ = ptP ;
-   ptQ.LocToLoc( frOri, frDest) ;
-   return ptQ ;
-}
@@ -13,7 +13,7 @@

 #pragma once

-#include "/EgtDev/Include/EGkBBox3d.h"
+#include "/EgtDev/Include/EgkBBox3d.h"
 #include "/EgtDev/Include/EgtNumCollection.h"
 #include <unordered_map>

@@ -108,51 +108,27 @@ class PolyLine
      EGK_EXPORT bool GetMaxDistanceFromLine( const Point3d& ptLine, const Vector3d& vtLine, double dLen,
                                              double& dMaxDist,  bool bIsSegment = true) const ;
      EGK_EXPORT bool AdjustForMaxSegmentLen( double dMaxLen) ;
-      EGK_EXPORT bool RemoveAlignedPoints( double dToler = EPS_SMALL, bool bStartEnd = true) ;
+      EGK_EXPORT bool RemoveAlignedPoints( double dToler = EPS_SMALL) ;
      EGK_EXPORT bool ApproxOnSide( const Vector3d& vtN, bool bLeftSide, double dToler = EPS_SMALL) ;
      EGK_EXPORT bool MakeConvex( const Vector3d& vtN,  bool bLeftSide) ;
      EGK_EXPORT bool Invert( bool bInvertU = true) ;
      EGK_EXPORT bool Flatten( double dZ = 0) ;
-      EGK_EXPORT bool FlattenInAutoPlane( double dToler = 10 * EPS_SMALL) ;
      EGK_EXPORT bool GetConvexHullXY( PNTVECTOR& vConvHull) const ;
      EGK_EXPORT bool GetMinAreaRectangleXY( Point3d& ptCen, Vector3d& vtAx, double& dLen, double& dHeight) const ;
      EGK_EXPORT bool Trim( const Plane3d& plPlane, bool bInVsOut = true) ;
-      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) ; }
-      EGK_EXPORT bool FromPointVector( const PNTVECTOR& vPnt)
-                      {  Clear() ;
-                         for ( int i = 0 ; i < std::ssize( vPnt) ; ++i)
-                            AddUPoint( i, vPnt[i]) ;
-                         return GetPointNbr() > 0 ; }

   private :
      bool MyChangeStart( int nPos) ;
      bool MyApproxOnSide( const Vector3d& vtN, bool bLeftSide, double dToler = EPS_SMALL) ;
      bool MyMakeConvex( const Vector3d& vtN,  bool bLeftSide) ;
-      bool MyRemoveSamePoints( double dToler = EPS_SMALL) ;

   private :
-      int      m_nRejected ;                       // numero punti rifiutati perchè coincidenti
-      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
-
-//----------------------------------------------------------------------------
-EGK_EXPORT bool DistPointPolyLine( const Point3d& ptP, const PolyLine& plPoly, double& dDist) ;
-EGK_EXPORT bool DistPointPolyLine( const Point3d& ptP, const PolyLine& plPoly, double& dDist, double& dMinDistPar) ;
-EGK_EXPORT bool IsPointInsidePolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler) ;
-EGK_EXPORT bool GetPointParamOnPolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler, double& dPar) ;
-EGK_EXPORT bool ChangePolyLineStart( PolyLine& plPoly, const Point3d& ptNewStart, double dToler) ;
-EGK_EXPORT bool SplitPolyLineAtPoint( const PolyLine& plPoly, const Point3d& ptP, double dToler, PolyLine& plPoly1, PolyLine& plPoly2) ;
-EGK_EXPORT bool AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIVECTOR& vPnt1, PNTIVECTOR& vPnt2, bool& bCommonInternalPoints) ;
-EGK_EXPORT bool MatchPolyLinesAddingPoints( const PolyLine& PL1, const PolyLine& PL2, int nType, PNTIVECTOR& vPnt1, PNTIVECTOR& vPnt2) ;
+typedef std::vector<PolyLine>  POLYLINEVECTOR ;   // vettore di PolyLine
+typedef std::list<PolyLine>    POLYLINELIST ;     // lista di PolyLine
@@ -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
@@ -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) ;
@@ -1,64 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2026
-//----------------------------------------------------------------------------
-// File : EGkProjectCurveSurfTm.h     Data : 14.04.26      Versione : 3.1d3
-// Contenuto : Dichiarazione funzioni proiezione curve su superficie Trimesh.
-//
-//
-//
-// Modifiche : 31.08.23 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkGeoPoint3d.h"
-#include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkSurf.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
-
-//----------------------------------------------------------------------------
-// Definizione di Punto 5assi e sue raccolte
-struct Point5ax {
-   Point3d  ptP ;
-   Vector3d vtDir1 ;
-   Vector3d vtDir2 ;
-   Vector3d vtDirU ;
-   Vector3d vtDirV ;
-   double   dPar ;
-   int      nFlag ;
-   Point5ax( void) : ptP(), vtDir1(), vtDir2(), vtDirU(), vtDirV(), dPar(), nFlag() {} ;
-   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, double dU, int nData)
-      : ptP( ptBase), vtDir1( vtTool), vtDir2(), vtDirU(), vtDirV(), dPar( dU), nFlag( nData) {} ;
-   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2, double dU, int nData)
-      : ptP( ptBase), vtDir1( vtTool), vtDir2( vtTool2), vtDirU(), vtDirV(), dPar( dU), nFlag( nData) {} ;
-   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2,
-             const Vector3d& vtDU, const Vector3d& vtDV, double dU, int nData)
-      : ptP( ptBase), vtDir1( vtTool), vtDir2( vtTool2), vtDirU( vtDU), vtDirV( vtDV), dPar( dU), nFlag( nData) {} ;
-} ; 
-typedef std::vector<Point5ax>        PNT5AXVECTOR ;    // vettore di Punti 5assi
-
-//----------------------------------------------------------------------------
-// Proiezione di una curva su una o più superfici a distanza minima
-EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici lungo la direzione data (da o verso)
-EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vector3d& vtDir,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici in direzione del punto (da o verso)
-EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeoPoint3d& gpRef,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici in direzione della curva (da o verso)
-EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICurve& crRef,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici in direzione della superficie (da o verso)
-EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISurf& sfRef,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
@@ -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)) ;
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
riccardo.elitropi	09a836c4a6	Include : - altra prova commit.	2022-06-06 10:51:02 +02:00
riccardo.elitropi	8c1df8cd87	Include : - prova commit.	2022-06-06 10:47:54 +02:00