//----------------------------------------------------------------------------
//  EgalTech 2017-20187
//----------------------------------------------------------------------------
// File : Tool.h           Data : 03.12.18          Versione : 1.9l1
// Contenuto : Dichiarazione dei prototipi delle funzioni di intersezione
//             superficie e componente lineare
//
//
// Modifiche : 22.01.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once 

#include "/EgtDev/Include/EGkPoint3d.h"
#include "/EgtDev//Include/EgtNumCollection.h"

// In tutte le funzioni dichiarate i punti e i vettori che definiscono gli oggetti geometrici
// devono essere espressi nel medesimo sistema di riferimento. I vettori devono essere normalizzati.
// Il valore di ritorno č una costante intera che individua la tipologia di intersezione.
// Se si verificano irregolaritā, essa vale ERROR_INT.
// Per riferimento vengono restituiti i parametri lungo la retta a cui avvengono le
// intersezioni. Se non vi sono intersezioni i valori di dU1 e dU2 non sono definiti,
// se vi č un'intersezione vale solo dU1, con due soluzioni valgono entrambi.
// Nelle routine per la semi-sfera come argomento appare un versore, che ne individua l'orientazione
// nello spazio. Si immagini uno spazio con origine nel centro della sfera e asse Z diretto come tale
// versore. La sfera č divisa in due parti: una nel semi spazio Z+ e una in quello Z-.
// La semi-sfera di interesse č quella nel semi-spazio Z-.
// Se il versore non ha, come deve, norma 1 viene restituito lo stato di errore.
// Anche per la routine d'intersezione di un componente lineare con la parte inferiore
// ed esterna (rispetto al centro) della superficie torica vale la stessa considerazione.

// Costanti tipologia di componente lineare
enum LinType { Line = 0, Ray = 1, Segment = 2} ;

// Costanti tipologia di intersezioni fra un componente lineare e un disco
enum LinCompDiscIntersType { D_ERROR_INT = -1, D_NO_INTERS = 0, D_BOUNDARY_INT_LINE_NOT_IN_PLANE = 1,
                             D_INNER_INT_LINE_NOT_IN_PLANE = 2, D_ONE_INT_LINE_ON_PLANE = 3,
                             D_INFINITE_INT_LINE_ON_PLANE = 4} ;
//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una retta e un disco.
// Nel caso in cui parte della retta giaccia all'interno del disco dU1 č il parametro a
// cui la retta entra e dU2 quello a cui esce.
int LineDisc( const Point3d& ptPLine, const Vector3d& vtVLine,
              const Point3d& ptPDisc, const Vector3d& vtVDisc, double dRad, 
              double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una semi-retta e un disco.
// Nel caso in cui parte della semi-retta giaccia all'interno del disco dU1 č il parametro a
// cui la semi-retta entra e dU2 quello a cui esce.
int RayDisc( const Point3d& ptPLine, const Vector3d& vtVLine, 
             const Point3d& ptPDis, const Vector3d& vtVDisc, double dRad, 
             double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un segmento e un disco.
// Nel caso in cui parte del segmento giaccia all'interno del disco dU1 č il parametro a
// cui il segmento entra e dU2 quello a cui esce.
int SegmentDisc( const Point3d& ptPLine, const Vector3d& vtVLine, double dLen,
                 const Point3d& ptPDisc, const Vector3d& vtVDisc, double dRad,
                 double& dU1, double& dU2) ;

// Costanti tipologia di intersezione fra un componente lineare e una sfera
enum LinCompSphereIntersType { S_ERROR_INT = -1, S_NO_INTERS = 0, S_ONE_INT_SEC = 1, S_TWO_INT = 2, S_ONE_INT_TAN = 3} ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una retta e una sfera.
int LineSphere( const Point3d& ptPLine, const Vector3d& vtVLine,
                const Point3d& ptSphC, double dRad, 
                double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una semi-retta e una sfera.
int RaySphere( const Point3d& ptPLine, const Vector3d& vtVLine,
               const Point3d& ptSphC, double dRad, 
               double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un segmento e una sfera.
int SegmentSphere( const Point3d& ptPLine, const Vector3d& vtVLine, double dLen,
                   const Point3d& ptSphC, double dRad,
                   double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una retta e una superficie semi-sferica
int LineSemiSphere( const Point3d& ptPLine, const Vector3d& vtVLine, 
                    const Point3d& ptSphC, const Vector3d& vtSSphOrient,
                    double dRad, double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una semi-retta e una superficie semi-sferica
int RaySemiSphere( const Point3d& ptPLine, const Vector3d& vtVLine,
                   const Point3d& ptSphC, const Vector3d& vtSSphOrient, double dRad,
                   double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un segmento e una sfera.
int SegmentSemiSphere( const Point3d& ptPLine, const Vector3d& vtVLine, double dLen, 
                       const Point3d& ptSphC, const Vector3d& vtSSphOrient, double dRad, 
                       double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un segmento e una sfera.
int LinCompSemiSphere( const Point3d& ptPLine, const Vector3d& vtVLine, double dLen, int nLinType, 
                       const Point3d& ptSphC, const Vector3d& vtSSphOrient, double dRad,
                       double& dU1, double& dU2) ;

// Costanti tipologia di intersezione fra un componente lineare e
// un solido cilindrico o conico
enum LinCompCCIntersType { CC_ERROR_INT = -1, CC_NO_INTERS = 0, CC_ONE_INT_SEC = 1, 
                           CC_TWO_INT = 2, CC_ONE_INT_TAN = 3, CC_INF_INT = 4, CC_ON_VERT = 5} ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un cilindro infinito e una retta.
// Nel caso in cui la retta giaccia sul cilindro, nIntType vale INF_INT e dU1 e dU2 valgono
// rispettivamente - INFINITO e INFINITO.
int IntersLineInfiniteCylinder( const Point3d& ptPLine, const Vector3d& vtVLine,
                                const Point3d& ptPCyl, const Vector3d& vtVCyl, double dCylRad,
                                double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un cilindro infinito e una semi-retta.
// Nel caso in cui la semi-retta giaccia sul cilindro, nIntType vale INF_INT e dU1 e dU2
// valgono rispettivamente 0 e INFINITO.
int IntersRayInfiniteCylinder( const Point3d& ptPLine, const Vector3d& vtVLine,
                               const Point3d& ptPCyl, const Vector3d& vtVCyl, double dCylRad,
                               double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un cilindro infinito e un segmento.
// Nel caso in cui il segmento giaccia sul cilindro, nIntType vale INF_INT e dU1 e dU2
// valgono rispettivamente 0 e dLen (lunghezza del segmento).
int IntersSegmentInfiniteCylinder( const Point3d& ptPLine, const Vector3d& vtVLine, double dLen,
                                   const Point3d& ptPCyl, const Vector3d& vtVCyl, double dCylRad,
                                   double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una retta e un cilindro semi-finito.
// Nel caso in cui parte della retta giaccia sul cilindro, nIntType vale INF_INT e un
// parametro ha valore finito mentre l'altro ha valore infinito.
int IntersLineSemiFiniteCylinder( const Point3d& ptPLine, const Vector3d& vtVLine,
                                  const Point3d& ptPCyl, const Vector3d& vtVCyl, double dCylRad,
                                  double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una semi-retta e un cilindro semi-finito.
// Nel caso in cui parte della semi-retta giaccia sul cilindro, nIntType vale INF_INT
// e almeno un parametro ha valore finito.
int RaySemiFiniteCylinder( const Point3d& ptPLine, const Vector3d& vtVLine, 
                           const Point3d& ptPCyl, const Vector3d& vtVCyl, double dCylRad,
                           double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un cilindro semi-finito e un segmento.
// Nel caso in cui il segmento giaccia sul cilindro, nIntType vale INF_INT e dU1 e dU2
// hanno entrambi valori finiti.
int SegmentSemiFiniteCylinder( const Point3d& ptPLine, const Vector3d& vtVLine, double dLen, 
                               const Point3d& ptPCyl, const Vector3d& vtVCyl, double dCylRad,
                               double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una retta e un cilindro.
// Nel caso in cui parte della retta giaccia sul cilindro, nIntType vale INF_INT e entrambi i
// i parametri dU1 e dU2 sono finiti.
int IntersLineCylinder( const Point3d& ptPLine, const Vector3d& vtVLine,
                        const Point3d& ptPCyl, const Vector3d& vtVCyl, double dCylRad, double dCylHeigth,
                        double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una semi-retta e un cilindro.
// Nel caso in cui parte della semi-retta giaccia sul cilindro, nIntType vale INF_INT e entrambi
// i parametri dU1 e dU2 hanno senso.
int RayCylinder( const Point3d& ptPLine, const Vector3d& vtVLine, 
                 const Point3d& ptPCyl, const Vector3d& vtVCyl, double dCylRad, double dCylHeigth,
                 double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un segmento e un cilindro.
// Nel caso in cui parte del segmento giaccia sul cilindro, nIntType vale INF_INT e entrambi i
// i parametri dU1 e dU2 hanno senso.
int IntersSegmentCylinder( const Point3d& ptPLine, const Vector3d& vtVLine, double dLen,
                           const Point3d& ptPCyl, const Vector3d& vtVCyl, double dCylRad, double dCylHeigth, 
                           double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una retta e un cono infinito.
// Nel caso in cui parte della retta giaccia sul cono, nIntType vale INF_INT e entrambi i
// i parametri dU1 e dU2 hanno senso; uno č finito e l'altro no.
int LineInfiniteCone( const Point3d& ptPLine, const Vector3d& vtDLine, 
                      const Point3d& ptVCone, const Vector3d& vtDCone, double dConeRad, double dConeHeigth, 
                      double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una semi-retta e un cono infinito.
// Nel caso in cui parte della semi-retta giaccia sul cono, nIntType vale INF_INT e entrambi i
// i parametri dU1 e dU2 hanno senso.
int RayInfiniteCone( const Point3d& ptPLine, const Vector3d& vtDLine,
                     const Point3d& ptVCone, const Vector3d& vtDCone, double dConeRad, double dConeHeigth, 
                     double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un segmento e un cono infinito.
// Nel caso in cui parte del segmento giaccia sul cono, nIntType vale INF_INT e entrambi i
// i parametri dU1 e dU2 hanno senso.
int SegmentInfiniteCone( const Point3d& ptPLine, const Vector3d& vtDLine, double dSgLen, 
                         const Point3d& ptVCone, const Vector3d& vtDCone, double dConeRad, double dConeHeigth, 
                         double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una retta e un cono.
// Nel caso in cui parte del segmento giaccia sul cono, nIntType vale INF_INT e entrambi i
// i parametri dU1 e dU2 hanno senso.
int LineCone( const Point3d& ptPLine, const Vector3d& vtDLine,
              const Point3d& ptVCone, const Vector3d& vtDCone, double dConeRad, double dConeHeigth, 
              double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una semi-retta e un cono.
// Nel caso in cui parte della semi-retta giaccia sul cono, nIntType vale INF_INT e entrambi i
// i parametri dU1 e dU2 hanno senso.
int RayCone( const Point3d& ptPLine, const Vector3d& vtDLine, 
             const Point3d& ptVCone, const Vector3d& vtDCone, double dConeRad, double dConeHeigth, 
             double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un segmento e un cono.
// Nel caso in cui parte del segmento giaccia sul cono, nIntType vale INF_INT e entrambi i
// i parametri dU1 e dU2 hanno senso.
int SegmentCone( const Point3d& ptPLine, const Vector3d& vtDLine, double dSgLen,
                 const Point3d& ptVCone, const Vector3d& vtDCone, double dConeRad, double dConeHeigth, 
                 double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca di una retta e un tronco di cono
// Nel caso in cui parte della retta giaccia sul tronco di cono, nIntType vale
// INF_INT e entrambi i parametri dU1 e dU2 hanno senso.
int LineConeFrustum( const Point3d& ptPLine, const Vector3d& vtDLine,
                     const Point3d& ptMinBase, const Vector3d& vtDCone, double dMinRad, double dMaxRad, double dHeigth,
                     double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca di una semi-retta e un tronco di cono.
// Nel caso in cui parte della semi-retta giaccia sul tronco di cono, nIntType vale
// INF_INT e entrambi i parametri dU1 e dU2 hanno senso.
int RayConeFrustum( const Point3d& ptPLine, const Vector3d& vtDLine,
                    const Point3d& ptMinBase, const Vector3d& vtDCone ,double dMinRad, double dMaxRad, double dHeigth,
                    double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca di un segmento e un tronco di cono.
// Nel caso in cui parte del segmento giaccia sul tronco di cono, nIntType vale
// INF_INT e entrambi i parametri dU1 e dU2 hanno senso.
int SegmentConeFrustum( const Point3d& ptPLine, const Vector3d& vtDLine, double dSgLen,
                        const Point3d& ptMinBase, const Vector3d& vtDCone, double dMinRad, double dMaxRad, double dHeigth, 
                        double& dU1, double& dU2) ;

// Cosntani tipologia di intersezione fra un componente lineare e un toro
enum LinCompTorusIntersType { T_ERROR = -1, T_NO_INT = 0, T_ONE_TAN = 1, T_ONE_SEC = 2, T_TWO_TAN = 3, T_TWO_SEC = 4,
                              T_TWO_TAN_SEC = 5, T_THREE_SEC = 6, T_THREE_ONE_TAN_TWO_SEC = 7, T_FOUR_SEC = 8} ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra una retta e un toro.
// Punti e vettori devono essere espressi nel medesimo sistema di riferimento.
int LineTorus( const Point3d& ptLine, const Vector3d& vtLine,
               const Point3d& ptOTorus, const Vector3d& vtAxTorus, double dMinRad, double dMaxRad,
               BOOLVECTOR& vbType, DBLVECTOR& vdPar) ; //double dU1, double dU2, double dU3, double dU4) ;

//----------------------------------------------------------------------------
int RayTorus( const Point3d& ptLine, const Vector3d& vtLine,
              const Point3d& ptOTorus, const Vector3d& vtAxTorus, double dMinRad, double dMaxRad,
              BOOLVECTOR& vbType, DBLVECTOR& vdPar) ;

//----------------------------------------------------------------------------
int SegmentTorus( const Point3d& ptLine, const Vector3d& vtLine, double dSgLen,
                  const Point3d& ptOTorus, const Vector3d& vtAxTorus, double dMinRad, double dMaxRad,
                  BOOLVECTOR& vbType, DBLVECTOR& vdPar) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un componente lineare e la parte inferiore 
// ed esterna rispetto al centro di una superficie torica.
int LinCompTorusExtInt( const Point3d& ptLine, const Vector3d& vtLine, double dSgLen, int nLinType,
                        const Point3d& ptOTorus, const Vector3d& vtAxTorus, double dMinRad, double dMaxRad,
                        BOOLVECTOR& vbType, DBLVECTOR& vdPar) ;

//----------------------------------------------------------------------------
// Valuta la posizione reciproca fra un componente lineare e la parte superiore 
// ed interna di una superficie torica.
int LinCompTorusInnUpInt( const Point3d& ptLine, const Vector3d& vtLine, double dSgLen, int nLinType,
                          const Point3d& ptOTorus, const Vector3d& vtAxTorus, double dMinRad, double dMaxRad,
                          BOOLVECTOR& vbType, DBLVECTOR& vdPar) ;