Compare commits
14 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Riccardo Elitropi
|
c5db0ed4ad | ||
|
Riccardo Elitropi
|
d4e6fd0749 | ||
|
Riccardo Elitropi
|
03be35f48b | ||
|
Riccardo Elitropi
|
ae036de6e5 | ||
|
Riccardo Elitropi
|
56e27b377f | ||
|
Riccardo Elitropi
|
132edaaa35 | ||
|
Riccardo Elitropi
|
ce380c220e | ||
|
Riccardo Elitropi
|
6e15145bf0 | ||
|
Riccardo Elitropi
|
37cafd5cf7 | ||
|
Riccardo Elitropi
|
8b8cc36ebd | ||
|
Riccardo Elitropi
|
c0c9772dfa | ||
|
Riccardo Elitropi
|
c4f4e33d1f | ||
|
Riccardo Elitropi
|
7c4b3f33d8 | ||
|
Riccardo Elitropi
|
dd6b3ea190 |
@@ -1,13 +1,12 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2016-2024
|
||||
// EgalTech 2016-2020
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkCDeBoxClosedSurfTm.h Data : 24.03.24 Versione : 2.6c2
|
||||
// File : EGkCDeBoxClosedSurfTm.h Data : 09.01.20 Versione : 2.2a2
|
||||
// Contenuto : Dichiarazione funzione verifica collisione tra
|
||||
// BoundingBox e Closed SurfTriMesh.
|
||||
//
|
||||
// Modifiche : 05.10.16 DS Creazione modulo.
|
||||
// 09.01.20 DS Cambio nome alla funzione e cambio parametri.
|
||||
// 24.03.24 DS Aggiunta TestBoxSurfTm.
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -33,8 +32,3 @@
|
||||
// - false in caso di assenza di collisione.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Verifica l'interferenza tra il box e la superficie : restituisce true in caso di interferenza.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool TestBoxSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2020-2024
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkCDeClosedSurfTmClosedSurfTm.h Data : 24.03.24 Versione : 2.6c2
|
||||
// File : EGkCDeClosedSurfTmClosedSurfTm.h Data : 15.02.24 Versione : 2.6b2
|
||||
// Contenuto : Dichiarazione funzione verifica collisione tra
|
||||
// SurfTm e SurfTm.
|
||||
//
|
||||
// Modifiche : 13.11.20 LM Creazione modulo.
|
||||
// 24.03.24 DS Aggiunta TestSurfTmSurfTm.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -30,8 +30,3 @@
|
||||
// - false in caso di assenza di collisione.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Verifica l'interferenza tra le due superfici : restituisce true in caso di interferenza.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist) ;
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2020-2024
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkCDeConeFrustumClosedSurfTm.h Data : 24.03.24 Versione : 2.6c2
|
||||
// File : EGkCDeConeFrustumClosedSurfTm.h Data : 15.02.24 Versione : 2.6b2
|
||||
// Contenuto : Dichiarazione funzione verifica collisione tra
|
||||
// Cone e Closed SurfTriMesh.
|
||||
//
|
||||
// Modifiche : 09.11.20 LM Creazione modulo.
|
||||
// 24.03.24 DS Aggiunta TestConeFrustumSurfTm.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -30,10 +30,4 @@
|
||||
// - true in caso di collisione o inconsistenza dei parametri di input
|
||||
// - false in caso di assenza di collisione.
|
||||
EGK_EXPORT bool CDeConeFrustumClosedSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
|
||||
const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Verifica l'interferenza tra il tronco di cono e la superficie : restituisce true in caso di interferenza.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool TestConeFrustumSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
|
||||
const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
@@ -1,12 +1,12 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2020-2024
|
||||
// EgalTech 2020-2020
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkCDeConvexTorusTria.h Data : 24.03.24 Versione : 2.6c2
|
||||
// File : EGkCDeConvexTorusTria.h Data : 18.11.20 Versione :
|
||||
// Contenuto : Dichiarazione funzione verifica collisione tra
|
||||
// toro convesso e SurfTriMesh.
|
||||
//
|
||||
// Modifiche : 18.11.20 LM Creazione modulo.
|
||||
// 24.03.24 DS Aggiunta TestConvexTorusSurfTm.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -33,9 +33,3 @@
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool CDeConvexTorusClosedSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
|
||||
const ISurfTriMesh& tmSurf, double dSafeDist) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Verifica l'interferenza tra il toro convesso e la superficie : restituisce true in caso di interferenza
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool TestConvexTorusSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
|
||||
const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2020-2024
|
||||
// EgalTech 2020-2020
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkCDeCylClosedSurfTm.h Data : 24.03.24 Versione : 2.6c2
|
||||
// File : EGkCDeCylClosedSurfTm.h Data : 09.01.20 Versione : 2.2a2
|
||||
// Contenuto : Dichiarazione funzione verifica collisione tra
|
||||
// Cylinder e Closed SurfTriMesh.
|
||||
//
|
||||
// Modifiche : 09.01.20 DS Creazione modulo.
|
||||
// 24.03.24 DS Aggiunta TestCylSurfTm.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -31,8 +31,3 @@
|
||||
// - false in caso di assenza di collisione.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Verifica l'interferenza tra il cilindro e la superficie : restituisce true in caso di interferenza.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool TestCylSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2020-2024
|
||||
// EgalTech 2020-2020
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkCDeRectPrismoidClosedSurfTm.h Data : 24.03.24 Versione : 2.6c2
|
||||
// File : EGkCDeRectPrismoidClosedSurfTm.h Data : 09.11.20 Versione :
|
||||
// Contenuto : Dichiarazione funzione verifica collisione tra
|
||||
// prismoide a basi rettangolari e Closed SurfTriMesh.
|
||||
//
|
||||
// Modifiche : 09.11.20 LM Creazione modulo.
|
||||
// 24.03.24 DS Aggiunta TestRectPrismoidSurfTm.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -32,11 +32,4 @@
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool CDeRectPrismoidClosedSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
|
||||
double dLenghtTopX, double dLenghtTopY, double dHeight,
|
||||
const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Verifica l'interferenza tra il Prismoide a basi rettangolari e la superficie : restituisce true in caso di interferenza.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool TestRectPrismoidSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
|
||||
double dLenghtTopX, double dLenghtTopY, double dHeight,
|
||||
const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
@@ -1,12 +1,12 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2020-2024
|
||||
// EgalTech 2020-2020
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkCDeSpheClosedSurfTm.h Data : 24.03.24 Versione : 2.6c2
|
||||
// File : EGkCDeSpheClosedSurfTm.h Data : 09.01.20 Versione : 2.2a2
|
||||
// Contenuto : Dichiarazione funzione verifica collisione tra
|
||||
// Sphere e Closed SurfTriMesh.
|
||||
//
|
||||
// Modifiche : 09.01.20 DS Creazione modulo.
|
||||
// 24.03.24 DS Aggiunta TestSpheSurfTm.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -28,8 +28,3 @@
|
||||
// - false in caso di assenza di collisione.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Verifica l'interferenza tra la sfera e la superficie : restituisce true in caso di interferenza
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool TestSpheSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, double dSafeDist) ;
|
||||
|
||||
+3
-1
@@ -16,6 +16,7 @@
|
||||
|
||||
#include "/EgtDev/Include/EGkPointGrid3d.h"
|
||||
#include "/EgtDev/Include/EGkGeoCollection.h"
|
||||
#include <unordered_set>
|
||||
|
||||
class IGeomDB ;
|
||||
|
||||
@@ -58,6 +59,7 @@ class ChainCurves
|
||||
EGK_EXPORT bool GetForkIds( INTVECTOR& vForkIds) ;
|
||||
|
||||
private :
|
||||
typedef std::unordered_set<int> INTUSET ;
|
||||
struct CrvData {
|
||||
int nId ;
|
||||
Point3d ptStart ;
|
||||
@@ -90,7 +92,7 @@ class ChainCurves
|
||||
private :
|
||||
bool m_bAllowInvert ;
|
||||
double m_dToler ;
|
||||
INTUNORDSET m_sCrvId ;
|
||||
INTUSET m_sCrvId ;
|
||||
CRVDATAVECTOR m_vCrvData ;
|
||||
PointGrid3d m_PointGrid ;
|
||||
bool m_bFromNear ;
|
||||
|
||||
@@ -108,7 +108,6 @@ class Color
|
||||
const Color WHITE( 255, 255, 255) ;
|
||||
const Color LGRAY( 192, 192, 192) ;
|
||||
const Color GRAY( 128, 128, 128) ;
|
||||
const Color DGRAY( 64, 64, 64) ;
|
||||
const Color BLACK( 0, 0, 0) ;
|
||||
const Color RED( 255, 0, 0) ;
|
||||
const Color MAROON( 128, 0, 0) ;
|
||||
|
||||
@@ -94,7 +94,3 @@ EGK_EXPORT bool CalcCurveMedialAxis( const ICurve& crvC, ICURVEPOVECTOR& vCrvs,
|
||||
//----------------------------------------------------------------------------
|
||||
//! Calcola l'offset completo di una curva
|
||||
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) ;
|
||||
@@ -70,8 +70,6 @@ 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 ;
|
||||
} ;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
@@ -62,4 +62,4 @@ class DistPointSurfTm
|
||||
//----------------------------------------------------------------------------
|
||||
// Calcola l'indice del vertice della superficie a minima distanza dal punto di riferimento.
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT int GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf) ;
|
||||
EGK_EXPORT int GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf) ;
|
||||
+2
-6
@@ -36,11 +36,8 @@ class __declspec( novtable) IExtDimension : public IGeoObj
|
||||
const Vector3d& vtN, const std::string& sText) = 0 ;
|
||||
virtual bool SetDiametral( const Point3d& ptCen, const Point3d& ptPos,
|
||||
const Vector3d& vtN, const std::string& sText) = 0 ;
|
||||
virtual bool SetAngular( const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
|
||||
const Vector3d& vtN, const std::string& sText) = 0 ;
|
||||
virtual bool SetAngularEx( const Point3d& ptV1, const Point3d& ptP1,
|
||||
const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptPos,
|
||||
const Vector3d& vtN, const std::string& sText) = 0 ;
|
||||
virtual bool SetAngular( const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptV, const Point3d& ptPos,
|
||||
const Vector3d& vtN, const std::string& sText ) = 0 ;
|
||||
virtual const Vector3d& GetNormVersor( void) const = 0 ;
|
||||
virtual const Vector3d& GetDirVersor( void) const = 0 ;
|
||||
virtual const std::string& GetText( void) const = 0 ;
|
||||
@@ -58,7 +55,6 @@ class __declspec( novtable) IExtDimension : public IGeoObj
|
||||
virtual double GetTextHeight( void) const = 0 ;
|
||||
virtual bool GetMidPoint( Point3d& ptMid) const = 0 ;
|
||||
virtual bool GetCenterPoint( Point3d& ptCen) const = 0 ;
|
||||
virtual const std::string& GetSubType( void) const = 0 ;
|
||||
virtual bool ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const = 0 ;
|
||||
} ;
|
||||
|
||||
|
||||
@@ -88,4 +88,3 @@ const std::string GDB_SI_DUPLIST = "!DLST" ; // Duplo Vettore Id entit
|
||||
const std::string GDB_SI_DUPMODIF = "!DMOD" ; // Flag di sorgente per duplo modificato
|
||||
const std::string GDB_SI_DUPLOCKED = "!DLOK" ; // Flag di duplo bloccato (da non aggiornare seguendo originale)
|
||||
const std::string GDB_SI_DUPTOUPDATE = "!DTUP" ; // Flag di duplo da aggiornare quando sbloccato
|
||||
const std::string GDB_SI_SHOWEDGES = "!SEDG" ; // Flag per forzare visualizzazione spigoli vivi anche in shading
|
||||
|
||||
@@ -15,7 +15,6 @@
|
||||
|
||||
#include "/EgtDev/Include/EGkPoint3d.h"
|
||||
#include "/EgtDev/Include/EGkBBox3d.h"
|
||||
#include "/EgtDev/Include/EGkFrame3d.h"
|
||||
#include "/EgtDev/Include/EGkCurvePointDiffGeom.h"
|
||||
#include "/EgtDev/Include/EgtNumCollection.h"
|
||||
|
||||
@@ -53,12 +52,6 @@ typedef std::list<CrvPointDiffGeom> CPDGLIST ; // lista di CrvPointDiffGe
|
||||
typedef std::vector<Vector3d> VCT3DVECTOR ; // vettore di vettori 3d
|
||||
typedef std::list<Vector3d> VCT3DLIST ; // lista di vettori 3d
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Raccolte di Frame3d
|
||||
typedef std::vector<Frame3d> FRAME3DVECTOR ; // vettore di riferimenti 3d
|
||||
typedef std::list<Frame3d> FRAME3DLIST ; // lista di riferimenti 3d
|
||||
typedef std::vector<std::pair<Frame3d,int>> FRAME3DIVECTOR ; // vettore di riferimenti 3d e Id
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Raccolte di BBox3d
|
||||
typedef std::vector<BBox3d> BOXVECTOR ; // vettore di bounding box 3d
|
||||
|
||||
@@ -1,79 +0,0 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2024
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkIntersLineSurfBez.h Data : 06.02.24 Versione : 2.6b1
|
||||
// Contenuto : Dichiarazione della classe intersezione Linea/SurfTriMesh.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 06.02.24 DB Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "/EgtDev/Include/EGkSurfTriMesh.h"
|
||||
#include "/EgtDev/Include/EGkIntersLineTria.h"
|
||||
#include "/EgtDev/Include/EGkHashGrids2d.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
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//! 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,
|
||||
LSBT_IN = 1,
|
||||
LSBT_OUT = 2,
|
||||
LSBT_TG_INI = 3,
|
||||
LSBT_TG_FIN = 4,
|
||||
LSBT_TOUCH = 5} ;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfBezier* pSBz,
|
||||
ILSBIVECTOR& vInfo, bool bFinite = true) ;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
class IntersParLinesSurfBz
|
||||
{
|
||||
public :
|
||||
EGK_EXPORT IntersParLinesSurfBz( const Frame3d& frLines, const ISurfBezier& SBz) ;
|
||||
EGK_EXPORT bool GetInters( const Point3d& ptL, double dLen, ILSBIVECTOR& vInfo, bool bFinite = true) const ;
|
||||
|
||||
private :
|
||||
bool m_bOk ;
|
||||
const Frame3d m_frLines ;
|
||||
const ISurfBezier* m_pSBz ;
|
||||
HashGrids2d m_HGrids ;
|
||||
} ;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
EGK_EXPORT bool FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters) ;
|
||||
+5
-34
@@ -1,13 +1,13 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2015-2024
|
||||
// EgalTech 2015-2015
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkLuaAux.h Data : 14.04.24 Versione : 2.6d4
|
||||
// File : EGkLuaAux.h Data : 21.03.15 Versione : 1.6c6
|
||||
// Contenuto : Funzioni per gestione parametri geometrici con LUA.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 21.03.15 DS Creazione modulo.
|
||||
// 14.04.24 DS Aggiunta gestione Quaternion.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -17,7 +17,6 @@
|
||||
#include "/EgtDev/Include/EGkPoint3d.h"
|
||||
#include "/EgtDev/Include/EGkFrame3d.h"
|
||||
#include "/EgtDev/Include/EGkBBox3d.h"
|
||||
#include "/EgtDev/Include/EGkQuaternion.h"
|
||||
#include "/EgtDev/Include/EGkColor.h"
|
||||
#include "/EgtDev/Include/EGkGeoCollection.h"
|
||||
#include "/EgtDev/Include/EGkSelection.h"
|
||||
@@ -26,16 +25,12 @@
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool
|
||||
LuaGetParam( lua_State* L, int nInd, Vector3d& vtPar)
|
||||
{
|
||||
return LuaGetParam( L, nInd, vtPar.v) ;
|
||||
}
|
||||
{ return LuaGetParam( L, nInd, vtPar.v) ; }
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool
|
||||
LuaGetParam( lua_State* L, int nInd, Point3d& ptPar)
|
||||
{
|
||||
return LuaGetParam( L, nInd, ptPar.v) ;
|
||||
}
|
||||
{ return LuaGetParam( L, nInd, ptPar.v) ; }
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool
|
||||
@@ -119,13 +114,6 @@ LuaGetParam( lua_State* L, int nInd, BBox3d& b3Par)
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool
|
||||
LuaGetParam( lua_State* L, int nInd, Quaternion& qtPar)
|
||||
{
|
||||
return LuaGetParam( L, nInd, qtPar.v) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool
|
||||
LuaGetParam( lua_State* L, int nInd, Color& colPar)
|
||||
@@ -381,23 +369,6 @@ LuaSetParam( lua_State* L, const BBox3d& b3Par)
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool
|
||||
LuaSetParam( lua_State* L, const Quaternion& qtPar)
|
||||
{
|
||||
try {
|
||||
lua_createtable( L, 4, 0) ;
|
||||
for ( int i = 1 ; i <= 4 ; ++ i) {
|
||||
lua_pushnumber( L, qtPar.v[i-1]) ;
|
||||
lua_rawseti( L, -2, i) ;
|
||||
}
|
||||
}
|
||||
catch( ...) {
|
||||
return false ;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------
|
||||
inline bool
|
||||
LuaSetParam( lua_State* L, const Color& colPar)
|
||||
|
||||
+2
-12
@@ -13,7 +13,6 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "/EgtDev/Include/EGkGeoPoint3d.h"
|
||||
#include "/EgtDev/Include/EGkCurve.h"
|
||||
#include "/EgtDev/Include/EGkSurfTriMesh.h"
|
||||
|
||||
@@ -30,14 +29,11 @@
|
||||
struct Point5ax {
|
||||
Point3d ptP ;
|
||||
Vector3d vtDir ;
|
||||
Vector3d vtDir2 ;
|
||||
double dPar ;
|
||||
int nFlag ;
|
||||
Point5ax( void) : ptP(), vtDir(), vtDir2(), dPar(), nFlag() {} ;
|
||||
Point5ax( void) : ptP(), vtDir(), 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) {} ;
|
||||
: ptP( ptBase), vtDir( vtTool), dPar( dU), nFlag( nData) {} ;
|
||||
} ;
|
||||
typedef std::vector<Point5ax> PNT5AXVECTOR ; // vettore di Punti 5assi
|
||||
|
||||
@@ -45,9 +41,3 @@ 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) ;
|
||||
|
||||
-174
@@ -1,174 +0,0 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2024-2024
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkQuaternion.h Data : 13.04.243 Versione : 2.6d4
|
||||
// Contenuto : Dichiarazione della classe Quaternion.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 31.12.13 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "/EgtDev/Include/EGkFrame3d.h"
|
||||
|
||||
//----------------------- Macro per import/export -----------------------------
|
||||
#undef EGK_EXPORT
|
||||
#if defined( I_AM_EGK) // da definirsi solo nella DLL
|
||||
#define EGK_EXPORT __declspec( dllexport)
|
||||
#else
|
||||
#define EGK_EXPORT __declspec( dllimport)
|
||||
#endif
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
class EGK_EXPORT Quaternion
|
||||
{
|
||||
public :
|
||||
Quaternion( double dW = 0, double dX = 0, double dY = 0, double dZ = 0) : w( dW), x( dX), y( dY), z( dZ) {}
|
||||
|
||||
public :
|
||||
bool IsValid( void) const
|
||||
{ return ( std::isfinite( w) && std::isfinite( x) && std::isfinite( y) && std::isfinite( z)) ; }
|
||||
bool IsSmall( void) const
|
||||
{ return ( ( w * w + x * x + y * y + z * z) < SQ_EPS_SMALL) ; }
|
||||
bool IsZero( void) const
|
||||
{ return ( ( w * w + x * x + y * y + z * z) < SQ_EPS_ZERO) ; }
|
||||
bool IsUnit( void) const
|
||||
{ return ( abs( w - 1) < EPS_ZERO && ( x * x + y * y + z * z) < SQ_EPS_ZERO) ; }
|
||||
double SqLen( void) const
|
||||
{ return ( w * w + x * x + y * y + z * z) ; }
|
||||
double Len( void) const ;
|
||||
bool Normalize( double dEps = EPS_SMALL) ;
|
||||
bool IsNormalized( void) const
|
||||
{ return ( abs( 1.0 - ( w * w + x * x + y * y + z * z)) < ( 2 * EPS_ZERO)) ; }
|
||||
Quaternion& operator +=( const Quaternion& qtQ)
|
||||
{ w += qtQ.w ; x += qtQ.x ; y += qtQ.y ; z += qtQ.z ; return *this ; }
|
||||
Quaternion& operator -=( const Quaternion& qtQ)
|
||||
{ w -= qtQ.w ; x -= qtQ.x ; y -= qtQ.y ; z -= qtQ.z ; return *this ; }
|
||||
Quaternion& operator *=( double dMul)
|
||||
{ w *= dMul ; x *= dMul ; y *= dMul ; z *= dMul ; return *this ; }
|
||||
Quaternion& operator /=( double dDiv)
|
||||
{ double dMul = 1 / dDiv ; w *= dMul ; x *= dMul ; y *= dMul ; z *= dMul ; return *this ; }
|
||||
|
||||
public :
|
||||
union {
|
||||
struct {
|
||||
double w ;
|
||||
double x ;
|
||||
double y ;
|
||||
double z ;
|
||||
} ;
|
||||
double v[4] ;
|
||||
} ;
|
||||
} ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Quaternioni notevoli
|
||||
//----------------------------------------------------------------------------
|
||||
// Quaternione non valido
|
||||
const Quaternion Q_INVALID( NAN, NAN, NAN, NAN) ;
|
||||
// Quaternione unità
|
||||
const Quaternion Q_UNIT( 1, 0, 0, 0) ;
|
||||
// Quaternione nullo
|
||||
const Quaternion Q_NULL( 0, 0, 0, 0) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Definizione da rotazione definita con asse e angolo e inverso
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT Quaternion FromAxisAngle( const Vector3d& vtAx, double dAngDeg) ;
|
||||
EGK_EXPORT bool ToAxisAngle( const Quaternion& qtQ, Vector3d& vtAx, double& dAngDeg) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Definizione da parte rotazione di un sistema di riferimento e inverso
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT Quaternion FromFrame( const Frame3d& frRef) ;
|
||||
EGK_EXPORT bool ToFrame( const Quaternion& qtQ, Frame3d& frRef) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Coniugato di un quaternione
|
||||
//----------------------------------------------------------------------------
|
||||
inline const Quaternion
|
||||
Conjugate( const Quaternion& qtQ)
|
||||
{
|
||||
return ( Quaternion( qtQ.w, -qtQ.x, -qtQ.y, -qtQ.z)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Opposto di un quaternione
|
||||
//----------------------------------------------------------------------------
|
||||
inline const Quaternion
|
||||
operator-( const Quaternion& qtQ)
|
||||
{
|
||||
return ( Quaternion( -qtQ.w, - qtQ.x, - qtQ.y, - qtQ.z)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Somma di due quaternioni
|
||||
//----------------------------------------------------------------------------
|
||||
inline const Quaternion
|
||||
operator+( const Quaternion& qtQ1, const Quaternion& qtQ2)
|
||||
{
|
||||
return ( Quaternion( qtQ1.w + qtQ2.w, qtQ1.x + qtQ2.x, qtQ1.y + qtQ2.y, qtQ1.z + qtQ2.z)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Sottrazione di due quaternioni
|
||||
//----------------------------------------------------------------------------
|
||||
inline const Quaternion
|
||||
operator-( const Quaternion& qtQ1, const Quaternion& qtQ2)
|
||||
{
|
||||
return ( Quaternion( qtQ1.w - qtQ2.w, qtQ1.x - qtQ2.x, qtQ1.y - qtQ2.y, qtQ1.z - qtQ2.z)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Prodotto di un quaternione con uno scalare
|
||||
//----------------------------------------------------------------------------
|
||||
inline const Quaternion
|
||||
operator*( const Quaternion& qtQ, double dMul)
|
||||
{
|
||||
return ( Quaternion( qtQ.w * dMul, qtQ.x * dMul, qtQ.y * dMul, qtQ.z * dMul)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Prodotto di uno scalare con un quaternione
|
||||
//----------------------------------------------------------------------------
|
||||
inline const Quaternion
|
||||
operator*( double dMul, const Quaternion& qtQ)
|
||||
{
|
||||
return ( Quaternion( qtQ.w * dMul, qtQ.x * dMul, qtQ.y * dMul, qtQ.z * dMul)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Divisione con uno scalare
|
||||
//----------------------------------------------------------------------------
|
||||
inline const Quaternion
|
||||
operator/( const Quaternion& qtQ, double dDiv)
|
||||
{
|
||||
double dMul = 1 / dDiv ;
|
||||
return ( Quaternion( qtQ.w * dMul, qtQ.x * dMul, qtQ.y * dMul, qtQ.z * dMul)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Prodotto scalare due quaternioni
|
||||
//----------------------------------------------------------------------------
|
||||
inline double
|
||||
Scalar( const Quaternion& qtQ1, const Quaternion& qtQ2)
|
||||
{
|
||||
return ( qtQ1.w * qtQ2.w + qtQ1.x * qtQ2.x + qtQ2.y * qtQ2.y + qtQ1.z * qtQ2.z) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Prodotto di due quaternioni
|
||||
//----------------------------------------------------------------------------
|
||||
inline const Quaternion
|
||||
operator*( const Quaternion& qtQ1, const Quaternion& qtQ2)
|
||||
{
|
||||
return ( Quaternion( qtQ1.w * qtQ2.w - qtQ1.x * qtQ2.x - qtQ1.y * qtQ2.y - qtQ1.z * qtQ2.z,
|
||||
qtQ1.w * qtQ2.x + qtQ1.x * qtQ2.w + qtQ1.y * qtQ2.z - qtQ1.z * qtQ2.y,
|
||||
qtQ1.w * qtQ2.y + qtQ1.y * qtQ2.w + qtQ1.z * qtQ2.x - qtQ1.x * qtQ2.z,
|
||||
qtQ1.w * qtQ2.z + qtQ1.z * qtQ2.w + qtQ1.x * qtQ2.y - qtQ1.y * qtQ2.x)) ;
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2024-2024
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkRotationMinimizingFrame.h Data : 05.04.24 Versione : 2.6d1
|
||||
// Contenuto : Dichiarazione della classe RotationMinimizingFrame.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 05.04.24 RE Creazione modulo.
|
||||
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "/EgtDev/Include/EGkCurve.h"
|
||||
#include "/EgtDev/Include/EGkGeoCollection.h"
|
||||
|
||||
//----------------------- Macro per import/export -----------------------------
|
||||
#undef EGK_EXPORT
|
||||
#if defined( I_AM_EGK) // da definirsi solo nella DLL
|
||||
#define EGK_EXPORT __declspec( dllexport)
|
||||
#else
|
||||
#define EGK_EXPORT __declspec( dllimport)
|
||||
#endif
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
class EGK_EXPORT RotationMinimizingFrame
|
||||
{
|
||||
public :
|
||||
RotationMinimizingFrame( void)
|
||||
: m_pCrv( nullptr), m_Frame0() {}
|
||||
~RotationMinimizingFrame( void)
|
||||
{ Clear() ; }
|
||||
bool Set( const ICurve* pCrv, const Frame3d& fr_Start) ;
|
||||
|
||||
public :
|
||||
bool GetFramesByStep( double dStep, bool bUniform, FRAME3DVECTOR& vRMFrames) ;
|
||||
bool GetFramesBySplit( int nIntervals, FRAME3DVECTOR& vRMFrames) ;
|
||||
bool GetFramesByTolerance( double dTol, FRAME3DVECTOR& vRMFrames) ;
|
||||
|
||||
private :
|
||||
bool Clear( void) ;
|
||||
bool IsValid( void) ;
|
||||
bool GetFrameAtParam( const Frame3d& frAct, const double dParNext, Frame3d& frNext) ;
|
||||
|
||||
private :
|
||||
ICurve* m_pCrv ; // curva per il calcolo del rotation Xplane frame
|
||||
Frame3d m_Frame0 ; // frame iniziale della curva
|
||||
} ;
|
||||
@@ -1,51 +0,0 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2024-2024
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkRotationXplaneFrame.h Data : 05.04.24 Versione : 2.6d1
|
||||
// Contenuto : Dichiarazione della classe RotationXplaneFrame.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 05.04.24 DS Creazione modulo.
|
||||
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "/EgtDev/Include/EGkCurve.h"
|
||||
#include "/EgtDev/Include/EGkGeoCollection.h"
|
||||
|
||||
//----------------------- Macro per import/export -----------------------------
|
||||
#undef EGK_EXPORT
|
||||
#if defined( I_AM_EGK) // da definirsi solo nella DLL
|
||||
#define EGK_EXPORT __declspec( dllexport)
|
||||
#else
|
||||
#define EGK_EXPORT __declspec( dllimport)
|
||||
#endif
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
class EGK_EXPORT RotationXplaneFrame
|
||||
{
|
||||
public :
|
||||
RotationXplaneFrame( void)
|
||||
: m_pCrv( nullptr), m_vtNorm(), m_vtNearX() {}
|
||||
~RotationXplaneFrame( void)
|
||||
{ Clear() ; }
|
||||
bool Set( const ICurve* pCrv, const Vector3d& vtNorm, const Vector3d& vtNearX = V_NULL) ;
|
||||
|
||||
public :
|
||||
bool GetFramesByStep( double dStep, bool bUniform, FRAME3DVECTOR& vRXFrames) ;
|
||||
bool GetFramesBySplit( int nIntervals, FRAME3DVECTOR& vRXFrames) ;
|
||||
bool GetFramesByTolerance( double dTol, FRAME3DVECTOR& vRXFrames) ;
|
||||
|
||||
private :
|
||||
bool Clear( void) ;
|
||||
bool IsValid( void) ;
|
||||
bool GetFrameAtParam( const Frame3d& frAct, const double dParNext, Frame3d& frNext) ;
|
||||
|
||||
private :
|
||||
ICurve* m_pCrv ; // curva per il calcolo del rotation Xplane frame
|
||||
Vector3d m_vtNorm ; // vettore normale al piano in cui deve sempre giacere l'asse X
|
||||
Vector3d m_vtNearX ; // vettore a cui deve essere il più vicino possibile la direzione X iniziale
|
||||
} ;
|
||||
@@ -1,27 +0,0 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2024
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkSbzStandard.h Data : 14.02.24 Versione : 2.6b2
|
||||
// Contenuto : Dichiarazione funzioni per creazione superfici Sbz
|
||||
// standard : Box, Pyramid, Cylinder, Sphere, Cone.
|
||||
//
|
||||
//
|
||||
// Modifiche : 14.02.24 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
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
EGK_EXPORT ISurfBezier* CreateBezierSphere( const Point3d& ptCenter, double dR) ;
|
||||
+3
-7
@@ -1,8 +1,8 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2015-2024
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkStmFromCurves.h Data : 27.02.24 Versione : 2.6d1
|
||||
// Contenuto : Prototipi funzioni di creazione TriMesh a partire da curve.
|
||||
// File : EGkStmFromCurves.h Data : 27.02.24 Versione : 2.6b4
|
||||
// Contenuto : Dichiarazione della classe StmFromTriangleSoup.
|
||||
//
|
||||
//
|
||||
//
|
||||
@@ -14,7 +14,6 @@
|
||||
#pragma once
|
||||
|
||||
#include "/EgtDev/Include/EGkCurve.h"
|
||||
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
|
||||
#include "/EgtDev/Include/EGkSurfTriMesh.h"
|
||||
|
||||
//----------------------- Macro per import/export ----------------------------
|
||||
@@ -41,10 +40,7 @@ EGK_EXPORT ISurfTriMesh* GetSurfTriMeshByScrewing( const ICurve* pCurve, const P
|
||||
double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
|
||||
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRectSwept( double dDimH, double dDimV, double dBevelH, double dBevelV,
|
||||
const ICurve* pGuide, int nCapType, double dLinTol = 10 * EPS_SMALL) ;
|
||||
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtAx,
|
||||
bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
|
||||
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ISurfFlatRegion* pSfrSect, const ICurve* pGuide, const Vector3d& vtAx,
|
||||
bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
|
||||
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
|
||||
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshTransSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol = 10 * EPS_SMALL) ;
|
||||
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRuled( const Point3d& ptP, const ICurve* pCurve, double dLinTol = 10 * EPS_SMALL) ;
|
||||
EGK_EXPORT ISurfTriMesh* GetSurfTriMeshRuled( const ICurve* pCurve1, const ICurve* pCurve2, int nType, double dLinTol = 10 * EPS_SMALL) ;
|
||||
|
||||
@@ -15,7 +15,6 @@
|
||||
|
||||
#include "/EgtDev/Include/EGkCurveComposite.h"
|
||||
#include "/EgtDev/Include/EGkSurf.h"
|
||||
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
|
||||
#include "/EgtDev/Include/EGkGeoCollection.h"
|
||||
|
||||
|
||||
@@ -60,8 +59,3 @@ struct SNurbsSurfData
|
||||
//! Trasforma una superficie Nurbs standard in una nuova superficie di Bezier semplice o composta
|
||||
EGK_EXPORT bool NurbsSurfaceCanonicalize( SNurbsSurfData& snData) ;
|
||||
EGK_EXPORT ISurf* NurbsToBezierSurface( const SNurbsSurfData& snData) ;
|
||||
//! Per rendere uniforme lo spazio parametrico passando da Nurbs a MultiBezier
|
||||
EGK_EXPORT bool MakeUniform( ISurfFlatRegion*& pSfr, bool& bRescaled, const DBLVECTOR& vU0, const DBLVECTOR& vV0,
|
||||
int nDegU, int nDegV, double dScaleU, double dScaleV, bool bRetry) ;
|
||||
//! Per identificare su che edge è il punto
|
||||
EGK_EXPORT bool OnWhichEdge( double u0, double u1, double v0, double v1, const Point3d& ptToAssign, int& nEdge) ;
|
||||
|
||||
+3
-17
@@ -1,7 +1,7 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2020-2024
|
||||
// EgalTech 2020-2020
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkSurfBezier.h Data : 10.04.24 Versione : 2.6d2
|
||||
// File : EGkSurfBezier.h Data : 22.03.20 Versione : 2.2c3
|
||||
// Contenuto : Dichiarazione della interfaccia ISurfBezier.
|
||||
//
|
||||
//
|
||||
@@ -14,7 +14,6 @@
|
||||
#pragma once
|
||||
|
||||
#include "/EgtDev/Include/EGkSurf.h"
|
||||
#include "/EgtDev/Include/EGkCurveComposite.h"
|
||||
#include "/EgtDev/Include/EgtPointerOwner.h"
|
||||
|
||||
class PolyLine ;
|
||||
@@ -37,7 +36,7 @@ class __declspec( novtable) ISurfBezier : public ISurf
|
||||
virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl) = 0 ;
|
||||
virtual bool SetControlPoint( int nIndU, int nIndV, const Point3d& ptCtrl, double dW) = 0 ;
|
||||
virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) = 0 ;
|
||||
virtual bool SetTrimRegion( ISurfFlatRegion& sfrTrimReg, bool bIntersectOrSubtrct = true) = 0 ;
|
||||
virtual bool SetTrimRegion( const ISurfFlatRegion& sfrTrimReg) = 0 ;
|
||||
virtual ISurfFlatRegion* GetTrimRegion( void) const = 0 ;
|
||||
virtual bool GetInfo( int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) const = 0 ;
|
||||
virtual const Point3d& GetControlPoint( int nIndU, int nIndV, bool* pbOk) const = 0 ;
|
||||
@@ -59,20 +58,7 @@ class __declspec( novtable) ISurfBezier : public ISurf
|
||||
virtual bool GetControlCurveOnU( int nIndV, PolyLine& plCtrlU) const = 0 ;
|
||||
virtual bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const = 0 ;
|
||||
virtual const ISurfTriMesh* GetAuxSurf( void) const = 0 ;
|
||||
virtual ISurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL) const = 0 ;
|
||||
virtual bool GetLeaves ( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const = 0 ;
|
||||
virtual bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const = 0 ;
|
||||
virtual bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL) const = 0 ;
|
||||
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 ;
|
||||
virtual bool IncreaseUV( double& dU, double dx, bool bUOrV, double* dUVCopy = nullptr, bool bModifyOrig = true) const = 0 ;
|
||||
virtual bool IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bModifyOrig) const = 0 ;
|
||||
virtual bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const = 0 ;
|
||||
virtual bool IsPlanar( void) const = 0 ;
|
||||
} ;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
@@ -51,7 +51,6 @@ class __declspec( novtable) ISurfFlatRegion : public ISurf
|
||||
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 ;
|
||||
} ;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
+2
-21
@@ -1,7 +1,7 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2017-2024
|
||||
// EgalTech 2017-2017
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkSurfLocal.h Data : 08.04.24 Versione : 2.6d2
|
||||
// File : EGkSurfLocal.h Data : 29.03.17 Versione : 1.8c3
|
||||
// Contenuto : Classe gestione superfici nel locale desiderato.
|
||||
//
|
||||
//
|
||||
@@ -45,25 +45,6 @@ class SurfLocal
|
||||
m_pCopy->LocToLoc( frSrf, frLoc) ;
|
||||
m_pSrf = m_pCopy ;
|
||||
}
|
||||
SurfLocal( const ISurf* pSurf, const Frame3d& frSrf, const Frame3d& frLoc)
|
||||
: m_pSrf( nullptr), m_pCopy( nullptr)
|
||||
{ // verifica dei parametri
|
||||
if ( pSurf == nullptr || &frSrf == nullptr || &frLoc == nullptr)
|
||||
return ;
|
||||
// assegno la superficie originale
|
||||
m_pSrf = pSurf ;
|
||||
// se i riferimenti coincidono non devo fare altro
|
||||
if ( AreSameFrame( frSrf, frLoc))
|
||||
return ;
|
||||
// copio la superficie e la porto in locale
|
||||
m_pCopy = m_pSrf->Clone() ;
|
||||
if ( m_pCopy == nullptr) {
|
||||
m_pSrf = nullptr ;
|
||||
return ;
|
||||
}
|
||||
m_pCopy->LocToLoc( frSrf, frLoc) ;
|
||||
m_pSrf = m_pCopy ;
|
||||
}
|
||||
SurfLocal( const SurfLocal& Other)
|
||||
: m_pSrf( nullptr), m_pCopy( nullptr)
|
||||
{ // se non devo clonare
|
||||
|
||||
+2
-4
@@ -1,7 +1,7 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2014-2024
|
||||
// EgalTech 2014-2023
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkSurfTriMesh.h Data : 05.03.24 Versione : 2.6c2
|
||||
// File : EGkSurfTriMesh.h Data : 10.12.23 Versione : 2.5l2
|
||||
// Contenuto : Dichiarazione della interfaccia ISurfTriMesh.
|
||||
//
|
||||
//
|
||||
@@ -43,7 +43,6 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
|
||||
virtual void SetLinearTolerance( double dLinTol) = 0 ;
|
||||
virtual void SetBoundaryAngle( double dBoundaryAngDeg) = 0 ;
|
||||
virtual void SetSmoothAngle( double dSmoothAngDeg) = 0 ;
|
||||
virtual void SetShowEdges( bool bShow) = 0 ;
|
||||
virtual int AddVertex( const Point3d& ptVert, double dU = -1, double dV = -1) = 0 ;
|
||||
virtual bool MoveVertex( int nInd, const Point3d& ptNewVert) = 0 ;
|
||||
virtual int AddTriangle( const int nIdVert[3], int nTFlag = 0) = 0 ;
|
||||
@@ -68,7 +67,6 @@ class __declspec( novtable) ISurfTriMesh : public ISurf
|
||||
virtual int GetTriangleSize( void) const = 0 ;
|
||||
virtual double GetLinearTolerance( void) const = 0 ;
|
||||
virtual double GetSmoothAngle( void) const = 0 ;
|
||||
virtual bool GetShowEdges( void) const = 0 ;
|
||||
virtual bool GetVertex( int nId, Point3d& ptP) const = 0 ;
|
||||
virtual bool GetVertexParam( int nId, double& dU, double& dV) const = 0 ;
|
||||
virtual int GetFirstVertex( Point3d& ptP) const = 0 ;
|
||||
|
||||
+18
-30
@@ -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,58 @@ 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
|
||||
{ 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+
|
||||
//! 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
|
||||
{ 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+
|
||||
//! 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
|
||||
{ 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
|
||||
//! Verifica se il vettore è generico
|
||||
bool IsGeneric( void) const
|
||||
{ return ( ! IsX() && ! IsY() && ! IsZ()) ; }
|
||||
//! Somma sul posto con altro vettore
|
||||
@@ -205,12 +193,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) ;
|
||||
|
||||
|
||||
+6
-11
@@ -1,14 +1,14 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2015-2024
|
||||
// EgalTech 2015-2023
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EGkVolZmap.h Data : 22.04.24 Versione : 2.6d4
|
||||
// File : EGkVolZmap.h Data : 12.09.23 Versione : 2.5i1
|
||||
// Contenuto : Dichiarazione della interfaccia IVolZmap.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 22.01.15 DS Creazione modulo.
|
||||
// 12.09.23 DS Aggiunto metodo IsTriDexel.
|
||||
// 09.03.24 DS Aggiunti SetShowEdges e GetShowEdges.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -27,10 +27,9 @@ class __declspec( novtable) IVolZmap : public IGeoObj
|
||||
public :
|
||||
virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
|
||||
virtual bool Clear( void) = 0 ;
|
||||
virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) = 0 ;
|
||||
virtual bool CreateEmpty( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) = 0 ;
|
||||
virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) = 0 ;
|
||||
virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex) = 0 ;
|
||||
virtual bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dPrec, bool bTriDex) = 0 ;
|
||||
virtual bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec, bool bTriDex) = 0 ;
|
||||
virtual bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bTriDex) = 0 ;
|
||||
virtual int GetBlockCount( void) const = 0 ;
|
||||
virtual int GetBlockUpdatingCounter( int nBlock) const = 0 ;
|
||||
virtual bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const = 0 ;
|
||||
@@ -40,8 +39,6 @@ class __declspec( novtable) IVolZmap : public IGeoObj
|
||||
virtual bool GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const = 0 ;
|
||||
virtual int GetResolution( void) const = 0 ;
|
||||
virtual bool ChangeResolution( int nDexvoxRatio) = 0 ;
|
||||
virtual void SetShowEdges( bool bShow) = 0 ;
|
||||
virtual bool GetShowEdges( void) const = 0 ;
|
||||
virtual bool SetToolTolerances( double dLinTol, double dAngTolDeg = 90) = 0 ;
|
||||
virtual bool SetStdTool( const std::string& sToolName,
|
||||
double dH, double dR, double dCornR, double dCutterH, int nFlag, bool bFirst) = 0 ;
|
||||
@@ -55,8 +52,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 ;
|
||||
|
||||
+11
@@ -19,6 +19,7 @@
|
||||
#include "/EgtDev/Include/EGkPlane3d.h"
|
||||
#include "/EgtDev/Include/EGkColor.h"
|
||||
#include "/EgtDev/Include/EgtNumCollection.h"
|
||||
#include "/EgtDev/Include/EGkSurfTriMesh.h"
|
||||
#define NOMINMAX
|
||||
#include <windows.h>
|
||||
#include <string>
|
||||
@@ -55,6 +56,8 @@ class IEGrScene
|
||||
virtual bool Project( const Point3d& ptWorld, Point3d& ptView) const = 0 ;
|
||||
virtual bool UnProject( const Point3d& ptView, Point3d& ptWorld) const = 0 ;
|
||||
virtual void Destroy( void) = 0 ;
|
||||
virtual void SetSceneColors( Color cColX, Color cColY, Color cColZ, Color cColXm, Color cColYm, Color cColZm,
|
||||
Color cColEdge, Color cColCorner) = 0 ;
|
||||
// Camera
|
||||
virtual bool SetCenter( const Point3d& ptCenter) = 0 ;
|
||||
virtual bool SetCameraDirOrizzOffset( int nRightStepOffset = 0) = 0 ;
|
||||
@@ -102,6 +105,14 @@ class IEGrScene
|
||||
virtual bool GetShowGrid( void) = 0 ;
|
||||
// Glob Frame
|
||||
virtual bool SetGlobFrameShow( bool bShow) = 0 ;
|
||||
virtual bool SetGlobFrameParameters( int nPosFlag, double dDistX, double dDistY,
|
||||
double dLenLine, double dWidthLine) = 0 ;
|
||||
// Glob Cube
|
||||
virtual bool DrawCube( bool bSurf) = 0 ;
|
||||
virtual bool CreateFlatPart( ISurfTriMesh* pSrf) = 0 ;
|
||||
virtual bool CreateEdgePart( ISurfTriMesh* pSrf) = 0 ;
|
||||
virtual bool CreateCornerPart( ISurfTriMesh* pSrf) = 0 ;
|
||||
virtual bool SetGlobCubeParameters( int nPosFlag, double dDistX, double dDistY, double dLenEdge) = 0 ;
|
||||
// Direct
|
||||
virtual bool SetGeoLineAttribs( Color GLcol) = 0 ;
|
||||
virtual bool SetGeoLine( const Point3d& ptP1, const Point3d& ptP2) = 0 ;
|
||||
|
||||
@@ -59,7 +59,6 @@ EIN_EXPORT BOOL __stdcall EgtGetKeyOptions( int nProd, int nVer, int nLev, unsig
|
||||
EIN_EXPORT BOOL __stdcall EgtGetKeyLeftDays( int* pnLeftDays) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetKeyAssLeftDays( int* pnAssLeftDays) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetKeyOptLeftDays( int* pnOptLeftDays) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetNetHwKey( void) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetOsInfo( wchar_t*& wsOs) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCpuInfo( wchar_t*& wsCpu) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetMemoryInfo( wchar_t*& wsMem) ;
|
||||
@@ -119,7 +118,7 @@ EIN_EXPORT BOOL __stdcall EgtImportStl( const wchar_t* wsFilePath, double dScale
|
||||
EIN_EXPORT BOOL __stdcall EgtImport3MF( const wchar_t* wsFilePath) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtImport3dm( const wchar_t* wsFilePath) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtAdvancedImportIsEnabled( void) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtAdvancedImport( const wchar_t* wsFilePath, double dLinToler, int nFlag) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtAdvancedImport( const wchar_t* wsFilePath, double dLinToler) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtExportDxf( int nId, const wchar_t* wsFilePath, int nFlag, int nFilter) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtExportStl( int nId, const wchar_t* wsFilePath, int nFilter) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtExport3MF( int nId, const wchar_t* wsFilePath, int nFilter) ;
|
||||
@@ -212,15 +211,6 @@ EIN_EXPORT int __stdcall EgtCreateVerticalDimension( int nParentId, const doubl
|
||||
const double ptDim[3], const wchar_t* wsText, int nRefType) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateAlignedDimension( int nParentId, const double ptP1[3], const double ptP2[3],
|
||||
const double ptDim[3], const wchar_t* wsText, int nRefType) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateAngularDimension( int nParentId, const double ptV[3], const double ptP1[3], const double ptP2[3],
|
||||
const double ptDim[3], const wchar_t* wsText, int nRefType) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateAngularDimensionEx( int nParentId, const double ptV1[3], const double ptP1[3],
|
||||
const double ptV2[3], const double ptP2[3], const double ptDim[3],
|
||||
const wchar_t* wsText, int nRefType) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateDiametralDimension( int nParentId, int nCrvId, const double ptDim[3],
|
||||
const wchar_t* wsText, int nRefType) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateRadialDimension( int nParentId, int nCrvId, const double ptDim[3],
|
||||
const wchar_t* wsText, int nRefType) ;
|
||||
|
||||
// GeomDB Create Curve
|
||||
EIN_EXPORT int __stdcall EgtCreateLine( int nParentId,
|
||||
@@ -252,8 +242,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],
|
||||
@@ -318,10 +306,9 @@ EIN_EXPORT int __stdcall EgtCreateSurfTmByRevolve( int nParentId, int nCrvId,
|
||||
const double ptAx[3], const double vtAx[3],
|
||||
BOOL bCapEnds, double dLinTol, int nRefType) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateSurfTmByScrewing( int nParentId, int nCrvId,
|
||||
const double ptAx[3], const double vtAx[3],
|
||||
double dAngRotDeg, double dMove, BOOL bCapEnds, double dLinTol, int nRefType) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, const double vtAx[3],
|
||||
BOOL bCapEnds, double dLinTol, int nRefType) ;
|
||||
const double ptAx[3], const double vtAx[3],
|
||||
double dAngRotDeg, double dMove, BOOL bCapEnds, double dLinTol, int nRefType) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, BOOL bCapEnds, double dLinTol) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateSurfTmRuled( int nParentId, int nPntOrCrvId1, int nCrvId2, int nType, double dLinTol) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateSurfTmByTriangles( int nParentId, int nNumId, const int nIds[], BOOL bErase) ;
|
||||
EIN_EXPORT int __stdcall EgtCreateSurfTmBySewing( int nParentId, int nNumId, const int nIds[], BOOL bErase) ;
|
||||
@@ -542,8 +529,6 @@ EIN_EXPORT BOOL __stdcall EgtSurfFrAdd( int nId1, int nId2) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfFrSubtract( int nId1, int nId2) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfFrIntersect( int nId1, int nId2) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfFrOffset( int nId, double dDist, int nType) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfTmMoveVertex( int nId, int nVert, const double ptNewVert[3], int nRefType, BOOL bUpdate) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfTmMoveFacet( int nId, int nFacet, const double vtMove[3], int nRefType, BOOL bUpdate) ;
|
||||
EIN_EXPORT int __stdcall EgtSurfTmToTriangles( int nId, int* pnCount) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfTmRemoveFacet( int nId, int nFacet) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtCutSurfTmPlane( int nId, const double ptOn[3], const double vtN[3], BOOL bSaveOnEq, int nRefType) ;
|
||||
@@ -602,8 +587,6 @@ EIN_EXPORT int __stdcall EgtExtractSurfFrChunkLoops( int nId, int nChunk, int n
|
||||
EIN_EXPORT int __stdcall EgtSurfTmPartCount( int nId) ;
|
||||
EIN_EXPORT int __stdcall EgtSurfTmFacetCount( int nId) ;
|
||||
EIN_EXPORT int __stdcall EgtSurfTmFacetFromTria( int nId, int nT) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfTmGetVertex( int nId, int nVert, int nRefId, double ptVert[3]) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfTmGetNearestVertex( int nId, const double ptNear[3], int nRefId, int* pnVert, double ptVert[3]) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfTmFacetNearestEndPoint( int nId, int nFacet, const double ptNear[3], int nRefId,
|
||||
double ptEnd[3], double vtNorm[3]) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtSurfTmFacetNearestMidPoint( int nId, int nFacet, const double ptNear[3], int nRefId,
|
||||
@@ -968,13 +951,11 @@ EIN_EXPORT BOOL __stdcall EgtSetCalcTool( const wchar_t* wsTool, const wchar_t*
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCalcTool( wchar_t*& wsTool, wchar_t*& wsHead, int* pnExit) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCalcAngles( const double vtDirT[3], const double vtDirA[3],
|
||||
int* pnStat, double* pdAngA1, double* pdAngB1, double* pdAngA2, double* pdAngB2) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCalcAnglesEx( const double vtDirT[3], const double vtDirA[3],
|
||||
int* pnStat, double*& vAngs1, double*& vAngs2, int* pnCount) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCalcPositions( const double ptP[3], int nCount, const double dAngs[],
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCalcPositions( const double ptP[3], double dAngA, double dAngB,
|
||||
int* pnStat, double* pdX, double* pdY, double* pdZ) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCalcTipFromPositions( double dX, double dY, double dZ, int nCount, const double dAngs[],
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
|
||||
BOOL bBottom, double ptTip[3]) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCalcToolDirFromAngles( int nCount, const double dAngs[], double vtDir[3]) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetCalcToolDirFromAngles( double dAngA, double dAngB, double vtDir[3]) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtVerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int* pnStat) ;
|
||||
EIN_EXPORT BOOL __stdcall EgtGetOutstrokeInfo( wchar_t*& wsInfo) ;
|
||||
// Machine Move
|
||||
|
||||
+3
-10
@@ -1,7 +1,7 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2015-2024
|
||||
// EgalTech 2015-2023
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EMkMachMgr.h Data : 22.04.24 Versione : 2.6d4
|
||||
// File : EMkMachMgr.h Data : 28.10.23 Versione : 2.5j4
|
||||
// Contenuto : Dichiarazione della interfaccia IMachMgr.
|
||||
//
|
||||
//
|
||||
@@ -15,9 +15,6 @@
|
||||
// 21.09.22 DS Aggiunta in interfaccia GetAxisOffset.
|
||||
// 25.08.23 DS Aggiunta in interfaccia CopyMachGroup.
|
||||
// 28.10.23 DS Aggiunte in interfaccia GetClEntAxesVal, GetToolSetupPosInCurrSetup e GetAllCurrAxesName.
|
||||
// 30.03.24 DS Aggiunte in interfaccia GetAllAxesNames e GetCalcTable.
|
||||
// 02.04.24 DS Aggiunta in interfaccia GetClEntAxesMask.
|
||||
// 22.04.24 DS Aggiunta in interfaccia GetExitId.
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -272,7 +269,6 @@ class __declspec( novtable) IMachMgr
|
||||
virtual bool GetClEntMove( int nEntId, int& nMove) const = 0 ;
|
||||
virtual bool GetClEntFlag( int nEntId, int& nFlag, int& nFlag2) const = 0 ;
|
||||
virtual bool GetClEntIndex( int nEntId, int& nIndex) const = 0 ;
|
||||
virtual bool GetClEntAxesMask( int nEntId, int& nMask) const = 0 ;
|
||||
virtual bool GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const = 0 ;
|
||||
// Simulation
|
||||
virtual bool SimInit( void) = 0 ;
|
||||
@@ -292,10 +288,9 @@ class __declspec( novtable) IMachMgr
|
||||
// Machine Calc
|
||||
virtual bool SetCalcTable( const std::string& sTable) = 0 ;
|
||||
virtual bool SetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) = 0 ;
|
||||
virtual bool GetAllCurrAxesNames( STRVECTOR& vAxName) const = 0 ;
|
||||
virtual bool GetAllCurrAxesName( 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 ;
|
||||
@@ -323,7 +318,6 @@ class __declspec( novtable) IMachMgr
|
||||
virtual int GetAxisId( const std::string& sAxis) const = 0 ;
|
||||
virtual int GetHeadId( const std::string& sHead) const = 0 ;
|
||||
virtual int GetHeadExitCount( const std::string& sHead) const = 0 ;
|
||||
virtual int GetExitId( const std::string& sHead, int nExit) const = 0 ;
|
||||
virtual int GetTcPosId( const std::string& sTcPos) const = 0 ;
|
||||
virtual bool GetAxisToken( const std::string& sAxis, std::string& sToken) const = 0 ;
|
||||
virtual bool GetAxisType( const std::string& sAxis, bool& bLinear) const = 0 ;
|
||||
@@ -337,7 +331,6 @@ class __declspec( novtable) IMachMgr
|
||||
virtual bool ResetAxisPos( const std::string& sAxis) = 0 ;
|
||||
virtual bool ResetAllAxesPos( void) = 0 ;
|
||||
virtual bool GetAllTablesNames( STRVECTOR& vNames) const = 0 ;
|
||||
virtual bool GetAllAxesNames( STRVECTOR& vNames) const = 0 ;
|
||||
virtual bool GetAllHeadsNames( STRVECTOR& vNames) const = 0 ;
|
||||
virtual bool GetAllTcPosNames( STRVECTOR& vNames) const = 0 ;
|
||||
virtual bool LoadTool( const std::string& sHead, int nExit, const std::string& sTool) = 0 ;
|
||||
|
||||
+3
-5
@@ -1,7 +1,7 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2015-2024
|
||||
// EgalTech 2015-2023
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EmkMachiningConst.h Data : 29.03.24 Versione : 2.6di1
|
||||
// File : EmkMachiningConst.h Data : 06.09.23 Versione : 2.5i1
|
||||
// Contenuto : Costanti delle lavorazioni.
|
||||
//
|
||||
//
|
||||
@@ -13,7 +13,6 @@
|
||||
// 09.11.20 DS Agg. MPA_SIDEANGFEED e MPA_STEPLAST.
|
||||
// 04.02.22 DS Agg. MPA_EPICYCLESRAD e MPA_EPICYCLESDIST.
|
||||
// 06.09.23 DS Agg. 5AxMachining.
|
||||
// 29.03.24 DS Agg. MGP_APPROXLINTOL.
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -40,8 +39,7 @@ enum MgpType { MGP_NONE = 0,
|
||||
MGP_EXTSAWARCMINRAD = ( MGP_DOU + 4),
|
||||
MGP_INTSAWARCMAXSIDEANG =( MGP_DOU + 5),
|
||||
MGP_SAFEAGGRBOTTZ = ( MGP_DOU + 6),
|
||||
MGP_MAXDEPTHSAFE = ( MGP_DOU + 7),
|
||||
MGP_APPROXLINTOL = ( MGP_DOU + 8)} ;
|
||||
MGP_MAXDEPTHSAFE = ( MGP_DOU + 7)} ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Costanti per tipologia di split arcs
|
||||
|
||||
@@ -35,7 +35,7 @@ static std::string MCH_ST = "ST" ;
|
||||
static std::string MCH_CL = "CL" ;
|
||||
static std::string MCH_DBL = "DBL" ;
|
||||
static std::string MCH_PATH = "P" ;
|
||||
// Nomi di entità CL speciali
|
||||
// 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" ;
|
||||
@@ -45,7 +45,7 @@ static std::string MCH_CL_AGB_DWN = "AGBD" ;
|
||||
static std::string MCH_CL_AGB_IN = "AGBI" ;
|
||||
static std::string MCH_CL_AGB_OUT = "AGBO" ;
|
||||
static std::string MCH_CL_AGB_UP = "AGBU" ;
|
||||
// Nomi di entità di preview
|
||||
// Nomi di entità di preview
|
||||
static std::string MCH_PV_CUT = "CUT" ;
|
||||
static std::string MCH_PV_PRE_CUT = "PRC" ;
|
||||
static std::string MCH_PV_POST_CUT = "POC" ;
|
||||
@@ -60,8 +60,6 @@ static std::string MCH_PV_DOWN_RCUT = "DRCUT" ;
|
||||
static std::string MCH_PV_DOWN_RRCUT = "DRRCUT" ;
|
||||
static std::string MCH_PV_DOWN_RLICUT = "DRLICUT" ;
|
||||
static std::string MCH_PV_DOWN_RLOCUT = "DRLOCUT" ;
|
||||
static std::string MCH_PV_UP_RAWCUT = "RUPCUT" ;
|
||||
static std::string MCH_PV_DOWN_RAWCUT = "RDWNCUT" ;
|
||||
// Chiave info con WidthT, DeltaTi, DeltaT, ExtraCut e RawBottomHeight lama in Preview
|
||||
static std::string MCH_PV_KEY_WT = "WT" ;
|
||||
static std::string MCH_PV_KEY_DTI = "DTI" ;
|
||||
@@ -70,10 +68,10 @@ static std::string MCH_PV_KEY_EC = "EC" ;
|
||||
static std::string MCH_PV_KEY_RBH = "RBH" ;
|
||||
// Chiave info per rinvio a preview spostato nel pezzo in Preview
|
||||
static std::string MCH_PV_KEY_RELOCATE = "PvId" ;
|
||||
// Chiave info per angoli in XY con entità successiva e precedente
|
||||
// Chiave info per angoli in XY con entità successiva e precedente
|
||||
static std::string MCH_KEY_NEXTANG = "NextAng" ;
|
||||
static std::string MCH_KEY_PREVANG = "PrevAng" ;
|
||||
// Chiave info per direzione libera in XY all'inizio e alla fine dell'entità (in assenza infinito)
|
||||
// Chiave info per direzione libera in XY all'inizio e alla fine dell'entità (in assenza infinito)
|
||||
static std::string MCH_KEY_START_FREELEN = "SFL" ;
|
||||
static std::string MCH_KEY_END_FREELEN = "EFL" ;
|
||||
// Angolo esterno minimo per calcolare la direzione libera sull'arco
|
||||
@@ -108,8 +106,6 @@ static std::string KEY_MMAX = "MMAX" ;
|
||||
// Chiavi info in gruppo CL per punti assi minimo e massimo di ingombro di tutta la lavorazione
|
||||
static std::string KEY_MAXMIN = "MAXMIN" ;
|
||||
static std::string KEY_MAXMAX = "MAXMAX" ;
|
||||
// Chiave info in sottogruppo di testa per abilitarne visualizzazione in Preview (0/1 default)
|
||||
static std::string KEY_PREVIEWSHOW = "PreviewShow" ;
|
||||
|
||||
//----------------- Costanti posizione per preview utensile in lavorazione ------
|
||||
enum MchToolShow { MCH_TPM_CURR = 0,
|
||||
|
||||
+8
-42
@@ -1,7 +1,7 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2015-2024
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EXcExecutor.h Data : 30.03.24 Versione : 2.6d1
|
||||
// File : EXcExecutor.h Data : 09.01.24 Versione : 2.5l6
|
||||
// Contenuto : Interfaccia Executor.
|
||||
//
|
||||
//
|
||||
@@ -64,7 +64,6 @@ EXE_EXPORT bool ExeGetKeyOptions( int nProd, int nVer, int nLev, unsigned int& n
|
||||
EXE_EXPORT bool ExeGetKeyLeftDays( int& nLeftDays) ;
|
||||
EXE_EXPORT bool ExeGetKeyAssLeftDays( int& nAssLeftDays) ;
|
||||
EXE_EXPORT bool ExeGetKeyOptLeftDays( int& nOptLeftDays) ;
|
||||
EXE_EXPORT bool ExeGetNetHwKey( void) ;
|
||||
EXE_EXPORT bool ExeGetOsInfo( std::string& sOs) ;
|
||||
EXE_EXPORT bool ExeGetCpuInfo( std::string& sCpu) ;
|
||||
EXE_EXPORT bool ExeGetMemoryInfo( std::string& sMem) ;
|
||||
@@ -127,7 +126,7 @@ EXE_EXPORT bool ExeImportStl( const std::string& sFilePath, double dScaleFactor)
|
||||
EXE_EXPORT bool ExeImport3MF( const std::string& sFilePath) ;
|
||||
EXE_EXPORT bool ExeImport3dm( const std::string& sFilePath) ;
|
||||
EXE_EXPORT bool ExeAdvancedImportIsEnabled( void) ;
|
||||
EXE_EXPORT bool ExeAdvancedImport( const std::string& sFilePath, double dToler = 0.1, int nFlag = 0) ;
|
||||
EXE_EXPORT bool ExeAdvancedImport( const std::string& sFilePath, double dToler = 0.1) ;
|
||||
EXE_EXPORT bool ExeExportDxf( int nId, const std::string& sFilePath, int nFlag = 1, int nFilter = 393) ;
|
||||
EXE_EXPORT bool ExeExportStl( int nId, const std::string& sFilePath, int nFilter = 393) ;
|
||||
EXE_EXPORT bool ExeExport3MF( int nId, const std::string& sFilePath, int nFilter = 393) ;
|
||||
@@ -234,11 +233,8 @@ EXE_EXPORT int ExeCreateAlignedDimension( int nParentId, const Point3d& ptP1, c
|
||||
const Point3d& ptDim, const std::string& sText, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateRadialDimension( int nParentId, int nCrvId, const Point3d& ptDim, const std::string& sText, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim, const std::string& sText, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2,
|
||||
EXE_EXPORT int ExeCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2,
|
||||
const Point3d& ptDim, const std::string& sText, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateAngularDimensionEx( int nParentId, const Point3d& ptV1, const Point3d& ptP1,
|
||||
const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptDim,
|
||||
const std::string& sText, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateAngularDimensionFromLines( int nParentId, const INTVECTOR vLineIds, const Point3d& ptDim,
|
||||
const std::string& sText, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDim,
|
||||
@@ -275,8 +271,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,
|
||||
@@ -360,24 +354,20 @@ EXE_EXPORT int ExeCreateSurfTmByScrewing( int nParentId, int nCrvId,
|
||||
double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateSurfTmRectSwept( int nParentId, double dDimH, double dDimV, double dBevelH, double dBevelV,
|
||||
int nGuideId, int nCapType, double dLinTol) ;
|
||||
EXE_EXPORT int ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, const Vector3d& vtAx,
|
||||
bool bCapEnds, double dLinTol, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol) ;
|
||||
EXE_EXPORT int ExeCreateSurfTmTransSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol) ;
|
||||
EXE_EXPORT int ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrCrvId2, int nType, double dLinTol) ;
|
||||
EXE_EXPORT int ExeCreateSurfTmByTriangles( int nParentId, const INTVECTOR& vIds, bool bErase) ;
|
||||
EXE_EXPORT int ExeCreateSurfTmBySewing( int nParentId, const INTVECTOR& vIds, bool bErase) ;
|
||||
EXE_EXPORT int ExeCreateSurfTmBySurfBezier( int nParentId, int nSbezId) ;
|
||||
EXE_EXPORT int ExeCreateSurfTmByVolZmap( int nParentId, int nZmapId, int nPart) ;
|
||||
EXE_EXPORT int ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTVECTOR& vPnt, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTUVECTOR& vPntW, int nRefType) ;
|
||||
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) ;
|
||||
|
||||
// GeomDB Create Volume
|
||||
EXE_EXPORT int ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX,
|
||||
double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateVolZmapEmpty( int nParentId, const Point3d& ptIni, double dDimX,
|
||||
double dDimY, double dDimZ, double dPrec, bool bTriDex, int nRefType) ;
|
||||
EXE_EXPORT int ExeCreateVolZmapByRegionExtrusion( int nParentId, int nSfrId, double dDimZ, double dPrec, bool bTriDex) ;
|
||||
EXE_EXPORT int ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDex) ;
|
||||
|
||||
@@ -605,8 +595,6 @@ EXE_EXPORT bool ExeChainCurvesInGroup( int nGroupId, const Point3d& ptNear, int
|
||||
EXE_EXPORT bool ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType) ;
|
||||
EXE_EXPORT bool ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId,
|
||||
double dLinTol, double dMaxSegmLen, int nRefType) ;
|
||||
EXE_EXPORT bool ExeProjectCurveOnSurfTmExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
|
||||
double dLinTol, double dMaxSegmLen, bool bDirFromGuide) ;
|
||||
EXE_EXPORT int ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) ;
|
||||
EXE_EXPORT int ExeCurveGetMedialAxis( int nId, int nDestGrpId, int nSide, int* pnCount) ;
|
||||
EXE_EXPORT int ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, bool bSquareMids, int* pnCount) ;
|
||||
@@ -614,7 +602,7 @@ EXE_EXPORT int ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool
|
||||
// GeomDb Surf Modify
|
||||
EXE_EXPORT bool ExeInvertSurface( const INTVECTOR& vIds) ;
|
||||
EXE_EXPORT int ExeExplodeSurface( int nId, int* pnCount) ;
|
||||
EXE_EXPORT bool ExeApproxSurface( int nId, double dLinTol, double dTriaMinSide = 100 * EPS_SMALL) ;
|
||||
EXE_EXPORT bool ExeApproxSurface( int nId, double dLinTol) ;
|
||||
EXE_EXPORT bool ExeSurfFrAdd( int nId1, int nId2) ;
|
||||
EXE_EXPORT bool ExeSurfFrSubtract( int nId1, int nId2) ;
|
||||
EXE_EXPORT bool ExeSurfFrIntersect( int nId1, int nId2) ;
|
||||
@@ -623,30 +611,26 @@ EXE_EXPORT bool ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewI
|
||||
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) ;
|
||||
EXE_EXPORT bool ExeSurfTmMoveFacet( int nId, int nFacet, const Vector3d& vtMove, int nRefType, bool bUpdate) ;
|
||||
EXE_EXPORT int ExeSurfTmToTriangles( int nId, int* pnCount) ;
|
||||
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) ;
|
||||
EXE_EXPORT bool ExeSurfTmIntersect( int nId1, int nId2, bool bTwoColors = false) ;
|
||||
EXE_EXPORT bool ExeSurfTmResetTwoColors( int nId) ;
|
||||
EXE_EXPORT int ExeSurfTmSplit( int nId, int nSplitterId, int* pnCount) ;
|
||||
EXE_EXPORT bool ExeSurfTmCut( int nId, int nCutterId, bool bInVsOut, bool bSaveOnEq) ;
|
||||
EXE_EXPORT bool ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId,
|
||||
INTVECTOR vSurfsId, bool bOCFlag,
|
||||
bool& bExistProjection, int& nNewId, int& nNewFaceNbr) ;
|
||||
EXE_EXPORT bool ExeSurfTmResetTwoColors( int nId) ;
|
||||
EXE_EXPORT bool ExeSurfTmSetShowEdges( int nId, bool bShow) ;
|
||||
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 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) ;
|
||||
@@ -659,8 +643,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,
|
||||
@@ -827,8 +809,6 @@ EXE_EXPORT bool ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, con
|
||||
INTDBLVECTOR& vInters) ;
|
||||
EXE_EXPORT bool ExeLineSurfTmInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
|
||||
INTDBLVECTOR& vInters) ;
|
||||
EXE_EXPORT bool ExeLineSurfBzInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
|
||||
INTDBLVECTOR& vInters) ;
|
||||
EXE_EXPORT bool ExeLineVolZmapInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
|
||||
INTDBLVECTOR& vInters) ;
|
||||
EXE_EXPORT int ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, const int nId, const int nDestGrpId, const int nRefType,
|
||||
@@ -858,16 +838,6 @@ EXE_EXPORT int ExeCDeConeSolid( const Frame3d& frCone, double dR1, double dR2,
|
||||
EXE_EXPORT int ExeCDeSpheSolid( const Point3d& ptCen, double dR, int nSolidId, double dSafeDist, int nRefType) ;
|
||||
EXE_EXPORT int ExeCDeSolidSolid( int nSolid1Id, int nSolid2Id, double dSafeDist) ;
|
||||
|
||||
// Test Interference
|
||||
EXE_EXPORT int ExeTestBoxSurface( const Frame3d& frBox, const Vector3d& vtDiag, int nSurfId, double dSafeDist, int nRefType) ;
|
||||
EXE_EXPORT int ExeTestRectPrismoidSurface( const Frame3d& frPrismoid, double dBaseLenX, double dBaseLenY,
|
||||
double dTopLenX, double dTopLenY, double dHeight,
|
||||
int nSurfId, double dSafeDist, int nRefType) ;
|
||||
EXE_EXPORT int ExeTestCylSurface( const Frame3d& frCyl, double dR, double dH, int nSurfId, double dSafeDist, int nRefType) ;
|
||||
EXE_EXPORT int ExeTestConeSurface( const Frame3d& frCone, double dR1, double dR2, double dH, int nSurfId, double dSafeDist, int nRefType) ;
|
||||
EXE_EXPORT int ExeTestSpheSurface( const Point3d& ptCen, double dR, int nSurfId, double dSafeDist, int nRefType) ;
|
||||
EXE_EXPORT int ExeTestSurfaceSurface( int nSurf1Id, int nSurf2Id, double dSafeDist) ;
|
||||
|
||||
// Maximum Filler
|
||||
EXE_EXPORT bool ExeMaxFillerStart( void) ;
|
||||
EXE_EXPORT bool ExeMaxFillerAddPart( int nPartId, double dLen) ;
|
||||
@@ -1177,7 +1147,6 @@ EXE_EXPORT bool ExeUpdateAllMachiningsEx( bool bStopOnFirstErr, std::string& sEr
|
||||
EXE_EXPORT bool ExeGetClEntMove( int nEntId, int& nMove) ;
|
||||
EXE_EXPORT bool ExeGetClEntFlag( int nEntId, int& nFlag, int& nFlag2) ;
|
||||
EXE_EXPORT bool ExeGetClEntIndex( int nEntId, int& nIndex) ;
|
||||
EXE_EXPORT bool ExeGetClEntAxesMask( int nEntId, int& nMask) ;
|
||||
EXE_EXPORT bool ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) ;
|
||||
|
||||
// Simulation
|
||||
@@ -1202,23 +1171,20 @@ 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 ExeGetAxisInvert( const std::string& sAxis, bool& bInvert) ;
|
||||
EXE_EXPORT bool ExeGetAxisOffset( const std::string& sAxis, double& dOffset) ;
|
||||
EXE_EXPORT bool ExeGetAllTablesNames( STRVECTOR& vNames) ;
|
||||
EXE_EXPORT bool ExeGetAllAxesNames( STRVECTOR& vNames) ;
|
||||
EXE_EXPORT bool ExeGetAllHeadsNames( STRVECTOR& vNames) ;
|
||||
EXE_EXPORT bool ExeGetAllTcPosNames( STRVECTOR& vNames) ;
|
||||
// Machine Calc
|
||||
EXE_EXPORT bool ExeSetCalcTable( const std::string& sTable) ;
|
||||
EXE_EXPORT bool ExeSetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) ;
|
||||
EXE_EXPORT bool ExeGetAllCurrAxesName( STRVECTOR& vAxName) ;
|
||||
EXE_EXPORT bool ExeSetRotAxisBlock( const std::string& sAxis, double dVal) ;
|
||||
EXE_EXPORT bool ExeGetCalcTable( std::string& sTable) ;
|
||||
EXE_EXPORT bool ExeGetCalcTool( std::string& sTool, std::string& sHead, int& nExit) ;
|
||||
EXE_EXPORT bool ExeGetAllCurrAxesNames( STRVECTOR& vAxName) ;
|
||||
EXE_EXPORT bool ExeGetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) ;
|
||||
EXE_EXPORT bool ExeGetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
|
||||
int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) ;
|
||||
|
||||
+1
-1
@@ -25,7 +25,7 @@
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
const int KEY_BASELIB_PROD = 207 ;
|
||||
const int KEY_BASELIB_VER = 2604 ;
|
||||
const int KEY_BASELIB_VER = 2603 ;
|
||||
const int KEY_BASELIB_LEV = 1 ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
@@ -44,4 +44,3 @@ const int KEY_ERR_VER = 5 ;
|
||||
const int KEY_ERR_LEV = 6 ;
|
||||
const int KEY_ERR_WRONG_TIME = 7 ;
|
||||
const int KEY_ERR_TIME = 8 ;
|
||||
const int KEY_ERR_NETKEY_NOTFOUND = 9 ;
|
||||
|
||||
@@ -23,8 +23,6 @@ bool SetLockType( int nType) ;
|
||||
bool SetNetHwKey( bool bNetHwKey, int nUserId, const std::string& sAddrPort) ;
|
||||
// Libero chiave di rete (da eseguire al termine del programma)
|
||||
bool CloseNetHwKey( void) ;
|
||||
// Chiave di rete non trovata (il dispositivo non risponde)
|
||||
bool NotFoundNetHwKey( void) ;
|
||||
// Recupero l'identificativo in chiaro della protezione
|
||||
bool GetLockId( std::string& sLockId) ;
|
||||
// Recupero l'identificativo cifrato della protezione
|
||||
|
||||
Reference in New Issue
Block a user