DarioS
8a3d46416d
- corretta IntersSegmentCylinder (qui come cilindro si intende solo la superficie dello stesso) - corretta e velocizzata AvoidSurfTm di VolZmap nel caso di test con singola map.
292 lines
18 KiB
C
292 lines
18 KiB
C
//----------------------------------------------------------------------------
|
|
// 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) ;
|