diff --git a/EGkBBox3d.h b/EGkBBox3d.h index 6eda641..9766b65 100644 --- a/EGkBBox3d.h +++ b/EGkBBox3d.h @@ -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 ; diff --git a/EGkCurvePointDiffGeom.h b/EGkCurvePointDiffGeom.h index 28f9c81..d1e7afd 100644 --- a/EGkCurvePointDiffGeom.h +++ b/EGkCurvePointDiffGeom.h @@ -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 ; diff --git a/EGkFrame3d.h b/EGkFrame3d.h index 9eaf565..b46de90 100644 --- a/EGkFrame3d.h +++ b/EGkFrame3d.h @@ -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 ; diff --git a/EGkGeoConst.h b/EGkGeoConst.h index e604579..f8176ec 100644 --- a/EGkGeoConst.h +++ b/EGkGeoConst.h @@ -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 ; diff --git a/EGkIntersCurveCurve.h b/EGkIntersCurveCurve.h index 182b19b..067c9f1 100644 --- a/EGkIntersCurveCurve.h +++ b/EGkIntersCurveCurve.h @@ -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 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.
//! 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 ; diff --git a/EGkPoint3d.h b/EGkPoint3d.h index 64adb82..76082c3 100644 --- a/EGkPoint3d.h +++ b/EGkPoint3d.h @@ -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)) ; } diff --git a/EGkTriangle3d.h b/EGkTriangle3d.h index f631c25..e524bb2 100644 --- a/EGkTriangle3d.h +++ b/EGkTriangle3d.h @@ -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 ; } diff --git a/EGkVector3d.h b/EGkVector3d.h index 496ac97..a366345 100644 --- a/EGkVector3d.h +++ b/EGkVector3d.h @@ -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) diff --git a/EgkCurve.h b/EgkCurve.h index f1ee588..24a74be 100644 --- a/EgkCurve.h +++ b/EgkCurve.h @@ -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 ; diff --git a/EgnCmdParser.h b/EgnCmdParser.h index de4cf92..9a6f983 100644 --- a/EgnCmdParser.h +++ b/EgnCmdParser.h @@ -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 ; } ;