Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtGeomKernel :

Browse Source 
- aggiunta funzione IntersCurveSurfTm
- funzioni di intersezione Line e Plane con Zmap separate dall'oggetto per l'interfaccia
This commit is contained in:
Dario Sassi
2024-02-26 15:00:15 +01:00
parent 6e810f050e
commit 451ef8356b
11 changed files with 522 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtGeomKernel.vcxproj
+11
View File
@@ -309,14 +309,25 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClCompile Include="CurveByApprox.cpp" />
<ClCompile Include="CurveByInterp.cpp" />
<ClCompile Include="CurveCompositeOffset.cpp" />
<ClCompile Include="IntersCurveSurfTm.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="IntersLineVolZmap.cpp" />
<ClCompile Include="IntersPlaneVolZmap.cpp" />
<ClCompile Include="PolygonElevation.cpp" />
<ClCompile Include="Voronoi.cpp" />
<ClInclude Include="..\Include\EGkCDeClosedSurfTmClosedSurfTm.h" />
<ClInclude Include="..\Include\EGkCDeConeFrustumClosedSurfTm.h" />
<ClInclude Include="..\Include\EGkCDeConvexTorusClosedSurfTm.h" />
<ClInclude Include="..\Include\EGkCDeRectPrismoidClosedSurfTm.h" />
<ClInclude Include="..\Include\EGkIntersCurveSurfTm.h" />
<ClInclude Include="..\Include\EGkIntersLineBox.h" />
<ClInclude Include="..\Include\EGkIntersLineVolZmap.h" />
<ClInclude Include="..\Include\EGkIntersPlaneBox.h" />
<ClInclude Include="..\Include\EGkIntersPlaneVolZmap.h" />
<ClInclude Include="..\Include\EGkPolygonElevation.h" />
<ClInclude Include="..\Include\EGkSubtractProjectedFacesOnStmFace.h" />
<ClInclude Include="CDeBoxTria.h" />
EgtGeomKernel.vcxproj.filters
+50 -29
View File
@@ -43,15 +43,18 @@
<Filter Include="File di origine\GeoOffset">
<UniqueIdentifier>{f07670fd-9429-4b7e-ac6d-1c0022e756fb}</UniqueIdentifier>
</Filter>
<Filter Include="File di origine\GeoCollision">
<UniqueIdentifier>{865b76ee-b10d-41fc-861c-b48ce52fa277}</UniqueIdentifier>
</Filter>
<Filter Include="File di origine\GeoProject">
<UniqueIdentifier>{d96752da-1884-4a73-ba1b-5b20b606e469}</UniqueIdentifier>
</Filter>
<Filter Include="File di origine\GeoElevation">
<UniqueIdentifier>{4c6a9dc5-8fac-4ecd-bde6-3e37e056712e}</UniqueIdentifier>
</Filter>
<Filter Include="File di origine\GeoCollisionAvoid">
<UniqueIdentifier>{ae52e402-3063-45e3-b9f7-1710035a1f56}</UniqueIdentifier>
</Filter>
<Filter Include="File di origine\GeoCollisionDetection">
<UniqueIdentifier>{865b76ee-b10d-41fc-861c-b48ce52fa277}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Vector3d.cpp">
@@ -372,17 +375,8 @@
<ClCompile Include="IntersLineSurfStd.cpp">
<Filter>File di origine\GeoInters</Filter>
</ClCompile>
<ClCompile Include="CAvToolTriangle.cpp">
<Filter>File di origine\GeoCollision</Filter>
</ClCompile>
<ClCompile Include="CAvToolSurfTm.cpp">
<Filter>File di origine\GeoCollision</Filter>
</ClCompile>
<ClCompile Include="CDeBoxTria.cpp">
<Filter>File di origine\GeoCollision</Filter>
</ClCompile>
<ClCompile Include="CAvSimpleSurfFrMove.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="IntersSurfTmSurfTm.cpp">
<Filter>File di origine\GeoInters</Filter>
@@ -400,19 +394,19 @@
<Filter>File di origine\Geo</Filter>
</ClCompile>
<ClCompile Include="CDeCylTria.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeBoxClosedSurfTm.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeCylClosedSurfTm.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeSpheTria.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeSpheClosedSurfTm.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="SurfBezier.cpp">
<Filter>File di origine\Geo</Filter>
@@ -430,34 +424,34 @@
<Filter>File di origine\GeoDist</Filter>
</ClCompile>
<ClCompile Include="CDeTriaTria.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeConeTria.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeUtility.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeClosedSurfTmClosedSurfTm.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeConeFrustumClosedSurfTm.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeConeFrustumTria.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeConvexTorusClosedSurfTm.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeConvexTorusTria.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeRectPrismoidClosedSurfTm.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="CDeRectPrismoidTria.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="SurfTriMeshUtilities.cpp">
<Filter>File di origine\Geo</Filter>
@@ -469,7 +463,7 @@
<Filter>File di origine\Base</Filter>
</ClCompile>
<ClCompile Include="CDeCapsTria.cpp">
<Filter>File di origine\GeoCollision</Filter>
<Filter>File di origine\GeoCollisionDetection</Filter>
</ClCompile>
<ClCompile Include="Circle2P.cpp">
<Filter>File di origine\GeoCreate</Filter>
@@ -510,6 +504,24 @@
<ClCompile Include="PolygonElevation.cpp">
<Filter>File di origine\GeoElevation</Filter>
</ClCompile>
<ClCompile Include="IntersCurveSurfTm.cpp">
<Filter>File di origine\GeoInters</Filter>
</ClCompile>
<ClCompile Include="CAvSimpleSurfFrMove.cpp">
<Filter>File di origine\GeoCollisionAvoid</Filter>
</ClCompile>
<ClCompile Include="CAvToolSurfTm.cpp">
<Filter>File di origine\GeoCollisionAvoid</Filter>
</ClCompile>
<ClCompile Include="CAvToolTriangle.cpp">
<Filter>File di origine\GeoCollisionAvoid</Filter>
</ClCompile>
<ClCompile Include="IntersLineVolZmap.cpp">
<Filter>File di origine\GeoInters</Filter>
</ClCompile>
<ClCompile Include="IntersPlaneVolZmap.cpp">
<Filter>File di origine\GeoInters</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="stdafx.h">
@@ -1169,6 +1181,15 @@
<ClInclude Include="Voronoi.h">
<Filter>File di intestazione</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkIntersCurveSurfTm.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkIntersPlaneVolZmap.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkIntersLineVolZmap.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtGeomKernel.rc">
IntersCurveSurfTm.cpp
+223
View File
@@ -0,0 +1,223 @@
//----------------------------------------------------------------------------
// EgalTech 2024-2024
//----------------------------------------------------------------------------
// File : IntersCurveSurfTm.cpp Data : 23.02.24 Versione : 2.6b4
// Contenuto : Implementazione della intersezione curva/superficie trimesh.
//
//
//
// Modifiche : 23.02.24 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "GeoConst.h"
#include "/EgtDev/Include/EGkIntersLineTria.h"
#include "/EgtDev/Include/EGkIntersCurveSurfTm.h"
using namespace std ;
//----------------------------------------------------------------------------
static void
UpdateInfoIntersCurveSurfTm( const Point3d& ptL, const Vector3d& vtDir, double dLen, double dUs, double dUe,
int nT, const Triangle3d& Tria, ICSIVECTOR& vInfo)
{
Point3d ptInt, ptInt2 ;
int nRes = IntersLineTria( ptL, vtDir, dLen, Tria, ptInt, ptInt2, true) ;
if ( nRes == ILTT_IN || nRes == ILTT_EDGE || nRes == ILTT_VERT) {
double dU = dUs + ( ptInt - ptL) * vtDir / dLen * ( dUe - dUs) ;
double dCosDN = vtDir * Tria.GetN() ;
vInfo.emplace_back( nRes, dU, nT, dCosDN, ptInt) ;
}
else if ( nRes == ILTT_SEGM || nRes == ILTT_SEGM_ON_EDGE) {
double dU = dUs + ( ptInt - ptL) * vtDir / dLen * ( dUe - dUs) ;
double dU2 = dUs + ( ptInt2 - ptL) * vtDir / dLen * ( dUe - dUs) ;
double dCosDN = vtDir * Tria.GetN() ;
vInfo.emplace_back( nRes, dU, dU2, nT, dCosDN, ptInt, ptInt2) ;
}
}
//----------------------------------------------------------------------------
static void
OrderInfoIntersCurveSurfTm( ICSIVECTOR& vInfo)
{
// se non trovati, esco
if ( vInfo.size() == 0)
return ;
// ordino il vettore delle intersezioni secondo il senso crescente del parametro di linea
sort( vInfo.begin(), vInfo.end(),
[]( const IntCrvStmInfo& a, const IntCrvStmInfo& b)
{ double dUa = ( ( a.nILTT == ILTT_SEGM || a.nILTT == ILTT_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
double dUb = ( ( b.nILTT == ILTT_SEGM || b.nILTT == ILTT_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
return ( dUa < dUb) ; }) ;
}
//----------------------------------------------------------------------------
// Intersezione di una curva con una superficie TriMesh
//----------------------------------------------------------------------------
bool
IntersCurveSurfTm( const ICurve& Curve, const ISurfTriMesh& Stm, double dLinTol, ICSIVECTOR& vInfo)
{
// verifico i parametri ricevuti
if ( & Curve == nullptr || &Stm == nullptr || &vInfo == nullptr)
return false ;
dLinTol = max( dLinTol, EPS_SMALL) ;
vInfo.clear() ;
// approssimo la curva con una spezzata
PolyLine PL ;
if ( ! Curve.ApproxWithLines( dLinTol, ANG_TOL_APPROX_DEG, ICurve::APL_SPECIAL, PL))
return false ;
// per ogni segmento dell'approssimante cerco l'intersezione con la superficie
double dParS, dParE ;
Point3d ptStart, ptEnd ;
bool bFound = PL.GetFirstULine( &dParS, &ptStart, &dParE, &ptEnd) ;
while ( bFound) {
Vector3d vtDir = ptEnd - ptStart ;
double dLen = vtDir.Len() ;
if ( dLen > EPS_SMALL) {
vtDir /= dLen ;
// cerco i triangoli intersecati dal segmento
const double BOX_STEP = 10 ;
int nStep = int( ceil( dLen / BOX_STEP)) ;
Vector3d vtStep = dLen / nStep * vtDir ;
INTVECTOR vPrevT ;
for ( int i = 0 ; i < nStep ; ++ i) {
BBox3d b3Box( ptStart + i * vtStep, ptStart + ( i + 1) * vtStep) ;
INTVECTOR vT ;
if ( Stm.GetAllTriaOverlapBox( b3Box, vT)) {
for ( auto nT : vT) {
// se triangolo non ancora intersecato
if ( find( vPrevT.begin(), vPrevT.end(), nT) == vPrevT.end()) {
vPrevT.emplace_back( nT) ;
Triangle3d Tria ;
Stm.GetTriangle( nT, Tria) ;
// aggiorno info con intersezione
UpdateInfoIntersCurveSurfTm( ptStart, vtDir, dLen, dParS, dParE, nT, Tria, vInfo) ;
}
}
}
}
}
// passo al segmento successivo
bFound = PL.GetNextULine( &dParS, &ptStart, &dParE, &ptEnd) ;
}
// ordino il vettore delle eventuali intersezioni secondo il senso crescente del parametro di linea
OrderInfoIntersCurveSurfTm( vInfo) ;
return true ;
}
//----------------------------------------------------------------------------
bool
IntersCurveSurfTmExt( const ICurve& Curve, const ISurfTriMesh& Stm, double dLinTol, INTDBLVECTOR& vInters)
{
ICSIVECTOR vInfo ;
vInters.clear() ;
return ( IntersCurveSurfTm( Curve, Stm, dLinTol, vInfo) && FilterCurveSurfTmInters( Curve, vInfo, vInters)) ;
}
//----------------------------------------------------------------------------
bool
FilterCurveSurfTmInters( const ICurve& Curve, const ICSIVECTOR& vInfo, INTDBLVECTOR& vInters)
{
// verifico i parametri ricevuti
if ( & Curve == nullptr || &vInfo == nullptr || &vInters == nullptr)
return false ;
vInters.clear() ;
// info sulla curva
bool bClosedCrv = Curve.IsClosed() ;
double dParSCrv, dParECrv ;
Curve.GetDomain( dParSCrv, dParECrv) ;
// ciclo sulle intersezioni
for ( const auto& Info : vInfo) {
// se intersezione puntuale
if ( Info.nILTT == ILTT_VERT || Info.nILTT == ILTT_EDGE || Info.nILTT == ILTT_IN) {
int nFlag = CSIT_NONE ;
if ( Info.dCosDN > EPS_ZERO)
nFlag = CSIT_IN_OUT ;
else if ( Info.dCosDN < -EPS_ZERO)
nFlag = CSIT_OUT_IN ;
vInters.emplace_back( nFlag, Info.dU) ;
}
// se altrimenti intersezione con coincidenza
else if ( Info.nILTT == ILTT_SEGM || Info.nILTT == ILTT_SEGM_ON_EDGE) {
vInters.emplace_back( CSIT_IN_ON, Info.dU) ;
vInters.emplace_back( CSIT_ON_IN, Info.dU2) ;
}
}
// elimino intersezioni ripetute
int nStart = ( bClosedCrv ? 0 : 1) ;
for ( int j = nStart ; j < int( vInters.size()) ; ) {
// intersezione precedente
int i = ( j > 0 ? j - 1 : int( vInters.size()) - 1) ;
// se hanno lo stesso parametro
if ( abs( vInters[i].second - vInters[j].second) < EPS_PARAM ||
( bClosedCrv && abs( vInters[i].second - dParECrv) < EPS_PARAM && abs( vInters[j].second - dParSCrv) < EPS_PARAM)) {
// flag per eseguita cancellazione
bool bSomeErased = false ;
// se sono entrambe entranti o uscenti, elimino la seconda
if ( ( vInters[i].first == CSIT_OUT_IN && vInters[j].first == CSIT_OUT_IN) ||
( vInters[i].first == CSIT_IN_OUT && vInters[j].first == CSIT_IN_OUT)) {
vInters.erase( vInters.begin() + j) ;
bSomeErased = true ;
}
// se una entrante e l'altra uscente, cambio in touch da fuori ed elimino la seconda
else if ( vInters[i].first == CSIT_OUT_IN && vInters[j].first == CSIT_IN_OUT) {
vInters[i].first = CSIT_OUT_OUT ;
vInters.erase( vInters.begin() + j) ;
bSomeErased = true ;
}
// se una uscente e l'altra entrante, cambio in touch da dentro ed elimino la seconda
else if ( vInters[i].first == CSIT_IN_OUT && vInters[j].first == CSIT_OUT_IN) {
vInters[i].first = CSIT_IN_IN ;
vInters.erase( vInters.begin() + j) ;
bSomeErased = true ;
}
// se una touch da fuori o da dentro e l'altra entrante o uscente, elimino la prima
else if ( ( vInters[i].first == CSIT_OUT_OUT || vInters[i].first == CSIT_IN_IN) &&
( vInters[j].first == CSIT_OUT_IN || vInters[j].first == CSIT_IN_OUT)) {
vInters.erase( vInters.begin() + i) ;
bSomeErased = true ;
}
// se una entrante o uscente e l'altra touch da fuori o da dentro, elimino la seconda
else if ( ( vInters[i].first == CSIT_OUT_IN || vInters[i].first == CSIT_IN_OUT) &&
( vInters[j].first == CSIT_OUT_OUT || vInters[j].first == CSIT_IN_IN)) {
vInters.erase( vInters.begin() + j) ;
bSomeErased = true ;
}
// se una puntuale e l'altra inizio di coincidenza, elimino la prima
else if ( ( vInters[i].first == CSIT_OUT_IN || vInters[i].first == CSIT_IN_OUT || vInters[i].first == CSIT_NONE) &&
( vInters[j].first == CSIT_IN_ON || vInters[j].first == CSIT_OUT_ON)) {
vInters[j].first = ( vInters[i].first == CSIT_IN_OUT ? CSIT_IN_ON : CSIT_OUT_ON) ;
vInters.erase( vInters.begin() + i) ;
bSomeErased = true ;
}
// se una fine di coincidenza e l'altra puntuale, elimino la seconda
else if ( ( vInters[i].first == CSIT_ON_IN || vInters[i].first == CSIT_ON_OUT) &&
( vInters[j].first == CSIT_OUT_IN || vInters[j].first == CSIT_IN_OUT || vInters[j].first == CSIT_NONE)) {
vInters[i].first = ( vInters[j].first == CSIT_IN_OUT ? CSIT_ON_OUT : CSIT_ON_IN) ;
vInters.erase( vInters.begin() + j) ;
bSomeErased = true ;
}
// se una fine di coincidenza e l'altra inizio di coincidenza, elimino entrambe
else if ( ( vInters[i].first == CSIT_ON_IN || vInters[i].first == CSIT_ON_OUT) &&
( vInters[j].first == CSIT_IN_ON || vInters[j].first == CSIT_OUT_ON)) {
vInters.erase( vInters.begin() + j) ;
vInters.erase( vInters.begin() + ( j > 0 ? i : i - 1)) ;
bSomeErased = true ;
}
if ( bSomeErased) {
if ( j > 0)
-- j ;
continue ;
}
}
// passo alla successiva
++ j ;
}
return true ;
}
IntersLineBox.cpp
+1 -1
View File
@@ -22,7 +22,7 @@ using namespace std ;
//----------------------------------------------------------------------------
// Linea e box allineato assi devono essere nel medesimo sistema di riferimento.
// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
// In caso di intersezione viene restituito true e i parametri lunghezza in dU1 e dU2.
//----------------------------------------------------------------------------
bool
IntersLineBox( const Point3d& ptL, const Vector3d& vtL,
IntersLineBox.h
+1 -1
View File
@@ -17,7 +17,7 @@
//----------------------------------------------------------------------------
// Linea e box allineato agli assi sono nel medesimo riferimento.
// Con intersezione viene restituito true e i parametri in dU1 e dU2.
// Con intersezione viene restituito true e i parametri lunghezza in dU1 e dU2.
//----------------------------------------------------------------------------
bool
IntersLineBox( const Point3d& ptL, const Vector3d& vtL,
IntersLineSurfTm.cpp
+70 -5
View File
@@ -21,7 +21,7 @@
using namespace std ;
//----------------------------------------------------------------------------
void
static void
UpdateInfoIntersLineSurfTm( const Point3d& ptL, const Vector3d& vtDir, double dLen,
int nT, const Triangle3d& Tria, ILSIVECTOR& vInfo, bool bFinite)
{
@@ -41,7 +41,7 @@ UpdateInfoIntersLineSurfTm( const Point3d& ptL, const Vector3d& vtDir, double dL
}
//----------------------------------------------------------------------------
void
static void
OrderInfoIntersLineSurfTm( ILSIVECTOR& vInfo)
{
// se non trovati, esco
@@ -81,7 +81,7 @@ IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
// lo ingrandisco per non avere problemi con faccia piana su piani canonici
b3Stm.Expand( 10 * EPS_SMALL) ;
double dU1, dU2 ;
if ( ! IntersLineBox( ptL, vtL, b3Stm.GetMin() , b3Stm.GetMax(), dU1, dU2))
if ( ! IntersLineBox( ptL, vtDir, b3Stm.GetMin() , b3Stm.GetMax(), dU1, dU2))
return true ;
if ( bFinite) {
dU1 = max( dU1, 0.) ;
@@ -89,12 +89,12 @@ IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
if ( dU2 - dU1 < EPS_SMALL)
return true ;
}
Point3d ptStart = ptL + dU1 * vtL ;
Point3d ptStart = ptL + dU1 * vtDir ;
double dLenEff = dU2 - dU1 ;
// cerco i triangoli intersecati dalla linea
const double BOX_STEP = 10 ;
int nStep = int( ceil( dLenEff / BOX_STEP)) ;
Vector3d vtStep = dLenEff / nStep * vtL ;
Vector3d vtStep = dLenEff / nStep * vtDir ;
INTVECTOR vPrevT ;
for ( int i = 0 ; i < nStep ; ++ i) {
BBox3d b3Box( ptStart + i * vtStep, ptStart + ( i + 1) * vtStep) ;
@@ -189,3 +189,68 @@ IntersParLinesSurfTm::GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vI
return true ;
}
//----------------------------------------------------------------------------
bool
FilterLineSurfTmInters( const ILSIVECTOR& vInfo, INTDBLVECTOR& vInters)
{
// ciclo sulle intersezioni
for ( const auto& Info : vInfo) {
// se intersezione puntuale
if ( Info.nILTT == ILTT_VERT || Info.nILTT == ILTT_EDGE || Info.nILTT == ILTT_IN) {
int nFlag = LST_TOUCH ;
if ( Info.dCosDN > EPS_ZERO)
nFlag = LST_OUT ;
else if ( Info.dCosDN < -EPS_ZERO)
nFlag = LST_IN ;
vInters.emplace_back( nFlag, Info.dU) ;
}
// se altrimenti intersezione con coincidenza
else if ( Info.nILTT == ILTT_SEGM || Info.nILTT == ILTT_SEGM_ON_EDGE) {
vInters.emplace_back( LST_TG_INI, Info.dU) ;
vInters.emplace_back( LST_TG_FIN, Info.dU2) ;
}
}
// elimino intersezioni ripetute
for ( size_t j = 1 ; j < vInters.size() ; ) {
// intersezione precedente
size_t i = j - 1 ;
// se hanno lo stesso parametro
if ( abs( vInters[i].second - vInters[j].second) < EPS_SMALL) {
// se sono entrambe entranti o uscenti, elimino la seconda
if ( ( vInters[i].first == LST_IN && vInters[j].first == LST_IN) ||
( vInters[i].first == LST_OUT && vInters[j].first == LST_OUT)) {
vInters.erase( vInters.begin() + j) ;
continue ;
}
// se una entrante e l'altra uscente, cambio in touch ed elimino la seconda
else if ( ( vInters[i].first == LST_IN && vInters[j].first == LST_OUT) ||
( vInters[i].first == LST_OUT && vInters[j].first == LST_IN)) {
vInters[i].first = LST_TOUCH ;
vInters.erase( vInters.begin() + j) ;
continue ;
}
// se una puntuale e l'altra inizio di coincidenza, elimino la prima
else if ( ( vInters[i].first == LST_IN || vInters[i].first == LST_OUT || vInters[i].first == LST_TOUCH) && vInters[j].first == LST_TG_INI) {
vInters.erase( vInters.begin() + i) ;
continue ;
}
// se una fine di coincidenza e l'altra puntuale, elimino la seconda
else if ( vInters[i].first == LST_TG_FIN && ( vInters[j].first == LST_IN || vInters[j].first == LST_OUT || vInters[j].first == LST_TOUCH)) {
vInters.erase( vInters.begin() + j) ;
continue ;
}
// se una fine di coincidenza e l'altra inizio di coincidenza, elimino entrambe
else if ( i > 0 && vInters[i].first == LST_TG_FIN && vInters[j].first == LST_TG_INI) {
vInters.erase( vInters.begin() + j) ;
vInters.erase( vInters.begin() + i) ;
-- j ;
continue ;
}
}
// passo alla successiva
++ j ;
}
return true ;
}
IntersLineVolZmap.cpp
+106
View File
@@ -0,0 +1,106 @@
//----------------------------------------------------------------------------
// EgalTech 2024-2024
//----------------------------------------------------------------------------
// File : IntersLineVolZmap.cpp Data : 22.02.24 Versione : 2.6b4
// Contenuto : Implementazione della intersezione linea/VolZmap.
//
//
//
// Modifiche : 22.02.24 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "VolZmap.h"
#include "/EgtDev/Include/EGkIntersLineVolZmap.h"
using namespace std ;
//----------------------------------------------------------------------------
// Intersezione di una linea con la superficie di un solido VolZmap
//----------------------------------------------------------------------------
bool
IntersLineVolZmap( const Point3d& ptL, const Vector3d& vtL, const IVolZmap& Vzm, ILZIVECTOR& vInfo)
{
// verifico linea
Vector3d vtDir = vtL ;
if ( ! vtDir.Normalize( EPS_ZERO))
return false ;
// verifico volume
const VolZmap* pVzm = GetBasicVolZmap( &Vzm) ;
if ( pVzm == nullptr)
return false ;
// verifico parametro di ritorno
if ( &vInfo == nullptr)
return false ;
// eseguo intersezione
return pVzm->GetLineIntersection( ptL, vtL, vInfo) ;
}
//----------------------------------------------------------------------------
bool
FilterLineVolZmapInters( const ILZIVECTOR& vInfo, INTDBLVECTOR& vInters)
{
// ciclo sulle intersezioni
for ( const auto& Info : vInfo) {
// se intersezione puntuale
if ( Info.nILTT == ILTT_VERT || Info.nILTT == ILTT_EDGE || Info.nILTT == ILTT_IN) {
int nFlag = LZT_TOUCH ;
if ( Info.dCosDN > EPS_ZERO)
nFlag = LZT_OUT ;
else if ( Info.dCosDN < -EPS_ZERO)
nFlag = LZT_IN ;
vInters.emplace_back( nFlag, Info.dU) ;
}
// se altrimenti intersezione con coincidenza
else if ( Info.nILTT == ILTT_SEGM || Info.nILTT == ILTT_SEGM_ON_EDGE) {
vInters.emplace_back( LZT_TG_INI, Info.dU) ;
vInters.emplace_back( LZT_TG_FIN, Info.dU2) ;
}
}
// elimino intersezioni ripetute
for ( size_t j = 1 ; j < vInters.size() ; ) {
// intersezione precedente
size_t i = j - 1 ;
// se hanno lo stesso parametro
if ( abs( vInters[i].second - vInters[j].second) < EPS_SMALL) {
// se sono entrambe entranti o uscenti, elimino la seconda
if ( ( vInters[i].first == LZT_IN && vInters[j].first == LZT_IN) ||
( vInters[i].first == LZT_OUT && vInters[j].first == LZT_OUT)) {
vInters.erase( vInters.begin() + j) ;
continue ;
}
// se una entrante e l'altra uscente, cambio in touch ed elimino la seconda
else if ( ( vInters[i].first == LZT_IN && vInters[j].first == LZT_OUT) ||
( vInters[i].first == LZT_OUT && vInters[j].first == LZT_IN)) {
vInters[i].first = LZT_TOUCH ;
vInters.erase( vInters.begin() + j) ;
continue ;
}
// se una puntuale e l'altra inizio di coincidenza, elimino la prima
else if ( ( vInters[i].first == LZT_IN || vInters[i].first == LZT_OUT || vInters[i].first == LZT_TOUCH) && vInters[j].first == LZT_TG_INI) {
vInters.erase( vInters.begin() + i) ;
continue ;
}
// se una fine di coincidenza e l'altra puntuale, elimino la seconda
else if ( vInters[i].first == LZT_TG_FIN && ( vInters[j].first == LZT_IN || vInters[j].first == LZT_OUT || vInters[j].first == LZT_TOUCH)) {
vInters.erase( vInters.begin() + j) ;
continue ;
}
// se una fine di coincidenza e l'altra inizio di coincidenza, elimino entrambe
else if ( i > 0 && vInters[i].first == LZT_TG_FIN && vInters[j].first == LZT_TG_INI) {
vInters.erase( vInters.begin() + j) ;
vInters.erase( vInters.begin() + i) ;
-- j ;
continue ;
}
}
// passo alla successiva
++ j ;
}
return true ;
}
IntersPlaneVolZmap.cpp
+37
View File
@@ -0,0 +1,37 @@
//----------------------------------------------------------------------------
// EgalTech 2024-2024
//----------------------------------------------------------------------------
// File : IntersPlaneVolZmap.cpp Data : 22.02.24 Versione : 2.6b4
// Contenuto : Implementazione della intersezione piano/VolZmap.
//
//
//
// Modifiche : 22.02.24 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "VolZmap.h"
#include "/EgtDev/Include/EGkIntersPlaneVolZmap.h"
using namespace std ;
//----------------------------------------------------------------------------
// Intersezione di unpiano con la superficie di un solido VolZmap
//----------------------------------------------------------------------------
bool
IntersPlaneVolZmap( const Plane3d& plPlane, const IVolZmap& Vzm, ICURVEPOVECTOR& vpLoop)
{
// verifico volume
const VolZmap* pVzm = GetBasicVolZmap( &Vzm) ;
if ( pVzm == nullptr)
return false ;
// verifico parametro di ritorno
if ( &vpLoop == nullptr)
return false ;
// eseguo intersezione
return pVzm->GetPlaneIntersection( plPlane, vpLoop) ;
}
VolZmap.h
+6 -3
View File
@@ -17,12 +17,15 @@
#include "GeoObjRW.h"
#include "Tool.h"
#include "/EgtDev/Include/EGkVolZmap.h"
#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
#include "/EgtDev/Include/EGkIntersLineVolZmap.h"
#include <unordered_map>
#include <stack>
#include <mutex>
#include <atomic>
// ------------------------- FORWARD -------------------------------------------------------------
class IntersParLinesSurfTm ;
// ------------------------- STRUTTURE -----------------------------------------------------------
struct AppliedVector {
Point3d ptPApp ;
@@ -112,8 +115,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) override ;
bool GetDepth( const Point3d& ptP, const Vector3d& vtD, double& dInLength, double& dOutLength, bool bExact) const override ;
bool GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const override ;
bool GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) const override ;
bool CDeBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise = false) const override ;
bool CDeSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise = false) const override ;
bool CDeCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise = false) const override ;
@@ -149,6 +150,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
{ if ( ! CopyFrom( stSrc))
LOG_ERROR( GetEGkLogger(), "VolZmap : copy error")
return *this ; }
bool GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const ;
bool GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) const ;
private :
enum CubeType { VOX_EXTERN = 1,
VolZmapCalculus.cpp
+16 -8
View File
@@ -2912,8 +2912,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
else if ( nIntType == ILTT_VERT || nIntType == ILTT_EDGE || nIntType == ILTT_IN) {
int nNumVox ;
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
double dCosDN = vtDir * trTria.GetN() ;
vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtDir,
nNumVox, nB, ptLineTria1, trTria) ;
nNumVox, nB, trTria, dCosDN, ptLineTria1) ;
}
// altrimenti ci sono due intersezioni
else {
@@ -2921,8 +2922,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
double dP1 = ( ptLineTria1 - ptP) * vtDir ;
double dP2 = ( ptLineTria2 - ptP) * vtDir ;
double dCosDN = vtDir * trTria.GetN() ;
vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
nNumVox, nB, ptLineTria1, ptLineTria2, trTria) ;
nNumVox, nB, trTria, dCosDN, ptLineTria1, ptLineTria2) ;
}
}
}
@@ -2948,8 +2950,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
else if ( nIntType == ILTT_VERT || nIntType == ILTT_EDGE || nIntType == ILTT_IN) {
int nNumVox ;
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
double dCosDN = vtDir * trTria.GetN() ;
vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtDir,
nNumVox, nB, ptLineTria1, trTria) ;
nNumVox, nB, trTria, dCosDN, ptLineTria1) ;
}
// altrimenti ci sono due intersezioni
else {
@@ -2957,8 +2960,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
double dP1 = ( ptLineTria1 - ptP) * vtDir ;
double dP2 = ( ptLineTria2 - ptP) * vtDir ;
double dCosDN = vtDir * trTria.GetN() ;
vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
nNumVox, nB, ptLineTria1, ptLineTria2, trTria) ;
nNumVox, nB, trTria, dCosDN, ptLineTria1, ptLineTria2) ;
}
}
}
@@ -2974,15 +2978,17 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
continue ;
// se altrimenti c'è una sola intersezione
else if ( nIntType == ILTT_VERT || nIntType == ILTT_EDGE || nIntType == ILTT_IN) {
double dCosDN = vtDir * trTria.GetN() ;
vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtDir,
-1, nB, ptLineTria1, trTria) ;
-1, nB, trTria, dCosDN, ptLineTria1) ;
}
// altrimenti ci sono due intersezioni
else {
double dP1 = ( ptLineTria1 - ptP) * vtDir ;
double dP2 = ( ptLineTria2 - ptP) * vtDir ;
double dCosDN = vtDir * trTria.GetN() ;
vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
-1, nB, ptLineTria1, ptLineTria2, trTria) ;
-1, nB, trTria, dCosDN, ptLineTria1, ptLineTria2) ;
}
}
}
@@ -3007,8 +3013,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
else if ( nIntType == ILTT_VERT || nIntType == ILTT_EDGE || nIntType == ILTT_IN) {
int nNumVox ;
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
double dCosDN = vtDir * trTria.GetN() ;
vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtDir,
nNumVox, nB, ptLineTria1, trTria) ;
nNumVox, nB, trTria, dCosDN, ptLineTria1) ;
}
// altrimenti ci sono due intersezioni
else {
@@ -3016,8 +3023,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
double dP1 = ( ptLineTria1 - ptP) * vtDir ;
double dP2 = ( ptLineTria2 - ptP) * vtDir ;
double dCosDN = vtDir * trTria.GetN() ;
vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
nNumVox, nB, ptLineTria1, ptLineTria2, trTria) ;
nNumVox, nB, trTria, dCosDN, ptLineTria1, ptLineTria2) ;
}
}
}
VolZmapCreation.cpp
+1
View File
@@ -17,6 +17,7 @@
#include "CurveLine.h"
#include "VolZmap.h"
#include "GeoConst.h"
#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include <future>