Egalware/Include
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: Egalware/Include:master
Branches Tags
Egalware/Include:master Egalware/Include:Nst_SurfFr Egalware/Include:Preview Egalware/Include:Trimming Egalware/Include:NewRuled Egalware/Include:FasterVMill5Axis_Bez3x1 Egalware/Include:FasterBezier Egalware/Include:MoreBezier Egalware/Include:Shell&Parts Egalware/Include:SetSmoothAngle Egalware/Include:Surf_Simp_Zmap Egalware/Include:VmillAdditivo Egalware/Include:Zmap Egalware/Include:CmdCreateSurfBezier Egalware/Include:RMF Egalware/Include:Cube Egalware/Include:Dijkstra Egalware/Include:develop Egalware/Include:Bezier_trim&mesh Egalware/Include:ExtDimension_Angular Egalware/Include:ThreeJS Egalware/Include:SaraP Egalware/Include:TempForVmill Egalware/Include:LorenzoM
Egalware/Include:AutoSave_2024/02/02 Egalware/Include:AutoSave_2024/03/08 Egalware/Include:AutoSave_2024/10/01
..
pull from: Egalware/Include:Zmap
Branches Tags
Egalware/Include:master Egalware/Include:Nst_SurfFr Egalware/Include:Preview Egalware/Include:Trimming Egalware/Include:NewRuled Egalware/Include:FasterVMill5Axis_Bez3x1 Egalware/Include:FasterBezier Egalware/Include:MoreBezier Egalware/Include:Shell&Parts Egalware/Include:SetSmoothAngle Egalware/Include:Surf_Simp_Zmap Egalware/Include:VmillAdditivo Egalware/Include:Zmap Egalware/Include:CmdCreateSurfBezier Egalware/Include:RMF Egalware/Include:Cube Egalware/Include:Dijkstra Egalware/Include:develop Egalware/Include:Bezier_trim&mesh Egalware/Include:ExtDimension_Angular Egalware/Include:ThreeJS Egalware/Include:SaraP Egalware/Include:TempForVmill Egalware/Include:LorenzoM
Egalware/Include:AutoSave_2024/02/02 Egalware/Include:AutoSave_2024/03/08 Egalware/Include:AutoSave_2024/10/01

1 Commits
master .. Zmap

Author SHA1 Message Date
Riccardo Elitropi 1bee53b085 Include : 
- codice di test per Zmap
 2024-04-22 08:05:01 +02:00
92 changed files with 510 additions and 2706 deletions
Expand all files Collapse all files
EBsAPI.h
-57
View File
@@ -1,57 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2024-2025
//----------------------------------------------------------------------------
// File : EBsAPI.h Data : 24.01.25 Versione : 2.7a1
// Contenuto : API (application programming interface).
//
//
//
// Modifiche : 05.10.24 DS Creazione modulo.
// 24.01.25 DS Aggiunta gestione messaggi.
//
//----------------------------------------------------------------------------
#pragma once
#define NOMINMAX
#include <windows.h>
//----------------------- Macro per import/export ----------------------------
#undef EGTBASIS_EXPORT
#if defined( I_AM_EGTBASIS) // da definirsi solo nella DLL
#define EGTBASIS_EXPORT __declspec( dllexport)
#else
#define EGTBASIS_EXPORT __declspec( dllimport)
#endif
//-----------------------------------------------------------------------------
#ifdef __cplusplus
extern "C" {
#endif
// API
// Protezione
EGTBASIS_EXPORT BOOL __stdcall EgtSetKey( const wchar_t* wsKey) ;
EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyLevel( int nProd, int nVer, int nLev, int* pnKLev) ;
EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyOptions( int nProd, int nVer, int nLev, unsigned int* pnOpt1, unsigned int* pnOpt2) ;
EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyLeftDays( int* pnLeftDays) ;
EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyAssLeftDays( int* pnAssLeftDays) ;
EGTBASIS_EXPORT BOOL __stdcall EgtGetKeyOptLeftDays( int* pnOptLeftDays) ;
// Liberazione memoria blocchi dati ritornati (di solito per stringhe)
EGTBASIS_EXPORT BOOL __stdcall EgtFreeMemory( void* pMem) ;
// Messaggi
EGTBASIS_EXPORT BOOL __stdcall EgtLoadMessages( const wchar_t* wsMsgFilePath) ;
EGTBASIS_EXPORT const wchar_t* __stdcall EgtGetMsg( int nMsg) ;
// Logger
EGTBASIS_EXPORT BOOL __stdcall EgtInitLogger( int nDebug, const wchar_t* wsLogFile) ;
EGTBASIS_EXPORT BOOL __stdcall EgtOutLog( const wchar_t* wsMsg, int nDebugLevel) ;
// Ini File
EGTBASIS_EXPORT BOOL __stdcall EgtGetStringUtf8FromIni( const wchar_t* wsSec, const wchar_t* wsKey,
const wchar_t* wsDef, wchar_t*& wsVal, const wchar_t* wsIniFile) ;
EGTBASIS_EXPORT BOOL __stdcall EgtWriteStringUtf8ToIni( const wchar_t* wsSec, const wchar_t* wsKey,
const wchar_t* wsVal, const wchar_t* wsIniFile) ;
#ifdef __cplusplus
}
#endif
EExBeamConst.h
+3 -5
View File
@@ -1,14 +1,13 @@
//----------------------------------------------------------------------------
// EgalTech 2020-2026
// EgalTech 2020-2022
//----------------------------------------------------------------------------
// File : EExBeamConst.h Data : 23.01.26 Versione : 3.1a2
// File : EExBeamConst.h Data : 04.04.22 Versione : 2.4d2
// Contenuto : Dichiarazione delle costanti per travi e pareti con BTL.
//
//
//
// Modifiche : 30.08.20 DS Creazione modulo.
// 04.04.22 DS Aggiunto EIBFLAG_TRIM_WITH_OUTLINE.
// 23.01.26 DS Aggiunto EIBFLAG_PARTOFFSET.
//
//----------------------------------------------------------------------------
@@ -23,5 +22,4 @@ enum EImBtlFlag { EIBFLAG_NONE = 0x0000,
EIBFLAG_SORT = 0x0010, // ordina i pezzi nel DB in base al nome
EIBFLAG_USEUATTR = 0x0020, // utilizza i parametri utente U per modificare la geometria delle features
EIBFLAG_OUTL_FLAT_POS = 0x0040, // pezzi secondo outline o di piatto (prevale sui precedenti POS)
EIBFLAG_TRIM_WITH_OUTLINE = 0x0080, // esegui il trim delle feature con l'outline (se presente)
EIBFLAG_PARTOFFSET = 0x0100} ; // gestione geometrica del PARTOFFSET
EIBFLAG_TRIM_WITH_OUTLINE = 0x0080} ; // esegui il trim delle feature con l'outline (se presente)
EExBeamMgr.h
+2 -5
View File
@@ -16,7 +16,6 @@
#include "/EgtDev/Include/EGkGeomDB.h"
#include "/EgtDev/Include/EExBeamConst.h"
#include "/EgtDev/Include/EgtFunPtrType.h"
#include <string>
//----------------------- Macro per import/export ----------------------------
@@ -54,13 +53,11 @@ class __declspec( novtable) IBeamMgr
int nCrvId, int nCrv2Id, bool bUpdate = true) = 0 ;
virtual bool EraseProcess( int nGeomId, bool bUpdate = true) = 0 ;
virtual bool EnableProcess( int nGeomId, bool bEnable, bool bUpdate = true) = 0 ;
virtual bool CalcAllSolids( bool bShow, bool bRecalc, pcfProcEvents pFun = nullptr) = 0 ;
virtual bool ShowAllSolids( bool bShow, pcfProcEvents pFun = nullptr) = 0 ;
virtual bool CalcSolid( int nPartId, bool bRecalc = false) = 0 ;
virtual int GetSolid( int nPartId) const = 0 ;
virtual bool ShowSolid( int nPartId, bool bShow) = 0 ;
virtual bool GetBuildingIsOn( int nAssGrpId) const = 0 ;
virtual bool ShowBuilding( int nAssGrpId, bool bShow) = 0 ;
virtual bool GetBuildingIsOn( void) const = 0 ;
virtual bool ShowBuilding( bool bShow) = 0 ;
} ;
EExImport3MF.h
+1 -4
View File
@@ -29,13 +29,10 @@ class __declspec( novtable) IImport3MF
{
public :
virtual ~IImport3MF( void) {}
virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup, int nFlag = 0) = 0 ;
virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup) = 0 ;
} ;
//-----------------------------------------------------------------------------
extern "C" {
EEX_EXPORT IImport3MF* CreateImport3MF( void) ;
}
enum EIm3MFFlag { EI3FLAG_NONE = 0x0000,
EI3FLAG_KEEP_GROUPS = 0x0001} ;
EExImportBtl.h
-1
View File
@@ -37,6 +37,5 @@ class __declspec( novtable) IImportBtl
//-----------------------------------------------------------------------------
extern "C" {
EEX_EXPORT bool SetBtlAuxDir( const std::string& sBtlAuxDir) ;
EEX_EXPORT bool SetBtlLuaData( const std::string& sLuaLibsDir, const std::string& sLuaLastRequire) ;
EEX_EXPORT IImportBtl* CreateImportBtl( void) ;
}
EExImportOff.h
-38
View File
@@ -1,38 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2024-2024
//----------------------------------------------------------------------------
// File : EExImportOff.h Data : 28.11.24 Versione : 2.6k2
// Contenuto : Dichiarazione della interfaccia IImportOff.
//
//
//
// Modifiche : 28.11.24 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkGeomDB.h"
#include <string>
//----------------------- Macro per import/export ----------------------------
#undef EEK_EXPORT
#if defined( I_AM_EEX) // da definirsi solo nella DLL
#define EEX_EXPORT __declspec( dllexport)
#else
#define EEX_EXPORT __declspec( dllimport)
#endif
//-----------------------------------------------------------------------------
class __declspec( novtable) IImportOff
{
public :
virtual ~IImportOff( void) {}
virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup, double dScaleFactor = 1) = 0 ;
} ;
//-----------------------------------------------------------------------------
extern "C" {
EEX_EXPORT IImportOff* CreateImportOff( void) ;
}
EExImportPly.h
-38
View File
@@ -1,38 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2025-2025
//----------------------------------------------------------------------------
// File : EExImportPly.h Data : 28.02.25 Versione : 2.7b2
// Contenuto : Dichiarazione della interfaccia IImportPly.
//
//
//
// Modifiche : 28.02.25 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkGeomDB.h"
#include <string>
//----------------------- Macro per import/export ----------------------------
#undef EEK_EXPORT
#if defined( I_AM_EEX) // da definirsi solo nella DLL
#define EEX_EXPORT __declspec( dllexport)
#else
#define EEX_EXPORT __declspec( dllimport)
#endif
//-----------------------------------------------------------------------------
class __declspec( novtable) IImportPly
{
public :
virtual ~IImportPly( void) {}
virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup, double dScaleFactor = 1) = 0 ;
} ;
//-----------------------------------------------------------------------------
extern "C" {
EEX_EXPORT IImportPly* CreateImportPly( void) ;
}
EGkBBox3d.h
+1 -11
View File
@@ -15,8 +15,6 @@
#pragma once
#include "/EgtDev/Include/EGkPoint3d.h"
#include "/EgtDev/Include/EGkFrame3d.h"
#include <vector>
//----------------------- Macro per import/export ----------------------------
#undef EGK_EXPORT
@@ -49,7 +47,7 @@ class EGK_EXPORT BBox3d
{ m_ptMin = Point3d( +INFINITO, +INFINITO, +INFINITO) ;
m_ptMax = Point3d( -INFINITO, -INFINITO, -INFINITO) ; }
void Set( const Point3d& ptP)
{ m_ptMin = ptP ; m_ptMax = ptP ; }
{ m_ptMin = ptP ; m_ptMax = ptP ; }
void Set( double dX, double dY, double dZ)
{ m_ptMin = Point3d( dX, dY, dZ) ; m_ptMax = m_ptMin ; }
void Set( const Point3d& ptP1, const Point3d& ptP2) ;
@@ -67,8 +65,6 @@ class EGK_EXPORT BBox3d
void Add( const Point3d& ptP) ;
void Add( double dX, double dY, double dZ) ;
void Add( const BBox3d& b3B) ;
void Add( const std::vector<Point3d>& vPnt) { for ( const Point3d& pt: vPnt){
Add( pt) ; }}
void Expand( double dDelta) ;
void Expand( double dDeltaX, double dDeltaY, double dDeltaZ) ;
const Point3d& GetMin( void) const
@@ -164,9 +160,3 @@ GetLocToLoc( const BBox3d& b3Box, const Frame3d& frOri, const Frame3d& frDest)
b3New.LocToLoc( frOri, frDest) ;
return b3New ;
}
//----------------------------------------------------------------------------
inline bool Overlaps( const BBox3d& bbA, const Frame3d& frA, const BBox3d& bbB, const Frame3d& frB)
{
return bbA.Overlaps( GetToLoc( frB, frA), bbB) ;
}
EGkCAvSilhouetteSurfTm.h
-42
View File
@@ -1,42 +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 SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol,
double dSideAng, double dDiam, double dCornRad, double dMaxMat, double dOffsR,
double dMaxDepth) = 0 ;
virtual bool GetSilhouette( double dLevel, POLYLINEVECTOR& vPL) = 0 ;
} ;
//-----------------------------------------------------------------------------
EGK_EXPORT ICAvParSilhouettesSurfTm* CreateCAvParSilhouettesSurfTm( void) ;
EGkCAvSimpleSurfFrMove.h
+7 -14
View File
@@ -35,27 +35,20 @@ const int SCI_LINE_LINE = 4 ; // tra linea di mobile e linea di fiss
struct SCollInfo
{
int nType ; // tipo di collisione
int nChunkM ; // indice del chunk della regione mobile
int nLoopM ; // indice del loop del chunk della regione mobile
int nCrvM ; // indice della curva nel loop del chunk
int nCrvM ; // indice della curva nel loop esterno del chunk
int nChunkF ; // indice del chunk della regione fissa
int nLoopF ; // indice del loop del chunk della regione fissa
int nCrvF ; // indice della curva nel loop del chunk
int nCrvF ; // indice della curva nel loop esterno del chunk
Point3d ptP1 ; // punto di contatto
Point3d ptP2 ; // se contatto linea-linea, secondo punto di contatto
Vector3d vtDirM ; // se contatto del mobile con linea, sua direzione
Vector3d vtDirF ; // se contatto del fisso con linea, sua direzione
// costruttori
SCollInfo() : nType( SCI_NONE), nChunkM( -1), nLoopM( -1), nCrvM( -1), nChunkF( -1), nLoopF( -1), nCrvF( -1),
SCollInfo() : nType( SCI_NONE), nChunkM( -1), nCrvM( -1), nChunkF( -1), nCrvF( -1),
ptP1(), ptP2(), vtDirM(), vtDirF() {}
SCollInfo( const SCollInfo& Sou) : nType( Sou.nType),
nChunkM( Sou.nChunkM), nLoopM( Sou.nLoopM), nCrvM( Sou.nCrvM),
nChunkF( Sou.nChunkF), nLoopF( Sou.nLoopF), nCrvF( Sou.nCrvF),
ptP1( Sou.ptP1), ptP2( Sou.ptP2), vtDirM( Sou.vtDirM), vtDirF( Sou.vtDirF) {}
SCollInfo( const SCollInfo& Sou) : nType( Sou.nType), nChunkM( Sou.nChunkM), nCrvM( Sou.nCrvM),
nChunkF( Sou.nChunkF), nCrvF( Sou.nCrvF), ptP1( Sou.ptP1),
ptP2( Sou.ptP2), vtDirM( Sou.vtDirM), vtDirF( Sou.vtDirF) {}
} ;
//----------------------------------------------------------------------------
@@ -74,4 +67,4 @@ class CAvSimpleSurfFrMove
const ISurfFlatRegion* m_pRegM ;
const ISurfFlatRegion* m_pRegF ;
SCollInfo m_SCollInfo ;
} ;
} ;
EGkCAvSurfFrMove.h
-41
View File
@@ -1,41 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2018
//----------------------------------------------------------------------------
// File : EGkCAvSurfFrMove.h Data : 26.03.2026 Versione : 3.1c7
// Contenuto : Dichiarazione classe per movimento di superfici flat region
// nel loro piano evitando collisioni
//
// Modifiche : 26.03.26 RE Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkCAvSimpleSurfFrMove.h"
//----------------------- Macro per import/export ----------------------------
#undef EGK_EXPORT
#if defined( I_AM_EGK) // da definirsi solo nella DLL
#define EGK_EXPORT __declspec( dllexport)
#else
#define EGK_EXPORT __declspec( dllimport)
#endif
//----------------------------------------------------------------------------
class CAvSurfFrMove
{
public :
EGK_EXPORT CAvSurfFrMove( const ISurfFlatRegion& SfrM, const ISurfFlatRegion& SfrF) ;
public :
EGK_EXPORT bool Translate( const Vector3d& vtDir, double& dLen) ;
EGK_EXPORT bool Rotate( const Point3d& ptCen, double& dAng) ;
EGK_EXPORT const SCollInfo& GetCollInfo()
{ return m_CollInfo ; }
private :
const ISurfFlatRegion* m_pRegM ;
const ISurfFlatRegion* m_pRegF ;
SCollInfo m_CollInfo ;
} ;
EGkCAvToolSurfTm.h
+2 -12
View File
@@ -23,8 +23,6 @@
#define EGK_EXPORT __declspec( dllimport)
#endif
class ICurveComposite ;
//-----------------------------------------------------------------------------
class __declspec( novtable) ICAvToolSurfTm {
public :
@@ -37,17 +35,9 @@ class __declspec( novtable) ICAvToolSurfTm {
virtual bool SetGenTool( const ICurveComposite* pToolOutline) = 0 ;
virtual double GetToolRadius( void) const = 0 ;
virtual double GetToolHeight( void) const = 0 ;
virtual double GetToolTipHeight( void) const = 0 ;
virtual double GetToolTipRadius( void) const = 0 ;
virtual double GetToolCornRadius( 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 TestPositionAdv( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
double& dTotDist, VCT3DVECTOR& vVtN) const = 0 ;
virtual bool TestSeries( PNTUVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff = 1) = 0 ;
virtual bool TestSeriesAdv( PNTUVVECTVECTOR& 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 ;
} ;
//-----------------------------------------------------------------------------
EGkCDeClosedSurfTmClosedSurfTm.h
+1 -2
View File
@@ -33,6 +33,5 @@ EGK_EXPORT bool CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const IS
//----------------------------------------------------------------------------
// Verifica l'interferenza tra le due superfici : restituisce true in caso di interferenza.
// Se richiesta verifica inclusione se una delle due è chiusa controlla l'inclusione dell'altra.
//----------------------------------------------------------------------------
EGK_EXPORT bool TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist, bool bTestEnclosion = false) ;
EGK_EXPORT bool TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist) ;
EGkCalcPocketing.h
+2 -70
View File
@@ -25,75 +25,7 @@
#endif
//-----------------------------------------------------------------------------
// Per calcolo percorso di Svuotatura o di Lucidatura
EGK_EXPORT bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadialOffs, double dStep,
double dAngle, double dOpenMinSafe, int nType, bool bSmooth, bool bCalcUnclReg, bool bInvert, bool bAvoidOpt,
bool bConventionalMilling, bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec,
const ISurfFlatRegion* pSfrLimit, bool bAllOffs, double dMaxOptSize,
int nLiType, double dLiTang, double dLiElev, int nLoType, double dLoTang,
bool bPolishing, double dEpicyclesRad, double dEpicyclesDist, ICRVCOMPOPOVECTOR& vCrv) ;
EGK_EXPORT bool IsPocketingHole( const ISurfFlatRegion* pSfr, double dRad, double dRadialOffs, double dStep, int nType,
int nLiType, double dLiTang, double dRatioSfrTool) ;
EGK_EXPORT bool CalcSmoothCurve( ICurveComposite* pCrv, double dRightLen, double dLeftLen, bool bAsParam) ;
EGK_EXPORT bool 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) ;
//-----------------------------------------------------------------------------
// Sottotipo di lavorazione
enum { POCKET_ZIGZAG = 0,
POCKET_ONEWAY = 1,
POCKET_SPIRALIN = 2,
POCKET_SPIRALOUT = 3,
POCKET_CONFORMAL_ZIGZAG = 4,
POCKET_CONFORMAL_ONEWAY = 5
} ;
// Definizione di lato aperto e lato chiuso
enum {
TEMP_PROP_CLOSE_EDGE = 0,
TEMP_PROP_OPEN_EDGE = 1,
TEMP_PROP_OPEN_EDGE_IN_RAW = 2
} ;
// Definizione di curva invalida
enum {
TEMP_PROP_INVALID = - 1
} ;
// Definizione curva di raccordo per smussi
enum {
TEMP_PROP_SMOOTH = - 2
} ;
// Definizione tipo di curva per casi speciali
enum {
TEMP_PROP_SINGLE_CURVE = - 3,
TEMP_PROP_OPT_TRAPEZOID = - 4,
TEMP_PROP_BORDER_CURVE = - 5,
TEMP_PROP_OPT_CIRCLE = - 9
} ;
// Definizione tipo di curva per entrate da fuori
enum {
TEMP_PROP_OUT_START = - 6
} ;
// Definizione di curva attiva/non attiva
enum {
TEMP_PROP_CURVE_ACTIVE = - 7,
TEMP_PROP_CURVE_INACTIVE = - 8
} ;
// Definizione tipo LeadIn
enum {
LEAD_IN_NONE = 0,
LEAD_IN_GLIDE = 1,
LEAD_IN_ZIGZAG = 2,
LEAD_IN_HELIX = 3
} ;
// Definizione tipo LeadOut
enum {
LEAD_OUT_NONE = 0,
LEAD_OUT_GLIDE = 1
} ;
EGkCurve.h
+1 -1
View File
@@ -80,7 +80,7 @@ class __declspec( novtable) ICurve : public IGeoObj
virtual bool ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA) const = 0 ;
virtual ICurve* CopyParamRange( double dUStart, double dUEnd) const = 0 ;
virtual bool Invert( void) = 0 ;
virtual bool SimpleOffset( double dDist, int nType = OFF_FILLET, double dMaxAngExt = ANG_RIGHT) = 0 ;
virtual bool SimpleOffset( double dDist, int nType = OFF_FILLET) = 0 ;
virtual bool SetExtrusion( const Vector3d& vtExtr) = 0 ;
virtual bool SetThickness( double dThick) = 0 ;
virtual bool ModifyStart( const Point3d& ptNewStart) = 0 ;
EGkCurveArc.h
+1 -1
View File
@@ -55,7 +55,7 @@ class __declspec( novtable) ICurveArc : public ICurve
virtual bool ChangeDeltaN( double dNewDeltaN) = 0 ;
virtual bool ChangeAngCenter( double dNewAngCenDeg) = 0 ;
virtual bool ChangeStartPoint( double dU) = 0 ;
virtual bool ExtendedOffset( double dDist) = 0 ;
virtual bool ExtendedOffset( double dDist, int nType = OFF_FILLET) = 0 ;
virtual bool ToExplementary( void) = 0 ;
virtual bool Flip( void) = 0 ;
} ;
EGkCurveAux.h
+6 -85
View File
@@ -15,10 +15,6 @@
#include "/EgtDev/Include/EGkCurveComposite.h"
class ICurveBezier ;
class ICurveLine ;
class ICurveArc ;
class ICurveComposite ;
//----------------------- Macro per import/export ----------------------------
#undef EGK_EXPORT
@@ -45,56 +41,12 @@ struct CNurbsData
CNurbsData( void) : nDeg( 0), bRat( false), bPeriodic( false), bClosed( false), bClamped( true), bExtraKnotes(false) {}
} ;
// N.B. : in caso la curva sia razionale i punti di controllo sono in forma NON OMOGENEA [ x, y, z, w] ( dove la forma OMOGENEA � [ w*x, w*y, w*z, w])
// N.B. : in caso la curva sia razionale i punti di controllo sono in forma NON OMOGENEA [ x, y, z, w] ( dove la forma OMOGENEA è [ w*x, w*y, w*z, w])
// tutte le operazioni richiedono la forma OMOGENEA, finite le quali posso riportarmi alla forma NON OMOGENEA
//----------------------------------------------------------------------------
//! Trasforma una curva in una nuova curva di Bezier semplice
EGK_EXPORT ICurve* CurveToBezierCurve( const ICurve* pCrv, int nDeg = 3, bool bMakeRatOrNot = false) ;
//----------------------------------------------------------------------------
//! Trasforma una linea in una nuova curva di Bezier semplice
EGK_EXPORT ICurveBezier* LineToBezierCurve( const ICurveLine* pCrvLine, int nDeg = 3, bool bMakeRatOrNot = false) ;
//----------------------------------------------------------------------------
//! Trasforma un arco in una nuova curva di Bezier semplice o composta
EGK_EXPORT ICurve* ArcToBezierCurve( const ICurveArc* 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* pCrv, int nDeg = 3, bool bMakeRatOrNot = false) ;
//----------------------------------------------------------------------------
//! Trasforma una curva bezier in una nuova curva di Bezier semplice o composta della razionalit� e grado desiderato ( minimo 3)
EGK_EXPORT ICurve* EditBezierCurve( const ICurveBezier* pCrv, int nDeg = 3, bool bMakeRatOrNot = false, double dTol = 10 * EPS_SMALL) ;
//----------------------------------------------------------------------------
//! Approssima una bezier con una serie di bezier cubiche
EGK_EXPORT ICurve* ApproxBezierWithCubics( const ICurve* pCrv, double dTol) ;
//----------------------------------------------------------------------------
//! Approssima una bezier con una serie di bezier cubiche
EGK_EXPORT ICurveBezier* ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen, const Vector3d& vtN) ;
//----------------------------------------------------------------------------
//! Campiona una serie di punti dalla curva e li approssima con una o pi� curve di bezier
EGK_EXPORT ICurve* ApproxCurveWithBezier( const ICurve* pCrv, double dTol, const Vector3d& vtStart = V_NULL, const Vector3d& vtEnd = V_NULL) ;
//----------------------------------------------------------------------------
//! Interpola un set di punti e li approssima con una o pi� curve di bezier cubiche
EGK_EXPORT ICurve* InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMaxLen) ;
//----------------------------------------------------------------------------
//! 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 CalcApproxError( const ICurve* pCrvOri, const ICurve* 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)
@@ -128,52 +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,
bool bMergeOnlySameProps = true) ;
//----------------------------------------------------------------------------
//! 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) ;
//----------------------------------------------------------------------------
//! Calcola, se possibile, le curve di offset del valore richiesto come curve singole
EGK_EXPORT bool CalcCurveSingleCurvesOffset( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dOffs) ;
//----------------------------------------------------------------------------
//! Calcola, se possibile, le curve di offset dato un vettore di curve aperte/chiuse
EGK_EXPORT bool CalcOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR& vCrvs, double dOffs,
int nType = ICurve::OFF_FILLET) ;
//----------------------------------------------------------------------------
//! Calcola, se possibile, le fat curve di offset dato un vettore di curve aperte/chiuse
EGK_EXPORT bool CalcFatOffsetCurves( const ICURVEPVECTOR& vpCrvs, ICURVEPOVECTOR& vCrvs, double dOffs,
bool bSquareEnds, bool bSquareMids,
bool bMergeOnlySameProps = true) ;
EGK_EXPORT bool CalcCurveFatCurve( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dRadius, bool bSquareEnds, bool bSquareMids) ;
//----------------------------------------------------------------------------
//! Resetta l'oggetto voronoi associato alla curva liberandone la memoria
EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;
//----------------------------------------------------------------------------
//! fa il join delle curve passate in input
EGK_EXPORT bool GetChainedCurves( ICRVCOMPOPOVECTOR& vCrv, double dChainTol = 5 * EPS_SMALL, bool bAllowInvert = false) ;
//----------------------------------------------------------------------------
//! dato un punto su una curva trova il corrispondente sulla seconda curva
EGK_EXPORT bool GetIsoPointOnSecondCurve( const ICurve* pCrv1, const ICurve* pCrv2, double dUCurr1, double& dUCurr2, double dMyDist, double dUPrev2,
double dLenPrev2, double& dLenCurr2, double dLen2) ;
EGK_EXPORT void ResetCurveVoronoi( const ICurve& crvC) ;
EGkCurveBezier.h
-7
View File
@@ -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 ;
} ;
//-----------------------------------------------------------------------------
EGkCurveByInterp.h
+1 -1
View File
@@ -36,7 +36,7 @@ class CurveByInterp
public :
enum METHOD { BESSEL = 1, AKIMA = 2, AKIMA_CORNER = 3} ;
enum TYPE { BIARCS = 1, CUBIC_BEZIERS = 2, CUBIC_BEZIERS_LONG = 3} ;
enum TYPE { BIARCS = 1, CUBIC_BEZIERS = 2} ;
private :
bool CalcAkimaTangents( bool bDetectCorner) ;
EGkCurveComposite.h
+5 -14
View File
@@ -50,7 +50,6 @@ class __declspec( novtable) ICurveComposite : public ICurve
virtual bool AddArcTg( const Point3d& ptNew, bool bEndOrStart = true) = 0 ;
virtual bool AddJoint( double dU) = 0 ;
virtual bool ModifyJoint( int nU, const Point3d& ptNewJoint) = 0 ;
virtual bool ModifyJoint( int nU, const Point3d& ptNewJoint, double dTol) = 0 ;
virtual bool RemoveJoint( int nU) = 0 ;
virtual bool MoveCurve( int nCrv, const Vector3d& vtMove) = 0 ;
virtual bool ModifyCurveToArc( int nCrv, const Point3d& ptMid) = 0 ;
@@ -71,8 +70,8 @@ class __declspec( novtable) ICurveComposite : public ICurve
virtual bool GetCurveTempProp( int nCrv, int& nProp, int nPropInd = 0) const = 0 ;
virtual bool SetCurveTempParam( int nCrv, double dParam, int nParamInd = 0) = 0 ;
virtual bool GetCurveTempParam( int nCrv, double& dParam, int nParamInd = 0) const = 0 ;
virtual bool FromPoint( Point3d& ptStart) = 0 ;
virtual bool GetOnlyPoint( Point3d& ptStart) const = 0 ;
virtual bool ReplaceSingleCurve( int nSubCrv, ICurve* pNewCurve, double dTolStartEnd, double dTolAlong = INFINITO) = 0 ;
} ;
//-----------------------------------------------------------------------------
@@ -95,16 +94,10 @@ inline ICurveComposite* ConvertCurveToComposite( IGeoObj* pGObj)
delete pGObj ;
return nullptr ;
}
ICurveComposite* pCrvCo = GetCurveComposite( pGObj) ;
if ( pCrvCo != nullptr) {
return pCrvCo ;
}
else {
pCrvCo = CreateCurveComposite() ;
if ( pCrvCo == nullptr) {
delete pGObj ;
return nullptr ;
}
ICurveComposite* pCrvCo = CreateCurveComposite() ;
if ( pCrvCo == nullptr) {
delete pGObj ;
return nullptr ;
}
ICurve* pCrv = static_cast<ICurve*>( pGObj) ;
Vector3d vtExtr ;
@@ -117,8 +110,6 @@ inline ICurveComposite* ConvertCurveToComposite( IGeoObj* pGObj)
int nProp = pCrv->GetTempProp( i) ;
if ( nProp != 0)
pCrvCo->SetTempProp( nProp, i) ;
double dParam = pCrv->GetTempParam( i) ;
pCrvCo->SetTempParam( dParam, i) ;
}
pCrvCo->AddCurve( pCrv) ;
return pCrvCo ;
EGkCurveLocal.h
+2 -2
View File
@@ -23,7 +23,7 @@ class CurveLocal
CurveLocal( IGeomDB* pGeomDB, int nCrvId, const Frame3d& frLoc)
: m_pCrv( nullptr), m_pCopy( nullptr)
{ // verifica dei parametri
if ( pGeomDB == nullptr)
if ( pGeomDB == nullptr || &frLoc == nullptr)
return ;
// recupero riferimento della curva
Frame3d frCrv ;
@@ -76,7 +76,7 @@ class CurveLocal
return ;
m_pCrv = m_pCopy ;
}
CurveLocal( CurveLocal&& Other) noexcept
CurveLocal( CurveLocal&& Other)
: m_pCrv( Other.m_pCrv), m_pCopy( Other.m_pCopy)
{ // annullo gli originali
Other.m_pCrv = nullptr ;
EGkCurvePointDiffGeom.h
+1 -2
View File
@@ -40,8 +40,7 @@ class CrvPointDiffGeom
double dCurv ;
public :
CrvPointDiffGeom( void)
: nStatus( NONE), nFlag( STD), dU( -1), dCurv( -1) {}
CrvPointDiffGeom( void) { nStatus = NONE ; nFlag = STD ; }
} ;
//----------------------------------------------------------------------------
EGkDistLineLine.h
-60
View File
@@ -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 ;
} ;
EGkDistPointCurve.h
+5 -4
View File
@@ -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.
//
//
@@ -63,11 +63,12 @@ class DistPointCurve
EGK_EXPORT bool GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFlag) const ;
EGK_EXPORT bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const ;
EGK_EXPORT bool GetParamAtMinDistPoint( double dNearParam, double& dParam, int& nFlag) const ;
EGK_EXPORT bool GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide, double dTol = EPS_SMALL) const ;
EGK_EXPORT bool GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide, double dTol = EPS_SMALL) const ;
EGK_EXPORT bool GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide) const ;
EGK_EXPORT bool GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide) const ;
EGK_EXPORT bool GetMinDistInfo( int nInd, MinDistPCInfo& aInfo) const ;
private :
DistPointCurve( void) ;
void LineCalculate( const Point3d& ptP, const ICurve& Curve, bool bIsSegment) ;
void ArcCalculate( const Point3d& ptP, const ICurve& Curve) ;
void CrvBezierCalculate( const Point3d& ptP, const ICurve& Curve) ;
EGkDistPointLine.h
-65
View File
@@ -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 ;
} ;
EGkDistPointSurfBz.h
-67
View File
@@ -1,67 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2018-2023
//----------------------------------------------------------------------------
// File : EgkDistPointSurfBz.cpp Data : 29.10.25 Versione : 2.7j3
// Contenuto : Dichiarazione della classe distanza Punto da superficie di Bezier.
//
//
//
// Modifiche : 29.10.25 DB Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkSurfBezier.h"
//----------------------- Macro per import/export ----------------------------
#undef EGK_EXPORT
#if defined( I_AM_EGK) // da definirsi solo nella DLL
#define EGK_EXPORT __declspec( dllexport)
#else
#define EGK_EXPORT __declspec( dllimport)
#endif
//----------------------------------------------------------------------------
// Calcola la distanza tra punto e superficie bezier.
// Risultati :
// - distanza
// - punto sulla superficie a minima distanza
// - corrispettivo punto nello spazio parametrico
// - normale alla superficie in quel 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 )
//----------------------------------------------------------------------------
class DistPointSurfBz
{
public :
EGK_EXPORT DistPointSurfBz( const Point3d& ptP, const ISurfBezier& srfBz) ;
public :
EGK_EXPORT bool GetDist( double& dDist) const ;
EGK_EXPORT bool IsEpsilon( double dTol) const
{ return ( m_dDist >= 0. && ( m_dDist < EPS_ZERO || m_dDist < dTol)) ; }
EGK_EXPORT bool IsSmall( void) const
{ return IsEpsilon( EPS_SMALL) ; }
EGK_EXPORT bool IsZero( void) const
{ return IsEpsilon( EPS_ZERO) ; }
EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDistPoint) const ;
EGK_EXPORT bool GetParamsAtMinDistPoint( double& dU, double& dV) const ;
EGK_EXPORT bool GetNorm( Vector3d& vtN) const ;
EGK_EXPORT bool IsPointInside( void) const
{ return ( m_bIsInside && m_bIsSurfClosed) ; }
EGK_EXPORT bool IsPointOnLeftSide( void) const
{ return m_bIsInside ;}
private :
void Calculate( const Point3d& ptP, const ISurfBezier& srfBz) ;
private :
double m_dDist ; // Minima distanza del punto dalla superficie
Point3d m_ptMinDistPoint ; // Punto sulla superficie a minima distanza
Point3d m_ptParam ; // punto corrispondente nello spazio parametrico (x->U, y->V)
Vector3d m_vtN ; // normale alla superficie nel punto a minima distanza
bool m_bIsInside ; // Flag per punto interno o esterno alla superficie ( se chiusa )
bool m_bIsSurfClosed ; // Flag per superficie aperta o chiusa
} ;
EGkDistPointSurfFr.h
-72
View File
@@ -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) ;}
EGkDistPointSurfTm.h
+6 -12
View File
@@ -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
{
@@ -47,22 +46,17 @@ class DistPointSurfTm
{ return IsEpsilon( EPS_ZERO) ; }
EGK_EXPORT bool GetMinDistPoint( Point3d& ptMinDistPoint) const ;
EGK_EXPORT bool GetMinDistTriaIndex( int& nMinDistTriaIndex) const ;
EGK_EXPORT bool GetMinDistTriaIndices( INTVECTOR& vMinDistTriaIndex) 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) ;
private :
double m_dDist ; // Minima distanza del punto dalla superficie
Point3d m_ptMinDistPoint ; // Punto sulla superficie a minima distanza
int m_nMinDistTriaIndex ; // Triangolo utilizzato per calcolare il punto a minima distanza
INTVECTOR m_vnMinDistTriaIndex ; // Indici dei triangoli a minima distanza
bool m_bIsInside ; // Flag per punto interno o esterno alla superficie ( se chiusa )
bool m_bIsSurfClosed ; // Flag per superficie aperta o chiusa
double m_dDist ;
Point3d m_ptMinDistPoint ;
int m_nMinDistTriaIndex ;
bool m_bIsInside ;
} ;
//----------------------------------------------------------------------------
EGkDllMain.h
+3 -6
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2025
// EgalTech 2014-2020
//----------------------------------------------------------------------------
// File : EGkDllMain.h Data : 11.09.25 Versione : 2.7i2
// File : EGkDllMain.h Data : 19.09.20 Versione : 2.2i2
// Contenuto : Prototipi funzioni generali della DLL.
//
//
@@ -9,7 +9,6 @@
// Modifiche : 21.11.13 DS Creazione modulo.
// 13.01.15 DS Agg. funzioni Get sui font.
// 19.09.20 DS Agg. funzione SetEGkDebugLev.
// 11.09.25 DS Agg. funzione SetDefaultFont.
//
//----------------------------------------------------------------------------
@@ -43,11 +42,9 @@ EGK_EXPORT void SetEGkKeyType( int nType) ;
EGK_EXPORT void SetEGkNetHwKey( bool bNetHwKey) ;
// permette di inizializzare il font manager
EGK_EXPORT void InitFontManager( const std::string& sNfeFontDir, const std::string& sDefaultFont) ;
// imposta il font di default
EGK_EXPORT void SetDefaultFont( const std::string& sDefaultFont) ;
// restituisce il direttorio dei font proprietari (Nfe)
EGK_EXPORT const std::string& GetNfeFontDir( void) ;
// restituisce il nome del font di default
EGK_EXPORT const std::string& GetDefaultFont( void) ;
// imposto il gestore eventi
EGK_EXPORT bool SetEGkProcessEvents( psfProcEvents pFun) ;
EGK_EXPORT bool SetEGkProcessEvents( pfProcEvents pFun) ;
EGkFrame3d.h
+1 -12
View File
@@ -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) ;
EGkGdbConst.h
+2 -4
View File
@@ -34,8 +34,7 @@ enum GdbInsPos { GDB_FIRST_SON = 0,
//----------------- Costanti tipo salvataggio del DB geometrico ----------------
enum GdbSave { GDB_SV_TXT = 0,
GDB_SV_BIN = 1,
GDB_SV_CMPTXT = 2,
GDB_SV_CMPBIN = 3} ;
GDB_SV_CMPTXT = 2} ;
//----------------- Costanti tipo oggetti del DB geometrico --------------------
enum GdbType { GDB_TY_NONE = 0,
@@ -59,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 ;
EGkGdbFunct.h
+1 -1
View File
@@ -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
EGkGdbIterator.h
+1 -1
View File
@@ -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 ;
EGkGeoCollection.h
-12
View File
@@ -70,15 +70,3 @@ typedef std::vector<std::pair<BBox3d,int>> BOXIVECTOR ; // vettore di boundin
typedef std::pair<Point3d,Vector3d> PNTVECT ; // coppia punto, vettore
typedef std::vector<PNTVECT> PNTVECTVECTOR ; // vettore di coppie punto, vettore
typedef std::list<PNTVECT> PNTVECTLIST ; // lista di coppie punto, vettore
//----------------------------------------------------------------------------
// Raccolte di coppie Point3d,Bool
typedef std::pair<Point3d, bool> PNTBOOL ; // coppia punto, bool
typedef std::vector<PNTBOOL> PNTBOOLVECTOR ; // vettore di coppie punto, bool
typedef std::list<PNTBOOL> PNTBOOLLIST ; // lista di coppie punto, bool
//----------------------------------------------------------------------------
// Raccolte di triplette Point3d,dU,vector<Vector3d>
typedef std::tuple<Point3d, double, VCT3DVECTOR> PNTUVVECT ; // tripletta punto, parametro, vettore di Vector3d
typedef std::vector<PNTUVVECT> PNTUVVECTVECTOR ; // vettore di triplette punto, parametro, vettore di Vector3d
typedef std::list<PNTUVVECT> PNTUVVECTLIST ; // lista di triplette punto, parametro, vettore di Vector3d
EGkGeoConst.h
+2 -6
View File
@@ -1,14 +1,13 @@
//----------------------------------------------------------------------------
// EgalTech 2013-2025
// EgalTech 2013-2019
//----------------------------------------------------------------------------
// File : EGkGeoConst.h Data : 22.11.25 Versione : 2.7k4
// File : EGkGeoConst.h Data : 23.11.19 Versione : 2.1k5
// Contenuto : Costanti generali per calcoli geometrici.
//
//
//
// Modifiche : 04.01.12 DS Creazione modulo.
// 23.11.19 DS Aggiunta costante EPS_TRIA_H.
// 22.11.25 DS Aggiunta costante PREC_SCALE_COEFF.
//
//----------------------------------------------------------------------------
@@ -60,6 +59,3 @@ const double SQRT2 = 1.41421356237309504880 ;
const double SQRT1_2 = 1 / SQRT2 ;
const double SQRT3 = 1.73205080756887729353 ;
const double SQRT1_3 = 1 / SQRT3 ;
// coefficiente di scalatura per aumentare precisione dei calcoli
const double PREC_SCALE_COEFF = 1024 ;
EGkGeoObjSave.h
+2 -180
View File
@@ -15,14 +15,13 @@
#include "/EgtDev/Include/EGkGeomDB.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
//----------------------------------------------------------------------------
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
@@ -48,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 ;
}
@@ -75,182 +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[i].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 SaveSfrBooleans( const ISurfFlatRegion* pSfrA, const ISurfFlatRegion* pSfrB,
const std::string& sFile, int nFlag = GDB_SV_BIN,
Color cColA = Color( 0., .5, .75, .5), Color cColB = Color( 0., .5, 0., .5))
{
// verifico validità superfici
if ( pSfrA == nullptr || ! pSfrA->IsValid() ||
pSfrB == nullptr || ! pSfrB->IsValid())
return false ;
// creo GeomDB temporaneo
PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
if ( IsNull( pGeomDB))
return false ;
// inserisco le superfici nel GeomDB (sotto pezzo/layer)
int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
int nIdSfrA = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, static_cast<IGeoObj*>( CloneSurfFlatRegion( pSfrA))) ;
if ( nIdSfrA == GDB_ID_NULL)
return false ;
pGeomDB->SetMaterial( nIdSfrA, cColA) ;
int nIdSfrB = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, static_cast<IGeoObj*>( CloneSurfFlatRegion( pSfrB))) ;
if ( nIdSfrB == GDB_ID_NULL)
return false ;
pGeomDB->SetMaterial( nIdSfrB, cColB) ;
// vettor di indici aggiunti
INTVECTOR vIds = { nIdSfrA, nIdSfrB} ;
// 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
SaveGeoObj( std::vector<std::vector<IGeoObj*>> vvpGObj, std::vector<std::vector<Color>> vvCol,
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 ;
}
}
// creo GeomDB temporaneo
PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
if ( IsNull( pGeomDB))
return false ;
INTVECTOR vIds ;
// 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
int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
for ( int j = 0 ; j < int( vvpGObj[i].size()) ; ++ j ) {
// inserisco gli oggetti corrispondenti
int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vvpGObj[i][j]) ;
if ( nId == GDB_ID_NULL)
return false ;
// setto il colore ( se definito)
if ( i < int( vvCol.size()) && j < int( vvCol[i].size()))
pGeomDB->SetMaterial( nId, vvCol[i][j]) ;
vIds.push_back( nId) ;
}
}
// 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
SaveGeoObj( std::vector<IGeoObj*> vpGObj, std::vector<Color> vCol,
const std::string& sFile, int nFlag = GDB_SV_BIN)
{
// verifico validità oggetti
if ( int( vpGObj.size()) != int( vCol.size()))
return false ;
// creo GeomDB temporaneo
PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
if ( IsNull( pGeomDB))
return false ;
INTVECTOR vIds ;
// creo il part
int nPartId = pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
// creo il layer
int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
// scorro gli elementi da visualizzare
for ( int i = 0 ; i < int( vpGObj.size()) ; ++ i) {
if ( vpGObj[i] == nullptr || ! vpGObj[i]->IsValid())
continue ;
// inserisco gli oggetti corrispondenti
int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, vpGObj[i]) ;
if ( nId == GDB_ID_NULL)
return false ;
// setto il colore
pGeomDB->SetMaterial( nId, vCol[i]) ;
// aggiungo l'Id ottenuto
vIds.push_back( nId) ;
}
// 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 ;
}
EGkGeomDB.h
+1 -1
View File
@@ -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 ;
EGkHashGrids1d.h
+3 -3
View File
@@ -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) ;
EGkHashGrids2d.h
+3 -3
View File
@@ -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) ;
EGkHashGrids3d.h
+3 -3
View File
@@ -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) ;
EGkIntersCurvePlane.h
-109
View File
@@ -1,109 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2025
//----------------------------------------------------------------------------
// File : EGkIntersCurvePlane.h Data : 07.11.25 Versione : 2.7k1
// Contenuto : Dichiarazione della classe intersezione curva-piano.
//
//
//
// Modifiche : 07.11.25 DB Creazione modulo.
//
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkPoint3d.h"
#include "/EgtDev/Include/EGkCurve.h"
#include "/EgtDev/Include/EGkIntersCurves.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
//-----------------------------------------------------------------------------
// Tipo di intersezione
// nulla
// puntiforme
// sovrapposizione
// Costanti per tipo di approccio/allontanamento dall'intersezione
const int ICPT_NULL = 0 ; //!< Approccio/allontanamento non definito
const int ICPT_IN = 1 ; //!< Approccio/allontanamento interno
const int ICPT_OUT = 2 ; //!< Approccio/allontanamento esterno
const int ICPT_ON = 3 ; //!< Approccio/allontanamento sovrapposto
//! dati di intersezione tra una curva e un piano
struct IntCrvPlnInfo {
bool bOverlap ; //!< intersezione con overlap
IntCrvInfo Ici[2] ; //!< Ici[0] intersez. isolata o inizio overlap, Ici[1] fine overlap
// costruttore
IntCrvPlnInfo( void)
: bOverlap( false) {}
} ;
//! vettore di IntCrvPlnInfo
typedef std::vector<IntCrvPlnInfo> ICPIVECTOR ;
//-----------------------------------------------------------------------------
//! Classificazione di parti di curva rispetto ad un piano
struct CrvPlaneClass {
double dParS ;
double dParE ;
int nClass ;
// costruttori
CrvPlaneClass( void)
: dParS( 0), dParE( 0), nClass( 0) {}
CrvPlaneClass( double dPS, double dPE, int nC)
: dParS( dPS), dParE( dPE), nClass( nC) {}
} ;
//! Vettore di CrvPlaneClass
typedef std::vector<CrvPlaneClass> CRVPLNCVECTOR ;
//-----------------------------------------------------------------------------
// Costanti per classe parti di curva rispetto ad un piano
const int CRVPLN_NULL = 0 ; //!< Parte di curva non classificabile
const int CRVPLN_IN = 1 ; //!< Parte di curva interna ( dal lato negativo della normale)
const int CRVPLN_OUT = 2 ; //!< Parte di curva esterna ( dal lato positivo della normale)
const int CRVPLN_ON = 3 ; //!< Parte di curva sovrapposta al piano
//-----------------------------------------------------------------------------
//! Classe per calcolo intersezione tra una curve e un piano, nel riferimento locale del piano
class IntersCurvePlane
{
public :
//! Le intersezioni sono calcolate nel piano XY locale.<br>
EGK_EXPORT IntersCurvePlane( const ICurve& CurveA, const Point3d& ptOrig, const Vector3d& vtN) ;
public :
//! Indica la presenza di intersezioni con sovrapposizioni
EGK_EXPORT bool GetOverlaps( void) ;
//! Restituisce il numero di intersezioni (intersezioni doppie coincidenti e sovrapposte contano uno)
EGK_EXPORT int GetIntersCount( void) ;
//! Restituisce informazioni sull'intersezione di indice nInd ( 0 based)
EGK_EXPORT bool GetIntCrvPlnInfo( int nInd, IntCrvPlnInfo& aInfo) ;
//! Restituisce il punto di intersezione più vicino al punto passato
EGK_EXPORT bool GetIntersPointNearTo( const Point3d& ptNear, Point3d& ptI, double& dParam) ;
//! Restituisce la classificazione di una curva rispetto al piano
EGK_EXPORT bool GetCurveClassification( double dLenMin, CRVPLNCVECTOR& ccClass) ;
private :
IntersCurvePlane( void) ;
bool CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Curve, int nCrv = 0) ;
bool IsArcToApprox( const ICurve& Curve) ;
bool AdjustIntersParams( bool bAdjCrv) ;
bool CalcCurveClassification( const ICurve* pCurve, const ICPIVECTOR& Info, double dLenMin, CRVPLNCVECTOR& ccClass) ;
bool CalcCurveInOrOut( const ICurve* pCurve, CRVPLNCVECTOR& ccClass) ;
void OrderAndCompleteIntersections() ;
private :
int m_nIntersType ;
int m_nIntersCount ;
ICPIVECTOR m_Info ;
const ICurve* m_pCurve ; // puntatore alla curva
Plane3d m_plPlane ;
} ;
EGkIntersCurves.h
+1 -5
View File
@@ -44,7 +44,7 @@ struct IntCrvCrvInfo {
IntCrvInfo IciB[2] ; //!< IciB[0] intersez. isolata o inizio overlap, IciB[1] fine overlap
// costruttore
IntCrvCrvInfo( void)
: bOverlap( false), bCBOverEq( false) {}
: bOverlap( false) {}
} ;
//! vettore di IntCrvCrvInfo
typedef std::vector<IntCrvCrvInfo> ICCIVECTOR ;
@@ -115,16 +115,12 @@ class IntersCurveCurve
EGK_EXPORT bool GetOverlaps( void) ;
//! Restituisce il numero di intersezioni (intersezioni doppie coincidenti e sovrapposte contano uno)
EGK_EXPORT int GetIntersCount( void) ;
//! Restituisce il numero di intersezioni in 3D ( filtrando le intersezioni)
EGK_EXPORT int GetInters3DCount( void) ;
//! Restituisce il numero di intersezioni in cui la curva si attraversa
EGK_EXPORT int GetCrossIntersCount( void) ;
//! Restituisce il numero di intersezioni in cui la curva si attraversa o si sovrappone
EGK_EXPORT int GetCrossOrOverlapIntersCount( void) ;
//! Restituisce informazioni sull'intersezione di indice nInd ( 0 based)
EGK_EXPORT bool GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
//! Restituisce informazioni sulla i-esima intersezione 3D ( 0 based)
EGK_EXPORT bool GetInt3DCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
//! Restituisce il punto di intersezione più vicino al punto passato
EGK_EXPORT bool GetIntersPointNearTo( int nCrv, const Point3d& ptNear, Point3d& ptI) ;
//! Restituisce la classificazione di una curva rispetto all'altra ( nCrv=0 -> CurvaA, nCrv=1 -> CurvaB)
EGkIntersLineBox.h
+2 -4
View File
@@ -32,11 +32,9 @@ EGK_EXPORT bool IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double d
//-----------------------------------------------------------------------------
// Tipo di intersezione linea-box
enum IntLineBoxType { ILBT_NONE = 0, // non è intersezione
enum IntLineBoxType { ILBT_NONE = 0, // non è intersezione
ILBT_IN = 1, // ingresso nel box
ILBT_OUT = 2, // uscita dal box
ILBT_TG_INI = 3, // ingresso tangente in una faccia del box
ILBT_TG_FIN = 4, // uscita tangente da una faccia del box
ILBT_TOUCH = 5, // contatto su uno spigolo o su un vertice del box
ILBT_INSIDE = 6, // contenimento nel box
ILBT_TG_INSIDE = 7} ; // contenimento su faccia del box
ILBT_TOUCH = 5} ; // contatto su uno spigolo o su un vertice del box
EGkIntersLineSurfBez.h
+22 -32
View File
@@ -26,6 +26,28 @@
#define EGK_EXPORT __declspec( dllimport)
#endif
//-----------------------------------------------------------------------------
//! dati di intersezione linea - superficie trimesh
struct IntLinSbzInfo {
int nILTT ; //!< tipo di intersezione linea-triangolo
double dU ; //!< parametro sulla linea
double dU2 ; //!< secondo parametro sulla linea
int nT ; //!< indice del triangolo della superficie trimesh
double dCosDN ; //!< coseno dell'angolo tra la direzione della linea e la normale del triangolo
Point3d ptI ; //!< punto di intersezione
Point3d ptI2 ; //!< secondo punto di intersezione (termine di tratto sovrapposto)
Point3d ptUV ; //!< coordinate del punto nello spazio parametrico
Point3d ptUV2 ; //!< coordinate del secondo punto nello spazio parametrico
// costruttori
IntLinSbzInfo( void) : nILTT( ILTT_NO), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2(), ptUV(), ptUV2(){}
IntLinSbzInfo( int nIL, double dUU, int nTT, double dCos, const Point3d& ptP, const Point3d ptSP)
: nILTT( nIL), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2(), ptUV( ptSP), ptUV2() {}
IntLinSbzInfo( int nIL, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2, const Point3d& ptSP, const Point3d& ptSP2)
: nILTT( nIL), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2), ptUV( ptSP), ptUV2( ptSP2) {}
} ;
//! vettore di IntLinSbzInfo
typedef std::vector<IntLinSbzInfo> ILSBIVECTOR ;
//-----------------------------------------------------------------------------
// Costanti tipo intersezione Linea SurfTriMesh dopo filtraggio
enum LSBiType { LSBT_NONE = 0,
@@ -35,38 +57,6 @@ enum LSBiType { LSBT_NONE = 0,
LSBT_TG_FIN = 4,
LSBT_TOUCH = 5} ;
//-----------------------------------------------------------------------------
// Tipo di intersezione linea-triangolo ausiliario (della trimesh ausilaria)
enum IntLineTriaAuxType { ILTA_NO_TRIA = -1, // l'intersezione è stata calcolata direttamente con la superficie bezier
ILTA_NO = 0, // non c'è intersezione
ILTA_SEGM = 1, // una parte di linea appartiene all'interno del triangolo
ILTA_SEGM_ON_EDGE = 2, // una parte di linea appartiene ad un lato del triangolo
ILTA_VERT = 3, // intersezione coincide con un vertice
ILTA_EDGE = 4, // intersezione coincide con interno di un lato
ILTA_IN = 5} ; // intersezione in interno del triangolo
//-----------------------------------------------------------------------------
//! dati di intersezione linea - superficie bezier
struct IntLinSbzInfo {
int nILSB ; //!< tipo di intersezione linea-bezier
double dU ; //!< parametro sulla linea
double dU2 ; //!< secondo parametro sulla linea
int nT ; //!< indice del triangolo della superficie trimesh // se -1 vuol dire che l'intersezione � stata calcolata direttamente, senza usare la trimesh
double dCosDN ; //!< coseno dell'angolo tra la direzione della linea e la normale del triangolo
Point3d ptI ; //!< punto di intersezione
Point3d ptI2 ; //!< secondo punto di intersezione (termine di tratto sovrapposto)
Point3d ptUV ; //!< coordinate del punto nello spazio parametrico
Point3d ptUV2 ; //!< coordinate del secondo punto nello spazio parametrico
// costruttori
IntLinSbzInfo( void) : nILSB( LSBT_NONE), dU( 0), dU2( 0), nT(0), dCosDN(0), ptI(), ptI2(), ptUV(), ptUV2(){}
IntLinSbzInfo( int nILS, double dUU, int nTT, double dCos, const Point3d& ptP, const Point3d ptSP)
: nILSB( nILS), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2(), ptUV( ptSP), ptUV2() {}
IntLinSbzInfo( int nILS, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2, const Point3d& ptSP, const Point3d& ptSP2)
: nILSB( nILS), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2), ptUV( ptSP), ptUV2( ptSP2) {}
} ;
//! vettore di IntLinSbzInfo
typedef std::vector<IntLinSbzInfo> ILSBIVECTOR ;
//-----------------------------------------------------------------------------
EGK_EXPORT bool IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfBezier* pSBz,
ILSBIVECTOR& vInfo, bool bFinite = true) ;
EGkIntersLineSurfTm.h
+9 -15
View File
@@ -31,20 +31,19 @@ struct IntLinStmInfo {
int nILTT ; //!< tipo di intersezione linea-triangolo
double dU ; //!< distanza sulla linea
double dU2 ; //!< seconda distanza sulla linea
int nStm ; //!< indice della superficie TriMesh di intersezione
int nT ; //!< indice del triangolo della superficie trimesh
double dCosDN ; //!< coseno dell'angolo tra la direzione della linea e la normale del triangolo
Point3d ptI ; //!< punto di intersezione
Point3d ptI2 ; //!< secondo punto di intersezione (termine di tratto sovrapposto)
// costruttori
IntLinStmInfo( void) : nILTT( ILTT_NO), dU( 0), dU2( 0), nStm( 0), nT( 0), dCosDN( 0), ptI(), ptI2() {}
IntLinStmInfo( int nIL, double dUU, int nSurfTm, int nTT, double dCos, const Point3d& ptP)
: nILTT( nIL), dU( dUU), dU2( 0), nStm( nSurfTm), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2() {}
IntLinStmInfo( int nIL, double dUU, double dUU2, int nSurfTm, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2)
: nILTT( nIL), dU( dUU), dU2( dUU2), nStm( nSurfTm), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2) {}
IntLinStmInfo( void) : nILTT( ILTT_NO), dU( 0), dU2( 0), nT( 0), dCosDN( 0), ptI(), ptI2() {}
IntLinStmInfo( int nIL, double dUU, int nTT, double dCos, const Point3d& ptP)
: nILTT( nIL), dU( dUU), dU2( 0), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2() {}
IntLinStmInfo( int nIL, double dUU, double dUU2, int nTT, double dCos, const Point3d& ptP, const Point3d& ptP2)
: nILTT( nIL), dU( dUU), dU2( dUU2), nT( nTT), dCosDN( dCos), ptI( ptP), ptI2( ptP2) {}
} ;
//! vettore di IntLinStmInfo
typedef std::vector<IntLinStmInfo> ILSIVECTOR ;
typedef std::vector<IntLinStmInfo> ILSIVECTOR ;
//-----------------------------------------------------------------------------
// Costanti tipo intersezione Linea SurfTriMesh dopo filtraggio
@@ -64,18 +63,13 @@ class IntersParLinesSurfTm
{
public :
EGK_EXPORT IntersParLinesSurfTm( const Frame3d& frLines, const ISurfTriMesh& Stm) ;
EGK_EXPORT IntersParLinesSurfTm( const Frame3d& frLines, const CISURFTMPVECTOR& vStm) ;
EGK_EXPORT bool GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vInfo, bool bFinite = true) const ;
private :
int GetSurfInd( int nT) const ;
private :
bool m_bOk ;
const Frame3d m_frLines ; // direzione della linea come versore Z
CISURFTMPVECTOR m_vpSTm ; // vettore delle superfici con cui calcolare le intersezioni con le linee
INTVECTOR m_vBaseInd ; // [0, nTriaStm0, nTriaStm0 + nTriaStm1, nTriaStm0 + nTriaStm1 + nTriaStm2, ...]
HashGrids2d m_HGrids ; // HasGrid di ottimizzazione per ricerca triangoli
const Frame3d m_frLines ;
const ISurfTriMesh* m_pSTm ;
HashGrids2d m_HGrids ;
} ;
//-----------------------------------------------------------------------------
EGkLuaAux.h
+1 -56
View File
@@ -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,60 +276,6 @@ LuaSetParam( lua_State* L, const Vector3d& vtPar)
return true ;
}
//-------------------------------------------------------------------------------
inline bool
LuaSetParam( lua_State* L, const PNTVECTOR& 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 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)
EGkMultiGeomDB.h
-30
View File
@@ -1,30 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2025-2025
//----------------------------------------------------------------------------
// File : MultiGeomDB.h Data : 22.12.25 Versione : 2.7l3
// Contenuto : Dichiarazione delle funzioni tra due GeomDB.
//
//
//
// Modifiche : 08.10.25 DB Creazione modulo.
// 22.12.25 DS Aggiunta funzione DuplicateGeomDB.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkGeomDB.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 int Copy( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter = GDB_LAST_SON) ;
EGK_EXPORT int CopyGlob( IGeomDB* pSouGeomDB, int nSouId, IGeomDB* pDestGeomDB, int nDestId, int nRefId, int nSonBeforeAfter = GDB_LAST_SON) ;
EGK_EXPORT bool DuplicateGeomDB( IGeomDB* pSouGeomDB, IGeomDB* pDestGeomDB, bool bSkipTemp = false) ;
EGkOffsetCurve.h
+2 -6
View File
@@ -1,13 +1,12 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2025
// EgalTech 2015-2019
//----------------------------------------------------------------------------
// File : EGkOffsetCurve.h Data : 08.04.25 Versione : 2.7d1
// File : EGkOffsetCurve.h Data : 24.06.19 Versione : 2.1f2
// Contenuto : Dichiarazione classe per offset di ICurve.
//
//
// Modifiche : 23.09.15 DS Creazione modulo.
// 24.06.19 DS Agg. GetShorterCurve.
// 08.04.25 SP Agg. GetPointOffset.
//
//----------------------------------------------------------------------------
@@ -38,13 +37,10 @@ class OffsetCurve
EGK_EXPORT ICurve* GetCurve( void) ;
EGK_EXPORT ICurve* GetLongerCurve( void) ;
EGK_EXPORT ICurve* GetShorterCurve( void) ;
EGK_EXPORT bool GetPointOffset( Point3d& ptOffs, Vector3d& vtOut) ;
EGK_EXPORT double GetLinTol( void) const { return m_dLinTol ; }
EGK_EXPORT void SetLinTol( double dTol) { m_dLinTol = dTol ; }
private :
ICURVEPLIST m_CrvLst ;
Point3d m_ptOffs = P_INVALID ;
Vector3d m_vtOut = V_INVALID ;
double m_dLinTol ;
} ;
EGkPlane3d.h
-25
View File
@@ -8,7 +8,6 @@
//
// Modifiche : 08.04.14 DS Creazione modulo.
// 25.02.15 DS Agg. PointInPlane*.
// 05.09.25 RE Agg. funzioni di confronto tra due piani
//
//----------------------------------------------------------------------------
@@ -155,27 +154,3 @@ PointInPlaneExact( const Point3d& ptP, const Plane3d& plPlane)
{
return ( abs( (( ptP - ORIG) * plPlane.GetVersN()) - plPlane.GetDist()) < EPS_ZERO) ;
}
//-----------------------------------------------------------------------------
inline bool
AreSamePlaneEpsilon( const Plane3d& plPlaneA, const Plane3d& plPlaneB, double dToler)
{
return ( AreSameVectorEpsilon( plPlaneA.GetVersN(), plPlaneB.GetVersN(), dToler) &&
PointInPlaneEpsilon( plPlaneA.GetPoint(), plPlaneB, dToler)) ;
}
//-----------------------------------------------------------------------------
inline bool
AreSamePlaneApprox( const Plane3d& plPlaneA, const Plane3d& plPlaneB)
{
return ( AreSameVectorApprox( plPlaneA.GetVersN(), plPlaneB.GetVersN()) &&
PointInPlaneApprox( plPlaneA.GetPoint(), plPlaneB)) ;
}
//-----------------------------------------------------------------------------
inline bool
AreSamePlaneExact( const Plane3d& plPlaneA, const Plane3d& plPlaneB)
{
return ( AreSameVectorExact( plPlaneA.GetVersN(), plPlaneB.GetVersN()) &&
PointInPlaneExact( plPlaneA.GetPoint(), plPlaneB)) ;
}
EGkPoint3d.h
+3 -30
View File
@@ -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) ;
}
//----------------------------------------------------------------------------
EGkPolyLine.h
+1 -9
View File
@@ -108,12 +108,11 @@ class PolyLine
EGK_EXPORT bool GetMaxDistanceFromLine( const Point3d& ptLine, const Vector3d& vtLine, double dLen,
double& dMaxDist, bool bIsSegment = true) const ;
EGK_EXPORT bool AdjustForMaxSegmentLen( double dMaxLen) ;
EGK_EXPORT bool RemoveAlignedPoints( double dToler = EPS_SMALL, bool bStartEnd = true) ;
EGK_EXPORT bool RemoveAlignedPoints( double dToler = EPS_SMALL) ;
EGK_EXPORT bool ApproxOnSide( const Vector3d& vtN, bool bLeftSide, double dToler = EPS_SMALL) ;
EGK_EXPORT bool MakeConvex( const Vector3d& vtN, bool bLeftSide) ;
EGK_EXPORT bool Invert( bool bInvertU = true) ;
EGK_EXPORT bool Flatten( double dZ = 0) ;
EGK_EXPORT bool FlattenInAutoPlane( double dToler = 10 * EPS_SMALL) ;
EGK_EXPORT bool GetConvexHullXY( PNTVECTOR& vConvHull) const ;
EGK_EXPORT bool GetMinAreaRectangleXY( Point3d& ptCen, Vector3d& vtAx, double& dLen, double& dHeight) const ;
EGK_EXPORT bool Trim( const Plane3d& plPlane, bool bInVsOut = true) ;
@@ -122,17 +121,11 @@ class PolyLine
m_nTempProp[nPropInd] = nProp ; }
EGK_EXPORT int GetTempProp( int nPropInd = 0) const
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
EGK_EXPORT bool FromPointVector( const PNTVECTOR& vPnt)
{ Clear() ;
for ( int i = 0 ; i < std::ssize( vPnt) ; ++i)
AddUPoint( i, vPnt[i]) ;
return GetPointNbr() > 0 ; }
private :
bool MyChangeStart( int nPos) ;
bool MyApproxOnSide( const Vector3d& vtN, bool bLeftSide, double dToler = EPS_SMALL) ;
bool MyMakeConvex( const Vector3d& vtN, bool bLeftSide) ;
bool MyRemoveSamePoints( double dToler = EPS_SMALL) ;
private :
int m_nRejected ; // numero punti rifiutati perchè coincidenti
@@ -155,4 +148,3 @@ EGK_EXPORT bool GetPointParamOnPolyLine( const Point3d& ptP, const PolyLine& plP
EGK_EXPORT bool ChangePolyLineStart( PolyLine& plPoly, const Point3d& ptNewStart, double dToler) ;
EGK_EXPORT bool SplitPolyLineAtPoint( const PolyLine& plPoly, const Point3d& ptP, double dToler, PolyLine& plPoly1, PolyLine& plPoly2) ;
EGK_EXPORT bool AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIVECTOR& vPnt1, PNTIVECTOR& vPnt2, bool& bCommonInternalPoints) ;
EGK_EXPORT bool MatchPolyLinesAddingPoints( const PolyLine& PL1, const PolyLine& PL2, int nType, PNTIVECTOR& vPnt1, PNTIVECTOR& vPnt2) ;
EGkProjectCurveSurf.h
-64
View File
@@ -1,64 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2023-2026
//----------------------------------------------------------------------------
// File : EGkProjectCurveSurfTm.h Data : 14.04.26 Versione : 3.1d3
// Contenuto : Dichiarazione funzioni proiezione curve su superficie Trimesh.
//
//
//
// Modifiche : 31.08.23 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkCurve.h"
#include "/EgtDev/Include/EGkSurf.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
//----------------------------------------------------------------------------
// Definizione di Punto 5assi e sue raccolte
struct Point5ax {
Point3d ptP ;
Vector3d vtDir1 ;
Vector3d vtDir2 ;
Vector3d vtDirU ;
Vector3d vtDirV ;
double dPar ;
int nFlag ;
Point5ax( void) : ptP(), vtDir1(), vtDir2(), vtDirU(), vtDirV(), dPar(), nFlag() {} ;
Point5ax( const Point3d& ptBase, const Vector3d& vtTool, double dU, int nData)
: ptP( ptBase), vtDir1( vtTool), vtDir2(), vtDirU(), vtDirV(), dPar( dU), nFlag( nData) {} ;
Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2, double dU, int nData)
: ptP( ptBase), vtDir1( vtTool), vtDir2( vtTool2), vtDirU(), vtDirV(), dPar( dU), nFlag( nData) {} ;
Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2,
const Vector3d& vtDU, const Vector3d& vtDV, double dU, int nData)
: ptP( ptBase), vtDir1( vtTool), vtDir2( vtTool2), vtDirU( vtDU), vtDirV( vtDV), dPar( dU), nFlag( nData) {} ;
} ;
typedef std::vector<Point5ax> PNT5AXVECTOR ; // vettore di Punti 5assi
//----------------------------------------------------------------------------
// Proiezione di una curva su una o più superfici a distanza minima
EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax) ;
// Proiezione di una curva su una o più superfici lungo la direzione data (da o verso)
EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vector3d& vtDir,
double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
// Proiezione di una curva su una o più superfici in direzione del punto (da o verso)
EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeoPoint3d& gpRef,
double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
// Proiezione di una curva su una o più superfici in direzione della curva (da o verso)
EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICurve& crRef,
double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
// Proiezione di una curva su una o più superfici in direzione della superficie (da o verso)
EGK_EXPORT bool ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISurf& sfRef,
double dLinTol, double dMaxSegmLen, bool bSharpEdges, bool bFromVsTo, PNT5AXVECTOR& vPt5ax) ;
EGkProjectCurveSurfTm.h
+53
View File
@@ -0,0 +1,53 @@
//----------------------------------------------------------------------------
// EgalTech 2023-2023
//----------------------------------------------------------------------------
// File : EGkProjectCurveSurfTm.h Data : 31.08.23 Versione : 2.5h3
// Contenuto : Dichiarazione funzioni proiezione curve su superficie Trimesh.
//
//
//
// Modifiche : 31.08.23 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkCurve.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
//----------------------- Macro per import/export ----------------------------
#undef EGK_EXPORT
#if defined( I_AM_EGK) // da definirsi solo nella DLL
#define EGK_EXPORT __declspec( dllexport)
#else
#define EGK_EXPORT __declspec( dllimport)
#endif
//----------------------------------------------------------------------------
// Definizione di Punto 5assi e sue raccolte
struct Point5ax {
Point3d ptP ;
Vector3d vtDir ;
Vector3d vtDir2 ;
double dPar ;
int nFlag ;
Point5ax( void) : ptP(), vtDir(), vtDir2(), dPar(), nFlag() {} ;
Point5ax( const Point3d& ptBase, const Vector3d& vtTool, double dU, int nData)
: ptP( ptBase), vtDir( vtTool), vtDir2(), dPar( dU), nFlag( nData) {} ;
Point5ax( const Point3d& ptBase, const Vector3d& vtTool, const Vector3d& vtTool2, double dU, int nData)
: ptP( ptBase), vtDir( vtTool), vtDir2( vtTool2), dPar( dU), nFlag( nData) {} ;
} ;
typedef std::vector<Point5ax> PNT5AXVECTOR ; // vettore di Punti 5assi
//----------------------------------------------------------------------------
// Proiezione di una curva su una superficie TriMesh lungo la direzione data.
EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir,
double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const IGeoPoint3d& gpRef,
double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ICurve& crRef,
double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
EGK_EXPORT bool ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ISurfTriMesh& tmRef,
double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax) ;
EGkSbzFromCurves.h
-51
View File
@@ -1,51 +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* GetSurfBezierRuledSmooth( const ICurve* pCurve1, const ICurve* pCurve2, BIPNTVECTOR& vSyncLines, double dSampleLen = 10) ;
EGK_EXPORT ISurfBezier* GetSurfBezierRuledGuided( const ICurve* pCurve1, const ICurve* pCurve2, const BIPNTVECTOR& vCrv, double dLinTol = 10 * EPS_SMALL) ;
EGK_EXPORT ISurfBezier* GetSurfBezierSkinned( const CICURVEPVECTOR& vCrv, double dLinTol = 10 * EPS_SMALL) ;
EGK_EXPORT ISurfBezier* GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtNorm, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
EGK_EXPORT ISurfBezier* GetSurfBezierSwept3d( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtNorm, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
EGkSbzStandard.h
+1 -1
View File
@@ -24,4 +24,4 @@
#endif
//----------------------------------------------------------------------------
EGK_EXPORT ISurfBezier* GetSurfBezierSphere( const Point3d& ptCenter, double dR) ;
EGK_EXPORT ISurfBezier* CreateBezierSphere( const Point3d& ptCenter, double dR) ;
EGkSelection.h
-2
View File
@@ -36,8 +36,6 @@ struct SelData {
: nId( nI), nSub( SEL_SUB_ALL) {}
SelData( int nI, int nS)
: nId( nI), nSub( nS) {}
bool operator == ( const SelData& other) const
{ return ( nId == other.nId && nSub == other.nSub) ; }
} ;
//----------------------------------------------------------------------------
EGkSfrCreate.h
+1 -4
View File
@@ -30,14 +30,11 @@ EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionRectangle( double dWidth, double dL
EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionStadium( double dWidth, double dLen) ;
EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionDisk( double dRadius) ;
EGK_EXPORT ISurfFlatRegion* GetSurfFlatRegionFromFatCurve( ICurve* pCrv, double dRadius,
bool bSquareEnds, bool bSquareMids, double dOffsLinTol = 10 * EPS_SMALL,
bool bMergeOnlySameProps = true) ;
bool bSquareEnds, bool bSquareMids, double dOffsLinTol = 10 * EPS_SMALL) ;
// NB : la curva ingrassata non deve autointersecarsi
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
EGkStmStandard.h
+3 -6
View File
@@ -1,13 +1,13 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2024
// EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : EGkStmStandard.h Data : 04.12.24 Versione : 2.6l2
// File : EGkStmStandard.h Data : 31.03.15 Versione : 1.6c7
// Contenuto : Dichiarazione funzioni per creazione superfici Stm
// standard : Box, Pyramid, Cylinder, Sphere, Cone.
//
//
// Modifiche : 31.03.15 DS Creazione modulo.
// 04.12.24 DS Aggiunta GetSurfTriMeshEmpty.
//
//
//----------------------------------------------------------------------------
@@ -24,13 +24,10 @@
#endif
//----------------------------------------------------------------------------
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshEmpty( void) ;
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshBox( double dDimX, double dDimY, double dHeight, bool bRegular = false) ;
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshPyramid( double dDimX, double dDimY, double dHeight) ;
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshCylinder( double dRadius, double dHeight, double dLinTol) ;
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshCone( double dRadius, double dHeight, double dLinTol) ;
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSphere( double dRadius, double dLinTol) ;
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshPyramidFrustum( double dBaseDimX, double dBaseDimY, double dTopDimX, double dTopDimY, double dHeight) ;
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshConeFrustum( double dBaseRad, double dTopRad, double dHeight, double dLinTol) ;
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshPlaneInBox( const Plane3d& plPlane, const BBox3d& b3Box, bool bOnEq = false, bool bOnCt = false) ;
EGkSurfBezier.h
+11 -49
View File
@@ -1,13 +1,13 @@
//----------------------------------------------------------------------------
// EgalTech 2020-2025
// EgalTech 2020-2024
//----------------------------------------------------------------------------
// File : EGkSurfBezier.h Data : 22.08.25 Versione : 2.7h1
// File : EGkSurfBezier.h Data : 10.04.24 Versione : 2.6d2
// Contenuto : Dichiarazione della interfaccia ISurfBezier.
//
//
//
// Modifiche : 22.03.20 DS Creazione modulo.
// 22.08.25 DS Aggiunte funzioni globali di impostazione tolleranze.
//
//
//----------------------------------------------------------------------------
@@ -17,15 +17,6 @@
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EgtPointerOwner.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
//----------------------- Forward --------------------------------------------
class PolyLine ;
class ICurveComposite ;
class ISurfFlatRegion ;
@@ -37,15 +28,6 @@ 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
ISurfBezier* Clone( void) const override = 0 ;
public :
@@ -63,7 +45,6 @@ class __declspec( novtable) ISurfBezier : public ISurf
virtual double GetControlWeight( int nIndU, int nIndV, bool* pbOk) const = 0 ;
virtual double GetControlWeight( int nInd, bool* pbOk) const = 0 ;
virtual bool IsAPoint( void) const = 0 ;
virtual bool GetPoint( double dU, double dV, Side nUs, Side nVs, Point3d& ptPos) const = 0;
virtual bool GetPointD1D2( double dU, double dV, Side nUs, Side nVs,
Point3d& ptPos,
Vector3d* pvtDerU = nullptr, Vector3d* pvtDerV = nullptr,
@@ -74,42 +55,29 @@ class __declspec( novtable) ISurfBezier : public ISurf
Vector3d* pvtDerUU = nullptr, Vector3d* pvtDerVV = nullptr, Vector3d* pvtDerUV = nullptr) const = 0 ;
virtual ICurveComposite* GetCurveOnU( double dV) const = 0 ;
virtual ICurveComposite* GetCurveOnV( double dU) const = 0 ;
virtual ICurveComposite* GetLoop( int nLoop) const = 0 ; // nLoop 0-based (1°esterno, successivi interni)
virtual ICurveComposite* GetLoop( int nLoop) const = 0 ; // nLoop 0-based (1°esterno, successivi interni)
virtual bool GetControlCurveOnU( int nIndV, PolyLine& plCtrlU) const = 0 ;
virtual bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const = 0 ;
virtual const ISurfTriMesh* GetAuxSurf( void) const = 0 ;
virtual const ISurfTriMesh* GetAuxSurfRefined( void) const = 0 ;
virtual ISurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 10 * EPS_SMALL, bool bUpdateEdges = false) const = 0 ;
virtual bool GetLeaves( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves, bool bRefined = false) const = 0 ;
virtual ISurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL) const = 0 ;
virtual bool GetLeaves ( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const = 0 ;
virtual bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const = 0 ;
virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL = 5) const = 0 ;
virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL) const = 0 ;
virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL, const Point3d& ptIPrev, bool* bTroughEdge = nullptr) const = 0 ;
virtual bool UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d& ptIPrev, bool* bTroughEdge = nullptr, const Plane3d* plCut = nullptr) const = 0 ;
virtual bool UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& vpCC, const Plane3d* pPlCut) const = 0 ;
// taglio la parte della superficie dalla parte positiva del versore del piano.
// Il booleano indica se tenere eventuali triangoli della trimesh ausiliaria che sono coplanari ed equiversi al piano di taglio
virtual bool Cut( const Plane3d& plPlane, bool bSaveOnEq) = 0 ;
// funzione da chiamare per calcolare i poli della superficie. NECESSARIO se si vuole tagliare la superficie con un piano
virtual bool CalcPoles( void) ;
virtual bool IncreaseUV( double& dU, double dx, bool bUOrV, double* dUVCopy = nullptr, bool bModifyOrig = true) const = 0 ;
virtual bool IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bModifyOrig) const = 0 ;
virtual bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier) const = 0 ;
virtual ICurveComposite* GetSingleEdge3D( bool bLineOrBezier, int nEdge) 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) = 0 ;
virtual bool CreateByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vector3d& vtAx, double dAngRotDeg, double dMove) = 0 ;
virtual bool CreateByPointCurve( const Point3d& pt, const ICurve* pCurve) = 0 ;
virtual bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) = 0 ;
virtual bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3 = true) = 0 ;
virtual bool RemoveCollapsedSpans() = 0 ;
virtual PNTVECTOR GetAllControlPoints( void) const = 0 ;
virtual bool LimitSurfToTrimmedRegion( void) = 0 ;
virtual bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen) = 0 ;
virtual bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen, BIPNTVECTOR& vSyncLines) = 0 ;
virtual bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const = 0 ;
} ;
//-----------------------------------------------------------------------------
static const double SBZ_TREG_COEFF = PREC_SCALE_COEFF ;
static const double SBZ_TREG_COEFF = 1000 ;
//-----------------------------------------------------------------------------
inline ISurfBezier* CreateSurfBezier( void)
@@ -127,12 +95,6 @@ inline ISurfBezier* GetSurfBezier( IGeoObj* pGObj)
return nullptr ;
return (static_cast<ISurfBezier*>(pGObj)) ; }
//----------------------------------------------------------------------------
EGK_EXPORT void SetSurfBezierAuxSurfTol( double dTol) ;
EGK_EXPORT double GetSurfBezierAuxSurfTol( void) ;
EGK_EXPORT void SetSurfBezierAuxSurfRefinedTol( double dTol) ;
EGK_EXPORT double GetSurfBezierAuxSurfRefinedTol( void) ;
//----------------------------------------------------------------------------
// Raccolte di puntatori a ISurfBezier
typedef std::vector<const ISurfBezier*> CISURFBEZPVECTOR ; // vettore di puntatori a const ISurfBezier
EGkSurfBzRuledFromStmFaces.h
-37
View File
@@ -1,37 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2025-2025
//----------------------------------------------------------------------------
// File : EGkSurfBzRuledFromStmFaces.h Data : 15.09.25 Versione : 2.7j1
// Contenuto : Calcolo di una superficie di Bezier Ruled definita da un sottoinsieme
// di facce di una superficie TriMesh
//
//
//
// Modifiche : 15.09.25 RE Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "EGkSelection.h"
#include "EGkCurveLine.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
//----------------------- Macro per import/export ----------------------------
#undef EGK_EXPORT
#if defined( I_AM_EGK) // da definirsi solo nella DLL
#define EGK_EXPORT __declspec( dllexport)
#else
#define EGK_EXPORT __declspec( dllimport)
#endif
//-----------------------------------------------------------------------------
EGK_EXPORT bool GetBezierEdgeCurvesFromSurfs( const CISURFPVECTOR& vSurf, const SELVECTOR& vSurfFace,
double dLinTol, double dAngTol, const BIPNTVECTOR& vBreakingPts,
ICRVCOMPOPOVECTOR& vBezierEdges) ;
EGK_EXPORT bool GetSyncPointsFromBezierCurves( const ICurveComposite* pEdge0, const ICurveComposite* pEdge1,
ICRVLINEPOVECTOR& vLines) ;
EGK_EXPORT bool GetAdjStmFacesInTol( const ISurfTriMesh* pStm, const INTVECTOR& vFaceRef, double dAngTol,
INTVECTOR& vOtherFaces, double dCurvature) ;
EGkSurfFlatRegion.h
+11 -24
View File
@@ -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,31 +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 = 0 ; // compare only outsides
virtual bool CheckChunkInterference( int nChunk, const ISurfFlatRegion& Other, int nOthChunk, bool& bInterference) const = 0 ;
virtual bool GetChunkMaxOffset( int nChunk, double& dOffs) const = 0 ;
virtual int GetLoopCount( int nChunk) const = 0 ;
virtual int GetLoopCurveCount( int nChunk, int nLoop) const = 0 ;
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 ;
} ;
//-----------------------------------------------------------------------------
EGkSurfLocal.h
+3 -3
View File
@@ -23,7 +23,7 @@ class SurfLocal
SurfLocal( IGeomDB* pGeomDB, int nSrfId, const Frame3d& frLoc)
: m_pSrf( nullptr), m_pCopy( nullptr)
{ // verifica dei parametri
if ( pGeomDB == nullptr)
if ( pGeomDB == nullptr || &frLoc == nullptr)
return ;
// recupero riferimento della superficie
Frame3d frSrf ;
@@ -48,7 +48,7 @@ class SurfLocal
SurfLocal( const ISurf* pSurf, const Frame3d& frSrf, const Frame3d& frLoc)
: m_pSrf( nullptr), m_pCopy( nullptr)
{ // verifica dei parametri
if ( pSurf == nullptr)
if ( pSurf == nullptr || &frSrf == nullptr || &frLoc == nullptr)
return ;
// assegno la superficie originale
m_pSrf = pSurf ;
@@ -76,7 +76,7 @@ class SurfLocal
return ;
m_pSrf = m_pCopy ;
}
SurfLocal( SurfLocal&& Other) noexcept
SurfLocal( SurfLocal&& Other)
: m_pSrf( Other.m_pSrf), m_pCopy( Other.m_pCopy)
{ // annullo gli originali
Other.m_pSrf = nullptr ;
EGkSurfTriMesh.h
+4 -19
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2025
// EgalTech 2014-2024
//----------------------------------------------------------------------------
// File : EGkSurfTriMesh.h Data : 28.03.25 Versione : 2.7c4
// File : EGkSurfTriMesh.h Data : 05.03.24 Versione : 2.6c2
// Contenuto : Dichiarazione della interfaccia ISurfTriMesh.
//
//
@@ -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 CreateByPolygonWithHoles( const POLYLINEVECTOR& vPL) = 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 ;
@@ -113,34 +112,20 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
virtual bool GetEdge( int nInd, int& nV1, int& nV2, int& nFl, int& nFr, double& dAng) const = 0 ;
virtual bool GetEdge( int nInd, Point3d& ptP1, Point3d& ptP2, double& dAng) const = 0 ;
virtual bool GetEdges( ICURVEPOVECTOR& vpCurve) const = 0 ;
virtual bool GetCurvature( int nV,
double& dMinK, Vector3d& vtMinK, double& dMaxK, Vector3d& vtMaxK, bool& bPlanar, Vector3d& vtNorm) const = 0 ;
virtual bool Cut( const Plane3d& plPlane, bool bSaveOnEq) = 0 ;
virtual bool GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq) = 0 ;
virtual bool Add( const ISurfTriMesh& Other) = 0 ;
virtual bool Intersect( const ISurfTriMesh& Other) = 0 ;
virtual bool Subtract( const ISurfTriMesh& Other) = 0 ;
virtual bool GetSurfClassification( const ISurfTriMesh& ClassifierSurf,
INTVECTOR& vTriaIn, INTVECTOR& vTriaOut, INTVECTOR& vTriaOnP, INTVECTOR& vTriaOnM, INTVECTOR& vTriaIndef) = 0 ;
INTVECTOR& vTriaIn, INTVECTOR& vTriaOut, INTVECTOR& vTriaOnP, INTVECTOR& vTriaOnM, INTVECTOR& vTriaIndef) = 0 ;
virtual bool CutWithOtherSurf( const ISurfTriMesh& CutterSurf, bool bInVsOut, bool bSaveOnEq) = 0 ;
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 bool GetPartLocalBBox( int nP, BBox3d& b3Loc) const = 0 ;
virtual bool GetPartBBox( int nP, const Frame3d& frRef, BBox3d& b3Ref) 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 GetPartLoops( int nPart, POLYLINEVECTOR& vPL) const = 0 ;
virtual bool RemovePart( int nPart) = 0 ;
virtual ISurfTriMesh* ClonePart( int nPart) const = 0 ;
virtual bool GetPartAndShellFromFacet( int nFacet, int& nPart, int& nShell) const = 0 ;
virtual bool SetTFlag( int nId, int nTFlag) = 0 ;
virtual bool GetTFlag( int nId, int& nFlag) const = 0 ;
virtual int GetMaxTFlag( void) const = 0 ;
virtual bool ResetTFlags( void) = 0 ;
} ;
EGkSurfTriMeshAux.h
-32
View File
@@ -1,32 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2025-2025
//----------------------------------------------------------------------------
// File : EGkSurfTriMeshAux.h Data : 07.07.25 Versione : 2.7g1
// Contenuto : Funzioni ausiliarie per ISurfTriMesh.
//
//
//
// Modifiche : 07.07.25 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkSurfTriMesh.h"
//----------------------------------------------------------------------------
// Costanti per offset
static int STMOFF_FILLET = 0 ;
static int STMOFF_CHAMFER = 1 ;
static int STMOFF_EXTEND = 2 ;
//----------------------------------------------------------------------------
// Funzioni per Offset di singola superficie
EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshOffset( const ISurfTriMesh* pStm, double dOffs, double dPrec, int nType = STMOFF_FILLET) ;
EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshThickeningOffset( const ISurfTriMesh* pStm, double dOffs, double dPrec, int nType = STMOFF_FILLET) ;
// Funzioni per Offset di più superfici
EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshesOffset( const CISURFTMPVECTOR& vStm, double dOffs, double dPrec, int nType = STMOFF_FILLET) ;
EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshesThickeningOffset( const CISURFTMPVECTOR& vStm, double dOffs, double dPrec, int nType = STMOFF_FILLET) ;
// Funzione per Creazione superficie Shell
EGK_EXPORT ISurfTriMesh* CreateSurfTriMeshShell( const ISurfTriMesh* pStm, double dThick, double dLinTol) ;
EGkTriangle3d.h
-7
View File
@@ -455,13 +455,6 @@ CalcNormal( const Point3d& ptP, const Triangle3d& Tria, const TriNormals3d& Tnor
return vtNorm.Normalize( EPS_ZERO) ;
}
//----------------------------------------------------------------------------
inline bool
CalcNormal( const Point3d& ptP, const Triangle3dEx& Tria, Vector3d& vtNorm)
{
return CalcNormal( ptP, Tria, Tria.GetTriNormals(), vtNorm) ;
}
//----------------------------------------------------------------------------
enum TriangleType { OPEN = -1, EXACT = 0, CLOSED = 1 };
EGkTrimming.h
-63
View File
@@ -1,63 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2025-2025
//----------------------------------------------------------------------------
// File : EgkTrimming.h Data : 15.09.25 Versione : 2.7j1
// Contenuto : Calcolo di una superficie di Bezier Ruled definita da un sottoinsieme
// di facce di una superficie TriMesh
//
//
//
// Modifiche : 15.09.25 RE Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "EGkSelection.h"
#include "EGkCurveLine.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
//----------------------- Macro per import/export ----------------------------
#undef EGK_EXPORT
#if defined( I_AM_EGK) // da definirsi solo nella DLL
#define EGK_EXPORT __declspec( dllexport)
#else
#define EGK_EXPORT __declspec( dllimport)
#endif
typedef std::vector<ISURFPOVECTOR> ISURFPOMATRIX ;
typedef std::vector<ICRVCOMPOPOVECTOR> ICRVCOMPOPOMATRIX ;
enum RegolarizeType { STD = 0, // standard, con modifiche dirette ai punti di controllo
RMF = 1}; // ricostruendo le curve usando il rotation minimizing frame
//-----------------------------------------------------------------------------
EGK_EXPORT bool GetTrimmingStmAdjTria( const ISurfTriMesh* pStm, int nStartTria, const Point3d& ptStartTria,
double dAngTol, double dSize, double dSizeTol, ISurfTriMesh* pStmAdjTria) ;
EGK_EXPORT bool GetTrimmingAdjSurfs( const CISURFPVECTOR& vSurf, const CISURFPVECTOR& vOtherSurf, double dLinTol,
double dAngTol, double dFaceAngTol,
INTVECTOR& vIndOtherSurf) ;
EGK_EXPORT bool GetTrimmingRawEdges( const CISURFPVECTOR& vSurf, const SELVECTOR& vSurfFace,
double dLinTol, double dAngTol,
ICRVCOMPOPOVECTOR& vBezierEdges) ;
EGK_EXPORT bool GetTrimmingBezierEdges( ICRVCOMPOPOVECTOR& vCompoRawEdges, double dLinTol, double dAngTol,
ICRVCOMPOPOVECTOR& vCompoEdges) ;
EGK_EXPORT bool GetTrimmingFinalBorders( ICRVCOMPOPOVECTOR& vCompoBezierEdges, double dLinTol,
double dAngTol, BIPNTVECTOR& vBreakingPts, double dThick, double dThickTol) ;
EGK_EXPORT bool GetTrimmingFinalBorders( CISURFPVECTOR& vpSurf, const SELVECTOR& vSurfFaces, double dSurfLinTol,
double dSurfAngTol, double dLinTol, double dAngTol, double dThick,
ICRVCOMPOPOVECTOR& vCompoBezierEdges) ;
EGK_EXPORT ISurfBezier* GetTrimmingRuledBezier( const CISURFPVECTOR& vSurf, const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
double dLinTol, const BIPNTVECTOR& vSyncPoints) ;
EGK_EXPORT bool GetTrimmingSurfBzSyncPoints( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
double dLinTol, BIPNTVECTOR& vSyncPoints) ;
EGK_EXPORT bool GetTrimmingSyncInterpolation( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
const ICurve* pSync1, const ICurve* pSync2, double dLinTol,
double dAngTol, BIPNTVECTOR& vSyncPoints) ;
EGK_EXPORT bool GetTrimmingHoleBorders( const CISURFPVECTOR& vpSurf, const Point3d& ptRef, double dSurfLinTol,
double dSurfAngTol, double dEdgeLinTol, double dEdgeAngTol,
double dEdgeThick, ICRVCOMPOPOVECTOR& vHoleBorders) ;
EGK_EXPORT ISurfBezier* RegolarizeBordersLocally( const ISurfBezier* pSurfBz, const BIPOINT& bpIsoStart,
const BIPOINT& bpIsoEnd, double dTol, int nType = RegolarizeType::STD) ;
EGkUserObjFactory.h
+25 -25
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2025
// EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : EGkUserObjFactory.h Data : 31.10.25 Versione : 2.7k1
// File : EGkUserObjFactory.h Data : 22.05.15 Versione : 1.6e3
// Contenuto : Factory della classe IUserObj.
//
//
@@ -32,6 +32,29 @@
#define USEROBJ_CREATE( sName) UserObjFactory::Create( sName)
#define USEROBJ_GETLIST( vsList) UserObjFactory::GetList( vsList)
//----------------------------------------------------------------------------
template <class T>
class UserObjRegister
{
public :
static bool DoRegister( const std::string& sName)
{ if ( ! UserObjFactory::Register( sName, Create))
return false ;
GetNamePrivate() = sName ;
return true ; }
static IUserObj* Create( void)
{ return new(nothrow) T ; }
static const std::string& GetName( void)
{ return GetNamePrivate() ; }
private :
UserObjRegister( void) {}
~UserObjRegister( void) {}
static std::string& GetNamePrivate( void)
{ static std::string s_sName ;
return s_sName ; }
} ;
//----------------------------------------------------------------------------
class UserObjFactory
{
@@ -53,26 +76,3 @@ class UserObjFactory
// metodo di accesso alla mappa statica
static CreatorMap& GetCreatorMap( void) ;
} ;
//----------------------------------------------------------------------------
template <class T>
class UserObjRegister
{
public :
static bool DoRegister( const std::string& sName)
{ if ( ! UserObjFactory::Register( sName, Create))
return false ;
GetNamePrivate() = sName ;
return true ; }
static IUserObj* Create( void)
{ return new( std::nothrow) T ; }
static const std::string& GetName( void)
{ return GetNamePrivate() ; }
private :
UserObjRegister( void) {}
~UserObjRegister( void) {}
static std::string& GetNamePrivate( void)
{ static std::string s_sName ;
return s_sName ; }
} ;
EGkVector3d.h
+27 -38
View File
@@ -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
//----------------------------------------------------------------------------
EGkVolZmap.h
+9 -17
View File
@@ -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.
//
//
@@ -9,8 +9,6 @@
// Modifiche : 22.01.15 DS Creazione modulo.
// 12.09.23 DS Aggiunto metodo IsTriDexel.
// 09.03.24 DS Aggiunti SetShowEdges e GetShowEdges.
// 10.06.25 RE Aggiunte funzioni per Offset di superfici TriMesh chiuse
// 04.07.25 RE Aggiunte funzioni per Thickening Offset di superfici TriMesh generiche
//
//----------------------------------------------------------------------------
@@ -19,7 +17,7 @@
#include "/EgtDev/Include/EGkGeoObj.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
//----------------------------------------------------------------------------
class __declspec( novtable) IVolZmap : public IGeoObj
@@ -29,14 +27,14 @@ 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, int* nError = nullptr) = 0 ;
virtual bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) = 0 ;
virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex, int* nError = nullptr) = 0 ;
virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex, double dExtraBox = 0, int* nError = nullptr) = 0 ;
virtual 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 ;
virtual ISurfTriMesh* GetSurfTriMesh( void) const = 0 ;
virtual bool GetEdges( ICURVEPOVECTOR& vpCurve) const = 0 ;
virtual bool GetVolume( double& dVol) const = 0 ;
virtual bool IsTriDexel( void) const = 0 ;
@@ -58,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 ;
@@ -90,12 +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 SubtractSurfTm( const ISurfTriMesh* pStm) = 0 ;
virtual bool MakeUniform( double dToler, bool bIsExtensionFirst = true, int nToolNum = 0) = 0 ;
virtual bool RemoveFins( const Vector3d& vtDir, double dThick) = 0 ;
virtual bool Offset( double dOffs, int nType) = 0 ;
virtual int GetPartMinDistFromPoint( const Point3d& ptP) const = 0 ;
virtual bool AddSrfTm( const ISurfTriMesh* pStm) = 0 ;
} ;
//-----------------------------------------------------------------------------
EGnFileUtils.h
+2 -4
View File
@@ -1,14 +1,13 @@
//----------------------------------------------------------------------------
// EgalTech 2013-2026
// EgalTech 2013-2022
//----------------------------------------------------------------------------
// File : EGnFileUtils.h Data : 09.01.26 Versione : 3.1a1
// File : EGnFileUtils.h Data : 09.04.22 Versione : 2.4d1
// Contenuto : Prototipi funzioni di utilità su file e direttori.
//
//
//
// Modifiche : 11.12.13 DS Creazione modulo.
// 09.04.22 DS Aggiunta FindAllFiles.
// 09.01.26 DS Aggiunta EraseNonEmptyDirectory.
//
//----------------------------------------------------------------------------
@@ -43,5 +42,4 @@ EGN_EXPORT bool ExistsDirectory( const std::string& sDir) ;
EGN_EXPORT bool CreateDirectoryEgt( const std::string& sDir) ;
EGN_EXPORT bool EmptyDirectory( const std::string& sDir) ;
EGN_EXPORT bool EraseDirectory( const std::string& sDir) ;
EGN_EXPORT bool EraseNonEmptyDirectory( const std::string& sDir) ;
EGN_EXPORT bool FindAllDirectories( const std::string& sDirSpec, STRVECTOR& vsDirNames) ;
EGnLuaAux.h
+17 -103
View File
@@ -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,29 +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 ;
if ( lua_getglobal( L, vsTokens[0].c_str()) != LUA_TTABLE) {
lua_pop( L, 1) ;
return false ;
}
for ( int nInd = 1 ; nInd <= nTokenCnt - 2 ; ++ nInd) {
bool bOk ;
int nField ;
if ( FromString( vsTokens[nInd], nField))
bOk = ( lua_rawgeti( L, -1, nField) == LUA_TTABLE) ;
else
bOk = ( lua_getfield( L, -1, vsTokens[nInd].c_str()) == LUA_TTABLE) ;
if ( ! bOk) {
lua_pop( L, nInd + 1) ;
return false ;
}
}
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 ;
}
}
@@ -566,30 +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 ;
if ( lua_getglobal( L, vsTokens[0].c_str()) != LUA_TTABLE) {
lua_pop( L, 1) ;
return false ;
}
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 ;
}
}
@@ -609,29 +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 ;
if ( lua_getglobal( L, vsTokens[0].c_str()) != LUA_TTABLE) {
lua_pop( L, 1) ;
return false ;
}
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 ;
}
EGnStringKeyVal.h
+4 -39
View File
@@ -101,14 +101,14 @@ GetVal( const std::string& sString, const std::string& sKey, T& Val)
inline bool
SetValInNotes( const std::string& sKey, const std::string& sVal, std::string& sNotes)
{
// verifiche validità chiave
// verifiche validità chiave
if ( ! IsValidKey( sKey) || ! IsValidVal( sVal))
return false ;
// chiave con carattere finale speciale
std::string sTkey = sKey ;
if ( sKey.back() != COLON)
sTkey += EQUAL ;
// ricerca se già presente
// ricerca se già presente
STRVECTOR vsTokens ;
Tokenize( sNotes, ";", vsTokens) ;
bool bFound = false ;
@@ -143,7 +143,7 @@ SetValInNotes( const std::string& sKey, T& Val, std::string& sNotes)
inline bool
GetValInNotes( const std::string& sNotes, const std::string& sKey, std::string& sVal)
{
// verifiche validità chiave
// verifiche validità chiave
if ( sNotes.empty() || ! IsValidKey( sKey))
return false ;
// chiave con carattere finale speciale
@@ -171,46 +171,11 @@ GetValInNotes( const std::string& sNotes, const std::string& sKey, T& Val)
return ( GetValInNotes( sNotes, sKey, sVal) && FromString( sVal, Val)) ;
}
//----------------------------------------------------------------------------
inline bool
GetValInNotes( const std::string& sNotes, const std::string& sKey, const std::string& sToken, std::string& sVal)
{
// verifiche validità chiave
if ( sNotes.empty() || ! IsValidKey( sKey))
return false ;
// verifiche validità del token
if ( sToken.empty())
return false ;
// chiave con carattere finale speciale
std::string sTkey = sKey ;
if ( sKey.back() != COLON)
sTkey += EQUAL ;
// ricerca
STRVECTOR vsTokens ;
Tokenize( sNotes, sToken, vsTokens) ;
for ( const auto& sToken : vsTokens) {
if ( FindKey( sToken, sTkey, true)) {
sVal = sToken.substr( sTkey.length()) ;
return true ;
}
}
return false ;
}
//----------------------------------------------------------------------------
template <class T>
inline bool
GetValInNotes( const std::string& sNotes, const std::string& sKey, const std::string& sToken, T& Val)
{
std::string sVal ;
return ( GetValInNotes( sNotes, sKey, sToken, sVal) && FromString( sVal, Val)) ;
}
//----------------------------------------------------------------------------
inline bool
RemoveValInNotes( const std::string& sKey, std::string& sNotes)
{
// verifiche validità chiave
// verifiche validità chiave
if ( sNotes.empty() || ! IsValidKey( sKey))
return false ;
// chiave con carattere finale speciale
EGnStringUtils.h
+54 -149
View File
@@ -1,14 +1,13 @@
//----------------------------------------------------------------------------
// EgalTech 2013-2025
// EgalTech 2013-2014
//----------------------------------------------------------------------------
// File : EGnStringUtils.h Data : 18.09.25 Versione : 2.7i1
// File : EGnStringUtils.h Data : 17.03.14 Versione : 1.5c2
// Contenuto : Dichiarazione delle funzioni di utilità per le stringhe.
//
//
//
// Modifiche : 20.11.13 DS Creazione modulo.
// 20.10.15 DS Agg. FromString e ToString per std::array<double,N>.
// 18.09.25 DS Agg. FromString e ToString per long long.
//
//----------------------------------------------------------------------------
@@ -16,10 +15,8 @@
#include "/EgtDev/Include/EgtStringBase.h"
#include "/EgtDev/Include/EgtNumCollection.h"
#include "/EgtDev/Extern/fast_float/fast_float.h"
#include <algorithm>
#include <array>
#include <charconv>
//----------------------- Macro per import/export -----------------------------
#undef EGN_EXPORT
@@ -126,20 +123,20 @@ ValidateDxfName( std::string& sName, bool bAdvanced)
}
//----------------------------------------------------------------------------
#define FAST_FLOAT_FMT fast_float::chars_format::general | fast_float::chars_format::allow_leading_plus | fast_float::chars_format::skip_white_space
#define FAST_FLOAT_OPTS fast_float::parse_options( FAST_FLOAT_FMT)
inline bool
FromString( const std::string& sVal, int& nVal)
{ auto answer = fast_float::from_chars_advanced( sVal.data(), sVal.data() + sVal.size(), nVal, FAST_FLOAT_OPTS) ;
return ( answer.ec == std::errc() && answer.ptr != sVal.data()) ; }
{ const char* pStart = sVal.c_str() ;
char* pStop ;
errno = 0 ;
nVal = strtol( pStart, &pStop, 10) ;
return ( pStop != pStart && errno == 0) ; }
inline bool
FromString( const std::string& sVal, unsigned int& nVal)
{ auto answer = fast_float::from_chars_advanced( sVal.data(), sVal.data() + sVal.size(), nVal, FAST_FLOAT_OPTS) ;
return ( answer.ec == std::errc() && answer.ptr != sVal.data()) ; }
inline bool
FromString( const std::string& sVal, long long& nVal)
{ auto answer = fast_float::from_chars_advanced( sVal.data(), sVal.data() + sVal.size(), nVal, FAST_FLOAT_OPTS) ;
return ( answer.ec == std::errc() && answer.ptr != sVal.data()) ; }
{ const char* pStart = sVal.c_str() ;
char* pStop ;
errno = 0 ;
nVal = strtoul( pStart, &pStop, 10) ;
return ( pStop != pStart && errno == 0) ; }
inline bool
FromString( const std::string& sVal, bool& bVal)
{ int nTmp ;
@@ -149,40 +146,49 @@ FromString( const std::string& sVal, bool& bVal)
return true ; }
inline bool
FromString( const std::string& sVal, double& dVal)
{ auto answer = fast_float::from_chars( sVal.data(), sVal.data() + sVal.size(), dVal, FAST_FLOAT_FMT) ;
return ( answer.ec == std::errc() && answer.ptr != sVal.data()) ; }
{ const char* pStart = sVal.c_str() ;
char* pStop ;
errno = 0 ;
dVal = strtod( pStart, &pStop) ;
return ( pStop != pStart && errno == 0) ; }
template <size_t size>
bool FromString( const std::string& sVal, int (&nVal)[size])
{ const char* pFirst = sVal.data() ;
{ const char* pStart = sVal.c_str() ;
char* pStop ;
errno = 0 ;
for ( int i = 0 ; i < size ; ++ i) {
auto answer = fast_float::from_chars_advanced( pFirst, sVal.data() + sVal.size(), nVal[i], FAST_FLOAT_OPTS) ;
if ( answer.ec != std::errc() || ( i < size - 1 && answer.ptr[0] != ','))
nVal[i] = strtol( pStart, &pStop, 10) ;
if ( ( i < size - 1 && *pStop != ',') || errno != 0)
return false ;
pFirst = answer.ptr + 1 ;
pStart = pStop + 1 ;
}
return true ;
return ( errno == 0) ;
}
template <size_t size>
bool FromString( const std::string& sVal, double (&dVal)[size])
{ const char* pFirst = sVal.data() ;
{ const char* pStart = sVal.c_str() ;
char* pStop ;
errno = 0 ;
for ( int i = 0 ; i < size ; ++ i) {
auto answer = fast_float::from_chars( pFirst, sVal.data() + sVal.size(), dVal[i], FAST_FLOAT_FMT) ;
if ( answer.ec != std::errc() || ( i < size - 1 && answer.ptr[0] != ','))
dVal[i] = strtod( pStart, &pStop) ;
if ( ( i < size - 1 && *pStop != ',') || errno != 0)
return false ;
pFirst = answer.ptr + 1 ;
pStart = pStop + 1 ;
}
return true ;
return ( errno == 0) ;
}
template <size_t size>
bool FromString( const std::string& sVal, std::array<double,size>& dVal)
{ const char* pFirst = sVal.data() ;
{ const char* pStart = sVal.c_str() ;
char* pStop ;
errno = 0 ;
for ( int i = 0 ; i < size ; ++ i) {
auto answer = fast_float::from_chars( pFirst, sVal.data() + sVal.size(), dVal[i], FAST_FLOAT_FMT) ;
if ( answer.ec != std::errc() || ( i < size - 1 && answer.ptr[0] != ','))
dVal[i] = strtod( pStart, &pStop) ;
if ( ( i < size - 1 && *pStop != ',') || errno != 0)
return false ;
pFirst = answer.ptr + 1 ;
pStart = pStop + 1 ;
}
return true ;
return ( errno == 0) ;
}
EGN_EXPORT bool FromString( const std::string& sVal, INTVECTOR& vnVal) ;
EGN_EXPORT bool FromString( const std::string& sVal, DBLVECTOR& vdVal) ;
@@ -190,146 +196,45 @@ EGN_EXPORT bool FromString( const std::string& sVal, STRVECTOR& vsVal) ;
//----------------------------------------------------------------------------
inline const std::string
ToStringAdv( int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
ToString( int nVal, int nPrec = 1, int nRadix = 10)
{
// eseguo conversione
const int nBuffSize = 36 ;
char szBuff[nBuffSize]{} ;
auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
if ( Res.ec != std::errc()) {
if ( pnErr != nullptr)
*pnErr = int( Res.ec) ;
char szBuff[24] ;
int nErr = _itoa_s( nVal, szBuff, nRadix) ;
// se errore, ritorno stringa opportuna
if ( nErr != 0) {
_ASSERT( 0) ;
return "#Error" ;
}
// gestione codice di errore
if ( pnErr != nullptr)
*pnErr = 0 ;
// verifico lunghezza minima
// verifico lunghezza minima
int nLen = (int) strlen( szBuff) ;
if ( nLen >= nPrec)
return szBuff ;
// porto la stringa alla minima lunghezza
// porto la stringa alla minima lunghezza
std::string sBuff( szBuff) ;
sBuff.insert( 0, ( nPrec - nLen), '0') ;
return sBuff ;
}
inline const std::string
ToString( int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
{
// se necessario processing avanzato
if ( nPrec > 1 || nRadix < 6)
return ToStringAdv( nVal, nPrec, nRadix, pnErr) ;
// eseguo conversione
const int nBuffSize = 16 ;
char szBuff[nBuffSize]{} ;
auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
if ( Res.ec != std::errc()) {
if ( pnErr != nullptr)
*pnErr = int( Res.ec) ;
return "#Error" ;
}
// gestione codice di errore
if ( pnErr != nullptr)
*pnErr = 0 ;
return szBuff ;
}
inline const std::string
ToStringAdv( unsigned int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
ToString( unsigned int nVal, int nPrec = 1, int nRadix = 10)
{
// eseguo conversione
const int nBuffSize = 36 ;
char szBuff[nBuffSize]{} ;
auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
if ( Res.ec != std::errc()) {
if ( pnErr != nullptr)
*pnErr = int( Res.ec) ;
char szBuff[24] ;
int nErr = _ultoa_s( nVal, szBuff, nRadix) ;
// se errore, ritorno stringa opportuna
if ( nErr != 0) {
_ASSERT( 0) ;
return "#Error" ;
}
// gestione codice di errore
if ( pnErr != nullptr)
*pnErr = 0 ;
// verifico lunghezza minima
// verifico lunghezza minima
int nLen = (int) strlen( szBuff) ;
if ( nLen >= nPrec)
return szBuff ;
// porto la stringa alla minima lunghezza
// porto la stringa alla minima lunghezza
std::string sBuff( szBuff) ;
sBuff.insert( 0, ( nPrec - nLen), '0') ;
return sBuff ;
}
inline const std::string
ToString( unsigned int nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
{
// se necessario processing avanzato
if ( nPrec > 1 || nRadix < 6)
return ToStringAdv( nVal, nPrec, nRadix, pnErr) ;
// eseguo conversione
const int nBuffSize = 16 ;
char szBuff[nBuffSize]{} ;
auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
if ( Res.ec != std::errc()) {
if ( pnErr != nullptr)
*pnErr = int( Res.ec) ;
return "#Error" ;
}
// gestione codice di errore
if ( pnErr != nullptr)
*pnErr = 0 ;
return szBuff ;
}
template <size_t size>
const std::string ToString( const unsigned int (&nVal)[size], int nPrec = 1)
{ std::string sDest ; sDest.reserve( 8 * size) ;
for ( const auto& nV : nVal)
sDest += ToString( nV, nPrec) + "," ;
sDest.pop_back() ;
return sDest ; }
inline const std::string
ToStringAdv( long long nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
{
// eseguo conversione
const int nBuffSize = 68 ;
char szBuff[nBuffSize]{} ;
auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
if ( Res.ec != std::errc()) {
if ( pnErr != nullptr)
*pnErr = int( Res.ec) ;
return "#Error" ;
}
// gestione codice di errore
if ( pnErr != nullptr)
*pnErr = 0 ;
// verifico lunghezza minima
int nLen = (int) strlen( szBuff) ;
if ( nLen >= nPrec)
return szBuff ;
// porto la stringa alla minima lunghezza
std::string sBuff( szBuff) ;
sBuff.insert( 0, ( nPrec - nLen), '0') ;
return sBuff ;
}
inline const std::string
ToString( long long nVal, int nPrec = 1, int nRadix = 10, int* pnErr = nullptr)
{
// se necessario processing avanzato
if ( nPrec > 1 || nRadix < 6)
return ToStringAdv( nVal, nPrec, nRadix, pnErr) ;
// eseguo conversione
const int nBuffSize = 16 ;
char szBuff[nBuffSize]{} ;
auto Res = std::to_chars( szBuff, szBuff + nBuffSize - 1, nVal, nRadix) ;
if ( Res.ec != std::errc()) {
if ( pnErr != nullptr)
*pnErr = int( Res.ec) ;
return "#Error" ;
}
// gestione codice di errore
if ( pnErr != nullptr)
*pnErr = 0 ;
return szBuff ;
}
template <size_t size>
const std::string ToString( const int (&nVal)[size], int nPrec = 1)
{ std::string sDest ; sDest.reserve( 8 * size) ;
EGrScene.h
-6
View File
@@ -75,8 +75,6 @@ class IEGrScene
virtual bool ZoomChange( double dCoeff) = 0 ;
virtual bool ZoomOnPoint( const Point3d& ptWin, double dCoeff) = 0 ;
virtual bool ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2) = 0 ;
virtual bool SetCameraType( bool bOrthoOrPersp) = 0 ;
virtual bool SetZoomType( int nZoomMode) = 0 ;
// ShowMode
virtual bool SetShowMode( int nShowMode) = 0 ;
virtual int GetShowMode( void) const = 0 ;
@@ -92,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
@@ -173,9 +170,6 @@ enum CameraDir { CT_NONE = 0,
CT_ISO_NE = 9,
CT_ISO_NW = 10,
CT_CPLANE = 11} ;
//------------------------ Costanti per tipologia di zoom nel caso prospettico ---------------------
enum PerspZoom { ZT_STD = 0,
ZT_DOLLY = 1} ;
//------------------------ Costanti per tipo di visualizzazione --------------
enum ShowMode { SM_WIREFRAME = 0,
SM_HIDDENLINE = 1,
EInAPI.h
+25 -63
View File
@@ -34,8 +34,8 @@ extern "C" {
// General
EIN_EXPORT BOOL __stdcall EgtInit( int nDebug, const wchar_t* wsLogFile, const wchar_t* wsLogMsg) ;
EIN_EXPORT BOOL __stdcall EgtExit( void) ;
typedef bool (__stdcall * psfOnTerminateProcess) ( int) ;
EIN_EXPORT BOOL __stdcall EgtSetOnTerminateProcess( psfOnTerminateProcess pFun) ;
typedef bool (__stdcall * pfOnTerminateProcess) ( int) ;
EIN_EXPORT BOOL __stdcall EgtSetOnTerminateProcess( pfOnTerminateProcess pFun) ;
EIN_EXPORT BOOL __stdcall EgtSetUserLevel( int nUserLev) ;
EIN_EXPORT int __stdcall EgtGetUserLevel( void) ;
EIN_EXPORT BOOL __stdcall EgtSetKey( const wchar_t* wsKey) ;
@@ -65,10 +65,10 @@ EIN_EXPORT BOOL __stdcall EgtGetCpuInfo( wchar_t*& wsCpu) ;
EIN_EXPORT BOOL __stdcall EgtGetMemoryInfo( wchar_t*& wsMem) ;
EIN_EXPORT BOOL __stdcall EgtFreeMemory( void* pMem) ;
EIN_EXPORT BOOL __stdcall EgtOutLog( const wchar_t* wsMsg) ;
typedef int (__stdcall * psfProcEvents) (int, int) ;
EIN_EXPORT BOOL __stdcall EgtSetProcessEvents( psfProcEvents pFun) ;
typedef BOOL (__stdcall * psfOutTextW) (wchar_t*&) ;
EIN_EXPORT BOOL __stdcall EgtSetOutText( psfOutTextW pFun) ;
typedef int (__stdcall * pfProcEvents) (int, int) ;
EIN_EXPORT BOOL __stdcall EgtSetProcessEvents( pfProcEvents pFun) ;
typedef BOOL (__stdcall * pfOutTextW) (wchar_t*&) ;
EIN_EXPORT BOOL __stdcall EgtSetOutText( pfOutTextW pFun) ;
EIN_EXPORT BOOL __stdcall EgtSetTempDir( const wchar_t* wsTempDir) ;
EIN_EXPORT BOOL __stdcall EgtGetTempDir( wchar_t*& wsTempDir) ;
EIN_EXPORT BOOL __stdcall EgtSetMainWindowHandle( HWND hMainWnd) ;
@@ -103,8 +103,8 @@ EIN_EXPORT BOOL __stdcall EgtNewFile( void) ;
EIN_EXPORT BOOL __stdcall EgtOpenFile( const wchar_t* wsFilePath) ;
EIN_EXPORT BOOL __stdcall EgtInsertFile( const wchar_t* wsFilePath) ;
EIN_EXPORT BOOL __stdcall EgtSaveFile( const wchar_t* wsFilePath, int nFlag) ;
EIN_EXPORT BOOL __stdcall EgtSaveObjToFile( int nNumId, const int nIds[], const wchar_t* wsFilePath, int nFlag) ;
EIN_EXPORT BOOL __stdcall EgtSaveMachGroupToFile( int nMGroupId, int nNumPlusId, const int nPlusIds[], const wchar_t* wsFilePath, int nFlag) ;
EIN_EXPORT BOOL __stdcall EgtSaveObjToFile( int nId, const wchar_t* wsFilePath, int nFlag) ;
EIN_EXPORT BOOL __stdcall EgtSaveMachGroupToFile( int nMGroupId, const wchar_t* wsFilePath, int nFlag) ;
// Exchange
EIN_EXPORT int __stdcall EgtGetFileType( const wchar_t* wsFilePath) ;
@@ -116,9 +116,7 @@ EIN_EXPORT BOOL __stdcall EgtImportCsf( const wchar_t* wsFilePath) ;
EIN_EXPORT BOOL __stdcall EgtImportDxf( const wchar_t* wsFilePath, double dScaleFactor) ;
EIN_EXPORT BOOL __stdcall EgtImportPnt( const wchar_t* wsFilePath, int nFlag) ;
EIN_EXPORT BOOL __stdcall EgtImportStl( const wchar_t* wsFilePath, double dScaleFactor) ;
EIN_EXPORT BOOL __stdcall EgtImportOff( const wchar_t* wsFilePath, double dScaleFactor) ;
EIN_EXPORT BOOL __stdcall EgtImportPly( const wchar_t* wsFilePath, double dScaleFactor) ;
EIN_EXPORT BOOL __stdcall EgtImport3MF( const wchar_t* wsFilePath, int nFlag) ;
EIN_EXPORT BOOL __stdcall EgtImport3MF( const wchar_t* wsFilePath) ;
EIN_EXPORT BOOL __stdcall EgtImport3dm( const wchar_t* wsFilePath) ;
EIN_EXPORT BOOL __stdcall EgtAdvancedImportIsEnabled( void) ;
EIN_EXPORT BOOL __stdcall EgtAdvancedImport( const wchar_t* wsFilePath, double dLinToler, int nFlag) ;
@@ -156,13 +154,11 @@ EIN_EXPORT int __stdcall EgtBeamModifyProcess( int nGeomId, int nGroup, int nPr
int nCrvId, int nCrv2Id, BOOL bUpdate) ;
EIN_EXPORT BOOL __stdcall EgtBeamEraseProcess( int nGeomId, BOOL bUpdate) ;
EIN_EXPORT BOOL __stdcall EgtBeamEnableProcess( int nGeomId, BOOL bEnable, BOOL bUpdate) ;
EIN_EXPORT BOOL __stdcall EgtBeamCalcAllSolids( BOOL bShow, BOOL bRecalc) ;
EIN_EXPORT BOOL __stdcall EgtBeamShowAllSolids( BOOL bShow) ;
EIN_EXPORT BOOL __stdcall EgtBeamCalcSolid( int nPartId, BOOL bRecalc) ;
EIN_EXPORT int __stdcall EgtBeamGetSolid( int nPartId) ;
EIN_EXPORT BOOL __stdcall EgtBeamShowSolid( int nPartId, BOOL bShow) ;
EIN_EXPORT BOOL __stdcall EgtBeamGetBuildingIsOn( int nAssGrpId) ;
EIN_EXPORT BOOL __stdcall EgtBeamShowBuilding( int nAssGrpId, BOOL bShow) ;
EIN_EXPORT BOOL __stdcall EgtBeamGetBuildingIsOn( void) ;
EIN_EXPORT BOOL __stdcall EgtBeamShowBuilding( BOOL bShow) ;
// Tsc Executor
EIN_EXPORT BOOL __stdcall EgtInitTscExec( void) ;
@@ -256,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],
@@ -297,8 +291,6 @@ EIN_EXPORT int __stdcall EgtCreatePolygonFromApothem( int nParentId, int nNumSi
const double ptMid[3], int nRefType) ;
EIN_EXPORT int __stdcall EgtCreatePolygonFromSide( int nParentId, int nNumSides, const double ptIni[3],
const double ptFin[3], int nRefType) ;
EIN_EXPORT int __stdcall EgtSurfBezierGetCurveU( int nSurfId, double dU, int nDestGroup) ;
EIN_EXPORT int __stdcall EgtSurfBezierGetCurveV( int nSurfId, double dV, int nDestGroup) ;
// GeomDB Create Surf
EIN_EXPORT int __stdcall EgtCreateSurfFrRectangle( int nParentId, const double ptIni[3], const double ptCross[3], int nRefType) ;
@@ -394,9 +386,7 @@ EIN_EXPORT BOOL __stdcall EgtGetBBoxRef( int nId, int nFlag, const double ptOrig
const double vtX[3], const double vtY[3], const double vtZ[3],
double ptMin[3], double ptMax[3]) ;
EIN_EXPORT int __stdcall EgtCopy( int nSouId, int nRefId, int nSonBeforeAfter) ;
EIN_EXPORT int __stdcall EgtCopyEx( int nSouCtx, int nSouId, int nDestCtx, int nRefId, int nSonBeforeAfter) ;
EIN_EXPORT int __stdcall EgtCopyGlob( int nSouId, int nRefId, int nSonBeforeAfter) ;
EIN_EXPORT int __stdcall EgtCopyGlobEx( int nSouCtx, int nSouId, int nDestCtx, int nRefId, int nSonBeforeAfter) ;
EIN_EXPORT BOOL __stdcall EgtRelocate( int nSouId, int nRefId, int nSonBeforeAfter) ;
EIN_EXPORT BOOL __stdcall EgtRelocateGlob( int nSouId, int nRefId, int nSonBeforeAfter) ;
EIN_EXPORT BOOL __stdcall EgtGroupSwap( int nId1, int nId2, BOOL bSwapRef, BOOL bMark) ;
@@ -421,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) ;
@@ -455,7 +445,6 @@ EIN_EXPORT BOOL __stdcall EgtGetInfoBBox( int nId, const wchar_t* wsKey,
double ptMin[3], double ptMax[3]) ;
EIN_EXPORT BOOL __stdcall EgtGetInfoFrame( int nId, const wchar_t* wsKey, double ptOrig[3],
double vtX[3], double vtY[3], double vtZ[3]) ;
EIN_EXPORT BOOL __stdcall EgtGetAllInfo( int nId, wchar_t*& wsInfos) ;
EIN_EXPORT BOOL __stdcall EgtExistsInfo( int nId, const wchar_t* wsKey) ;
EIN_EXPORT BOOL __stdcall EgtRemoveInfo( int nId, const wchar_t* wsKey) ;
EIN_EXPORT BOOL __stdcall EgtSetTextureName( int nId, const wchar_t* wsTxrName) ;
@@ -560,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) ;
@@ -584,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,8 +587,6 @@ EIN_EXPORT BOOL __stdcall EgtArcAngCenter( int nId, double* pdAngDeg) ;
EIN_EXPORT BOOL __stdcall EgtArcDeltaN( int nId, double* pdDeltaN) ;
EIN_EXPORT BOOL __stdcall EgtArcNormVersor( int nId, int nRefId, double vtNorm[3]) ;
EIN_EXPORT BOOL __stdcall EgtCurveCompoCenter( int nId, int nSimpCrv, int nRefId, double ptCen[3]) ;
EIN_EXPORT BOOL __stdcall EgtCopyCompoSubCurve( int nId, int nSubCrvToCopy, int nParentId) ;
EIN_EXPORT BOOL __stdcall EgtCopyParamRange( int nId, double dUStart, double dUEnd, int nParentId) ;
// GeomDb Surf Get
EIN_EXPORT BOOL __stdcall EgtSurfArea( int nId, double* pdArea) ;
@@ -613,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) ;
@@ -635,10 +617,6 @@ EIN_EXPORT int __stdcall EgtGetSurfTmSilhouette( int nId, const double vtDir[3]
EIN_EXPORT int __stdcall EgtExtractSurfTmLoops( int nId, int nDestGrpId, int* pnCount) ;
EIN_EXPORT int __stdcall EgtExtractSurfTmFacetLoops( int nId, int nFacet, int nDestGrpId, int* pnCount) ;
EIN_EXPORT int __stdcall EgtCopySurfTmFacet( int nId, int nFacet, int nDestGrpId) ;
EIN_EXPORT int __stdcall EgtExtractSurfTmTriaLoop( int nId, int nT, int nDestGrpId) ;
EIN_EXPORT BOOL __stdcall EgtSurfBezierParamsFromPoint( int nSurfId, const double ptOnSurf[3], int nRefId, double* pdU, double* pdV) ;
EIN_EXPORT BOOL __stdcall EgtSurfBezierGetPointNrmD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
double ptP[3], double vtNorm[3], double vtDerU[3], double vtDerV[3]) ;
EIN_EXPORT int __stdcall EgtExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount) ;
// Geo Snap Vector/Point/Frame
@@ -784,7 +762,7 @@ EIN_EXPORT int __stdcall EgtAddRawPart( const double ptOrig[3],
EIN_EXPORT BOOL __stdcall EgtModifyRawPart( int nRawId, const double ptOrig[3],
double dLength, double dWidth, double dHeight, const int vCol[4]) ;
EIN_EXPORT BOOL __stdcall EgtModifyRawPart2( int nRawId, int nCrvId,
double dOverMat, double dHeight, const int vCol[4]) ;
double dOverMat, double dZmin, double dHeight, const int vCol[4]) ;
EIN_EXPORT BOOL __stdcall EgtModifyRawPartSize( int nRawId, double dLength, double dWidth, double dHeight) ;
EIN_EXPORT BOOL __stdcall EgtModifyRawPartHeight( int nRawId, double dHeight) ;
EIN_EXPORT BOOL __stdcall EgtKeepRawPart( int nRawId, int nSouPhase) ;
@@ -815,10 +793,7 @@ EIN_EXPORT BOOL __stdcall EgtGetTableArea( int nInd, double ptMin[3], double ptM
EIN_EXPORT BOOL __stdcall EgtGetTableAreaOffset( int nInd, double ptMinOffs[3], double ptMaxOffs[3]) ;
EIN_EXPORT BOOL __stdcall EgtChangeTable( const wchar_t* wsTable, BOOL bUpdateDisp) ;
EIN_EXPORT BOOL __stdcall EgtShowOnlyTable( BOOL bVal) ;
EIN_EXPORT BOOL __stdcall EgtMoveDispAxis( const wchar_t* wsName, double dPos) ;
EIN_EXPORT BOOL __stdcall EgtRemoveDispAxis( const wchar_t* wsName) ;
EIN_EXPORT int __stdcall EgtAddFixture( const wchar_t* wsName, const double ptPos[3], double dAngRotDeg, double dMov) ;
EIN_EXPORT BOOL __stdcall EgtKeepAllDispAxes( int nSouPhase) ;
EIN_EXPORT BOOL __stdcall EgtKeepFixture( int nFxtId, int nSouPhase) ;
EIN_EXPORT BOOL __stdcall EgtRemoveFixture( int nFxtId) ;
EIN_EXPORT BOOL __stdcall EgtVerifyFixture( int nFxtId) ;
@@ -826,9 +801,7 @@ EIN_EXPORT int __stdcall EgtGetFirstFixture( void) ;
EIN_EXPORT int __stdcall EgtGetNextFixture( int nFxtId) ;
EIN_EXPORT BOOL __stdcall EgtMoveFixture( int nFxtId, const double vtMove[3]) ;
EIN_EXPORT BOOL __stdcall EgtRotateFixture( int nFxtId, double dDeltaAngDeg) ;
EIN_EXPORT BOOL __stdcall EgtSetFixtureLink( int nFxtId, const wchar_t* wsTaLink) ;
EIN_EXPORT BOOL __stdcall EgtMoveFixtureMobile( int nFxtId, double dDeltaMov) ;
EIN_EXPORT BOOL __stdcall EgtSetFixtureMobile( int nFxtId, double dMov) ;
// Tools DataBase
EIN_EXPORT BOOL __stdcall EgtTdbGetToolNewName( const wchar_t* wsName, wchar_t*& wsNewName) ;
EIN_EXPORT BOOL __stdcall EgtTdbAddTool( const wchar_t* wsName, int nType) ;
@@ -908,16 +881,16 @@ EIN_EXPORT int __stdcall EgtGetFirstOperation( void) ;
EIN_EXPORT int __stdcall EgtGetNextOperation( int nId) ;
EIN_EXPORT int __stdcall EgtGetLastOperation( void) ;
EIN_EXPORT int __stdcall EgtGetPrevOperation( int nId) ;
EIN_EXPORT int __stdcall EgtGetFirstActiveOperation( bool bNeedMachNotEmpty) ;
EIN_EXPORT int __stdcall EgtGetNextActiveOperation( int nId, bool bNeedMachNotEmpty) ;
EIN_EXPORT int __stdcall EgtGetLastActiveOperation( bool bNeedMachNotEmpty) ;
EIN_EXPORT int __stdcall EgtGetPrevActiveOperation( int nId, bool bNeedMachNotEmpty) ;
EIN_EXPORT int __stdcall EgtGetFirstActiveOperation( void) ;
EIN_EXPORT int __stdcall EgtGetNextActiveOperation( int nId) ;
EIN_EXPORT int __stdcall EgtGetLastActiveOperation( void) ;
EIN_EXPORT int __stdcall EgtGetPrevActiveOperation( int nId) ;
EIN_EXPORT int __stdcall EgtGetOperationType( int nId) ;
EIN_EXPORT int __stdcall EgtGetOperationPhase( int nId) ;
EIN_EXPORT BOOL __stdcall EgtSetOperationName( int nId, const wchar_t* wsName) ;
EIN_EXPORT BOOL __stdcall EgtGetOperationName( int nId, wchar_t*& wsName) ;
EIN_EXPORT int __stdcall EgtGetOperationId( const wchar_t* wsName) ;
EIN_EXPORT BOOL __stdcall EgtIsOperationEmpty( int nId, int nEmptyType) ;
EIN_EXPORT BOOL __stdcall EgtIsOperationEmpty( int nId) ;
EIN_EXPORT BOOL __stdcall EgtRemoveOperation( int nId) ;
EIN_EXPORT BOOL __stdcall EgtRemoveAllPhaseOperations( int nPhase) ;
EIN_EXPORT BOOL __stdcall EgtRemoveAllOperations( void) ;
@@ -950,17 +923,15 @@ EIN_EXPORT BOOL __stdcall EgtSetMachiningGeometry( int nNumId, const int nIds[],
EIN_EXPORT BOOL __stdcall EgtPreviewMachining( BOOL bRecalc) ;
EIN_EXPORT BOOL __stdcall EgtApplyMachining( BOOL bRecalc) ;
EIN_EXPORT BOOL __stdcall EgtUpdateMachining( void) ;
EIN_EXPORT BOOL __stdcall EgtChangePreviewMachiningToolShow( int nLookFlag) ;
EIN_EXPORT BOOL __stdcall EgtPreparePreviewMachiningTool( void) ;
EIN_EXPORT BOOL __stdcall EgtRemovePreviewMachiningTool( void) ;
EIN_EXPORT int __stdcall EgtGetPreviewMachiningToolStepCount( void) ;
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) ;
EIN_EXPORT BOOL __stdcall EgtGetMachiningParamString( int nType, wchar_t*& wsVal) ;
EIN_EXPORT BOOL __stdcall EgtGetMachiningGeometry( int nInd, int* pnId, int* pnSub) ;
EIN_EXPORT BOOL __stdcall EgtIsMachiningEmpty( int nEmptyType) ;
EIN_EXPORT BOOL __stdcall EgtIsMachiningEmpty( void) ;
EIN_EXPORT BOOL __stdcall EgtGetMachiningStartPoint( double ptP[3]) ;
EIN_EXPORT BOOL __stdcall EgtGetMachiningEndPoint( double ptP[3]) ;
EIN_EXPORT BOOL __stdcall EgtApplyAllMachinings( BOOL bRecalc, BOOL bStopOnFirstErr, wchar_t*& wsErrList) ;
@@ -972,7 +943,6 @@ EIN_EXPORT BOOL __stdcall EgtSimMove( int* pnStatus) ;
EIN_EXPORT BOOL __stdcall EgtSimHome( void) ;
EIN_EXPORT BOOL __stdcall EgtSimSetStep( double dStep) ;
EIN_EXPORT BOOL __stdcall EgtSimSetUiStatus( int nUiStatus) ;
EIN_EXPORT BOOL __stdcall EgtSimEnableToolTipTrace( BOOL bEnable) ;
EIN_EXPORT BOOL __stdcall EgtSimGetAxisInfoPos( int nI, wchar_t*& wsName, wchar_t*& wsToken, BOOL* pbLinear, double* pdVal) ;
EIN_EXPORT BOOL __stdcall EgtSimGetToolInfo( wchar_t*& wsTool, double* pdSpeed) ;
EIN_EXPORT BOOL __stdcall EgtSimGetOperationInfo( wchar_t*& wsName, int* pnType) ;
@@ -987,20 +957,13 @@ EIN_EXPORT int __stdcall EgtGetTableId( const wchar_t* wsTable) ;
EIN_EXPORT int __stdcall EgtGetAxisId( const wchar_t* wsAxis) ;
EIN_EXPORT int __stdcall EgtGetHeadId( const wchar_t* wsHead) ;
EIN_EXPORT int __stdcall EgtGetHeadExitCount( const wchar_t* wsHead) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisType( const wchar_t* wsAxis, BOOL* pbLinear) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisDir( const wchar_t* wsAxis, double vtDir[3]) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisInvert( const wchar_t* wsAxis, BOOL* pbInvert) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisOffset( const wchar_t* wsAxis, double* pdOffset) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisPos( const wchar_t* wsAxis, double* pdVal) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisMin( const wchar_t* wsAxis, double* pdMin) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisMax( const wchar_t* wsAxis, double* pdMax) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisHomePos( const wchar_t* wsAxis, double* pdHome) ;
EIN_EXPORT BOOL __stdcall EgtGetAllHeadsNames( wchar_t*& wsNames) ;
EIN_EXPORT BOOL __stdcall EgtGetAllTablesNames( wchar_t*& wsNames) ;
// Machine Calc
EIN_EXPORT BOOL __stdcall EgtSetCalcTool( const wchar_t* wsTool, const wchar_t* wsHead, int nExit) ;
EIN_EXPORT BOOL __stdcall EgtGetCalcTool( wchar_t*& wsTool, wchar_t*& wsHead, int* pnExit) ;
EIN_EXPORT BOOL __stdcall EgtGetAllCurrAxesNames( wchar_t*& wsAxNames) ;
EIN_EXPORT BOOL __stdcall EgtGetCalcAngles( const double vtDirT[3], const double vtDirA[3],
int* pnStat, double* pdAngA1, double* pdAngB1, double* pdAngA2, double* pdAngB2) ;
EIN_EXPORT BOOL __stdcall EgtGetCalcAnglesEx( const double vtDirT[3], const double vtDirA[3],
@@ -1014,6 +977,10 @@ EIN_EXPORT BOOL __stdcall EgtVerifyOutstroke( double dX, double dY, double dZ, d
EIN_EXPORT BOOL __stdcall EgtGetOutstrokeInfo( wchar_t*& wsInfo) ;
// Machine Move
EIN_EXPORT BOOL __stdcall EgtSetAxisPos( const wchar_t* wsAxis, double dVal) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisPos( const wchar_t* wsAxis, double* pdVal) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisMin( const wchar_t* wsAxis, double* pdMin) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisMax( const wchar_t* wsAxis, double* pdMax) ;
EIN_EXPORT BOOL __stdcall EgtGetAxisHomePos( const wchar_t* wsAxis, double* pdHome) ;
EIN_EXPORT BOOL __stdcall EgtLoadTool( const wchar_t* wsHead, int nExit, const wchar_t* wsTool) ;
EIN_EXPORT BOOL __stdcall EgtResetHeadSet( const wchar_t* wsHead) ;
EIN_EXPORT BOOL __stdcall EgtSetMachineLook( int nFlag) ;
@@ -1023,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]) ;
@@ -1036,7 +1003,6 @@ EIN_EXPORT BOOL __stdcall EgtSetGridGeoAdv( double dSnapStep, int nMinLineSstep,
EIN_EXPORT BOOL __stdcall EgtSetGridColor( const int nMinCol[4], const int nMajCol[4]) ;
EIN_EXPORT BOOL __stdcall EgtResize( int nW, int nH) ;
EIN_EXPORT BOOL __stdcall EgtDraw( void) ;
EIN_EXPORT BOOL __stdcall EgtRedraw( void) ;
EIN_EXPORT BOOL __stdcall EgtSelect( int nWinX, int nWinY, int nSelW, int nSelH, int* pnSel) ;
EIN_EXPORT BOOL __stdcall EgtSetObjFilterForSelWin( BOOL bZerodim, BOOL bCurve, BOOL bSurf, BOOL bVolume, BOOL bExtra) ;
EIN_EXPORT BOOL __stdcall EgtUnselectableAdd( int nId) ;
@@ -1056,8 +1022,6 @@ EIN_EXPORT BOOL __stdcall EgtSetShowCurveDirection( BOOL bShow, BOOL bRedraw) ;
EIN_EXPORT BOOL __stdcall EgtGetShowCurveDirection( void) ;
EIN_EXPORT BOOL __stdcall EgtSetShowTriaAdv( BOOL bAdvanced, BOOL bRedraw) ;
EIN_EXPORT BOOL __stdcall EgtGetShowTriaAdv( void) ;
EIN_EXPORT BOOL __stdcall EgtSetShowSurfBezierTol( double dLinTol, BOOL bRedraw) ;
EIN_EXPORT double __stdcall EgtGetShowSurfBezierTol( void) ;
EIN_EXPORT BOOL __stdcall EgtSetShowZmap( int nMode, BOOL bRedraw) ;
EIN_EXPORT int __stdcall EgtGetShowZmap( void) ;
EIN_EXPORT BOOL __stdcall EgtZoom( int nZoom, BOOL bRedraw) ;
@@ -1091,8 +1055,6 @@ EIN_EXPORT BOOL __stdcall EgtGetTextureDimensions( const wchar_t* wsName, double
EIN_EXPORT BOOL __stdcall EgtChangeTextureDimensions( const wchar_t* wsName, double dDimX, double dDimY) ;
EIN_EXPORT BOOL __stdcall EgtGetImage( int nShowMode, const int TopCol[4], const int BottomCol[4],
int nWidth, int nHeight, const wchar_t* wsName) ;
EIN_EXPORT BOOL __stdcall EgtSetCameraType( BOOL bOrthoOrPersp, BOOL bRedraw) ;
EIN_EXPORT BOOL __stdcall EgtSetZoomType( int nZoomType, BOOL bRedraw) ;
// Image
EIN_EXPORT BOOL __stdcall EgtGetImagePixels( const wchar_t* wsFile, int* pnPixelX, int* pnPixelY) ;
EMkDispositionConst.h
-2
View File
@@ -30,7 +30,5 @@ enum RawPartCenterPos { MCH_CE_TC = 1, // top center
//------------------------ Costanti per fixtures ------------------------------
static std::string FXT_MOBILE = "MOBILE" ; // gruppo parte mobile
static std::string FXT_MOB_MINPOS = "MINPOS" ; // posizione minima della parte mobile
static std::string FXT_MOB_MAXPOS = "MAXPOS" ; // posizione massima della parte mobile
static std::string FXT_MOB_CPOS = "CPOS" ; // posizione corrente della parte mobile
static std::string FXT_MOB_MOVEDIR = "MDIR" ; // direzione di movimento della parte mobile (default Z di gruppo)
EMkMachMgr.h
+17 -45
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2025
// EgalTech 2015-2024
//----------------------------------------------------------------------------
// File : EMkMachMgr.h Data : 09.09.25 Versione : 2.7i2
// File : EMkMachMgr.h Data : 02.04.24 Versione : 2.6d1
// Contenuto : Dichiarazione della interfaccia IMachMgr.
//
//
@@ -17,9 +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.
// 25.11.24 DS Aggiunta in interfaccia GetMachiningSkippedGeometry.
// 09.09.25 DS Aggiunta in interfaccia GetRobotAngles.
//
//----------------------------------------------------------------------------
@@ -87,7 +84,7 @@ class __declspec( novtable) IMachMgr
virtual int AddRawPart( const Point3d& ptOrig, double dLen, double dWidth, double dHeight, Color cCol) = 0 ;
virtual int AddRawPartWithPart( int nPartId, int nCrvSrfId, double dOverMat, Color cCol) = 0 ;
virtual bool ModifyRawPart( int nRawId, const Point3d& ptOrig, double dLen, double dWidth, double dHeight, Color cCol) = 0 ;
virtual bool ModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dHeight, Color cCol) = 0 ;
virtual bool ModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dZmin, double dHeight, Color cCol) = 0 ;
virtual bool ModifyRawPartSize( int nRawId, double dLength, double dWidth, double dHeight) = 0 ;
virtual bool ModifyRawPartHeight( int nRawId, double dHeight) = 0 ;
virtual bool KeepRawPart( int nRawId, int nSouPhase) = 0 ;
@@ -119,9 +116,6 @@ class __declspec( novtable) IMachMgr
virtual bool GetTableAreaOffset( int nInd, BBox3d& b3Area) const = 0 ;
virtual bool ChangeTable( const std::string& sTable, bool bUpdateDisp) = 0 ;
virtual bool ShowOnlyTable( bool bVal) = 0 ;
virtual bool MoveDispAxis( const std::string& sName, double dPos) = 0 ;
virtual bool RemoveDispAxis( const std::string& sName) = 0 ;
virtual bool KeepAllDispAxes( int nSouPhase) = 0 ;
virtual int AddFixture( const std::string& sName, const Point3d& ptPos, double dAngRotDeg, double dMov) = 0 ;
virtual bool KeepFixture( int nFxtId, int nSouPhase) = 0 ;
virtual bool RemoveFixture( int nFxtId) = 0 ;
@@ -130,9 +124,7 @@ class __declspec( novtable) IMachMgr
virtual int GetNextFixture( int nFxtId) const = 0 ;
virtual bool MoveFixture( int nId, const Vector3d& vtMove) = 0 ;
virtual bool RotateFixture( int nId, double dDeltaAngDeg) = 0 ;
virtual bool SetFixtureLink( int nId, const std::string& sTaLink) = 0 ;
virtual bool MoveFixtureMobile( int nId, double dDeltaMov) = 0 ;
virtual bool SetFixtureMobile( int nId, double dMov) = 0 ;
// Tools DataBase
virtual bool TdbGetToolNewName( std::string& sName) const = 0 ;
virtual bool TdbAddTool( const std::string& sName, int nType) = 0 ;
@@ -176,11 +168,10 @@ class __declspec( novtable) IMachMgr
virtual int GetCurrSetup( void) const = 0 ;
virtual bool GetDefaultSetupName( std::string& sName) const = 0 ;
virtual bool ImportSetup( const std::string& sName) = 0 ;
virtual bool ExistsCurrSetup( void) const = 0 ;
virtual bool VerifyCurrSetup( STRVECTOR& vsErrors) = 0 ;
virtual bool FindToolInCurrSetup( const std::string& sTool) const = 0 ;
virtual bool GetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) const = 0 ;
virtual bool GetToolsInCurrSetupPos( const std::string& sTcPos, STRVECTOR& vsTools) const = 0 ;
virtual bool FindToolInCurrSetup( const std::string& sTool) = 0 ;
virtual bool GetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) = 0 ;
virtual bool GetToolsInCurrSetupPos( const std::string& sTcPos, STRVECTOR& vsTools) = 0 ;
virtual bool UpdateCurrSetup( void) = 0 ;
virtual bool EraseCurrSetup( void) = 0 ;
// Machinings DataBase
@@ -221,16 +212,16 @@ class __declspec( novtable) IMachMgr
virtual int GetNextOperation( int nId) const = 0 ;
virtual int GetLastOperation( void) const = 0 ;
virtual int GetPrevOperation( int nId) const = 0 ;
virtual int GetFirstActiveOperation( bool bNeedMachNotEmpty = false) const = 0 ;
virtual int GetNextActiveOperation( int nId, bool bNeedMachNotEmpty = false) const = 0 ;
virtual int GetLastActiveOperation( bool bNeedMachNotEmpty = false) const = 0 ;
virtual int GetPrevActiveOperation( int nId, bool bNeedMachNotEmpty = false) const = 0 ;
virtual int GetFirstActiveOperation( void) const = 0 ;
virtual int GetNextActiveOperation( int nId) const = 0 ;
virtual int GetLastActiveOperation( void) const = 0 ;
virtual int GetPrevActiveOperation( int nId) const = 0 ;
virtual int GetOperationType( int nId) const = 0 ;
virtual int GetOperationPhase( int nId) const = 0 ;
virtual bool SetOperationName( int nId, const std::string& sName) = 0 ;
virtual std::string GetOperationName( int nId) const = 0 ;
virtual int GetOperationId( const std::string& sName) const = 0 ;
virtual bool IsOperationEmpty( int nId, int nEmptyType = 0) const = 0 ;
virtual bool IsOperationEmpty( int nId) const = 0 ;
virtual bool RemoveOperation( int nId) = 0 ;
virtual bool RemoveAllPhaseOperations( int nPhase) = 0 ;
virtual bool RemoveAllOperations( void) = 0 ;
@@ -248,7 +239,6 @@ class __declspec( novtable) IMachMgr
virtual int GetPhaseDisposition( int nPhase) const = 0 ;
virtual bool DispositionSpecialApply( int nId, bool bRecalc) = 0 ;
virtual bool DispositionSpecialUpdate( int nId) = 0 ;
virtual bool GetDispositionToolData( int nId, std::string& sName, std::string& sHead, int& nExit, std::string& sTcPos) = 0 ;
// Operations : machinings
virtual int AddMachining( const std::string& sName, const std::string& sMachining) = 0 ;
virtual int AddMachining( const std::string& sName, int nMchType, const std::string& sTool) = 0 ;
@@ -266,33 +256,23 @@ class __declspec( novtable) IMachMgr
virtual bool RemoveMachiningPreview( void) = 0 ;
virtual bool MachiningApply( bool bRecalc, bool bPostApply = true) = 0 ;
virtual bool MachiningUpdate( bool bPostApply = true) = 0 ;
virtual bool ChangePreviewMachiningToolShow( int nLookFlag) = 0 ;
virtual bool PreparePreviewMachiningTool( void) const = 0 ;
virtual bool RemovePreviewMachiningTool( void) const = 0 ;
virtual int GetPreviewMachiningToolStepCount( void) const = 0 ;
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 ;
virtual bool GetMachiningParam( int nType, std::string& sVal) const = 0 ;
virtual bool GetMachiningGeometry( SELVECTOR& vIds) const = 0 ;
virtual bool GetMachiningSkippedGeometry( SELVECTOR& vIds) const = 0 ;
virtual bool IsMachiningEmpty( int nEmptyType = 0) const = 0 ;
virtual bool IsMachiningEmpty( void) const = 0 ;
virtual bool GetMachiningStartPoint( Point3d& ptStart) const = 0 ;
virtual bool GetMachiningEndPoint( Point3d& ptEnd) const = 0 ;
virtual bool GetMachiningStartAxes( bool bSkipClimb, DBLVECTOR& vAxVal) const = 0 ;
virtual bool GetMachiningEndAxes( bool bSkipRise, DBLVECTOR& vAxVal) const = 0 ;
// CL Entities Interrogations
virtual bool GetClEntMove( int nEntId, int& nMove) const = 0 ;
virtual bool GetClEntFlag( int nEntId, int& nFlag, int& nFlag2) const = 0 ;
virtual bool GetClEntIndex( int nEntId, int& nIndex) const = 0 ;
virtual bool GetClEntFeed( int nEntId, double& dFeed) const = 0 ;
virtual bool GetClEntAxesStatus( int nEntId, int& nStatus) const = 0 ;
virtual bool GetClEntAxesMask( int nEntId, int& nMask) const = 0 ;
virtual bool GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const = 0 ;
virtual bool GetClEntTDir( int nEntId, Vector3d& vtTDir) const = 0 ;
virtual bool GetClEntCDir( int nEntId, Vector3d& vtCDir) const = 0 ;
virtual bool GetClEntADir( int nEntId, Vector3d& vtADir) const = 0 ;
// Simulation
virtual bool SimInit( void) = 0 ;
virtual bool SimStart( bool bFirst) = 0 ;
@@ -303,7 +283,6 @@ class __declspec( novtable) IMachMgr
virtual bool SimGetMoveInfo( int& nGmove, double& dFeed) const = 0 ;
virtual bool SimSetStep( double dStep) = 0 ;
virtual bool SimSetUiStatus( int nUiStatus) = 0 ;
virtual bool SimEnableToolTipTrace( bool bEnable) = 0 ;
virtual bool SimGoHome( void) = 0 ;
virtual bool SimExit( void) = 0 ;
// Generation
@@ -312,25 +291,21 @@ class __declspec( novtable) IMachMgr
// Machine Calc
virtual bool SetCalcTable( const std::string& sTable) = 0 ;
virtual bool SetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) = 0 ;
virtual bool SetCalcSolCh( int nScc, bool bExact) = 0 ;
virtual bool GetAllCurrAxesNames( STRVECTOR& vAxName) const = 0 ;
virtual bool SetRotAxisBlock( const std::string& sAxis, double dVal) = 0 ;
virtual bool GetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) const = 0 ;
virtual bool GetCalcTable( std::string& sTable) const = 0 ;
virtual bool GetCalcTool( std::string& sTool) const = 0 ;
virtual bool GetCalcHead( std::string& sHead) const = 0 ;
virtual bool GetCalcExit( int& nExit) const = 0 ;
virtual bool GetCalcSolCh( int& nScc, bool& bExact) const = 0 ;
virtual bool GetAllCurrAxesNames( STRVECTOR& vAxName) const = 0 ;
virtual bool GetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) const = 0 ;
virtual bool GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) const = 0 ;
virtual bool GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
int& nStat, DBLVECTOR& vAng1, DBLVECTOR& vAng2) const = 0 ;
virtual bool GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB,
double& dX, double& dY, double& dZ) const = 0 ;
int& nStat, double& dX, double& dY, double& dZ) const = 0 ;
virtual bool GetCalcPositions( const Point3d& ptP, const DBLVECTOR& vAng,
double& dX, double& dY, double& dZ) const = 0 ;
virtual bool GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vector3d& vtDirA,
DBLVECTOR& vAng1, DBLVECTOR& vAng2) const = 0 ;
int& nStat, double& dX, double& dY, double& dZ) const = 0 ;
virtual bool GetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
bool bOverall, bool bBottom, Point3d& ptTip) const = 0 ;
virtual bool GetCalcTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
@@ -340,7 +315,6 @@ class __declspec( novtable) IMachMgr
virtual bool GetNearestAngleInStroke( int nInd, double dAngRef, double& dAng) const = 0 ;
virtual bool LimitAngleToStroke( int nInd, double& dAng) const = 0 ;
virtual bool VerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) const = 0 ;
virtual bool VerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, bool bClear, int& nStat) const = 0 ;
virtual std::string GetOutstrokeInfo( bool bMM = true) const = 0 ;
// Machine
virtual int GetBaseId( const std::string& sBase) const = 0 ;
@@ -348,11 +322,9 @@ 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 ;
virtual bool GetAxisDir( const std::string& sAxis, Vector3d& vtDir) const = 0 ;
virtual bool GetAxisInvert( const std::string& sAxis, bool& bInvert) const = 0 ;
virtual bool GetAxisOffset( const std::string& sAxis, double& dOffset) const = 0 ;
virtual bool SetAxisPos( const std::string& sAxis, double dVal, double* pdNewVal = nullptr) = 0 ;
EMkMachiningConst.h
+12 -41
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2025
// EgalTech 2015-2024
//----------------------------------------------------------------------------
// File : EmkMachiningConst.h Data : 20.01.25 Versione : 2.7a1
// File : EmkMachiningConst.h Data : 29.03.24 Versione : 2.6di1
// Contenuto : Costanti delle lavorazioni.
//
//
@@ -14,8 +14,6 @@
// 04.02.22 DS Agg. MPA_EPICYCLESRAD e MPA_EPICYCLESDIST.
// 06.09.23 DS Agg. 5AxMachining.
// 29.03.24 DS Agg. MGP_APPROXLINTOL.
// 04.12.24 ES Agg. SURFFIN_SUB_Z_CONST e SURFFIN_SUB_OPTIMAL.
// 20.01.25 ES Agg. SURFFIN_SUB_PROJECT.
//
//----------------------------------------------------------------------------
@@ -68,8 +66,7 @@ enum MachiningType {
MT_SURFROUGHING = OPER_SURFROUGHING,
MT_SURFFINISHING = OPER_SURFFINISHING,
MT_WATERJETTING = OPER_WATERJETTING,
MT_FIVEAXISMILLING = OPER_FIVEAXISMILLING,
MT_PROBING = OPER_PROBING
MT_5AXMACHINING = OPER_5AXMACHINING
} ;
//----------------------------------------------------------------------------
@@ -159,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),
@@ -301,12 +297,10 @@ enum { SAWROU_HS_LEFT = 1,
SAWROU_HS_RIGHT = 2} ;
// Tipo di lavorazione a step
enum { SAWROU_ST_ZIGZAG = 0,
SAWROU_ST_ONEWAY = 1,
SAWROU_ST_ZCONST = 2} ;
SAWROU_ST_ONEWAY = 1} ;
// Tipo di attacco/uscita/link
enum { SAWROU_LL_CENT = 0,
SAWROU_LL_OUT = 1,
SAWROU_LL_INT = 2} ;
SAWROU_LL_OUT = 1} ;
//----------------------------------------------------------------------------
// Parametri per finitura con lama
@@ -330,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,
@@ -369,26 +361,7 @@ enum { MORTISE_PLUNGE_STEP = 0,
MORTISE_PLUNGE_START = 1,
MORTISE_PLUNGE_END = 2,
MORTISE_PLUNGE_START_END = 3,
MORTISE_PLUNGE_START_TO_END = 4,
MORTISE_PLUNGE_STEP_NO_SAFEZ = 10} ;
//----------------------------------------------------------------------------
// 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} ;
MORTISE_PLUNGE_START_TO_END = 4} ;
//----------------------------------------------------------------------------
// Parametri per finitura superfici
@@ -396,15 +369,14 @@ enum { SURFROU_LO_NONE = 0,
enum { SURFFIN_SUB_ZIGZAG = 0,
SURFFIN_SUB_ONEWAY = 1,
SURFFIN_SUB_SPIRALIN = 2,
SURFFIN_SUB_SPIRALOUT = 3,
SURFFIN_SUB_Z_CONST = 4,
SURFFIN_SUB_OPTIMAL = 5,
SURFFIN_SUB_PROJECT = 6,
SURFFIN_SUB_PENCIL = 7} ;
SURFFIN_SUB_SPIRALOUT = 3} ;
// Tipo di attacco
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,
@@ -423,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,
EMkMachiningGeoConst.h
+2 -16
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2016-2024
// EgalTech 2016-2016
//----------------------------------------------------------------------------
// File : EmkMachiningGeoConst.h Data : 25.11.24 Versione : 2.6k5
// File : EmkMachiningGeoConst.h Data : 06.01.16 Versione : 1.6l6
// Contenuto : Costanti per le geometrie delle lavorazioni.
//
//
@@ -26,32 +26,25 @@ static std::string KEY_STRAIGHT = "STR" ;
static std::string KEY_NUM = "NUM" ;
// Chiave per stato di aggiornamento di lavorazione
static std::string KEY_STAT = "STAT" ;
// Chiave per elenco identificativi non lavorati
static std::string KEY_SKIPS = "SKIPS" ;
// Sottogruppi delle lavorazioni
static std::string MCH_AUX = "AUX" ;
static std::string MCH_AUXVIEW = "AVIEW" ;
static std::string MCH_TABS = "TABS" ;
static std::string MCH_PV = "PV" ;
static std::string MCH_ST = "ST" ;
static std::string MCH_ST_DBL = "STDBL" ;
static std::string MCH_CL = "CL" ;
static std::string MCH_DBL = "DBL" ;
static std::string MCH_HOME = "HOME" ;
static std::string MCH_PATH = "P" ;
// Nomi di entità CL speciali
static std::string MCH_CL_CLIMB = "CLIMB" ;
static std::string MCH_CL_RISE = "RISE" ;
static std::string MCH_CL_HOME = "HOME" ;
static std::string MCH_CL_SAFEIN = "SI" ;
static std::string MCH_CL_LEADIN = "LI" ;
static std::string MCH_CL_LEADOUT = "LO" ;
static std::string MCH_CL_SAFEOUT = "SO" ;
static std::string MCH_CL_AGB_DWN = "AGBD" ;
static std::string MCH_CL_AGB_IN = "AGBI" ;
static std::string MCH_CL_AGB_OUT = "AGBO" ;
static std::string MCH_CL_AGB_UP = "AGBU" ;
static std::string MCH_CL_PARALLEL_DBL = "DBP" ;
// Nomi di entità di preview
static std::string MCH_PV_CUT = "CUT" ;
static std::string MCH_PV_PRE_CUT = "PRC" ;
@@ -115,15 +108,8 @@ static std::string KEY_MMAX = "MMAX" ;
// Chiavi info in gruppo CL per punti assi minimo e massimo di ingombro di tutta la lavorazione
static std::string KEY_MAXMIN = "MAXMIN" ;
static std::string KEY_MAXMAX = "MAXMAX" ;
// Chiave info in gruppo CL per indicare il tipo di catena cinematica
static std::string KEY_KINTYPE = "KINTYPE" ;
// Chiave info in sottogruppo di CL per uscite attivate (per forature con gang drill)
static std::string KEY_DRACEX = "DRACEX" ;
// Chiave info in sottogruppo di testa per abilitarne visualizzazione in Preview (0/1 default)
static std::string KEY_PREVIEWSHOW = "PreviewShow" ;
// Chiavi info in entità di CL e DBL per riferimenti reciproci
static std::string KEY_DBL_MAIN = "Main" ;
static std::string KEY_CL_DOUBLE = "Double" ;
//----------------- Costanti posizione per preview utensile in lavorazione ------
enum MchToolShow { MCH_TPM_CURR = 0,
EMkOperationConst.h
+18 -21
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2025
// EgalTech 2015-2023
//----------------------------------------------------------------------------
// File : EmkOperationConst.h Data : 09.06.25 Versione : 2.7f2
// File : EmkOperationConst.h Data : 06.09.23 Versione : 2.5i1
// Contenuto : Costanti delle operazioni.
//
//
@@ -13,29 +13,27 @@
// 25.05.19 DS Agg. SurfRoughing e SurfFinishing.
// 08.07.19 DS Agg. WaterJetting.
// 06.09.23 DS Agg. 5AxMachining.
// 09.06.25 DS Agg. Probing.
//
//----------------------------------------------------------------------------
#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
OPER_PROBING = 0x400000} ; // tastatura
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)
{
@@ -55,6 +53,5 @@ bool inline IsValidMachiningType( int nType)
nType == OPER_SURFROUGHING ||
nType == OPER_SURFFINISHING ||
nType == OPER_WATERJETTING ||
nType == OPER_FIVEAXISMILLING ||
nType == OPER_PROBING) ;
nType == OPER_5AXMACHINING) ;
}
EMkToolConst.h
+4 -15
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2025
// EgalTech 2015-2021
//----------------------------------------------------------------------------
// File : EmkToolConst.h Data : 09.06.25 Versione : 2.7f2
// File : EmkToolConst.h Data : 16.09.21 Versione : 2.3i6
// Contenuto : Costanti degli utensili.
//
//
@@ -11,7 +11,6 @@
// 20.09.18 DS Agg. costanti per ToolHolder
// 05.04.21 DS Agg. TPA_DIST e TPA_STEMDIAM.
// 16.09.21 DS Agg. TPA_CORE.
// 09.06.25 DS Agg. probe.
//
//----------------------------------------------------------------------------
@@ -28,7 +27,6 @@ const int TF_MORTISE = 0x0800 ; // 2048
const int TF_CHISEL = 0x1000 ; // 4096
const int TF_WATERJET = 0x2000 ; // 8192
const int TF_COMPO = 0x4000 ; // 16384
const int TF_PROBE = 0x8000 ; // 32768
// Costante per tutte le famiglie
const int TF_ALL = 0xFF00 ;
// Tipologie di utensili
@@ -44,8 +42,7 @@ enum ToolType {
TT_MORTISE_STD = TF_MORTISE + 0, // 2048
TT_CHISEL_STD = TF_CHISEL + 0, // 4096
TT_WATERJET = TF_WATERJET + 0, // 8192
TT_COMPO = TF_COMPO + 0, // 16384
TT_PROBE = TF_PROBE + 0 // 32768
TT_COMPO = TF_COMPO + 0 // 16384
} ;
// Controllo tipo valido
bool inline IsValidToolType( int nType)
@@ -56,8 +53,7 @@ bool inline IsValidToolType( int nType)
nType == TT_MORTISE_STD ||
nType == TT_CHISEL_STD ||
nType == TT_WATERJET ||
nType == TT_COMPO ||
nType == TT_PROBE) ;
nType == TT_COMPO) ;
}
//----------------------------------------------------------------------------
@@ -126,10 +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
const std::string TTH_TYPE = "TYPE" ; // stringa tipo di portautensile
const std::string TTH_TYPE_STD = "Std" ; // tipo standard (default)
const std::string TTH_TYPE_FLOAT = "Float" ; // tipo flottante
//----------------------------------------------------------------------------
// Costanti per nomi di parti di utensile
const std::string TNA_TOOL_START = "Tool_" ; // inizio nome delle geometrie che costituiscono il vero utensile
ENkMachOptimization.h
-133
View File
@@ -1,133 +0,0 @@
//----------------------------------------------------------------------------
// EgalTech 2025-2025
//----------------------------------------------------------------------------
// File : ENkMachOptimization.h Data : 31.03.25 Versione : 2.7a1
// Contenuto : Classe per calcolo ottimizzato per le lavorazioni.
//
//
// Modifiche : 31.03.2025 RE Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EgtNumCollection.h"
//----------------------- Macro per import/export ----------------------------
#undef ENK_EXPORT
#if defined( I_AM_ENK) // da definirsi solo nella DLL
#define ENK_EXPORT __declspec( dllexport)
#else
#define ENK_EXPORT __declspec( dllimport)
#endif
//----------------------------------------------------------------------------
// Definizione utensile
struct ToolOptm {
int nId ; // Id dell'utensile ( univoco)
double dTCX ; // Coordinata cambio utensile per X
double dTCY ; // Coordinata cambio utensile per Y
double dTCZ ; // Coordinata cambio utensile per Z
double dTCA ; // Coordinata cambio utensile per A
double dTCB ; // Coordinata cambio utensile per B
double dTCC ; // Coordinata cambio utensile per C
bool bTCX ; // Flag per condsiderare/scartare il controllo sulla coordinata X
bool bTCY ; // Flag per condsiderare/scartare il controllo sulla coordinata Y
bool bTCZ ; // Flag per condsiderare/scartare il controllo sulla coordinata Z
bool bTCA ; // Flag per condsiderare/scartare il controllo sulla coordinata A
bool bTCB ; // Flag per condsiderare/scartare il controllo sulla coordinata B
bool bTCC ; // Flag per condsiderare/scartare il controllo sulla coordinata C
double dTLoad ; // Tempo di carico
double dTUnLoad ; // Tempo di scarico
ToolOptm( int nI, double dX, double dY, double dZ, double dA, double dB, double dC,
bool bX, bool bY, bool bZ, bool bA, bool bB, bool bC, double dTL, double dTUL) :
nId( nI), dTCX( dX), dTCY( dY), dTCZ( dZ), dTCA( dA), dTCB( dB), dTCC( dC),
bTCX( bX), bTCY( bY), bTCZ( bZ), bTCA( bA), bTCB( bB), bTCC( bC), dTLoad( dTL), dTUnLoad( dTUL) {}
} ;
typedef std::vector<ToolOptm> TOOLOPTMVECTOR ;
// Definizione strutta per singola lavorazione
struct MachOptm {
int nId ; // Id della lavorazione corrente
int nIdTool ; // Id dell'utensile corrente
int nGroup ; // Gruppo di appartenenza della lavorazione
double dX_Start ; // Stato iniziale asse lineare X
double dY_Start ; // Stato iniziale asse lineare Y
double dZ_Start ; // Stato iniziale asse lineare Z
double dA_Start ; // Stato iniziale asse rotante A
double dB_Start ; // Stato iniziale asse rotante B
double dC_Start ; // Stato iniziale asse rotante C
double dX_End ; // Stato finale asse lineare X
double dY_End ; // Stato finale asse lineare Y
double dZ_End ; // Stato finale asse lineare Z
double dA_End ; // Stato finale asse rotante A
double dB_End ; // Stato finale asse rotante B
double dC_End ; // Stato finale asse rotante C
MachOptm( int nIdL, int nToolL, int nGroupL,
double dX_Start, double dY_Start, double dZ_Start, double dA_Start, double dB_Start, double dC_Start,
double dX_End, double dY_End, double dZ_End, double dA_End, double dB_End, double dC_End) :
nId( nIdL), nIdTool( nToolL), nGroup( nGroupL),
dX_Start( dX_Start), dY_Start( dY_Start), dZ_Start( dZ_Start),
dA_Start( dA_Start) , dB_Start( dB_Start), dC_Start( dC_Start),
dX_End( dX_End), dY_End( dY_End), dZ_End( dZ_End),
dA_End( dA_End), dB_End( dB_End), dC_End( dC_End) {}
MachOptm()
: nId( -1), nIdTool( -1), nGroup( -1),
dX_Start( 0.), dY_Start( 0.), dZ_Start( 0.),
dA_Start( 0.) , dB_Start( 0.), dC_Start( 0.),
dX_End( 0.), dY_End( 0.), dZ_End( 0.),
dA_End( 0.), dB_End( 0.), dC_End( 0.) {} ;
} ;
typedef std::vector<MachOptm> MACHOPTMVECTOR ;
typedef std::vector<MACHOPTMVECTOR> MACHOPTMMATRIX ;
// Definizione struttura per OpenBounds
struct OpenBoundOptm {
int nGroup ;
bool bStartVsEnd ;
int nFlag ;
double dX ;
double dY ;
double dZ ;
OpenBoundOptm( int nOBGroup, bool bOBStartVsEnd, int nOBFlag, double dOBX, double dOBY, double dOBZ )
: nGroup( nOBGroup), bStartVsEnd( bOBStartVsEnd), nFlag( nOBFlag), dX( dOBX), dY( dOBY), dZ( dOBZ) {}
} ;
typedef std::vector<OpenBoundOptm> MACHOPTOPENBOUNDVECTOR ;
//----------------------------------------------------------------------------
class __declspec( novtable) IMachOptimization
{
public :
virtual ~IMachOptimization( void) {}
virtual bool InsertTool( int nId, double dTCX, double dTCY, double dTCZ, double dTCA,
double dTCB, double dTCC, bool bX, bool bY, bool bZ, bool bA,
bool bB, bool bC, double dTLoad, double dTUnL) ;
virtual bool InsertMachining( int nId, int nToolId, int nGroup,
double dX_Start, double dY_Start, double dZ_Start,
double dA_Start, double dB_Start, double dC_Start,
double dX_End, double dY_End, double dZ_End,
double dA_End, double dB_End, double dC_End) = 0 ;
virtual bool InsertDependence( int nIdPrec, int nIdSucc) = 0 ;
virtual bool InsertSuggestedDependences( int nIdPrec, int nIdSucc) = 0 ;
virtual bool SetFirstMachining( int nId) = 0 ;
virtual bool SetLastMachining( int nId) = 0 ;
virtual bool SetFeeds( double dFeedL, double dFeedA) = 0 ;
virtual bool SetAllGroupsAsMandatory( bool bAllMandatory = false) = 0 ;
virtual bool SetOptimizationForGroups( bool bOptForGroups = false) = 0 ;
virtual bool SetOpenBound( bool bStartVsEnd, int nFlag, double dX, double dY, double dZ) = 0 ;
virtual bool SetOpenBoundForGroups( int nGroup, bool bStartVsEnd, int nFlag, double dX, double dY, double dZ) = 0 ;
virtual bool Calculate( INTVECTOR& vIds) = 0 ;
} ;
//-----------------------------------------------------------------------------
ENK_EXPORT IMachOptimization* CreateMachOptimization( void) ;
ENkShortestPath.h
-3
View File
@@ -39,9 +39,6 @@ class __declspec( novtable) IShortestPath
virtual bool Calculate( int nType) = 0 ;
virtual bool GetOrder( INTVECTOR& vOrder) = 0 ;
virtual bool GetMinLength( double& dMinLen) = 0 ;
virtual bool SetConstraintOrder( int nPrev, int nNext) = 0 ;
virtual bool SetSuggestedOrder( int nPrev, int nNext) = 0 ;
virtual bool SetDistMatrix( const INTMATRIX& mDistMatrix) = 0 ;
public :
enum SpType{ SP_NONE = 0,
ENsAutoNester.h
-2
View File
@@ -57,13 +57,11 @@ class __declspec( novtable) IAutoNester
virtual bool SetStripYconstraintToPart( int nPartId, const Point3d& ptRef, double dStripStart, double dStripRepeat) = 0 ;
virtual bool SetStripXconstraintToPart( int nPartId, const Point3d& ptRef, double dStripStart, double dStripRepeat) = 0 ;
virtual bool SetInterpartGap( double dGap) = 0 ;
virtual bool SetShearGap( double dShearGap) = 0 ;
virtual bool SetReportFile( const std::string& sReportFile) = 0 ;
virtual bool Compute( bool bMinimizeOnXvsY, int nMaxTime) = 0 ;
virtual bool CancelComputation( void) = 0 ;
virtual bool GetComputationStatus( int& nStatus) = 0 ;
virtual bool GetResults( double& dTotFillRatio, ANIVECT& vANI) = 0 ;
virtual bool CalcShearSequence( int nNesting, std::vector<Point3d>& vPtStart, std::vector<Point3d>& vPtEnd) = 0 ;
virtual bool PrintResults( const std::string& sHtmlFile) = 0 ;
} ;
EXeConst.h
+30 -45
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2025
// EgalTech 2014-2022
//----------------------------------------------------------------------------
// File : EXeConst.h Data : 11.05.25 Versione : 2.7e2
// File : EXeConst.h Data : 11.01.22 Versione : 2.4a
// Contenuto : Costanti generali per EgtExecuter.
//
//
@@ -13,7 +13,6 @@
#pragma once
#include <string>
//----------------- Costanti per tipo di file ----------------------------------
enum FileType { FT_NULL = 0,
@@ -29,10 +28,8 @@ enum FileType { FT_NULL = 0,
FT_SVG = 18,
FT_BTLX = 19,
FT_3MF = 20,
FT_OBJ = 21,
FT_3DM = 22,
FT_OFF = 23,
FT_PLY = 24,
FT_OBJ = 21,
FT_3DM = 22 ,
FT_IGES = 31,
FT_STEP = 32,
FT_ACIS = 33,
@@ -59,8 +56,7 @@ const int RTY_DEFAULT = RTY_LOC ;
//----------------- Costanti tipo di interpolazione ----------------------------
enum InterpType{ ITT_ARCS = 0, // stima tg Akima, curve risultanti archi
ITT_ARCS_CORNER = 1, // stima tg AkimaCorner, curve risultanti archi
ITT_CUBICS = 2, // stima tg Bessel, curve risultanti Bezier cubiche
ITT_CUBICS_LONG = 3} ; // interpolazione con nurbs, poi convertite in bezier
ITT_CUBICS = 2} ; // stima tg Bessel, curve risultanti Bezier cubiche
//----------------- Costanti tipo di approssimazione di curve ------------------
enum ApprType{ APP_LINES = 0, // come ICurve::APL_STD
@@ -69,8 +65,7 @@ enum ApprType{ APP_LINES = 0, // come ICurve::APL_STD
APP_LEFT_CONVEX_LINES = 11, // come ICurve::APL_LEFT_CONVEX
APP_RIGHT_LINES = 2, // come ICurve::APL_RIGHT
APP_RIGHT_CONVEX_LINES = 12, // come ICurve::APL_RIGHT_CONVEX
APP_ARCS = 3,
APP_CUBIC_BEZIER = 4} ;
APP_ARCS = 3} ;
//----------------- Costanti tipo punto intersezione Linea Curva ---------------
enum CLiType { CLT_NONE = 0,
@@ -86,9 +81,8 @@ enum CLiType { CLT_NONE = 0,
//----------------- Costanti tipo di costruzione di superficie rigata ----------
enum RuledType{ RUL_TYPE_ISOPAR = 0, // come ISurfTrimesh::RLT_ISOPAR
RUL_TYPE_MINDIST = 1, // come ISurfTrimesh::RLT_MINDIST
RUL_TYPE_ISOPAR_SMOOTH = 2} ; // come ISurfTrimesh::RLT_ISOPAR_SMOOTH
RUL_TYPE_ISOPAR_SMOOTH = 3} ; // come ISurfTrimesh::RLT_ISOPAR_SMOOTH
//----------------- Costanti per classificazione di curve rispetto a regioni ---------
enum CrvRegClass { CRC_NULL = 0,
CRC_IN = 1,
CRC_OUT = 2,
@@ -101,10 +95,6 @@ enum RSCapType { RSCT_NONE = 0, // come RSCAP_NONE
RSCT_ROUND = 2, // come RSCAP_ROUND
RSCT_BEVEL = 3} ; // come RSCAP_BEVEL
//----------------- Costanti tipo Zoom -----------------------------------------
enum ZoomType { ZM_ALL = 1, // zoom tutto
ZM_IN = 2, // ingrandisci
ZM_OUT = 3} ; // rimpicciolisci
//----------------- Costanti flag import CNC -----------------------------------
enum EicFlag { EIC_FLAG_NONE = 0, // come EImCncFlag::EICFLAG_NONE
@@ -119,41 +109,36 @@ enum EibFlag { EIB_FLAG_NONE = 0, // come EImBtlFlag::EIBFLAG_NONE
EIB_FLAG_SPECIAL_TRIM = 4} ; // come EImBtlFlag::EIBFLAG_SPECIAL_TRIM
//----------------- Costanti tipo costruzione pezzi piani ----------------------
enum FpcType { FPC_NGE = 0, // costruzione da pezzo Nge
FPC_REGION = 1, // costruzione da regione
FPC_LAYER = 2, // costruzione da layer
FPC_CLOSEDCURVE = 3} ; // costruzione da curva chiusa
enum FpcType{ FPC_NGE = 0, // costruzione da pezzo Nge
FPC_REGION = 1, // costruzione da regione
FPC_LAYER = 2, // costruzione da layer
FPC_CLOSEDCURVE = 3} ; // costruzione da curva chiusa
//----------------- Costanti tipo interferenza di lavorazioni piane ------------
enum FmiType { FMI_NONE = 0, // nessuna interferenza
FMI_LI = 1, // interferenza con attacco
FMI_RM = 2, // interferenza con lavorazione ridotta
FMI_LO = 4} ; // interferenza con uscita
enum FmiType{ FMI_NONE = 0, // nessuna interferenza
FMI_LI = 1, // interferenza con attacco
FMI_RM = 2, // interferenza con lavorazione ridotta
FMI_LO = 4} ; // interferenza con uscita
//----------------- Costanti risultato verifica tagli lama allungati -----------
enum CarRes { CAR_INTERF = 0, // interferiscono entrambi gli allungamenti
CAR_LI_OK = 1, // allungamento inizio va bene
CAR_LO_OK = 2, // allungameno uscita va bene
CAR_LI_LO_OK = 1 + 2} ; // entrambi gli allungamenti vanno bene
enum CarRes{ CAR_INTERF = 0, // interferiscono entrambi gli allungamenti
CAR_LI_OK = 1, // allungamento inizio va bene
CAR_LO_OK = 2, // allungameno uscita va bene
CAR_LI_LO_OK = 1 + 2} ; // entrambi gli allungamenti vanno bene
//----------------- Costanti tipo controllo lavorazione vuota -------------------
enum EmptyNeed { EMP_NEED_GEOM = 0, // necessaria solo presenza geometria di definizione
EMP_NEED_ONE_TP_OK = 1, // almeno un percorso utensile non vuoto
EMP_NEED_ALL_TP_OK = 2} ; // tutti i percorsi utensile non vuoti
//----------------- Costanti tipo Zoom -----------------------------------------
enum ZoomType { ZM_ALL = 1, // zoom tutto
ZM_IN = 2, // ingrandisci
ZM_OUT = 3} ; // rimpicciolisci
//----------------- Costanti errore simulatore in cieco ------------------------
enum SimHideErr { SHE_NONE = 0, // nessun errore
SHE_INIT = 1, // errore nell'avvio della simulazione
SHE_OUTSTROKE = 2, // errore di extracorsa
SHE_DIR_ERR = 3, // errore direzione utensile non raggiungibile
SHE_COLLISION = 4, // errore collisione testa-pezzo
SHE_SPECIAL = 5, // errore speciale/custom
SHE_GENERAL = 6} ; // errore generico
//----------------- Costanti Offset per VolZmap --------------------------------
enum VolZmapOffset { FILLET = 0 , // come in VolZmap
CHAMFER = 1, // come in VolZmap
EXTEND = 2 } ; // come in VolZmap
enum SimHideErr { SHE_NONE = 0, // nessun errore
SHE_INIT = 1, // errore nell'avvio della simulazione
SHE_OUTSTROKE = 2, // errore di extracorsa
SHE_DIR_ERR = 3, // errore direzione utensile non raggiungibile
SHE_COLLISION = 4, // errore collisione testa-pezzo
SHE_SPECIAL = 5, // errore speciale/custom
SHE_GENERAL = 6} ; // errore generico
//----------------- Costanti per sostituzione direttorio e nome progetto --------------------
const std::string SUB_PROJECT_DIR = "%PRJDIR%" ;
EXeExecutor.h
+46 -235
View File
@@ -37,7 +37,7 @@ class LuaMgr ;
// General
EXE_EXPORT bool ExeInit( int nDebug, const std::string& sLogFile, const std::string& sLogMsg) ;
EXE_EXPORT bool ExeExit( void) ;
EXE_EXPORT bool ExeSetOnTerminateProcess( psfOnTerminateProcess pFun) ;
EXE_EXPORT bool ExeSetOnTerminateProcess( pfOnTerminateProcess pFun) ;
EXE_EXPORT bool ExeOnTerminateProcess( int nExitCode) ;
EXE_EXPORT int ExeGetDebugLevel( void) ;
EXE_EXPORT bool ExeSetUserLevel( int nUserLev) ;
@@ -72,9 +72,9 @@ EXE_EXPORT bool ExeOutLog( const std::string& sMsg, int nDebugLevel = 0) ;
EXE_EXPORT bool ExeSetEnableUI( bool bEnableUI) ;
EXE_EXPORT bool ExeGetEnableUI( void) ;
EXE_EXPORT int ExeMessageBox( const std::string& sText, const std::string& sTitle, int nType) ;
EXE_EXPORT bool ExeSetProcessEvents( psfProcEvents pFun) ;
EXE_EXPORT bool ExeSetProcessEvents( pfProcEvents pFun) ;
EXE_EXPORT int ExeProcessEvents( int nProg, int nPause) ;
EXE_EXPORT bool ExeSetOutText( psfOutText pFun) ;
EXE_EXPORT bool ExeSetOutText( pfOutText pFun) ;
EXE_EXPORT bool ExeOutText( const std::string& sText) ;
EXE_EXPORT bool ExeSetTempDir( const std::string& sTempDir) ;
EXE_EXPORT bool ExeGetTempDir( std::string& sTempDir) ;
@@ -111,8 +111,8 @@ EXE_EXPORT bool ExeNewFile( void) ;
EXE_EXPORT bool ExeOpenFile( const std::string& sFilePath) ;
EXE_EXPORT bool ExeInsertFile( const std::string& sFilePath) ;
EXE_EXPORT bool ExeSaveFile( const std::string& sFilePath, int nFlag) ;
EXE_EXPORT bool ExeSaveObjToFile( const INTVECTOR& vId, const std::string& sFilePath, int nFlag) ;
EXE_EXPORT bool ExeSaveMachGroupToFile( int nMGroupId, const INTVECTOR& vPlusId, const std::string& sFilePath, int nFlag) ;
EXE_EXPORT bool ExeSaveObjToFile( int nId, const std::string& sFilePath, int nFlag) ;
EXE_EXPORT bool ExeSaveMachGroupToFile( int nMGroupId, const std::string& sFilePath, int nFlag) ;
// Exchange
EXE_EXPORT int ExeGetFileType( const std::string& sFilePath) ;
@@ -124,9 +124,7 @@ EXE_EXPORT bool ExeImportCsf( const std::string& sFilePath) ;
EXE_EXPORT bool ExeImportDxf( const std::string& sFilePath, double dScaleFactor) ;
EXE_EXPORT bool ExeImportPnt( const std::string& sFilePath, int nFlag) ;
EXE_EXPORT bool ExeImportStl( const std::string& sFilePath, double dScaleFactor) ;
EXE_EXPORT bool ExeImportOff( const std::string& sFilePath, double dScaleFactor) ;
EXE_EXPORT bool ExeImportPly( const std::string& sFilePath, double dScaleFactor) ;
EXE_EXPORT bool ExeImport3MF( const std::string& sFilePath, int nFlag = 0) ;
EXE_EXPORT bool ExeImport3MF( const std::string& sFilePath) ;
EXE_EXPORT bool ExeImport3dm( const std::string& sFilePath) ;
EXE_EXPORT bool ExeAdvancedImportIsEnabled( void) ;
EXE_EXPORT bool ExeAdvancedImport( const std::string& sFilePath, double dToler = 0.1, int nFlag = 0) ;
@@ -160,13 +158,11 @@ EXE_EXPORT int ExeBeamModifyProcess( int nGeomId, int nGroup, int nProc, int nS
int nCrvId, int nCrv2Id, bool bUpdate = true) ;
EXE_EXPORT bool ExeBeamEraseProcess( int nGeomId, bool bUpdate = true) ;
EXE_EXPORT bool ExeBeamEnableProcess( int nGeomId, bool bEnable, bool bUpdate = true) ;
EXE_EXPORT bool ExeBeamCalcAllSolids( bool bShow, bool bRecalc = false) ;
EXE_EXPORT bool ExeBeamShowAllSolids( bool bShow) ;
EXE_EXPORT bool ExeBeamCalcSolid( int nPartId, bool bRecalc = false) ;
EXE_EXPORT int ExeBeamGetSolid( int nPartId) ;
EXE_EXPORT bool ExeBeamShowSolid( int nPartId, bool bShow) ;
EXE_EXPORT bool ExeBeamGetBuildingIsOn( int nAssGrpId) ;
EXE_EXPORT bool ExeBeamShowBuilding( int nAssGrpId, bool bShow) ;
EXE_EXPORT bool ExeBeamGetBuildingIsOn( void) ;
EXE_EXPORT bool ExeBeamShowBuilding( bool bShow) ;
// Tsc Executor
EXE_EXPORT bool ExeInitTscExec( void) ;
@@ -215,29 +211,6 @@ EXE_EXPORT bool ExeSpCalculate( int nType) ;
EXE_EXPORT bool ExeSpGetOrder( INTVECTOR& vOrder) ;
EXE_EXPORT bool ExeSpGetMinLength( double& dMinLen) ;
// Machining Order Optimization
EXE_EXPORT bool ExeOptMachInit( void) ;
EXE_EXPORT bool ExeOptMachTerminate( void) ;
EXE_EXPORT bool ExeOptMachAddTool( int nId,
double dTCX, double dTCY, double dTCZ, double dTCA, double dTCB, double dTCC,
bool bX, bool bY, bool bZ, bool bA, bool bB, bool bC,
double dTLoad, double dTUnL) ;
EXE_EXPORT bool ExeOptMachAddMachining( int nId, int nToolId, int nGroup,
double dX_Start, double dY_Start, double dZ_Start,
double dA_Start, double dB_Start, double dC_Start,
double dX_End, double dY_End, double dZ_End,
double dA_End, double dB_End, double dC_End) ;
EXE_EXPORT bool ExeOptMachSetFirstMachining( int nId) ;
EXE_EXPORT bool ExeOptMachSetLastMachining( int nId) ;
EXE_EXPORT bool ExeOptMachSetFeeds( double dFeedL, double dFeedA) ;
EXE_EXPORT bool ExeOptMachAddDependence( int nIdPrec, int nIdNext) ;
EXE_EXPORT bool ExeOptMachAddSuggestedDependence( int nIdPrec, int nIdNext) ;
EXE_EXPORT bool ExeOptMachSetAllGroupDependencesAsMandatory( bool bAllMandatory) ;
EXE_EXPORT bool ExeOptMachSetOptimizationForGroups( bool bOptForGroups) ;
EXE_EXPORT bool ExeOptMachSetOpenBound( bool bStartVsEnd, int nFlag, double dX, double dY, double dZ) ;
EXE_EXPORT bool ExeOptMachSetOpenBoundForGroups( int nGroup, bool bStartVsEnd, int nFlag, double dX, double dY, double dZ) ;
EXE_EXPORT bool ExeOptMachCalculate( INTVECTOR& vIds) ;
// GeomDB Create
EXE_EXPORT int ExeCreateGroup( int nParentId, const Frame3d& frFrame, int nRefType) ;
EXE_EXPORT int ExeCreateGeoPoint( int nParentId, const Point3d& ptP, int nRefType) ;
@@ -302,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,
@@ -324,7 +295,6 @@ EXE_EXPORT int ExeCreateCurveChamfer( int nParentId, int nCrv1, const Point3d&
EXE_EXPORT int ExeCreateCurveBezier( int nParentId, int nDegree, const PNTVECTOR& vPnt, int nRefType) ;
EXE_EXPORT int ExeCreateCurveBezierRational( int nParentId, int nDegree, const PNTUVECTOR& vPntW, int nRefType) ;
EXE_EXPORT int ExeCreateCurveBezierFromArc( int nParentId, int nArcId, bool bErase) ;
EXE_EXPORT int ExeCreateCurveBezierFromCurve( int nParentId, int nCrvId, bool bRational = true) ;
EXE_EXPORT int ExeCreateCurveCompo( int nParentId, const INTVECTOR& vIds, bool bErase) ;
EXE_EXPORT int ExeCreateCurveCompoByChain( int nParentId, const INTVECTOR& vIds,
const Point3d& ptNear, bool bErase, int nRefType, int* pnCount) ;
@@ -351,7 +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) ;
// 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) ;
@@ -360,7 +329,6 @@ EXE_EXPORT int ExeCreateSurfFrRectangle3P( int nParentId, const Point3d& ptIni,
const Point3d& ptCross, const Point3d& ptDir, int nRefType) ;
EXE_EXPORT int ExeCreateSurfFrStadium( int nParentId, const Point3d& ptIni, const Point3d& ptCross, int nRefType) ;
EXE_EXPORT int ExeCreateSurfFrDisk( int nParentId, const Point3d& ptOrig, double dRad, int nRefType) ;
EXE_EXPORT int ExeCreateSurfTmEmpty( int nParentId) ;
EXE_EXPORT int ExeCreateSurfTmPlaneInBBox( int nParentId, const Point3d& ptP, const Vector3d& vtN, const BBox3d& b3Box, int nRefType) ;
EXE_EXPORT int ExeCreateSurfTmConvexHullInBBox( int nParentId, int nId, const BBox3d& b3Box, int nRefType) ;
EXE_EXPORT int ExeCreateSurfTmBBox( int nParentId, const BBox3d& b3Box, bool bRegular, int nRefType) ;
@@ -374,13 +342,8 @@ EXE_EXPORT int ExeCreateSurfTmCone( int nParentId, const Point3d& ptOrig, const
double dRad, double dHeight, double dLinTol, int nRefType) ;
EXE_EXPORT int ExeCreateSurfTmSphere( int nParentId, const Point3d& ptOrig,
double dRad, double dLinTol, int nRefType) ;
EXE_EXPORT int ExeCreateSurfTmPyramidFrustum( int nParentId, double dBaseDimX, double dBaseDimY,
double dTopDimX, double dTopDimY, double dHeight) ;
EXE_EXPORT int ExeCreateSurfTmConeFrustum( int nParentId, double dBaseRad, double dTopRad, double dHeight, double dLinTol) ;
EXE_EXPORT int ExeCreateSurfTmTriangle( int nParentId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptP3, int nRefType) ;
EXE_EXPORT int ExeCreateSurfTmRectangle( int nParentId, const Point3d& ptO, const Point3d& ptL, const Point3d& ptT, int nRefType) ;
EXE_EXPORT int ExeCreateSurfTmByPolygon( int nParentId, const PolyLine& PL, int nRefType) ;
EXE_EXPORT int ExeCreateSurfTmByPolygonWithHoles( int nParentId, const POLYLINEVECTOR& vPL, int nRefType) ;
EXE_EXPORT int ExeCreateSurfTmByFlatContour( int nParentId, int nCrvId, double dLinTol) ;
EXE_EXPORT int ExeCreateSurfTmByRegion( int nParentId, const INTVECTOR& vCrvIds, double dLinTol) ;
EXE_EXPORT int ExeCreateSurfTmByExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vector3d& vtExtr,
@@ -402,41 +365,20 @@ EXE_EXPORT int ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrC
EXE_EXPORT int ExeCreateSurfTmByTriangles( int nParentId, const INTVECTOR& vIds, bool bErase) ;
EXE_EXPORT int ExeCreateSurfTmBySewing( int nParentId, const INTVECTOR& vIds, bool bErase) ;
EXE_EXPORT int ExeCreateSurfTmByVolZmap( int nParentId, int nZmapId, int nPart) ;
EXE_EXPORT int ExeCreateSurfShell( int nParentId, int nSurfId, double dThick, double dLinTol) ;
EXE_EXPORT int ExeSurfTmOffset( int nParentId, const INTVECTOR& vIds, double dOffs, double dLinTol, int nType) ;
EXE_EXPORT int ExeSurfTmThickeningOffset( int nParentId, const INTVECTOR& vIds, double dOffs, double dLinTol, int nType) ;
EXE_EXPORT int ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTVECTOR& vPnt, int nRefType) ;
EXE_EXPORT int ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTUVECTOR& vPntW, int nRefType) ;
EXE_EXPORT int ExeCreateSurfBezierLeaves( int nParentId, int nSurfBzId, int nTextHeight = 50, bool bShowTrim = false, bool bRefined = false, int* pnCount = nullptr) ;
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, int* pnCount = nullptr) ;
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 ExeCreateSurfBzRuledGuided( int nParentId, int nCrvId1, int nCrvId2, const BIPNTVECTOR& vGuidesCrv,
bool bCapEnds, double dLinTol, int nLayGuides = GDB_ID_NULL) ;
EXE_EXPORT int ExeCreateSurfBzSkinned( int nParentId, const INTVECTOR& nCrvId1, bool bCapEnds, double dLinTol) ;
EXE_EXPORT int ExeCreateSurfBzSwept( int nParentId, int nSectId, int nGuideId, const Vector3d& vtAx,
bool bCapEnds, double dLinTol, int nRefType) ;
// 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, double dExtraBox = 0) ;
EXE_EXPORT int ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDex) ;
EXE_EXPORT bool ExeUpdateVolZmapByAddingSurfTm( int nParentId, int nZmapId, int nStmId) ;
// GeomDB PartLayer
EXE_EXPORT bool ExeIsPart( int nPartId) ;
@@ -496,16 +438,11 @@ EXE_EXPORT int ExeGetFirstNameInGroup( int nGroupId, const std::string& sName)
EXE_EXPORT int ExeGetNextName( int nId, const std::string& sName) ;
EXE_EXPORT int ExeGetLastNameInGroup( int nGroupId, const std::string& sName) ;
EXE_EXPORT int ExeGetPrevName( int nId, const std::string& sName) ;
EXE_EXPORT bool ExeGetNameInGroup( int nGroupId, const std::string& sName, INTVECTOR& vIds) ;
EXE_EXPORT bool ExeGetInfoInGroup( int nGroupId, const std::string& sKey, INTVECTOR& vIds) ;
EXE_EXPORT bool ExeGetBBox( int nId, int nFlag, BBox3d& b3Box) ;
EXE_EXPORT bool ExeGetBBoxGlob( int nId, int nFlag, BBox3d& b3Box) ;
EXE_EXPORT bool ExeGetBBoxRef( int nId, int nFlag, const Frame3d& frRef, BBox3d& b3Box) ;
EXE_EXPORT int ExeCopy( int nSouId, int nRefId, int nSonBeforeAfter) ;
EXE_EXPORT int ExeCopyEx( int nSouCtx, int nSouId, int nDestCtx, int nRefId, int nSonBeforeAfter) ;
EXE_EXPORT int ExeCopyGlob( int nSouId, int nRefId, int nSonBeforeAfter) ;
EXE_EXPORT int ExeCopyGlobEx( int nSouCtx, int nSouId, int nDestCtx, int nRefId, int nSonBeforeAfter) ;
EXE_EXPORT bool ExeDuplicateGeomDB( int nSouCtx, int nDestCtx, bool bSkipTemp = false) ;
EXE_EXPORT bool ExeRelocate( int nSouId, int nRefId, int nSonBeforeAfter) ;
EXE_EXPORT bool ExeRelocateGlob( int nSouId, int nRefId, int nSonBeforeAfter) ;
EXE_EXPORT bool ExeGroupSwap( int nId1, int nId2, bool bSwapRef, bool bMark) ;
@@ -520,11 +457,11 @@ EXE_EXPORT bool ExeGeoObjDump( int nId, std::string& sDump) ;
// GeomDB Obj Attributes
EXE_EXPORT bool ExeCopyAttributes( int nSouId, int nDestId) ;
EXE_EXPORT bool ExeSetLevel( const INTVECTOR& vIds, int nLevel) ;
EXE_EXPORT bool ExeSetLevel( int nId, int nLevel) ;
EXE_EXPORT bool ExeRevertLevel( int nId) ;
EXE_EXPORT bool ExeGetLevel( int nId, int* pnLevel) ;
EXE_EXPORT bool ExeGetCalcLevel( int nId, int* pnLevel) ;
EXE_EXPORT bool ExeSetMode( const INTVECTOR& vIds, int nMode) ;
EXE_EXPORT bool ExeSetMode( int nId, int nMode) ;
EXE_EXPORT bool ExeRevertMode( int nId) ;
EXE_EXPORT bool ExeGetMode( int nId, int* pnMode) ;
EXE_EXPORT bool ExeGetCalcMode( int nId, int* pnMode) ;
@@ -532,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) ;
@@ -576,7 +513,6 @@ EXE_EXPORT bool ExeSetTextureFrame( int nId, const Frame3d& frTxrRef, int nRefTy
EXE_EXPORT bool ExeRemoveTextureData( int nId) ;
EXE_EXPORT bool ExeGetTextureName( int nId, std::string& sTxrName) ;
EXE_EXPORT bool ExeGetTextureFrame( int nId, int nRefId, Frame3d& frTxrRef) ;
EXE_EXPORT bool ExeSetStipple( int nId, int nFactor, int nPattern) ;
// GeomDb Obj Selection
EXE_EXPORT bool ExeSetObjFilterForSelect( bool bZerodim, bool bCurve, bool bSurf, bool bVolume, bool bExtra) ;
@@ -643,7 +579,6 @@ EXE_EXPORT int ExeGetCurveLinearConvexHullXY( int nId, double dLinTol, int nRef
EXE_EXPORT bool ExeModifyCircleCP( int nId, const Point3d& ptOn, int nRefType) ;
EXE_EXPORT bool ExeModifyCircle3P( int nId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptP3, int nRefType) ;
EXE_EXPORT bool ExeModifyArcRadius( int nId, double dRad, bool bKeepCenter = true) ;
EXE_EXPORT bool ExeModifyArcAngCenter( int nId, double dAngCenter) ;
EXE_EXPORT bool ExeModifyArcC2P( int nId, const Point3d& ptEnd, int nRefType) ;
EXE_EXPORT bool ExeModifyArc3P( int nId, const Point3d& ptMid, int nRefType) ;
EXE_EXPORT bool ExeModifyArcToExplementary( int nId) ;
@@ -665,23 +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, double dToler = 10 * EPS_SMALL) ;
EXE_EXPORT bool ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType, double dToler = 10 * EPS_SMALL) ;
EXE_EXPORT bool ExeProjectCurveOnSurf( int nCurveId, const INTVECTOR& vnSurfId, int nDestGrpId,
double dLinTol, double dMaxSegmLen) ;
EXE_EXPORT bool ExeProjectCurveOnSurfDir( int nCurveId, const INTVECTOR& vnSurfId, const Vector3d& vtProj, int nDestGrpId,
double dLinTol, double dMaxSegmLen, bool bDirFromProj, bool bFromVsTo, int nRefType) ;
EXE_EXPORT bool ExeProjectCurveOnSurfExt( int nCurveId, const INTVECTOR& vnSurfId, int nGuideId, int nDestGrpId,
double dLinTol, double dMaxSegmLen, bool bDirFromGuide, bool bFromVsTo) ;
EXE_EXPORT int ExeCurveGetVoronoi( const INTVECTOR& vIds, int nDestGrpId, int nBound, int* pnCount) ;
EXE_EXPORT int ExeCurveGetMedialAxis( const INTVECTOR& vIds, int nDestGrpId, int nSide, int* pnCount) ;
EXE_EXPORT 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 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) ;
@@ -692,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) ;
@@ -702,6 +628,7 @@ EXE_EXPORT bool ExeSurfTmRemoveFacet( int nId, int nFacet) ;
EXE_EXPORT bool ExeSurfTmSwapFacets( int nId, int nFacet1, int nFacet2) ;
EXE_EXPORT bool ExeSurfTmRemovePart( int nId, int nPart) ;
EXE_EXPORT bool ExeCutSurfTmPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
EXE_EXPORT bool ExeCutSurfBzPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
EXE_EXPORT bool ExeCutSurfTmClosedCurve( int nSurfId, int nCurveId, bool bSaveOnEq) ;
EXE_EXPORT bool ExeSurfTmAdd( int nId1, int nId2, bool bTwoColors = false) ;
EXE_EXPORT bool ExeSurfTmSubtract( int nId1, int nId2, bool bTwoColors = false) ;
@@ -711,21 +638,14 @@ 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 ExeSurfTmSetSmoothAng( int nId, double dAngDeg) ;
EXE_EXPORT bool ExeSurfTmGetSmoothAng( int nId, double& dAngDeg) ;
EXE_EXPORT bool ExeCutSurfBzPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) ;
EXE_EXPORT bool ExeSurfBzTrim( int nId, int nCutterId) ;
// GeomDb Volume Modify
EXE_EXPORT int ExeExplodeVolume( int nId, int* pnCount) ;
EXE_EXPORT bool ExeVolZmapChangeResolution( int nId, int nNewRes) ;
EXE_EXPORT bool ExeVolZmapSetShowEdges( int nId, bool bShow) ;
EXE_EXPORT bool ExeVolZmapGetShowEdges( int nId, bool& bShow) ;
EXE_EXPORT bool ExeRemoveVolZmapPart( int nId, int nPart) ;
EXE_EXPORT bool ExeVolZmapSetStdTool( const INTVECTOR& vIds, const std::string& sToolName,
double dLen, double dDiam, double dCornR, double dCutterH, int nFlag, bool bFirst) ;
@@ -738,8 +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,
@@ -747,10 +665,6 @@ EXE_EXPORT bool ExeVolZmapMillingStep( int nId, const Point3d& ptPs, const Vecto
EXE_EXPORT bool ExeVolZmapMillingStep( int nId, const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe, int nRefType) ;
EXE_EXPORT bool ExeCutVolZmapPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, int nRefType) ;
EXE_EXPORT bool ExeUpdateVolZmapByAddingSurfTm( int nVolZmapId, int nStmId) ;
EXE_EXPORT bool ExeVolZmapMakeUniform( int nVolZmapId, double dToler, bool bExtensionFirst, int nToolNum) ;
EXE_EXPORT bool ExeVolZMapOffset( int nId, double dDist, int nType) ;
EXE_EXPORT bool ExeVolZMapRemoveFins( int nVolZMapId, const Vector3d& vtDir, double dThick, int nRefType) ;
// GeomDB Get
EXE_EXPORT bool ExeTextNormVersor( int nId, int nRefId, Vector3d& vtNorm) ;
@@ -760,13 +674,12 @@ EXE_EXPORT bool ExeTextGetHeight( int nId, double& dH) ;
EXE_EXPORT bool ExeTextGetItalic( int nId, bool& bItl) ;
// GeomDb Get Pocketing
EXE_EXPORT bool ExePocketing( int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId, int& nFirstId, int& nCrvCount) ;
EXE_EXPORT int ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, bool bRemoveOverlapLink,int* pnCount) ;
EXE_EXPORT bool ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId, int& nFirstId, int& nCrvCount) ;
EXE_EXPORT int ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, bool bRemoveOverlapLink,int* pnCount) ;
// 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) ;
@@ -777,7 +690,6 @@ EXE_EXPORT bool ExeCurveIsARectangle( int nId, Point3d& ptP, Vector3d& vtL1, Vec
EXE_EXPORT bool ExeCurveIsATrapezoid( int nId, Point3d& ptP, Vector3d& vtB1, Vector3d& vtL1, Vector3d& vtB2, double dToler = EPS_SMALL) ;
EXE_EXPORT bool ExeCurveAreaXY( int nId, double& dArea) ;
EXE_EXPORT bool ExeCurveArea( int nId, Plane3d& Plane, double& dArea) ;
EXE_EXPORT bool ExeCurveMaxOffset( int nId, double& dMaxOffset) ;
EXE_EXPORT bool ExeCurveNearestExtremityToPoint( int nId, const Point3d& ptP, bool& bStart) ;
EXE_EXPORT bool ExeCurveExtrusion( int nId, int nRefId, Vector3d& vtExtr) ;
EXE_EXPORT bool ExeCurveThickness( int nId, double* pdThick) ;
@@ -794,11 +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) ;
EXE_EXPORT int ExeCopyCompoSubCurve( int nCrvId, int nSubCrvToCopy, int nDestGrpId) ;
EXE_EXPORT int ExeCopyParamRange( int nCrvId, double dUStart, double dUEnd, int nDestGrpId) ;
// GeomDb Surf Get
EXE_EXPORT bool ExeSurfArea( int nId, double& dArea) ;
@@ -806,21 +713,16 @@ 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 int ExeSurfFlatRegionInterference( int nId1, int nChunk1, int nId2, int nChunk2, double dToler = 0) ;
EXE_EXPORT bool ExeSurfFrChunkCenter( int nId, int nChunk, int nRefId, Point3d& ptCen, Vector3d& vtN) ;
EXE_EXPORT int ExeExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount) ;
EXE_EXPORT int ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, int* pnCount) ;
EXE_EXPORT int ExeSurfTmVertexCount( int nId) ;
EXE_EXPORT int ExeSurfTmFacetCount( int nId) ;
EXE_EXPORT int ExeSurfTmPartCount( int nId) ;
EXE_EXPORT bool ExeSurfTmGetPartAndShellFromFacet( int nSurfTm, int nFacet, int& nPart, int& nShell) ;
EXE_EXPORT bool ExeSurfTmGetVertex( int nId, int nVert, int nRefId, Point3d& ptVert) ;
EXE_EXPORT bool ExeSurfTmGetNearestVertex( int nId, const Point3d& ptNear, int nRefId, int& nVert, Point3d& ptVert) ;
EXE_EXPORT bool ExeSurfTmTriangleNormVersor( int nId, int nTria, int nRefId, Vector3d& vtNorm) ;
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,
@@ -839,33 +741,24 @@ 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 ExeExtractSurfTmTriaLoop( int nId, int nT, int nDestGrpId) ;
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,
PNTVECTOR& vptStart, VCT3DVECTOR& vvtNorm, DBLVECTOR& vdElev) ;
EXE_EXPORT int ExeSurfTmGetEdges( int nId, int nDestGrpId, bool bSmoothAng, int* pnCount) ;
EXE_EXPORT bool ExeSurfTmGetCurvatures( int nId, int nV, double& dK1, Vector3d& vtK1, double& dK2, Vector3d& vtK2) ;
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,
Point3d& ptP, Vector3d& vtDerU, Vector3d& vtDerV) ;
EXE_EXPORT bool ExeSurfBezierGetPointNrmD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
Point3d& ptP, Vector3d& vtN, Vector3d& vtDerU, Vector3d& vtDerV) ;
EXE_EXPORT bool ExeSurfBezierParamsFromPoint( int nSurfId, const Point3d& ptOnSurf, int nRefId, double& dU, double& dV) ;
EXE_EXPORT bool ExeSurfBezierGetInfo( int nSurfId, int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) ;
EXE_EXPORT int ExeSurfBezierGetCurveU( int nSurfId, double dV, int nDestGrpId) ;
EXE_EXPORT int ExeSurfBezierGetCurveV( int nSurfId, double dU, int nDestGrpId) ;
EXE_EXPORT bool ExeSurfBezierGetInfo( int nSurfId, int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) ;
EXE_EXPORT int ExeSurfBezierGetControlCurveU( int nSurfId, int nIndV, int nDestGrpId) ;
EXE_EXPORT int ExeSurfBezierGetControlCurveV( int nSurfId, int nIndU, int nDestGrpId) ;
EXE_EXPORT int ExeExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount) ;
EXE_EXPORT int ExeShowSurfBezierControlPoints( int nSrfId, int nDestGrpId, int* pnCount) ;
// GeomDb Volume Get
EXE_EXPORT bool ExeVolZmapVolume( int nId, double& dVol) ;
@@ -923,11 +816,9 @@ EXE_EXPORT bool ExePointCurveDistSide( const Point3d& ptP, int nCurveId, const V
double* pdDist, Point3d& ptMin, int* pnSide) ;
EXE_EXPORT bool ExePointSurfTmDist( const Point3d& ptP, int nStmId, int nRefType,
double* pdDist, Point3d& ptMin, int* pnTria) ;
EXE_EXPORT bool ExePointSurfBzDist( const Point3d& ptP, int nSbzId, int nRefType,
double* pdDist, Point3d& ptMin, Vector3d& vtN) ;
// Geo Intersect
EXE_EXPORT bool ExeLineCurveInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
EXE_EXPORT bool ExeLineCurveInters( const Point3d& ptP, const Vector3d& vtDir, const int nId, const int nRefType,
INTDBLVECTOR& vInters) ;
EXE_EXPORT bool ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, const BBox3d& b3Box,
INTDBLVECTOR& vInters) ;
@@ -937,7 +828,7 @@ EXE_EXPORT bool ExeLineSurfBzInters( const Point3d& ptP, const Vector3d& vtDir,
INTDBLVECTOR& vInters) ;
EXE_EXPORT bool ExeLineVolZmapInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
INTDBLVECTOR& vInters) ;
EXE_EXPORT int ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType,
EXE_EXPORT int ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, const int nId, const int nDestGrpId, const int nRefType,
int* pnCount) ;
EXE_EXPORT int ExePlaneBoxInters( const Point3d& ptOn, const Vector3d& vtN, const BBox3d& b3Box, int nDestGrpId, int nRefType,
int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
@@ -947,13 +838,12 @@ EXE_EXPORT int ExeParPlanesSurfTmInters( const Point3d& ptOn, const Vector3d& v
int* pnGrpCount) ;
EXE_EXPORT int ExePlaneVolZmapInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDestGrpId, int nRefType,
int* pnCount) ;
EXE_EXPORT int ExeCurveCurveInters( int nId1, int nId2, int nDestGrpId,
int* pnPntCount, int* pnCrvCount, bool bOnly3D = false) ;
EXE_EXPORT int ExeCurveSurfTmInters( int nCrvId, int nStmId, int nDestGrpId,
EXE_EXPORT int ExeCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId,
int* pnPntCount, int* pnCrvCount) ;
EXE_EXPORT int ExeCurveSurfTmInters( const int nCrvId, const int nStmId, const int nDestGrpId,
int* pnPntCount, int* pnCrvCount) ;
EXE_EXPORT int ExeSurfTmSurfTmInters( int nId1, int nId2, int nDestGrpId, double dToler,
int* pnPntCount, int* pnCrvCount, int* pnSrfCount) ;
EXE_EXPORT bool ExeBBoxOverlap( const BBox3d& bboxA, const Frame3d& frA, const BBox3d& bboxB, const Frame3d& frB) ;
// Collision Detection
EXE_EXPORT int ExeCDeBoxSolid( const Frame3d& frBox, const Vector3d& vtDiag, int nSolidId, double dSafeDist, int nRefType) ;
@@ -973,7 +863,7 @@ EXE_EXPORT int ExeTestRectPrismoidSurface( const Frame3d& frPrismoid, double dB
EXE_EXPORT int ExeTestCylSurface( const Frame3d& frCyl, double dR, double dH, int nSurfId, double dSafeDist, int nRefType) ;
EXE_EXPORT int ExeTestConeSurface( const Frame3d& frCone, double dR1, double dR2, double dH, int nSurfId, double dSafeDist, int nRefType) ;
EXE_EXPORT int ExeTestSpheSurface( const Point3d& ptCen, double dR, int nSurfId, double dSafeDist, int nRefType) ;
EXE_EXPORT int ExeTestSurfaceSurface( int nSurf1Id, int nSurf2Id, double dSafeDist, bool bTestEnclosion = false) ;
EXE_EXPORT int ExeTestSurfaceSurface( int nSurf1Id, int nSurf2Id, double dSafeDist) ;
// Maximum Filler
EXE_EXPORT bool ExeMaxFillerStart( void) ;
@@ -1035,7 +925,6 @@ EXE_EXPORT bool ExeAutoNestSetRestrictedZoneToPart( int nPartId, int nRzConstrId
EXE_EXPORT bool ExeAutoNestSetStripYconstraintToPart( int nPartId, const Point3d& ptRef, double dStripStart, double dStripRepeat) ;
EXE_EXPORT bool ExeAutoNestSetStripXconstraintToPart( int nPartId, const Point3d& ptRef, double dStripStart, double dStripRepeat) ;
EXE_EXPORT bool ExeAutoNestSetInterpartGap( double dGap) ;
EXE_EXPORT bool ExeAutoNestSetShearGap( double dShearGap) ;
EXE_EXPORT bool ExeAutoNestSetReportFile( const std::string& sReportFile) ;
EXE_EXPORT bool ExeAutoNestCompute( bool bMinimizeOnXvsY, int nMaxTime) ;
EXE_EXPORT bool ExeAutoNestCancelComputation( void) ;
@@ -1043,7 +932,6 @@ EXE_EXPORT bool ExeAutoNestGetComputationStatus( int& nStatus) ;
EXE_EXPORT bool ExeAutoNestPrintResults( const std::string& sHtmlFile) ;
EXE_EXPORT bool ExeAutoNestGetResults( int& nNestedParts, int& nParts, int& nSheets, int& nNestings, double& dTotFillRatio) ;
EXE_EXPORT bool ExeAutoNestGetOneResult( int nInd, int& nType, int& nId, int& nFlag, double& dX, double& dY, double& dAngRot) ;
EXE_EXPORT bool ExeAutoNestCalcShearSequence( int nNesting, PNTVECTOR& vPtStart, PNTVECTOR& vPtEnd) ;
// Collision Avoidance Tool SurfaceTriMesh
EXE_EXPORT bool ExeCAvSetStdTool( double dToolLen, double dToolDiam, double dToolCornR) ;
@@ -1099,7 +987,7 @@ EXE_EXPORT bool ExeIsRawPart( int nRawId) ;
EXE_EXPORT int ExeAddRawPart( Point3d ptOrig, double dLength, double dWidth, double dHeight, Color cCol) ;
EXE_EXPORT int ExeAddRawPartWithPart( int nPartId, int nCrvId, double dOverMat, Color cCol) ;
EXE_EXPORT bool ExeModifyRawPart( int nRawId, Point3d ptOrig, double dLength, double dWidth, double dHeight, Color cCol) ;
EXE_EXPORT bool ExeModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dHeight, Color cCol) ;
EXE_EXPORT bool ExeModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dZmin, double dHeight, Color cCol) ;
EXE_EXPORT bool ExeModifyRawPartSize( int nRawId, double dLength, double dWidth, double dHeight) ;
EXE_EXPORT bool ExeModifyRawPartHeight( int nRawId, double dHeight) ;
EXE_EXPORT bool ExeKeepRawPart( int nRawId, int nSouPhase) ;
@@ -1131,9 +1019,6 @@ EXE_EXPORT bool ExeGetTableArea( int nInd, BBox3d& b3Area) ;
EXE_EXPORT bool ExeGetTableAreaOffset( int nInd, BBox3d& b3AreaOffs) ;
EXE_EXPORT bool ExeChangeTable( const std::string& sTable, bool bUpdateDisp) ;
EXE_EXPORT bool ExeShowOnlyTable( bool bVal) ;
EXE_EXPORT bool ExeMoveDispAxis( const std::string& sName, double dPos) ;
EXE_EXPORT bool ExeRemoveDispAxis( const std::string& sName) ;
EXE_EXPORT bool ExeKeepAllDispAxes( int nSouPhase) ;
EXE_EXPORT int ExeAddFixture( const std::string& sName, const Point3d& ptPos, double dAngRotDeg, double dMov) ;
EXE_EXPORT bool ExeKeepFixture( int nFxtId, int nSouPhase) ;
EXE_EXPORT bool ExeRemoveFixture( int nFxtId) ;
@@ -1142,9 +1027,7 @@ EXE_EXPORT int ExeGetFirstFixture( void) ;
EXE_EXPORT int ExeGetNextFixture( int nFxtId) ;
EXE_EXPORT bool ExeMoveFixture( int nFxtId, const Vector3d& vtMove) ;
EXE_EXPORT bool ExeRotateFixture( int nFxtId, double dDeltaAngDeg) ;
EXE_EXPORT bool ExeSetFixtureLink( int nFxtId, const std::string& sTaLink) ;
EXE_EXPORT bool ExeMoveFixtureMobile( int nFxtId, double dDeltaMove) ;
EXE_EXPORT bool ExeSetFixtureMobile( int nFxtId, double dMove) ;
// Tools Database
EXE_EXPORT bool ExeTdbGetToolNewName( std::string& sName) ;
EXE_EXPORT bool ExeTdbAddTool( const std::string& sName, int nType) ;
@@ -1176,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) ;
@@ -1189,7 +1071,6 @@ EXE_EXPORT bool ExeTdbImport( const std::string& sFile, const STRVECTOR& vsTools
EXE_EXPORT int ExeGetCurrSetup( void) ;
EXE_EXPORT bool ExeGetDefaultSetupName( std::string& sName) ;
EXE_EXPORT bool ExeImportSetup( const std::string& sName) ;
EXE_EXPORT bool ExeExistsCurrSetup( void) ;
EXE_EXPORT bool ExeVerifyCurrSetup( STRVECTOR& vsErrors) ;
EXE_EXPORT bool ExeFindToolInCurrSetup( const std::string& sTool) ;
EXE_EXPORT bool ExeGetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) ;
@@ -1232,16 +1113,16 @@ EXE_EXPORT int ExeGetFirstOperation( void) ;
EXE_EXPORT int ExeGetNextOperation( int nId) ;
EXE_EXPORT int ExeGetLastOperation( void) ;
EXE_EXPORT int ExeGetPrevOperation( int nId) ;
EXE_EXPORT int ExeGetFirstActiveOperation( bool bNeedMachNotEmpty = false) ;
EXE_EXPORT int ExeGetNextActiveOperation( int nId, bool bNeedMachNotEmpty = false) ;
EXE_EXPORT int ExeGetLastActiveOperation( bool bNeedMachNotEmpty = false) ;
EXE_EXPORT int ExeGetPrevActiveOperation( int nId, bool bNeedMachNotEmpty = false) ;
EXE_EXPORT int ExeGetFirstActiveOperation( void) ;
EXE_EXPORT int ExeGetNextActiveOperation( int nId) ;
EXE_EXPORT int ExeGetLastActiveOperation( void) ;
EXE_EXPORT int ExeGetPrevActiveOperation( int nId) ;
EXE_EXPORT int ExeGetOperationType( int nId) ;
EXE_EXPORT int ExeGetOperationPhase( int nId) ;
EXE_EXPORT bool ExeSetOperationName( int nId, const std::string& sName) ;
EXE_EXPORT bool ExeGetOperationName( int nId, std::string& sName) ;
EXE_EXPORT int ExeGetOperationId( const std::string& sName) ;
EXE_EXPORT bool ExeIsOperationEmpty( int nId, int nEmptyType = 0) ;
EXE_EXPORT bool ExeIsOperationEmpty( int nId) ;
EXE_EXPORT bool ExeRemoveOperation( int nId) ;
EXE_EXPORT bool ExeRemoveAllPhaseOperations( int nPhase) ;
EXE_EXPORT bool ExeRemoveAllOperations( void) ;
@@ -1259,7 +1140,6 @@ EXE_EXPORT bool ExeRemoveOperationHome( int nId) ;
EXE_EXPORT int ExeGetPhaseDisposition( int nPhase) ;
EXE_EXPORT bool ExeSpecialApplyDisposition( int nId, bool bRecalc) ;
EXE_EXPORT bool ExeSpecialUpdateDisposition( int nId) ;
EXE_EXPORT bool ExeGetDispositionToolData( int nId, std::string& sName, std::string& sHead, int& nExit, std::string& sTcPos) ;
// Machinings
EXE_EXPORT int ExeAddMachining( const std::string& sName, const std::string& sMachining) ;
EXE_EXPORT int ExeAddMachining( const std::string& sName, int nMchType, const std::string& sTool) ;
@@ -1275,22 +1155,17 @@ EXE_EXPORT bool ExeSetMachiningGeometry( const SELVECTOR& vIds) ;
EXE_EXPORT bool ExePreviewMachining( bool bRecalc) ;
EXE_EXPORT bool ExeApplyMachining( bool bRecalc, bool bPostApply = true) ;
EXE_EXPORT bool ExeUpdateMachining( bool bPostApply = true) ;
EXE_EXPORT bool ExeChangePreviewMachiningToolShow( int nLookFlag) ;
EXE_EXPORT bool ExePreparePreviewMachiningTool( void) ;
EXE_EXPORT bool ExeRemovePreviewMachiningTool( void) ;
EXE_EXPORT int ExeGetPreviewMachiningToolStepCount( void) ;
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) ;
EXE_EXPORT bool ExeGetMachiningParam( int nType, std::string& sVal) ;
EXE_EXPORT bool ExeGetMachiningGeometry( SELVECTOR& vIds) ;
EXE_EXPORT bool ExeGetMachiningSkippedGeometry( SELVECTOR& vIds) ;
EXE_EXPORT bool ExeIsMachiningEmpty( int nEmptyType) ;
EXE_EXPORT bool ExeIsMachiningEmpty( void) ;
EXE_EXPORT bool ExeGetMachiningStartPoint( Point3d& ptStart) ;
EXE_EXPORT bool ExeGetMachiningEndPoint( Point3d& ptEnd) ;
EXE_EXPORT bool ExeGetMachiningStartAxes( bool bSkipClimb, DBLVECTOR& vAxVal) ;
EXE_EXPORT bool ExeGetMachiningEndAxes( bool bSkipRise, DBLVECTOR& vAxVal) ;
EXE_EXPORT bool ExeApplyAllMachinings( bool bRecalc, bool bStopOnFirstErr, std::string& sErrList) ;
EXE_EXPORT bool ExeApplyAllMachiningsEx( bool bRecalc, bool bStopOnFirstErr, std::string& sErrList, std::string& sWarnList) ;
EXE_EXPORT bool ExeUpdateAllMachinings( bool bStopOnFirstErr, std::string& sErrList) ;
@@ -1299,13 +1174,9 @@ EXE_EXPORT bool ExeUpdateAllMachiningsEx( bool bStopOnFirstErr, std::string& sEr
EXE_EXPORT bool ExeGetClEntMove( int nEntId, int& nMove) ;
EXE_EXPORT bool ExeGetClEntFlag( int nEntId, int& nFlag, int& nFlag2) ;
EXE_EXPORT bool ExeGetClEntIndex( int nEntId, int& nIndex) ;
EXE_EXPORT bool ExeGetClEntFeed( int nEntId, double& dFeed) ;
EXE_EXPORT bool ExeGetClEntAxesStatus( int nEntId, int& nStatus) ;
EXE_EXPORT bool ExeGetClEntAxesMask( int nEntId, int& nMask) ;
EXE_EXPORT bool ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) ;
EXE_EXPORT bool ExeGetClEntTDir( int nEntId, Vector3d& vtTDir) ;
EXE_EXPORT bool ExeGetClEntCDir( int nEntId, Vector3d& vtCDir) ;
EXE_EXPORT bool ExeGetClEntADir( int nEntId, Vector3d& vtADir) ;
// Simulation
EXE_EXPORT bool ExeSimInit( void) ;
EXE_EXPORT bool ExeSimStart( bool bFirst) ;
@@ -1313,7 +1184,6 @@ EXE_EXPORT bool ExeSimMove( int& nStatus) ;
EXE_EXPORT bool ExeSimHome( void) ;
EXE_EXPORT bool ExeSimSetStep( double dStep) ;
EXE_EXPORT bool ExeSimSetUiStatus( int nUiStatus) ;
EXE_EXPORT bool ExeSimEnableToolTipTrace( bool bEnable) ;
EXE_EXPORT bool ExeSimGetAxisInfoPos( int nI, std::string& sName, std::string& sToken, bool& bLinear, double& dVal) ;
EXE_EXPORT bool ExeSimGetToolInfo( std::string& sName, double& dSpeed) ;
EXE_EXPORT bool ExeSimGetOperationInfo( std::string& sName, int& nType) ;
@@ -1329,11 +1199,9 @@ 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) ;
EXE_EXPORT bool ExeGetAxisDir( const std::string& sAxis, Vector3d& vtDir) ;
EXE_EXPORT bool ExeGetAxisInvert( const std::string& sAxis, bool& bInvert) ;
EXE_EXPORT bool ExeGetAxisOffset( const std::string& sAxis, double& dOffset) ;
EXE_EXPORT bool ExeGetAllTablesNames( STRVECTOR& vNames) ;
@@ -1343,11 +1211,9 @@ EXE_EXPORT bool ExeGetAllTcPosNames( STRVECTOR& vNames) ;
// Machine Calc
EXE_EXPORT bool ExeSetCalcTable( const std::string& sTable) ;
EXE_EXPORT bool ExeSetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) ;
EXE_EXPORT bool ExeSetCalcSolCh( int nScc, bool bExact) ;
EXE_EXPORT bool ExeSetRotAxisBlock( const std::string& sAxis, double dVal) ;
EXE_EXPORT bool ExeGetCalcTable( std::string& sTable) ;
EXE_EXPORT bool ExeGetCalcTool( std::string& sTool, std::string& sHead, int& nExit) ;
EXE_EXPORT bool ExeGetCalcSolCh( int& nScc, bool& bExact) ;
EXE_EXPORT bool ExeGetAllCurrAxesNames( STRVECTOR& vAxName) ;
EXE_EXPORT bool ExeGetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) ;
EXE_EXPORT bool ExeGetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
@@ -1355,11 +1221,9 @@ EXE_EXPORT bool ExeGetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA
EXE_EXPORT bool ExeGetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
int& nStat, DBLVECTOR& vAng1, DBLVECTOR& vAng2) ;
EXE_EXPORT bool ExeGetCalcPositions( const Point3d& ptP, double dAngA, double dAngB,
double& dX, double& dY, double& dZ) ;
int& nStat, double& dX, double& dY, double& dZ) ;
EXE_EXPORT bool ExeGetCalcPositions( const Point3d& ptP, const DBLVECTOR& vAng,
double& dX, double& dY, double& dZ) ;
EXE_EXPORT bool ExeGetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vector3d& vtDirA,
DBLVECTOR& vAng1, DBLVECTOR& vAng2) ;
int& nStat, double& dX, double& dY, double& dZ) ;
EXE_EXPORT bool ExeGetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
bool bBottom, Point3d& ptTip) ;
EXE_EXPORT bool ExeGetCalcTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
@@ -1367,7 +1231,6 @@ EXE_EXPORT bool ExeGetCalcTipFromPositions( double dX, double dY, double dZ, con
EXE_EXPORT bool ExeGetCalcToolDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) ;
EXE_EXPORT bool ExeGetCalcAuxDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) ;
EXE_EXPORT bool ExeVerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) ;
EXE_EXPORT bool ExeVerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, int& nStat) ;
EXE_EXPORT bool ExeGetOutstrokeInfo( std::string& sInfo) ;
// Machine Move
EXE_EXPORT bool ExeSetAxisPos( const std::string& sAxis, double dVal, double* pdNewVal = nullptr) ;
@@ -1388,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) ;
@@ -1399,11 +1262,8 @@ EXE_EXPORT bool ExeSetGridGeo( double dSnapStep, int nMinLineSstep, int nMajLine
EXE_EXPORT bool ExeSetGridGeoAdv( double dSnapStep, int nMinLineSstep, int nMajLineSstep,
double dXmin, double dXmax, double dYmin, double dYmax) ;
EXE_EXPORT bool ExeSetGridColor( Color colMin, Color colMaj) ;
EXE_EXPORT bool ExeSetCameraType( bool bOrthoOrPersp, bool bRedraw) ;
EXE_EXPORT bool ExeSetZoomType( int nMode, bool bRedraw) ;
EXE_EXPORT bool ExeResize( int nW, int nH) ;
EXE_EXPORT bool ExeDraw( void) ;
EXE_EXPORT bool ExeRedraw( void) ;
EXE_EXPORT bool ExeSelect( int nWinX, int nWinY, int nSelW, int nSelH, int* pnSel) ;
EXE_EXPORT bool ExeSetObjFilterForSelWin( bool bZerodim, bool bCurve, bool bSurf, bool bVolume, bool bExtra) ;
EXE_EXPORT bool ExeUnselectableRemove( int nId) ;
@@ -1423,8 +1283,6 @@ EXE_EXPORT bool ExeSetShowCurveDirection( bool bShow, bool bRedraw) ;
EXE_EXPORT bool ExeGetShowCurveDirection( void) ;
EXE_EXPORT bool ExeSetShowTriaAdv( bool bAdvanced, bool bRedraw) ;
EXE_EXPORT bool ExeGetShowTriaAdv( void) ;
EXE_EXPORT bool ExeSetShowSurfBezierTol( double dLinTol, bool bRedraw) ;
EXE_EXPORT double ExeGetShowSurfBezierTol( void) ;
EXE_EXPORT bool ExeSetShowZmap( int nMode, bool bRedraw) ;
EXE_EXPORT int ExeGetShowZmap( void) ;
EXE_EXPORT bool ExeZoomRadius( double dRadius, bool bRedraw) ;
@@ -1461,9 +1319,6 @@ EXE_EXPORT bool ExeGetTextureDimensions( const std::string& sName, double& dDimX
EXE_EXPORT bool ExeChangeTextureDimensions( const std::string& sName, double dDimX, double dDimY) ;
EXE_EXPORT bool ExeGetImage( int nShowMode, Color colBackTop, Color colBackBottom,
int nWidth, int nHeight, const std::string& sFile) ;
EXE_EXPORT bool ExeGetImageEx( int nDriver, bool b2Buff, int nColorBits, int nDepthBits,
int nShowMode, Color colBackTop, Color colBackBottom,
int nCameraDir, int nWidth, int nHeight, const std::string& sFile) ;
// Image
EXE_EXPORT bool ExeGetImagePixels( const std::string& sFile, int& nPixelX, int& nPixelY) ;
@@ -1494,47 +1349,3 @@ EXE_EXPORT int ExeAddPicture( int nParentId, const std::string& sName, const st
EXE_EXPORT bool ExeLoadMessages( const std::string& sMsgFilePath) ;
EXE_EXPORT const std::string& ExeGetLanguage( void) ;
EXE_EXPORT const std::string& ExeGetMsg( int nMsg) ;
// Redis
EXE_EXPORT bool ExeRedisConnect( const std::string& sConnection, int& nIdConnection) ;
EXE_EXPORT bool ExeRedisDisconnect( int nIdConnection) ;
EXE_EXPORT bool ExeRedisSetValFromKey( int nIdConnection, const std::string& sKey, const std::string& sVal) ;
EXE_EXPORT bool ExeRedisGetValFromKey( int nIdConnection, const std::string& sKey, std::string& sVal) ;
EXE_EXPORT bool ExeRedisAsyncConnect( const std::string& sConnection, int& nIdConnection) ;
EXE_EXPORT bool ExeRedisAsyncDisconnect( int nIdConnection) ;
EXE_EXPORT bool ExeRedisAsyncPublish( int nIdConnection, const std::string& sChannel, const std::string& sMessage) ;
EXE_EXPORT bool ExeRedisAsyncSubscribe( int nIdConnection, const std::string& sChannel) ;
EXE_EXPORT bool ExeRedisAsyncUnsubscribe( int nIdConnection, const std::string& sChannel) ;
EXE_EXPORT bool ExeRedisAsyncSubscribeOneMessage( int nIdConnection, const std::string& sChannel, double dMaxTimeOut, std::string& sMessage) ;
EXE_EXPORT bool ExeRedisAsyncGetMessage( int nIdConnection, const std::string& sChannel, int& nCount, std::string& sMessage) ;
// Base64
EXE_EXPORT bool ExeBase64Encode( const std::string& sFile, std::string& sB64Dest) ;
EXE_EXPORT bool ExeBase64Decode( const std::string& sB64Sou, const std::string& sFile) ;
// Trimming
EXE_EXPORT int ExeTrimmingGetSurfTmFaceAdj( int nParentId, int nSurfId, int nTria, const Point3d& vPts,
double dAngTol, double dSize, double dSizeTol) ;
EXE_EXPORT int ExeTrimmingGetSurfTmFromStmFaces( int nParentId, int nSurfId, const INTVECTOR& vFaces) ;
EXE_EXPORT bool ExeTrimmingGetAdjSurfs( const INTVECTOR& vSurfId, const INTVECTOR& vOtherSurfId, double dLinTol,
double dAngTol, double dAngFaceTol, INTVECTOR& vResId) ;
EXE_EXPORT bool ExeTrimmingGetBorders( int nParentId, const SELVECTOR& vIds, double dSurfLinTol, double dSurfAngTol,
double dLinTol, double dAngTol, int& nFirstId, int& nCount) ;
EXE_EXPORT bool ExeTrimmingGetBordersByNormals( int nParentId, const SELVECTOR& vIds, double dSurfLinTol,
double dSurfAngTol, double dLinTol, double dAngTol,
double dThick, int& nFirstId, int& nCount) ;
EXE_EXPORT bool ExeTrimmingGetFinalBorders( int nParentId, const INTVECTOR& vCrvBezierId, double dLinTol, double dAngTol,
const PNTVECTOR& vBreakingPts, double dThick, double dThickTol,
int& nFirstId, int& nCount) ;
EXE_EXPORT int ExeTrimmingGetRuledBezier( int nParentId, const INTVECTOR& vIds, int nEdge1Id, int nEdge2Id, double dLinTol,
const INTVECTOR& vnLineIds) ;
EXE_EXPORT bool ExeTrimmingInterpolateSyncLines( int nParentId, int nSync1Id, int nSync2Id,
int nBorder1Id, int nBorder2Id, double dEdgeLinTol,
double dEdgeAngTol, int& nFirstId, int& nCount) ;
EXE_EXPORT bool ExeTrimmingGetSurfBzSyncPoints( int nParentId, int nEdge1Id, int nEdge2Id, double dLinTol,
double dAngTol, int nLineNbr, bool bShowOnCorners,
int& nFirstId, int& nCount) ;
EXE_EXPORT bool ExeTrimmingGetHoleBorder( int nParentId, const INTVECTOR& vSurfIds, const INTVECTOR& vOtherSurfIds,
double dSurfLinTol, double dSurfAngTol, double dEdgeLinTol, double dEdgeAngTol,
double dEdgeThick, int& nFirstId, int& nCount) ;
EXE_EXPORT int ExeRegolarizeSurfaceLocally( int nParentId, int nSurfId, int nSyncStartId, int nSyncEndId, double dLinTol, int nType) ;
EgtBase64.h
+3 -3
View File
@@ -101,9 +101,9 @@ B64Decode( const std::string& sB64Sou, std::string& sDest)
if ( p != nullptr)
nVal = char( p - EncB64) ;
in[phase] = (( c < 43 || c > 122) ? -1 : (int) DecB64[ c - 43]) ;
if ( in[phase] != 0 )
in[phase] = ((in[phase] == (int)'$') ? -1 : in[phase] - 62) ;
if ( in[phase] != -1 ) {
if ( in[phase] != 0 )
in[phase] = ((in[phase] == (int)'$') ? -1 : in[phase] - 62) ;
if ( in[phase] != -1 ) {
phase = (phase + 1) % 4 ;
if ( phase == 0) {
decodeblock( in, sDest) ;
EgtFunPtrType.h
+5 -9
View File
@@ -1,14 +1,13 @@
//----------------------------------------------------------------------------
// EgalTech 2018-2025
// EgalTech 2018-2023
//----------------------------------------------------------------------------
// File : EgtFunPtrType.h Data : 12.10.25 Versione : 2.7j25
// File : EgtFunPtrType.h Data : 23.11.23 Versione : 2.5k5
// Contenuto : Dichiarazione tipi puntatori a funzione.
//
//
//
// Modifiche : 19.07.18 DS Creazione modulo.
// 23.11.23 DS Aggiunta pfOnTerminateProcess.
// 12.10.25 DS Aggiunta pfCdeclProcEvents.
//
//----------------------------------------------------------------------------
@@ -17,9 +16,6 @@
#include <string>
//----------------------------------------------------------------------------
typedef bool (__stdcall * psfOnTerminateProcess) ( int) ;
typedef int (__stdcall * psfProcEvents) ( int, int) ;
typedef bool (__stdcall * psfOutText) ( const std::string&) ;
//----------------------------------------------------------------------------
typedef int (__cdecl * pcfProcEvents) ( int, int) ;
typedef bool (__stdcall * pfOnTerminateProcess) ( int) ;
typedef int (__stdcall * pfProcEvents) ( int, int) ;
typedef bool (__stdcall * pfOutText) ( const std::string&) ;
EgtKeyCodes.h
+3 -5
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2026
// EgalTech 2015-2024
//----------------------------------------------------------------------------
// File : EgtKeyCodes.h Data : 02.01.26 Versione : 3.1a1
// File : EgtKeyCodes.h Data : 16.01.24 Versione : 2.6a1
// Contenuto : Costanti per codici di protezione librerie di base.
//
//
@@ -18,8 +18,6 @@
// 01.01.22 DS Passaggio a versione 24.
// 01.01.23 DS Passaggio a versione 25.
// 16.01.24 DS Passaggio a versione 26.
// 07.01.25 DS Passaggio a versione 27.
// 02.01.26 DS Passaggio a versione 31.
//
//----------------------------------------------------------------------------
@@ -27,7 +25,7 @@
//----------------------------------------------------------------------------
const int KEY_BASELIB_PROD = 207 ;
const int KEY_BASELIB_VER = 3105 ;
const int KEY_BASELIB_VER = 2604 ;
const int KEY_BASELIB_LEV = 1 ;
//----------------------------------------------------------------------------
EgtNumCollection.h
+9 -17
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2025
// EgalTech 2014-2019
//----------------------------------------------------------------------------
// File : EgtNumCollection.h Data : 21.09.25 Versione : 2.7i2
// File : EgtNumCollection.h Data : 07.07.19 Versione : 2.1g1
// Contenuto : Raccolte di oggetti numerici semplici.
//
//
@@ -16,7 +16,6 @@
#include <vector>
#include <list>
#include <utility>
#include <set>
#include <unordered_set>
//----------------------------------------------------------------------------
@@ -29,8 +28,7 @@ typedef std::list<bool> BOOLLIST ; // lista di bool
typedef std::vector<int> INTVECTOR ; // vettore di interi
typedef std::list<int> INT_LIST ; // lista di interi (con _ per non collidere con Win)
typedef std::vector<std::vector<int>> INTMATRIX ; // matrice di interi
typedef std::set<int> INTSET ; // set di interi
typedef std::unordered_set<int> INTUNORDSET ; // unordered set di interi
typedef std::unordered_set<int> INTUNORDSET ; // unordered set di interi
//----------------------------------------------------------------------------
// Raccolte di interi senza segno
@@ -45,18 +43,12 @@ typedef std::vector<std::vector<double>> DBLMATRIX ; // matrice di double
//----------------------------------------------------------------------------
// Raccolte di coppie integer, integer
typedef std::pair<int,int> INTINT ; // coppia di interi
typedef std::vector<INTINT> INTINTVECTOR ; // vettore di coppie di interi
typedef std::list<INTINT> INTINTLIST ; // lista di coppie di interi
typedef std::pair<int,int> INTINT ; // coppia di interi
typedef std::vector<INTINT> INTINTVECTOR ; // vettore di coppie di interi
typedef std::list<INTINT> INTINTLIST ; // lista di coppie di interi
//----------------------------------------------------------------------------
// Raccolte di coppie integer, double
typedef std::pair<int,double> INTDBL ; // coppia flag, parametro
typedef std::vector<INTDBL> INTDBLVECTOR ; // vettore di coppie flag, parametro
typedef std::list<INTDBL> INTDBLLIST ; // lista di coppie flag, parametro
//----------------------------------------------------------------------------
// Raccolte di coppie double, double
typedef std::pair<double,double> DBLDBL ; // coppia di double
typedef std::vector<DBLDBL> DBLDBLVECTOR ; // vettore di coppie di double
typedef std::list<DBLDBL> DBLDBLLIST ; // lista di coppie di double
typedef std::pair<int,double> INTDBL ; // coppia flag, parametro
typedef std::vector<INTDBL> INTDBLVECTOR ; // vettore di coppie flag, parametro
typedef std::list<INTDBL> INTDBLLIST ; // lista di coppie flag, parametro
EgtNumUtils.h
-21
View File
@@ -13,8 +13,6 @@
#pragma once
#include <cmath>
//----------------------------------------------------------------------------
inline
int Clamp( int nVal, int nMin, int nMax)
@@ -36,22 +34,3 @@ bool IsEven( int nVal)
return ( ( nVal % 2) == 0) ;
}
//----------------------------------------------------------------------------
inline
double Pow( double dBase, int nExp)
{
if ( nExp == 0)
return 1 ;
else if ( nExp < 0) {
if ( dBase < -DBL_EPSILON || dBase > DBL_EPSILON)
return Pow( 1 / dBase, -nExp) ;
else
return NAN ;
}
else {
double dVal = 1 ;
for ( int i = 1 ; i <= nExp ; ++ i)
dVal *= dBase ;
return dVal ;
}
}
EgtPointerOwner.h
+1 -1
View File
@@ -21,7 +21,7 @@ class PtrOwner
public :
explicit PtrOwner( void) : m_pT( nullptr) {}
explicit PtrOwner( T* pT) : m_pT( pT) {}
PtrOwner( PtrOwner<T>&& RPT) noexcept : m_pT( Release( RPT)) {}
PtrOwner( PtrOwner<T>&& RPT) : m_pT( Release( RPT)) {}
PtrOwner( const PtrOwner<T>& RPT) = delete ;
~PtrOwner( void) { Reset() ; }
bool Set( T* pT) { Reset() ; m_pT = pT ; return ( m_pT != nullptr) ; }