//----------------------------------------------------------------------------
//  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) {}
} ;
//! 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 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 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
} ;