Include :

- codice di test per Zmap

EGkCDeBoxClosedSurfTm.h

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

EGkCDeClosedSurfTmClosedSurfTm.h

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

EGkCDeConeFrustumClosedSurfTm.h

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

EGkCDeConvexTorusClosedSurfTm.h

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

EGkCDeCylClosedSurfTm.h

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

EGkCDeRectPrismoidClosedSurfTm.h

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

EGkCDeSpheClosedSurfTm.h

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

EGkExtDimension.h

@@ -58,6 +58,7 @@ class __declspec( novtable) IExtDimension : public IGeoObj
       virtual double GetTextHeight( void) const = 0 ;
       virtual bool GetMidPoint( Point3d& ptMid) const = 0 ;
       virtual bool GetCenterPoint( Point3d& ptCen) const = 0 ;
+      virtual const std::string& GetSubType( void) const = 0 ;
       virtual bool ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const = 0 ;
 } ;
 

EGkGeoCollection.h

@@ -15,6 +15,7 @@
 
 #include "/EgtDev/Include/EGkPoint3d.h"
 #include "/EgtDev/Include/EGkBBox3d.h"
+#include "/EgtDev/Include/EGkFrame3d.h"
 #include "/EgtDev/Include/EGkCurvePointDiffGeom.h"
 #include "/EgtDev/Include/EgtNumCollection.h"
 
@@ -52,6 +53,12 @@ typedef std::list<CrvPointDiffGeom>    CPDGLIST ;     // lista di CrvPointDiffGe
 typedef std::vector<Vector3d>  VCT3DVECTOR ;   // vettore di vettori 3d
 typedef std::list<Vector3d>    VCT3DLIST ;     // lista di vettori 3d
 
+//----------------------------------------------------------------------------
+// Raccolte di Frame3d
+typedef std::vector<Frame3d>  FRAME3DVECTOR ;                   // vettore di riferimenti 3d
+typedef std::list<Frame3d>    FRAME3DLIST ;                     // lista di riferimenti 3d
+typedef std::vector<std::pair<Frame3d,int>>  FRAME3DIVECTOR ;   // vettore di riferimenti 3d e Id
+
 //----------------------------------------------------------------------------
 // Raccolte di BBox3d
 typedef std::vector<BBox3d>  BOXVECTOR ;                   // vettore di bounding box 3d

EGkLuaAux.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2015
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkLuaAux.h       Data : 21.03.15        Versione : 1.6c6
+// File : EGkLuaAux.h       Data : 14.04.24        Versione : 2.6d4
 // Contenuto : Funzioni per gestione parametri geometrici con LUA.
 //
 //
 //
 // Modifiche : 21.03.15 DS Creazione modulo.
-//
+//             14.04.24 DS Aggiunta gestione Quaternion.
 //
 //----------------------------------------------------------------------------
 
@@ -17,6 +17,7 @@
 #include "/EgtDev/Include/EGkPoint3d.h"
 #include "/EgtDev/Include/EGkFrame3d.h"
 #include "/EgtDev/Include/EGkBBox3d.h"
+#include "/EgtDev/Include/EGkQuaternion.h"
 #include "/EgtDev/Include/EGkColor.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
 #include "/EgtDev/Include/EGkSelection.h"
@@ -25,12 +26,16 @@
 //----------------------------------------------------------------------------
 inline bool
 LuaGetParam( lua_State* L, int nInd, Vector3d& vtPar)
-{  return LuaGetParam( L, nInd, vtPar.v) ; }
+{
+   return LuaGetParam( L, nInd, vtPar.v) ;
+}
 
 //----------------------------------------------------------------------------
 inline bool
 LuaGetParam( lua_State* L, int nInd, Point3d& ptPar)
-{  return LuaGetParam( L, nInd, ptPar.v) ; }
+{
+   return LuaGetParam( L, nInd, ptPar.v) ;
+}
 
 //----------------------------------------------------------------------------
 inline bool
@@ -114,6 +119,13 @@ LuaGetParam( lua_State* L, int nInd, BBox3d& b3Par)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+inline bool
+LuaGetParam( lua_State* L, int nInd, Quaternion& qtPar)
+{
+   return LuaGetParam( L, nInd, qtPar.v) ;
+}
+
 //----------------------------------------------------------------------------
 inline bool
 LuaGetParam( lua_State* L, int nInd, Color& colPar)
@@ -369,6 +381,23 @@ LuaSetParam( lua_State* L, const BBox3d& b3Par)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+inline bool
+LuaSetParam( lua_State* L, const Quaternion& qtPar)
+{
+   try {
+      lua_createtable( L, 4, 0) ;
+      for ( int i = 1 ; i <= 4 ; ++ i) {
+         lua_pushnumber( L, qtPar.v[i-1]) ;
+         lua_rawseti( L, -2, i) ;
+      }
+   }
+   catch( ...) {
+      return false ;
+   }
+   return true ;
+}
+
 //-------------------------------------------------------------------------------
 inline bool
 LuaSetParam( lua_State* L, const Color& colPar)

EGkProjectCurveSurfTm.h

@@ -13,6 +13,7 @@
 
 #pragma once
 
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 
@@ -29,11 +30,14 @@
 struct Point5ax {
    Point3d  ptP ;
    Vector3d vtDir ;
+   Vector3d vtDir2 ;
    double   dPar ;
    int      nFlag ;
-   Point5ax( void) : ptP(), vtDir(), dPar(), nFlag() {} ;
+   Point5ax( void) : ptP(), vtDir(), vtDir2(), dPar(), nFlag() {} ;
    Point5ax( const Point3d& ptBase, const Vector3d& vtTool, double dU, int nData)
-      : ptP( ptBase), vtDir( vtTool), dPar( dU), nFlag( nData) {} ;
+      : ptP( ptBase), vtDir( vtTool), vtDir2(), dPar( dU), nFlag( nData) {} ;
+   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2, double dU, int nData)
+      : ptP( ptBase), vtDir( vtTool), vtDir2( vtTool2), dPar( dU), nFlag( nData) {} ;
 } ; 
 typedef std::vector<Point5ax>        PNT5AXVECTOR ;    // vettore di Punti 5assi
 
@@ -41,3 +45,9 @@ typedef std::vector<Point5ax>        PNT5AXVECTOR ;    // vettore di Punti 5assi
 // Proiezione di una curva su una superficie TriMesh lungo la direzione data.
 EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir,
                                       double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
+EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const IGeoPoint3d& gpRef,
+                                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
+EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ICurve& crRef,
+                                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
+EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ISurfTriMesh& tmRef,
+                                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;

EGkQuaternion.h

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

EGkRotationMinimizingFrame.h

@@ -0,0 +1,50 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EGkRotationMinimizingFrame.h    Data : 05.04.24   Versione : 2.6d1
+// Contenuto : Dichiarazione della classe RotationMinimizingFrame.
+//
+//
+//
+// Modifiche : 05.04.24 RE Creazione modulo.
+
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EGkGeoCollection.h"
+
+//----------------------- Macro per import/export -----------------------------
+#undef EGK_EXPORT
+#if defined( I_AM_EGK)            // da definirsi solo nella DLL
+   #define EGK_EXPORT __declspec( dllexport)
+#else
+   #define EGK_EXPORT __declspec( dllimport)
+#endif
+
+//----------------------------------------------------------------------------
+class EGK_EXPORT RotationMinimizingFrame
+{
+   public :
+      RotationMinimizingFrame( void)
+         : m_pCrv( nullptr), m_Frame0() {}
+      ~RotationMinimizingFrame( void)
+         { Clear() ; }
+      bool Set( const ICurve* pCrv, const Frame3d& fr_Start) ;
+
+   public :
+      bool GetFramesByStep( double dStep, bool bUniform, FRAME3DVECTOR& vRMFrames) ;
+      bool GetFramesBySplit( int nIntervals, FRAME3DVECTOR& vRMFrames) ;
+      bool GetFramesByTolerance( double dTol, FRAME3DVECTOR& vRMFrames) ;
+   
+   private :
+      bool Clear( void) ;
+      bool IsValid( void) ;
+      bool GetFrameAtParam( const Frame3d& frAct, const double dParNext, Frame3d& frNext) ;
+   
+   private :
+      ICurve* m_pCrv ;           // curva per il calcolo del rotation Xplane frame
+      Frame3d m_Frame0 ;         // frame iniziale della curva
+} ;

EGkRotationXplaneFrame.h

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

EGkStmFromCurves.h

@@ -1,8 +1,8 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkStmFromCurves.h   Data : 27.02.24       Versione : 2.6b4
-// Contenuto : Dichiarazione della classe StmFromTriangleSoup.
+// File : EGkStmFromCurves.h   Data : 27.02.24       Versione : 2.6d1
+// Contenuto : Prototipi funzioni di creazione TriMesh a partire da curve.
 //
 //
 //
@@ -14,6 +14,7 @@
 #pragma once
 
 #include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EGkSurfFlatRegion.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 
 //----------------------- Macro per import/export ----------------------------
@@ -40,7 +41,10 @@ EGK_EXPORT ISurfTriMesh* GetSurfTriMeshByScrewing( const ICurve* pCurve, const P
                                                    double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRectSwept( double dDimH, double dDimV, double dBevelH, double dBevelV,
                                                   const ICurve* pGuide, int nCapType, double dLinTol = 10 * EPS_SMALL) ;
-EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtAx,
+                                              bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ISurfFlatRegion* pSfrSect, const ICurve* pGuide, const Vector3d& vtAx,
+                                              bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshTransSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRuled( const Point3d& ptP, const ICurve* pCurve, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, double dLinTol = 10 * EPS_SMALL) ;

EGkSurfAux.h

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

EGkSurfBezier.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+// EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : EGkSurfBezier.h      Data : 22.03.20          Versione : 2.2c3
+// File : EGkSurfBezier.h      Data : 10.04.24          Versione : 2.6d2
 // Contenuto : Dichiarazione della interfaccia ISurfBezier.
 //
 //
@@ -59,6 +59,7 @@ class __declspec( novtable) ISurfBezier : public ISurf
       virtual bool GetControlCurveOnU( int nIndV, PolyLine& plCtrlU) const = 0 ;
       virtual bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const = 0 ;
       virtual const ISurfTriMesh* GetAuxSurf( void) const = 0 ;
+      virtual ISurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL) const = 0 ;
       virtual bool GetLeaves ( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const = 0 ;
       virtual bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const = 0 ;
       virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL) const = 0 ;

EGkSurfLocal.h

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

EGkVector3d.h

@@ -85,6 +85,10 @@ class EGK_EXPORT Vector3d
       bool IsX( void) const
              { double dMO = std::max( abs( y), abs( z)) ;
                return ( abs( x) > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  abs( x) > KV_BIG * dMO) ; }
+      //! Verifica se il vettore è circa parallelo a x
+      bool IsXEpsilon( double dToll) const
+             { double dMO = std::max( abs( y), abs( z)) ;
+               return ( abs( x) > dToll  &&  dMO < 10 * dToll  &&  abs( x) > KV_BIG * dMO) ; }
       //! Verifica se il vettore è parallelo ed equiverso con Y+
       bool IsYplus( void) const
              { double dMO = std::max( abs( z), abs( x)) ;
@@ -97,6 +101,10 @@ class EGK_EXPORT Vector3d
       bool IsY( void) const
              { double dMO = std::max( abs( z), abs( x)) ;
                return ( abs( y) > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  abs( y) > KV_BIG * dMO) ; }
+      //! Verifica se il vettore è circa parallelo a y
+      bool IsYEpsilon( double dToll) const
+             { double dMO = std::max( abs( z), abs( x)) ;
+               return ( abs( y) > dToll  &&  dMO < 10 * dToll  &&  abs( y) > KV_BIG * dMO) ; }
       //! Verifica se il vettore è parallelo ed equiverso con Z+
       bool IsZplus( void) const
              { double dMO = std::max( abs( x), abs( y)) ;
@@ -109,6 +117,10 @@ class EGK_EXPORT Vector3d
       bool IsZ( void) const
              { double dMO = std::max( abs( x), abs( y)) ;
                return ( abs( z) > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  abs( z) > KV_BIG * dMO) ; }
+      //! Verifica se il vettore è circa parallelo a Z
+      bool IsZEpsilon( double dToll) const
+             { double dMO = std::max( abs( x), abs( y)) ;
+               return ( abs( z) > dToll  &&  dMO < 10 * dToll  &&  abs( z) > KV_BIG * dMO) ; }
       //! Verifica se il vettore è generico
       bool IsGeneric( void) const
              { return ( ! IsX()  &&  ! IsY()  &&  ! IsZ()) ; }

EGkVolZmap.h

@@ -27,7 +27,9 @@ class __declspec( novtable) IVolZmap : public IGeoObj
    public :
       virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Clear( void) = 0 ;
+      virtual bool IsEmpty( void) = 0 ;
       virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dPrec, bool bTriDex) = 0 ;
+      virtual bool CreateEmptyMap( const Point3d& ptO, double dLengthX, double dLengthY, double dLengthZ, double dStep, bool bTriDex) = 0 ;
       virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec, bool bTriDex) = 0 ;
       virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bTriDex) = 0 ;
       virtual int  GetBlockCount( void) const = 0 ;
@@ -84,7 +86,8 @@ class __declspec( novtable) IVolZmap : public IGeoObj
       virtual bool GetPartBBox( int nPart, const Frame3d& frRef, BBox3d& b3Ref, int nFlag = BBF_STANDARD) const = 0 ;
       virtual IVolZmap* ClonePart( int nPart) const = 0 ;
       virtual bool RemovePart( int nPart) = 0 ;
-      virtual int  GetPartMinDistFromPoint( const Point3d& ptP) const = 0 ;
+      virtual int GetPartMinDistFromPoint( const Point3d& ptP) const = 0 ;
+      virtual bool AddSrfTm( const ISurfTriMesh* pStm) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EInAPI.h

@@ -59,6 +59,7 @@ EIN_EXPORT BOOL __stdcall EgtGetKeyOptions( int nProd, int nVer, int nLev, unsig
 EIN_EXPORT BOOL __stdcall EgtGetKeyLeftDays( int* pnLeftDays) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyAssLeftDays( int* pnAssLeftDays) ;
 EIN_EXPORT BOOL __stdcall EgtGetKeyOptLeftDays( int* pnOptLeftDays) ;
+EIN_EXPORT BOOL __stdcall EgtGetNetHwKey( void) ;
 EIN_EXPORT BOOL __stdcall EgtGetOsInfo( wchar_t*& wsOs) ;
 EIN_EXPORT BOOL __stdcall EgtGetCpuInfo( wchar_t*& wsCpu) ;
 EIN_EXPORT BOOL __stdcall EgtGetMemoryInfo( wchar_t*& wsMem) ;
@@ -118,7 +119,7 @@ EIN_EXPORT BOOL __stdcall EgtImportStl( const wchar_t* wsFilePath, double dScale
 EIN_EXPORT BOOL __stdcall EgtImport3MF( const wchar_t* wsFilePath) ;
 EIN_EXPORT BOOL __stdcall EgtImport3dm( const wchar_t* wsFilePath) ;
 EIN_EXPORT BOOL __stdcall EgtAdvancedImportIsEnabled( void) ;
-EIN_EXPORT BOOL __stdcall EgtAdvancedImport( const wchar_t* wsFilePath, double dLinToler) ;
+EIN_EXPORT BOOL __stdcall EgtAdvancedImport( const wchar_t* wsFilePath, double dLinToler, int nFlag) ;
 EIN_EXPORT BOOL __stdcall EgtExportDxf( int nId, const wchar_t* wsFilePath, int nFlag, int nFilter) ;
 EIN_EXPORT BOOL __stdcall EgtExportStl( int nId, const wchar_t* wsFilePath, int nFilter) ;
 EIN_EXPORT BOOL __stdcall EgtExport3MF( int nId, const wchar_t* wsFilePath, int nFilter) ;
@@ -315,9 +316,10 @@ EIN_EXPORT int  __stdcall EgtCreateSurfTmByRevolve( int nParentId, int nCrvId,
                                                     const double ptAx[3], const double vtAx[3],
                                                     BOOL bCapEnds, double dLinTol, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateSurfTmByScrewing( int nParentId, int nCrvId,
-                                               const double ptAx[3], const double vtAx[3],
-                                               double dAngRotDeg, double dMove, BOOL bCapEnds, double dLinTol, int nRefType) ;
-EIN_EXPORT int  __stdcall EgtCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, BOOL bCapEnds, double dLinTol) ;
+                                                     const double ptAx[3], const double vtAx[3],
+                                                     double dAngRotDeg, double dMove, BOOL bCapEnds, double dLinTol, int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, const double vtAx[3],
+                                                BOOL bCapEnds, double dLinTol, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateSurfTmRuled( int nParentId, int nPntOrCrvId1, int nCrvId2, int nType, double dLinTol) ;
 EIN_EXPORT int  __stdcall EgtCreateSurfTmByTriangles( int nParentId, int nNumId, const int nIds[], BOOL bErase) ;
 EIN_EXPORT int  __stdcall EgtCreateSurfTmBySewing( int nParentId, int nNumId, const int nIds[], BOOL bErase) ;
@@ -964,11 +966,13 @@ EIN_EXPORT BOOL __stdcall EgtSetCalcTool( const wchar_t* wsTool, const wchar_t*
 EIN_EXPORT BOOL __stdcall EgtGetCalcTool( wchar_t*& wsTool, wchar_t*& wsHead, int* pnExit) ;
 EIN_EXPORT BOOL __stdcall EgtGetCalcAngles( const double vtDirT[3], const double vtDirA[3],
                                             int* pnStat, double* pdAngA1, double* pdAngB1, double* pdAngA2, double* pdAngB2) ;
-EIN_EXPORT BOOL __stdcall EgtGetCalcPositions( const double ptP[3], double dAngA, double dAngB,
+EIN_EXPORT BOOL __stdcall EgtGetCalcAnglesEx( const double vtDirT[3], const double vtDirA[3],
+                                              int* pnStat, double*& vAngs1, double*& vAngs2, int* pnCount) ;
+EIN_EXPORT BOOL __stdcall EgtGetCalcPositions( const double ptP[3], int nCount, const double dAngs[],
                                                int* pnStat, double* pdX, double* pdY, double* pdZ) ;
-EIN_EXPORT BOOL __stdcall EgtGetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
+EIN_EXPORT BOOL __stdcall EgtGetCalcTipFromPositions( double dX, double dY, double dZ, int nCount, const double dAngs[],
                                                       BOOL bBottom, double ptTip[3]) ;
-EIN_EXPORT BOOL __stdcall EgtGetCalcToolDirFromAngles( double dAngA, double dAngB, double vtDir[3]) ;
+EIN_EXPORT BOOL __stdcall EgtGetCalcToolDirFromAngles( int nCount, const double dAngs[], double vtDir[3]) ;
 EIN_EXPORT BOOL __stdcall EgtVerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int* pnStat) ;
 EIN_EXPORT BOOL __stdcall EgtGetOutstrokeInfo( wchar_t*& wsInfo) ;
 // Machine Move

EMkMachMgr.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2023
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EMkMachMgr.h           Data : 28.10.23          Versione : 2.5j4
+// File : EMkMachMgr.h           Data : 02.04.24          Versione : 2.6d1
 // Contenuto : Dichiarazione della interfaccia IMachMgr.
 //
 //
@@ -15,6 +15,8 @@
 //             21.09.22 DS Aggiunta in interfaccia GetAxisOffset.
 //             25.08.23 DS Aggiunta in interfaccia CopyMachGroup.
 //             28.10.23 DS Aggiunte in interfaccia GetClEntAxesVal, GetToolSetupPosInCurrSetup e GetAllCurrAxesName.
+//             30.03.24 DS Aggiunte in interfaccia GetAllAxesNames e GetCalcTable.
+//             02.04.24 DS Aggiunta in interfaccia GetClEntAxesMask.
 //
 //----------------------------------------------------------------------------
 
@@ -269,6 +271,7 @@ class __declspec( novtable) IMachMgr
       virtual bool GetClEntMove( int nEntId, int& nMove) const = 0 ;
       virtual bool GetClEntFlag( int nEntId, int& nFlag, int& nFlag2) const = 0 ;
       virtual bool GetClEntIndex( int nEntId, int& nIndex) const = 0 ;
+      virtual bool GetClEntAxesMask( int nEntId, int& nMask) const = 0 ;
       virtual bool GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const = 0 ;
      // Simulation
       virtual bool SimInit( void) = 0 ;
@@ -288,9 +291,10 @@ class __declspec( novtable) IMachMgr
      // Machine Calc
       virtual bool SetCalcTable( const std::string& sTable) = 0 ;
       virtual bool SetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) = 0 ;
-      virtual bool GetAllCurrAxesName( STRVECTOR& vAxName) const = 0 ;
+      virtual bool GetAllCurrAxesNames( STRVECTOR& vAxName) const = 0 ;
       virtual bool SetRotAxisBlock( const std::string& sAxis, double dVal) = 0 ;
       virtual bool GetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) const = 0 ;
+      virtual bool GetCalcTable( std::string& sTable) const = 0 ;
       virtual bool GetCalcTool( std::string& sTool) const = 0 ;
       virtual bool GetCalcHead( std::string& sHead) const = 0 ;
       virtual bool GetCalcExit( int& nExit) const = 0 ;
@@ -331,6 +335,7 @@ class __declspec( novtable) IMachMgr
       virtual bool ResetAxisPos( const std::string& sAxis) = 0 ;
       virtual bool ResetAllAxesPos( void) = 0 ;
       virtual bool GetAllTablesNames( STRVECTOR& vNames) const = 0 ;
+      virtual bool GetAllAxesNames( STRVECTOR& vNames) const = 0 ;
       virtual bool GetAllHeadsNames( STRVECTOR& vNames) const = 0 ;
       virtual bool GetAllTcPosNames( STRVECTOR& vNames) const = 0 ;
       virtual bool LoadTool( const std::string& sHead, int nExit, const std::string& sTool) = 0 ;

EMkMachiningConst.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2023
+//  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EmkMachiningConst.h     Data : 06.09.23      Versione : 2.5i1
+// File : EmkMachiningConst.h     Data : 29.03.24      Versione : 2.6di1
 // Contenuto : Costanti delle lavorazioni.      
 //
 //
@@ -13,6 +13,7 @@
 //             09.11.20 DS Agg. MPA_SIDEANGFEED e MPA_STEPLAST.
 //             04.02.22 DS Agg. MPA_EPICYCLESRAD e MPA_EPICYCLESDIST.
 //             06.09.23 DS Agg. 5AxMachining.
+//             29.03.24 DS Agg. MGP_APPROXLINTOL.
 //
 //----------------------------------------------------------------------------
 
@@ -39,7 +40,8 @@ enum MgpType { MGP_NONE =                             0,
                MGP_EXTSAWARCMINRAD =    ( MGP_DOU +  4),
                MGP_INTSAWARCMAXSIDEANG =( MGP_DOU +  5),
                MGP_SAFEAGGRBOTTZ =      ( MGP_DOU +  6),
-               MGP_MAXDEPTHSAFE =       ( MGP_DOU +  7)} ;
+               MGP_MAXDEPTHSAFE =       ( MGP_DOU +  7),
+               MGP_APPROXLINTOL =       ( MGP_DOU +  8)} ;
 
 //----------------------------------------------------------------------------
 // Costanti per tipologia di split arcs

EMkMachiningGeoConst.h

@@ -108,6 +108,8 @@ static std::string KEY_MMAX = "MMAX" ;
 // Chiavi info in gruppo CL per punti assi minimo e massimo di ingombro di tutta la lavorazione
 static std::string KEY_MAXMIN = "MAXMIN" ;
 static std::string KEY_MAXMAX = "MAXMAX" ;
+// Chiave info in sottogruppo di testa per abilitarne visualizzazione in Preview (0/1 default) 
+static std::string KEY_PREVIEWSHOW = "PreviewShow" ;
 
 //----------------- Costanti posizione per preview utensile in lavorazione ------
 enum MchToolShow { MCH_TPM_CURR = 0,

EXeExecutor.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EXcExecutor.h          Data : 09.01.24          Versione : 2.5l6
+// File : EXcExecutor.h          Data : 30.03.24          Versione : 2.6d1
 // Contenuto : Interfaccia Executor.
 //
 //
@@ -64,6 +64,7 @@ EXE_EXPORT bool ExeGetKeyOptions( int nProd, int nVer, int nLev, unsigned int& n
 EXE_EXPORT bool ExeGetKeyLeftDays( int& nLeftDays) ;
 EXE_EXPORT bool ExeGetKeyAssLeftDays( int& nAssLeftDays) ;
 EXE_EXPORT bool ExeGetKeyOptLeftDays( int& nOptLeftDays) ;
+EXE_EXPORT bool ExeGetNetHwKey( void) ;
 EXE_EXPORT bool ExeGetOsInfo( std::string& sOs) ;
 EXE_EXPORT bool ExeGetCpuInfo( std::string& sCpu) ;
 EXE_EXPORT bool ExeGetMemoryInfo( std::string& sMem) ;
@@ -126,7 +127,7 @@ EXE_EXPORT bool ExeImportStl( const std::string& sFilePath, double dScaleFactor)
 EXE_EXPORT bool ExeImport3MF( const std::string& sFilePath) ;
 EXE_EXPORT bool ExeImport3dm( const std::string& sFilePath) ;
 EXE_EXPORT bool ExeAdvancedImportIsEnabled( void) ;
-EXE_EXPORT bool ExeAdvancedImport( const std::string& sFilePath, double dToler = 0.1) ;
+EXE_EXPORT bool ExeAdvancedImport( const std::string& sFilePath, double dToler = 0.1, int nFlag = 0) ;
 EXE_EXPORT bool ExeExportDxf( int nId, const std::string& sFilePath, int nFlag = 1, int nFilter = 393) ;
 EXE_EXPORT bool ExeExportStl( int nId, const std::string& sFilePath, int nFilter = 393) ;
 EXE_EXPORT bool ExeExport3MF( int nId, const std::string& sFilePath, int nFilter = 393) ;
@@ -357,12 +358,12 @@ EXE_EXPORT int  ExeCreateSurfTmByScrewing( int nParentId, int nCrvId,
                                            double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfTmRectSwept( int nParentId, double dDimH, double dDimV, double dBevelH, double dBevelV,
                                           int nGuideId, int nCapType, double dLinTol) ;
-EXE_EXPORT int  ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol) ;
+EXE_EXPORT int  ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, const Vector3d& vtAx,
+                                      bool bCapEnds, double dLinTol, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfTmTransSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrCrvId2, int nType, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfTmByTriangles( int nParentId, const INTVECTOR& vIds, bool bErase) ;
 EXE_EXPORT int  ExeCreateSurfTmBySewing( int nParentId, const INTVECTOR& vIds, bool bErase) ;
-EXE_EXPORT int  ExeCreateSurfTmBySurfBezier( int nParentId, int nSbezId) ;
 EXE_EXPORT int  ExeCreateSurfTmByVolZmap( int nParentId, int nZmapId, int nPart) ;
 EXE_EXPORT int  ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTVECTOR& vPnt, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTUVECTOR& vPntW, int nRefType) ;
@@ -372,9 +373,12 @@ EXE_EXPORT int  ExeCreateSurfBezierTria2D( int nParentId, int nSurfBzId, int nTe
 
 // GeomDB Create Volume
 EXE_EXPORT int  ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX,
-                                   double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
+                                  double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
+EXE_EXPORT int  ExeCreateVolZmapEmpty( int nParentId, const Point3d& ptIni, double dDimX,
+                                       double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType ) ;
 EXE_EXPORT int  ExeCreateVolZmapByRegionExtrusion( int nParentId, int nSfrId, double dDimZ, double dPrec, bool bTriDex) ;
 EXE_EXPORT int  ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDex) ;
+EXE_EXPORT bool  ExeUpdateVolZmapByAddingSurfTm( int nParentId, int nZmapId, int nStmId) ;
 
 // GeomDB PartLayer
 EXE_EXPORT bool ExeIsPart( int nPartId) ;
@@ -600,6 +604,8 @@ EXE_EXPORT bool ExeChainCurvesInGroup( int nGroupId, const Point3d& ptNear, int
 EXE_EXPORT bool ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType) ;
 EXE_EXPORT bool ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId,
                                          double dLinTol, double dMaxSegmLen, int nRefType) ;
+EXE_EXPORT bool ExeProjectCurveOnSurfTmExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
+                                            double dLinTol, double dMaxSegmLen, bool bDirFromGuide) ;
 EXE_EXPORT int  ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) ;
 EXE_EXPORT int  ExeCurveGetMedialAxis( int nId, int nDestGrpId, int nSide, int* pnCount) ;
 EXE_EXPORT int  ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, bool bSquareMids, int* pnCount) ;
@@ -607,7 +613,7 @@ EXE_EXPORT int  ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool
 // GeomDb Surf Modify
 EXE_EXPORT bool ExeInvertSurface( const INTVECTOR& vIds) ;
 EXE_EXPORT int  ExeExplodeSurface( int nId, int* pnCount) ;
-EXE_EXPORT bool ExeApproxSurface( int nId, double dLinTol) ;
+EXE_EXPORT bool ExeApproxSurface( int nId, double dLinTol, double dTriaMinSide = 100 * EPS_SMALL) ;
 EXE_EXPORT bool ExeSurfFrAdd( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrSubtract( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrIntersect( int nId1, int nId2) ;
@@ -849,6 +855,16 @@ EXE_EXPORT int  ExeCDeConeSolid( const Frame3d& frCone, double dR1, double dR2,
 EXE_EXPORT int  ExeCDeSpheSolid( const Point3d& ptCen, double dR, int nSolidId, double dSafeDist, int nRefType) ;
 EXE_EXPORT int  ExeCDeSolidSolid( int nSolid1Id, int nSolid2Id, double dSafeDist) ;
 
+// Test Interference
+EXE_EXPORT int  ExeTestBoxSurface( const Frame3d& frBox, const Vector3d& vtDiag, int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestRectPrismoidSurface( const Frame3d& frPrismoid, double dBaseLenX, double dBaseLenY,
+                                            double dTopLenX, double dTopLenY, double dHeight,
+                                            int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestCylSurface( const Frame3d& frCyl, double dR, double dH, int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestConeSurface( const Frame3d& frCone, double dR1, double dR2, double dH, int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestSpheSurface( const Point3d& ptCen, double dR, int nSurfId, double dSafeDist, int nRefType) ;
+EXE_EXPORT int  ExeTestSurfaceSurface( int nSurf1Id, int nSurf2Id, double dSafeDist) ;
+
 // Maximum Filler
 EXE_EXPORT bool ExeMaxFillerStart( void) ;
 EXE_EXPORT bool ExeMaxFillerAddPart( int nPartId, double dLen) ;
@@ -1158,6 +1174,7 @@ EXE_EXPORT bool ExeUpdateAllMachiningsEx( bool bStopOnFirstErr, std::string& sEr
 EXE_EXPORT bool ExeGetClEntMove( int nEntId, int& nMove) ;
 EXE_EXPORT bool ExeGetClEntFlag( int nEntId, int& nFlag, int& nFlag2) ;
 EXE_EXPORT bool ExeGetClEntIndex( int nEntId, int& nIndex) ;
+EXE_EXPORT bool ExeGetClEntAxesMask( int nEntId, int& nMask) ;
 EXE_EXPORT bool ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) ;
 
 // Simulation
@@ -1188,14 +1205,16 @@ EXE_EXPORT bool ExeGetAxisType( const std::string& sAxis, bool& bLinear) ;
 EXE_EXPORT bool ExeGetAxisInvert( const std::string& sAxis, bool& bInvert) ;
 EXE_EXPORT bool ExeGetAxisOffset( const std::string& sAxis, double& dOffset) ;
 EXE_EXPORT bool ExeGetAllTablesNames( STRVECTOR& vNames) ;
+EXE_EXPORT bool ExeGetAllAxesNames( STRVECTOR& vNames) ;
 EXE_EXPORT bool ExeGetAllHeadsNames( STRVECTOR& vNames) ;
 EXE_EXPORT bool ExeGetAllTcPosNames( STRVECTOR& vNames) ;
 // Machine Calc
 EXE_EXPORT bool ExeSetCalcTable( const std::string& sTable) ;
 EXE_EXPORT bool ExeSetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) ;
-EXE_EXPORT bool ExeGetAllCurrAxesName( STRVECTOR& vAxName) ;
 EXE_EXPORT bool ExeSetRotAxisBlock( const std::string& sAxis, double dVal) ;
+EXE_EXPORT bool ExeGetCalcTable( std::string& sTable) ;
 EXE_EXPORT bool ExeGetCalcTool( std::string& sTool, std::string& sHead, int& nExit) ;
+EXE_EXPORT bool ExeGetAllCurrAxesNames( STRVECTOR& vAxName) ;
 EXE_EXPORT bool ExeGetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) ;
 EXE_EXPORT bool ExeGetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                                   int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) ;

EgtKeyCodes.h

@@ -25,7 +25,7 @@
 
 //----------------------------------------------------------------------------
 const int KEY_BASELIB_PROD = 207 ;
-const int KEY_BASELIB_VER = 2603 ;
+const int KEY_BASELIB_VER = 2604 ;
 const int KEY_BASELIB_LEV = 1 ;
 
 //----------------------------------------------------------------------------

SELkKeyProc.h

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

SELkLockId.h

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