Include :

- Aggiornamento prototipi.

EGkCurveAux.h

@@ -15,6 +15,8 @@
 
 #include "/EgtDev/Include/EGkCurveComposite.h"
 
+class ICurveBezier ;
+class ICurveLine ;
 
 //----------------------- Macro per import/export ----------------------------
 #undef EGK_EXPORT
@@ -44,9 +46,29 @@ struct CNurbsData
 // N.B. : in caso la curva sia razionale i punti di controllo sono in forma NON OMOGENEA [ x, y, z, w]  ( dove la forma OMOGENEA è [ w*x, w*y, w*z, w])
 // tutte le operazioni richiedono la forma OMOGENEA, finite le quali posso riportarmi alla forma NON OMOGENEA
 
+//----------------------------------------------------------------------------
+//! Trasforma una linea in una nuova curva di Bezier semplice
+EGK_EXPORT ICurveBezier* LineToBezierCurve( const ICurveLine* pLine) ;
+
 //----------------------------------------------------------------------------
 //! Trasforma un arco in una nuova curva di Bezier semplice o composta
-EGK_EXPORT ICurve* ArcToBezierCurve( const ICurve* pArc) ;
+EGK_EXPORT ICurve* ArcToBezierCurve( const ICurve* pArc, bool bDeg3OrDeg2 = true) ;
+
+//----------------------------------------------------------------------------
+//! Trasforma una curva compo in una nuova curva di Bezier semplice o composta
+EGK_EXPORT ICurve* CompositeToBezierCurve( const ICurveComposite* pCrvCompo) ;
+
+//----------------------------------------------------------------------------
+//! Trasforma una curva bezier in una nuova curva di Bezier semplice o composta di grado 2 e razionale
+EGK_EXPORT ICurve* BezierToBasicBezierCurve( const ICurveBezier* pCrvBezier) ;
+
+//----------------------------------------------------------------------------
+//! Aumento il grado della curva di Bezier
+EGK_EXPORT ICurveBezier* BezierIncreaseDegree( const ICurveBezier* pCrvBezier) ;
+
+//----------------------------------------------------------------------------
+//! Riduco il grado della curva di Bezier
+EGK_EXPORT ICurveBezier* BezierDecreaseDegree( const ICurveBezier* pCrvBezier, double dTol) ;
 
 //----------------------------------------------------------------------------
 //! Trasforma una curva in una nuova curva semplice o composta senza archi (solo linee o curve di Bezier)

EGkCurveBezier.h

@@ -16,6 +16,7 @@
 #include "/EgtDev/Include/EGkCurve.h"
 
 class ICurveArc ;
+class ICurveLine ;
 
 //----------------------------------------------------------------------------
 class __declspec( novtable) ICurveBezier : public ICurve
@@ -28,6 +29,7 @@ class __declspec( novtable) ICurveBezier : public ICurve
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl) = 0 ;
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) = 0 ;
       virtual bool FromArc( const ICurveArc& crArc) = 0 ;
+      virtual bool FromLine( const ICurveLine& crLine) = 0 ;
       virtual int  GetDegree( void) const = 0 ;
       virtual bool IsRational( void) const = 0 ;
       virtual bool IsAPoint( void) const = 0 ;

EGkDistLineLine.h

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

EGkDistPointCurve.h

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

EGkDistPointLine.h

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

EGkDistPointSurfTm.h

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

EGkLuaAux.h

@@ -1,13 +1,14 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkLuaAux.h       Data : 14.04.24        Versione : 2.6d4
+// File : EGkLuaAux.h       Data : 08.05.24        Versione : 2.6e2
 // Contenuto : Funzioni per gestione parametri geometrici con LUA.
 //
 //
 //
 // Modifiche : 21.03.15 DS Creazione modulo.
 //             14.04.24 DS Aggiunta gestione Quaternion.
+//             08.05.24 DS Aggiunta LuaSetParam per VCT3DVECTOR.
 //
 //----------------------------------------------------------------------------
 
@@ -276,6 +277,33 @@ LuaSetParam( lua_State* L, const Vector3d& vtPar)
    return true ;
 }
 
+//-------------------------------------------------------------------------------
+inline bool
+LuaSetParam( lua_State* L, const VCT3DVECTOR& vPar)
+{
+   try {
+     // recupero dimensione vettore
+      int nDim = int( vPar.size()) ;
+     // creo tavola principale
+      lua_createtable( L, nDim, 0) ;
+     // creo e inserisco tavola per ogni componente
+      for ( int i = 1 ; i <= nDim ; ++ i) {
+        // creo tavola componente
+         lua_createtable( L, 3, 0) ;
+         for ( int j = 1 ; j <= 3 ; ++ j) {
+            lua_pushnumber( L, vPar[i-1].v[j-1]) ;
+            lua_rawseti( L, -2, j) ;
+         }
+         // la metto nel vettore
+         lua_rawseti( L, -2, i) ;
+      }
+   }
+   catch( ...) {
+      return false ;
+   }
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 inline bool
 LuaSetParam( lua_State* L, const Point3d& ptPar)

EGkProjectCurveSurfBez.h

@@ -0,0 +1,37 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EGkProjectCurveSurfTm.h     Data : 07.05.24      Versione : 2.6e3
+// Contenuto : Dichiarazione funzioni proiezione curve su superficie Bezier.
+//
+//
+//
+// Modifiche : 07.05.24 DB Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
+#include "/EgtDev/Include/EGkCurve.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
+
+//----------------------------------------------------------------------------
+// Proiezione di una curva su una superficie TriMesh lungo la direzione data.
+EGK_EXPORT bool ProjectCurveOnSurfBez( const ICurve& crCrv, const ISurfBezier& surfBez, const Vector3d& vtDir,
+   double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
+EGK_EXPORT bool ProjectCurveOnSurfBez( const ICurve& crCrv, const ISurfBezier& surfBez, const IGeoPoint3d& gpRef,
+   double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
+EGK_EXPORT bool ProjectCurveOnSurfBez( const ICurve& crCrv, const ISurfBezier& surfBez, const ICurve& crRef,
+   double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
+EGK_EXPORT bool ProjectCurveOnSurfBez( const ICurve& crCrv, const ISurfBezier& surfBez, const ISurfTriMesh& tmRef,
+   double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;

EGkSurfBezier.h

@@ -69,11 +69,10 @@ class __declspec( novtable) ISurfBezier : public ISurf
       // 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 ;
+      virtual bool IsPlanar( void) const = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGkSurfTriMesh.h

@@ -89,6 +89,7 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual ISurfTriMesh* CloneTriangle( int nTria) const = 0 ;
       virtual bool GetLoops( POLYLINEVECTOR& vPL) const = 0 ;
       virtual bool GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const = 0 ;
+      virtual bool GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const = 0 ;
       virtual int  GetFacetCount( void) const = 0 ;
       virtual int  GetFacetSize( void) const = 0 ;
       virtual int  GetFacetFromTria( int nT) const = 0 ;
@@ -123,9 +124,14 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual bool Repair( double dMaxEdgeLen = MAX_EDGE_LEN_STD) = 0 ;
       virtual bool GetAllTriaOverlapBox( const BBox3d& b3Box, INTVECTOR& vT) const = 0 ;
       virtual const BBox3d& GetAllTriaBox( void) const = 0 ;
-      virtual int  GetPartCount( void) const = 0 ;
+      virtual int GetPartCount( void) const = 0 ;
+      virtual int GetShellCount( void) const = 0 ;
       virtual bool RemovePart( int nPart) = 0 ;
+      virtual bool RemoveShell( int nShell) = 0 ;
       virtual ISurfTriMesh* ClonePart( int nPart) const = 0 ;
+      virtual ISurfTriMesh* CloneShell( int nShell) const = 0 ;
+      virtual bool SetTFlag( int nId, int nTFlag) = 0 ;
+      virtual bool GetTFlag( int nId, int& nFlag) const = 0 ;
       virtual int  GetMaxTFlag( void) const = 0 ;
       virtual bool ResetTFlags( void) = 0 ;
 } ;

EGkVector3d.h

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

EGkVolZmap.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkVolZmap.h      Data : 09.03.24          Versione : 2.6c2
+// File : EGkVolZmap.h      Data : 22.04.24          Versione : 2.6d4
 // Contenuto : Dichiarazione della interfaccia IVolZmap.
 //
 //
@@ -27,9 +27,10 @@ class __declspec( novtable) IVolZmap : public IGeoObj
    public :
       virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Clear( void) = 0 ;
-      virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dPrec, bool bTriDex) = 0 ;
-      virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec, bool bTriDex) = 0 ;
-      virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bTriDex) = 0 ;
+      virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) = 0 ;
+      virtual bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) = 0 ;
+      virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) = 0 ;
+      virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex) = 0 ;
       virtual int  GetBlockCount( void) const = 0 ;
       virtual int  GetBlockUpdatingCounter( int nBlock) const = 0 ;
       virtual bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const = 0 ;
@@ -54,6 +55,8 @@ class __declspec( novtable) IVolZmap : public IGeoObj
                                     double dH, double dW, double dTh, double dRc, int nFlag, bool bFirst) = 0 ;
       virtual bool SetChiselTool( const std::string& sToolName,
                                   double dH, double dW, double dTh, int nFlag, bool bFirst) = 0 ;
+      virtual bool SetAdditiveTool( const std::string& sToolName,
+                                    double dH, double dR, double dRc, int nFlag, bool bFirst) = 0 ;
       virtual int  GetToolCount( void) const = 0 ;
       virtual bool SetCurrTool( int nCurrTool) = 0 ;
       virtual bool ResetTools( void) = 0 ;
@@ -85,6 +88,8 @@ class __declspec( novtable) IVolZmap : public IGeoObj
       virtual IVolZmap* ClonePart( int nPart) const = 0 ;
       virtual bool RemovePart( int nPart) = 0 ;
       virtual int  GetPartMinDistFromPoint( const Point3d& ptP) const = 0 ;
+      virtual bool AddSurfTm( const ISurfTriMesh* pStm) = 0 ;
+      virtual bool MakeUniform( double dToler) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------

EGnLuaAux.h

@@ -323,6 +323,24 @@ LuaSetParam( lua_State* L, const std::string& sPar)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+inline bool
+LuaSetParam( lua_State* L, const BOOLVECTOR& vPar)
+{
+   try {
+      int nSize = int( vPar.size()) ;
+      lua_createtable( L, nSize, 0) ;
+      for ( int i = 1 ; i <= nSize ; ++ i) {
+         lua_pushboolean( L, ( vPar[i-1] ? 1 : 0)) ;
+         lua_rawseti( L, -2, i) ;
+      }
+   }
+   catch( ...) {
+      return false ;
+   }
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 inline bool
 LuaSetParam( lua_State* L, const INTVECTOR& vPar)

EInAPI.h

@@ -252,6 +252,8 @@ EIN_EXPORT int  __stdcall EgtCreateArcC2PEx( int nParentId, const double ptCen[3
                                              const double ptNearEnd[3], int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateArc3P( int nParentId, const double ptP1[3],
                                           const double ptP2[3], const double ptP3[3], int nRefType) ;
+EIN_EXPORT int  __stdcall EgtCreateArc2PR( int nParentId, const double ptStart[3], const double ptEnd[3],
+                                           double dRad, BOOL bCCW, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateArc2PD( int nParentId, const double ptStart[3], const double ptEnd[3],
                                            double dDirSDeg, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateArc2PDEx( int nParentId, const double ptStart[3],

EMkMachMgr.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EMkMachMgr.h           Data : 02.04.24          Versione : 2.6d1
+// File : EMkMachMgr.h           Data : 22.04.24          Versione : 2.6d4
 // Contenuto : Dichiarazione della interfaccia IMachMgr.
 //
 //
@@ -17,6 +17,7 @@
 //             28.10.23 DS Aggiunte in interfaccia GetClEntAxesVal, GetToolSetupPosInCurrSetup e GetAllCurrAxesName.
 //             30.03.24 DS Aggiunte in interfaccia GetAllAxesNames e GetCalcTable.
 //             02.04.24 DS Aggiunta in interfaccia GetClEntAxesMask.
+//             22.04.24 DS Aggiunta in interfaccia GetExitId.
 //
 //----------------------------------------------------------------------------
 
@@ -322,6 +323,7 @@ class __declspec( novtable) IMachMgr
       virtual int  GetAxisId( const std::string& sAxis) const = 0 ;
       virtual int  GetHeadId( const std::string& sHead) const = 0 ;
       virtual int  GetHeadExitCount( const std::string& sHead) const = 0 ;
+      virtual int  GetExitId( const std::string& sHead, int nExit) const = 0 ;
       virtual int  GetTcPosId( const std::string& sTcPos) const = 0 ;
       virtual bool GetAxisToken( const std::string& sAxis, std::string& sToken) const = 0 ;
       virtual bool GetAxisType( const std::string& sAxis, bool& bLinear) const = 0 ;

EMkMachiningConst.h

@@ -66,7 +66,7 @@ enum MachiningType {
    MT_SURFROUGHING = OPER_SURFROUGHING,
    MT_SURFFINISHING = OPER_SURFFINISHING,
    MT_WATERJETTING = OPER_WATERJETTING,
-   MT_5AXMACHINING = OPER_5AXMACHINING
+   MT_FIVEAXISMILLING = OPER_FIVEAXISMILLING
 } ;
 
 //----------------------------------------------------------------------------
@@ -363,6 +363,22 @@ enum { MORTISE_PLUNGE_STEP = 0,
        MORTISE_PLUNGE_START_END = 3,
        MORTISE_PLUNGE_START_TO_END = 4} ;
 
+//----------------------------------------------------------------------------
+// Parametri per sgrossatura superfici
+// Sottotipo di lavorazione
+enum { SURFROU_SUB_ZIGZAG = 0,
+       SURFROU_SUB_ONEWAY = 1, 
+       SURFROU_SUB_SPIRALIN = 2,
+       SURFROU_SUB_SPIRALOUT = 3} ;
+// Tipo di attacco
+enum { SURFROU_LI_NONE = 0,
+       SURFROU_LI_GLIDE = 1,
+       SURFROU_LI_ZIGZAG = 2,
+       SURFROU_LI_HELIX = 3} ;
+// Tipo di uscita
+enum { SURFROU_LO_NONE = 0,
+       SURFROU_LO_GLIDE = 1} ;
+
 //----------------------------------------------------------------------------
 // Parametri per finitura superfici
 // Sottotipo di lavorazione
@@ -374,9 +390,6 @@ enum { SURFFIN_SUB_ZIGZAG = 0,
 enum { SURFFIN_LI_NONE = 0,
        SURFFIN_LI_LINEAR = 1,
        SURFFIN_LI_TANGENT = 2} ;
-// Tipo di link
-enum { SURFFIN_LL_STD = 0,
-       SURFFIN_LL_CENT = 1} ;
 // Tipo di uscita
 enum { SURFFIN_LO_NONE = 0,
        SURFFIN_LO_LINEAR = 1,

EMkOperationConst.h

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

EXeExecutor.h

@@ -275,6 +275,8 @@ EXE_EXPORT int  ExeCreateArcC2PEx( int nParentId, const Point3d& ptCen,
                                    const Point3d& ptNearEnd, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc3P( int nParentId, const Point3d& ptP1,
                                 const Point3d& ptP2, const Point3d& ptP3, int nRefType) ;
+EXE_EXPORT int  ExeCreateArc2PR( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
+                                 double dRad, bool bCCW, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc2PB( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
                                  double dBulge, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc2PD( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
@@ -321,6 +323,8 @@ EXE_EXPORT int  ExeCreatePolygonFromSide( int nParentId, int nNumSides, const Po
                                           const Point3d& ptFin, int nRefType) ;
 EXE_EXPORT int  ExeCreateCirclesAlongCurve( int nParentId, int nCrvId, double dOffset, double dOverlap,
                                             double dStartAdd, double dEndAdd, double dDiam, int* pnCount) ;
+EXE_EXPORT int  ExeCreateCurveBezierForm( int nParentId, int nCrvId) ;
+
 // GeomDB Create Surf
 EXE_EXPORT int  ExeCreateSurfFlatRegion( int nParentId, const INTVECTOR& vCrvIds, int* pnCount) ;
 EXE_EXPORT int  ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquaredEnds, bool bSquaredMids, double dLinTol) ;
@@ -374,8 +378,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) ;
+EXE_EXPORT int  ExeCreateVolZmapEmpty( int nParentId, const Point3d& ptIni, double dDimX,
+                                       double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
 EXE_EXPORT int  ExeCreateVolZmapByRegionExtrusion( int nParentId, int nSfrId, double dDimZ, double dPrec, bool bTriDex) ;
 EXE_EXPORT int  ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDex) ;
+EXE_EXPORT bool ExeUpdateVolZmapByAddingSurfTm( int nVolZmapId, int nStmId) ;
+EXE_EXPORT bool ExeUniformVolZmap( int nVolZmapId, double dToler) ;
 
 // GeomDB PartLayer
 EXE_EXPORT bool ExeIsPart( int nPartId) ;
@@ -603,6 +611,10 @@ EXE_EXPORT bool ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vect
                                          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 bool ExeProjectCurveOnSurfBz( int nCurveId, int nSurfBzId, const Vector3d& vtDir, int nDestGrpId,
+                                         double dLinTol, double dMaxSegmLen, int nRefType) ;
+EXE_EXPORT bool ExeProjectCurveOnSurfBzExt( int nCurveId, int nSurfBzId, 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) ;
@@ -635,9 +647,13 @@ EXE_EXPORT bool ExeSurfTmCut( int nId, int nCutterId, bool bInVsOut, bool bSaveO
 EXE_EXPORT bool ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId,
                                                        INTVECTOR vSurfsId, bool bOCFlag,
                                                        bool& bExistProjection, int& nNewId, int& nNewFaceNbr) ;
+EXE_EXPORT bool ExeSurfTmSetFaceColor( int nId, int nFacet, int nColor) ;
+EXE_EXPORT bool ExeSurfTmGetTriaColor( int nId, int nTria, int& nColor) ;
 EXE_EXPORT bool ExeSurfTmResetTwoColors( int nId) ;
 EXE_EXPORT bool ExeSurfTmSetShowEdges( int nId, bool bShow) ;
+EXE_EXPORT bool ExeSurfTmGetShowEdges( int nId, bool& bShow) ;
 EXE_EXPORT bool ExeSurfBzTrim( int nId, int nCutterId) ;
+EXE_EXPORT bool ExeSurfTmSetSmoothAng( int nId, double dAngDeg) ;
 
 // GeomDb Volume Modify
 EXE_EXPORT int  ExeExplodeVolume( int nId, int* pnCount) ;
@@ -655,6 +671,8 @@ EXE_EXPORT bool ExeVolZmapSetMortiserTool( const INTVECTOR& vIds, const std::str
                                            double dLen, double dWidth, double dThick, double dCornR, int nFlag, bool bFirst) ;
 EXE_EXPORT bool ExeVolZmapSetChiselTool( const INTVECTOR& vIds, const std::string& sToolName,
                                          double dLen, double dWidth, double dThick, int nFlag, bool bFirst) ;
+EXE_EXPORT bool ExeVolZmapSetAdditiveTool( const INTVECTOR& vIds, const std::string& sToolName,
+                                           double dLen, double dDiam, double dCornR, int nFlag, bool bFirst) ;
 EXE_EXPORT bool ExeVolZmapResetTools( const INTVECTOR& vIds) ;
 EXE_EXPORT int  ExeVolZmapGetToolOutline( int nId, int nDestGrpId, bool bApprox = false) ;
 EXE_EXPORT bool ExeVolZmapMillingStep( int nId, const Point3d& ptPs, const Vector3d& vtDs,
@@ -703,6 +721,7 @@ EXE_EXPORT bool ExeCurveCompoCenter( int nId, int nSimpCrv, int nRefId, Point3d&
 EXE_EXPORT bool ExeCurveCompoRadius( int nId, int nSimpCrv, double& dRad) ;
 EXE_EXPORT bool ExeCurveCompoAngCenter( int nId, int nSimpCrv, double& dAngCen) ;
 EXE_EXPORT bool ExeCurveCompoNormVersor( int nId, int nSimpCrv, int nRefId, Vector3d& vtNorm) ;
+EXE_EXPORT int ExeShowCurveBezierControlPoints( int nCrvId, int* pnCount) ;
 
 // GeomDb Surf Get
 EXE_EXPORT bool ExeSurfArea( int nId, double& dArea) ;
@@ -738,12 +757,16 @@ EXE_EXPORT bool ExeSurfTmFacetOppositeSideEx( int nId, int nFacet, const Vector3
 EXE_EXPORT bool ExeSurfTmFacetsContact( int nId, int nF1, int nF2, int nRefId, bool& bAdjac, Point3d& ptP1, Point3d& ptP2, double& dAng) ;
 EXE_EXPORT int  ExeExtractSurfTmLoops( int nId, int nDestGrpId, int* pnCount) ;
 EXE_EXPORT int  ExeGetSurfTmSilhouette( int nId, const Vector3d& vtDir, double dToler, int nDestGrpId, int nRefType, int* pnCount, bool bAllTria = false) ;
+EXE_EXPORT int  ExeGetSurfTmSilhouetteEx( int nId, const Point3d& ptOn, const Vector3d& vtN, double dToler, int nDestGrpId, int nRefType,
+                                          int* pnCount, bool bAllTria) ;
 EXE_EXPORT int  ExeExtractSurfTmFacetLoops( int nId, int nFacet, int nDestGrpId, int* pnCount) ;
 EXE_EXPORT int  ExeCopySurfTmFacet( int nId, int nFacet, int nDestGrpId) ;
 EXE_EXPORT bool ExeSurfTmGetAllVertInFacet( int nId, int nFacet, INTVECTOR& vVert) ;
 EXE_EXPORT bool ExeSurfTmGetFacetBBox( int nId, int nFacet, int nFlag, BBox3d& b3Box) ;
 EXE_EXPORT bool ExeSurfTmGetFacetBBoxGlob( int nId, int nFacet, int nFlag, BBox3d& b3Box) ;
 EXE_EXPORT bool ExeSurfTmGetFacetBBoxRef( int nId, int nFacet, int nFlag, const Frame3d& frRef, BBox3d& b3Box) ;
+EXE_EXPORT bool ExeSurfTmGetFacetOutlineInfo( int nId, int nFacet, int nRefId,
+                                              int& nStatus, BOOLVECTOR& vbOpen, INTVECTOR& vnAdj, DBLVECTOR& vdLen, VCT3DVECTOR& vvtNorm, DBLVECTOR& vdElev) ;
 EXE_EXPORT int  ExeSurfTmGetEdges( int nId, int nDestGrpId, bool bSmoothAng, int* pnCount) ;
 EXE_EXPORT bool ExeSurfBezierGetPoint( int nSurfId, double dU, double dV, int nRefId, Point3d& ptP) ;
 EXE_EXPORT bool ExeSurfBezierGetPointD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
@@ -1196,6 +1219,7 @@ EXE_EXPORT int  ExeGetTableId( const std::string& sTable) ;
 EXE_EXPORT int  ExeGetAxisId( const std::string& sAxis) ;
 EXE_EXPORT int  ExeGetHeadId( const std::string& sHead) ;
 EXE_EXPORT int  ExeGetHeadExitCount( const std::string& sHead) ;
+EXE_EXPORT int  ExeGetExitId( const std::string& sHead, int nExit) ;
 EXE_EXPORT int  ExeGetTcPosId( const std::string& sTcPos) ;
 EXE_EXPORT bool ExeGetAxisToken( const std::string& sAxis, std::string& sToken) ;
 EXE_EXPORT bool ExeGetAxisType( const std::string& sAxis, bool& bLinear) ;

EgtKeyCodes.h

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