Include :

- codice di test per Zmap
2024-04-22 08:05:01 +02:00
39 changed files with 138 additions and 995 deletions
@@ -1,39 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EGkCAvSilhouetteSurfTm.h      Data : 08.06.24      Versione : 2.6f2
-// Contenuto : Dichiarazione della funzione calcolo silhouette.
-//
-//
-//
-// Modifiche : 08.06.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkSurfTriMesh.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
- 
-//-----------------------------------------------------------------------------
-EGK_EXPORT bool CAvSilhouetteSurfTm( const ISurfTriMesh& Stm, const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL) ;
-
-//-----------------------------------------------------------------------------
-class __declspec( novtable) ICAvParSilhouettesSurfTm
-{
-   public :
-      virtual ~ICAvParSilhouettesSurfTm( void) {}
-      virtual bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol) = 0 ;
-      virtual bool GetSilhouette( double dLevel, POLYLINEVECTOR& vPL) = 0 ;
-} ;
-
-//-----------------------------------------------------------------------------
-EGK_EXPORT ICAvParSilhouettesSurfTm* CreateCAvParSilhouettesSurfTm( void) ;
@@ -23,8 +23,6 @@
   #define EGK_EXPORT __declspec( dllimport)
 #endif

-class ICurveComposite ;
-
 //-----------------------------------------------------------------------------
 class __declspec( novtable) ICAvToolSurfTm {
   public :
@@ -38,10 +36,8 @@ class __declspec( novtable) ICAvToolSurfTm {
      virtual double GetToolRadius( void) const = 0 ;
      virtual double GetToolHeight( void) const = 0 ;
      virtual const ICurveComposite& GetToolOutline( bool bApprox = false) const = 0 ;
-      virtual bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
-                                 double& dTotDist, Vector3d* pvtTriaN = nullptr) const = 0 ;
-      virtual bool TestSeries( PNTUVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff = 1) = 0 ;
-      virtual bool TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol, double dProgCoeff = 1) = 0 ;
+      virtual bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist) = 0 ;
+      virtual bool TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol) = 0 ;
 } ;

 //-----------------------------------------------------------------------------
@@ -25,28 +25,7 @@
 #endif

 //-----------------------------------------------------------------------------
-EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double dStep,
-                               double dAngle, int nType, bool bSmooth, bool bInvert, bool bAvoidOpt,
-                               bool bAllowZigZagOneWayBorders, const Point3d& ptEndPrec, const ISurfFlatRegion* pSfrLimit,
-                               ICRVCOMPOPOVECTOR& vCrv) ;
+EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dStep, double dAngle, int nType,
+                               bool bSmooth, ICRVCOMPOPOVECTOR& vCrv) ;
 EGK_EXPORT bool CalcZigZagInfill( const ISurfFlatRegion* pSfr, double dStep, bool bSmooth, bool bRemoveOverlapLink,
                                  ICRVCOMPOPOVECTOR& vCrvCompoRes) ;
-
-//-----------------------------------------------------------------------------
-enum { POCKET_ZIGZAG = 0,
-       POCKET_ONEWAY = 1,
-       POCKET_SPIRALIN = 2,
-       POCKET_SPIRALOUT = 3,
-       POCKET_CONFORMAL_ZIGZAG = 4,
-       POCKET_CONFORMAL_ONEWAY = 5} ;
-
-enum { TEMP_PROP_SMOOTH = -2,
-       TEMP_PROP_INVALID = -1,
-       TEMP_PROP_CLOSE_EDGE = 0,
-       TEMP_PROP_OPEN_EDGE = 1,
-       TEMP_PROP_OUT_START = 2,
-       TEMP_PROP_SINGLE_CURVE = 3,
-       TEMP_PROP_OPT_TRAPEZOID = 4,
-       TEMP_PROP_BORDER_CURVE = 5,
-       TEMP_PROP_CURVE_ACTIVE = 6, 
-       TEMP_PROP_CURVE_INACTIVE = 7} ;
@@ -15,8 +15,6 @@

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

-class ICurveBezier ;
-class ICurveLine ;

 //----------------------- Macro per import/export ----------------------------
 #undef EGK_EXPORT
@@ -46,53 +44,9 @@ struct CNurbsData
 // N.B. : in caso la curva sia razionale i punti di controllo sono in forma NON OMOGENEA [ x, y, z, w]  ( dove la forma OMOGENEA è [ w*x, w*y, w*z, w])
 // tutte le operazioni richiedono la forma OMOGENEA, finite le quali posso riportarmi alla forma NON OMOGENEA

-//----------------------------------------------------------------------------
-//! Trasforma una linea in una nuova curva di Bezier semplice
-EGK_EXPORT ICurve* CurveToBezierCurve( const ICurve* pCrv, int nDeg = 3, bool bMakeRatOrNot = true) ;
-
-//----------------------------------------------------------------------------
-//! Trasforma una linea in una nuova curva di Bezier semplice
-EGK_EXPORT ICurveBezier* LineToBezierCurve( const ICurveLine* pLine, int nDeg = 3, bool bMakeRatOrNot = true) ;
-
 //----------------------------------------------------------------------------
 //! Trasforma un arco in una nuova curva di Bezier semplice o composta
-EGK_EXPORT ICurve* ArcToBezierCurve( const ICurve* pArc, int nDeg = 3, bool bMakeRatOrNot = true) ;
-
-//----------------------------------------------------------------------------
-//! Trasforma una curva compo in una nuova curva di Bezier semplice o composta
-EGK_EXPORT ICurve* CompositeToBezierCurve( const ICurveComposite* pCrvCompo, int nDeg = 3, bool bMakeRatOrNot = true) ;
-
-//----------------------------------------------------------------------------
-//! 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* pCrvBezier, int nDeg = 3, bool bMakeRatOrNot = true, double dTol = 10 * EPS_SMALL) ;
-
-//----------------------------------------------------------------------------
-//! Approssima una bezier con una serie di bezier cubiche
-EGK_EXPORT ICurve* ApproxBezierWithCubics( const ICurveBezier* pCrvBezier, double dTol) ;
-
-//----------------------------------------------------------------------------
-//! Approssima una bezier con una serie di bezier cubiche
-EGK_EXPORT ICurveBezier* ApproxArcCurveBezierWithSingleCubic( const ICurveBezier* pCrvBezier, const Point3d& ptCen) ;
-
-//----------------------------------------------------------------------------
-//! 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) ;
-
-//----------------------------------------------------------------------------
-//! Interpola un set di punti e li approssima con una o più curve di bezier cubiche
-EGK_EXPORT ICurve* InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dTol) ;
-
-//----------------------------------------------------------------------------
-//! Aumento il grado della curva di Bezier
-EGK_EXPORT ICurveBezier* BezierIncreaseDegree( const ICurveBezier* pCrvBezier) ;
-
-//----------------------------------------------------------------------------
-//! Riduco il grado della curva di Bezier
-EGK_EXPORT ICurveBezier* BezierDecreaseDegree( const ICurveBezier* pCrvBezier, double dTol) ;
-
-//----------------------------------------------------------------------------
-//! Misura l'errore di approsimazione tra la curva originale e quella modificata
-EGK_EXPORT bool CalcBezierApproxError( const ICurveBezier* pCrvOri, const ICurveBezier* pCrvNew, double& dErr, int nPoints = 20) ;
+EGK_EXPORT ICurve* ArcToBezierCurve( const ICurve* pArc) ;

 //----------------------------------------------------------------------------
 //! Trasforma una curva in una nuova curva semplice o composta senza archi (solo linee o curve di Bezier)
@@ -126,27 +80,21 @@ EGK_EXPORT ICurve* ProjectCurveOnPlane( const ICurve& crCrv, const Plane3d& plPl
 EGK_EXPORT bool AdjustCurveSlope( ICurveComposite* pCrv, double dNini, double dNfin) ;

 //----------------------------------------------------------------------------
-//! Calcolo del diagramma di Voronoi della curva/e, nei TempParam dei risultati la distanza
+//! Calcolo del diagramma di Voronoi della curva, nei TempParam dei risultati la distanza
 //! Per nBound tenere valore di default. 
 EGK_EXPORT bool CalcCurveVoronoiDiagram( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nBound = 3) ;
-EGK_EXPORT bool CalcCurvesVoronoiDiagram( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, int nBound = 3) ;

 //----------------------------------------------------------------------------
-//! Calcolo del Medial Axis della curva/e (sottoinsieme del diagramma di Voronoi), nei TempParam dei risultati la distanza
+//! Calcolo del Medial Axis della curva (sottoinsieme del diagramma di Voronoi), nei TempParam dei risultati la distanza
 const int WMAT_BOTHSIDES = 0 ;
 const int WMAT_LEFT = 1 ;
 const int WMAT_RIGHT = 2 ;
 EGK_EXPORT bool CalcCurveMedialAxis( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nSide) ;
-EGK_EXPORT bool CalcCurvesMedialAxis( const CICURVEPVECTOR& vCrvC, ICURVEPOVECTOR& vCrvs, int nSide) ;

 //----------------------------------------------------------------------------
 //! Calcola l'offset completo di una curva
 EGK_EXPORT bool CalcCurveFatCurve( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dRadius, bool bSquareEnds, bool bSquareMids) ;

-//----------------------------------------------------------------------------
-//! Calcola, nel caso di curve chiuse, il valore limite di offset ( in valore assoluto) che fa sparire la curva
-EGK_EXPORT bool CalcCurveLimitOffset( const ICurve& crvC, double& dOffs) ;
-
 //----------------------------------------------------------------------------
 //! Resetta l'oggetto voronoi associato alla curva liberandone la memoria
 EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;
@@ -16,7 +16,6 @@
 #include "/EgtDev/Include/EGkCurve.h"

 class ICurveArc ;
-class ICurveLine ;

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

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

   private :
+      DistPointCurve( void) ;
      void LineCalculate( const Point3d& ptP, const ICurve& Curve, bool bIsSegment) ;
      void ArcCalculate( const Point3d& ptP, const ICurve& Curve) ;
      void CrvBezierCalculate( const Point3d& ptP, const ICurve& Curve) ;
@@ -1,65 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2013-2024
-//----------------------------------------------------------------------------
-// File : EGkDistPointLine.h      Data : 20.05.24          Versione : 2.6e5
-// Contenuto : Dichiarazione della classe distanza punto da linea/segmento.
-//
-//
-//
-// Modifiche : 30.12.12 DS Creazione modulo.
-//             20.05.24 DS Pubblicato in Include.
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkPoint3d.h"
-#include "/EgtDev/Include/EGkCurveLine.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
-
-
-//-----------------------------------------------------------------------------
-class DistPointLine
-{
-   friend class DistPointCurve ;
-
-   public :
-      EGK_EXPORT DistPointLine( const Point3d& ptP,
-                                const ICurveLine& crvLine, bool bIsSegment = true) ;
-      EGK_EXPORT DistPointLine( const Point3d& ptP,
-                                const Point3d& ptIni, const Point3d& ptFin, bool bIsSegment = true) ;
-      EGK_EXPORT DistPointLine( const Point3d& ptP,
-                                const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment = true) ;
-
-   public :
-      EGK_EXPORT bool GetSqDist( double& dSqDist) const ;
-      EGK_EXPORT bool GetDist( double& dDist) const ;
-      EGK_EXPORT bool IsEpsilon( double dTol) const
-                         { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
-      EGK_EXPORT bool IsSmall( void) const
-                         { return IsEpsilon( EPS_SMALL) ; }
-      EGK_EXPORT bool IsZero( void) const
-                         { return IsEpsilon( EPS_ZERO) ; }
-      EGK_EXPORT int  GetNbrMinDist( void) const
-                         { return (( m_dSqDist < 0) ? 0 : 1) ; }
-      EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDist) const ;
-      EGK_EXPORT bool GetParamAtMinDistPoint( double& dParam) const ;
-
-   private :
-      void Calculate( const Point3d& ptP,
-                      const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment) ;
-
-   private :
-      double  m_dSqDist ;
-      mutable double  m_dDist ;
-      double  m_dParam ;
-      Point3d m_ptMinDist ;
-} ;
-
@@ -1,72 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EGkDistPointSurfFr.h     Data : 18.07.24        Versione : 2.6g5
-// Contenuto : Dichiarazione della classe distanza Punto da FlatRegion.
-//
-//
-//
-// Modifiche : 18.07.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkSurfFlatRegion.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-   #define EGK_EXPORT __declspec( dllexport)
-#else
-   #define EGK_EXPORT __declspec( dllimport)
-#endif
-
-//----------------------------------------------------------------------------
-// Calcola la distanza tra punto e Flat Region.
-// Risultati :
-// - distanza
-// - punto sulla superficie a minima distanza
-// - indici del chunk e del loop e parametro del punto di frontiera a minima distanza
-// - indicazione se il punto passato è sul bordo (PRS_ON), interno (PRS_IN) o esterno (PRS_OUT) alla regione.
-// Note :
-// - nel caso di più punti di frontiera vicini, ne viene calcolato solo uno
-// - se il punto non giace nel piano della Regione 
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-enum PrSide { PRS_IN = -1, PRS_ON = 0, PRS_OUT = +1} ;
-// Corrispondono a MDS_LEFT, MDS_ON e MDS_RIGHT per giacitura punto rispetto a curva.
-
-//----------------------------------------------------------------------------
-class DistPointSurfFr
-{
-   public :
-      EGK_EXPORT DistPointSurfFr( const Point3d& ptP, const ISurfFlatRegion& frSurf) ;
-
-   public :
-      EGK_EXPORT bool GetDist( double& dDist) const ;
-      EGK_EXPORT bool GetDistOnRegionPlane( double& dDist) const ;
-      EGK_EXPORT bool GetPointAtMinDist( Point3d& ptMinDistPoint) const ;
-      EGK_EXPORT bool GetParamAtMinDist( int& nMinChunk, int& nMinLoop, double& dMinPar) const ;
-      EGK_EXPORT bool GetSideAtMinDist( int& nSide) const ;
-
-   private :
-      void Calculate( const Point3d& ptP, const ISurfFlatRegion& frSurf) ;
-
-   private :
-      double  m_dDist ;
-      double  m_dDistOnPlane ;
-      int     m_nMinChunk ;
-      int     m_nMinLoop ;
-      double  m_dMinPar ;
-      Point3d m_ptMinDistPoint ;
-      int     m_nSide ;
-} ;
-
-//----------------------------------------------------------------------------
-// Verifica velocizzata
-EGK_EXPORT bool IsPointInsideSurfFr( const Point3d& ptP, const ISurfFlatRegion* pSfr, double dMinDist, bool& bInside, int& nChunk) ;
-inline bool IsPointInsideSurfFr( const Point3d& ptP, const ISurfFlatRegion* pSfr, double dMinDist, bool& bInside)
-               { int nChunk ; return IsPointInsideSurfFr( ptP, pSfr, dMinDist, bInside, nChunk) ;}
@@ -29,8 +29,7 @@
 // - distanza
 // - punto sulla superficie a minima distanza
 // - indice del triangolo su cui giace il punto
-// - indicazione se il punto di riferimento è dalla parte interna o esterna della superficie ( se chiusa ).
-// - indicazione se il punto di riferimento è a destra o sinistra della superficie ( se aperta )
+// - indicazione se il punto di riferimento è dalla parte interna o esterna della superficie.
 //----------------------------------------------------------------------------
 class DistPointSurfTm
 {
@@ -48,9 +47,7 @@ class DistPointSurfTm
      EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDistPoint) const ;
      EGK_EXPORT bool GetMinDistTriaIndex( int& nMinDistTriaIndex) const ;
      EGK_EXPORT bool IsPointInside( void) const
-                        { return ( m_bIsInside  &&  m_bIsSurfClosed) ; }
-      EGK_EXPORT bool IsPointOnLeftSide( void) const
-                        { return m_bIsInside ;}
+                        { return m_bIsInside ; }

   private :
      void Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf) ;
@@ -60,7 +57,6 @@ class DistPointSurfTm
      Point3d m_ptMinDistPoint ;
      int     m_nMinDistTriaIndex ;
      bool    m_bIsInside ;
-      bool    m_bIsSurfClosed ;
 } ;

 //----------------------------------------------------------------------------
@@ -116,22 +116,11 @@ operator/( const Frame3d& frRef, const Frame3d& frDest)
   return frNew ;
 }

-//----------------------------------------------------------------------------
-//! Restituisce il frame inverso di quello passato
-//----------------------------------------------------------------------------
-inline const Frame3d 
-GetInvert( const Frame3d& frRef)
-{
-   Frame3d frNew = GLOB_FRM ;
-   frNew.ToLoc( frRef) ;
-   return frNew ;
-}
-
 //----------------------------------------------------------------------------
 //! Restituisce una copia in locale del frame passato
 //----------------------------------------------------------------------------
 inline const Frame3d 
-GetToLoc( const Frame3d& frRef, const Frame3d& frDest)
+GetToLoc ( const Frame3d& frRef, const Frame3d& frDest)
 {
   Frame3d frNew = frRef ;
   frNew.ToLoc( frDest) ;
@@ -58,8 +58,7 @@ enum GdbStatus { GDB_ST_OFF = 0,

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

 //----------------- Costante per numero proprietà temporanee -------------------
 const int GDB_NUM_TEMP_PROP = 2 ;
@@ -80,7 +80,7 @@ CalcMark( int nObjMark, int nParentMark)
   if ( nObjMark == GDB_MK_OFF  &&  nParentMark == GDB_MK_OFF)
      return GDB_MK_OFF ;

-   return ( nParentMark != GDB_MK_OFF ? nParentMark : nObjMark) ;
+   return GDB_MK_ON ;
 }
 // ovviamente la marcatura si combina con lo stato, nel senso che un oggetto 
 // non visibile non viene nemmeno marcato
@@ -104,7 +104,7 @@ class __declspec( novtable) IGdbIterator
      virtual bool RevertStatus( void) = 0 ;
      virtual bool GetStatus( int& nStat) const = 0 ;
      virtual bool GetCalcStatus( int& nStat) const = 0 ;
-      virtual bool SetMark(  int nMark = GDB_MK_ON) = 0 ;
+      virtual bool SetMark( void) = 0 ;
      virtual bool ResetMark( void) = 0 ;
      virtual bool GetMark( int& nMark) const = 0 ;
      virtual bool GetCalcMark( int& nMark) const = 0 ;
@@ -21,7 +21,7 @@
 bool
 SaveGeoObj( IGeoObj* pGObj, const std::string& sFile, int nFlag = GDB_SV_BIN)
 {
-  // verifico validità oggetto
+  // verifico validità oggetto
   if ( pGObj == nullptr  ||  ! pGObj->IsValid())
      return false ;
  // creo GeomDB temporaneo
@@ -47,7 +47,7 @@ bool
 SaveGeoObj( std::vector<IGeoObj*> vpGObj, const std::string& sFile, int nFlag = GDB_SV_BIN)
 {
   for ( int i = 0 ; i < int( vpGObj.size()); ++i) {
-     // verifico validità oggetto
+     // verifico validità oggetto
      if ( vpGObj[i] == nullptr  ||  ! vpGObj[i]->IsValid() )
         return false ;
   }
@@ -74,174 +74,5 @@ SaveGeoObj( std::vector<IGeoObj*> vpGObj, const std::string& sFile, int nFlag =
   for ( int i = 0 ; i < int( vIds.size()); ++i)
      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr ) && bOk ;

-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SaveGeoObj( std::vector<std::vector<IGeoObj*>> vvpGObj, std::vector<Color> vCol,
-            const std::string& sFile, int nFlag = GDB_SV_BIN)
-{
-  // verifico validità oggetti
-   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++ i) {
-      for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j) {
-         if ( vvpGObj[i][j] == nullptr  ||  ! vvpGObj[i][j]->IsValid())
-            return false ;
-      }
-   }
-   if ( int( vCol.size()) <= int( vvpGObj.size())) {
-      for ( int i = int( vCol.size()) ; i < int( vvpGObj.size()) ; ++ i)
-         vCol.push_back( BLACK) ;
-   }
-   else
-      return false ;
-
-  // creo GeomDB temporaneo
-   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
-   if ( IsNull( pGeomDB))
-      return false ;
-   INTVECTOR vIds ;
-   int nLayId = 0 ;
-
-  // creo il part
-   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-
-  // per ogni elemento i-esimo, creo un layer
-   for ( int i = 0 ; i < int( vvpGObj.size()) ; ++i) {
-     // creo il layer
-      nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-      pGeomDB->SetMaterial( nLayId, vCol[i]) ;
-
-      for ( int j = 0 ; j < int( vvpGObj.size()) ; ++ j) {
-        // inserisco gli oggetti corrispondenti
-         int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vvpGObj[i][j]) ;
-         vIds.push_back( nId) ;
-         if ( nId == GDB_ID_NULL)
-            return false ;
-      }
-   }
-
-  // eseguo il salvataggio
-   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
-  // rimuovo l'oggetto dal GeomDB
-   for ( int i = 0 ; i < int( vIds.size()) ; ++i)
-      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr) && bOk ;
-
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SaveCurveCompo( ICRVCOMPOPOVECTOR& vCompo, bool bUniform, const std::string& sFile, int nFlag = GDB_SV_BIN)
-{
-  // controllo validità delle curve
-   std::vector<IGeoObj*> vpGObj ;
-   for ( int i = 0 ; i < int( vCompo.size()) ; ++ i) {
-      if ( vCompo[i] == nullptr  ||  ! vCompo[i]->IsValid())
-         return false ;
-      vpGObj.emplace_back( static_cast<IGeoObj*>( vCompo[i]->Clone())) ;
-   }
-  // creo GeomDB temporaneo
-   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
-   if ( IsNull( pGeomDB))
-      return false ;
-   INTVECTOR vIds ;
-
-  // se curve con colore uniforme
-   if ( bUniform)
-      return SaveGeoObj( vpGObj, sFile, nFlag) ;
-
-  // altrimenti scorro le sottocurve e le coloro in base alle temp prop
-   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-   int nLayId = 0 ;
-   for ( int i = 0 ; i < int( vCompo.size()) ; ++i) {
-     // inserisco l'oggetto nel GeomDB (sotto pezzo/layer)
-      nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-      for ( int u = 0 ; u < vCompo[i]->GetCurveCount() ; ++ u) {
-         const ICurve* pCrv = vCompo[i]->GetCurve( u) ;
-         if ( pCrv == nullptr)
-            return false ;
-         int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, pCrv->Clone()) ;
-         pGeomDB->SetMaterial( nId, ( pCrv->GetTempProp( 0) == 1 ? RED :
-                                    ( pCrv->GetTempProp( 0)) == 0 ? BLUE : WHITE)) ;
-         vIds.push_back( nId) ;
-         if ( nId == GDB_ID_NULL)
-            return false ;
-      }
-   }
-  // eseguo il salvataggio
-   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
-  // rimuovo l'oggetto dal GeomDB
-   for ( int i = 0 ; i < int( vIds.size()); ++i)
-      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr) && bOk ;
-
-   return bOk ;
-
-}
-
-bool SaveVoronoi( const ICRVCOMPOPOVECTOR& vCrvsCompo, const ICURVEPOVECTOR& vBisectors, 
-                  bool bUniform, const std::string& sFile, int nFlag = GDB_SV_BIN)
-{
-  // controllo validità delle curve
-   std::vector<IGeoObj*> vpGObj_crv ;
-   for ( int i = 0 ; i < int( vCrvsCompo.size()) ; ++ i) {
-      if ( vCrvsCompo[i] == nullptr  ||  ! vCrvsCompo[i]->IsValid())
-         return false ;
-      vpGObj_crv.emplace_back( static_cast<IGeoObj*>( vCrvsCompo[i]->Clone())) ;
-   }
-   std::vector<IGeoObj*> vpGObj_bisect ;
-   for ( int i = 0 ; i < int( vBisectors.size()) ; ++ i) {
-      if ( vBisectors[i] == nullptr  ||  ! vBisectors[i]->IsValid())
-         return false ;
-      vpGObj_bisect.emplace_back( static_cast<IGeoObj*>( vBisectors[i]->Clone())) ;
-   }
-
-  // creo GeomDB temporaneo
-   PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
-   if ( IsNull( pGeomDB))
-      return false ;
-   INTVECTOR vIds ;
-
-  // salvo le curve
-   int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-   int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-   pGeomDB->SetName( nLayId, "Curves") ;
-   for ( int i = 0 ; i < int( vpGObj_crv.size()) ; ++i) {
-     // inserisco l'oggetto nel GeomDB
-      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vpGObj_crv[i]->Clone()) ;
-      if ( nId == GDB_ID_NULL)
-         return false ;
-      vIds.push_back( nId) ;
-      pGeomDB->SetMaterial( nId, LIME) ;
-   }
-
-  // salvo i bisettori
-   nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-   pGeomDB->SetName( nLayId, "Bisectors") ;
-   for ( int i = 0 ; i < int( vpGObj_bisect.size()) ; ++i) {
-     // inserisco l'oggetto nel GeomDB
-      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vpGObj_bisect[i]->Clone()) ;
-      if ( nId == GDB_ID_NULL)
-         return false ;
-      vIds.push_back( nId) ;
-      if ( bUniform)
-         pGeomDB->SetMaterial( nId, RED) ;
-      else {
-         if ( vBisectors[i]->GetTempParam( 0) < EPS_SMALL  ||
-              vBisectors[i]->GetTempParam( 1) < EPS_SMALL)
-            pGeomDB->SetMaterial( nId, ORANGE) ;
-         else
-            pGeomDB->SetMaterial( nId, RED) ;
-      }
-      pGeomDB->SetInfo( nId, "START_PARAM", vBisectors[i]->GetTempParam( 0)) ;
-      pGeomDB->SetInfo( nId, "END_PARAM", vBisectors[i]->GetTempParam( 1)) ;
-   }
-
-  // eseguo il salvataggio
-   bool bOk = pGeomDB->Save( vIds, sFile, nFlag) ;
-  // rimuovo l'oggetto dal GeomDB
-   for ( int i = 0 ; i < int( vIds.size()); ++i)
-      bOk = ( pGeomDB->RemoveGeoObjAndErase( vIds[i]) != nullptr) && bOk ;
-
   return bOk ;
 }
@@ -134,7 +134,7 @@ class __declspec( novtable) IGeomDB
      virtual bool RevertStatus( int nId) = 0 ;
      virtual bool GetStatus( int nId, int& nStat) const = 0 ;
      virtual bool GetCalcStatus( int nId, int& nStat) const = 0 ;
-      virtual bool SetMark( int nId, int nMark = GDB_MK_ON) = 0 ;
+      virtual bool SetMark( int nId) = 0 ;
      virtual bool ResetMark( int nId) = 0 ;
      virtual bool GetMark( int nId, int& nMark) const = 0 ;
      virtual bool GetCalcMark( int nId, int& nMark) const = 0 ;
@@ -56,11 +56,11 @@ private :
   typedef std::list<ObjData> ObjList ; 
   typedef std::vector<ObjData*> PtrObjVector ;
   typedef std::unordered_map<int,ObjData*> IntPObjUmap ;
-   typedef std::list<HashGrid1d*> GridList ;

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

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

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

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

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

@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkLuaAux.h       Data : 08.05.24        Versione : 2.6e2
+// File : EGkLuaAux.h       Data : 14.04.24        Versione : 2.6d4
 // Contenuto : Funzioni per gestione parametri geometrici con LUA.
 //
 //
 //
 // Modifiche : 21.03.15 DS Creazione modulo.
 //             14.04.24 DS Aggiunta gestione Quaternion.
-//             08.05.24 DS Aggiunta LuaSetParam per VCT3DVECTOR.
 //
 //----------------------------------------------------------------------------

@@ -277,33 +276,6 @@ LuaSetParam( lua_State* L, const Vector3d& vtPar)
   return true ;
 }

-//-------------------------------------------------------------------------------
-inline bool
-LuaSetParam( lua_State* L, const VCT3DVECTOR& vPar)
-{
-   try {
-     // recupero dimensione vettore
-      int nDim = int( vPar.size()) ;
-     // creo tavola principale
-      lua_createtable( L, nDim, 0) ;
-     // creo e inserisco tavola per ogni componente
-      for ( int i = 1 ; i <= nDim ; ++ i) {
-        // creo tavola componente
-         lua_createtable( L, 3, 0) ;
-         for ( int j = 1 ; j <= 3 ; ++ j) {
-            lua_pushnumber( L, vPar[i-1].v[j-1]) ;
-            lua_rawseti( L, -2, j) ;
-         }
-         // la metto nel vettore
-         lua_rawseti( L, -2, i) ;
-      }
-   }
-   catch( ...) {
-      return false ;
-   }
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 inline bool
 LuaSetParam( lua_State* L, const Point3d& ptPar)
@@ -323,16 +323,7 @@ DirDist( const Point3d& ptP1, const Point3d& ptP2, Vector3d& vtDir, double& dDis
 inline bool
 AreSamePointEpsilon( const Point3d& ptP1, const Point3d& ptP2, double dToler)
 {
-   double dX = ptP1.x - ptP2.x ;
-   if ( abs( dX) > dToler)
-      return false ;
-   double dY = ptP1.y - ptP2.y ;
-   if ( abs( dY) > dToler)
-      return false ;
-   double dZ = ptP1.z - ptP2.z ;
-   if ( abs( dZ) > dToler)
-      return false ;
-   return ( ( dX * dX + dY * dY + dZ * dZ) < ( dToler * dToler)) ;
+   return ( SqDist( ptP1, ptP2) < ( dToler * dToler)) ;
 }

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

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

 //----------------------------------------------------------------------------
@@ -1,37 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EGkProjectCurveSurfTm.h     Data : 07.05.24      Versione : 2.6e3
-// Contenuto : Dichiarazione funzioni proiezione curve su superficie Bezier.
-//
-//
-//
-// Modifiche : 07.05.24 DB Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkGeoPoint3d.h"
-#include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkSurfBezier.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-#define EGK_EXPORT __declspec( dllexport)
-#else
-#define EGK_EXPORT __declspec( dllimport)
-#endif
-
-//----------------------------------------------------------------------------
-// Proiezione di una curva su una superficie TriMesh lungo la direzione data.
-EGK_EXPORT bool ProjectCurveOnSurfBez( const ICurve& crCrv, const ISurfBezier& surfBez, const Vector3d& vtDir,
-   double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
-EGK_EXPORT bool ProjectCurveOnSurfBez( const ICurve& crCrv, const ISurfBezier& surfBez, const IGeoPoint3d& gpRef,
-   double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
-EGK_EXPORT bool ProjectCurveOnSurfBez( const ICurve& crCrv, const ISurfBezier& surfBez, const ICurve& crRef,
-   double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
-EGK_EXPORT bool ProjectCurveOnSurfBez( const ICurve& crCrv, const ISurfBezier& surfBez, const ISurfTriMesh& tmRef,
-   double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
@@ -1,49 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EGkSbzFromCurves.h   Data : 07.05.24       Versione : 2.6d2
-// Contenuto : Prototipi funzioni di creazione TriMesh a partire da curve.
-//
-//
-//
-// Modifiche : 07.05.24 DB Creazione modulo.
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkSurfFlatRegion.h"
-#include "/EgtDev/Include/EGkSurfTriMesh.h"
-#include "/EgtDev/Include/EGkSurfBezier.h"
-
-//----------------------- Macro per import/export ----------------------------
-#undef EGK_EXPORT
-#if defined( I_AM_EGK)            // da definirsi solo nella DLL
-#define EGK_EXPORT __declspec( dllexport)
-#else
-#define EGK_EXPORT __declspec( dllimport)
-#endif
-
-////----------------------------------------------------------------------------
-//enum RS_CAP { RSCAP_NONE = 0, RSCAP_FLAT = 1, RSCAP_ROUND = 2, RSCAP_BEVEL = 3} ;
-
-//----------------------------------------------------------------------------
-EGK_EXPORT ISurfBezier* GetSurfBezierByFlatContour( const ICurve* pCurve, double dLinTol = 10 * EPS_SMALL) ;
-EGK_EXPORT ISurfBezier* GetSurfBezierByRegion( const CICURVEPVECTOR& vpCurve, double dLinTol = 10 * EPS_SMALL) ;
-EGK_EXPORT ISurfBezier* GetSurfBezierByExtrusion( const ICurve* pCurve, const Vector3d& vtExtr,
-                                                   bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
-//EGK_EXPORT ISurfBezier* GetSurfBezierByRegionExtrusion( const CICURVEPVECTOR& vpCurve, const Vector3d& vtExtr,
-//                                                   double dLinTol = 10 * EPS_SMALL) ;
-EGK_EXPORT ISurfBezier* GetSurfBezierByRevolve( const ICurve* pCurve, const Point3d& ptAx,
-                                                   const Vector3d& vtAx, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
-EGK_EXPORT ISurfBezier* GetSurfBezierByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vector3d& vtAx,
-                                                   double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
-//EGK_EXPORT ISurfBezier* GetSurfBezierRectSwept( double dDimH, double dDimV, double dBevelH, double dBevelV,
-//                                                   const ICurve* pGuide, int nCapType, double dLinTol = 10 * EPS_SMALL) ;
-//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* 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) ;
@@ -24,4 +24,4 @@
 #endif

 //----------------------------------------------------------------------------
-EGK_EXPORT ISurfBezier* GetSurfBezierSphere( const Point3d& ptCenter, double dR) ;
+EGK_EXPORT ISurfBezier* CreateBezierSphere( const Point3d& ptCenter, double dR) ;
@@ -35,8 +35,6 @@ EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromFatCurve( ICurve* pCrv, double
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromTriangle( const Triangle3d& Tria) ;
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromPolyLine( const PolyLine& ContourPolyLine) ;
 EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromPolyLineVector( const POLYLINEVECTOR& vContoursPolyLineVec) ;
-EGK_EXPORT bool CalcRegionPolyLines( const POLYLINEVECTOR& vPL, Vector3d& vtN, INTMATRIX& vnPLIndMat, BOOLVECTOR& vbInvert) ;  // la funzione restituisce una matrice con la struttura dei chunk e un vettore che indica se invertire le polyline
-

 //----------------------------------------------------------------------------
 class SurfFlatRegionByContours
@@ -28,16 +28,7 @@ class __declspec( novtable) ISurfBezier : public ISurf
   public :
      enum Side { FROM_MINUS = -1,     // da valori inferiori del parametro
                  FROM_PLUS  = 1} ;    // da valori superiori del parametro
-public :
-   enum RuledType { RLT_B_ISOPAR = 0,            // con parametrizzazione simile tra le due curve
-                    RLT_B_MINDIST = 1,           // con distanza minima tra le due curve, usando start e end delle curve presenti
-                    RLT_B_MINDIST_PLUS = 2,      // con distanza minima tra le due curve, aggiungendo punti lungo le curve dove necessario
-                    RLT_B_LENPAR = 3} ;          // aggiungo punti alla curve in modo da matchare meglio le sottocurve, inoltre parametrizzo le curve in base alla lunghezza e non al numero di curve
-   enum Is_Planar { NOT_CALCULATED = -1,
-                   NOT_PLANAR_SURF = 0 ,
-                   PLANAR_SURF = 1};
-
-public :                      // IGeoObj
+   public :                      // IGeoObj
      ISurfBezier* Clone( void) const override = 0 ;
   public :
      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
@@ -78,17 +69,11 @@ public :                      // IGeoObj
      // taglio la parte della superficie dalla parte positiva del versore del piano.
      // Il booleano indica se tenere eventuali triangoli della trimesh ausiliaria che sono coplanari ed equiversi al piano di taglio
      virtual bool Cut( const Plane3d& plPlane, bool bSaveOnEq) = 0 ;
+      // funzione da chiamare per calcolare i poli della superficie. NECESSARIO se si vuole tagliare la superficie con un piano
+      virtual bool CalcPoles( void) ;
      virtual bool IncreaseUV( double& dU, double dx, bool bUOrV, double* dUVCopy = nullptr, bool bModifyOrig = true) const = 0 ;
      virtual bool IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bModifyOrig) const = 0 ;
      virtual bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const = 0 ;
-      virtual bool IsPlanar( void) const = 0 ;
-      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 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 ;
 } ;

 //-----------------------------------------------------------------------------
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : EGkSurfFlatRegion.h      Data : 18.07.24          Versione : 2.6g5
+// File : EGkSurfFlatRegion.h      Data : 05.08.15          Versione : 1.6h2
 // Contenuto : Dichiarazione della interfaccia ISurfFlatRegion.
 //
 //
@@ -27,7 +27,7 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
      ISurfFlatRegion* Clone( void) const override = 0 ;
   public :
      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
-      virtual bool Clear( void) = 0 ;
+      virtual bool Clear( void) ;
      virtual bool AddExtLoop( const ICurve& cCrv) = 0 ;
      virtual bool AddExtLoop( ICurve* pCrv) = 0 ;
      virtual bool AddIntLoop( const ICurve& cCrv) = 0 ;
@@ -40,30 +40,18 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
      virtual bool GetGrossArea( double& dArea) const = 0 ;
      virtual const Point3d& GetPlanePoint( void) const = 0 ;
      virtual const Vector3d& GetNormVersor( void) const = 0 ;
-      virtual bool CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound = 3) const = 0 ;
-      virtual void ResetVoronoiObject( void) const = 0 ;
-      virtual bool GetMaxOffset( double& dOffs) const = 0 ;
-      virtual bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide = 1) const = 0 ;
-      virtual const ISurfTriMesh* GetAuxSurf( void) const = 0 ;
-      virtual bool GetCurveClassification( const ICurve& Crv, double dLenMin, CRVCVECTOR& ccClass) const = 0 ;
      virtual int  GetChunkCount( void) const = 0 ;
-      virtual ISurfFlatRegion* CloneChunk( int nChunk) const = 0 ;
-      virtual bool EraseChunk(int nChunk) = 0 ;
-      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 bool GetChunkMaxOffset( int nChunk, double& dOffs) const = 0 ;
      virtual int  GetLoopCount( int nChunk) const = 0 ;
-      virtual int  GetLoopCurveCount( int nChunk, int nLoop) const = 0 ;
      virtual ICurve* GetLoop( int nChunk, int nLoop) const = 0 ;   // nChunk 0-based, nLoop 0-based (1°esterno, successivi interni) 
      virtual bool ApproxLoopWithLines( int nChunk, int nLoop, double dLinTol, double dAngTolDeg, int nType, PolyLine& PL) const = 0 ;
-      virtual bool SetCurveTempProp( int nChunk, int nLoop, int nCrv, int nProp, int nPropInd = 0) = 0 ;
-      virtual bool GetCurveTempProp( int nChunk, int nLoop, int nCrv, int& nProp, int nPropInd = 0) const = 0 ;
-      virtual bool ResetAllCurveTempProps( void) = 0 ;
-      virtual bool SetCurveTempParam( int nChunk, int nLoop, int nCrv, double dParam, int nParamInd = 0) = 0 ;
-      virtual bool GetCurveTempParam( int nChunk, int nLoop, int nCrv, double& dParam, int nParamInd = 0) const = 0 ;
-      virtual bool ResetAllCurveTempParams( void) = 0 ;
+      virtual const ISurfTriMesh* GetAuxSurf( void) const = 0 ;
+      virtual ISurfFlatRegion* CloneChunk( int nChunk) const = 0 ;
+      virtual bool GetChunkCentroid( int nChunk, Point3d& ptCen) const ;
+      virtual bool GetCurveClassification( const ICurve& Crv, double dLenMin, CRVCVECTOR& ccClass) const = 0 ;
+      virtual int  GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion& Other, int nOthChunk) const ;   // compare only outsides
+      virtual bool CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound = 3) const = 0 ;
+      virtual bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide = 1) const = 0 ;
+      virtual void ResetVoronoiObject( void) const = 0 ;
 } ;

 //-----------------------------------------------------------------------------
@@ -50,7 +50,7 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
      virtual bool RemoveTriangle( int nId) = 0 ;
      virtual bool AdjustTopology( void) = 0 ;
      virtual bool CreateByFlatContour( const PolyLine& PL) = 0 ;
-      virtual bool CreateByRegion( const POLYLINEVECTOR& vPL, const INTMATRIX& vnPLIndMat) = 0 ;
+      virtual bool CreateByRegion( const POLYLINEVECTOR& vPL) = 0 ;
      virtual bool CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr) = 0 ;
      virtual bool CreateByPointCurve( const Point3d& ptP, const PolyLine& PL) = 0 ;
      virtual bool CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nRuledType) = 0 ;
@@ -89,7 +89,6 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
      virtual ISurfTriMesh* CloneTriangle( int nTria) const = 0 ;
      virtual bool GetLoops( POLYLINEVECTOR& vPL) const = 0 ;
      virtual bool GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const = 0 ;
-      virtual bool GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const = 0 ;
      virtual int  GetFacetCount( void) const = 0 ;
      virtual int  GetFacetSize( void) const = 0 ;
      virtual int  GetFacetFromTria( int nT) const = 0 ;
@@ -124,17 +123,9 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
      virtual bool Repair( double dMaxEdgeLen = MAX_EDGE_LEN_STD) = 0 ;
      virtual bool GetAllTriaOverlapBox( const BBox3d& b3Box, INTVECTOR& vT) const = 0 ;
      virtual const BBox3d& GetAllTriaBox( void) const = 0 ;
-      virtual int  GetShellCount( void) const = 0 ;
-      virtual bool GetShellArea( int nShell, double& dArea) const = 0 ;
-      virtual bool RemoveShell( int nShell) = 0 ;
-      virtual ISurfTriMesh* CloneShell( int nShell) const = 0 ;
      virtual int  GetPartCount( void) const = 0 ;
-      virtual bool GetPartArea( int nPart, double& dArea) const = 0 ;
-      virtual bool GetPartVolume( int nPart, double& dVolume) const = 0 ;
      virtual bool RemovePart( int nPart) = 0 ;
      virtual ISurfTriMesh* ClonePart( int nPart) const = 0 ;
-      virtual bool SetTFlag( int nId, int nTFlag) = 0 ;
-      virtual bool GetTFlag( int nId, int& nFlag) const = 0 ;
      virtual int  GetMaxTFlag( void) const = 0 ;
      virtual bool ResetTFlags( void) = 0 ;
 } ;
@@ -45,7 +45,7 @@ class EGK_EXPORT Vector3d
      void Set( double dX, double dY, double dZ) { x = dX ; y = dY ; z = dZ ; }

   public :
-      //! Verifica la validità delle coordinate del vettore
+      //! Verifica la validità delle coordinate del vettore
      bool IsValid( void) const
             { return ( std::isfinite( x)  &&  std::isfinite( y)  &&  std::isfinite( z)) ; }
      //! Quadrato della lunghezza del vettore
@@ -58,70 +58,70 @@ class EGK_EXPORT Vector3d
             { return ( x * x + y * y ) ; }
      //! Lunghezza del vettore nel piano XY
      double LenXY( void) const ;
-      //! Verifica se il vettore è quasi nullo
+      //! Verifica se il vettore è quasi nullo
      bool IsSmall( void) const
             { return ( ( x * x + y * y + z * z) < SQ_EPS_SMALL) ; }
-      //! Verifica se il vettore è esattamente nullo
+      //! Verifica se il vettore è esattamente nullo
      bool IsZero( void) const
             { return ( ( x * x + y * y + z * z) < SQ_EPS_ZERO) ; }
-      //! Verifica se il vettore è quasi nullo nel piano XY
+      //! Verifica se il vettore è quasi nullo nel piano XY
      bool IsSmallXY( void) const
             { return ( ( x * x + y * y) < SQ_EPS_SMALL) ; }
-      //! Verifica se il vettore è esattamente nullo nel piano XY
+      //! Verifica se il vettore è esattamente nullo nel piano XY
      bool IsZeroXY( void) const
             { return ( ( x * x + y * y) < SQ_EPS_ZERO) ; }
-      //! Verifica se il vettore è normalizzato (è un versore)
+      //! Verifica se il vettore è normalizzato (è un versore)
      bool IsNormalized( void) const
             { return ( abs( 1.0 - (x * x + y * y + z * z)) < ( 2 * EPS_ZERO)) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con X+
+      //! Verifica se il vettore è parallelo ed equiverso con X+
      bool IsXplus( void) const
             { double dMO = std::max( abs( y), abs( z)) ;
               return ( x > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  x > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con X-
+      //! Verifica se il vettore è parallelo ed equiverso con X-
      bool IsXminus( void) const
             { double dMO = std::max( abs( y), abs( z)) ;
               return ( x < -EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  x < -KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo a X
+      //! Verifica se il vettore è parallelo a X
      bool IsX( void) const
             { double dMO = std::max( abs( y), abs( z)) ;
               return ( abs( x) > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  abs( x) > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è circa parallelo a x
-      bool IsXEpsilon( double dToler) const
+      //! Verifica se il vettore è circa parallelo a x
+      bool IsXEpsilon( double dToll) const
             { double dMO = std::max( abs( y), abs( z)) ;
-               return ( abs( x) > dToler  &&  dMO < 10 * dToler  &&  abs( x) > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con Y+
+               return ( abs( x) > dToll  &&  dMO < 10 * dToll  &&  abs( x) > KV_BIG * dMO) ; }
+      //! Verifica se il vettore è parallelo ed equiverso con Y+
      bool IsYplus( void) const
             { double dMO = std::max( abs( z), abs( x)) ;
               return ( y > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  y > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con Y-
+      //! Verifica se il vettore è parallelo ed equiverso con Y-
      bool IsYminus( void) const
             { double dMO = std::max( abs( z), abs( x)) ;
               return ( y < -EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  y < -KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo a Y
+      //! Verifica se il vettore è parallelo a Y
      bool IsY( void) const
             { double dMO = std::max( abs( z), abs( x)) ;
               return ( abs( y) > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  abs( y) > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è circa parallelo a y
-      bool IsYEpsilon( double dToler) const
+      //! Verifica se il vettore è circa parallelo a y
+      bool IsYEpsilon( double dToll) const
             { double dMO = std::max( abs( z), abs( x)) ;
-               return ( abs( y) > dToler  &&  dMO < 10 * dToler  &&  abs( y) > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con Z+
+               return ( abs( y) > dToll  &&  dMO < 10 * dToll  &&  abs( y) > KV_BIG * dMO) ; }
+      //! Verifica se il vettore è parallelo ed equiverso con Z+
      bool IsZplus( void) const
             { double dMO = std::max( abs( x), abs( y)) ;
               return ( z > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  z > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo ed equiverso con Z-
+      //! Verifica se il vettore è parallelo ed equiverso con Z-
      bool IsZminus( void) const
             { double dMO = std::max( abs( x), abs( y)) ;
               return ( z < -EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  z < -KV_BIG * dMO) ; }
-      //! Verifica se il vettore è parallelo a Z
+      //! Verifica se il vettore è parallelo a Z
      bool IsZ( void) const
             { double dMO = std::max( abs( x), abs( y)) ;
               return ( abs( z) > EPS_ZERO  &&  dMO < 10 * EPS_ZERO  &&  abs( z) > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è circa parallelo a Z
-      bool IsZEpsilon( double dToler) const
+      //! Verifica se il vettore è circa parallelo a Z
+      bool IsZEpsilon( double dToll) const
             { double dMO = std::max( abs( x), abs( y)) ;
-               return ( abs( z) > dToler  &&  dMO < 10 * dToler  &&  abs( z) > KV_BIG * dMO) ; }
-      //! Verifica se il vettore è generico
+               return ( abs( z) > dToll  &&  dMO < 10 * dToll  &&  abs( z) > KV_BIG * dMO) ; }
+      //! Verifica se il vettore è generico
      bool IsGeneric( void) const
             { return ( ! IsX()  &&  ! IsY()  &&  ! IsZ()) ; }
      //! Somma sul posto con altro vettore
@@ -205,12 +205,12 @@ EGK_EXPORT Vector3d FromSpherical( double dLen, double dAngVertDeg, double dAngO
 EGK_EXPORT Vector3d FromPolar( double dLen, double dAngDeg) ;

 //----------------------------------------------------------------------------
-//! Definizione come più verticale dei vettori ortogonali a quello ricevuto
+//! Definizione come più verticale dei vettori ortogonali a quello ricevuto
 //----------------------------------------------------------------------------
 EGK_EXPORT Vector3d FromUprightOrtho( const Vector3d& vtV) ;

 //----------------------------------------------------------------------------
-//! Definizione come ortogonale al primo ricevuto, orizzontale e più vicino al secondo
+//! Definizione come ortogonale al primo ricevuto, orizzontale e più vicino al secondo
 //----------------------------------------------------------------------------
 EGK_EXPORT Vector3d FromNearestHorizontalOrtho( const Vector3d& vtV, const Vector3d& vtNear) ;

@@ -441,17 +441,6 @@ AreOrthoExact( const Vector3d& vtV1, const Vector3d& vtV2)
   return ( abs( vtV1 * vtV2) < COS_ORTO_ANG_ZERO) ;
 }

-//----------------------------------------------------------------------------
-//! Restituisce una copia ruotata del vettore passato
-//----------------------------------------------------------------------------
-inline const Vector3d
-GetRotate( const Vector3d& vtV, const Vector3d& vtAx, double dAngDeg)
-{
-   Vector3d vtW = vtV ;
-   vtW.Rotate( vtAx, dAngDeg) ;
-   return vtW ;
-}
-
 //----------------------------------------------------------------------------
 //! Restituisce una copia in locale del vettore passato
 //----------------------------------------------------------------------------
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EGkVolZmap.h      Data : 22.04.24          Versione : 2.6d4
+// File : EGkVolZmap.h      Data : 09.03.24          Versione : 2.6c2
 // Contenuto : Dichiarazione della interfaccia IVolZmap.
 //
 //
@@ -27,10 +27,11 @@ 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) = 0 ;
+      virtual bool IsEmpty( void) = 0 ;
+      virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dPrec, bool bTriDex) = 0 ;
+      virtual bool CreateEmptyMap( const Point3d& ptO, double dLengthX, double dLengthY, double dLengthZ, double dStep, bool bTriDex) = 0 ;
+      virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec, bool bTriDex) = 0 ;
+      virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bTriDex) = 0 ;
      virtual int  GetBlockCount( void) const = 0 ;
      virtual int  GetBlockUpdatingCounter( int nBlock) const = 0 ;
      virtual bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const = 0 ;
@@ -55,8 +56,6 @@ class __declspec( novtable) IVolZmap : public IGeoObj
                                    double dH, double dW, double dTh, double dRc, int nFlag, bool bFirst) = 0 ;
      virtual bool SetChiselTool( const std::string& sToolName,
                                  double dH, double dW, double dTh, int nFlag, bool bFirst) = 0 ;
-      virtual bool SetAdditiveTool( const std::string& sToolName,
-                                    double dH, double dR, double dRc, int nFlag, bool bFirst) = 0 ;
      virtual int  GetToolCount( void) const = 0 ;
      virtual bool SetCurrTool( int nCurrTool) = 0 ;
      virtual bool ResetTools( void) = 0 ;
@@ -87,9 +86,8 @@ class __declspec( novtable) IVolZmap : public IGeoObj
      virtual bool GetPartBBox( int nPart, const Frame3d& frRef, BBox3d& b3Ref, int nFlag = BBF_STANDARD) const = 0 ;
      virtual IVolZmap* ClonePart( int nPart) const = 0 ;
      virtual bool RemovePart( int nPart) = 0 ;
-      virtual int  GetPartMinDistFromPoint( const Point3d& ptP) const = 0 ;
-      virtual bool AddSurfTm( const ISurfTriMesh* pStm) = 0 ;
-      virtual bool MakeUniform( double dToler) = 0 ;
+      virtual int GetPartMinDistFromPoint( const Point3d& ptP) const = 0 ;
+      virtual bool AddSrfTm( const ISurfTriMesh* pStm) = 0 ;
 } ;

 //-----------------------------------------------------------------------------
@@ -229,11 +229,7 @@ LuaGetTabFieldParam( lua_State* L, int nInd, const char* szField, T& Val)
 {
   if ( ! lua_istable( L, nInd))
      return false ;
-   int nField ;
-   if ( FromString( szField, nField))
-      lua_rawgeti( L, nInd, nField) ;
-   else
-      lua_getfield( L, nInd, szField) ;
+   lua_getfield( L, nInd, szField) ;
   bool bOk = LuaGetParam( L, -1, Val) ;
   lua_pop( L, 1) ;
   return bOk ;
@@ -327,24 +323,6 @@ LuaSetParam( lua_State* L, const std::string& sPar)
   return true ;
 }

-//----------------------------------------------------------------------------
-inline bool
-LuaSetParam( lua_State* L, const BOOLVECTOR& vPar)
-{
-   try {
-      int nSize = int( vPar.size()) ;
-      lua_createtable( L, nSize, 0) ;
-      for ( int i = 1 ; i <= nSize ; ++ i) {
-         lua_pushboolean( L, ( vPar[i-1] ? 1 : 0)) ;
-         lua_rawseti( L, -2, i) ;
-      }
-   }
-   catch( ...) {
-      return false ;
-   }
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 inline bool
 LuaSetParam( lua_State* L, const INTVECTOR& vPar)
@@ -466,11 +444,7 @@ LuaSetTabFieldParam( lua_State* L, int nInd, const char* szField)
   if ( ! LuaSetParam( L))
      return false ;
   int nPos = ( nInd > 0 ? nInd : nInd - 1) ;
-   int nField ;
-   if ( FromString( szField, nField))
-      lua_rawseti( L, nPos, nField) ;
-   else
-      lua_setfield( L, nPos, szField) ;
+   lua_setfield( L, nPos, szField) ;
   return true ;
 }

@@ -491,11 +465,7 @@ LuaSetTabFieldParam( lua_State* L, int nInd, const char* szField, const T& Val)
   if ( ! LuaSetParam( L, Val))
      return false ;
   int nPos = ( nInd > 0 ? nInd : nInd - 1) ;
-   int nField ;
-   if ( FromString( szField, nField))
-      lua_rawseti( L, nPos, nField) ;
-   else
-      lua_setfield( L, nPos, szField) ;
+   lua_setfield( L, nPos, szField) ;
   return true ;
 }

@@ -523,21 +493,11 @@ LuaGetGlobVar( lua_State* L, const std::string& sVar, T& Val)
   }
  // altrimenti campo di tabella
   else {
-      STRVECTOR vsTokens ;
-      Tokenize( sVar, ".", vsTokens) ;
-      int nTokenCnt = int( vsTokens.size()) ;
-      if ( nTokenCnt < 2)
-         return false ;
-      lua_getglobal( L, vsTokens[0].c_str()) ;
-      for ( int nInd = 1 ; nInd <= nTokenCnt - 2 ; ++ nInd) {
-         int nField ;
-         if ( FromString( vsTokens[nInd], nField))
-            lua_rawgeti( L, -1, nField) ;
-         else
-            lua_getfield( L, -1, vsTokens[nInd].c_str()) ;
-      }
-      bool bOk = LuaGetTabFieldParam( L, -1, vsTokens[nTokenCnt-1].c_str(), Val) ;
-      lua_pop( L, nTokenCnt - 1) ;
+      std::string sTab, sField ;
+      SplitFirst( sVar, ".", sTab, sField) ;
+      lua_getglobal( L, sTab.c_str()) ;
+      bool bOk = LuaGetTabFieldParam( L, -1, sField.c_str(), Val) ;
+      lua_pop( L, 1) ;
      return bOk ;
   }
 }
@@ -558,27 +518,11 @@ LuaSetGlobVar( lua_State* L, const std::string& sVar, const T& Val)
   }
  // altrimenti campo di tabella
   else {
-      STRVECTOR vsTokens ;
-      Tokenize( sVar, ".", vsTokens) ;
-      int nTokenCnt = int( vsTokens.size()) ;
-      if ( nTokenCnt < 2)
-         return false ;
-      lua_getglobal( L, vsTokens[0].c_str()) ;
-      for ( int nInd = 1 ; nInd <= nTokenCnt - 2 ; ++ nInd) {
-         int nField ;
-         bool bNumber = FromString( vsTokens[nInd], nField) ;
-         if ( ( bNumber ? lua_rawgeti( L, -1, nField) : lua_getfield( L, -1, vsTokens[nInd].c_str())) != LUA_TTABLE) {
-            lua_pop( L, 1) ;
-            lua_newtable( L) ;
-            lua_pushvalue( L, -1) ;
-            if ( bNumber)
-               lua_rawseti( L, -3, nField) ;
-            else
-               lua_setfield( L, -3, vsTokens[nInd].c_str()) ;
-         }
-      }
-      bool bOk = LuaSetTabFieldParam( L, -1, vsTokens[nTokenCnt-1].c_str(), Val) ;
-      lua_pop( L, nTokenCnt - 1) ;
+      std::string sTab, sField ;
+      SplitFirst( sVar, ".", sTab, sField) ;
+      lua_getglobal( L, sTab.c_str()) ;
+      bool bOk = LuaSetTabFieldParam( L, -1, sField.c_str(), Val) ;
+      lua_pop( L, 1) ;
      return bOk ;
   }
 }
@@ -598,26 +542,10 @@ LuaResetGlobVar( lua_State* L, const std::string& sVar)
   }
  // altrimenti campo di tabella
   else {
-      STRVECTOR vsTokens ;
-      Tokenize( sVar, ".", vsTokens) ;
-      int nTokenCnt = int( vsTokens.size()) ;
-      if ( nTokenCnt < 2)
-         return false ;
-      lua_getglobal( L, vsTokens[0].c_str()) ;
-      for ( int nInd = 1 ; nInd <= nTokenCnt - 2 ; ++ nInd) {
-         int nField ;
-         bool bNumber = FromString( vsTokens[nInd], nField) ;
-         if ( ( bNumber ? lua_rawgeti( L, -1, nField) : lua_getfield( L, -1, vsTokens[nInd].c_str())) != LUA_TTABLE) {
-            lua_pop( L, 1) ;
-            lua_newtable( L) ;
-            lua_pushvalue( L, -1) ;
-            if ( bNumber)
-               lua_rawseti( L, -3, nField) ;
-            else
-               lua_setfield( L, -3, vsTokens[nInd].c_str()) ;
-         }
-      }
-      bool bOk = LuaSetTabFieldParam( L, -1, vsTokens[nTokenCnt-1].c_str()) ;
+      std::string sTab, sField ;
+      SplitFirst( sVar, ".", sTab, sField) ;
+      lua_getglobal( L, sTab.c_str()) ;
+      bool bOk = LuaSetTabFieldParam( L, -1, sField.c_str()) ;
      lua_pop( L, 1) ;
      return bOk ;
   }
@@ -90,7 +90,6 @@ class IEGrScene
      virtual bool SetExtension( const BBox3d& b3Ext) = 0 ;
      virtual bool UpdateExtension( void) = 0 ;
      virtual bool SetMark( Color colMark) = 0 ;
-      virtual bool SetMark2( Color colMark) = 0 ;
      virtual bool SetSelSurf( Color colSelSurf) = 0 ;
      virtual bool SetLineWidth( int nW) = 0 ;
     // Grid
@@ -252,8 +252,6 @@ EIN_EXPORT int  __stdcall EgtCreateArcC2PEx( int nParentId, const double ptCen[3
                                             const double ptNearEnd[3], int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateArc3P( int nParentId, const double ptP1[3],
                                          const double ptP2[3], const double ptP3[3], int nRefType) ;
-EIN_EXPORT int  __stdcall EgtCreateArc2PR( int nParentId, const double ptStart[3], const double ptEnd[3],
-                                           double dRad, BOOL bCCW, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateArc2PD( int nParentId, const double ptStart[3], const double ptEnd[3],
                                           double dDirSDeg, int nRefType) ;
 EIN_EXPORT int  __stdcall EgtCreateArc2PDEx( int nParentId, const double ptStart[3],
@@ -413,7 +411,7 @@ EIN_EXPORT BOOL __stdcall EgtSetStatus( int nId, int nStat) ;
 EIN_EXPORT BOOL __stdcall EgtRevertStatus( int nId) ;
 EIN_EXPORT BOOL __stdcall EgtGetStatus( int nId, int* pnStat) ;
 EIN_EXPORT BOOL __stdcall EgtGetCalcStatus( int nId, int* pnStat) ;
-EIN_EXPORT BOOL __stdcall EgtSetMark( int nId, int nMark) ;
+EIN_EXPORT BOOL __stdcall EgtSetMark( int nId) ;
 EIN_EXPORT BOOL __stdcall EgtResetMark( int nId) ;
 EIN_EXPORT BOOL __stdcall EgtGetMark( int nId, BOOL* pnMark) ;
 EIN_EXPORT BOOL __stdcall EgtGetCalcMark( int nId, BOOL* pnMark) ;
@@ -551,7 +549,6 @@ EIN_EXPORT BOOL __stdcall EgtCutSurfTmClosedCurve( int nSurfId, int nCurveId, BO
 EIN_EXPORT BOOL __stdcall EgtSurfTmAdd( int nId1, int nId2, BOOL bTwoColors) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmSubtract( int nId1, int nId2, BOOL bTwoColors) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmIntersect( int nId1, int nId2, BOOL bTwoColors) ;
-EIN_EXPORT BOOL __stdcall EgtSurfTmSetFaceColor( int nId, int nFacet, int nColor) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmResetTwoColors( int nId) ;
 EIN_EXPORT int  __stdcall EgtSurfTmSplit( int nId, int nSplitterId, int* pnCount) ;
 EIN_EXPORT BOOL __stdcall EgtSurfTmCut( int nId, int nCutterId, BOOL bInVsOut, BOOL bSaveOnEq) ;
@@ -575,9 +572,6 @@ EIN_EXPORT BOOL __stdcall EgtCurveParamAtLength( int nId, double dLen, double* p
 EIN_EXPORT BOOL __stdcall EgtCurveLengthAtPoint( int nId, const double ptOn[3], double dExtend, double* pdLen) ;
 EIN_EXPORT BOOL __stdcall EgtCurveIsClosed( int nId) ;
 EIN_EXPORT BOOL __stdcall EgtCurveIsFlat( int nId, BOOL bUseExtrusion, double dToler, double vtN[3], double* pdDist) ;
-EIN_EXPORT BOOL __stdcall EgtCurveIsACircle( int nId, double dToler, double ptC[3], double vtN[3], double* pdRad, BOOL* pbCCW) ;
-EIN_EXPORT BOOL __stdcall EgtCurveIsARectangle( int nId, double dToler, double ptP[3], double vtL1[3], double vtL2[3]) ;
-EIN_EXPORT BOOL __stdcall EgtCurveIsATrapezoid( int nId, double dToler, double ptP[3], double vtB1[3], double vtL1[3], double vtB2[3]) ;
 EIN_EXPORT BOOL __stdcall EgtCurveAreaXY( int nId, double* pdArea) ;
 EIN_EXPORT BOOL __stdcall EgtCurveArea( int nId, double vtN[3], double* pdDist, double* pdArea) ;
 EIN_EXPORT BOOL __stdcall EgtCurveNearestExtremityToPoint( int nId, const double ptP[3], BOOL* pbStart) ;
@@ -602,7 +596,6 @@ EIN_EXPORT BOOL __stdcall EgtSurfFrNormVersor( int nId, int nRefId, double vtNor
 EIN_EXPORT BOOL __stdcall EgtSurfFrGrossArea( int nId, double* pdArea) ;
 EIN_EXPORT int  __stdcall EgtSurfFrChunkCount( int nId) ;
 EIN_EXPORT int  __stdcall EgtSurfFrChunkSimpleClassify( int nId1, int nChunk1, int nId2, int nChunk2, double dToler) ;
-EIN_EXPORT BOOL __stdcall EgtSurfFrChunkCenter( int nId, int nChunk, int nRefId, double ptCen[3], double vtNorm[3]) ;
 EIN_EXPORT int  __stdcall EgtExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount) ;
 EIN_EXPORT int  __stdcall EgtSurfTmPartCount( int nId) ;
 EIN_EXPORT int  __stdcall EgtSurfTmFacetCount( int nId) ;
@@ -932,8 +925,7 @@ EIN_EXPORT BOOL __stdcall EgtApplyMachining( BOOL bRecalc) ;
 EIN_EXPORT BOOL __stdcall EgtUpdateMachining( void) ;
 EIN_EXPORT BOOL __stdcall EgtPreparePreviewMachiningTool( void) ;
 EIN_EXPORT BOOL __stdcall EgtRemovePreviewMachiningTool( void) ;
-EIN_EXPORT int  __stdcall EgtGetPreviewMachiningToolStepCount( void) ;
-EIN_EXPORT int  __stdcall EgtPreviewMachiningTool( int nEntId, int nStep) ;
+EIN_EXPORT int  __stdcall EgtPreviewMachiningTool( int nEntId, int nFlag) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachiningParamBool( int nType, BOOL* pbVal) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachiningParamInt( int nType, int* pnVal) ;
 EIN_EXPORT BOOL __stdcall EgtGetMachiningParamDouble( int nType, double* pdVal) ;
@@ -998,7 +990,7 @@ EIN_EXPORT BOOL __stdcall EgtInitScene( HWND hWnd, int nDriver, BOOL b2Buff, int
 EIN_EXPORT BOOL __stdcall EgtGetSceneInfo( wchar_t*& wsInfo) ;
 EIN_EXPORT BOOL __stdcall EgtSetBackground( const int nTopCol[4], const int nBottomCol[4], BOOL bRedraw) ;
 EIN_EXPORT BOOL __stdcall EgtSetLineAttribs( int nWidth) ;
-EIN_EXPORT BOOL __stdcall EgtSetMarkAttribs( const int MarkCol[4], const int Mark2Col[4]) ;
+EIN_EXPORT BOOL __stdcall EgtSetMarkAttribs( const int MarkCol[4]) ;
 EIN_EXPORT BOOL __stdcall EgtSetSelSurfAttribs( const int SelSurfCol[4]) ;
 EIN_EXPORT BOOL __stdcall EgtSetGeoLineAttribs( const int GlCol[4]) ;
 EIN_EXPORT BOOL __stdcall EgtSetGeoTriaAttribs( const int GtCol[4]) ;
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2024
 //----------------------------------------------------------------------------
-// File : EMkMachMgr.h           Data : 22.04.24          Versione : 2.6d4
+// File : EMkMachMgr.h           Data : 02.04.24          Versione : 2.6d1
 // Contenuto : Dichiarazione della interfaccia IMachMgr.
 //
 //
@@ -17,7 +17,6 @@
 //             28.10.23 DS Aggiunte in interfaccia GetClEntAxesVal, GetToolSetupPosInCurrSetup e GetAllCurrAxesName.
 //             30.03.24 DS Aggiunte in interfaccia GetAllAxesNames e GetCalcTable.
 //             02.04.24 DS Aggiunta in interfaccia GetClEntAxesMask.
-//             22.04.24 DS Aggiunta in interfaccia GetExitId.
 //
 //----------------------------------------------------------------------------

@@ -259,8 +258,7 @@ class __declspec( novtable) IMachMgr
      virtual bool MachiningUpdate( bool bPostApply = true) = 0 ;
      virtual bool PreparePreviewMachiningTool( void) const = 0 ;
      virtual bool RemovePreviewMachiningTool( void) const = 0 ;
-      virtual int  GetPreviewMachiningToolStepCount( void) const = 0 ; 
-      virtual int  PreviewMachiningTool( int nEntId, int nStep) const = 0 ;
+      virtual int  PreviewMachiningTool( int nEntId, int nFlag) const = 0 ;
      virtual bool GetMachiningParam( int nType, bool& bVal) const = 0 ;
      virtual bool GetMachiningParam( int nType, int& nVal) const = 0 ;
      virtual bool GetMachiningParam( int nType, double& dVal) const = 0 ;
@@ -324,7 +322,6 @@ class __declspec( novtable) IMachMgr
      virtual int  GetAxisId( const std::string& sAxis) const = 0 ;
      virtual int  GetHeadId( const std::string& sHead) const = 0 ;
      virtual int  GetHeadExitCount( const std::string& sHead) const = 0 ;
-      virtual int  GetExitId( const std::string& sHead, int nExit) const = 0 ;
      virtual int  GetTcPosId( const std::string& sTcPos) const = 0 ;
      virtual bool GetAxisToken( const std::string& sAxis, std::string& sToken) const = 0 ;
      virtual bool GetAxisType( const std::string& sAxis, bool& bLinear) const = 0 ;
@@ -66,7 +66,7 @@ enum MachiningType {
   MT_SURFROUGHING = OPER_SURFROUGHING,
   MT_SURFFINISHING = OPER_SURFFINISHING,
   MT_WATERJETTING = OPER_WATERJETTING,
-   MT_FIVEAXISMILLING = OPER_FIVEAXISMILLING
+   MT_5AXMACHINING = OPER_5AXMACHINING
 } ;

 //----------------------------------------------------------------------------
@@ -156,7 +156,6 @@ enum MpaType { MPA_NONE =                         0,
               MPA_STEPLAST =        ( MPA_DOU + 51),      // per tagli con lama
               MPA_EPICYCLESRAD =    ( MPA_DOU + 52),      // per svuotature con epicicli
               MPA_EPICYCLESDIST =   ( MPA_DOU + 53),      // per svuotature con epicicli
-               MPA_SUBSTEP =         ( MPA_DOU + 54),      // per sgrossature superfici
               MPA_NAME =            ( MPA_STR +  0),
               MPA_TOOL =            ( MPA_STR +  1),
               MPA_DEPTH_STR =       ( MPA_STR +  2),
@@ -325,9 +324,7 @@ enum { SAWFIN_LL_STD = 0,
 enum { POCKET_SUB_ZIGZAG = 0,
       POCKET_SUB_ONEWAY = 1,
       POCKET_SUB_SPIRALIN = 2,
-       POCKET_SUB_SPIRALOUT = 3,
-       POCKET_SUB_CONFORMAL_ZIGZAG = 4,
-       POCKET_SUB_CONFORMAL_ONEWAY = 5} ;
+       POCKET_SUB_SPIRALOUT = 3} ;
 // Tipo di attacco
 enum { POCKET_LI_NONE = 0,
       POCKET_LI_GLIDE = 1,
@@ -366,24 +363,6 @@ enum { MORTISE_PLUNGE_STEP = 0,
       MORTISE_PLUNGE_START_END = 3,
       MORTISE_PLUNGE_START_TO_END = 4} ;

-//----------------------------------------------------------------------------
-// Parametri per sgrossatura superfici
-// Sottotipo di lavorazione
-enum { SURFROU_SUB_ZIGZAG = 0,
-       SURFROU_SUB_ONEWAY = 1, 
-       SURFROU_SUB_SPIRALIN = 2,
-       SURFROU_SUB_SPIRALOUT = 3,
-       SURFROU_SUB_CONFORMAL_ZIGZAG = 4,
-       SURFROU_SUB_CONFORMAL_ONEWAY = 5} ;
-// Tipo di attacco
-enum { SURFROU_LI_NONE = 0,
-       SURFROU_LI_GLIDE = 1,
-       SURFROU_LI_ZIGZAG = 2,
-       SURFROU_LI_HELIX = 3} ;
-// Tipo di uscita
-enum { SURFROU_LO_NONE = 0,
-       SURFROU_LO_GLIDE = 1} ;
-
 //----------------------------------------------------------------------------
 // Parametri per finitura superfici
 // Sottotipo di lavorazione
@@ -395,6 +374,9 @@ enum { SURFFIN_SUB_ZIGZAG = 0,
 enum { SURFFIN_LI_NONE = 0,
       SURFFIN_LI_LINEAR = 1,
       SURFFIN_LI_TANGENT = 2} ;
+// Tipo di link
+enum { SURFFIN_LL_STD = 0,
+       SURFFIN_LL_CENT = 1} ;
 // Tipo di uscita
 enum { SURFFIN_LO_NONE = 0,
       SURFFIN_LO_LINEAR = 1,
@@ -413,8 +395,7 @@ enum { WJET_EC_NONE = 0,
       WJET_EC_LOOP = 2} ;
 // Comportamento su angolo interno
 enum { WJET_IC_NONE = 0,
-       WJET_IC_SLOW = 1,
-       WJET_IC_SLOW_FULL = 2} ;
+       WJET_IC_SLOW = 1} ;
 // Tipo di attacco
 enum { WJET_LI_NONE = 0,
       WJET_LI_LINEAR = 1,
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2023
 //----------------------------------------------------------------------------
-// File : EmkOperationConst.h     Data : 22.05.24     Versione : 2.6e5
+// File : EmkOperationConst.h     Data : 06.09.23     Versione : 2.5i1
 // Contenuto : Costanti delle operazioni.      
 //
 //
@@ -19,21 +19,21 @@
 #pragma once

 //------------------------ Costanti per tipo Operazioni -----------------------
-enum OperType { OPER_NULL =                  0,      // nulla
-                OPER_DISP =            0x000100,     // disposizione
-                OPER_DRILLING =        0x000200,     // foratura
-                OPER_SAWING =          0x000400,     // taglio di lama
-                OPER_MILLING =         0x000800,     // fresatura
-                OPER_POCKETING =       0x001000,     // svuotatura
-                OPER_MORTISING =       0x002000,     // mortasatura
-                OPER_SAWROUGHING =     0x004000,     // sgrossatura con lama
-                OPER_SAWFINISHING =    0x008000,     // finitura con lama
-                OPER_GENMACHINING =    0x010000,     // lavorazione generica
-                OPER_CHISELING =       0x020000,     // scalpellatura
-                OPER_SURFROUGHING =    0x040000,     // sgrossatura superficie
-                OPER_SURFFINISHING =   0x080000,     // finitura superficie
-                OPER_WATERJETTING =    0x100000,     // taglio water jet
-                OPER_FIVEAXISMILLING = 0x200000} ;   // lavorazione 5 assi
+enum OperType { OPER_NULL =                0,      // nulla
+                OPER_DISP =          0x000100,     // disposizione
+                OPER_DRILLING =      0x000200,     // foratura
+                OPER_SAWING =        0x000400,     // taglio di lama
+                OPER_MILLING =       0x000800,     // fresatura
+                OPER_POCKETING =     0x001000,     // svuotatura
+                OPER_MORTISING =     0x002000,     // mortasatura
+                OPER_SAWROUGHING =   0x004000,     // sgrossatura con lama
+                OPER_SAWFINISHING =  0x008000,     // finitura con lama
+                OPER_GENMACHINING =  0x010000,     // lavorazione generica
+                OPER_CHISELING =     0x020000,     // scalpellatura
+                OPER_SURFROUGHING =  0x040000,     // sgrossatura superficie
+                OPER_SURFFINISHING = 0x080000,     // finitura superficie
+                OPER_WATERJETTING =  0x100000,     // taglio water jet
+                OPER_5AXMACHINING =  0x200000} ;   // lavorazione 5 assi
 // Controllo tipo valido
 bool inline IsValidDispositionType( int nType)
 {
@@ -53,5 +53,5 @@ bool inline IsValidMachiningType( int nType)
            nType == OPER_SURFROUGHING  ||
            nType == OPER_SURFFINISHING  ||
            nType == OPER_WATERJETTING  ||
-            nType == OPER_FIVEAXISMILLING) ;
+            nType == OPER_5AXMACHINING) ;
 }
@@ -122,7 +122,3 @@ const std::string TTH_BASE = "B" ;                      // posizione base portau
 const std::string TTH_LEN = "H" ;                       // lunghezza portautensile da naso mandrino
 const std::string TTH_DIAM = "D" ;                      // diametro massimo portautensile
 const std::string TTH_STEM_DIAM = "D_STEM" ;            // diametro massimo gambo utensile
-
-//----------------------------------------------------------------------------
-// Costanti per nomi di parti di utensile
-const std::string TNA_TOOL_START = "Tool_" ;            // inizio nome delle geometrie che costituiscono il vero utensile
@@ -275,8 +275,6 @@ EXE_EXPORT int  ExeCreateArcC2PEx( int nParentId, const Point3d& ptCen,
                                   const Point3d& ptNearEnd, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc3P( int nParentId, const Point3d& ptP1,
                                const Point3d& ptP2, const Point3d& ptP3, int nRefType) ;
-EXE_EXPORT int  ExeCreateArc2PR( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
-                                 double dRad, bool bCCW, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc2PB( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
                                 double dBulge, int nRefType) ;
 EXE_EXPORT int  ExeCreateArc2PD( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
@@ -323,8 +321,6 @@ EXE_EXPORT int  ExeCreatePolygonFromSide( int nParentId, int nNumSides, const Po
                                          const Point3d& ptFin, int nRefType) ;
 EXE_EXPORT int  ExeCreateCirclesAlongCurve( int nParentId, int nCrvId, double dOffset, double dOverlap,
                                            double dStartAdd, double dEndAdd, double dDiam, int* pnCount) ;
-EXE_EXPORT int  ExeCreateCurveBezierForm( int nParentId, int nCrvId, int nDeg) ;
-
 // GeomDB Create Surf
 EXE_EXPORT int  ExeCreateSurfFlatRegion( int nParentId, const INTVECTOR& vCrvIds, int* pnCount) ;
 EXE_EXPORT int  ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquaredEnds, bool bSquaredMids, double dLinTol) ;
@@ -374,33 +370,15 @@ EXE_EXPORT int  ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV
 EXE_EXPORT int  ExeCreateSurfBezierLeaves( int nParentId, int nSurfBzId, int nTextHeight = 50, bool bShowTrim = false, int* pnCount = nullptr) ;
 EXE_EXPORT int  ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nRefType) ;
 EXE_EXPORT int  ExeCreateSurfBezierTria2D( int nParentId, int nSurfBzId, int nTextHeight, bool bShowTrim, int* pnCount) ;
-EXE_EXPORT int  ExeCreateSurfBzByFlatContour( int nParentId, int nCrvId, double dLinTol) ;
-EXE_EXPORT int  ExeCreateSurfBzByRegion( int nParentId, const INTVECTOR& vCrvId, double dLinTol) ;
-EXE_EXPORT int  ExeCreateSurfBzByExtrusion( int nParentId, int nCrvId, const Vector3d& vtExtr, bool bCapEnds,
-                                            double dLinTol, int nRefType) ;
-EXE_EXPORT int  ExeCreateSurfBzByRegionExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vector3d& vtExtr, bool bCapEnds,
-                                                  double dLinTol, int nRefType) ;
-EXE_EXPORT int  ExeCreateSurfBzByScrewing( int nParentId, int nCrvId,
-                                           const Point3d& ptAx, const Vector3d& vtAx,
-                                           double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol, int nRefType) ;
-EXE_EXPORT int  ExeCreateSurfBzByRevolve( int nParentId, int nCrvId,
-                                           const Point3d& ptAx, const Vector3d& vtAx,
-                                           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  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) ;

 // GeomDB Create Volume
 EXE_EXPORT int  ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX,
-                                   double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
+                                  double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
 EXE_EXPORT int  ExeCreateVolZmapEmpty( int nParentId, const Point3d& ptIni, double dDimX,
-                                       double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
+                                       double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType ) ;
 EXE_EXPORT int  ExeCreateVolZmapByRegionExtrusion( int nParentId, int nSfrId, double dDimZ, double dPrec, bool bTriDex) ;
 EXE_EXPORT int  ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDex) ;
-EXE_EXPORT bool ExeUpdateVolZmapByAddingSurfTm( int nVolZmapId, int nStmId) ;
-EXE_EXPORT bool ExeUniformVolZmap( int nVolZmapId, double dToler) ;
+EXE_EXPORT bool  ExeUpdateVolZmapByAddingSurfTm( int nParentId, int nZmapId, int nStmId) ;

 // GeomDB PartLayer
 EXE_EXPORT bool ExeIsPart( int nPartId) ;
@@ -491,7 +469,7 @@ EXE_EXPORT bool ExeSetStatus( const INTVECTOR& vIds, int nStat) ;
 EXE_EXPORT bool ExeRevertStatus( int nId) ;
 EXE_EXPORT bool ExeGetStatus( int nId, int* pnStat) ;
 EXE_EXPORT bool ExeGetCalcStatus( int nId, int* pnStat) ;
-EXE_EXPORT bool ExeSetMark( int nId, int nMark = 1) ;
+EXE_EXPORT bool ExeSetMark( int nId) ;
 EXE_EXPORT bool ExeResetMark( int nId) ;
 EXE_EXPORT bool ExeGetMark( int nId, int* pnMark) ;
 EXE_EXPORT bool ExeGetCalcMark( int nId, int* pnMark) ;
@@ -622,25 +600,15 @@ EXE_EXPORT bool ExeModifyCurveCompoCurveToLine( int nId, int nCrv) ;
 EXE_EXPORT int  ExeExplodeCurveCompo( int nId, int* pnCount) ;
 EXE_EXPORT bool ExeMergeCurvesInCurveCompo( int nId, double dLinTol, bool bStartEnd) ;
 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 ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId,
                                         double dLinTol, double dMaxSegmLen, int nRefType) ;
 EXE_EXPORT bool ExeProjectCurveOnSurfTmExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
                                            double dLinTol, double dMaxSegmLen, bool bDirFromGuide) ;
-EXE_EXPORT bool ExeProjectCurveOnSurfBz( int nCurveId, int nSurfBzId, const Vector3d& vtDir, int nDestGrpId,
-                                         double dLinTol, double dMaxSegmLen, int nRefType) ;
-EXE_EXPORT bool ExeProjectCurveOnSurfBzExt( int nCurveId, int nSurfBzId, int nGuideId, int nDestGrpId,
-                                            double dLinTol, double dMaxSegmLen, bool bDirFromGuide) ;
-EXE_EXPORT int  ExeCurveGetVoronoi( 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  ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) ;
+EXE_EXPORT int  ExeCurveGetMedialAxis( int nId, int nDestGrpId, int nSide, int* pnCount) ;
 EXE_EXPORT int  ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, bool bSquareMids, int* pnCount) ;
-EXE_EXPORT bool ExeCurveBezierIncreaseDegree( int nCrvId) ;
-EXE_EXPORT bool ExeCurveBezierDecreaseDegree( int nCrvId, double dTol = 100) ;
-EXE_EXPORT bool ExeCurveBezierApproxToNonRat( int nCrvId, double dTol = 10 * EPS_SMALL) ;
-EXE_EXPORT bool ExeCurveBezierApproxWithCubicBeziers( int nCrvId, double dTol = 10 * EPS_SMALL) ;

 // GeomDb Surf Modify
 EXE_EXPORT bool ExeInvertSurface( const INTVECTOR& vIds) ;
@@ -651,7 +619,6 @@ EXE_EXPORT bool ExeSurfFrSubtract( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrIntersect( int nId1, int nId2) ;
 EXE_EXPORT bool ExeSurfFrOffset( int nId, double dDist, int nType) ;
 EXE_EXPORT bool ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewId) ;
-EXE_EXPORT bool ExeSurfFrEraseChunk( int nId, int nChunk) ;
 EXE_EXPORT bool ExeSurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double& dLen, int nRefType) ;
 EXE_EXPORT bool ExeSurfFrRotateSimpleNoCollision( int nId1, int nId2, const Point3d& ptCen, double& dAngDeg, int nRefType) ;
 EXE_EXPORT bool ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType, bool bUpdate) ;
@@ -671,13 +638,9 @@ EXE_EXPORT bool ExeSurfTmCut( int nId, int nCutterId, bool bInVsOut, bool bSaveO
 EXE_EXPORT bool ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId,
                                                       INTVECTOR vSurfsId, bool bOCFlag,
                                                       bool& bExistProjection, int& nNewId, int& nNewFaceNbr) ;
-EXE_EXPORT bool ExeSurfTmSetFaceColor( int nId, int nFacet, int nColor) ;
-EXE_EXPORT bool ExeSurfTmGetTriaColor( int nId, int nTria, int& nColor) ;
 EXE_EXPORT bool ExeSurfTmResetTwoColors( int nId) ;
 EXE_EXPORT bool ExeSurfTmSetShowEdges( int nId, bool bShow) ;
-EXE_EXPORT bool ExeSurfTmGetShowEdges( int nId, bool& bShow) ;
 EXE_EXPORT bool ExeSurfBzTrim( int nId, int nCutterId) ;
-EXE_EXPORT bool ExeSurfTmSetSmoothAng( int nId, double dAngDeg) ;

 // GeomDb Volume Modify
 EXE_EXPORT int  ExeExplodeVolume( int nId, int* pnCount) ;
@@ -695,8 +658,6 @@ EXE_EXPORT bool ExeVolZmapSetMortiserTool( const INTVECTOR& vIds, const std::str
                                           double dLen, double dWidth, double dThick, double dCornR, int nFlag, bool bFirst) ;
 EXE_EXPORT bool ExeVolZmapSetChiselTool( const INTVECTOR& vIds, const std::string& sToolName,
                                         double dLen, double dWidth, double dThick, int nFlag, bool bFirst) ;
-EXE_EXPORT bool ExeVolZmapSetAdditiveTool( const INTVECTOR& vIds, const std::string& sToolName,
-                                           double dLen, double dDiam, double dCornR, int nFlag, bool bFirst) ;
 EXE_EXPORT bool ExeVolZmapResetTools( const INTVECTOR& vIds) ;
 EXE_EXPORT int  ExeVolZmapGetToolOutline( int nId, int nDestGrpId, bool bApprox = false) ;
 EXE_EXPORT bool ExeVolZmapMillingStep( int nId, const Point3d& ptPs, const Vector3d& vtDs,
@@ -719,7 +680,6 @@ EXE_EXPORT int ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep,
 // GeomDb Curve Get
 EXE_EXPORT bool ExeCurveDomain( int nId, double* pdStart, double* pdEnd) ;
 EXE_EXPORT bool ExeCurveLength( int nId, double* pdLen) ;
-EXE_EXPORT bool ExeCurveLengthAtParam( int nId, double dPar, double* pdLen) ;
 EXE_EXPORT bool ExeCurveParamAtLength( int nId, double dLen, double* pdPar) ;
 EXE_EXPORT bool ExeCurveParamAtPoint( int nId, const Point3d& pt, double dTol, int nRefType, double* pdPar) ;
 EXE_EXPORT bool ExeCurveLengthAtPoint( int nId, const Point3d& ptOn, double dExtend, double* pdLen) ;
@@ -746,9 +706,6 @@ EXE_EXPORT bool ExeCurveCompoCenter( int nId, int nSimpCrv, int nRefId, Point3d&
 EXE_EXPORT bool ExeCurveCompoRadius( int nId, int nSimpCrv, double& dRad) ;
 EXE_EXPORT bool ExeCurveCompoAngCenter( int nId, int nSimpCrv, double& dAngCen) ;
 EXE_EXPORT bool ExeCurveCompoNormVersor( int nId, int nSimpCrv, int nRefId, Vector3d& vtNorm) ;
-EXE_EXPORT bool ExeCurveCompoGetTempProp( int nId, INTVECTOR& vProp, int nPropInd) ;
-EXE_EXPORT bool ExeCurveCompoGetTempParam( int nId, DBLVECTOR& vParam, int nParamInd) ;
-EXE_EXPORT int  ExeShowCurveBezierControlPoints( int nCrvId, int nDestGrpId, int* pnCount) ;

 // GeomDb Surf Get
 EXE_EXPORT bool ExeSurfArea( int nId, double& dArea) ;
@@ -756,11 +713,9 @@ EXE_EXPORT bool ExeSurfIsClosed( int nId) ;
 EXE_EXPORT bool ExeSurfVolume( int nId, double& dVol) ;
 EXE_EXPORT bool ExeSurfFrNormVersor( int nId, int nRefId, Vector3d& vtNorm) ;
 EXE_EXPORT bool ExeSurfFrGrossArea( int nId, double& dArea) ;
-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 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) ;
@@ -768,7 +723,6 @@ EXE_EXPORT int  ExeSurfTmFacetCount( int nId) ;
 EXE_EXPORT int  ExeSurfTmPartCount( int nId) ;
 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) ;
 EXE_EXPORT int  ExeSurfTmFacetFromTria( int nId, int nT) ;
 EXE_EXPORT bool ExeSurfTmFacetAdjacencies( int nId, int nFacet, INTMATRIX& vAdj) ;
 EXE_EXPORT bool ExeSurfTmFacetNearestEndPoint( int nId, int nFacet, const Point3d& ptNear, int nRefId,
@@ -787,16 +741,12 @@ EXE_EXPORT bool ExeSurfTmFacetOppositeSideEx( int nId, int nFacet, const Vector3
 EXE_EXPORT bool ExeSurfTmFacetsContact( int nId, int nF1, int nF2, int nRefId, bool& bAdjac, Point3d& ptP1, Point3d& ptP2, double& dAng) ;
 EXE_EXPORT int  ExeExtractSurfTmLoops( int nId, int nDestGrpId, int* pnCount) ;
 EXE_EXPORT int  ExeGetSurfTmSilhouette( int nId, const Vector3d& vtDir, double dToler, int nDestGrpId, int nRefType, int* pnCount, bool bAllTria = false) ;
-EXE_EXPORT int  ExeGetSurfTmParSilhouettes( const INTVECTOR& vIds, const Point3d& ptOn, const Vector3d& vtN, const DBLVECTOR& vdDist,
-                                            double dToler, int nDestGrpId, int nRefType, int* pnCount) ;
 EXE_EXPORT int  ExeExtractSurfTmFacetLoops( int nId, int nFacet, int nDestGrpId, int* pnCount) ;
 EXE_EXPORT int  ExeCopySurfTmFacet( int nId, int nFacet, int nDestGrpId) ;
 EXE_EXPORT bool ExeSurfTmGetAllVertInFacet( int nId, int nFacet, INTVECTOR& vVert) ;
 EXE_EXPORT bool ExeSurfTmGetFacetBBox( int nId, int nFacet, int nFlag, BBox3d& b3Box) ;
 EXE_EXPORT bool ExeSurfTmGetFacetBBoxGlob( int nId, int nFacet, int nFlag, BBox3d& b3Box) ;
 EXE_EXPORT bool ExeSurfTmGetFacetBBoxRef( int nId, int nFacet, int nFlag, const Frame3d& frRef, BBox3d& b3Box) ;
-EXE_EXPORT bool ExeSurfTmGetFacetOutlineInfo( int nId, int nFacet, int nRefId,
-                                              int& nStatus, BOOLVECTOR& vbOpen, INTVECTOR& vnAdj, DBLVECTOR& vdLen, VCT3DVECTOR& vvtNorm, DBLVECTOR& vdElev) ;
 EXE_EXPORT int  ExeSurfTmGetEdges( int nId, int nDestGrpId, bool bSmoothAng, int* pnCount) ;
 EXE_EXPORT bool ExeSurfBezierGetPoint( int nSurfId, double dU, double dV, int nRefId, Point3d& ptP) ;
 EXE_EXPORT bool ExeSurfBezierGetPointD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
@@ -809,7 +759,6 @@ EXE_EXPORT bool ExeSurfBezierGetInfo( int nSurfId, int& nDegU, int& nDegV, int&
 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) ;
-EXE_EXPORT int  ExeShowSurfBezierControlPoints( int nSrfId, int nDestGrpId, int* pnCount) ;

 // GeomDb Volume Get
 EXE_EXPORT bool ExeVolZmapVolume( int nId, double& dVol) ;
@@ -1110,7 +1059,6 @@ EXE_EXPORT bool ExeTdbGetCurrToolValInNotes( int nType, const std::string& sKey,
 EXE_EXPORT bool ExeTdbGetCurrToolMaxDepth( double& dMaxDepth) ;
 EXE_EXPORT bool ExeTdbGetCurrToolThDiam( double& dThDiam) ;
 EXE_EXPORT bool ExeTdbGetCurrToolThLength( double& dThLen) ;
-EXE_EXPORT bool ExeTdbCurrToolIsStandardDraw( bool& bStandard) ;
 EXE_EXPORT int  ExeTdbCurrToolDraw( int nGenCtx, int nToolCtx) ;
 EXE_EXPORT bool ExeTdbReload( void) ;
 EXE_EXPORT bool ExeTdbSave( void) ;
@@ -1209,8 +1157,7 @@ EXE_EXPORT bool ExeApplyMachining( bool bRecalc, bool bPostApply = true) ;
 EXE_EXPORT bool ExeUpdateMachining( bool bPostApply = true) ;
 EXE_EXPORT bool ExePreparePreviewMachiningTool( void) ;
 EXE_EXPORT bool ExeRemovePreviewMachiningTool( void) ;
-EXE_EXPORT int  ExeGetPreviewMachiningToolStepCount( void) ;
-EXE_EXPORT int  ExePreviewMachiningTool( int nEntId, int nStep) ;
+EXE_EXPORT int  ExePreviewMachiningTool( int nEntId, int nFlag) ;
 EXE_EXPORT bool ExeGetMachiningParam( int nType, bool& bVal) ;
 EXE_EXPORT bool ExeGetMachiningParam( int nType, int& nVal) ;
 EXE_EXPORT bool ExeGetMachiningParam( int nType, double& dVal) ;
@@ -1252,7 +1199,6 @@ EXE_EXPORT int  ExeGetTableId( const std::string& sTable) ;
 EXE_EXPORT int  ExeGetAxisId( const std::string& sAxis) ;
 EXE_EXPORT int  ExeGetHeadId( const std::string& sHead) ;
 EXE_EXPORT int  ExeGetHeadExitCount( const std::string& sHead) ;
-EXE_EXPORT int  ExeGetExitId( const std::string& sHead, int nExit) ;
 EXE_EXPORT int  ExeGetTcPosId( const std::string& sTcPos) ;
 EXE_EXPORT bool ExeGetAxisToken( const std::string& sAxis, std::string& sToken) ;
 EXE_EXPORT bool ExeGetAxisType( const std::string& sAxis, bool& bLinear) ;
@@ -1305,7 +1251,7 @@ EXE_EXPORT bool ExeGetSceneInfo( std::string& sInfo) ;
 EXE_EXPORT bool ExeSetBackground( Color TopCol, Color BottomCol, bool bRedraw) ;
 EXE_EXPORT bool ExeGetBackground( Color& TopCol, Color& BottomCol) ;
 EXE_EXPORT bool ExeSetLineAttribs( int nWidth) ;
-EXE_EXPORT bool ExeSetMarkAttribs( Color MarkCol, Color Mark2Col) ;
+EXE_EXPORT bool ExeSetMarkAttribs( Color MarkCol) ;
 EXE_EXPORT bool ExeSetSelSurfAttribs( Color SelSurfCol) ;
 EXE_EXPORT bool ExeSetGeoLineAttribs( Color GlCol) ;
 EXE_EXPORT bool ExeSetGeoTriaAttribs( Color GtCol) ;
@@ -25,7 +25,7 @@

 //----------------------------------------------------------------------------
 const int KEY_BASELIB_PROD = 207 ;
-const int KEY_BASELIB_VER = 2610 ;
+const int KEY_BASELIB_VER = 2604 ;
 const int KEY_BASELIB_LEV = 1 ;

 //----------------------------------------------------------------------------