Dario Sassi
197 lines
9.9 KiB
C++
197 lines
9.9 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2014-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : EGkIntersCurves.h Data : 06.07.15 Versione : 1.6g2
|
|
// Contenuto : Dichiarazione della classe intersezione curva/curva.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 20.06.14 DS Creazione modulo.
|
|
// 06.07.15 DS Aggiunta dichiarazione classe SelfIntersCurve e
|
|
// cambiato nome da EGkIntersCurveCurve a EGkIntersCurves.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include "/EgtDev/Include/EGkPoint3d.h"
|
|
#include "/EgtDev/Include/EGkCurve.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 relativi ad una curva
|
|
struct IntCrvInfo {
|
|
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(), nPrevTy( 0), nNextTy(0) {}
|
|
} ;
|
|
//! dati di intersezione delle due curve A e B
|
|
struct IntCrvCrvInfo {
|
|
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)
|
|
: bOverlap( false), bCBOverEq( false) {}
|
|
} ;
|
|
//! vettore di IntCrvCrvInfo
|
|
typedef std::vector<IntCrvCrvInfo> ICCIVECTOR ;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 ; //!< Approccio/allontanamento non definito
|
|
const int ICCT_IN = 1 ; //!< Approccio/allontanamento interno
|
|
const int ICCT_OUT = 2 ; //!< Approccio/allontanamento esterno
|
|
const int ICCT_ON = 3 ; //!< Approccio/allontanamento sovrapposto
|
|
const int ICCT_SPK = 4 ; //!< Punta di spike (solo in autointersezioni)
|
|
//! 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 ;
|
|
}}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//! Classificazione di parti di curva rispetto ad altra curva chiusa
|
|
struct CrvClass {
|
|
double dParS ;
|
|
double dParE ;
|
|
int nClass ;
|
|
// costruttori
|
|
CrvClass( void)
|
|
: dParS( 0), dParE( 0), nClass( 0) {}
|
|
CrvClass( double dPS, double dPE, int nC)
|
|
: dParS( dPS), dParE( dPE), nClass( nC) {}
|
|
} ;
|
|
//! Vettore di CrvClass
|
|
typedef std::vector<CrvClass> CRVCVECTOR ;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Costanti per classe parti di curva rispetto a curva chiusa
|
|
const int CRVC_NULL = 0 ; //!< Parte di curva non classificabile
|
|
const int CRVC_IN = 1 ; //!< Parte di curva interna
|
|
const int CRVC_OUT = 2 ; //!< Parte di curva esterna
|
|
const int CRVC_ON_P = 3 ; //!< Parte di curva sovrapposta equiversa
|
|
const int CRVC_ON_M = 4 ; //!< Parte di curva sovrapposta controversa
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Costanti per classificazione di curve chiuse come regioni
|
|
const int CCREGC_NULL = 0 ; //!< Non classificabili
|
|
const int CCREGC_IN1 = 1 ; //!< La prima regione è inclusa nella seconda
|
|
const int CCREGC_IN2 = 2 ; //!< La seconda regione è inclusa nella prima
|
|
const int CCREGC_SAME = 3 ; //!< Le due regioni coincidono
|
|
const int CCREGC_OUT = 4 ; //!< Le due regioni sono esterne
|
|
const int CCREGC_INTERS = 5 ; //!< Le due regioni si intersecano
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//! Classe per calcolo intersezione tra due curve nel piano XY locale
|
|
class IntersCurveCurve
|
|
{
|
|
public :
|
|
//! Le intersezioni sono calcolate nel piano XY locale.<br>
|
|
//! Il flag bAreSegments vale solo per intersezione tra due linee e riguarda entrambe.
|
|
EGK_EXPORT IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB, bool bAreSegments = true) ;
|
|
|
|
public :
|
|
//! Indica la presenza di intersezioni con sovrapposizioni
|
|
EGK_EXPORT bool GetOverlaps( void) ;
|
|
//! Restituisce il numero di intersezioni (intersezioni doppie coincidenti e sovrapposte contano uno)
|
|
EGK_EXPORT int GetIntersCount( void) ;
|
|
//! Restituisce il numero di intersezioni in 3D ( filtrando le intersezioni)
|
|
EGK_EXPORT int GetInters3DCount( void) ;
|
|
//! Restituisce il numero di intersezioni in cui la curva si attraversa
|
|
EGK_EXPORT int GetCrossIntersCount( void) ;
|
|
//! Restituisce il numero di intersezioni in cui la curva si attraversa o si sovrappone
|
|
EGK_EXPORT int GetCrossOrOverlapIntersCount( void) ;
|
|
//! Restituisce informazioni sull'intersezione di indice nInd ( 0 based)
|
|
EGK_EXPORT bool GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
|
|
//! Restituisce informazioni sulla i-esima intersezione 3D ( 0 based)
|
|
EGK_EXPORT bool GetInt3DCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
|
|
//! Restituisce il punto di intersezione più vicino al punto passato
|
|
EGK_EXPORT bool GetIntersPointNearTo( int nCrv, const Point3d& ptNear, Point3d& ptI) ;
|
|
//! Restituisce la classificazione di una curva rispetto all'altra ( nCrv=0 -> CurvaA, nCrv=1 -> CurvaB)
|
|
EGK_EXPORT bool GetCurveClassification( int nCrv, double dLenMin, CRVCVECTOR& ccClass) ;
|
|
//! Restituisce la classificazione di curve chiuse secondo le regole delle regioni
|
|
EGK_EXPORT int GetRegionCurveClassification( void) ;
|
|
|
|
private :
|
|
IntersCurveCurve( void) ;
|
|
bool IsArcToApprox( const ICurve& Curve) ;
|
|
void LineLineCalculate( const ICurve& CurveA, const ICurve& CurveB, bool bAreSegments) ;
|
|
void LineArcCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
|
|
void LineCrvCompoCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
|
|
void ArcLineCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
|
|
void ArcArcCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
|
|
void ArcCrvCompoCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
|
|
void CrvCompoLineCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
|
|
void CrvCompoArcCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
|
|
void CrvCompoCrvCompoCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
|
|
bool AdjustIntersParams( bool bAdjCrvA, bool bAdjCrvB) ;
|
|
bool SwapInfoAB( ICCIVECTOR& Info, int IndCrvOrd) ;
|
|
bool CalcCurveClassification( const ICurve* pCurve, const ICCIVECTOR& Info, double dLenMin, CRVCVECTOR& ccClass) ;
|
|
bool CalcCurveInOrOut( const ICurve* pCurveA, const ICurve* pCurveB, CRVCVECTOR& ccClass) ;
|
|
bool GetCurveOutClass( const ICurve* pCurve, int& nClass) ;
|
|
|
|
private :
|
|
bool m_bOverlaps ;
|
|
int m_nIntersCount ;
|
|
ICCIVECTOR m_Info ;
|
|
const ICurve* m_pCurve[2] ; // puntatori alle curve
|
|
} ;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//! Classe per calcolo auto-intersezioni di una curva nel piano XY locale
|
|
class SelfIntersCurve
|
|
{
|
|
public :
|
|
//! Le intersezioni sono calcolate nel piano XY locale.<br>
|
|
EGK_EXPORT SelfIntersCurve( const ICurve& Curve) ;
|
|
|
|
public :
|
|
//! Indica la presenza di intersezioni con sovrapposizioni
|
|
EGK_EXPORT bool GetOverlaps( void) ;
|
|
//! Restituisce il numero di auto-intersezioni (intersezioni doppie coincidenti e sovrapposte contano uno)
|
|
EGK_EXPORT int GetIntersCount( void) ;
|
|
//! Restituisce il numero di auto-intersezioni in cui la curva si attraversa
|
|
EGK_EXPORT int GetCrossIntersCount( void) ;
|
|
//! Restituisce il numero di auto-intersezioni in cui la curva si attraversa o si sovrappone
|
|
EGK_EXPORT int GetCrossOrOverlapIntersCount( void) ;
|
|
// ! Restituisce il numero di auto-intersezioni in cui la curva si tocca
|
|
EGK_EXPORT int GetTouchIntersCount( void) ;
|
|
//! Restituisce informazioni sull'auto-intersezione di indice nInd ( 0 based)
|
|
EGK_EXPORT bool GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
|
|
//! Restituisce il punto di auto-intersezione più vicino al punto passato
|
|
EGK_EXPORT bool GetIntersPointNearTo( const Point3d& ptNear, Point3d& ptI) ;
|
|
|
|
private :
|
|
SelfIntersCurve( void) ;
|
|
bool IsArcToApprox( const ICurve& Curve) ;
|
|
bool GetCurveParamFromApproxParam( double& dU, const ICurve* pCalcCrv, const DBLVECTOR& vCalcPar) ;
|
|
bool AdjustIntersParams( bool bAdjCrv, const ICurve* pCalcCrv, const DBLVECTOR& vCalcPar) ;
|
|
bool SwapInfoAB( ICCIVECTOR& Info, int IndCrvOrd) ;
|
|
|
|
private :
|
|
bool m_bOverlaps ;
|
|
int m_nIntersCount ;
|
|
ICCIVECTOR m_Info ;
|
|
const ICurve* m_pCurve ; // puntatore alla curva originale
|
|
} ;
|