Riccardo Elitropi
626d5b0e51
- Aggiunte funzioni per calcolo di Offset per superfici chiuse TriMesh - Piccola miglioria alla triangolazione (con SaraP) - Migliorie per rimozioni TJunction, calcolo delle normali dei triangoli e creazione di una TriMesh a partire da uno ZMap (con SaraP) - Aggiunte funzioni di SubtractMap e piccole modifiche per estensione dei Box di creazione per gli Zmap.
301 lines
13 KiB
C++
301 lines
13 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2025-2025
|
|
//----------------------------------------------------------------------------
|
|
// File : OffsetSurfTm.cpp Data : 09.06.25 Versione : 2.7e3
|
|
// Contenuto : Dichiarazione della funzione per calcolare l'offset di superfici TriMesh
|
|
// mediante Zmap
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 09.06.25 RE Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "stdafx.h"
|
|
#include "VolZmap.h"
|
|
#include "CurveLine.h"
|
|
#include "GeoConst.h"
|
|
#include "/EgtDev/Include/EGkStmFromCurves.h"
|
|
#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
|
|
#include "/EgtDev/Include/EgtNumUtils.h"
|
|
#include <future>
|
|
|
|
using namespace std ;
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
/* Funzione per aggiungere intervalli lungo un Dexel per l'offset di una superficie TriMesh */
|
|
bool
|
|
VolZmap::SubtractIntervalsForOffset( int nGrid, int nI, int nJ,
|
|
double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
|
|
int nToolNum, bool bSkipSwap)
|
|
{
|
|
// per ora la funzione è la stessa della differenza in generale
|
|
// TODO -- Aggiustare eventuali tolleranze
|
|
return SubtractIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, bSkipSwap) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/* Funzione per aggiungere intervalli lungo un Dexel per l'offset di una superficie TriMesh */
|
|
bool
|
|
VolZmap::AddIntervalsForOffset( int nGrid, int nI, int nJ,
|
|
double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
|
|
int nToolNum, bool bSkipSwap)
|
|
{
|
|
// per ora la funzione è la stessa della somma generale
|
|
// TODO -- Aggiustare eventuali tolleranze
|
|
return AddIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, bSkipSwap) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/* Funzione per la creazione di una sfera di Offset centrata sul vertice di una TriMesh con cui
|
|
aggiungere o sottrarre intervalli lungo i Dexel coinvolti */
|
|
bool
|
|
VolZmap::CreateOffsSphereOnVertex( const Point3d& ptV, double dOffs, int nGrid)
|
|
{
|
|
// determino il Box della sfera posizionata su tale vertice
|
|
BBox3d BBoxSphere( ptV - dOffs * Vector3d( 1., 1., 1.),
|
|
ptV + dOffs * Vector3d( 1., 1., 1.)) ;
|
|
// determino gli intervalli di interesse mediante intersezione con Box della sfera
|
|
int nStartI = max( 0, int( BBoxSphere.GetMin().x / m_dStep)) ;
|
|
int nEndI = min( m_nNx[nGrid] - 1, int( BBoxSphere.GetMax().x / m_dStep)) ;
|
|
int nStartJ = max( 0, int( BBoxSphere.GetMin().y / m_dStep)) ;
|
|
int nEndJ = min( m_nNy[nGrid] - 1, int( BBoxSphere.GetMax().y / m_dStep)) ;
|
|
// aggiorno gli spilloni interessati
|
|
double dSqRad = dOffs * dOffs ;
|
|
for ( int i = nStartI ; i <= nEndI ; ++ i) {
|
|
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
|
|
double dX = ( i + 0.5) * m_dStep ;
|
|
double dY = ( j + 0.5) * m_dStep ;
|
|
Point3d ptC( dX, dY, 0.) ;
|
|
double dStSqDXY = SqDistXY( ptC, ptV) ;
|
|
if ( dStSqDXY < dSqRad) {
|
|
double dMin = ptV.z - sqrt( dSqRad - dStSqDXY) ;
|
|
Vector3d vtNmin = Point3d( dX, dY, dMin) - ptV ;
|
|
vtNmin.Normalize() ;
|
|
double dMax = ptV.z + sqrt( dSqRad - dStSqDXY) ;
|
|
Vector3d vtNmax = Point3d( dX, dY, dMax) - ptV ;
|
|
vtNmax.Normalize() ;
|
|
if ( dOffs > 0.)
|
|
AddIntervalsForOffset( nGrid, i, j, dMin, dMax, vtNmin, vtNmax, 0) ;
|
|
else
|
|
SubtractIntervalsForOffset( nGrid, i, j, dMin, dMax, -vtNmin, -vtNmax, 0) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/* Funzione per la creazione di un cilindro di Offset sul vertice di una TriMesh con cui
|
|
aggiungere o sottrarre intervalli lungo i Dexel coinvolti */
|
|
bool
|
|
VolZmap::CreateOffsCylinderOnEdge( const Point3d& ptP1, const Point3d& ptP2, double dOffs, int nGrid)
|
|
{
|
|
// determino la lunghezza dello spigolo corrente
|
|
double dH = Dist( ptP1, ptP2) ;
|
|
// asse del cilindro
|
|
Vector3d vtV = ptP2 - ptP1 ; vtV.Normalize() ;
|
|
// calcolo box del cilindro
|
|
BBox3d BBoxCylinder ;
|
|
BBoxCylinder.Add( ptP1) ;
|
|
BBoxCylinder.Add( ptP2) ;
|
|
if ( AreSameOrOppositeVectorApprox( vtV, X_AX))
|
|
BBoxCylinder.Expand( 0., abs( dOffs), abs( dOffs)) ;
|
|
else if ( AreSameOrOppositeVectorApprox( vtV, Y_AX))
|
|
BBoxCylinder.Expand( abs( dOffs), 0., abs( dOffs)) ;
|
|
else if ( AreSameOrOppositeVectorApprox( vtV, Z_AX))
|
|
BBoxCylinder.Expand( abs( dOffs), abs( dOffs), 0.) ;
|
|
else {
|
|
double dExpandX = abs( dOffs) * sqrt( 1 - vtV.x * vtV.x) ;
|
|
double dExpandY = abs( dOffs) * sqrt( 1 - vtV.y * vtV.y) ;
|
|
double dExpandZ = abs( dOffs) * sqrt( 1 - vtV.z * vtV.z) ;
|
|
BBoxCylinder.Expand( dExpandX, dExpandY, dExpandZ) ;
|
|
}
|
|
// determino gli intervalli di interesse mediante intersezione
|
|
int nStartI = max( 0, int( BBoxCylinder.GetMin().x / m_dStep)) ;
|
|
int nEndI = min( m_nNx[nGrid] - 1, int( BBoxCylinder.GetMax().x / m_dStep)) ;
|
|
int nStartJ = max( 0, int( BBoxCylinder.GetMin().y / m_dStep)) ;
|
|
int nEndJ = min( m_nNy[nGrid] - 1, int( BBoxCylinder.GetMax().y / m_dStep)) ;
|
|
// aggiorno gli spilloni interessati
|
|
Frame3d CylFrame ;
|
|
if ( ! CylFrame.Set( ptP1, vtV))
|
|
return false ;
|
|
for ( int i = nStartI ; i <= nEndI ; ++ i) {
|
|
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
|
|
Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ;
|
|
Point3d ptInt1, ptInt2 ;
|
|
Vector3d vtN1, vtN2 ;
|
|
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dH, abs( dOffs), true, true,
|
|
ptInt1, vtN1, ptInt2, vtN2)) {
|
|
if ( dOffs > 0.)
|
|
AddIntervalsForOffset( nGrid, i, j, ptInt1.z, ptInt2.z, -vtN1, -vtN2, 0) ;
|
|
else
|
|
SubtractIntervalsForOffset( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, 0) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/* Funzione per la creazine di uno Zmap di Offset (positivo o negativo) a partire da una
|
|
superficie TriMesh */
|
|
bool
|
|
VolZmap::CreateFromTriMeshOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol)
|
|
{
|
|
// controllo delle superfici
|
|
for ( const ISurfTriMesh* Surf : vSurf) {
|
|
if ( Surf == nullptr)
|
|
return false ;
|
|
}
|
|
// verifica sul parametro di Offset ( coerente con Curve e FlatRegion)
|
|
if ( abs( dOffs) < 10 * EPS_SMALL)
|
|
return true ;
|
|
// se non ho superfici, non faccio nulla
|
|
if ( vSurf.empty())
|
|
return true ;
|
|
|
|
// definisco lo Zmap di partenza a partire dalle superfici
|
|
// se una sola superficie
|
|
double dBoxExpansion = ( abs( dOffs) + 1.5 * dTol) + 10 * EPS_SMALL ;
|
|
if ( int( vSurf.size()) == 1) {
|
|
// controllo la validità della superficie
|
|
if ( ! vSurf[0]->IsValid() || vSurf[0]->GetTriangleCount() == 0)
|
|
return true ;
|
|
// definisco lo Zamp a partire dall'espansione del Box della superficie
|
|
if ( ! CreateFromTriMesh( *vSurf[0], dTol, true, dBoxExpansion))
|
|
return false ;
|
|
}
|
|
// se più superfici
|
|
else {
|
|
// calcolo il Box complessivo delle superfici TriMesh
|
|
BBox3d BBoxGlob ;
|
|
for ( int i = 0 ; i < int( vSurf.size()) ; ++ i) {
|
|
// controllo la validità della superficie
|
|
if ( ! vSurf[i]->IsValid() || vSurf[i]->GetTriangleCount() == 0)
|
|
continue ;
|
|
// calcolo il Box della superficie
|
|
BBox3d BBoxSurf ; vSurf[i]->GetLocalBBox( BBoxSurf) ;
|
|
// aggiungo il Box a quello complessivo
|
|
BBoxGlob.Add( BBoxSurf) ;
|
|
}
|
|
// definisco uno Zmap vuoto a partire dal Box
|
|
BBoxGlob.Expand( dBoxExpansion) ;
|
|
if ( ! CreateEmpty( BBoxGlob.GetMin(), BBoxGlob.GetDimX(), BBoxGlob.GetDimY(), BBoxGlob.GetDimZ(), dTol, true))
|
|
return false ;
|
|
for ( const ISurfTriMesh* Surf : vSurf) {
|
|
if ( ! AddSurfTm( Surf))
|
|
return false ;
|
|
}
|
|
}
|
|
|
|
/* Assunzioni :
|
|
- Idea Generale di Offset
|
|
- Su ogni vertice viene definita una sfera ( con raggio pari al valore di Offset e
|
|
centro il vertice corrente)
|
|
- Su ogni lato viene definito un cilindro ( con raggio di pase pari al valore di Offset
|
|
e asse definito dall'edge stesso)
|
|
- Su ogni faccia viene definita una superficie di estrusione ( dove le due basi sono
|
|
definite dalla traslazione sia in positivo che in negativo della faccia lungo la sua normale)
|
|
|
|
- Segno dell'Offset :
|
|
- Positivo ( si sommano gli intervalli corrisipondenti alle entità create)
|
|
- Negativo ( si sottraggono gli intervalli corrispondenti alle enetità create)
|
|
|
|
- Semplificazione entità :
|
|
La creazione di Sfere e Cilindri potrebbe essere resa più "corretta" definitendo solo
|
|
"spicchi 3d" di sfera e "spicchi 3d" di cilindri. Dato che le operazioni di somma, sottrazioni e
|
|
calcolo delle normali per gli spilloni sono elementari su queste figure, si rischia di appesantire
|
|
troppo i conti introducendo variabili angolari che non sommando tutte le parti.
|
|
*/
|
|
|
|
// definisco vettore di frame Locali alle 3 griglie
|
|
FRAME3DVECTOR vFrGrid( 4) ;
|
|
vFrGrid[0].Set( ORIG, X_AX, Y_AX, Z_AX) ;
|
|
vFrGrid[1].Set( m_MapFrame.Orig(), m_MapFrame.VersX(), m_MapFrame.VersY(), m_MapFrame.VersZ()) ;
|
|
vFrGrid[2].Set( m_MapFrame.Orig(), m_MapFrame.VersY(), m_MapFrame.VersZ(), m_MapFrame.VersX()) ;
|
|
vFrGrid[3].Set( m_MapFrame.Orig(), m_MapFrame.VersZ(), m_MapFrame.VersX(), m_MapFrame.VersY()) ;
|
|
|
|
|
|
// scorro le superfici
|
|
for ( const ISurfTriMesh* Surf : vSurf) {
|
|
// se superficie non valida, passo alla successiva
|
|
if ( ! Surf->IsValid() || Surf->GetTriangleCount() == 0)
|
|
continue ;
|
|
// definisco una mappa dei vertici, in modo da sapere su quali sono state già create le sfere
|
|
BOOLVECTOR vbVert( Surf->GetVertexCount(), false) ;
|
|
// ----------------------- Cilindri e Sfere -----------------------
|
|
// scorro gli Edge della superficie
|
|
for ( int nE = 0 ; nE < Surf->GetEdgeCount() ; ++ nE) {
|
|
// recupero lo spigolo
|
|
int nV1, nV2, nF1, nF2 ; double dAng ;
|
|
Surf->GetEdge( nE, nV1, nV2, nF1, nF2, dAng) ;
|
|
// controllo se il cilindro serve
|
|
// NB. la mancata creazione del cilindro comporta la mancata creazione delle sfere sui suoi vertici
|
|
// durante questa iterazione; non significa che questa sfera non verrà mai creata...
|
|
// Non esiste la sfera sul vertive V <=> non esiste alcun cilindro su tutti gli edge concorrenti
|
|
if ( dAng * dOffs < 0)
|
|
continue ;
|
|
// recupero le coordinate dei vertici
|
|
Point3d ptP1 ; Surf->GetVertex( nV1, ptP1) ;
|
|
Point3d ptP2 ; Surf->GetVertex( nV2, ptP2) ;
|
|
// ciclo sulle griglie
|
|
for ( int nGrid = 0 ; nGrid < 3 ; ++ nGrid) {
|
|
// esprimo gli estremi nel riferimento della griglia
|
|
ptP1.LocToLoc( vFrGrid[nGrid], vFrGrid[nGrid + 1]) ;
|
|
ptP2.LocToLoc( vFrGrid[nGrid], vFrGrid[nGrid + 1]) ;
|
|
// aggiungo/sottraggo gli intervalli definiti dal cilindro
|
|
if ( ! CreateOffsCylinderOnEdge( ptP1, ptP2, dOffs, nGrid))
|
|
return false ;
|
|
// aggiungo/sottraggo gli intervalli definiti dalla sfera
|
|
if ( ! vbVert[nV1]) {
|
|
vbVert[nV1] = ( nGrid == 2) ;
|
|
if ( ! CreateOffsSphereOnVertex( ptP1, dOffs, nGrid))
|
|
return false ;
|
|
}
|
|
if ( ! vbVert[nV2]) {
|
|
vbVert[nV2] = ( nGrid == 2) ;
|
|
if ( ! CreateOffsSphereOnVertex( ptP2, dOffs, nGrid))
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
// ----------------------- Facce -----------------------
|
|
// scorro tutte le facce definendo una superficie di estrusione
|
|
for ( int nF = 0 ; nF < Surf->GetFacetCount() ; ++ nF) {
|
|
// recupero lo faccia
|
|
POLYLINEVECTOR vPL ; Surf->GetFacetLoops( nF, vPL) ;
|
|
// recupero la normale della faccia
|
|
Vector3d vtN ; Surf->GetFacetNormal( nF, vtN) ;
|
|
// definisco la superficie di estrusione
|
|
CICURVEPVECTOR vpCrvs ; vpCrvs.reserve( vPL.size()) ;
|
|
for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
|
|
vPL[i].Translate( - abs( dOffs) * vtN) ;
|
|
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
|
|
if ( IsNull( pCrvCompo) || ! pCrvCompo->FromPolyLine( vPL[i]))
|
|
return false ;
|
|
vpCrvs.emplace_back( Release( pCrvCompo)) ;
|
|
}
|
|
// recupero la TriMesh di estrusione
|
|
PtrOwner<ISurfTriMesh> pStmExtr( GetSurfTriMeshByRegionExtrusion( vpCrvs, 2 * abs( dOffs) * vtN)) ;
|
|
if ( IsNull( pStmExtr) || ! pStmExtr->IsValid() || pStmExtr->GetTriangleCount() == 0)
|
|
return false ;
|
|
// aggiorno gli spilloni
|
|
if ( dOffs > 0.)
|
|
AddSurfTm( pStmExtr) ;
|
|
else
|
|
SubtractSurfTm( pStmExtr) ;
|
|
}
|
|
}
|
|
m_nShape = OFFSET ; // OFFSET (?) ... per ora va bene così
|
|
|
|
return true ;
|
|
}
|
|
|
|
|
|
|