Include/EGkIntersCurveCurve.h

//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : EGkIntersCurveCurve.h     Data : 20.06.14        Versione : 1.5f6
// Contenuto : Dichiarazione della classe intersezione curva/curva.
//
//
//
// Modifiche : 20.06.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#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) {}
} ;
//! 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
//! 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 ;
  // costruttore
   CrvClass( void)
      : dParS( 0), dParE( 0), nClass( 0) {}
} ;
//! 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

//-----------------------------------------------------------------------------
//! 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  GetNumInters( void) ;
      //! Restituisce informazioni sull'intersezione di indice nInd ( 0 based)
      EGK_EXPORT bool GetIntCrvCrvInfo( 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, CRVCVECTOR& ccClass) ;

   private :
      IntersCurveCurve( void) ;
      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 SwapInfoAB( ICCIVECTOR& Info, int IndCrvOrd) ;
      bool CalcCurveClassification( const ICurve* pCurve, const ICCIVECTOR& Info, 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_nNumInters ;
      ICCIVECTOR    m_Info ;
      const ICurve* m_pCurve[2] ;
} ;