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

Include :

Browse Source 
- aggiornamento.
This commit is contained in:
Dario Sassi
2014-07-01 12:31:23 +00:00
parent ce98475a7c
commit f553fc3466
10 changed files with 113 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EGkBBox3d.h
+4
View File
@@ -64,9 +64,13 @@ class EGK_EXPORT BBox3d
bool ToGlob( const Frame3d& frRef) ;
bool ToLoc( const Frame3d& frRef) ;
bool Encloses( const Point3d& ptP) const ;
bool EnclosesXY( const Point3d& ptP) const ;
bool Overlaps( const BBox3d& b3B) const ;
bool OverlapsXY( const BBox3d& b3B) const ;
bool FindIntersection( const BBox3d& b3B, BBox3d& b3Int) const ;
bool FindIntersectionXY( const BBox3d& b3B, BBox3d& b3Int) const ;
double SqDistFromPoint( const Point3d& ptP) const ;
double SqDistFromPointXY( const Point3d& ptP) const ;
private :
bool IsValid( void) const ;
EGkCurvePointDiffGeom.h
+3 -3
View File
@@ -56,14 +56,14 @@ ThereIsDiscontinuity( CrvPointDiffGeom& oDiffGp, CrvPointDiffGeom& oDiffGs)
return false ;
// verifico che il parametro e i punti coincidano
if ( fabs ( oDiffGp.dU - oDiffGs.dU) > EPS_ZERO ||
! AreSamePointNear( oDiffGp.ptP, oDiffGs.ptP))
! AreSamePointApprox( oDiffGp.ptP, oDiffGs.ptP))
return false ;
// verifico che siano definite le tangenti
if ( ( oDiffGp.nStatus & CrvPointDiffGeom::TANG) == 0 ||
( oDiffGs.nStatus & CrvPointDiffGeom::TANG) == 0)
return false ;
// verifico discontinuità sulle tangenti
if ( ! AreSameVectorNear( oDiffGp.vtT, oDiffGs.vtT)) {
if ( ! AreSameVectorApprox( oDiffGp.vtT, oDiffGs.vtT)) {
oDiffGp.nFlag = CrvPointDiffGeom::P1_DISC_TG ;
oDiffGs.nFlag = CrvPointDiffGeom::P2_DISC_TG ;
return true ;
@@ -73,7 +73,7 @@ ThereIsDiscontinuity( CrvPointDiffGeom& oDiffGp, CrvPointDiffGeom& oDiffGs)
( oDiffGs.nStatus & CrvPointDiffGeom::NCRV) == 0)
return false ;
// verifico discontinuità sulle normali/curvature
if ( ! AreSameVectorNear( oDiffGp.vtN, oDiffGs.vtN) ||
if ( ! AreSameVectorApprox( oDiffGp.vtN, oDiffGs.vtN) ||
fabs( oDiffGp.dCurv - oDiffGs.dCurv) > EPS_SMALL) {
oDiffGp.nFlag = CrvPointDiffGeom::P1_DISC_NC ;
oDiffGs.nFlag = CrvPointDiffGeom::P2_DISC_NC ;
EGkFrame3d.h
+1 -1
View File
@@ -127,7 +127,7 @@ AreSameFrame( const Frame3d& frRef1, const Frame3d& frRef2)
{
if ( frRef1.GetType() == Frame3d::ERR || frRef2.GetType() == Frame3d::ERR)
return false ;
if ( ! AreSamePointNear( frRef1.Orig(), frRef2.Orig()))
if ( ! AreSamePointApprox( frRef1.Orig(), frRef2.Orig()))
return false ;
if ( ! AreSameVectorExact( frRef1.VersX(), frRef2.VersX()))
return false ;
EGkGeoConst.h
+1
View File
@@ -23,6 +23,7 @@ const double ONEINCH = 25.4 ;
const double EPS_SMALL = 1e-3 ;
const double EPS_ZERO = 1e-7 ;
const double EPS_PARAM = 1e-7 ;
const double HSPAN_PARAM = 0.5 ; // metà intervallo di curva o superficie semplici
// infinito per lunghezze
const double INFINITO = 1e10 ;
EGkIntersCurveCurve.h
+33 -52
View File
@@ -27,61 +27,44 @@
//-----------------------------------------------------------------------------
struct IntCrvInfo {
// dati dell'intersezione relativi alla curva
double dU ; //!< parametro
Point3d ptI ; //!< punto sulla curva (Z della curva, intersezione a Z=0)
int nTy ; //!< tipo
// costruttori
// dati di intersezione relativi ad una curva
double dU ; //!< parametro
Point3d ptI ; //!< punto sulla curva (Z della curva, intersezione a Z=0)
int nPrevTy ; //!< tipo di approccio (precedente l'intersezione)
int nNextTy ; //!< tipo di allontanamento (seguente l'intersezione)
// costruttore
IntCrvInfo( void)
: dU( 0), ptI(), nTy( 0){}
IntCrvInfo( double dUp, Point3d ptIp, int nTyp)
: dU( dUp), ptI( ptIp), nTy( nTyp){}
// assegnazione
void Set( double dUp, Point3d ptIp, int nTyp)
{ dU = dUp ; ptI = ptIp ; nTy = nTyp ; }
: dU( 0), ptI(), nPrevTy( 0), nNextTy(0) {}
} ;
struct IntCrvCrvInfo {
IntCrvInfo Ici[2] ;
// costruttori
// dati di intersezione delle due curve A e B
bool bOverlap ; //!< intersezione con overlap
bool bCBOverEq ; //!< overlap su curva B equiverso o controverso con curva A
IntCrvInfo IciA[2] ; //!< IciA[0] intersez. isolata o inizio overlap, IciA[1] fine overlap
IntCrvInfo IciB[2] ; //!< IciB[0] intersez. isolata o inizio overlap, IciB[1] fine overlap
// costruttore
IntCrvCrvInfo( void)
{ Ici[0].Set( 0, Point3d(), 0) ; Ici[1].Set( 0, Point3d(), 0) ; }
IntCrvCrvInfo( double dU1p, Point3d ptI1p, int nTy1p, double dU2p, Point3d ptI2p, int nTy2p)
{ Ici[0].Set( dU1p, ptI1p, nTy1p) ; Ici[1].Set( dU2p, ptI2p, nTy2p) ; }
: bOverlap( false) {}
} ;
typedef std::vector<IntCrvCrvInfo> ICCIVECTOR ; // vettore di IntCrvCrvInfo
//-----------------------------------------------------------------------------
// Costanti per tipo di intersezione
const int ICCT_RESET = 0 ;
const int ICCT_PNULL = 0 ;
const int ICCT_PIN = 1 ;
const int ICCT_PON = 2 ;
const int ICCT_POUT = 3 ;
const int ICCT_NNULL = 0 ;
const int ICCT_NIN = 4 ;
const int ICCT_NON = 8 ;
const int ICCT_NOUT = 12 ;
// Per settare entrambi contemporaneamente basta sommare i valori dei due flag Prev e Next
inline bool SetIcctPrev( int nVal, int& nFlag)
{ if ( ( nVal & ( ~ICCT_POUT)) != 0)
return false ;
nFlag &= ( ~ICCT_POUT) ;
nFlag |= nVal ;
return true ; }
inline bool SetIcctNext( int nVal, int& nFlag)
{ if ( ( nVal & ( ~ICCT_NOUT)) != 0)
return false ;
nFlag &= ( ~ICCT_NOUT) ;
nFlag |= nVal ;
return true ; }
inline bool IsIcctPrevNull( int nFlag) { return ( ( nFlag & ICCT_POUT) == ICCT_PNULL) ; }
inline bool IsIcctPrevIn( int nFlag) { return ( ( nFlag & ICCT_POUT) == ICCT_PIN) ; }
inline bool IsIcctPrevOn( int nFlag) { return ( ( nFlag & ICCT_POUT) == ICCT_PON) ; }
inline bool IsIcctPrevOut( int nFlag) { return ( ( nFlag & ICCT_POUT) == ICCT_POUT) ; }
inline bool IsIcctNextNull( int nFlag) { return ( ( nFlag & ICCT_NOUT) == ICCT_NNULL) ; }
inline bool IsIcctNextIn( int nFlag) { return ( ( nFlag & ICCT_NOUT) == ICCT_NIN) ; }
inline bool IsIcctNextOn( int nFlag) { return ( ( nFlag & ICCT_NOUT) == ICCT_NON) ; }
inline bool IsIcctNextOut( int nFlag) { return ( ( nFlag & ICCT_NOUT) == ICCT_NOUT) ; }
// Tipo di intersezione
// puntiforme bOverlap = false bCBOverEq = non conta
// sovrapposta equiversa bOverlap = true bCBOverEq = true
// sovrapposta controversa bOverlap = true bCBOverEq = false
// Costanti per tipo di approccio/allontanamento dall'intersezione
const int ICCT_NULL = 0 ;
const int ICCT_IN = 1 ;
const int ICCT_ON = 2 ;
const int ICCT_OUT = 3 ;
// Calcolo del tipo duale
inline int GetDualIcct( int nType)
{ switch ( nType) {
case ICCT_IN : return ICCT_OUT ;
case ICCT_OUT : return ICCT_IN ;
default : return nType ;
}}
//-----------------------------------------------------------------------------
class IntersCurveCurve
@@ -89,19 +72,17 @@ class IntersCurveCurve
public :
//! Le intersezioni sono calcolate nel piano XY locale.<br/>
//! Il flag bIsSegment vale solo per le linee.
EGK_EXPORT IntersCurveCurve( const ICurve& Curve1, const ICurve& Curve2, bool bIsSegment = true) ;
EGK_EXPORT IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB, bool bIsSegment = true) ;
public :
EGK_EXPORT bool GetOverlaps( void) ;
EGK_EXPORT int GetNumInters( void) ;
EGK_EXPORT bool GetIntersParam( int nInd, int nCrv, double& dPar) ;
EGK_EXPORT bool GetIntersPoint( int nInd, int nCrv, Point3d& ptI) ;
EGK_EXPORT bool GetIntersType( int nInd, int nCrv, int& nType) ;
EGK_EXPORT bool GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
EGK_EXPORT bool GetIntersPointNearTo( int nCrv, const Point3d& ptNear, Point3d& ptI) ;
private :
void LineLineCalculate( const ICurve& Curve1, const ICurve& Curve2, bool bIsSegment) ;
void LineLineCalculate( const ICurve& CurveA, const ICurve& CurveB, bool bIsSegment) ;
void CrvCompoCrvCompoCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
private :
bool m_bOverlaps ;
EGkPoint3d.h
+2 -2
View File
@@ -248,10 +248,10 @@ DirDist( const Point3d& ptP1, const Point3d& ptP2, Vector3d& vtDir, double& dDis
}
//----------------------------------------------------------------------------
// Verifica che due punti sono quasi coincidenti (Small error -> Near)
// Verifica che due punti sono quasi coincidenti (Small error -> Approx)
//----------------------------------------------------------------------------
inline bool
AreSamePointNear( const Point3d& ptP1, const Point3d& ptP2)
AreSamePointApprox( const Point3d& ptP1, const Point3d& ptP2)
{
return ( SqDist( ptP1, ptP2) < ( EPS_SMALL * EPS_SMALL)) ;
}
EGkTriangle3d.h
+2 -2
View File
@@ -32,12 +32,12 @@ class Triangle3d
return true ;
}
bool Validate( void)
{ if ( AreSamePointNear( ptP[0], ptP[1]) || AreSamePointNear( ptP[0], ptP[2]))
{ if ( AreSamePointApprox( ptP[0], ptP[1]) || AreSamePointApprox( ptP[0], ptP[2]))
return false ;
Vector3d vtV = ( ptP[1] - ptP[0]) ^ ( ptP[2] - ptP[0]) ;
vtV.Normalize() ;
if ( ! vtN.IsZero())
return AreSameVectorNear( vtV, vtN) ;
return AreSameVectorApprox( vtV, vtN) ;
vtN = vtV ;
return true ;
}
EGkVector3d.h
+63 -19
View File
@@ -31,61 +31,100 @@ class Frame3d ;
class EGK_EXPORT Vector3d
{
public :
//! Costruttore del vettore con tre componenti X, Y e Z
Vector3d( double dX, double dY, double dZ) : x( dX), y( dY), z( dZ) {}
//! Costruttore del vettore con due componenti X e Y, Z = 0
Vector3d( double dX, double dY) : x( dX), y( dY), z( 0) {}
//! Costruttore del vettore nullo X= Y = Z = 0
Vector3d( void) : x( 0), y( 0), z( 0) {}
//! Assegnazione delle componenti X, Y e Z al vettore
void Set( double dX, double dY, double dZ) { x = dX ; y = dY ; z = dZ ;}
//! Copia
const Vector3d& operator =( const Vector3d& vtSrc)
{ if ( &vtSrc != this) {
x = vtSrc.x , y = vtSrc.y , z = vtSrc.z ; }
return *this ; }
//! Definizione a partire da coordinate sferiche
void FromSpherical( double dLen, double dAngVertDeg, double dAngOrizzDeg) ;
//! Definizione a partire da coordinate polari
void FromPolar( double dLen, double dAngDeg) ;
public :
//! Quadrato della lunghezza del vettore
double SqLen( void) const
{ return ( x * x + y * y + z * z) ; }
//! Lunghezza del vettore
double Len( void) const ;
//! Quadrato della lunghezza del vettore nel piano XY
double SqLenXY( void) const
{ return ( x * x + y * y ) ; }
//! Lunghezza del vettore nel piano XY
double LenXY( void) const ;
//! Verifica se il vettore è quasi nullo
bool IsSmall( void) const
{ return ( ( x * x + y * y + z * z) < ( EPS_SMALL * EPS_SMALL)) ; }
//! Verifica se il vettore è esattamente nullo
bool IsZero( void) const
{ return ( ( x * x + y * y + z * z) < ( EPS_ZERO * EPS_ZERO)) ; }
//! Verifica se il vettore è normalizzato (è un versore)
bool IsNormalized( void) const
{ return ( fabs( 1.0 - (x * x + y * y + z * z)) < ( 2 * EPS_ZERO)) ; }
//! Verifica se il vettore è parallelo ed equiverso con X+
bool IsXplus( void) const
{ return ( x > EPS_ZERO && fabs( y) < EPS_ZERO && fabs( z) < EPS_ZERO) ; }
//! Verifica se il vettore è parallelo ed equiverso con X-
bool IsXminus( void) const
{ return ( x < - EPS_ZERO && fabs( y) < EPS_ZERO && fabs( z) < EPS_ZERO) ; }
//! Verifica se il vettore è parallelo ed equiverso con Y+
bool IsYplus( void) const
{ return ( fabs( x) < EPS_ZERO && y > EPS_ZERO && fabs( z) < EPS_ZERO) ; }
//! Verifica se il vettore è parallelo ed equiverso con Y-
bool IsYminus( void) const
{ return ( fabs( x) < EPS_ZERO && y < - EPS_ZERO && fabs( z) < EPS_ZERO) ; }
//! Verifica se il vettore è parallelo ed equiverso con Z+
bool IsZplus( void) const
{ return ( fabs( x) < EPS_ZERO && fabs( y) < EPS_ZERO && z > EPS_ZERO) ; }
//! Verifica se il vettore è parallelo ed equiverso con Z-
bool IsZminus( void) const
{ return ( fabs( x) < EPS_ZERO && fabs( y) < EPS_ZERO && z < - EPS_ZERO) ; }
//! Somma sul posto con altro vettore
const Vector3d& operator +=( const Vector3d& vtV)
{ this->x += vtV.x ; this->y += vtV.y ; this->z += vtV.z ; return *this ; }
//! Sottrazione sul posto con altro vettore
const Vector3d& operator -=( const Vector3d& vtV)
{ this->x -= vtV.x ; this->y -= vtV.y ; this->z -= vtV.z ; return *this ; }
//! Moltiplicazione sul posto con un numero
const Vector3d& operator *=( double dMul)
{ this->x *= dMul ; this->y *= dMul ; this->z *= dMul ; return *this ; }
//! Divisione sul posto con un numero
const Vector3d& operator /=( double dDiv)
{ double dMul = 1 / dDiv ; this->x *= dMul ; this->y *= dMul ; this->z *= dMul ; return *this ; }
//! Ritorna la rappresentazione in coordinate sferiche
void ToSpherical( double* pdLen, double* pdAngVertDeg, double* pdAngOrizzDeg) const ;
//! Normalizzazione di un vettore (trasformazione in versore)
bool Normalize( double dEps = EPS_SMALL) ;
//! Rotazione
bool Rotate( const Vector3d& vtAx, double dAngDeg) ;
//! Rotazione da coseno e seno dell'angolo di rotazione
bool Rotate( const Vector3d& vtAx, double dCosAng, double dSinAng) ;
//! Scalatura non uniforme
bool Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) ;
//! Specchiatura
bool Mirror( const Vector3d& vtNorm) ;
//! Scorrimento
bool Shear( const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff) ;
//! Cambio di riferimento : dal riferimento al globale
bool ToGlob( const Frame3d& frRef) ;
//! Cambio di riferimento : dal globale al riferimento
bool ToLoc( const Frame3d& frRef) ;
//! Cambio di riferimento : dal primo riferimento al secondo
bool LocToLoc( const Frame3d& frOri, const Frame3d& frDest) ;
//! Calcolo dell'angolo tra il vettore e un altro
bool GetAngle( const Vector3d& vtEnd, double& dAngDeg) const ;
//! Calcolo dell'angolo tra il vettore e un altro nel piano XY
bool GetAngleXY( const Vector3d& vtEnd, double& dAngDeg) const ;
//! \brief Calcolo angolo di rotazione per portare la componente del vettore perpendicolare
//! all'asse di rotazione sulla stessa direzione della componente perpendicolare di vtEnd
bool GetRotation( const Vector3d& vtEnd, const Vector3d& vtAx, double& dAngDeg, bool& bDet) const ;
public :
@@ -102,12 +141,15 @@ class EGK_EXPORT Vector3d
//----------------------------------------------------------------------------
// Vettori notevoli
//----------------------------------------------------------------------------
//! Versore asse X
const Vector3d X_AX( 1, 0, 0) ;
//! Versore asse Y
const Vector3d Y_AX( 0, 1, 0) ;
//! Versore asse Z
const Vector3d Z_AX( 0, 0, 1) ;
//----------------------------------------------------------------------------
// Opposto di un vettore
//! Opposto di un vettore
//----------------------------------------------------------------------------
inline Vector3d
operator-( const Vector3d& vtV)
@@ -116,7 +158,7 @@ operator-( const Vector3d& vtV)
}
//----------------------------------------------------------------------------
// Somma di due vettori
//! Somma di due vettori
//----------------------------------------------------------------------------
inline Vector3d
operator+( const Vector3d& vtV1, const Vector3d& vtV2)
@@ -125,7 +167,7 @@ operator+( const Vector3d& vtV1, const Vector3d& vtV2)
}
//----------------------------------------------------------------------------
// Sottrazione di due vettori
//! Sottrazione di due vettori
//----------------------------------------------------------------------------
inline Vector3d
operator-( const Vector3d& vtV1, const Vector3d& vtV2)
@@ -134,7 +176,7 @@ operator-( const Vector3d& vtV1, const Vector3d& vtV2)
}
//----------------------------------------------------------------------------
// Prodotto con uno scalare
//! Prodotto con uno scalare
//----------------------------------------------------------------------------
inline Vector3d
operator*( const Vector3d& vtV, double dMul)
@@ -142,6 +184,8 @@ operator*( const Vector3d& vtV, double dMul)
return ( Vector3d( vtV.x * dMul, vtV.y * dMul, vtV.z * dMul)) ;
}
//----------------------------------------------------------------------------
//! Prodotto di uno scalare con un vettore
//----------------------------------------------------------------------------
inline Vector3d
operator*( double dMul, const Vector3d& vtV)
@@ -150,7 +194,7 @@ operator*( double dMul, const Vector3d& vtV)
}
//----------------------------------------------------------------------------
// Divisione con uno scalare
//! Divisione con uno scalare
//----------------------------------------------------------------------------
inline Vector3d
operator/( const Vector3d& vtV, double dDiv)
@@ -162,7 +206,7 @@ operator/( const Vector3d& vtV, double dDiv)
}
//----------------------------------------------------------------------------
// Prodotto scalare
//! Prodotto scalare
//----------------------------------------------------------------------------
inline double
operator*( const Vector3d& vtV1, const Vector3d& vtV2)
@@ -171,7 +215,7 @@ operator*( const Vector3d& vtV1, const Vector3d& vtV2)
}
//----------------------------------------------------------------------------
// Prodotto scalare nel piano XY
//! Prodotto scalare nel piano XY
//----------------------------------------------------------------------------
inline double
ScalarXY( const Vector3d& vtV1, const Vector3d& vtV2)
@@ -180,7 +224,7 @@ ScalarXY( const Vector3d& vtV1, const Vector3d& vtV2)
}
//----------------------------------------------------------------------------
// Prodotto vettoriale
//! Prodotto vettoriale
//----------------------------------------------------------------------------
inline Vector3d
operator^( const Vector3d& vtV1, const Vector3d& vtV2)
@@ -191,7 +235,7 @@ operator^( const Vector3d& vtV1, const Vector3d& vtV2)
}
//----------------------------------------------------------------------------
// Prodotto vettoriale nel piano XY
//! Prodotto vettoriale nel piano XY
//----------------------------------------------------------------------------
inline double
CrossXY( const Vector3d& vtV1, const Vector3d& vtV2)
@@ -200,7 +244,7 @@ CrossXY( const Vector3d& vtV1, const Vector3d& vtV2)
}
//----------------------------------------------------------------------------
// Somma mediata di due vettori (baricentrica)
//! Somma mediata di due vettori (baricentrica)
//----------------------------------------------------------------------------
inline Vector3d
Media( const Vector3d& vtV1, const Vector3d& vtV2, double dCoeff)
@@ -211,16 +255,16 @@ Media( const Vector3d& vtV1, const Vector3d& vtV2, double dCoeff)
}
//----------------------------------------------------------------------------
// Verifica che due vettori sono quasi coincidenti (Small error -> Near)
//! Verifica se due vettori sono quasi coincidenti (Small error -> Approx)
//----------------------------------------------------------------------------
inline bool
AreSameVectorNear( const Vector3d& vtV1, const Vector3d& vtV2)
AreSameVectorApprox( const Vector3d& vtV1, const Vector3d& vtV2)
{
return ( ( vtV1 - vtV2).IsSmall()) ;
}
//----------------------------------------------------------------------------
// Verifica che due vettori sono esattamente coincidenti (Zero error -> Exact)
//! Verifica se due vettori sono esattamente coincidenti (Zero error -> Exact)
//----------------------------------------------------------------------------
inline bool
AreSameVectorExact( const Vector3d& vtV1, const Vector3d& vtV2)
@@ -229,16 +273,16 @@ AreSameVectorExact( const Vector3d& vtV1, const Vector3d& vtV2)
}
//----------------------------------------------------------------------------
// Verifica che due vettori sono quasi opposti (Small error -> Near)
//! Verifica se due vettori sono quasi opposti (Small error -> Approx)
//----------------------------------------------------------------------------
inline bool
AreOppositeVectorNear( const Vector3d& vtV1, const Vector3d& vtV2)
AreOppositeVectorApprox( const Vector3d& vtV1, const Vector3d& vtV2)
{
return ( ( vtV1 + vtV2).IsSmall()) ;
}
//----------------------------------------------------------------------------
// Verifica che due vettori sono esattamente coincidenti (Zero error -> Exact)
//! Verifica se due vettori sono esattamente coincidenti (Zero error -> Exact)
//----------------------------------------------------------------------------
inline bool
AreOppositeVectorExact( const Vector3d& vtV1, const Vector3d& vtV2)
@@ -247,16 +291,16 @@ AreOppositeVectorExact( const Vector3d& vtV1, const Vector3d& vtV2)
}
//----------------------------------------------------------------------------
// Verifica che due versori sono ortogonali (Small error -> Near)
//! Verifica se due versori sono ortogonali (Small error -> Approx)
//----------------------------------------------------------------------------
inline bool
AreOrthoNear( const Vector3d& vtV1, const Vector3d& vtV2)
AreOrthoApprox( const Vector3d& vtV1, const Vector3d& vtV2)
{
return ( fabs( vtV1 * vtV2) < COS_ORTO_ANG_SMALL) ;
}
//----------------------------------------------------------------------------
// Verifica che due versori sono ortogonali (Zero error -> Exact)
//! Verifica se due versori sono ortogonali (Zero error -> Exact)
//----------------------------------------------------------------------------
inline bool
AreOrthoExact( const Vector3d& vtV1, const Vector3d& vtV2)
EgkCurve.h
+3
View File
@@ -40,6 +40,9 @@ class __declspec( novtable) ICurve : public IGeoObj
virtual bool GetEndDir( Vector3d& vtDir) const = 0 ;
virtual bool GetMidDir( Vector3d& vtDir) const = 0 ;
virtual bool GetDomain( double& dStart, double& dEnd) const = 0 ;
virtual bool IsValidParam( double dPar, Side nSide) const = 0 ;
virtual bool IsStartParam( double dPar) const = 0 ;
virtual bool IsEndParam( double dPar) const = 0 ;
virtual bool GetLength( double& dLen) const = 0 ;
virtual bool GetLengthAtParam( double dU, double& dLen) const = 0 ;
virtual bool GetParamAtLength( double dLen, double& dU) const = 0 ;
EgnCmdParser.h
+1
View File
@@ -45,6 +45,7 @@ class __declspec( novtable) ICmdParser
virtual int DirReplace( std::string& sPath) = 0 ;
virtual int DirInvReplace( std::string& sPath) = 0 ;
virtual int GetIdParam( const std::string& sParam, bool bNewAllowed = false) = 0 ;
virtual bool GetTextParam( const std::string& sParam, std::string& sText) = 0 ;
virtual bool Run( const std::string& sCmdFile, bool bIsolated = true) = 0 ;
virtual bool ExecLine( const std::string& sCmdLine, bool bIsolated = false) = 0 ;
} ;