EgtGeomKernel/CDeUtility.h

//----------------------------------------------------------------------------
//  EgalTech 2020-2020
//----------------------------------------------------------------------------
// File : CoplanarDiscTriaInterferance.h      Data : 27.10.20     Versione : 
// Contenuto : Dichiarazione funzione verifica interferenza tra
//             Disco e Triangle3d complanari
//
// Modifiche : 27.10.20 LM Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

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

//----------------------------------------------------------------------------
// Dati un punto e una retta, restituisce il quadrato della loro distanza.
// La retta è descritta da un suo punto e dal suo versore tangente.
double
GetPointLineSqDist( const Point3d& ptP, const Point3d& ptLine, const Vector3d& vtLine) ;

//----------------------------------------------------------------------------
// Dati un punto e un piano, ne restituisce la distanza con segno.
// Il piano è descritto da un suo punto e dal suo versore normale.
double
PointPlaneSignedDist( const Point3d& ptP, const Point3d& ptPlane, const Vector3d& vtNorm) ;

//----------------------------------------------------------------------------
// Dati un sistema di tre punti e un piano, ne calcola le tre distanze con segno e ne restituisce la
// maggiore. I tre punti sono passati mediante un triangolo, il piano è descritto da un suo punto e
// dal suo versore normale.
double
ThreePointPlaneSignedDist( const Triangle3d& trTria, const Point3d& ptPlane, const Vector3d& vtNorm) ;

//----------------------------------------------------------------------------
// Calcola, se esiste, il punto di una retta a distanza con segno data da un piano.
// Il piano è descritto da punto e versore normale.
// La retta è descritta da punto e versore direzione.
// I casi possibili sono:
// - Nessun punto della retta dista d dal piano (retta parallela al piano con distanza diversa da d),
//   viene restituito 0 e il valore di dPar non ha senso.
// - Un solo punto della retta dista d dal piano (retta non parallela al piano), viene restituito 1
//   e il valore di dPar è il parametro del punto sulla retta.
// - Tutti i punti della retta distano d dal piano (retta parallela al piano con distanza d), viene 
//   restituito 2 e qualunque valore di dPar ha senso. 
int
LinePlaneDDistPar( const Point3d& ptPlane, const Vector3d& vtPlane, const Point3d& ptLine, const Vector3d& vtLine,
                   double dDist, double& dPar) ;

//----------------------------------------------------------------------------
// Date due rette nello spazio restituisce il quadrato della loro distanza.
// Le rette sono definite da un punto e dal versore direzione.
double
LineLineSqDist( const Point3d& ptP1, const Vector3d& vtD1, const Point3d& ptP2, const Vector3d& vtD2) ;

//----------------------------------------------------------------------------
// Data una retta e un segmento, ne restituisce il quadrato della distanza.
// La retta è definita da un punto e dal versore direzione.
// Il segmento è definito da un estremo, dal versore direzione verso l'altro estremo e dalla lunghezza.
double
LineSegmentSqDist( const Point3d& ptPLn, const Vector3d& vtDLn,
                   const Point3d& ptPSg, const Vector3d& vtDSg, double dSgLen) ;

//----------------------------------------------------------------------------
// Valuta l'interferenza di un disco e un triangolo complanari.
// Si assume che disco e piano siano paralleli, ovvero che valga a n = 1 con
// a versore dell'asse del disco e n versore normale al triangolo.
// L'informazione su n è contenuta nell'oggetto triangolo; quella su a non è passata
// in quanto inutile sotto le nostre assunzioni.
bool
CoplanarDiscTriangleInterference( const Point3d& ptCen, double dRad, const Triangle3d& trTria, int nTriType) ;

//----------------------------------------------------------------------------
// Date due rette, descritte da un punto e un vettore direzione,
// trova i parametri corrispondenti ai punti di minima distanza. 
// Se le rette non sono parallele abbiamo una singola coppia di
// punti e viene restituito true, altrimenti ne abbiamo infinite
// e viene restituito false. Si noti che i parametri dU1, dU2   
// non hanno necessariamente il significato di lunghezza;
// perché non è richiesto che i vettori siano normalizzati.
bool
FindLineLineMinDistPar( const Point3d& ptL1, const Vector3d& vtV1,
                        const Point3d& ptL2, const Vector3d& vtV2,
                        double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Calcolo delle posizioni di tangenza di una sfera che si muove dalla posizione
// originale lungo una direzione prefissata rispetto ad una retta.
// Le posizioni sono rappresentate dalla distanza percorsa.
// Il parametro di ritorno può assumere i seguenti valori :
//  0 : la sfera non è mai tangente alla retta; dU1 e dU2 non hanno senso
//  1 : la sfera è tangente alla retta in una posizione; solo dU1 ha senso 
//  2 : la sfera è tangente alla retta in due posizioni; dU1 e dU2 valide
//  3 : la sfera è sempre tangente 
int
SphereLineTangentPoints( const Point3d& ptSpheCen, double dSpheRad,
                         const Point3d& ptSeg, const Vector3d& vtSegDir, double dSegLen,
                         const Vector3d& vtMove, double& dU1, double& dU2) ;

//----------------------------------------------------------------------------
// Valuta l'allontanamento di un disco, lungo il proprio asse di simmetria, da un piano.
// Il disco è descritto dal centro nella posizione iniziale e dal raggio (la normale è il versore traslazione).
// Il piano è descritto da un suo punto e dal suo versore normale.
// Il moto è descritto dal versore di traslazione.
// Il valore restituito è un intero che descrive la situazione di allontanamento e,
// quando sensato, per referenza restituisce il punto di ultimo contatto.
// 0: Nessun contatto
// 1: Un contatto
// 2: Disco e piano ortogonali, con disco tg al piano, il contatto è una semiretta
// 3: Disco e piano ortogonali, con disco secante il piano, il contatto è una striscia 
// 4: Disco e piano paralleli, come ultimo contatto si restituisce il centro.
// Nel caso 0 il parametro ptTouch non ha senso, così come nel caso 2 e nel caso 3
int
DiskPlaneLastContactLongMot( const Point3d& ptDiskCen, double dDiskRad,
                             const Point3d& ptPlane, const Vector3d& vtPlane,
                             const Vector3d& vtMove, Point3d& ptTouch) ;

//----------------------------------------------------------------------------
// Si limita il segmento alla parte di spazio con distanza positiva dal piano.
// Se segmento ancora valido si restituisce true, altrimenti false.
bool
ClampSegmentOutPlane( const Plane3d& plPlane, Point3d& ptSegP, const Vector3d& vtSegV, double& dSegLen, double dSignTol = 0.) ;