Merge branch 'master' into CmdCreateSurfBezier

- modificato il nome di una funzione per le Bezier.

EGkCDeBoxClosedSurfTm.h

@@ -24,4 +24,11 @@
 #endif
 
 //----------------------------------------------------------------------------
-EGK_EXPORT bool CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, const ISurfTriMesh& Stm) ;
+// 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) ;

EGkCDeClosedSurfTmClosedSurfTm.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2023
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File :      EGkCDeClosedSurfTmClosedSurfTm.h      Data : 14.06.23    Versione : 2.5f3
+// File : EGkCDeClosedSurfTmClosedSurfTm.h  Data : 15.02.24  Versione : 2.6b2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             SurfTm e SurfTm.
 //
@@ -23,8 +23,10 @@
 #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) ;

EGkCDeConeFrustumClosedSurfTm.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : EGkCDeConeFrustumClosedSurfTm.h      Data : 09.11.20    Versione : 
+// File : EGkCDeConeFrustumClosedSurfTm.h   Data : 15.02.24  Versione : 2.6b2
 // Contenuto : Dichiarazione funzione verifica collisione tra
 //             Cone e Closed SurfTriMesh.
 //
@@ -23,8 +23,11 @@
 #endif
 
 //----------------------------------------------------------------------------
-// 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.
+// 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.
 EGK_EXPORT bool CDeConeFrustumClosedSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                                            double dSafeDist, const ISurfTriMesh& Stm) ;
+                                            const ISurfTriMesh& Stm, double dSafeDist) ;

EGkCDeConvexTorusClosedSurfTm.h

@@ -24,9 +24,12 @@
 #endif
 
 //----------------------------------------------------------------------------
-// Il toro convesso è il disco limitato dalla sola parte esterna del toro.
+// Il toro convesso è il disco solido 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.
+// 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, 
-                                            double dSafeDist, const ISurfTriMesh& tmSurf) ;
+                                            const ISurfTriMesh& tmSurf, double dSafeDist) ;

EGkCDeCylClosedSurfTm.h

@@ -23,4 +23,11 @@
 #endif
 
 //----------------------------------------------------------------------------
-EGK_EXPORT bool CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, double dSafeDist, const ISurfTriMesh& Stm) ;
+// 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) ;

EGkCDeRectPrismoidClosedSurfTm.h

@@ -26,6 +26,10 @@
 // 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,
-                                             double dSafeDist, const ISurfTriMesh& Stm) ;
+                                             const ISurfTriMesh& Stm, double dSafeDist) ;

EGkCDeSpheClosedSurfTm.h

@@ -23,4 +23,8 @@
 #endif
 
 //----------------------------------------------------------------------------
-EGK_EXPORT bool CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, double dSafeDist, const ISurfTriMesh& Stm) ;
+// 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) ;

EGkColor.h

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

EGkCurve.h

@@ -19,8 +19,6 @@
 #include "/EgtDev/Include/EGkPlane3d.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
-class Voronoi ;
-
 //----------------------------------------------------------------------------
 class __declspec( novtable) ICurve : public IGeoObj
 {
@@ -94,7 +92,6 @@ class __declspec( novtable) ICurve : public IGeoObj
       virtual bool TrimEndAtLen( double dLenTrim) = 0 ;
       virtual bool ExtendStartByLen( double dLenExt) = 0 ;
       virtual bool ExtendEndByLen( double dLenExt) = 0 ;
-      virtual Voronoi* GetVoronoiObject( void) const = 0 ;
 } ;
 
 //----------------------------------------------------------------------------

EGkCurveAux.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2014-2014
 //----------------------------------------------------------------------------
-// File : EGkCurveAux.h         Data : 23.05.14          Versione : 1.5e9
+// File : EGkCurveAux.h         Data : 28.01.24          Versione : 2.6a2
 // Contenuto : Dichiarazione funzioni ausiliarie per ICurve.
 //
 //
@@ -86,8 +86,15 @@ EGK_EXPORT bool CalcCurveVoronoiDiagram( const ICurve& crvC, ICURVEPOVECTOR& vCr
 
 //----------------------------------------------------------------------------
 //! Calcolo del Medial Axis della curva (sottoinsieme del diagramma di Voronoi), nei TempParam dei risultati la distanza
+const int WMAT_BOTHSIDES = 0 ;
+const int WMAT_LEFT = 1 ;
+const int WMAT_RIGHT = 2 ;
 EGK_EXPORT bool CalcCurveMedialAxis( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nSide) ;
 
 //----------------------------------------------------------------------------
 //! Calcola l'offset completo di una curva
 EGK_EXPORT bool CalcCurveFatCurve( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dRadius, bool bSquareEnds, bool bSquareMids) ;
+
+//----------------------------------------------------------------------------
+//! Resetta l'oggetto voronoi associato alla curva liberandone la memoria
+EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;

EGkCurveComposite.h

@@ -70,6 +70,8 @@ class __declspec( novtable) ICurveComposite : public ICurve
       virtual bool GetCurveTempProp( int nCrv, int& nProp, int nPropInd = 0) const = 0 ;
       virtual bool SetCurveTempParam( int nCrv, double dParam, int nParamInd = 0) = 0 ;
       virtual bool GetCurveTempParam( int nCrv, double& dParam, int nParamInd = 0) const = 0 ;
+      virtual bool FromPoint( Point3d& ptStart) = 0 ;
+      virtual bool GetOnlyPoint( Point3d& ptStart) const = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkExtDimension.h

@@ -36,8 +36,11 @@ class __declspec( novtable) IExtDimension : public IGeoObj
                               const Vector3d& vtN, const std::string& sText) = 0 ;
       virtual bool SetDiametral( const Point3d& ptCen, const Point3d& ptPos,
                                  const Vector3d& vtN, const std::string& sText) = 0 ;
-      virtual bool SetAngular( const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptV, const Point3d& ptPos,
-                               const Vector3d& vtN, const std::string& sText ) = 0 ;
+      virtual bool SetAngular( const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
+                               const Vector3d& vtN, const std::string& sText) = 0 ;
+      virtual bool SetAngularEx( const Point3d& ptV1, const Point3d& ptP1,
+                                 const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptPos,
+                                 const Vector3d& vtN, const std::string& sText) = 0 ;
       virtual const Vector3d& GetNormVersor( void) const = 0 ;
       virtual const Vector3d& GetDirVersor( void) const = 0 ;
       virtual const std::string& GetText( void) const = 0 ;

EGkGdbConst.h

@@ -88,3 +88,4 @@ const std::string GDB_SI_DUPLIST = "!DLST" ;         // Duplo Vettore Id entit
 const std::string GDB_SI_DUPMODIF = "!DMOD" ;        // Flag di sorgente per duplo modificato
 const std::string GDB_SI_DUPLOCKED = "!DLOK" ;       // Flag di duplo bloccato (da non aggiornare seguendo originale)
 const std::string GDB_SI_DUPTOUPDATE = "!DTUP" ;     // Flag di duplo da aggiornare quando sbloccato
+const std::string GDB_SI_SHOWEDGES = "!SEDG" ;       // Flag per forzare visualizzazione spigoli vivi anche in shading

EGkGeoObjSave.h

@@ -39,5 +39,40 @@ 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 ;
 }

EGkIntersCurveSurfTm.h

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

EGkIntersLineSurfTm.h

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

EGkIntersLineTria.h

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

EGkIntersLineVolZmap.h

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

EGkIntersPlaneVolZmap.h

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

EGkProjectCurveSurfTm.h

@@ -39,5 +39,5 @@ typedef std::vector<Point5ax>        PNT5AXVECTOR ;    // vettore di Punti 5assi
 
 //----------------------------------------------------------------------------
 // Proiezione di una curva su una superficie TriMesh lungo la direzione data.
-EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir, double dLinTol,
-                                      PNT5AXVECTOR& vPt5ax) ;
+EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir,
+                                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;

EGkStmFromCurves.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2015
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkStmFromCurves.h   Data : 01.02.15       Versione : 1.6b1
+// File : EGkStmFromCurves.h   Data : 27.02.24       Versione : 2.6b4
 // Contenuto : Dichiarazione della classe StmFromTriangleSoup.
 //
 //
 //
 // Modifiche : 19.05.14 DS Creazione modulo.
-//
+//             27.02.24 DS Aggiunta GetSurfTriMeshTransSwept.
 //
 //----------------------------------------------------------------------------
 
@@ -39,7 +39,8 @@ EGK_EXPORT ISurfTriMesh* GetSurfTriMeshByRevolve( const ICurve* pCurve, const Po
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vector3d& vtAx,
                                                    double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRectSwept( double dDimH, double dDimV, double dBevelH, double dBevelV,
-                                                  const ICurve* pGuide, int nCapType, double dLinTol) ;
+                                                  const ICurve* pGuide, int nCapType, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfTriMesh* GetSurfTriMeshTransSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRuled( const Point3d& ptP, const ICurve* pCurve, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, double dLinTol = 10 * EPS_SMALL) ;

EGkSurfBezier.h

@@ -14,6 +14,7 @@
 #pragma once
 
 #include "/EgtDev/Include/EGkSurf.h"
+#include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 class PolyLine ;
@@ -36,7 +37,7 @@ class __declspec( novtable) ISurfBezier : public ISurf
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl) = 0 ;
       virtual bool SetControlPoint( int nIndU, int nIndV, const Point3d& ptCtrl, double dW) = 0 ;
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) = 0 ;
-      virtual bool SetTrimRegion( const ISurfFlatRegion& sfrTrimReg) = 0 ;
+      virtual bool SetTrimRegion( ISurfFlatRegion& sfrTrimReg, bool bIntersectOrSubtrct = true) = 0 ;
       virtual ISurfFlatRegion* GetTrimRegion( void) const = 0 ;
       virtual bool GetInfo( int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) const = 0 ;
       virtual const Point3d& GetControlPoint( int nIndU, int nIndV, bool* pbOk) const = 0 ;
@@ -59,6 +60,19 @@ class __declspec( novtable) ISurfBezier : public ISurf
       virtual bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const = 0 ;
       virtual const ISurfTriMesh* GetAuxSurf( void) const = 0 ;
       virtual bool GetLeaves ( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const = 0 ;
+      virtual bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const = 0 ;
+      virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL) const = 0 ;
+      virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL, const Point3d& ptIPrev, bool* bTroughEdge = nullptr) const = 0 ;
+      virtual bool UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d& ptIPrev, bool* bTroughEdge = nullptr, const Plane3d* plCut = nullptr) const = 0 ;
+      virtual bool UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& vpCC, const Plane3d* pPlCut) const = 0 ;
+      // taglio la parte della superficie dalla parte positiva del versore del piano.
+      // Il booleano indica se tenere eventuali triangoli della trimesh ausiliaria che sono coplanari ed equiversi al piano di taglio
+      virtual bool Cut( const Plane3d& plPlane, bool bSaveOnEq) = 0 ;
+      // funzione da chiamare per calcolare i poli della superficie. NECESSARIO se si vuole tagliare la superficie con un piano
+      virtual bool CalcPoles( void) ;
+      virtual bool IncreaseUV( double& dU, double dx, bool bUOrV, double* dUVCopy = nullptr, bool bModifyOrig = true) const = 0 ;
+      virtual bool IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bModifyOrig) const = 0 ;
+      virtual bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkSurfFlatRegion.h

@@ -17,7 +17,6 @@
 #include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EgkCurveComposite.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EGkVoronoi.h"
 
 class ISurfTriMesh ;
 
@@ -50,9 +49,9 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
       virtual bool GetChunkCentroid( int nChunk, Point3d& ptCen) const ;
       virtual bool GetCurveClassification( const ICurve& Crv, double dLenMin, CRVCVECTOR& ccClass) const = 0 ;
       virtual int  GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion& Other, int nOthChunk) const ;   // compare only outsides
-      virtual Voronoi* GetVoronoiObject( void) const = 0 ;
-      virtual bool CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound = VORONOI_STD_BOUND) const = 0 ;
-      virtual bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide = Voronoi::WMAT_LEFT) const = 0 ;
+      virtual bool CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound = 3) const = 0 ;
+      virtual bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide = 1) const = 0 ;
+      virtual void ResetVoronoiObject( void) const = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------
@@ -86,3 +85,9 @@ const int REGC_IN2 = 2 ;               //!< La seconda regione
 const int REGC_SAME = 3 ;              //!< Le due regioni coincidono
 const int REGC_OUT = 4 ;               //!< Le due regioni sono esterne
 const int REGC_INTERS = 5 ;            //!< Le due regioni si intersecano
+
+//-----------------------------------------------------------------------------
+// Costanti per zona calcolo medial axis della regione
+const int WMAT_IN_OUT = 0 ;
+const int WMAT_IN = 1 ;
+const int WMAT_OUT = 2 ;

EGkSurfTriMesh.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2024
 //----------------------------------------------------------------------------
-// File : EGkSurfTriMesh.h      Data : 10.12.23          Versione : 2.5l2
+// File : EGkSurfTriMesh.h      Data : 05.03.24          Versione : 2.6c2
 // Contenuto : Dichiarazione della interfaccia ISurfTriMesh.
 //
 //
@@ -43,6 +43,7 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual void SetLinearTolerance( double dLinTol) = 0 ;
       virtual void SetBoundaryAngle( double dBoundaryAngDeg) = 0 ;
       virtual void SetSmoothAngle( double dSmoothAngDeg) = 0 ;
+      virtual void SetShowEdges( bool bShow) = 0 ;
       virtual int  AddVertex( const Point3d& ptVert, double dU = -1, double dV = -1) = 0 ;
       virtual bool MoveVertex( int nInd, const Point3d& ptNewVert) = 0 ;
       virtual int  AddTriangle( const int nIdVert[3], int nTFlag = 0) = 0 ;
@@ -67,6 +68,7 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual int  GetTriangleSize( void) const = 0 ;
       virtual double GetLinearTolerance( void) const = 0 ;
       virtual double GetSmoothAngle( void) const = 0 ;
+      virtual bool GetShowEdges( void) const = 0 ;
       virtual bool GetVertex( int nId, Point3d& ptP) const = 0 ;
       virtual bool GetVertexParam( int nId, double& dU, double& dV) const = 0 ;
       virtual int  GetFirstVertex( Point3d& ptP) const = 0 ;

EGkVolZmap.h

@@ -1,49 +1,23 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2023
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkVolZmap.h      Data : 12.09.23          Versione : 2.5i1
+// File : EGkVolZmap.h      Data : 09.03.24          Versione : 2.6c2
 // Contenuto : Dichiarazione della interfaccia IVolZmap.
 //
 //
 //
 // Modifiche : 22.01.15 DS Creazione modulo.
 //             12.09.23 DS Aggiunto metodo IsTriDexel.
-//
+//             09.03.24 DS Aggiunti SetShowEdges e GetShowEdges.
 //
 //----------------------------------------------------------------------------
 
 #pragma once
 
 #include "/EgtDev/Include/EGkGeoObj.h"
-#include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
-#include "/EgtDev/Include/EGkTriangle3d.h"
-#include "/EgtDev/Include/EGkIntersLineTria.h"
-
-// ------------------------- STRUTTURE -----------------------------------------------------------
-// Informazioni su intersezione linea - volume Zmap
-struct IntLineZmapInfo {
-   int     nILTT ;          // Tipo di intersezione linea-triangolo
-   double  dU ;             // Parametro sulla linea
-   double  dU2 ;            // Secondo parametro sulla linea
-   int     nVox ;           // Indice del voxel del triangolo 
-   int     nBlock ;         // Indice del blocco del triangolo
-   Point3d ptI ;            // Punto di intersezione
-   Point3d ptI2 ;           // Secondo punto di intersezione (termine di tratto sovrapposto)
-   Triangle3d trTria ;      // Triangolo 
-  // Costruttori
-   IntLineZmapInfo( void)
-          : nILTT( ILTT_NO), dU( 0), dU2( 0), nVox( -1), nBlock( -1), ptI(), ptI2(), trTria() {}
-   IntLineZmapInfo( int nIL, double dUU, int nVx, int nBl, const Point3d& ptP, Triangle3d& trTr)
-          : nILTT( nIL), dU( dUU), dU2( 0), nVox( nVx), nBlock( nBl), ptI( ptP), ptI2(), trTria( trTr) {}
-   IntLineZmapInfo( int nIL, double dUU, double dUU2, int nVx, int nBl,
-                    const Point3d& ptP, const Point3d& ptP2, Triangle3d& trTr)
-          : nILTT( nIL), dU( dUU), dU2( dUU2), nVox( nVx), nBlock( nBl), ptI( ptP), ptI2( ptP2), trTria( trTr) {}
-} ;
-// Vettore di IntLineZmapInfo
-typedef std::vector<IntLineZmapInfo>    ILZIVECTOR ;
 
 //----------------------------------------------------------------------------
 class __declspec( novtable) IVolZmap : public IGeoObj
@@ -65,6 +39,8 @@ class __declspec( novtable) IVolZmap : public IGeoObj
       virtual bool GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const = 0 ;
       virtual int  GetResolution( void) const = 0 ;
       virtual bool ChangeResolution( int nDexvoxRatio) = 0 ;
+      virtual void SetShowEdges( bool bShow) = 0 ;
+      virtual bool GetShowEdges( void) const = 0 ;
       virtual bool SetToolTolerances( double dLinTol, double dAngTolDeg = 90) = 0 ;
       virtual bool SetStdTool( const std::string& sToolName,
                                double dH, double dR, double dCornR, double dCutterH, int nFlag, bool bFirst) = 0 ;
@@ -89,19 +65,17 @@ class __declspec( novtable) IVolZmap : public IGeoObj
                                 const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
                                 const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) = 0 ;
       virtual bool GetDepth( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength, bool bExact) const = 0 ;
-      virtual bool GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const = 0 ;
-      virtual bool GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) const = 0 ;
-      virtual bool AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool AvoidSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool AvoidCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool AvoidConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop, double dHeight,
-                                     double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool AvoidRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
-                                      double dLenghtTopX, double dLenghtTopY, double dHeight,
-                                      double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool AvoidTorus( const Frame3d& frTorus, double dRadMax, double dRadMin,
-                               double dSafeDist, bool bPrecise = false) const = 0 ;
-      virtual bool AvoidSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool CDeBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool CDeSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool CDeCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool CDeConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop, double dHeight,
+                                   double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool CDeRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
+                                    double dLenghtTopX, double dLenghtTopY, double dHeight,
+                                    double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool CDeTorus( const Frame3d& frTorus, double dRadMax, double dRadMin,
+                             double dSafeDist, bool bPrecise = false) const = 0 ;
+      virtual bool CDeSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecise = false) const = 0 ;
       virtual bool Cut( const Plane3d& plPlane) = 0 ;
       virtual bool Compact( void) = 0 ;
       virtual int  GetPartCount( void) const = 0 ;

EGkVoronoi.h

@@ -1,93 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2015-2023
-//----------------------------------------------------------------------------
-// File : EGkVoronoi.h         Data : 23.11.23          Versione : 2.5k5
-// Contenuto : Dichiarazione della classe Voronoi con libreria VRONI
-//
-//
-//
-// Modifiche : 23.11.23 SP Creazione modulo.
-
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkFrame3d.h"
-#include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkCurveArc.h"
-#include "/EgtDev/Include/EGkCurveBezier.h"
-#include "/EgtDev/Include/EGkCurveComposite.h"
-#include "/EgtDev/Include/EGkCurveLine.h"
-#include "/EgtDev/Extern/vroni/Include/vroni_object.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
-
-static const int VORONOI_STD_BOUND = 3 ;
-static const double VRONI_OFFS_TOL = 1e-14 ;
-
-//-------------------------- Forward Definitions -------------------------------
-class ISurfFlatRegion ;
-
-//----------------------------------------------------------------------------
-class Voronoi
-{
-   public :
-     // costanti per il lato del medial axis
-      enum WMATSide { WMAT_LEFT = 0,
-                      WMAT_RIGHT = 1,
-                      WMAT_BOTHSIDES = 2} ;
-   public :
-      EGK_EXPORT Voronoi( void)
-                    : m_vroni( nullptr), m_nBound( VORONOI_STD_BOUND), m_bVDComputed( false), m_bAllowAdd( true) {} ;
-      EGK_EXPORT Voronoi( const ICurve* pCrv, bool bAllowAdd) ;
-      EGK_EXPORT Voronoi( const ISurfFlatRegion* pSfr, bool bAllowAdd) ;
-      EGK_EXPORT ~Voronoi( void) ;
-
-   public :
-      EGK_EXPORT bool AddCurve( const ICurve* pCrv) ;
-      EGK_EXPORT bool AddSurfFlatRegion( const ISurfFlatRegion* pSfr) ;
-      EGK_EXPORT ICurve* GetCurve( int nId) const ;
-      EGK_EXPORT int GetCurveCount( void) const
-                        { return m_vpCrvs.size() ; } ;
-
-      EGK_EXPORT bool CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound = VORONOI_STD_BOUND) ;
-      EGK_EXPORT bool CalcOffset( ICURVEPOVECTOR& vOffs, double dOffs, int nType) ;
-      EGK_EXPORT bool CalcFatCurve( ICURVEPOVECTOR& vOffs, double dOffs, bool bSquareEnds, bool bSquareMids) ;
-      EGK_EXPORT bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide) ;
-
-   private :
-      bool Clear( void) ;
-      bool IsValid( void) const
-              { return m_vroni != nullptr ; } ;
-      bool AddCurveToVroni( const ICurve * pCrv) ;
-      bool AddLineToVroni( const ICurveLine* pLine, int& nVroniCrv, int nLoopId, int nCrvId = 0, Point3d ptForcedEnd = P_INVALID) ;
-      bool AddArcToVroni( const ICurveArc* pArc, int& nVroniCrv, int nLoopId, int nCrvId = 0, Point3d ptForcedEnd = P_INVALID) ;
-      bool AddCompoToVroni( const ICurveComposite* pCompo, int& nCrv, int nLoopId) ;
-      bool AddBezierToVroni( const ICurveBezier* pBezier, int& nVroniCrv, int nLoopId) ;
-
-      bool CalcVoronoi( int nBound = VORONOI_STD_BOUND) ;
-      bool CalcVroniOffset( ICRVCOMPOPLIST& vOffs, double dOffs, bool bRightOffs, bool bLeftOffs) ;
-      bool UpdateVoronoi( double dOffs) ;
-      bool VerifyCurvesValidityForOffset( void) ;
-      bool AdjustOpenOffsetCurve( ICurveComposite& pCompo, double dOffs) ;
-      bool AdjustOffsetStart( ICurveComposite& pCompo) ;
-      int GetOffsetCurveSide( const ICurveComposite& pOffs, int nCrv) ;
-      ICurve* GetBisectorCurve( int i) ;
-
-   private :
-      vroniObject*   m_vroni ;        // oggetto base della libreria vroni
-      Frame3d        m_Frame ;        // frame in cui è espresso l'oggetto vroni
-      int            m_nBound ;       // bound associato al diagramma di Voronoi corrente
-      CICURVEPVECTOR m_vpCrvs ;       // curve associate al Voronoi ( espresse rispetto a m_Frame)
-      BBox3d         m_bBox ;         // box degli oggetti associati al Voronoi
-      bool           m_bVDComputed ;  // indica se il diagramma di Voronoi è stato calcolato
-      bool           m_bAllowAdd ;    // indica se possibile aggiungere altre curve/superifici dopo aver creato l'oggetto Voronoi
-} ;

EGnStringUtils.h

@@ -245,7 +245,7 @@ const std::string ToString( const int (&nVal)[size], int nPrec = 1)
 inline const std::string
 ToString( bool bVal)
       { return std::string( ( bVal ? "1" : "0")) ; }
-EGN_EXPORT const std::string ToString( double dVal, int nPrec = 6) ;
+EGN_EXPORT const std::string ToString( double dVal, int nPrec = 6, int* pnErr = nullptr) ;
 template <size_t size>
 const std::string ToString( const double (&dVal)[size], int nPrec = 6)
       { std::string sDest ; sDest.reserve( 14 * size) ;

EGrScene.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2014-2024
 //----------------------------------------------------------------------------
-// File : EGrScene.h          Data : 09.01.24           Versione : 2.5l7
+// File : EGrScene.h          Data : 16.02.24           Versione : 2.6b4
 // Contenuto : Dichiarazione della interfaccia IEGrScene per scena OpenGL.
 //
 //
 //
 // Modifiche : 13.02.14 DS Creazione modulo.
-//
+//             16.02.24 DS Aggiunte Set/Get CameraDirOrizzOffset.
 //
 //----------------------------------------------------------------------------
 
@@ -57,10 +57,12 @@ class IEGrScene
       virtual void Destroy( void) = 0 ;
      // Camera
       virtual bool SetCenter( const Point3d& ptCenter) = 0 ;
+      virtual bool SetCameraDirOrizzOffset( int nRightStepOffset = 0)  = 0 ;
       virtual bool SetCamera( double dAngVertDeg, double dAngOrizzDeg, double dDist) = 0 ;
       virtual bool SetCamera( int nDir, double dDist = 0) = 0 ;
       virtual const Point3d& GetCenter( void) const = 0 ;
       virtual Point3d GetProjectedCenter( void) const = 0 ;
+      virtual int  GetCameraDirOrizzOffset( void) const = 0 ;
       virtual void GetCamera( double* pdAngVertDeg, double* pdAngOrizzDeg, double* pdDist = nullptr) const = 0 ;
       virtual int  GetCameraDir( void) const = 0 ;
       virtual const Vector3d& GetCameraUp( void) const = 0 ;

EInAPI.h

@@ -57,6 +57,7 @@ EIN_EXPORT BOOL __stdcall EgtSetNetHwKey( BOOL bNetHwKey) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyLevel( int nProd, int nVer, int nLev, int* pnKLev) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyOptions( int nProd, int nVer, int nLev, unsigned int* pnOpt2) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyLeftDays( int* pnLeftDays) ;
+EIN_EXPORT BOOL __stdcall EgtGetKeyAssLeftDays( int* pnAssLeftDays) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyOptLeftDays( int* pnOptLeftDays) ;
 EIN_EXPORT BOOL __stdcall EgtGetOsInfo( wchar_t*& wsOs) ;
 EIN_EXPORT BOOL __stdcall EgtGetCpuInfo( wchar_t*& wsCpu) ;
@@ -210,6 +211,15 @@ EIN_EXPORT int  __stdcall EgtCreateVerticalDimension( int nParentId, const doubl
                                                       const double ptDim[3], const wchar_t* wsText, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateAlignedDimension( int nParentId, const double ptP1[3], const double ptP2[3],
                                                      const double ptDim[3], const wchar_t* wsText, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateAngularDimension( int nParentId, const double ptV[3], const double ptP1[3], const double ptP2[3],
+                                                     const double ptDim[3], const wchar_t* wsText, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateAngularDimensionEx( int nParentId, const double ptV1[3], const double ptP1[3],
+                                                       const double ptV2[3], const double ptP2[3], const double ptDim[3],
+                                                       const wchar_t* wsText, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateDiametralDimension( int nParentId, int nCrvId, const double ptDim[3],
+                                                       const wchar_t* wsText, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateRadialDimension( int nParentId, int nCrvId, const double ptDim[3],
+                                                    const wchar_t* wsText, int nRefType) ;
 
 // GeomDB Create Curve
 EIN_EXPORT int  __stdcall EgtCreateLine( int nParentId,
@@ -528,6 +538,8 @@ EIN_EXPORT BOOL __stdcall EgtSurfFrAdd( int nId1, int nId2) ;
 EIN_EXPORT BOOL __stdcall EgtSurfFrSubtract( int nId1, int nId2) ;
 EIN_EXPORT BOOL __stdcall EgtSurfFrIntersect( int nId1, int nId2) ;
 EIN_EXPORT BOOL __stdcall EgtSurfFrOffset( int nId, double dDist, int nType) ;
+EIN_EXPORT BOOL __stdcall EgtSurfTmMoveVertex( int nId, int nVert, const double ptNewVert[3], int nRefType, BOOL bUpdate) ;
+EIN_EXPORT BOOL __stdcall EgtSurfTmMoveFacet( int nId, int nFacet, const double vtMove[3], int nRefType, BOOL bUpdate) ;
 EIN_EXPORT int  __stdcall EgtSurfTmToTriangles( int nId, int* pnCount) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmRemoveFacet( int nId, int nFacet) ;
 EIN_EXPORT BOOL __stdcall EgtCutSurfTmPlane( int nId, const double ptOn[3], const double vtN[3], BOOL bSaveOnEq, int nRefType) ;
@@ -586,6 +598,8 @@ EIN_EXPORT int  __stdcall EgtExtractSurfFrChunkLoops( int nId, int nChunk, int n
 EIN_EXPORT int  __stdcall EgtSurfTmPartCount( int nId) ;
 EIN_EXPORT int  __stdcall EgtSurfTmFacetCount( int nId) ;
 EIN_EXPORT int  __stdcall EgtSurfTmFacetFromTria( int nId, int nT) ;
+EIN_EXPORT BOOL __stdcall EgtSurfTmGetVertex( int nId, int nVert, int nRefId, double ptVert[3]) ;
+EIN_EXPORT BOOL __stdcall EgtSurfTmGetNearestVertex( int nId, const double ptNear[3], int nRefId, int* pnVert, double ptVert[3]) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmFacetNearestEndPoint( int nId, int nFacet, const double ptNear[3], int nRefId,
                                                          double ptEnd[3], double vtNorm[3]) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmFacetNearestMidPoint( int nId, int nFacet, const double ptNear[3], int nRefId,
@@ -724,6 +738,7 @@ EIN_EXPORT BOOL __stdcall EgtGetMachGroupNewName( const wchar_t* wsName, wchar_t
 EIN_EXPORT int  __stdcall EgtAddMachGroup( const wchar_t* wsName, const wchar_t* wsMachineName) ;
 EIN_EXPORT int  __stdcall EgtCopyMachGroup( const wchar_t* wsSouName, const wchar_t* wsName) ;
 EIN_EXPORT BOOL __stdcall EgtRemoveMachGroup( int nMGroupId) ;
+EIN_EXPORT BOOL __stdcall EgtChangeMachGroupName( int nMGroupInd, const wchar_t* wsNewName) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachGroupName( int nMGroupId, wchar_t*& wsName) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachGroupMachineName( int nMGroupId, wchar_t*& wsMachineName) ;
 EIN_EXPORT int  __stdcall EgtGetMachGroupId( const wchar_t* wsName) ;

EMkMachMgr.h

@@ -61,6 +61,7 @@ class __declspec( novtable) IMachMgr
       virtual int  AddMachGroup( const std::string& sName, const std::string& sMachineName) = 0 ;
       virtual int  CopyMachGroup( const std::string& sSouName, const std::string& sName) = 0 ;
       virtual bool RemoveMachGroup( int nId) = 0 ;
+      virtual bool ChangeMachGroupName( int nId, const std::string& sNewName) = 0 ;
       virtual std::string GetMachGroupName( int nId) const = 0 ;
       virtual std::string GetMachGroupMachineName( int nId) const = 0 ;
       virtual int  GetMachGroupId( const std::string& sName) const = 0 ;

EMkMachiningGeoConst.h

@@ -35,7 +35,7 @@ static std::string MCH_ST = "ST" ;
 static std::string MCH_CL = "CL" ;
 static std::string MCH_DBL = "DBL" ;
 static std::string MCH_PATH = "P" ;
-// Nomi di entità CL speciali
+// Nomi di entità CL speciali
 static std::string MCH_CL_CLIMB = "CLIMB" ;
 static std::string MCH_CL_RISE = "RISE" ;
 static std::string MCH_CL_HOME = "HOME" ;
@@ -45,7 +45,7 @@ static std::string MCH_CL_AGB_DWN = "AGBD" ;
 static std::string MCH_CL_AGB_IN = "AGBI" ;
 static std::string MCH_CL_AGB_OUT = "AGBO" ;
 static std::string MCH_CL_AGB_UP = "AGBU" ;
-// Nomi di entità di preview
+// Nomi di entità di preview
 static std::string MCH_PV_CUT = "CUT" ;
 static std::string MCH_PV_PRE_CUT = "PRC" ;
 static std::string MCH_PV_POST_CUT = "POC" ;
@@ -60,6 +60,8 @@ static std::string MCH_PV_DOWN_RCUT = "DRCUT" ;
 static std::string MCH_PV_DOWN_RRCUT = "DRRCUT" ;
 static std::string MCH_PV_DOWN_RLICUT = "DRLICUT" ;
 static std::string MCH_PV_DOWN_RLOCUT = "DRLOCUT" ;
+static std::string MCH_PV_UP_RAWCUT = "RUPCUT" ;
+static std::string MCH_PV_DOWN_RAWCUT = "RDWNCUT" ;
 // Chiave info con WidthT, DeltaTi, DeltaT, ExtraCut e RawBottomHeight lama in Preview
 static std::string MCH_PV_KEY_WT = "WT" ;
 static std::string MCH_PV_KEY_DTI = "DTI" ;
@@ -68,10 +70,10 @@ static std::string MCH_PV_KEY_EC = "EC" ;
 static std::string MCH_PV_KEY_RBH = "RBH" ;
 // Chiave info per rinvio a preview spostato nel pezzo in Preview
 static std::string MCH_PV_KEY_RELOCATE = "PvId" ;
-// Chiave info per angoli in XY con entità successiva e precedente
+// Chiave info per angoli in XY con entità successiva e precedente
 static std::string MCH_KEY_NEXTANG = "NextAng" ;
 static std::string MCH_KEY_PREVANG = "PrevAng" ;
-// Chiave info per direzione libera in XY all'inizio e alla fine dell'entità (in assenza infinito)
+// Chiave info per direzione libera in XY all'inizio e alla fine dell'entità (in assenza infinito)
 static std::string MCH_KEY_START_FREELEN = "SFL" ;
 static std::string MCH_KEY_END_FREELEN = "EFL" ;
 // Angolo esterno minimo per calcolare la direzione libera sull'arco

ENkDijkstra.h

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

EXeConst.h

@@ -67,13 +67,16 @@ enum ApprType{ APP_LINES = 0,                // come ICurve::APL_STD
                APP_RIGHT_CONVEX_LINES = 12,  // come ICurve::APL_RIGHT_CONVEX
                APP_ARCS = 3} ;
 
-//----------------- Costanti tipo punto intersezione Linea SurfTriMesh ---------
-enum SLiType { SLT_NONE =  0,
-               SLT_IN =  1,
-               SLT_OUT = 2,
-               SLT_TG_INI = 3,
-               SLT_TG_FIN = 4,
-               SLT_TOUCH = 5} ;
+//----------------- Costanti tipo punto intersezione Linea Curva ---------------
+enum CLiType { CLT_NONE =  0,
+               CLT_IN =  1,
+               CLT_OUT = 2,
+               CLT_TOUCH_IN = 3,
+               CLT_TOUCH_OUT = 4,
+               CLT_TGINI_IN = 5,
+               CLT_TGFIN_IN = 6,
+               CLT_TGINI_OUT = 7,
+               CLT_TGFIN_OUT = 8} ;
 
 //----------------- Costanti tipo di costruzione di superficie rigata ----------
 enum RuledType{ RUL_TYPE_ISOPAR = 0,          // come ISurfTrimesh::RLT_ISOPAR

EXeExecutor.h

@@ -62,6 +62,7 @@ EXE_EXPORT bool ExeSetNetHwKey( bool bNetHwKey, int nUserId = 0, const std::stri
 EXE_EXPORT bool ExeGetKeyLevel( int nProd, int nVer, int nLev, int& nKLev) ;
 EXE_EXPORT bool ExeGetKeyOptions( int nProd, int nVer, int nLev, unsigned int& nOpt2) ;
 EXE_EXPORT bool ExeGetKeyLeftDays( int& nLeftDays) ;
+EXE_EXPORT bool ExeGetKeyAssLeftDays( int& nAssLeftDays) ;
 EXE_EXPORT bool ExeGetKeyOptLeftDays( int& nOptLeftDays) ;
 EXE_EXPORT bool ExeGetOsInfo( std::string& sOs) ;
 EXE_EXPORT bool ExeGetCpuInfo( std::string& sCpu) ;
@@ -232,8 +233,11 @@ EXE_EXPORT int  ExeCreateAlignedDimension( int nParentId, const Point3d& ptP1, c
                                            const Point3d& ptDim, const std::string& sText, int nRefType) ;
 EXE_EXPORT int  ExeCreateRadialDimension( int nParentId, int nCrvId, const Point3d& ptDim, const std::string& sText, int nRefType) ;
 EXE_EXPORT int  ExeCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim, const std::string& sText, int nRefType) ;
-EXE_EXPORT int  ExeCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2,
+EXE_EXPORT int  ExeCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2,
                                             const Point3d& ptDim, const std::string& sText, int nRefType) ;
+EXE_EXPORT int  ExeCreateAngularDimensionEx( int nParentId, const Point3d& ptV1, const Point3d& ptP1,
+                                             const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptDim,
+                                             const std::string& sText, int nRefType) ;
 EXE_EXPORT int  ExeCreateAngularDimensionFromLines( int nParentId, const INTVECTOR vLineIds, const Point3d& ptDim,
                                                     const std::string& sText, int nRefType) ;
 EXE_EXPORT int  ExeCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDim,
@@ -354,6 +358,7 @@ EXE_EXPORT int  ExeCreateSurfTmByScrewing( int nParentId, int nCrvId,
 EXE_EXPORT int  ExeCreateSurfTmRectSwept( int nParentId, double dDimH, double dDimV, double dBevelH, double dBevelV,
                                           int nGuideId, int nCapType, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol) ;
+EXE_EXPORT int  ExeCreateSurfTmTransSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrCrvId2, int nType, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmByTriangles( int nParentId, const INTVECTOR& vIds, bool bErase) ;
 EXE_EXPORT int  ExeCreateSurfTmBySewing( int nParentId, const INTVECTOR& vIds, bool bErase) ;
@@ -362,6 +367,8 @@ EXE_EXPORT int  ExeCreateSurfTmByVolZmap( int nParentId, int nZmapId, int nPart)
 EXE_EXPORT int  ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTVECTOR& vPnt, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTUVECTOR& vPntW, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBezierLeaves( int nParentId, int nSurfBzId, int nTextHeight = 50, bool bShowTrim = false, int* pnCount = nullptr) ;
+EXE_EXPORT int  ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nRefType) ;
+EXE_EXPORT int  ExeCreateSurfBezierTria2D( int nParentId, int nSurfBzId, int nTextHeight, bool bShowTrim, int* pnCount) ;
 
 // GeomDB Create Volume
 EXE_EXPORT int  ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX,
@@ -539,7 +546,7 @@ EXE_EXPORT bool ExeInvertCurve( const INTVECTOR& vIds) ;
 EXE_EXPORT bool ExeOffsetCurve( int nId, double dDist, int nType) ;
 EXE_EXPORT int  ExeOffsetCurveAdv( int nId, double dDist, int nType, int* pnCount, double dLinTol = 10 * EPS_SMALL) ;
 EXE_EXPORT int  ExeCurveMedialAxis( int nId) ;
-EXE_EXPORT bool ExeApproxCurve( int nId, int nApprType, double dLinTol) ;
+EXE_EXPORT bool ExeApproxCurve( int nId, int nApprType, double dLinTol, double dMaxSegmLen = INFINITO) ;
 EXE_EXPORT bool ExeProjectCurveOnPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, int nRefType) ;
 EXE_EXPORT bool ExeChangeClosedCurveStart( int nId, double dU) ;
 EXE_EXPORT bool ExeChangeClosedCurveStartPoint( int nId, const Point3d& ptP, int nRefType) ;
@@ -591,7 +598,8 @@ EXE_EXPORT bool ExeMergeCurvesInCurveCompo( int nId, double dLinTol, bool bStart
 EXE_EXPORT bool ExeRemoveCurveCompoUndercutOnY( int nId, double dLinTol) ;
 EXE_EXPORT bool ExeChainCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType) ;
 EXE_EXPORT bool ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType) ;
-EXE_EXPORT bool ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId, double dLinTol, int nRefType) ;
+EXE_EXPORT bool ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId,
+                                         double dLinTol, double dMaxSegmLen, int nRefType) ;
 EXE_EXPORT int  ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) ;
 EXE_EXPORT int  ExeCurveGetMedialAxis( int nId, int nDestGrpId, int nSide, int* pnCount) ;
 EXE_EXPORT int  ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, bool bSquareMids, int* pnCount) ;
@@ -604,29 +612,34 @@ EXE_EXPORT bool ExeSurfFrAdd( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrSubtract( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrIntersect( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrOffset( int nId, double dDist, int nType) ;
+EXE_EXPORT bool ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewId) ;
 EXE_EXPORT bool ExeSurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double& dLen, int nRefType) ;
 EXE_EXPORT bool ExeSurfFrRotateSimpleNoCollision( int nId1, int nId2, const Point3d& ptCen, double& dAngDeg, int nRefType) ;
 EXE_EXPORT bool ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType, bool bUpdate) ;
+EXE_EXPORT bool ExeSurfTmMoveFacet( int nId, int nFacet, const Vector3d& vtMove, int nRefType, bool bUpdate) ;
 EXE_EXPORT int  ExeSurfTmToTriangles( int nId, int* pnCount) ;
 EXE_EXPORT bool ExeSurfTmRemoveFacet( int nId, int nFacet) ;
 EXE_EXPORT bool ExeSurfTmSwapFacets( int nId, int nFacet1, int nFacet2) ;
 EXE_EXPORT bool ExeSurfTmRemovePart( int nId, int nPart) ;
 EXE_EXPORT bool ExeCutSurfTmPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
+EXE_EXPORT bool ExeCutSurfBzPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
 EXE_EXPORT bool ExeCutSurfTmClosedCurve( int nSurfId, int nCurveId, bool bSaveOnEq) ;
 EXE_EXPORT bool ExeSurfTmAdd( int nId1, int nId2, bool bTwoColors = false) ;
 EXE_EXPORT bool ExeSurfTmSubtract( int nId1, int nId2, bool bTwoColors = false) ;
 EXE_EXPORT bool ExeSurfTmIntersect( int nId1, int nId2, bool bTwoColors = false) ;
-EXE_EXPORT bool ExeSurfTmResetTwoColors( int nId) ;
 EXE_EXPORT int  ExeSurfTmSplit( int nId, int nSplitterId, int* pnCount) ;
 EXE_EXPORT bool ExeSurfTmCut( int nId, int nCutterId, bool bInVsOut, bool bSaveOnEq) ;
 EXE_EXPORT bool ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId,
                                                        INTVECTOR vSurfsId, bool bOCFlag,
                                                        bool& bExistProjection, int& nNewId, int& nNewFaceNbr) ;
+EXE_EXPORT bool ExeSurfTmResetTwoColors( int nId) ;
+EXE_EXPORT bool ExeSurfTmSetShowEdges( int nId, bool bShow) ;
 EXE_EXPORT bool ExeSurfBzTrim( int nId, int nCutterId) ;
 
 // GeomDb Volume Modify
 EXE_EXPORT int  ExeExplodeVolume( int nId, int* pnCount) ;
 EXE_EXPORT bool ExeVolZmapChangeResolution( int nId, int nNewRes) ;
+EXE_EXPORT bool ExeVolZmapSetShowEdges( int nId, bool bShow) ;
 EXE_EXPORT bool ExeRemoveVolZmapPart( int nId, int nPart) ;
 EXE_EXPORT bool ExeVolZmapSetStdTool( const INTVECTOR& vIds, const std::string& sToolName,
                                       double dLen, double dDiam, double dCornR, double dCutterH, int nFlag, bool bFirst) ;
@@ -799,21 +812,32 @@ EXE_EXPORT bool ExePointSurfTmDist( const Point3d& ptP, int nStmId, int nRefType
                                     double* pdDist, Point3d& ptMin, int* pnTria) ;
  
 // Geo Intersect
-EXE_EXPORT bool ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, const BBox3d& b3Box, INTDBLVECTOR& vInters) ;
+EXE_EXPORT bool ExeLineCurveInters( const Point3d& ptP, const Vector3d& vtDir, const int nId, const int nRefType,
+                                    INTDBLVECTOR& vInters) ;
+EXE_EXPORT bool ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, const BBox3d& b3Box,
+                                  INTDBLVECTOR& vInters) ;
+EXE_EXPORT bool ExeLineSurfTmInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
+                                     INTDBLVECTOR& vInters) ;
+EXE_EXPORT bool ExeLineSurfBzInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
+                                     INTDBLVECTOR& vInters) ;
+EXE_EXPORT bool ExeLineVolZmapInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
+                                      INTDBLVECTOR& vInters) ;
+EXE_EXPORT int  ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, const int nId, const int nDestGrpId, const int nRefType,
+                                     int* pnCount) ;
 EXE_EXPORT int  ExePlaneBoxInters( const Point3d& ptOn, const Vector3d& vtN, const BBox3d& b3Box, int nDestGrpId, int nRefType,
                                    int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
-EXE_EXPORT bool ExeLineSurfTmInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType, INTDBLVECTOR& vInters) ;
 EXE_EXPORT int  ExePlaneSurfTmInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType, double dToler,
                                       int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
-EXE_EXPORT int ExeParPlanesSurfTmInters( const Point3d& ptOn, const Vector3d& vtN, const DBLVECTOR& vdDist, int nId, int nDestGrpId, int nRefType, double dToler,
-                                         int* pnGrpCount) ;
-EXE_EXPORT int  ExeSurfTmSurfTmInters( int nId1, int nId2, int nDestGrpId, double dToler,
-                                       int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
-EXE_EXPORT int ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, const int nId, const int nDestGrpId, const int nRefType, int* pnCount) ;
-EXE_EXPORT int ExeCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId, int* pnPntCount, int* pnCrvCount) ;
-EXE_EXPORT bool ExeLineVolZmapInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType, INTDBLVECTOR& vInters) ;
+EXE_EXPORT int  ExeParPlanesSurfTmInters( const Point3d& ptOn, const Vector3d& vtN, const DBLVECTOR& vdDist, int nId, int nDestGrpId, int nRefType, double dToler,
+                                          int* pnGrpCount) ;
 EXE_EXPORT int  ExePlaneVolZmapInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType,
                                        int* pnCount) ;
+EXE_EXPORT int  ExeCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId,
+                                     int* pnPntCount, int* pnCrvCount) ;
+EXE_EXPORT int  ExeCurveSurfTmInters( const int nCrvId, const int nStmId, const int nDestGrpId,
+                                      int* pnPntCount, int* pnCrvCount) ;
+EXE_EXPORT int  ExeSurfTmSurfTmInters( int nId1, int nId2, int nDestGrpId, double dToler,
+                                       int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
 
 // Collision Detection
 EXE_EXPORT int  ExeCDeBoxSolid( const Frame3d& frBox, const Vector3d& vtDiag, int nSolidId, double dSafeDist, int nRefType) ;
@@ -926,6 +950,7 @@ EXE_EXPORT bool ExeGetMachGroupNewName( std::string& sName) ;
 EXE_EXPORT int  ExeAddMachGroup( const std::string& sName, const std::string& sMachineName) ;
 EXE_EXPORT int  ExeCopyMachGroup( const std::string& sSouName, const std::string& sName) ;
 EXE_EXPORT bool ExeRemoveMachGroup( int nMGroupId) ;
+EXE_EXPORT bool ExeChangeMachGroupName( int nId, const std::string& sNewName) ;
 EXE_EXPORT bool ExeGetMachGroupName( int nId, std::string& sName) ;
 EXE_EXPORT bool ExeGetMachGroupMachineName( int nId, std::string& sMachineName) ;
 EXE_EXPORT int  ExeGetMachGroupId( const std::string& sName) ;
@@ -1252,11 +1277,13 @@ EXE_EXPORT bool ExeResetGeoTria( bool bRedraw) ;
 EXE_EXPORT bool ExeSetWinRect( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw) ;
 EXE_EXPORT bool ExeResetWinRect( bool bRedraw) ;
 EXE_EXPORT bool ExeZoomWin( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw) ;
+EXE_EXPORT bool ExeSetViewOrizzOffsStep( int nDirOffsStep = 0) ;
 EXE_EXPORT bool ExeSetView( int nDir, bool bRedraw) ;
 EXE_EXPORT bool ExeSetGenericView( double dAngVertDeg, double dAngHorizDeg, bool bRedraw) ;
 EXE_EXPORT bool ExeSetViewCenter( const Point3d& ptP, bool bRedraw) ;
 EXE_EXPORT bool ExePanView( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw) ;
 EXE_EXPORT bool ExeRotateView( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw) ;
+EXE_EXPORT bool ExeGetViewOrizzOffsStep( int* pnDirOffsStep) ;
 EXE_EXPORT bool ExeGetView( int* pnDir) ;
 EXE_EXPORT bool ExeGetGenericView( double* pdAngVertDeg, double* pdAngHorizDeg) ;
 EXE_EXPORT bool ExeGetViewUp( Vector3d& vtUp) ;

EgkIntersLineSurfBez.h

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

EgkSbzStandard.h

@@ -0,0 +1,27 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024
+//----------------------------------------------------------------------------
+// File : EGkSbzStandard.h   Data : 14.02.24       Versione : 2.6b2
+// Contenuto : Dichiarazione funzioni per creazione superfici Sbz
+//             standard : Box, Pyramid, Cylinder, Sphere, Cone.
+//
+//
+// Modifiche : 14.02.24 DB Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkSurfBezier.h"
+
+//----------------------- Macro per import/export ----------------------------
+#undef EGK_EXPORT
+#if defined( I_AM_EGK)            // da definirsi solo nella DLL
+#define EGK_EXPORT __declspec( dllexport)
+#else
+#define EGK_EXPORT __declspec( dllimport)
+#endif
+
+//----------------------------------------------------------------------------
+EGK_EXPORT ISurfBezier* CreateBezierSphere( const Point3d& ptCenter, double dR) ;

EgtKeyCodes.h

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

SELkKeyProc.h

@@ -1,13 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2015
+//  EgalTech 2014-2024
 //----------------------------------------------------------------------------
-// File : SELkKeyProc.h           Data : 27.07.15          Versione : 1.6g1
+// File : SELkKeyProc.h           Data : 25.01.24          Versione : 2.6a1
 // Contenuto : Dichiarazione funzioni per la gestione della chiave.
 //
 //
 //
 // Modifiche : 10.09.14 DS Creazione modulo.
 //             27.02.15 DS Agg. gestione chiavi hardware OxySec.
+//             25.01.24 DS Agg. GetKeyLevelEx per scadenza assistenza.
 //
 //----------------------------------------------------------------------------
 
@@ -25,6 +26,8 @@ bool ReadKey( const std::string& sKey, const std::string& sScramKey,
 int VerifyKey( const std::string& sKey, int nProd, int nVer, int nLev) ;
 int GetKeyLevel( const std::string& sKey, int nProd, int nVer, int nLev,
                  int& nKLev, int& nKExpDays) ;
+int GetKeyLevelEx( const std::string& sKey, int nProd, int nVer, int nLev,
+                   int& nKLev, int& nKExpDays, int& nKAssExpDays) ;
 int GetKeyOptions( const std::string& sKey, int nProd, int nVer, int nLev,
                    unsigned int& nKOpt1, unsigned int& nKOpt2, int& nKOptExpDays) ;
 int GetCurrDay( void) ;