Include :

- aggiornamento prototipi.

EExBeamConst.h

@@ -1,13 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2022
+//  EgalTech 2020-2026
 //----------------------------------------------------------------------------
-// File : EExBeamConst.h          Data : 04.04.22          Versione : 2.4d2
+// File : EExBeamConst.h          Data : 23.01.26          Versione : 3.1a2
 // Contenuto : Dichiarazione delle costanti per travi e pareti con BTL.
 //
 //
 //
 // Modifiche : 30.08.20 DS Creazione modulo.
 //             04.04.22 DS Aggiunto EIBFLAG_TRIM_WITH_OUTLINE.
+//             23.01.26 DS Aggiunto EIBFLAG_PARTOFFSET.
 //
 //----------------------------------------------------------------------------
 
@@ -22,4 +23,5 @@ enum EImBtlFlag { EIBFLAG_NONE =              0x0000,
                   EIBFLAG_SORT =              0x0010,         // ordina i pezzi nel DB in base al nome
                   EIBFLAG_USEUATTR =          0x0020,         // utilizza i parametri utente U per modificare la geometria delle features
                   EIBFLAG_OUTL_FLAT_POS =     0x0040,         // pezzi secondo outline o di piatto (prevale sui precedenti POS)
-                  EIBFLAG_TRIM_WITH_OUTLINE = 0x0080} ;       // esegui il trim delle feature con l'outline (se presente)
+                  EIBFLAG_TRIM_WITH_OUTLINE = 0x0080,         // esegui il trim delle feature con l'outline (se presente)
+                  EIBFLAG_PARTOFFSET =        0x0100} ;       // gestione geometrica del PARTOFFSET

EGkBBox3d.h

@@ -15,6 +15,7 @@
 #pragma once
 
 #include "/EgtDev/Include/EGkPoint3d.h"
+#include "/EgtDev/Include/EGkFrame3d.h"
 #include <vector>
 
 //----------------------- Macro per import/export ----------------------------
@@ -163,3 +164,9 @@ GetLocToLoc( const BBox3d& b3Box, const Frame3d& frOri, const Frame3d& frDest)
    b3New.LocToLoc( frOri, frDest) ;
    return b3New ;
 }
+
+//----------------------------------------------------------------------------
+inline bool Overlaps( const BBox3d& bbA, const Frame3d& frA, const BBox3d& bbB, const Frame3d& frB)
+{
+   return bbA.Overlaps( GetToLoc( frB, frA), bbB) ;
+}

EGkCAvSimpleSurfFrMove.h

@@ -35,20 +35,27 @@ const int SCI_LINE_LINE = 4 ;             // tra linea di mobile e linea di fiss
 struct SCollInfo
 {
    int nType ;                    // tipo di collisione
+
    int nChunkM ;                  // indice del chunk della regione mobile
-   int nCrvM ;                    // indice della curva nel loop esterno del chunk
+   int nLoopM ;                   // indice del loop del chunk della regione mobile
+   int nCrvM ;                    // indice della curva nel loop del chunk
+
    int nChunkF ;                  // indice del chunk della regione fissa
-   int nCrvF ;                    // indice della curva nel loop esterno del chunk
+   int nLoopF ;                   // indice del loop del chunk della regione fissa
+   int nCrvF ;                    // indice della curva nel loop del chunk
+
    Point3d ptP1 ;                 // punto di contatto
    Point3d ptP2 ;                 // se contatto linea-linea, secondo punto di contatto
    Vector3d vtDirM ;              // se contatto del mobile con linea, sua direzione
    Vector3d vtDirF ;              // se contatto del fisso con linea, sua direzione
+
    // costruttori
-   SCollInfo() : nType( SCI_NONE), nChunkM( -1), nCrvM( -1), nChunkF( -1), nCrvF( -1),
+   SCollInfo() : nType( SCI_NONE), nChunkM( -1), nLoopM( -1), nCrvM( -1), nChunkF( -1), nLoopF( -1), nCrvF( -1),
                  ptP1(), ptP2(), vtDirM(), vtDirF() {}
-   SCollInfo( const SCollInfo& Sou) : nType( Sou.nType), nChunkM( Sou.nChunkM), nCrvM( Sou.nCrvM),
-                                      nChunkF( Sou.nChunkF), nCrvF( Sou.nCrvF), ptP1( Sou.ptP1),
-                                      ptP2( Sou.ptP2), vtDirM( Sou.vtDirM), vtDirF( Sou.vtDirF) {} 
+   SCollInfo( const SCollInfo& Sou) : nType( Sou.nType),
+                                      nChunkM( Sou.nChunkM), nLoopM( Sou.nLoopM), nCrvM( Sou.nCrvM),
+                                      nChunkF( Sou.nChunkF), nLoopF( Sou.nLoopF), nCrvF( Sou.nCrvF),
+                                      ptP1( Sou.ptP1), ptP2( Sou.ptP2), vtDirM( Sou.vtDirM), vtDirF( Sou.vtDirF) {}
 } ;
 
 //----------------------------------------------------------------------------
@@ -67,4 +74,4 @@ class CAvSimpleSurfFrMove
       const ISurfFlatRegion* m_pRegM ;
       const ISurfFlatRegion* m_pRegF ;
       SCollInfo m_SCollInfo ;
-} ;
+} ;

EGkCAvSurfFrMove.h

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

EGkCDeClosedSurfTmClosedSurfTm.h

@@ -33,5 +33,6 @@ EGK_EXPORT bool CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const IS
 
 //----------------------------------------------------------------------------
 // Verifica l'interferenza tra le due superfici : restituisce true in caso di interferenza.
+// Se richiesta verifica inclusione se una delle due è chiusa controlla l'inclusione dell'altra. 
 //----------------------------------------------------------------------------
-EGK_EXPORT bool TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist) ;
+EGK_EXPORT bool TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist, bool bTestEnclosion = false) ;

EGkCalcPocketing.h

@@ -25,10 +25,15 @@
 #endif
 
 //-----------------------------------------------------------------------------
-EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double dStep,
+// Per calcolo percorso di Svuotatura o di Lucidatura
+EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadialOffs, double dStep,
                                double dAngle, double dOpenMinSafe, int nType, bool bSmooth, bool bCalcUnclReg, bool bInvert, bool bAvoidOpt,
-                               bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec, const ISurfFlatRegion* pSfrLimit,
-                               bool bAllOffs, double dMaxOptSize, double dLiTang, int nLiType, ICRVCOMPOPOVECTOR& vCrv) ;
+                               bool bConventionalMilling, bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec,
+                               const ISurfFlatRegion* pSfrLimit, bool bAllOffs, double dMaxOptSize,
+                               int nLiType, double dLiTang, double dLiElev, int nLoType, double dLoTang,
+                               bool bPolishing, double dEpicyclesRad, double dEpicyclesDist, ICRVCOMPOPOVECTOR& vCrv) ;
+EGK_EXPORT bool IsPocketingHole( const ISurfFlatRegion* pSfr, double dRad, double dRadialOffs, double dStep, int nType,
+                                 int nLiType, double dLiTang, double dRatioSfrTool) ;
 EGK_EXPORT bool CalcSmoothCurve( ICurveComposite* pCrv, double dRightLen, double dLeftLen, bool bAsParam) ;
 EGK_EXPORT bool CalcZigZagInfill( const ISurfFlatRegion* pSfr, double dStep, bool bSmooth, bool bRemoveOverlapLink,
                                   ICRVCOMPOPOVECTOR& vCrvCompoRes) ;
@@ -86,3 +91,9 @@ enum {
    LEAD_IN_ZIGZAG = 2,
    LEAD_IN_HELIX = 3
 } ;
+
+// Definizione tipo LeadOut
+enum {
+   LEAD_OUT_NONE = 0,
+   LEAD_OUT_GLIDE = 1
+} ;

EGkCurveAux.h

@@ -45,7 +45,7 @@ struct CNurbsData
    CNurbsData( void) : nDeg( 0), bRat( false), bPeriodic( false), bClosed( false), bClamped( true), bExtraKnotes(false) {}
 } ;
 
-// N.B. : in caso la curva sia razionale i punti di controllo sono in forma NON OMOGENEA [ x, y, z, w]  ( dove la forma OMOGENEA è [ w*x, w*y, w*z, w])
+// 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
 
 //----------------------------------------------------------------------------
@@ -65,7 +65,7 @@ EGK_EXPORT ICurve* ArcToBezierCurve( const ICurveArc* pArc, int nDeg = 3, bool b
 EGK_EXPORT ICurve* CompositeToBezierCurve( const ICurveComposite* pCrv, int nDeg = 3, bool bMakeRatOrNot = false) ;
 
 //----------------------------------------------------------------------------
-//! Trasforma una curva bezier in una nuova curva di Bezier semplice o composta della razionalità e  grado desiderato ( minimo 3)
+//! Trasforma una curva bezier in una nuova curva di Bezier semplice o composta della razionalit� e  grado desiderato ( minimo 3)
 EGK_EXPORT ICurve* EditBezierCurve( const ICurveBezier* pCrv, int nDeg = 3, bool bMakeRatOrNot = false, double dTol = 10 * EPS_SMALL) ;
 
 //----------------------------------------------------------------------------
@@ -77,11 +77,11 @@ EGK_EXPORT ICurve* ApproxBezierWithCubics( const ICurve* pCrv, double dTol) ;
 EGK_EXPORT ICurveBezier* ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen, const Vector3d& vtN) ;
 
 //----------------------------------------------------------------------------
-//! Campiona una serie di punti dalla curva e li approssima con una o più curve di bezier
-EGK_EXPORT ICurve* ApproxCurveWithBezier( const ICurve*, double dTol, int nType) ;
+//! Campiona una serie di punti dalla curva e li approssima con una o pi� curve di bezier
+EGK_EXPORT ICurve* ApproxCurveWithBezier( const ICurve* pCrv, double dTol, const Vector3d& vtStart = V_NULL, const Vector3d& vtEnd = V_NULL) ;
 
 //----------------------------------------------------------------------------
-//! Interpola un set di punti e li approssima con una o più curve di bezier cubiche
+//! Interpola un set di punti e li approssima con una o pi� curve di bezier cubiche
 EGK_EXPORT ICurve* InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMaxLen) ;
 
 //----------------------------------------------------------------------------
@@ -167,4 +167,13 @@ EGK_EXPORT bool CalcFatOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR
 
 //----------------------------------------------------------------------------
 //! Resetta l'oggetto voronoi associato alla curva liberandone la memoria
-EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;
+EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;
+
+//----------------------------------------------------------------------------
+//! fa il join delle curve passate in input
+EGK_EXPORT bool GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol = 5 * EPS_SMALL, bool bAllowInvert = false) ;
+
+//----------------------------------------------------------------------------
+//! dato un punto su una curva trova il corrispondente sulla seconda curva
+EGK_EXPORT bool GetIsoPointOnSecondCurve( const ICurve* pCrv1, const ICurve* pCrv2, double dUCurr1, double& dUCurr2, double dMyDist, double dUPrev2,
+                                          double dLenPrev2, double& dLenCurr2, double dLen2) ;

EGkCurveComposite.h

@@ -50,6 +50,7 @@ class __declspec( novtable) ICurveComposite : public ICurve
       virtual bool AddArcTg( const Point3d& ptNew, bool bEndOrStart = true) = 0 ;
       virtual bool AddJoint( double dU) = 0 ;
       virtual bool ModifyJoint( int nU, const Point3d& ptNewJoint) = 0 ;
+      virtual bool ModifyJoint( int nU, const Point3d& ptNewJoint, double dTol) = 0 ;
       virtual bool RemoveJoint( int nU) = 0 ;
       virtual bool MoveCurve( int nCrv, const Vector3d& vtMove) = 0 ;
       virtual bool ModifyCurveToArc( int nCrv, const Point3d& ptMid) = 0 ;
@@ -71,6 +72,7 @@ class __declspec( novtable) ICurveComposite : public ICurve
       virtual bool SetCurveTempParam( int nCrv, double dParam, int nParamInd = 0) = 0 ;
       virtual bool GetCurveTempParam( int nCrv, double& dParam, int nParamInd = 0) const = 0 ;
       virtual bool GetOnlyPoint( Point3d& ptStart) const = 0 ;
+      virtual bool ReplaceSingleCurve( int nSubCrv, ICurve* pNewCurve, double dTolStartEnd, double dTolAlong = INFINITO) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------
@@ -93,10 +95,16 @@ inline ICurveComposite* ConvertCurveToComposite( IGeoObj* pGObj)
                     delete pGObj ;
                     return nullptr ;
                  }
-                 ICurveComposite* pCrvCo = CreateCurveComposite() ;
-                 if ( pCrvCo == nullptr) {
-                    delete pGObj ;
-                    return nullptr ;
+                 ICurveComposite* pCrvCo = GetCurveComposite( pGObj) ;
+                 if ( pCrvCo != nullptr) {
+                    return pCrvCo ;
+                 }
+                 else {
+                    pCrvCo = CreateCurveComposite() ;
+                    if ( pCrvCo == nullptr) {
+                       delete pGObj ;
+                       return nullptr ;
+                    }
                  }
                  ICurve* pCrv = static_cast<ICurve*>( pGObj) ;
                  Vector3d vtExtr ;

EGkCurveLocal.h

@@ -23,7 +23,7 @@ class CurveLocal
       CurveLocal( IGeomDB* pGeomDB, int nCrvId, const Frame3d& frLoc)
          : m_pCrv( nullptr), m_pCopy( nullptr)
          { // verifica dei parametri
-            if ( pGeomDB == nullptr  ||  &frLoc == nullptr)
+            if ( pGeomDB == nullptr)
                return ;
            // recupero riferimento della curva
             Frame3d frCrv ;
@@ -76,7 +76,7 @@ class CurveLocal
                return ;
             m_pCrv = m_pCopy ;
          }
-      CurveLocal( CurveLocal&& Other)
+      CurveLocal( CurveLocal&& Other) noexcept
          : m_pCrv( Other.m_pCrv), m_pCopy( Other.m_pCopy)
          { // annullo gli originali
             Other.m_pCrv = nullptr ;

EGkCurvePointDiffGeom.h

@@ -40,7 +40,8 @@ class CrvPointDiffGeom
       double   dCurv ;
 
    public :
-      CrvPointDiffGeom( void) { nStatus = NONE ; nFlag = STD ; }
+      CrvPointDiffGeom( void)
+         : nStatus( NONE), nFlag( STD), dU( -1), dCurv( -1) {}
 } ;
 
 //----------------------------------------------------------------------------

EGkDistPointCurve.h

@@ -63,8 +63,8 @@ class DistPointCurve
       EGK_EXPORT bool GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFlag) const ;
       EGK_EXPORT bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const ;
       EGK_EXPORT bool GetParamAtMinDistPoint( double dNearParam, double& dParam, int& nFlag) const ;
-      EGK_EXPORT bool GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide) const ;
-      EGK_EXPORT bool GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide) const ;
+      EGK_EXPORT bool GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide, double dTol = EPS_SMALL) const ;
+      EGK_EXPORT bool GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide, double dTol = EPS_SMALL) const ;
       EGK_EXPORT bool GetMinDistInfo( int nInd, MinDistPCInfo& aInfo) const ;
 
    private :

EGkDistPointSurfBz.h

@@ -47,7 +47,7 @@ class DistPointSurfBz
       EGK_EXPORT bool IsZero( void) const
                        { return IsEpsilon( EPS_ZERO) ; }
       EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDistPoint) const ;
-      EGK_EXPORT bool GetParamPoint( Point3d& ptParamPoint) const ;
+      EGK_EXPORT bool GetParamsAtMinDistPoint( double& dU, double& dV) const ;
       EGK_EXPORT bool GetNorm( Vector3d& vtN) const ;
       EGK_EXPORT bool IsPointInside( void) const
                         { return ( m_bIsInside  &&  m_bIsSurfClosed) ; }
@@ -58,10 +58,10 @@ class DistPointSurfBz
       void Calculate( const Point3d& ptP, const ISurfBezier& srfBz) ;
 
    private :
-      double  m_dDist ;                   // Minima distanza del punto dalla superficie
-      Point3d m_ptMinDistPoint ;          // Punto sulla superficie a minima distanza
-      Point3d m_ptParam ;                 // punto corrispondente nello spazio parametrico
-      Vector3d m_vtN ;                    // normale alla superficie nel punto a minima distanza
-      bool    m_bIsInside ;               // Flag per punto interno o esterno alla superficie ( se chiusa )
-      bool    m_bIsSurfClosed ;           // Flag per superficie aperta o chiusa
+      double   m_dDist ;                   // Minima distanza del punto dalla superficie
+      Point3d  m_ptMinDistPoint ;          // Punto sulla superficie a minima distanza
+      Point3d  m_ptParam ;                 // punto corrispondente nello spazio parametrico (x->U, y->V)
+      Vector3d m_vtN ;                     // normale alla superficie nel punto a minima distanza
+      bool     m_bIsInside ;               // Flag per punto interno o esterno alla superficie ( se chiusa )
+      bool     m_bIsSurfClosed ;           // Flag per superficie aperta o chiusa
 } ;

EGkGdbConst.h

@@ -34,7 +34,8 @@ enum GdbInsPos { GDB_FIRST_SON = 0,
 //----------------- Costanti tipo salvataggio del DB geometrico ----------------
 enum GdbSave { GDB_SV_TXT =  0,
                GDB_SV_BIN =  1,
-               GDB_SV_CMPTXT = 2} ;
+               GDB_SV_CMPTXT = 2,
+               GDB_SV_CMPBIN = 3} ;
 
 //----------------- Costanti tipo oggetti del DB geometrico --------------------
 enum GdbType { GDB_TY_NONE =  0,

EGkGeoConst.h

@@ -1,13 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2019
+//  EgalTech 2013-2025
 //----------------------------------------------------------------------------
-// File : EGkGeoConst.h           Data : 23.11.19          Versione : 2.1k5
+// File : EGkGeoConst.h           Data : 22.11.25          Versione : 2.7k4
 // Contenuto : Costanti generali per calcoli geometrici.       
 //
 //
 //
 // Modifiche : 04.01.12 DS Creazione modulo.
 //             23.11.19 DS Aggiunta costante EPS_TRIA_H.
+//             22.11.25 DS Aggiunta costante PREC_SCALE_COEFF.
 //
 //----------------------------------------------------------------------------
 
@@ -59,3 +60,6 @@ const double SQRT2   = 1.41421356237309504880 ;
 const double SQRT1_2 = 1 / SQRT2 ;
 const double SQRT3   = 1.73205080756887729353 ;
 const double SQRT1_3 = 1 / SQRT3 ;
+
+// coefficiente di scalatura per aumentare precisione dei calcoli
+const double PREC_SCALE_COEFF = 1024 ;

EGkIntersCurvePlane.h

@@ -86,7 +86,7 @@ class IntersCurvePlane
       EGK_EXPORT int  GetIntersCount( void) ;
       //! Restituisce informazioni sull'intersezione di indice nInd ( 0 based)
       EGK_EXPORT bool GetIntCrvPlnInfo( int nInd, IntCrvPlnInfo& aInfo) ;
-      //! Restituisce il punto di intersezione più vicino al punto passato
+      //! Restituisce il punto di intersezione più vicino al punto passato
       EGK_EXPORT bool GetIntersPointNearTo( const Point3d& ptNear, Point3d& ptI, double& dParam) ;
       //! Restituisce la classificazione di una curva rispetto al piano
       EGK_EXPORT bool GetCurveClassification( double dLenMin, CRVPLNCVECTOR& ccClass) ;
@@ -106,4 +106,4 @@ class IntersCurvePlane
       ICPIVECTOR           m_Info ;
       const ICurve*        m_pCurve ;    // puntatore alla curva
       Plane3d              m_plPlane ;
-} ;
+} ;

EGkIntersCurves.h

@@ -44,7 +44,7 @@ struct IntCrvCrvInfo {
    IntCrvInfo IciB[2] ;     //!< IciB[0] intersez. isolata o inizio overlap, IciB[1] fine overlap 
   // costruttore
    IntCrvCrvInfo( void)
-      : bOverlap( false) {}
+      : bOverlap( false), bCBOverEq( false) {}
 } ;
 //! vettore di IntCrvCrvInfo
 typedef std::vector<IntCrvCrvInfo>  ICCIVECTOR ;
@@ -115,12 +115,16 @@ class IntersCurveCurve
       EGK_EXPORT bool GetOverlaps( void) ;
       //! Restituisce il numero di intersezioni (intersezioni doppie coincidenti e sovrapposte contano uno)
       EGK_EXPORT int  GetIntersCount( void) ;
+      //! Restituisce il numero di intersezioni in 3D ( filtrando le intersezioni)
+      EGK_EXPORT int  GetInters3DCount( void) ;
       //! Restituisce il numero di intersezioni in cui la curva si attraversa
       EGK_EXPORT int  GetCrossIntersCount( void) ;
       //! Restituisce il numero di intersezioni in cui la curva si attraversa o si sovrappone
       EGK_EXPORT int  GetCrossOrOverlapIntersCount( void) ;
       //! Restituisce informazioni sull'intersezione di indice nInd ( 0 based)
       EGK_EXPORT bool GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
+      //! Restituisce informazioni sulla i-esima intersezione 3D ( 0 based)
+      EGK_EXPORT bool GetInt3DCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
       //! Restituisce il punto di intersezione più vicino al punto passato
       EGK_EXPORT bool GetIntersPointNearTo( int nCrv, const Point3d& ptNear, Point3d& ptI) ;
       //! Restituisce la classificazione di una curva rispetto all'altra ( nCrv=0 -> CurvaA, nCrv=1 -> CurvaB)

EGkIntersLineBox.h

@@ -32,9 +32,11 @@ EGK_EXPORT bool IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double d
 
 //-----------------------------------------------------------------------------
 // Tipo di intersezione linea-box
-enum IntLineBoxType { ILBT_NONE =  0,                 // non è intersezione
+enum IntLineBoxType { ILBT_NONE =  0,                 // non è intersezione
                       ILBT_IN =  1,                   // ingresso nel box
                       ILBT_OUT = 2,                   // uscita dal box
                       ILBT_TG_INI = 3,                // ingresso tangente in una faccia del box
                       ILBT_TG_FIN = 4,                // uscita tangente da una faccia del box
-                      ILBT_TOUCH = 5} ;               // contatto su uno spigolo o su un vertice del box
+                      ILBT_TOUCH = 5,                 // contatto su uno spigolo o su un vertice del box
+                      ILBT_INSIDE = 6,                // contenimento nel box
+                      ILBT_TG_INSIDE = 7} ;              // contenimento su faccia del box

EGkIntersLineSurfBez.h

@@ -46,9 +46,9 @@ enum IntLineTriaAuxType { ILTA_NO_TRIA = -1,       // l'intersezione è stata ca
                           ILTA_IN = 5} ;          // intersezione in interno del triangolo
 
 //-----------------------------------------------------------------------------
-//! dati di intersezione linea - superficie trimesh
+//! dati di intersezione linea - superficie bezier
 struct IntLinSbzInfo {
-   int     nILTA ;          //!< tipo di intersezione linea-triangolo   // se -1 vuol dire che l'intersezione � stata calcolata direttamente, senza usare la trimesh
+   int     nILSB ;          //!< tipo di intersezione linea-bezier
    double  dU ;             //!< parametro sulla linea
    double  dU2 ;            //!< secondo parametro sulla linea
    int     nT ;             //!< indice del triangolo della superficie trimesh  // se -1 vuol dire che l'intersezione � stata calcolata direttamente, senza usare la trimesh
@@ -58,11 +58,11 @@ struct IntLinSbzInfo {
    Point3d ptUV ;            //!< coordinate del punto nello spazio parametrico
    Point3d ptUV2 ;           //!< coordinate del secondo punto nello spazio parametrico
    // costruttori
-   IntLinSbzInfo( void) : nILTA( ILTA_NO), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2(), ptUV(), ptUV2(){}
-   IntLinSbzInfo( int nILT, double dUU, int nTT, double dCos, const Point3d& ptP, const Point3d ptSP)
-      : nILTA( nILT), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2(), ptUV( ptSP), ptUV2() {}
-   IntLinSbzInfo( int nILT, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2, const Point3d& ptSP, const Point3d& ptSP2)
-      : nILTA( nILT), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2), ptUV( ptSP), ptUV2( ptSP2) {}
+   IntLinSbzInfo( void) : nILSB( LSBT_NONE), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2(), ptUV(), ptUV2(){}
+   IntLinSbzInfo( int nILS, double dUU, int nTT, double dCos, const Point3d& ptP, const Point3d ptSP)
+      : nILSB( nILS), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2(), ptUV( ptSP), ptUV2() {}
+   IntLinSbzInfo( int nILS, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2, const Point3d& ptSP, const Point3d& ptSP2)
+      : nILSB( nILS), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2), ptUV( ptSP), ptUV2( ptSP2) {}
 } ;
 //! vettore di IntLinSbzInfo
 typedef std::vector<IntLinSbzInfo>  ILSBIVECTOR ;

EGkMultiGeomDB.h

@@ -1,12 +1,13 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2025-2025
 //----------------------------------------------------------------------------
-// File : MultiGeomDB.h       Data : 08.10.25          Versione : 2.7j1
+// File : MultiGeomDB.h       Data : 22.12.25          Versione : 2.7l3
 // Contenuto : Dichiarazione delle funzioni tra due GeomDB.
 //
 //
 //
 // Modifiche : 08.10.25 DB Creazione modulo.
+//             22.12.25 DS Aggiunta funzione DuplicateGeomDB.
 //
 //
 //----------------------------------------------------------------------------
@@ -24,5 +25,6 @@
 #endif
 
 //----------------------------------------------------------------------------
-EGK_EXPORT int Copy( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter = GDB_LAST_SON) ;
-EGK_EXPORT int CopyGlob( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter = GDB_LAST_SON) ;
+EGK_EXPORT int  Copy( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter = GDB_LAST_SON) ;
+EGK_EXPORT int  CopyGlob( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter = GDB_LAST_SON) ;
+EGK_EXPORT bool DuplicateGeomDB( IGeomDB* pSouGeomDB, IGeomDB* pDestGeomDB, bool bSkipTemp = false) ;

EGkPlane3d.h

@@ -174,9 +174,8 @@ AreSamePlaneApprox( const Plane3d& plPlaneA, const Plane3d& plPlaneB)
 
 //-----------------------------------------------------------------------------
 inline bool
-AreSamePlaneExact( const Plane3d plPlaneA, const Plane3d& plPlaneB)
+AreSamePlaneExact( const Plane3d& plPlaneA, const Plane3d& plPlaneB)
 {
    return ( AreSameVectorExact( plPlaneA.GetVersN(), plPlaneB.GetVersN())  &&
             PointInPlaneExact( plPlaneA.GetPoint(), plPlaneB)) ;
 }
-

EGkPolyLine.h

@@ -108,7 +108,7 @@ class PolyLine
       EGK_EXPORT bool GetMaxDistanceFromLine( const Point3d& ptLine, const Vector3d& vtLine, double dLen,
                                               double& dMaxDist,  bool bIsSegment = true) const ;
       EGK_EXPORT bool AdjustForMaxSegmentLen( double dMaxLen) ;
-      EGK_EXPORT bool RemoveAlignedPoints( double dToler = EPS_SMALL) ;
+      EGK_EXPORT bool RemoveAlignedPoints( double dToler = EPS_SMALL, bool bStartEnd = true) ;
       EGK_EXPORT bool ApproxOnSide( const Vector3d& vtN, bool bLeftSide, double dToler = EPS_SMALL) ;
       EGK_EXPORT bool MakeConvex( const Vector3d& vtN,  bool bLeftSide) ;
       EGK_EXPORT bool Invert( bool bInvertU = true) ;
@@ -124,8 +124,8 @@ class PolyLine
                           { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
       EGK_EXPORT bool FromPointVector( const PNTVECTOR& vPnt)
                       {  Clear() ;
-                         for( int i = 0 ; i < int( vPnt.size()) ; ++i)
-                            { AddUPoint( i, vPnt[i]) ; }
+                         for ( int i = 0 ; i < std::ssize( vPnt) ; ++i)
+                            AddUPoint( i, vPnt[i]) ;
                          return GetPointNbr() > 0 ; }
 
    private :

EGkProjectCurveSurf.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2023-2023
+//  EgalTech 2023-2026
 //----------------------------------------------------------------------------
-// File : EGkProjectCurveSurfTm.h     Data : 31.08.23      Versione : 2.5h3
+// File : EGkProjectCurveSurfTm.h     Data : 14.04.26      Versione : 3.1d3
 // Contenuto : Dichiarazione funzioni proiezione curve su superficie Trimesh.
 //
 //
@@ -31,26 +31,34 @@ struct Point5ax {
    Point3d  ptP ;
    Vector3d vtDir1 ;
    Vector3d vtDir2 ;
+   Vector3d vtDirU ;
+   Vector3d vtDirV ;
    double   dPar ;
    int      nFlag ;
-   Point5ax( void) : ptP(), vtDir1(), vtDir2(), dPar(), nFlag() {} ;
+   Point5ax( void) : ptP(), vtDir1(), vtDir2(), vtDirU(), vtDirV(), dPar(), nFlag() {} ;
    Point5ax( const Point3d& ptBase, const Vector3d& vtTool, double dU, int nData)
-      : ptP( ptBase), vtDir1( vtTool), vtDir2(), dPar( dU), nFlag( nData) {} ;
+      : ptP( ptBase), vtDir1( vtTool), vtDir2(), vtDirU(), vtDirV(), dPar( dU), nFlag( nData) {} ;
    Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2, double dU, int nData)
-      : ptP( ptBase), vtDir1( vtTool), vtDir2( vtTool2), dPar( dU), nFlag( nData) {} ;
+      : ptP( ptBase), vtDir1( vtTool), vtDir2( vtTool2), vtDirU(), vtDirV(), dPar( dU), nFlag( nData) {} ;
+   Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2,
+             const Vector3d& vtDU, const Vector3d& vtDV, double dU, int nData)
+      : ptP( ptBase), vtDir1( vtTool), vtDir2( vtTool2), vtDirU( vtDU), vtDirV( vtDV), dPar( dU), nFlag( nData) {} ;
 } ; 
 typedef std::vector<Point5ax>        PNT5AXVECTOR ;    // vettore di Punti 5assi
 
 //----------------------------------------------------------------------------
-// Proiezione di una curva su una o più superfici lungo la direzione data
+// Proiezione di una curva su una o più superfici a distanza minima
+EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una o più superfici lungo la direzione data (da o verso)
 EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vector3d& vtDir,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici in direzione del punto
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una o più superfici in direzione del punto (da o verso)
 EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeoPoint3d& gpRef,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici in direzione della curva
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una o più superfici in direzione della curva (da o verso)
 EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICurve& crRef,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
-// Proiezione di una curva su una o più superfici in direzione della superficie
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
+// Proiezione di una curva su una o più superfici in direzione della superficie (da o verso)
 EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISurf& sfRef,
-                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
+                                    double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;

EGkSbzFromCurves.h

@@ -44,7 +44,8 @@ EGK_EXPORT ISurfBezier* GetSurfBezierByScrewing( const ICurve* pCurve, const Poi
 //EGK_EXPORT ISurfBezier* GetSurfBezierTransSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierRuled( const Point3d& ptP, const ICurve* pCurve, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, double dLinTol = 10 * EPS_SMALL) ;
-EGK_EXPORT ISurfBezier* GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const ICURVEPOVECTOR& vCrv, double dLinTol = 10 * EPS_SMALL) ;
+EGK_EXPORT ISurfBezier* GetSurfBezierRuledSmooth( const ICurve* pCurve1, const ICurve* pCurve2, BIPNTVECTOR& vSyncLines, double dSampleLen = 10) ;
+EGK_EXPORT ISurfBezier* GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const BIPNTVECTOR& vCrv, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierSkinned( const CICURVEPVECTOR& vCrv, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtNorm, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
 EGK_EXPORT ISurfBezier* GetSurfBezierSwept3d( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtNorm, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;

EGkSurfBezier.h

@@ -74,13 +74,13 @@ class __declspec( novtable) ISurfBezier : public ISurf
                                     Vector3d* pvtDerUU = nullptr, Vector3d* pvtDerVV = nullptr, Vector3d* pvtDerUV = nullptr) const = 0 ;
       virtual ICurveComposite* GetCurveOnU( double dV) const = 0 ;
       virtual ICurveComposite* GetCurveOnV( double dU) const = 0 ;
-      virtual ICurveComposite* GetLoop( int nLoop) const = 0 ;                               // nLoop 0-based (1°esterno, successivi interni) 
+      virtual ICurveComposite* GetLoop( int nLoop) const = 0 ;                               // nLoop 0-based (1°esterno, successivi interni) 
       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 const ISurfTriMesh* GetAuxSurfRefined( void) const = 0 ;
-      virtual ISurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL, bool bUpdateEdges = false) const = 0 ;
-      virtual bool GetLeaves ( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const = 0 ;
+      virtual ISurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 10 * EPS_SMALL, bool bUpdateEdges = false) const = 0 ;
+      virtual bool GetLeaves( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves, bool bRefined = false) 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 = 5) const = 0 ;
       virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL, const Point3d& ptIPrev, bool* bTroughEdge = nullptr) const = 0 ;
@@ -96,15 +96,20 @@ class __declspec( novtable) ISurfBezier : public ISurf
       virtual bool IsPlanar( void) const = 0 ;
       virtual bool CreateByFlatContour( const PolyLine& PL) = 0 ;
       virtual bool CreateByRegion( const POLYLINEVECTOR& vPL) = 0 ;
-      virtual bool CreateByExtrusion( const ICurve* pCrv, const Vector3d& vtExtr, bool bDeg3OrDeg2 = false) = 0 ;
+      virtual bool CreateByExtrusion( const ICurve* pCrv, const Vector3d& vtExtr) = 0 ;
       virtual bool CreateByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vector3d& vtAx, double dAngRotDeg, double dMove) = 0 ;
       virtual bool CreateByPointCurve( const Point3d& pt, const ICurve* pCurve) = 0 ;
       virtual bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) = 0 ;
       virtual bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3 = true) = 0 ;
+      virtual bool RemoveCollapsedSpans() = 0 ;
+      virtual PNTVECTOR GetAllControlPoints( void) const = 0 ;
+      virtual bool LimitSurfToTrimmedRegion( void) = 0 ;
+      virtual bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen) = 0 ;
+      virtual bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen, BIPNTVECTOR& vSyncLines) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------
-static const double SBZ_TREG_COEFF = 1024 ;
+static const double SBZ_TREG_COEFF = PREC_SCALE_COEFF ;
 
 //-----------------------------------------------------------------------------
 inline ISurfBezier* CreateSurfBezier( void)

EGkSurfBzRuledFromStmFaces.h

@@ -0,0 +1,37 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2025-2025
+//----------------------------------------------------------------------------
+// File : EGkSurfBzRuledFromStmFaces.h      Data : 15.09.25       Versione : 2.7j1
+// Contenuto : Calcolo di una superficie di Bezier Ruled definita da un sottoinsieme
+//             di facce di una superficie TriMesh
+//
+//
+//
+// Modifiche : 15.09.25 RE Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "EGkSelection.h"
+#include "EGkCurveLine.h"
+#include "/EgtDev/Include/EGkSurfBezier.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
+
+//----------------------- Macro per import/export ----------------------------
+#undef EGK_EXPORT
+#if defined( I_AM_EGK)            // da definirsi solo nella DLL
+   #define EGK_EXPORT __declspec( dllexport)
+#else
+   #define EGK_EXPORT __declspec( dllimport)
+#endif
+
+//-----------------------------------------------------------------------------
+EGK_EXPORT bool GetBezierEdgeCurvesFromSurfs( const CISURFPVECTOR& vSurf, const SELVECTOR& vSurfFace,
+                                     double dLinTol, double dAngTol, const BIPNTVECTOR& vBreakingPts,
+                                     ICRVCOMPOPOVECTOR& vBezierEdges) ;
+EGK_EXPORT bool GetSyncPointsFromBezierCurves( const ICurveComposite* pEdge0, const ICurveComposite* pEdge1,
+                                               ICRVLINEPOVECTOR& vLines) ;
+EGK_EXPORT bool GetAdjStmFacesInTol( const ISurfTriMesh* pStm, const INTVECTOR& vFaceRef, double dAngTol,
+                                     INTVECTOR& vOtherFaces, double dCurvature) ;

EGkSurfFlatRegion.h

@@ -52,7 +52,8 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
       virtual bool GetChunkCentroid( int nChunk, Point3d& ptCen) const = 0 ;
       virtual bool GetChunkArea( int nChunk, double& dArea) const = 0 ;
       virtual bool GetChunkPerimeter( int nChunk, double& dLen) const = 0 ;
-      virtual int  GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion& Other, int nOthChunk) const ;   // compare only outsides
+      virtual int  GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion& Other, int nOthChunk) const = 0 ;   // compare only outsides
+      virtual bool CheckChunkInterference( int nChunk, const ISurfFlatRegion& Other, int nOthChunk, bool& bInterference) const = 0 ;
       virtual bool GetChunkMaxOffset( int nChunk, double& dOffs) const = 0 ;
       virtual int  GetLoopCount( int nChunk) const = 0 ;
       virtual int  GetLoopCurveCount( int nChunk, int nLoop) const = 0 ;

EGkSurfLocal.h

@@ -23,7 +23,7 @@ class SurfLocal
       SurfLocal( IGeomDB* pGeomDB, int nSrfId, const Frame3d& frLoc)
          : m_pSrf( nullptr), m_pCopy( nullptr)
          { // verifica dei parametri
-            if ( pGeomDB == nullptr  ||  &frLoc == nullptr)
+            if ( pGeomDB == nullptr)
                return ;
            // recupero riferimento della superficie
             Frame3d frSrf ;
@@ -48,7 +48,7 @@ class SurfLocal
       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)
+            if ( pSurf == nullptr)
                return ;
            // assegno la superficie originale
             m_pSrf = pSurf ;
@@ -76,7 +76,7 @@ class SurfLocal
                return ;
             m_pSrf = m_pCopy ;
          }
-      SurfLocal( SurfLocal&& Other)
+      SurfLocal( SurfLocal&& Other) noexcept
          : m_pSrf( Other.m_pSrf), m_pCopy( Other.m_pCopy)
          { // annullo gli originali
             Other.m_pSrf = nullptr ;

EGkSurfTriMesh.h

@@ -138,6 +138,7 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
       virtual bool GetPartLoops( int nPart, POLYLINEVECTOR& vPL) const = 0 ;
       virtual bool RemovePart( int nPart) = 0 ;
       virtual ISurfTriMesh* ClonePart( int nPart) const = 0 ;
+      virtual bool GetPartAndShellFromFacet( int nFacet, int& nPart, 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 ;

EGkSurfTriMeshAux.h

@@ -25,6 +25,8 @@ static int STMOFF_EXTEND = 2 ;
 // Funzioni per Offset di singola superficie
 EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshOffset( const ISurfTriMesh* pStm, double dOffs, double dPrec, int nType = STMOFF_FILLET) ;
 EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshThickeningOffset( const ISurfTriMesh* pStm, double dOffs, double dPrec, int nType = STMOFF_FILLET) ;
-// Funzioni per Offset di più superfici
+// Funzioni per Offset di più superfici
 EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshesOffset( const CISURFTMPVECTOR& vStm, double dOffs, double dPrec, int nType = STMOFF_FILLET) ;
 EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshesThickeningOffset( const CISURFTMPVECTOR& vStm, double dOffs, double dPrec, int nType = STMOFF_FILLET) ;
+// Funzione per Creazione superficie Shell
+EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshShell( const ISurfTriMesh* pStm, double dThick, double dLinTol) ;

EGkTrimming.h

@@ -0,0 +1,63 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2025-2025
+//----------------------------------------------------------------------------
+// File : EgkTrimming.h      Data : 15.09.25       Versione : 2.7j1
+// Contenuto : Calcolo di una superficie di Bezier Ruled definita da un sottoinsieme
+//             di facce di una superficie TriMesh
+//
+//
+//
+// Modifiche : 15.09.25 RE Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "EGkSelection.h"
+#include "EGkCurveLine.h"
+#include "/EgtDev/Include/EGkSurfBezier.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
+
+//----------------------- Macro per import/export ----------------------------
+#undef EGK_EXPORT
+#if defined( I_AM_EGK)            // da definirsi solo nella DLL
+   #define EGK_EXPORT __declspec( dllexport)
+#else
+   #define EGK_EXPORT __declspec( dllimport)
+#endif
+
+typedef std::vector<ISURFPOVECTOR> ISURFPOMATRIX ;
+typedef std::vector<ICRVCOMPOPOVECTOR> ICRVCOMPOPOMATRIX ;
+
+enum RegolarizeType { STD = 0,  // standard, con modifiche dirette ai punti di controllo
+                      RMF = 1}; // ricostruendo le curve usando il rotation minimizing frame
+
+//-----------------------------------------------------------------------------
+EGK_EXPORT bool GetTrimmingStmAdjTria( const ISurfTriMesh* pStm, int nStartTria, const Point3d& ptStartTria,
+                                       double dAngTol, double dSize, double dSizeTol, ISurfTriMesh* pStmAdjTria) ;
+EGK_EXPORT bool GetTrimmingAdjSurfs( const CISURFPVECTOR& vSurf, const CISURFPVECTOR& vOtherSurf, double dLinTol,
+                                     double dAngTol, double dFaceAngTol,
+                                     INTVECTOR& vIndOtherSurf) ;
+EGK_EXPORT bool GetTrimmingRawEdges( const CISURFPVECTOR& vSurf, const SELVECTOR& vSurfFace,
+                                     double dLinTol, double dAngTol,
+                                     ICRVCOMPOPOVECTOR& vBezierEdges) ;
+EGK_EXPORT bool GetTrimmingBezierEdges( ICRVCOMPOPOVECTOR& vCompoRawEdges, double dLinTol, double dAngTol,
+                                        ICRVCOMPOPOVECTOR& vCompoEdges) ;
+EGK_EXPORT bool GetTrimmingFinalBorders( ICRVCOMPOPOVECTOR& vCompoBezierEdges, double dLinTol,
+                                         double dAngTol, BIPNTVECTOR& vBreakingPts, double dThick, double dThickTol) ;
+EGK_EXPORT bool GetTrimmingFinalBorders( CISURFPVECTOR& vpSurf, const SELVECTOR& vSurfFaces, double dSurfLinTol,
+                                         double dSurfAngTol, double dLinTol, double dAngTol, double dThick,
+                                         ICRVCOMPOPOVECTOR& vCompoBezierEdges) ;
+EGK_EXPORT ISurfBezier* GetTrimmingRuledBezier( const CISURFPVECTOR& vSurf, const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
+                                                double dLinTol, const BIPNTVECTOR& vSyncPoints) ;
+EGK_EXPORT bool GetTrimmingSurfBzSyncPoints( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
+                                             double dLinTol, BIPNTVECTOR& vSyncPoints) ;
+EGK_EXPORT bool GetTrimmingSyncInterpolation( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
+                                              const ICurve* pSync1, const ICurve* pSync2, double dLinTol,
+                                              double dAngTol, BIPNTVECTOR& vSyncPoints) ;
+EGK_EXPORT bool GetTrimmingHoleBorders( const CISURFPVECTOR& vpSurf, const Point3d& ptRef, double dSurfLinTol,
+                                        double dSurfAngTol, double dEdgeLinTol, double dEdgeAngTol,
+                                        double dEdgeThick, ICRVCOMPOPOVECTOR& vHoleBorders) ;
+EGK_EXPORT ISurfBezier* RegolarizeBordersLocally( const ISurfBezier* pSurfBz, const BIPOINT& bpIsoStart,
+                                                  const BIPOINT& bpIsoEnd, double dTol, int nType = RegolarizeType::STD) ;

EGkVolZmap.h

@@ -29,10 +29,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 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, double dExtraBox = 0) = 0 ;
+      virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) = 0 ;
+      virtual bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) = 0 ;
+      virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) = 0 ;
+      virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0, int* nError = nullptr) = 0 ;
       virtual int  GetBlockCount( void) const = 0 ;
       virtual int  GetBlockUpdatingCounter( int nBlock) const = 0 ;
       virtual bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const = 0 ;
@@ -94,6 +94,7 @@ class __declspec( novtable) IVolZmap : public IGeoObj
       virtual bool AddSurfTm( const ISurfTriMesh* pStm) = 0 ;
       virtual bool SubtractSurfTm( const ISurfTriMesh* pStm) = 0 ;
       virtual bool MakeUniform( double dToler, bool bIsExtensionFirst = true, int nToolNum = 0) = 0 ;
+      virtual bool RemoveFins( const Vector3d& vtDir, double dThick) = 0 ;
       virtual bool Offset( double dOffs, int nType) = 0 ;
 } ;
 

EGnFileUtils.h

@@ -1,13 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2022
+//  EgalTech 2013-2026
 //----------------------------------------------------------------------------
-// File : EGnFileUtils.h       Data : 09.04.22          Versione : 2.4d1
+// File : EGnFileUtils.h       Data : 09.01.26          Versione : 3.1a1
 // Contenuto : Prototipi funzioni di utilità su file e direttori.
 //
 //
 //
 // Modifiche : 11.12.13 DS Creazione modulo.
 //             09.04.22 DS Aggiunta FindAllFiles.
+//             09.01.26 DS Aggiunta EraseNonEmptyDirectory.
 //
 //----------------------------------------------------------------------------
 
@@ -42,4 +43,5 @@ EGN_EXPORT bool ExistsDirectory( const std::string& sDir) ;
 EGN_EXPORT bool CreateDirectoryEgt( const std::string& sDir) ;
 EGN_EXPORT bool EmptyDirectory( const std::string& sDir) ;
 EGN_EXPORT bool EraseDirectory( const std::string& sDir) ;
+EGN_EXPORT bool EraseNonEmptyDirectory( const std::string& sDir) ;
 EGN_EXPORT bool FindAllDirectories( const std::string& sDirSpec, STRVECTOR& vsDirNames) ;

EGnStringUtils.h

@@ -189,7 +189,30 @@ EGN_EXPORT bool FromString( const std::string& sVal, DBLVECTOR& vdVal) ;
 EGN_EXPORT bool FromString( const std::string& sVal, STRVECTOR& vsVal) ;
 
 //----------------------------------------------------------------------------
-EGN_EXPORT const std::string ToStringAdv( int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr) ;
+inline const std::string
+ToStringAdv( int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
+      {
+        // eseguo conversione
+         const int nBuffSize = 36 ;
+         char szBuff[nBuffSize]{} ;
+         auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
+         if ( Res.ec != std::errc()) {
+            if ( pnErr != nullptr)
+               *pnErr = int( Res.ec) ;
+            return "#Error" ;
+         }
+         // gestione codice di errore
+         if ( pnErr != nullptr)
+            *pnErr = 0 ;
+         // verifico lunghezza minima
+         int  nLen = (int) strlen( szBuff) ;
+         if ( nLen >= nPrec)
+            return szBuff ;
+         // porto la stringa alla minima lunghezza
+         std::string sBuff( szBuff)  ;
+         sBuff.insert( 0, ( nPrec - nLen), '0') ;
+         return sBuff ;
+      }
 inline const std::string
 ToString( int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
       {
@@ -210,7 +233,31 @@ ToString( int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
             *pnErr = 0 ;
          return szBuff ;
       }
-EGN_EXPORT const std::string ToStringAdv( unsigned int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr) ;
+
+inline const std::string
+ToStringAdv( unsigned int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
+      {
+        // eseguo conversione
+         const int nBuffSize = 36 ;
+         char szBuff[nBuffSize]{} ;
+         auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
+         if ( Res.ec != std::errc()) {
+            if ( pnErr != nullptr)
+               *pnErr = int( Res.ec) ;
+            return "#Error" ;
+         }
+         // gestione codice di errore
+         if ( pnErr != nullptr)
+            *pnErr = 0 ;
+         // verifico lunghezza minima
+         int  nLen = (int) strlen( szBuff) ;
+         if ( nLen >= nPrec)
+            return szBuff ;
+         // porto la stringa alla minima lunghezza
+         std::string sBuff( szBuff)  ;
+         sBuff.insert( 0, ( nPrec - nLen), '0') ;
+         return sBuff ;
+      }
 inline const std::string
 ToString( unsigned int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
       {
@@ -231,7 +278,38 @@ ToString( unsigned int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullpt
             *pnErr = 0 ;
          return szBuff ;
       }
-EGN_EXPORT const std::string ToStringAdv( long long nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr) ;
+template <size_t size>
+const std::string ToString( const unsigned int (&nVal)[size], int nPrec = 1)
+      { std::string sDest ; sDest.reserve( 8 * size) ;
+        for ( const auto& nV : nVal)
+           sDest += ToString( nV, nPrec) + "," ;
+        sDest.pop_back() ;
+        return sDest ; }
+
+inline const std::string
+ToStringAdv( long long nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
+      {
+        // eseguo conversione
+         const int nBuffSize = 68 ;
+         char szBuff[nBuffSize]{} ;
+         auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
+         if ( Res.ec != std::errc()) {
+            if ( pnErr != nullptr)
+               *pnErr = int( Res.ec) ;
+            return "#Error" ;
+         }
+         // gestione codice di errore
+         if ( pnErr != nullptr)
+            *pnErr = 0 ;
+         // verifico lunghezza minima
+         int  nLen = (int) strlen( szBuff) ;
+         if ( nLen >= nPrec)
+            return szBuff ;
+         // porto la stringa alla minima lunghezza
+         std::string sBuff( szBuff)  ;
+         sBuff.insert( 0, ( nPrec - nLen), '0') ;
+         return sBuff ;
+      }
 inline const std::string
 ToString( long long nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
       {

EInAPI.h

@@ -297,6 +297,8 @@ EIN_EXPORT int  __stdcall EgtCreatePolygonFromApothem( int nParentId, int nNumSi
                                                        const double ptMid[3], int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreatePolygonFromSide( int nParentId, int nNumSides, const double ptIni[3],
                                                     const double ptFin[3], int nRefType) ;
+EIN_EXPORT int  __stdcall EgtSurfBezierGetCurveU( int nSurfId, double dU, int nDestGroup) ;
+EIN_EXPORT int  __stdcall EgtSurfBezierGetCurveV( int nSurfId, double dV, int nDestGroup) ;
 
 // GeomDB Create Surf
 EIN_EXPORT int  __stdcall EgtCreateSurfFrRectangle( int nParentId, const double ptIni[3], const double ptCross[3], int nRefType) ;
@@ -634,6 +636,9 @@ EIN_EXPORT int  __stdcall EgtExtractSurfTmLoops( int nId, int nDestGrpId, int* p
 EIN_EXPORT int  __stdcall EgtExtractSurfTmFacetLoops( int nId, int nFacet, int nDestGrpId, int* pnCount) ;
 EIN_EXPORT int  __stdcall EgtCopySurfTmFacet( int nId, int nFacet, int nDestGrpId) ;
 EIN_EXPORT int  __stdcall EgtExtractSurfTmTriaLoop( int nId, int nT, int nDestGrpId) ;
+EIN_EXPORT BOOL __stdcall EgtSurfBezierParamsFromPoint( int nSurfId, const double ptOnSurf[3], int nRefId, double* pdU, double* pdV) ;
+EIN_EXPORT BOOL __stdcall EgtSurfBezierGetPointNrmD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
+                                                      double ptP[3], double vtNorm[3], double vtDerU[3], double vtDerV[3]) ;
 EIN_EXPORT int  __stdcall EgtExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount) ;
 
 // Geo Snap Vector/Point/Frame
@@ -945,6 +950,7 @@ EIN_EXPORT BOOL __stdcall EgtSetMachiningGeometry( int nNumId, const int nIds[],
 EIN_EXPORT BOOL __stdcall EgtPreviewMachining( BOOL bRecalc) ;
 EIN_EXPORT BOOL __stdcall EgtApplyMachining( BOOL bRecalc) ;
 EIN_EXPORT BOOL __stdcall EgtUpdateMachining( void) ;
+EIN_EXPORT BOOL __stdcall EgtChangePreviewMachiningToolShow( int nLookFlag) ;
 EIN_EXPORT BOOL __stdcall EgtPreparePreviewMachiningTool( void) ;
 EIN_EXPORT BOOL __stdcall EgtRemovePreviewMachiningTool( void) ;
 EIN_EXPORT int  __stdcall EgtGetPreviewMachiningToolStepCount( void) ;
@@ -1030,6 +1036,7 @@ EIN_EXPORT BOOL __stdcall EgtSetGridGeoAdv( double dSnapStep, int nMinLineSstep,
 EIN_EXPORT BOOL __stdcall EgtSetGridColor( const int nMinCol[4], const int nMajCol[4]) ;
 EIN_EXPORT BOOL __stdcall EgtResize( int nW, int nH) ;
 EIN_EXPORT BOOL __stdcall EgtDraw( void) ;
+EIN_EXPORT BOOL __stdcall EgtRedraw( void) ;
 EIN_EXPORT BOOL __stdcall EgtSelect( int nWinX, int nWinY, int nSelW, int nSelH, int* pnSel) ;
 EIN_EXPORT BOOL __stdcall EgtSetObjFilterForSelWin( BOOL bZerodim, BOOL bCurve, BOOL bSurf, BOOL bVolume, BOOL bExtra) ;
 EIN_EXPORT BOOL __stdcall EgtUnselectableAdd( int nId) ;

EMkMachMgr.h

@@ -176,10 +176,11 @@ class __declspec( novtable) IMachMgr
       virtual int  GetCurrSetup( void) const = 0 ;
       virtual bool GetDefaultSetupName( std::string& sName) const = 0 ;
       virtual bool ImportSetup( const std::string& sName) = 0 ;
+      virtual bool ExistsCurrSetup( void) const = 0 ;
       virtual bool VerifyCurrSetup( STRVECTOR& vsErrors) = 0 ;
-      virtual bool FindToolInCurrSetup( const std::string& sTool) = 0 ;
-      virtual bool GetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) = 0 ;
-      virtual bool GetToolsInCurrSetupPos( const std::string& sTcPos, STRVECTOR& vsTools) = 0 ;
+      virtual bool FindToolInCurrSetup( const std::string& sTool) const = 0 ;
+      virtual bool GetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) const = 0 ;
+      virtual bool GetToolsInCurrSetupPos( const std::string& sTcPos, STRVECTOR& vsTools) const = 0 ;
       virtual bool UpdateCurrSetup( void) = 0 ;
       virtual bool EraseCurrSetup( void) = 0 ;
      // Machinings DataBase
@@ -265,6 +266,7 @@ class __declspec( novtable) IMachMgr
       virtual bool RemoveMachiningPreview( void) = 0 ;
       virtual bool MachiningApply( bool bRecalc, bool bPostApply = true) = 0 ;
       virtual bool MachiningUpdate( bool bPostApply = true) = 0 ;
+      virtual bool ChangePreviewMachiningToolShow( int nLookFlag) = 0 ;
       virtual bool PreparePreviewMachiningTool( void) const = 0 ;
       virtual bool RemovePreviewMachiningTool( void) const = 0 ;
       virtual int  GetPreviewMachiningToolStepCount( void) const = 0 ; 
@@ -278,13 +280,19 @@ class __declspec( novtable) IMachMgr
       virtual bool IsMachiningEmpty( int nEmptyType = 0) const = 0 ;
       virtual bool GetMachiningStartPoint( Point3d& ptStart) const = 0 ;
       virtual bool GetMachiningEndPoint( Point3d& ptEnd) const = 0 ;
+      virtual bool GetMachiningStartAxes( bool bSkipClimb, DBLVECTOR& vAxVal) const = 0 ;
+      virtual bool GetMachiningEndAxes( bool bSkipRise, DBLVECTOR& vAxVal) const = 0 ;
      // CL Entities Interrogations
       virtual bool GetClEntMove( int nEntId, int& nMove) const = 0 ;
       virtual bool GetClEntFlag( int nEntId, int& nFlag, int& nFlag2) const = 0 ;
       virtual bool GetClEntIndex( int nEntId, int& nIndex) const = 0 ;
+      virtual bool GetClEntFeed( int nEntId, double& dFeed) const = 0 ;
       virtual bool GetClEntAxesStatus( int nEntId, int& nStatus) const = 0 ;
       virtual bool GetClEntAxesMask( int nEntId, int& nMask) const = 0 ;
       virtual bool GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const = 0 ;
+      virtual bool GetClEntTDir( int nEntId, Vector3d& vtTDir) const = 0 ;
+      virtual bool GetClEntCDir( int nEntId, Vector3d& vtCDir) const = 0 ;
+      virtual bool GetClEntADir( int nEntId, Vector3d& vtADir) const = 0 ;
      // Simulation
       virtual bool SimInit( void) = 0 ;
       virtual bool SimStart( bool bFirst) = 0 ;
@@ -304,13 +312,15 @@ class __declspec( novtable) IMachMgr
      // Machine Calc
       virtual bool SetCalcTable( const std::string& sTable) = 0 ;
       virtual bool SetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) = 0 ;
-      virtual bool GetAllCurrAxesNames( STRVECTOR& vAxName) const = 0 ;
+      virtual bool SetCalcSolCh( int nScc, bool bExact) = 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 ;
+      virtual bool GetCalcSolCh( int& nScc, bool& bExact) const = 0 ;
+      virtual bool GetAllCurrAxesNames( STRVECTOR& vAxName) const = 0 ;
+      virtual bool GetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) const = 0 ;
       virtual bool GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                                   int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) const = 0 ;
       virtual bool GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
@@ -330,6 +340,7 @@ class __declspec( novtable) IMachMgr
       virtual bool GetNearestAngleInStroke( int nInd, double dAngRef, double& dAng) const = 0 ;
       virtual bool LimitAngleToStroke( int nInd, double& dAng) const = 0 ;
       virtual bool VerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) const = 0 ;
+      virtual bool VerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, bool bClear, int& nStat) const = 0 ;
       virtual std::string GetOutstrokeInfo( bool bMM = true) const = 0 ;
      // Machine
       virtual int  GetBaseId( const std::string& sBase) const = 0 ;

EMkMachiningGeoConst.h

@@ -34,8 +34,10 @@ static std::string MCH_AUXVIEW = "AVIEW" ;
 static std::string MCH_TABS = "TABS" ;
 static std::string MCH_PV = "PV" ;
 static std::string MCH_ST = "ST" ;
+static std::string MCH_ST_DBL = "STDBL" ;
 static std::string MCH_CL = "CL" ;
 static std::string MCH_DBL = "DBL" ;
+static std::string MCH_HOME = "HOME" ;
 static std::string MCH_PATH = "P" ;
 // Nomi di entità CL speciali
 static std::string MCH_CL_CLIMB = "CLIMB" ;
@@ -49,6 +51,7 @@ static std::string MCH_CL_AGB_DWN = "AGBD" ;
 static std::string MCH_CL_AGB_IN = "AGBI" ;
 static std::string MCH_CL_AGB_OUT = "AGBO" ;
 static std::string MCH_CL_AGB_UP = "AGBU" ;
+static std::string MCH_CL_PARALLEL_DBL = "DBP" ;
 // Nomi di entità di preview
 static std::string MCH_PV_CUT = "CUT" ;
 static std::string MCH_PV_PRE_CUT = "PRC" ;
@@ -112,10 +115,15 @@ 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 gruppo CL per indicare il tipo di catena cinematica
+static std::string KEY_KINTYPE = "KINTYPE" ;
 // Chiave info in sottogruppo di CL per uscite attivate (per forature con gang drill)
 static std::string KEY_DRACEX = "DRACEX" ;
 // Chiave info in sottogruppo di testa per abilitarne visualizzazione in Preview (0/1 default) 
 static std::string KEY_PREVIEWSHOW = "PreviewShow" ;
+// Chiavi info in entità di CL e DBL per riferimenti reciproci
+static std::string KEY_DBL_MAIN = "Main" ;
+static std::string KEY_CL_DOUBLE = "Double" ;
 
 //----------------- Costanti posizione per preview utensile in lavorazione ------
 enum MchToolShow { MCH_TPM_CURR = 0,

ENkMachOptimization.h

@@ -51,7 +51,6 @@ struct ToolOptm {
       bTCX( bX), bTCY( bY), bTCZ( bZ), bTCA( bA), bTCB( bB), bTCC( bC), dTLoad( dTL), dTUnLoad( dTUL) {}
 } ;
 typedef std::vector<ToolOptm> TOOLOPTMVECTOR ;
-typedef std::list<ToolOptm> TOOLOPTMLIST ;
 
 // Definizione strutta per singola lavorazione
 struct MachOptm {
@@ -81,9 +80,29 @@ struct MachOptm {
       dA_Start( dA_Start) , dB_Start( dB_Start), dC_Start( dC_Start),
       dX_End( dX_End), dY_End( dY_End), dZ_End( dZ_End),
       dA_End( dA_End), dB_End( dB_End), dC_End( dC_End) {}
+   MachOptm()
+      : nId( -1), nIdTool( -1), nGroup( -1),
+        dX_Start( 0.), dY_Start( 0.), dZ_Start( 0.),
+        dA_Start( 0.) , dB_Start( 0.), dC_Start( 0.),
+        dX_End( 0.), dY_End( 0.), dZ_End( 0.),
+        dA_End( 0.), dB_End( 0.), dC_End( 0.) {} ;
 } ;
 typedef std::vector<MachOptm> MACHOPTMVECTOR ;
-typedef std::list<MachOptm> MACHOPTMLIST ;
+typedef std::vector<MACHOPTMVECTOR> MACHOPTMMATRIX ;
+
+// Definizione struttura per OpenBounds
+struct OpenBoundOptm {
+   int nGroup ;
+   bool bStartVsEnd ;
+   int nFlag ;
+   double dX ;
+   double dY ;
+   double dZ ;
+
+   OpenBoundOptm( int nOBGroup, bool bOBStartVsEnd, int nOBFlag, double dOBX, double dOBY, double dOBZ )
+      : nGroup( nOBGroup), bStartVsEnd( bOBStartVsEnd), nFlag( nOBFlag), dX( dOBX), dY( dOBY), dZ( dOBZ) {}
+} ;
+typedef std::vector<OpenBoundOptm> MACHOPTOPENBOUNDVECTOR ;
 
 //----------------------------------------------------------------------------
 class __declspec( novtable) IMachOptimization
@@ -104,8 +123,11 @@ class __declspec( novtable) IMachOptimization
       virtual bool SetLastMachining( int nId) = 0 ;
       virtual bool SetFeeds( double dFeedL, double dFeedA) = 0 ;
       virtual bool SetAllGroupsAsMandatory( bool bAllMandatory = false) = 0 ;
-      virtual bool GetResult( INTVECTOR& vIds) = 0 ;
+      virtual bool SetOptimizationForGroups( bool bOptForGroups = false) = 0 ;
+      virtual bool SetOpenBound( bool bStartVsEnd, int nFlag, double dX, double dY, double dZ) = 0 ;
+      virtual bool SetOpenBoundForGroups( int nGroup, bool bStartVsEnd, int nFlag, double dX, double dY, double dZ) = 0 ;
+      virtual bool Calculate( INTVECTOR& vIds) = 0 ;
 } ;
 
 //-----------------------------------------------------------------------------
-ENK_EXPORT IMachOptimization* CreateMachOptimization( void) ;
+ENK_EXPORT IMachOptimization* CreateMachOptimization( void) ;

EXeConst.h

@@ -69,7 +69,8 @@ enum ApprType{ APP_LINES = 0,                // come ICurve::APL_STD
                APP_LEFT_CONVEX_LINES = 11,   // come ICurve::APL_LEFT_CONVEX
                APP_RIGHT_LINES = 2,          // come ICurve::APL_RIGHT
                APP_RIGHT_CONVEX_LINES = 12,  // come ICurve::APL_RIGHT_CONVEX
-               APP_ARCS = 3} ;
+               APP_ARCS = 3,
+               APP_CUBIC_BEZIER = 4} ;
 
 //----------------- Costanti tipo punto intersezione Linea Curva ---------------
 enum CLiType { CLT_NONE =  0,

EXeExecutor.h

@@ -233,7 +233,10 @@ EXE_EXPORT bool ExeOptMachSetFeeds( double dFeedL, double dFeedA) ;
 EXE_EXPORT bool ExeOptMachAddDependence( int nIdPrec, int nIdNext) ;
 EXE_EXPORT bool ExeOptMachAddSuggestedDependence( int nIdPrec, int nIdNext) ;
 EXE_EXPORT bool ExeOptMachSetAllGroupDependencesAsMandatory( bool bAllMandatory) ;
-EXE_EXPORT bool ExeOptMachGetResult( INTVECTOR& vIds) ;
+EXE_EXPORT bool ExeOptMachSetOptimizationForGroups( bool bOptForGroups) ;
+EXE_EXPORT bool ExeOptMachSetOpenBound( bool bStartVsEnd, int nFlag, double dX, double dY, double dZ) ;
+EXE_EXPORT bool ExeOptMachSetOpenBoundForGroups( int nGroup, bool bStartVsEnd, int nFlag, double dX, double dY, double dZ) ;
+EXE_EXPORT bool ExeOptMachCalculate( INTVECTOR& vIds) ;
 
 // GeomDB Create
 EXE_EXPORT int  ExeCreateGroup( int nParentId, const Frame3d& frFrame, int nRefType) ;
@@ -399,11 +402,12 @@ EXE_EXPORT int  ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrC
 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  ExeCreateSurfTmByVolZmap( int nParentId, int nZmapId, int nPart) ;
+EXE_EXPORT int  ExeCreateSurfShell( int nParentId, int nSurfId, double dThick, double dLinTol) ;
 EXE_EXPORT int  ExeSurfTmOffset( int nParentId, const INTVECTOR& vIds, double dOffs, double dLinTol, int nType) ;
 EXE_EXPORT int  ExeSurfTmThickeningOffset( int nParentId, const INTVECTOR& vIds, double dOffs, double dLinTol, int nType) ;
 EXE_EXPORT int  ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTVECTOR& vPnt, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTUVECTOR& vPntW, int nRefType) ;
-EXE_EXPORT int  ExeCreateSurfBezierLeaves( int nParentId, int nSurfBzId, int nTextHeight = 50, bool bShowTrim = false, int* pnCount = nullptr) ;
+EXE_EXPORT int  ExeCreateSurfBezierLeaves( int nParentId, int nSurfBzId, int nTextHeight = 50, bool bShowTrim = false, bool bRefined = false, int* pnCount = nullptr) ;
 EXE_EXPORT int  ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBezierTria2D( int nParentId, int nSurfBzId, int nTextHeight, bool bShowTrim, int* pnCount) ;
 EXE_EXPORT int  ExeCreateSurfBzByFlatContour( int nParentId, int nCrvId, double dLinTol) ;
@@ -420,7 +424,8 @@ EXE_EXPORT int  ExeCreateSurfBzByRevolve( int nParentId, int nCrvId,
                                            bool bCapEnds, double dLinTol, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBzByPointCurve( int nParentId, int nCrvId, const Point3d& ptAx, bool bCapEnds, double dLinTol, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBzRuled( int nParentId, int nCrvId1, int nCrvId2, int nRuledType, bool bCapEnds, double dLinTol) ;
-EXE_EXPORT int  ExeCreateSurfBzRuledGuided( int nParentId, int nCrvId1, int nCrvId2, int nLayGuides, bool bCapEnds, double dLinTol) ;
+EXE_EXPORT int  ExeCreateSurfBzRuledGuided( int nParentId, int nCrvId1, int nCrvId2, const BIPNTVECTOR& vGuidesCrv,
+                                            bool bCapEnds, double dLinTol, int nLayGuides = GDB_ID_NULL) ;
 EXE_EXPORT int  ExeCreateSurfBzSkinned( int nParentId, const INTVECTOR& nCrvId1, bool bCapEnds, double dLinTol) ;
 EXE_EXPORT int  ExeCreateSurfBzSwept( int nParentId, int nSectId, int nGuideId, const Vector3d& vtAx,
                                       bool bCapEnds, double dLinTol, int nRefType) ;
@@ -500,6 +505,7 @@ EXE_EXPORT int  ExeCopy( int nSouId, int nRefId, int nSonBeforeAfter) ;
 EXE_EXPORT int  ExeCopyEx( int nSouCtx, int nSouId, int nDestCtx, int nRefId, int nSonBeforeAfter) ;
 EXE_EXPORT int  ExeCopyGlob( int nSouId, int nRefId, int nSonBeforeAfter) ;
 EXE_EXPORT int  ExeCopyGlobEx( int nSouCtx, int nSouId, int nDestCtx, int nRefId, int nSonBeforeAfter) ;
+EXE_EXPORT bool ExeDuplicateGeomDB( int nSouCtx, int nDestCtx, bool bSkipTemp = false) ;
 EXE_EXPORT bool ExeRelocate( int nSouId, int nRefId, int nSonBeforeAfter) ;
 EXE_EXPORT bool ExeRelocateGlob( int nSouId, int nRefId, int nSonBeforeAfter) ;
 EXE_EXPORT bool ExeGroupSwap( int nId1, int nId2, bool bSwapRef, bool bMark) ;
@@ -661,12 +667,14 @@ EXE_EXPORT bool ExeMergeCurvesInCurveCompo( int nId, double dLinTol, bool bStart
 EXE_EXPORT bool ExeRemoveCurveCompoUndercutOnY( int nId, double dLinTol) ;
 EXE_EXPORT bool ExeCurveCompoSetTempProp( int nId, int nCrv, int nProp, int nPropInd = 0) ;
 EXE_EXPORT bool ExeCurveCompoSetTempParam( int nId, int nCrv, double dParam, int nParamInd = 0) ;
-EXE_EXPORT bool ExeChainCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType) ;
-EXE_EXPORT bool ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType) ;
-EXE_EXPORT bool ExeProjectCurveOnSurf( int nCurveId, const INTVECTOR& vnSurfId, const Vector3d& vtProj, int nDestGrpId,
-                                       double dLinTol, double dMaxSegmLen, bool bDirFromProj, int nRefType) ;
+EXE_EXPORT bool ExeChainCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType, double dToler = 10 * EPS_SMALL) ;
+EXE_EXPORT bool ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType, double dToler = 10 * EPS_SMALL) ;
+EXE_EXPORT bool ExeProjectCurveOnSurf( int nCurveId, const INTVECTOR& vnSurfId, int nDestGrpId,
+                                       double dLinTol, double dMaxSegmLen) ;
+EXE_EXPORT bool ExeProjectCurveOnSurfDir( int nCurveId, const INTVECTOR& vnSurfId, const Vector3d& vtProj, int nDestGrpId,
+                                          double dLinTol, double dMaxSegmLen, bool bDirFromProj, bool bFromVsTo, int nRefType) ;
 EXE_EXPORT bool ExeProjectCurveOnSurfExt( int nCurveId, const INTVECTOR& vnSurfId, int nGuideId, int nDestGrpId,
-                                          double dLinTol, double dMaxSegmLen, bool bDirFromGuide) ;
+                                          double dLinTol, double dMaxSegmLen, bool bDirFromGuide, bool bFromVsTo) ;
 EXE_EXPORT int  ExeCurveGetVoronoi( const INTVECTOR& vIds, int nDestGrpId, int nBound, int* pnCount) ;
 EXE_EXPORT int  ExeCurveGetMedialAxis( const INTVECTOR& vIds, int nDestGrpId, int nSide, int* pnCount) ;
 EXE_EXPORT int  ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, bool bSquareMids, int* pnCount) ;
@@ -694,7 +702,6 @@ EXE_EXPORT bool ExeSurfTmRemoveFacet( int nId, int nFacet) ;
 EXE_EXPORT bool ExeSurfTmSwapFacets( int nId, int nFacet1, int nFacet2) ;
 EXE_EXPORT bool ExeSurfTmRemovePart( int nId, int nPart) ;
 EXE_EXPORT bool ExeCutSurfTmPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
-EXE_EXPORT bool ExeCutSurfBzPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
 EXE_EXPORT bool ExeCutSurfTmClosedCurve( int nSurfId, int nCurveId, bool bSaveOnEq) ;
 EXE_EXPORT bool ExeSurfTmAdd( int nId1, int nId2, bool bTwoColors = false) ;
 EXE_EXPORT bool ExeSurfTmSubtract( int nId1, int nId2, bool bTwoColors = false) ;
@@ -709,13 +716,16 @@ 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) ;
+EXE_EXPORT bool ExeSurfTmGetSmoothAng( int nId, double& dAngDeg) ;
+EXE_EXPORT bool ExeCutSurfBzPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
+EXE_EXPORT bool ExeSurfBzTrim( int nId, int nCutterId) ;
 
 // GeomDb Volume Modify
 EXE_EXPORT int  ExeExplodeVolume( int nId, int* pnCount) ;
 EXE_EXPORT bool ExeVolZmapChangeResolution( int nId, int nNewRes) ;
 EXE_EXPORT bool ExeVolZmapSetShowEdges( int nId, bool bShow) ;
+EXE_EXPORT bool ExeVolZmapGetShowEdges( int nId, bool& bShow) ;
 EXE_EXPORT bool ExeRemoveVolZmapPart( int nId, int nPart) ;
 EXE_EXPORT bool ExeVolZmapSetStdTool( const INTVECTOR& vIds, const std::string& sToolName,
                                       double dLen, double dDiam, double dCornR, double dCutterH, int nFlag, bool bFirst) ;
@@ -738,8 +748,9 @@ EXE_EXPORT bool ExeVolZmapMillingStep( int nId, const Point3d& ptPs, const Vecto
                                                 const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe, int nRefType) ;
 EXE_EXPORT bool ExeCutVolZmapPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, int nRefType) ;
 EXE_EXPORT bool ExeUpdateVolZmapByAddingSurfTm( int nVolZmapId, int nStmId) ;
-EXE_EXPORT bool ExeUniformVolZmap( int nVolZmapId, double dToler, bool bExtensionFirst, int nToolNum) ;
+EXE_EXPORT bool ExeVolZmapMakeUniform( int nVolZmapId, double dToler, bool bExtensionFirst, int nToolNum) ;
 EXE_EXPORT bool ExeVolZMapOffset( int nId, double dDist, int nType) ;
+EXE_EXPORT bool ExeVolZMapRemoveFins( int nVolZMapId, const Vector3d& vtDir, double dThick, int nRefType) ;
 
 // GeomDB Get
 EXE_EXPORT bool ExeTextNormVersor( int nId, int nRefId, Vector3d& vtNorm) ;
@@ -749,7 +760,7 @@ EXE_EXPORT bool ExeTextGetHeight( int nId, double& dH) ;
 EXE_EXPORT bool ExeTextGetItalic( int nId, bool& bItl) ;
 
 // GeomDb Get Pocketing
-EXE_EXPORT bool ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId, int& nFirstId, int& nCrvCount) ;
+EXE_EXPORT bool ExePocketing( int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId, int& nFirstId, int& nCrvCount) ;
 EXE_EXPORT int  ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, bool bRemoveOverlapLink,int* pnCount) ;
 
 // GeomDb Curve Get
@@ -799,12 +810,14 @@ EXE_EXPORT bool ExeSurfFrChunkMaxOffset( int nId, int nChunk, double& dMaxOffset
 EXE_EXPORT bool ExeSurfFrTestExternal( int nId1, int nId2, double dMinDist) ;
 EXE_EXPORT int  ExeSurfFrChunkCount( int nId) ;
 EXE_EXPORT int  ExeSurfFrChunkSimpleClassify( int nId1, int nChunk1, int nId2, int nChunk2, double dToler = 0) ;
+EXE_EXPORT int  ExeSurfFlatRegionInterference( int nId1, int nChunk1, int nId2, int nChunk2, double dToler = 0) ;
 EXE_EXPORT bool ExeSurfFrChunkCenter( int nId, int nChunk, int nRefId, Point3d& ptCen, Vector3d& vtN) ;
 EXE_EXPORT int  ExeExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount) ;
 EXE_EXPORT int  ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, int* pnCount) ;
 EXE_EXPORT int  ExeSurfTmVertexCount( int nId) ;
 EXE_EXPORT int  ExeSurfTmFacetCount( int nId) ;
 EXE_EXPORT int  ExeSurfTmPartCount( int nId) ;
+EXE_EXPORT bool ExeSurfTmGetPartAndShellFromFacet( int nSurfTm, int nFacet, int& nPart, int& nShell) ;
 EXE_EXPORT bool ExeSurfTmGetVertex( int nId, int nVert, int nRefId, Point3d& ptVert) ;
 EXE_EXPORT bool ExeSurfTmGetNearestVertex( int nId, const Point3d& ptNear, int nRefId, int& nVert, Point3d& ptVert) ;
 EXE_EXPORT bool ExeSurfTmTriangleNormVersor( int nId, int nTria, int nRefId, Vector3d& vtNorm) ;
@@ -845,9 +858,10 @@ EXE_EXPORT bool ExeSurfBezierGetPointD1( int nSurfId, double dU, double dV, int
                                          Point3d& ptP, Vector3d& vtDerU, Vector3d& vtDerV) ;
 EXE_EXPORT bool ExeSurfBezierGetPointNrmD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
                                             Point3d& ptP, Vector3d& vtN, Vector3d& vtDerU, Vector3d& vtDerV) ;
+EXE_EXPORT bool ExeSurfBezierParamsFromPoint( int nSurfId, const Point3d& ptOnSurf, int nRefId, double& dU, double& dV) ;
+EXE_EXPORT bool ExeSurfBezierGetInfo( int nSurfId, int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) ;
 EXE_EXPORT int  ExeSurfBezierGetCurveU( int nSurfId, double dV, int nDestGrpId) ;
 EXE_EXPORT int  ExeSurfBezierGetCurveV( int nSurfId, double dU, int nDestGrpId) ;
-EXE_EXPORT bool ExeSurfBezierGetInfo( int nSurfId, int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) ;
 EXE_EXPORT int  ExeSurfBezierGetControlCurveU( int nSurfId, int nIndV, int nDestGrpId) ;
 EXE_EXPORT int  ExeSurfBezierGetControlCurveV( int nSurfId, int nIndU, int nDestGrpId) ;
 EXE_EXPORT int  ExeExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount) ;
@@ -913,7 +927,7 @@ EXE_EXPORT bool ExePointSurfBzDist( const Point3d& ptP, int nSbzId, int nRefType
                                     double* pdDist, Point3d& ptMin, Vector3d& vtN) ;
  
 // Geo Intersect
-EXE_EXPORT bool ExeLineCurveInters( const Point3d& ptP, const Vector3d& vtDir, const int nId, const int nRefType,
+EXE_EXPORT bool ExeLineCurveInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
                                     INTDBLVECTOR& vInters) ;
 EXE_EXPORT bool ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, const BBox3d& b3Box,
                                   INTDBLVECTOR& vInters) ;
@@ -923,7 +937,7 @@ EXE_EXPORT bool ExeLineSurfBzInters( const Point3d& ptP, const Vector3d& vtDir,
                                      INTDBLVECTOR& vInters) ;
 EXE_EXPORT bool ExeLineVolZmapInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
                                       INTDBLVECTOR& vInters) ;
-EXE_EXPORT int  ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, const int nId, const int nDestGrpId, const int nRefType,
+EXE_EXPORT int  ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType,
                                      int* pnCount) ;
 EXE_EXPORT int  ExePlaneBoxInters( const Point3d& ptOn, const Vector3d& vtN, const BBox3d& b3Box, int nDestGrpId, int nRefType,
                                    int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
@@ -933,12 +947,13 @@ EXE_EXPORT int  ExeParPlanesSurfTmInters( const Point3d& ptOn, const Vector3d& v
                                           int* pnGrpCount) ;
 EXE_EXPORT int  ExePlaneVolZmapInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType,
                                        int* pnCount) ;
-EXE_EXPORT int  ExeCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId,
-                                     int* pnPntCount, int* pnCrvCount) ;
-EXE_EXPORT int  ExeCurveSurfTmInters( const int nCrvId, const int nStmId, const int nDestGrpId,
+EXE_EXPORT int  ExeCurveCurveInters( int nId1, int nId2, int nDestGrpId,
+                                     int* pnPntCount, int* pnCrvCount, bool bOnly3D = false) ;
+EXE_EXPORT int  ExeCurveSurfTmInters( int nCrvId, int nStmId, int nDestGrpId,
                                       int* pnPntCount, int* pnCrvCount) ;
 EXE_EXPORT int  ExeSurfTmSurfTmInters( int nId1, int nId2, int nDestGrpId, double dToler,
                                        int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
+EXE_EXPORT bool ExeBBoxOverlap( const BBox3d& bboxA, const Frame3d& frA, const BBox3d& bboxB, const Frame3d& frB) ;
 
 // Collision Detection
 EXE_EXPORT int  ExeCDeBoxSolid( const Frame3d& frBox, const Vector3d& vtDiag, int nSolidId, double dSafeDist, int nRefType) ;
@@ -958,7 +973,7 @@ EXE_EXPORT int  ExeTestRectPrismoidSurface( const Frame3d& frPrismoid, double dB
 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) ;
+EXE_EXPORT int  ExeTestSurfaceSurface( int nSurf1Id, int nSurf2Id, double dSafeDist, bool bTestEnclosion = false) ;
 
 // Maximum Filler
 EXE_EXPORT bool ExeMaxFillerStart( void) ;
@@ -1174,6 +1189,7 @@ EXE_EXPORT bool ExeTdbImport( const std::string& sFile, const STRVECTOR& vsTools
 EXE_EXPORT int  ExeGetCurrSetup( void) ;
 EXE_EXPORT bool ExeGetDefaultSetupName( std::string& sName) ;
 EXE_EXPORT bool ExeImportSetup( const std::string& sName) ;
+EXE_EXPORT bool ExeExistsCurrSetup( void) ;
 EXE_EXPORT bool ExeVerifyCurrSetup( STRVECTOR& vsErrors) ;
 EXE_EXPORT bool ExeFindToolInCurrSetup( const std::string& sTool) ;
 EXE_EXPORT bool ExeGetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) ;
@@ -1259,6 +1275,7 @@ EXE_EXPORT bool ExeSetMachiningGeometry( const SELVECTOR& vIds) ;
 EXE_EXPORT bool ExePreviewMachining( bool bRecalc) ;
 EXE_EXPORT bool ExeApplyMachining( bool bRecalc, bool bPostApply = true) ;
 EXE_EXPORT bool ExeUpdateMachining( bool bPostApply = true) ;
+EXE_EXPORT bool ExeChangePreviewMachiningToolShow( int nLookFlag) ;
 EXE_EXPORT bool ExePreparePreviewMachiningTool( void) ;
 EXE_EXPORT bool ExeRemovePreviewMachiningTool( void) ;
 EXE_EXPORT int  ExeGetPreviewMachiningToolStepCount( void) ;
@@ -1272,6 +1289,8 @@ EXE_EXPORT bool ExeGetMachiningSkippedGeometry( SELVECTOR& vIds) ;
 EXE_EXPORT bool ExeIsMachiningEmpty( int nEmptyType) ;
 EXE_EXPORT bool ExeGetMachiningStartPoint( Point3d& ptStart) ;
 EXE_EXPORT bool ExeGetMachiningEndPoint( Point3d& ptEnd) ;
+EXE_EXPORT bool ExeGetMachiningStartAxes( bool bSkipClimb, DBLVECTOR& vAxVal) ;
+EXE_EXPORT bool ExeGetMachiningEndAxes( bool bSkipRise, DBLVECTOR& vAxVal) ;
 EXE_EXPORT bool ExeApplyAllMachinings( bool bRecalc, bool bStopOnFirstErr, std::string& sErrList) ;
 EXE_EXPORT bool ExeApplyAllMachiningsEx( bool bRecalc, bool bStopOnFirstErr, std::string& sErrList, std::string& sWarnList) ;
 EXE_EXPORT bool ExeUpdateAllMachinings( bool bStopOnFirstErr, std::string& sErrList) ;
@@ -1280,10 +1299,13 @@ 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 ExeGetClEntFeed( int nEntId, double& dFeed) ;
 EXE_EXPORT bool ExeGetClEntAxesStatus( int nEntId, int& nStatus) ;
 EXE_EXPORT bool ExeGetClEntAxesMask( int nEntId, int& nMask) ;
 EXE_EXPORT bool ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) ;
-
+EXE_EXPORT bool ExeGetClEntTDir( int nEntId, Vector3d& vtTDir) ;
+EXE_EXPORT bool ExeGetClEntCDir( int nEntId, Vector3d& vtCDir) ;
+EXE_EXPORT bool ExeGetClEntADir( int nEntId, Vector3d& vtADir) ;
 // Simulation
 EXE_EXPORT bool ExeSimInit( void) ;
 EXE_EXPORT bool ExeSimStart( bool bFirst) ;
@@ -1321,9 +1343,11 @@ 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 ExeSetCalcSolCh( int nScc, bool bExact) ;
 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 ExeGetCalcSolCh( int& nScc, bool& bExact) ;
 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,
@@ -1343,6 +1367,7 @@ EXE_EXPORT bool ExeGetCalcTipFromPositions( double dX, double dY, double dZ, con
 EXE_EXPORT bool ExeGetCalcToolDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) ;
 EXE_EXPORT bool ExeGetCalcAuxDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) ;
 EXE_EXPORT bool ExeVerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) ;
+EXE_EXPORT bool ExeVerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, int& nStat) ;
 EXE_EXPORT bool ExeGetOutstrokeInfo( std::string& sInfo) ;
 // Machine Move
 EXE_EXPORT bool ExeSetAxisPos( const std::string& sAxis, double dVal, double* pdNewVal = nullptr) ;
@@ -1378,6 +1403,7 @@ EXE_EXPORT bool ExeSetCameraType( bool bOrthoOrPersp, bool bRedraw) ;
 EXE_EXPORT bool ExeSetZoomType( int nMode, bool bRedraw) ;
 EXE_EXPORT bool ExeResize( int nW, int nH) ;
 EXE_EXPORT bool ExeDraw( void) ;
+EXE_EXPORT bool ExeRedraw( void) ;
 EXE_EXPORT bool ExeSelect( int nWinX, int nWinY, int nSelW, int nSelH, int* pnSel) ;
 EXE_EXPORT bool ExeSetObjFilterForSelWin( bool bZerodim, bool bCurve, bool bSurf, bool bVolume, bool bExtra) ;
 EXE_EXPORT bool ExeUnselectableRemove( int nId) ;
@@ -1480,7 +1506,35 @@ EXE_EXPORT bool ExeRedisAsyncPublish( int nIdConnection, const std::string& sCha
 EXE_EXPORT bool ExeRedisAsyncSubscribe( int nIdConnection, const std::string& sChannel) ;
 EXE_EXPORT bool ExeRedisAsyncUnsubscribe( int nIdConnection, const std::string& sChannel) ;
 EXE_EXPORT bool ExeRedisAsyncSubscribeOneMessage( int nIdConnection, const std::string& sChannel, double dMaxTimeOut, std::string& sMessage) ;
+EXE_EXPORT bool ExeRedisAsyncGetMessage( int nIdConnection, const std::string& sChannel, int& nCount, std::string& sMessage) ;
 
 // Base64
 EXE_EXPORT bool ExeBase64Encode( const std::string& sFile, std::string& sB64Dest) ;
 EXE_EXPORT bool ExeBase64Decode( const std::string& sB64Sou, const std::string& sFile) ;
+
+// Trimming
+EXE_EXPORT int  ExeTrimmingGetSurfTmFaceAdj( int nParentId, int nSurfId, int nTria, const Point3d& vPts,
+                                             double dAngTol, double dSize, double dSizeTol) ;
+EXE_EXPORT int  ExeTrimmingGetSurfTmFromStmFaces( int nParentId, int nSurfId, const INTVECTOR& vFaces) ;
+EXE_EXPORT bool ExeTrimmingGetAdjSurfs( const INTVECTOR& vSurfId, const INTVECTOR& vOtherSurfId, double dLinTol,
+                                        double dAngTol, double dAngFaceTol, INTVECTOR& vResId) ;
+EXE_EXPORT bool ExeTrimmingGetBorders( int nParentId, const SELVECTOR& vIds, double dSurfLinTol, double dSurfAngTol,
+                                       double dLinTol, double dAngTol, int& nFirstId,  int& nCount) ;
+EXE_EXPORT bool ExeTrimmingGetBordersByNormals( int nParentId, const SELVECTOR& vIds, double dSurfLinTol,
+                                                double dSurfAngTol, double dLinTol, double dAngTol,
+                                                double dThick, int& nFirstId, int& nCount) ;
+EXE_EXPORT bool ExeTrimmingGetFinalBorders( int nParentId, const INTVECTOR& vCrvBezierId, double dLinTol, double dAngTol,
+                                            const PNTVECTOR& vBreakingPts, double dThick, double dThickTol,
+                                            int& nFirstId, int& nCount) ;
+EXE_EXPORT int  ExeTrimmingGetRuledBezier( int nParentId, const INTVECTOR& vIds, int nEdge1Id, int nEdge2Id, double dLinTol,
+                                           const INTVECTOR& vnLineIds) ;
+EXE_EXPORT bool ExeTrimmingInterpolateSyncLines( int nParentId, int nSync1Id, int nSync2Id,
+                                                 int nBorder1Id, int nBorder2Id, double dEdgeLinTol,
+                                                 double dEdgeAngTol, int& nFirstId, int& nCount) ;
+EXE_EXPORT bool ExeTrimmingGetSurfBzSyncPoints( int nParentId, int nEdge1Id, int nEdge2Id, double dLinTol,
+                                                double dAngTol, int nLineNbr, bool bShowOnCorners,
+                                                int& nFirstId, int& nCount) ;
+EXE_EXPORT bool ExeTrimmingGetHoleBorder( int nParentId, const INTVECTOR& vSurfIds, const INTVECTOR& vOtherSurfIds,
+                                          double dSurfLinTol, double dSurfAngTol, double dEdgeLinTol, double dEdgeAngTol,
+                                          double dEdgeThick, int& nFirstId, int& nCount) ;
+EXE_EXPORT int ExeRegolarizeSurfaceLocally( int nParentId, int nSurfId, int nSyncStartId, int nSyncEndId, double dLinTol, int nType) ;

EgtKeyCodes.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2025
+//  EgalTech 2015-2026
 //----------------------------------------------------------------------------
-// File : EgtKeyCodes.h       Data : 01.11.25        Versione : 2.7k1
+// File : EgtKeyCodes.h       Data : 02.01.26        Versione : 3.1a1
 // Contenuto : Costanti per codici di protezione librerie di base.
 //
 //
@@ -19,6 +19,7 @@
 //             01.01.23 DS Passaggio a versione 25.
 //             16.01.24 DS Passaggio a versione 26.
 //             07.01.25 DS Passaggio a versione 27.
+//             02.01.26 DS Passaggio a versione 31.
 //
 //----------------------------------------------------------------------------
 
@@ -26,7 +27,7 @@
 
 //----------------------------------------------------------------------------
 const int KEY_BASELIB_PROD = 207 ;
-const int KEY_BASELIB_VER = 2711 ;
+const int KEY_BASELIB_VER = 3105 ;
 const int KEY_BASELIB_LEV = 1 ;
 
 //----------------------------------------------------------------------------

EgtPointerOwner.h

@@ -21,7 +21,7 @@ class PtrOwner
    public :
       explicit PtrOwner( void) : m_pT( nullptr) {}
       explicit PtrOwner( T* pT) : m_pT( pT) {}
-      PtrOwner( PtrOwner<T>&& RPT) : m_pT( Release( RPT)) {}
+      PtrOwner( PtrOwner<T>&& RPT) noexcept : m_pT( Release( RPT)) {}
       PtrOwner( const PtrOwner<T>& RPT) = delete ;
       ~PtrOwner( void) { Reset() ; }
       bool Set( T* pT) { Reset() ; m_pT = pT ; return ( m_pT != nullptr) ; }