Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
NewIntersections
EgtGeomKernel/Trimming.cpp
T
Daniele Bariletti e46768b14b EgtGeomKernel : 
- modificata la funzione per la creazione di una surf Bezier ruled guided.
2026-01-15 11:50:03 +01:00

3768 lines
156 KiB
C++
Raw Permalink Blame History

//----------------------------------------------------------------------------
// EgalTech 2025-2025
//----------------------------------------------------------------------------
// File : Trimming.cpp Data : 16.11.23 Versione : 2.7j1
// Contenuto : Dichiarazione delle funzioni per calcolare una superficie di Bezier
// Ruled mediante Estrazione di Edge e Selezione di Facce/Superfici
//
//
//
// Modifiche : 16.11.23 RE Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "BiArcs.h"
#include "GeoConst.h"
#include "CurveArc.h"
#include "CurveComposite.h"
#include "SurfTriMesh.h"
#include "SurfBezier.h"
#include "CurveBezier.h"
#include "/EgtDev/Include/EGkTrimming.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkChainCurves.h"
#include "/EgtDev/Include/EGkDistPointLine.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkDistPointSurfTm.h"
#include "/EgtDev/Include/EGkDistPointSurfBz.h"
#include "/EgtDev/Include/EGkDistPointTria.h"
#include "/EgtDev/Include/EGkDistLineLine.h"
#include "/EgtDev/Include/EGkSbzFromCurves.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkIntersLineBox.h"
#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include <thread>
#include <future>
// -------------------------- Debug --------------------------------------------
#define DEBUG 0
#define DEBUG_BASIC_BORDERS 0
#define DEBUG_CHAIN_CURVES 0
#define DEBUG_ANG_APPROX 0
#define DEBUG_BEZIER_INTERP 0
#define DEBUG_FACE_SEARCH 0
#define DEBUG_BRK_POINTS 0
#define DEBUG_BRK_THICK 0
#define DEBUG_BRK 0
#define DEBUG_BORDERS_BY_NORMALS 0
#define DEBUG_SYNC_POINTS 0
#define DEBUG_BEZIER_RULED 0
#define DEBUG_CURVATURE 0
#define DEBUG_SIMPLE_PATCHES 0
#define DEBUG_SURF_PATCHES 0
#define DEBUG_EDGES 0
#define DEBUG_SHAPE_STM 0
#if DEBUG_BASIC_BORDERS || DEBUG_CHAIN_CURVES || DEBUG_ANG_APPROX || DEBUG_BEZIER_INTERP || \
DEBUG_FACE_SEARCH || DEBUG_BRK_POINTS || DEBUG_BRK_THICK || DEBUG_BRK || DEBUG_BORDERS_BY_NORMALS || \
DEBUG_SYNC_POINTS || DEBUG_BEZIER_RULED || DEBUG_CURVATURE || DEBUG_SIMPLE_PATCHES || DEBUG_SURF_PATCHES || \
DEBUG_EDGES || DEBUG_SHAPE_STM || DEBUG
#include "CurveLine.h"
#include "/EgtDev/Include/EGkGeoObjSave.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
std::vector<IGeoObj*> VT ;
std::vector<Color> VC ;
std::vector<IGeoObj*> VT_Glob ;
std::vector<Color> VC_Glob ;
std::string sFileName = "C:\\Temp\\Debug.nge" ;
#endif
using namespace std ;
// Vettori e Matrici di curva composite
typedef vector<CurveComposite> COMPOVECTOR ;
typedef vector<COMPOVECTOR> COMPOMATRIX ;
// Strutta per Patch semplici, Bordi e insieme di Bordi
struct SimplePatch {
Point3d ptStart ;
Point3d ptEnd ;
bool bErase ;
int nBorder ;
SimplePatch()
: ptStart( P_INVALID), ptEnd( P_INVALID), bErase( true), nBorder( 0) {} ;
SimplePatch( const Point3d& ptS, const Point3d& ptE, int nB, bool bDelete)
: ptStart( ptS), ptEnd( ptE), bErase( bDelete), nBorder( nB) {} ;
} ;
typedef vector<SimplePatch> SimpleBorder ;
typedef vector<SimpleBorder> SimpleBorderVector ;
typedef vector<SimpleBorderVector> SimpleBorderMatrix ;
// Struttura per superficie con relative Patch
struct SurfPatches {
int nIndSurf ;
const ISurf* pSurf ;
vector<SimplePatch> vPatches ; // non definiscono per forza un bordo, sono solo patch non ordinate
COMPOVECTOR CompoPathces ;
} ;
typedef vector<SurfPatches> SURFPATCHESVECTOR ;
// Struttura per Calcolo delle Normali su una superficie lungo il suo bordo ( per parallelismo )
struct BorderInfo {
const ISurf* pSurf ;
const ICurveComposite* pCompo ;
int nInd ;
double dParam ;
Point3d ptCrv ;
Vector3d vtTan ;
Vector3d vtNorm ;
Point3d ptFinal ;
BorderInfo( const ISurf* pS, const ICurveComposite* pC, int nI, double dP)
: pSurf( pS), pCompo( pC), nInd( nI), dParam( dP) {}
} ;
typedef vector<BorderInfo> VBORDERINFO ;
//-----------------------------------------------------------------------------
static const string sCircle{ "circle"} ;
//-----------------------------------------------------------------------------
//--------------------------- Approssimazione ---------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Funzione per spezzare una PolyLine in un insieme di Patches, ovvero un insieme di
// PolyLine dove per ogni punto si discosta da due successivi per non più della tolleranza
// angolare passata
static bool
GetPointSetByAngTol( const PolyLine& PL, double dAngTol, POLYLINEVECTOR& vPL)
{
// Se PL chiusa, deve contenere almeno 3 punti
if ( PL.IsClosed() && PL.GetPointNbr() < 3)
return false ;
// Se PL aperta, deve contenere almeno 2 punti
if ( ! PL.IsClosed() && PL.GetPointNbr() < 2)
return false ;
// Se PL aperta con solo due punti, allora non devo fare nulla
if ( ! PL.IsClosed() && PL.GetPointNbr() == 2) {
vPL.emplace_back( PL) ;
return true ;
}
// Recupero l'insieme di punti associati alla PolyLine
PNTVECTOR vPoints ; vPoints.reserve( PL.GetPointNbr()) ;
Point3d ptCurr = P_INVALID ;
bool bFound = PL.GetFirstPoint( ptCurr) ;
while ( bFound) {
vPoints.emplace_back( ptCurr) ;
bFound = PL.GetNextPoint( ptCurr) ;
}
#if DEBUG_ANG_APPROX
VT.clear() ; VC.clear() ;
Color _col = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
for ( auto _p : vPoints) {
IGeoPoint3d* _pt = CreateGeoPoint3d() ;
_pt->Set( _p) ;
VT.emplace_back( _pt) ;
VC.emplace_back( _col) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\RawPoints.nge") ;
#endif
// Sin della tolleranza angolare massima
double dCosTol = cos( dAngTol * DEGTORAD) ;
// Scorro i punti controllando le loro deviazioni angolari
PNTMATRIX vvPoints ;
Vector3d vtTanCurr = V_INVALID, vtTanNext = V_INVALID ;
bool bNewCurve = true ;
int nPoints = int( vPoints.size()) ;
for ( int nP = 0 ; nP < nPoints - 2 ; ++ nP) {
// Recupero il punto corrente e i due punti successivi
Point3d& ptCurr = vPoints[nP] ;
Point3d& ptNext = vPoints[nP + 1] ;
Point3d& ptNextNext = vPoints[nP + 2] ;
// Recupero i versori tangenti definiti dai tre punti ( ptCurr|ptNext e ptNext|ptNextNext)
if ( nP == 0) {
vtTanCurr = ptNext - ptCurr ;
vtTanCurr.Normalize() ;
}
else
vtTanCurr = vtTanNext ;
vtTanNext = ptNextNext - ptNext ; vtTanNext.Normalize() ;
// Calcolo il Coseno tra i due versori
double dCos = vtTanCurr * vtTanNext ;
// Se dentro alla tolleranza, allora i punti apparterranno alla stessa curva
if ( dCos > dCosTol) {
// Se devo definire una curva nuova
if ( bNewCurve) {
vvPoints.emplace_back( PNTVECTOR()) ;
vvPoints.back().emplace_back( ptCurr) ;
vvPoints.back().emplace_back( ptNext) ;
bNewCurve = false ;
}
// Aggiungo il punto
vvPoints.back().emplace_back( ptNextNext) ;
}
// Se tratto al di fuori della tolleranza, devo definire una nuova curva
else {
// Se curva nuova, allora è solamente tratto lineare
if ( bNewCurve) {
vvPoints.emplace_back( PNTVECTOR()) ;
vvPoints.back().emplace_back( ptCurr) ;
vvPoints.back().emplace_back( ptNext) ;
}
bNewCurve = true ;
}
}
// Se PolyLine originale chiusa
if ( PL.IsClosed()) {
// Se ho più tratti, potrei riuniore il primo con l'ultimo
if ( int( vvPoints.size()) > 1) {
Point3d& ptCurr = vPoints[int( vPoints.size()) - 2] ;
Point3d& ptNext = vPoints[0] ;
Point3d& ptNextNext = vPoints[1] ;
vtTanCurr = ptNext - ptCurr ; vtTanCurr.Normalize() ;
vtTanNext = ptNextNext - ptNext ; vtTanNext.Normalize() ;
double dCos = vtTanCurr * vtTanNext ;
// Se dentro alla tolleranza
if ( dCos > dCosTol) {
// Recupero la tangenza del tratto finale dell'ultimo tratto
Point3d& ptLast = vvPoints.back()[int( vvPoints.back().size()) - 1] ;
Point3d& ptLastLast = vvPoints.back()[int( vvPoints.back().size()) - 2] ;
Vector3d vtTanLast = ptLast - ptLastLast ; vtTanLast.Normalize() ;
dCos = vtTanLast * vtTanCurr ;
// Se nella tolleranza allora posso allacciare il primo e l'ultimo tratto
if ( dCos > dCosTol) {
for ( int i = bNewCurve ? 1 : 0 ; i < int( vvPoints[0].size()) ; ++ i)
vvPoints.back().emplace_back( vvPoints[0][i]) ;
vvPoints.erase( vvPoints.begin()) ;
}
// Altrimenti sposto il punto d'inizio in ptCurr del primo tratto
else {
PNTVECTOR vPointsFirst ; vPointsFirst.reserve( vvPoints.front().size() + 1) ;
vPointsFirst.emplace_back( ptCurr) ;
for ( const Point3d& pt : vvPoints.front())
vPointsFirst.emplace_back( pt) ;
vvPoints.front() = vPointsFirst ;
}
}
// Se fuori dalla tolleranza, e l'ultimo punto non è già stato aggiunto
else if ( bNewCurve) {
// tratto lineare finale
vvPoints.emplace_back( PNTVECTOR{}) ;
vvPoints.back().emplace_back( ptCurr) ;
vvPoints.back().emplace_back( ptNext) ;
}
}
}
// Se invece PolyLine Aperta
else {
// Se devo creare una curva nuova, aggiungo il tratto finale
if ( bNewCurve) {
vvPoints.emplace_back( PNTVECTOR{}) ;
vvPoints.back().emplace_back( vPoints[int( vPoints.size()) - 2]) ;
vvPoints.back().emplace_back( vPoints[int( vPoints.size()) - 1]) ;
}
}
#if DEBUG_ANG_APPROX
VT.clear() ; VC.clear() ;
for ( auto _v : vvPoints) {
Color _col = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
for ( auto _p : _v) {
IGeoPoint3d* _pt = CreateGeoPoint3d() ;
_pt->Set( _p) ;
VT.emplace_back( _pt) ;
VC.emplace_back( _col) ;
}
}
SaveGeoObj( VT, VC, "C:\\Temp\\GroupPoints.nge") ;
#endif
// Converto i punti ricavati in PolyLine risultati
for ( int i = 0 ; i < int( vvPoints.size()) ; ++ i) {
vPL.emplace_back( PolyLine()) ;
double dPar = -1. ;
for ( int j = 0 ; j < int( vvPoints[i].size()) ; ++ j) {
vPL.back().AddUPoint( ++ dPar, vvPoints[i][j]) ;
}
}
return true ;
}
//-----------------------------------------------------------------------------
// Funzione che approssima la curva di bordo per la costruzione della Bezier Ruled mediante
// Patches di curve di Bezier
static bool
ApproxCurveWithBezier( ICurveComposite* pCrvCompo, double dLinTol, double dAngTol)
{
// Controllo dei parametri
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return false ;
// Recupero la PolyLine associata ( senza alcuna approssimazione)
PolyLine myPL ;
if ( ! pCrvCompo->ApproxWithLines( EPS_SMALL, EPS_ANG_SMALL, ICurve::APL_SPECIAL, myPL))
return false ;
// Approssimo la curva mediante Set di punti considerando la tolleranza angolare
POLYLINEVECTOR vPL ;
if ( ! GetPointSetByAngTol( myPL, dAngTol, vPL))
return false ;
#if DEBUG_BEZIER_INTERP
VT.clear() ; VC.clear() ;
VT.emplace_back( pCrvCompo->Clone()) ;
VC.emplace_back( RED) ;
for ( PolyLine& PL : vPL) {
if ( PL.GetPointNbr() > 1) {
Point3d ptCurr ; PL.GetFirstPoint( ptCurr) ;
IGeoPoint3d* pt = CreateGeoPoint3d() ;
pt->Set( ptCurr) ;
VT.emplace_back( pt) ;
VC.emplace_back( AQUA) ;
PL.GetLastPoint( ptCurr) ;
pt->Set( ptCurr) ;
VT.emplace_back( pt) ;
VC.emplace_back( AQUA) ;
}
}
SaveGeoObj( VT, VC, "C:\\Temp\\AngBorderApprox.nge") ;
VT.clear() ; VC.clear() ;
#endif
// Pulisco la curva originale
pCrvCompo->Clear() ;
// Ogni PolyLine ricavata viene approssimata con un tratto di Bezier
const double MAXLEN = 1.5 ;
for ( const PolyLine& PL : vPL) {
// Se meno di due punti, non la considero ( non dovrebbe mai capitare )
if ( PL.GetPointNbr() < 2)
continue ;
// Recupero i punti
PNTVECTOR vPoints ;
Point3d ptCurr ;
bool bFound = PL.GetFirstPoint( ptCurr) ;
while ( bFound) {
vPoints.emplace_back( ptCurr) ;
bFound = PL.GetNextPoint( ptCurr) ;
}
#if DEBUG_BEZIER_INTERP
Color myCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
for ( int i = 0 ; i < int( vPoints.size()) ; ++ i) {
IGeoPoint3d* pt = CreateGeoPoint3d() ;
pt->Set( vPoints[i]) ;
VT.emplace_back( pt) ;
VC.emplace_back( myCol) ;
}
#endif
// Approssimo con una Bezier
PtrOwner<ICurve> pCrvBz( InterpolatePointSetWithBezier( vPoints, dLinTol, MAXLEN)) ;
if ( IsNull( pCrvBz) || ! pCrvBz->IsValid()) {
LOG_ERROR( GetEGkLogger(), "Error : Interpolating points to bezier curve failed") ;
return false ;
}
#if DEBUG_BEZIER_INTERP
VT.emplace_back( pCrvBz->Clone()) ;
myCol.Set( myCol.GetRed() * .95, myCol.GetGreen() * .95, myCol.GetBlue() * .95) ;
VC.emplace_back( myCol) ;
#endif
// Aggiungo il tratto approssimato alla curva finale complessiva
if ( ! pCrvCompo->AddCurve( Release( pCrvBz)))
return false ;
}
#if DEBUG_BEZIER_INTERP
SaveGeoObj( VT, VC, "C:\\Temp\\InterpolationCurveBezier.nge") ;
#endif
return ( pCrvCompo->IsValid()) ;
}
//-----------------------------------------------------------------------------
//-------------------------------- Analisi Bordi ------------------------------
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Funzione per controllare e sistemare le curve di bordo di una riagata Bezier
static bool
ManageRuledBorders( ICurveComposite* pCompoEdge1, ICurveComposite* pCompoEdge2)
{
// Se curve non valide, errore
if ( pCompoEdge1 == nullptr || ! pCompoEdge1->IsValid() ||
pCompoEdge2 == nullptr || ! pCompoEdge2->IsValid())
return false ;
// Le due curve devono essere entrambe aperte o entrambe chiuse
bool bAllClosed = ( pCompoEdge1->IsClosed() && pCompoEdge2->IsClosed()) ;
bool bAllOpen = ( ! pCompoEdge1->IsClosed() && ! pCompoEdge2->IsClosed()) ;
if ( ! bAllClosed && ! bAllOpen) {
LOG_ERROR( GetEGkLogger(), "Error in Trimming : Mixed Edges") ;
return false ;
}
// Eseguo una copia delle curve composite per non modificare i parametri
PtrOwner<ICurve> pCrvEdge1CL( pCompoEdge1->Clone()) ;
PtrOwner<ICurve> pCrvEdge2CL( pCompoEdge2->Clone()) ;
if ( IsNull( pCrvEdge1CL) || IsNull( pCrvEdge2CL) ||
! pCrvEdge1CL->IsValid() || ! pCrvEdge2CL->IsValid())
return false ;
PtrOwner<ICurveComposite> pMyCompoEdge1( ConvertCurveToComposite( Release( pCrvEdge1CL))) ;
PtrOwner<ICurveComposite> pMyCompoEdge2( ConvertCurveToComposite( Release( pCrvEdge2CL))) ;
if ( IsNull( pMyCompoEdge1) || IsNull( pMyCompoEdge2) ||
! pMyCompoEdge1->IsValid() || ! pMyCompoEdge2->IsValid())
return false ;
// Modifico il punto iniziale o oriento le curve allo stesso modo
// --- Se entrambe aperte
if ( bAllOpen) {
// Recupero il punto iniziale della prima curva
Point3d ptStart1 ; pMyCompoEdge1->GetStartPoint( ptStart1) ;
// Recupero gli estremi della seconda curva
Point3d ptStart2 ; pMyCompoEdge2->GetStartPoint( ptStart2) ;
Point3d ptEnd2 ; pMyCompoEdge2->GetEndPoint( ptEnd2) ;
// Se necessario inverto la seconda curva
if ( SqDist( ptStart1, ptEnd2) < SqDist( ptStart1, ptStart2))
pMyCompoEdge2->Invert() ;
}
// --- Se entrambe chiuse
else {
// Modifico il punto iniziale della prima curva a metà del suo tratto più lungo
double dMaxLen = - INFINITO ;
int nCrvInd = 0 ;
for ( int nCrv = 0 ; nCrv < pMyCompoEdge1->GetCurveCount() ; ++ nCrv) {
const ICurve* pCurve = pMyCompoEdge1->GetCurve( nCrv) ;
if ( pCurve == nullptr || ! pCurve->IsValid())
return false ;
double dLen = 0. ;
pCurve->GetLength( dLen) ;
if ( dLen > dMaxLen) {
dMaxLen = dLen ;
nCrvInd = nCrv ;
}
}
pMyCompoEdge1->ChangeStartPoint( nCrvInd + 0.5) ;
// Recupero il punto iniziale della prima curva
Point3d ptStart1 ; pMyCompoEdge1->GetStartPoint( ptStart1) ;
// Recupero il punto più vicino sulla seconda curva
double dUStart = 0. ;
int nFlag = 0 ;
DistPointCurve( ptStart1, *pMyCompoEdge2).GetParamAtMinDistPoint( 0., dUStart, nFlag) ;
pMyCompoEdge2->ChangeStartPoint( dUStart) ;
// Verifico che le tangenti iniziali siano concordi
Vector3d vtStart1 ; pMyCompoEdge1->GetStartDir( vtStart1) ;
Vector3d vtStart2 ; pMyCompoEdge2->GetStartDir( vtStart2) ;
if ( vtStart1 * vtStart2 < - EPS_SMALL)
pMyCompoEdge2->Invert() ;
}
// Sostiuisco i risultati
pCompoEdge1->Clear() ; pCompoEdge1->CopyFrom( pMyCompoEdge1) ;
pCompoEdge2->Clear() ; pCompoEdge2->CopyFrom( pMyCompoEdge2) ;
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per determinare la normale di una superficie generica in un punto
static bool
GetNormalAtPoint( const ISurf* pSurf, const Point3d& pt, Vector3d& vtN)
{
// Verifico che le due superfici siano valide
if ( pSurf == nullptr || ! pSurf->IsValid())
return false ;
const double dMinLen = 20. * EPS_SMALL ;
const double dMinArea = dMinLen * dMinLen ;
// Se è Trimesh, recupero la normale del triangolo più vicino al punto scelto
if ( pSurf->GetType() == SRF_TRIMESH) {
const ISurfTriMesh* pStm = GetSurfTriMesh( pSurf) ;
if ( pStm == nullptr || ! pStm->IsValid())
return false ;
int nTria = 0 ;
DistPointSurfTm( pt, *pStm).GetMinDistTriaIndex( nTria) ;
Triangle3d Tria ;
if ( ! pStm->GetTriangle( nTria, Tria))
return false ;
// se il triangolo è rappresentativo, recupero la sua normale
if ( Tria.GetArea() > dMinArea)
vtN = Tria.GetN() ;
else {
BBox3d BBoxPt ;
BBoxPt.Add( pt) ;
BBoxPt.Expand( dMinLen + 2. * EPS_SMALL) ;
INTVECTOR vT ;
pStm->GetAllTriaOverlapBox( BBoxPt, vT) ;
int nBestTria = -1 ;
double dMaxArea = dMinArea ;
for ( const int& nT : vT) {
if ( pStm->GetTriangle( nT, Tria)) {
double dCurrArea = Tria.GetArea() ;
if ( dCurrArea > dMaxArea) {
dMaxArea = dCurrArea ;
nBestTria = nT ;
}
}
}
if ( nBestTria == -1) // recupero lo stesso il più vicino ( calcolato prima)
nBestTria = nTria ;
if ( ! pStm->GetTriangle( nBestTria, Tria))
return false ;
vtN = Tria.GetN() ;
}
}
// Se è Bezier, la normale è calcolata automaticamente
else if ( pSurf->GetType() == SRF_BEZIER) {
const ISurfBezier* pSbz = GetSurfBezier( pSurf) ;
if ( pSbz == nullptr || ! pSbz->IsValid())
return false ;
if ( ! DistPointSurfBz( pt, *pSbz).GetNorm( vtN))
return false ;
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per Splittare una Patch con un'altra
static bool
SplitPatchWithPatch( SurfPatches& SurfPatchA, SurfPatches& SurfPatchB, double dLinTol)
{
// Definisco la tolleranza di parametro
const double TOL_LINE_PARAM = 10. * EPS_SMALL ; // <-- euristica, modificabile
// Scorro le Patch della superficie A
for ( int nPatchA = 0 ; nPatchA < int( SurfPatchA.CompoPathces.size()) ; ++ nPatchA) {
// Recupero la PatchA
CurveComposite& PatchA = SurfPatchA.CompoPathces[nPatchA] ;
Point3d& ptStartA = SurfPatchA.vPatches[nPatchA].ptStart ;
Point3d& ptEndA = SurfPatchA.vPatches[nPatchA].ptEnd ;
// Scorro le Patch della supericie B
for ( int nPatchB = 0 ; nPatchB < int( SurfPatchB.CompoPathces.size()) ; ++ nPatchB) {
// Recupero la PatchB
CurveComposite& PatchB = SurfPatchB.CompoPathces[nPatchB] ;
Point3d& ptStartB = SurfPatchB.vPatches[nPatchB].ptStart ;
Point3d& ptEndB = SurfPatchB.vPatches[nPatchB].ptEnd ;
// Verifico se gli estremi giaciono sulle linee
double dDist = 0. ;
double dPar = 0., dParS = 0., dParE = 0. ;
int nFlag = 0 ;
bool bSplit = false ;
Point3d ptInters ;
// Estremi B su PatchA ( sono tutti tratti lineari, quindi nel 3d va bene)
DistPointCurve DLL0( ptStartB, PatchA) ;
bSplit = ( DLL0.GetDist( dDist) && dDist < dLinTol &&
DLL0.GetParamAtMinDistPoint( 0., dPar, nFlag) &&
PatchA.GetDomain( dParS, dParE) &&
dParS + TOL_LINE_PARAM < dPar && dPar < dParE - TOL_LINE_PARAM) ;
if ( ! bSplit) {
DistPointCurve DLL1( ptEndB, PatchA) ;
bSplit = ( DLL1.GetDist( dDist) && dDist < dLinTol &&
DLL1.GetParamAtMinDistPoint( 0., dPar, nFlag) &&
PatchA.GetDomain( dParS, dParE) &&
dParS + TOL_LINE_PARAM < dPar && dPar < dParE - TOL_LINE_PARAM) ;
}
// Se Split della PatchA richiesto
if ( bSplit) {
// Split della Patch
PatchA.GetPointD1D2( dPar, ICurve::FROM_MINUS, ptInters) ;
SimplePatch NextPatch( ptInters, ptEndA, 0, false) ;
SurfPatchA.vPatches.insert( SurfPatchA.vPatches.begin() + nPatchA + 1, NextPatch) ;
ptEndA = ptInters ;
// Split della curva composita associata
CurveComposite* pCompoAfter( PatchA.Clone()) ;
PatchA.TrimEndAtParam( dPar) ;
pCompoAfter->TrimStartAtParam( dPar) ;
SurfPatchA.CompoPathces.insert( SurfPatchA.CompoPathces.begin() + nPatchA + 1, *pCompoAfter) ;
// Aggiorno i contatori
-- nPatchA ;
break ;
}
// Estremi Curr su LineNext ( sono tutti tratti lineari, quindi nel 3d va bene)
DistPointCurve DLL2( ptStartA, PatchB) ;
bSplit = ( DLL2.GetDist( dDist) && dDist < dLinTol &&
DLL2.GetParamAtMinDistPoint( 0., dPar, nFlag) &&
PatchB.GetDomain( dParS, dParE) &&
dParS + TOL_LINE_PARAM < dPar && dPar < dParE - TOL_LINE_PARAM) ;
if ( ! bSplit) {
DistPointCurve DLL3( ptEndA, PatchB) ;
bSplit = ( DLL3.GetDist( dDist) && dDist < dLinTol &&
DLL3.GetParamAtMinDistPoint( 0., dPar, nFlag) &&
PatchB.GetDomain( dParS, dParE) &&
dParS + TOL_LINE_PARAM < dPar && dPar < dParE - TOL_LINE_PARAM) ;
}
// Se Split della PatchB richiesto
if ( bSplit) {
// Split della Patch
PatchB.GetPointD1D2( dPar, ICurve::FROM_MINUS, ptInters) ;
SimplePatch NextPatch( ptInters, ptEndB, 0, false) ;
SurfPatchB.vPatches.insert( SurfPatchB.vPatches.begin() + nPatchB + 1, NextPatch) ;
ptEndB = ptInters ;
// Split della curva composita associata
CurveComposite* pCompoAfter( PatchB.Clone()) ;
PatchB.TrimEndAtParam( dPar) ;
pCompoAfter->TrimStartAtParam( dPar) ;
SurfPatchB.CompoPathces.insert( SurfPatchB.CompoPathces.begin() + nPatchB + 1, *pCompoAfter) ;
// Aggiorno i contatori
-- nPatchB ;
}
}
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per ottenere le Patch dei bordi di una superficie
static bool
CalcPatches( const POLYLINEVECTOR& vPLBorders, double dAngTol, POLYLINEMATRIX& matPLPatches)
{
// Ogni PolyLine di bordo viene vista come un insieme di Patches
matPLPatches.reserve( vPLBorders.size()) ;
for ( const PolyLine& PL : vPLBorders) {
// Approssimo mediante tolleranza angolare ricavando l'insieme delle Patches
matPLPatches.emplace_back( POLYLINEVECTOR{}) ;
if ( ! GetPointSetByAngTol( PL, dAngTol, matPLPatches.back()))
return false ;
// Trasferisco le TempProps
for ( PolyLine newPL : matPLPatches.back())
newPL.SetTempProp( 0, PL.GetTempProp( 0)) ;
}
return true ;
}
//-----------------------------------------------------------------------------
// Funzione per scremare le curve di Bordo tenendo solo i tratti utili concatenabili
static bool
ManagePatches( const POLYLINEVECTOR& vPLBorders, double dLinTol, double dAngTol,
ICRVCOMPOPOVECTOR& vCompoResult)
{
// Se non ho Polyline non faccio nulla
if ( vPLBorders.empty())
return true ;
vCompoResult.clear() ;
// Approssimo le curve
// NB. Per Patch si intende un tratto di PolyLine dove la tangenza di ogni punto con i suoi 2 successivi
// rimane all'interno della tolleranza angolare definita
// Ogni curva di bordo viene quindi vista come un insieme di Patches
POLYLINEMATRIX matPLPatches ;
if ( ! CalcPatches( vPLBorders, dAngTol, matPLPatches))
return false ;
// Tengo anche la curva composita rispettiva per ogni Patch ( serve più avanti) [*]
COMPOMATRIX matCompoPatches ; matCompoPatches.reserve( vPLBorders.size()) ;
for ( const POLYLINEVECTOR& PLBorder : matPLPatches) {
matCompoPatches.emplace_back( COMPOVECTOR{}) ;
for ( const PolyLine& PLPatch : PLBorder) {
matCompoPatches.back().emplace_back( CurveComposite()) ;
matCompoPatches.back().back().FromPolyLine( PLPatch) ;
}
}
// Ogni curva Patch diventa un insieme di tratti attivi definiti dagli estremi calcolati
// NB. In questo modo si salvano solo gli estremi della curva Patch, mentre la sua geometria
// è rimasta memorizzata in precedenza [*]
// Ogni bordo viene quindi visto come un insieme di Patch semplici ( per adesso tutte attive)
SimpleBorderVector vvSimpleBorder ; vvSimpleBorder.reserve( matPLPatches.size()) ;
for ( int i = 0 ; i < int( matPLPatches.size()) ; ++ i) {
vvSimpleBorder.emplace_back( SimpleBorder()) ;
for ( int j = 0 ; j < int( matPLPatches[i].size()) ; ++ j) {
Point3d ptS ; matPLPatches[i][j].GetFirstPoint( ptS) ;
Point3d ptE ; matPLPatches[i][j].GetLastPoint( ptE) ;
vvSimpleBorder.back().emplace_back( ptS, ptE, i, false) ;
}
}
#if DEBUG_CHAIN_CURVES
VC.clear() ; VT.clear() ;
for ( int i = 0 ; i < int( vvSimpleBorder.size()) ; ++ i) {
for ( int j = 0 ; j < int( vvSimpleBorder[i].size()) ; ++ j) {
VT.emplace_back( matCompoPatches[i][j].Clone()) ;
VC.emplace_back( RED) ;
IGeoPoint3d* ptS = CreateGeoPoint3d() ;
ptS->Set( vvSimpleBorder[i][j].ptStart) ;
VT.emplace_back( ptS) ;
VC.emplace_back( AQUA) ;
IGeoPoint3d* ptE = CreateGeoPoint3d() ;
ptE->Set( vvSimpleBorder[i][j].ptEnd) ;
VT.emplace_back( ptE) ;
VC.emplace_back( AQUA) ;
}
}
SaveGeoObj( VT, VC, "C:\\Temp\\EdgesAndPoints.nge") ;
#endif
// In generale se sono state selezionate più superfici, non è garantito che tutti gli estremi
// delle Patch coicidano solo con altri estremi di altre Patches ( può capitare che un estremo di
// una Patch cada ad esempio a metà di un'altra Patch e non nei suoi estremi )
// Soluzione : si spezzano le Patch ulteriormente in modo che ogni estremo di patch sia o nell'intorno
// di un altro estremo di patch o isolato ( ad esempio nei bordi più esterni )
const double TOL_LINE_PARAM = 10. * EPS_SMALL ; // <-- eursitica, modificabile
for ( int nCurrCrv = 0 ; nCurrCrv < int( vvSimpleBorder.size()) - 1 ; ++ nCurrCrv) {
// Recupero la curva corrente
SimpleBorder& CurrCurve = vvSimpleBorder[nCurrCrv] ;
// Scorro i suoi Edges
for ( int nCurrEdge = 0 ; nCurrEdge < int( CurrCurve.size()) ; ++ nCurrEdge) {
// Recupero il tratto di curva corrente
CurveComposite& CurrCompo = matCompoPatches[nCurrCrv][nCurrEdge] ;
// Scorro le curve successive
for ( int nNextCrv = nCurrCrv + 1 ; nNextCrv < int( vvSimpleBorder.size()) ; ++ nNextCrv) {
// Recupero la curva successiva
SimpleBorder& NextCurve = vvSimpleBorder[nNextCrv] ;
// Scorro i suoi Edges
for ( int nNextEdge = 0 ; nNextEdge < int( NextCurve.size()) ; ++ nNextEdge) {
// Se appartiene allo stesso bordo, passo alla seguente
if ( NextCurve[nNextEdge].nBorder == CurrCurve[nCurrEdge].nBorder)
continue ;
// Recupero il tratto di curva corrente
CurveComposite& NextCompo = matCompoPatches[nNextCrv][nNextEdge] ;
// Verifico se gli estremi giaciono sulle linee
double dDist = 0. ;
double dPar = 0., dParS = 0., dParE = 0. ;
int nFlag = 0 ;
bool bSplit = false ;
Point3d ptInters ;
// Estremi Next su LineCurr ( sono tutti tratti lineari, quindi nel 3d va bene)
DistPointCurve DLL0( NextCurve[nNextEdge].ptStart, CurrCompo) ;
bSplit = ( DLL0.GetDist( dDist) && dDist < dLinTol &&
DLL0.GetParamAtMinDistPoint( 0., dPar, nFlag) &&
CurrCompo.GetDomain( dParS, dParE) &&
dParS + TOL_LINE_PARAM < dPar && dPar < dParE - TOL_LINE_PARAM) ;
if ( ! bSplit) {
DistPointCurve DLL1( NextCurve[nNextEdge].ptEnd, CurrCompo) ;
bSplit = ( DLL1.GetDist( dDist) && dDist < dLinTol &&
DLL1.GetParamAtMinDistPoint( 0., dPar, nFlag) &&
CurrCompo.GetDomain( dParS, dParE) &&
dParS + TOL_LINE_PARAM < dPar && dPar < dParE - TOL_LINE_PARAM) ;
}
// Split dell'Edge se richiesto
if ( bSplit) {
#if DEBUG_CHAIN_CURVES
VT.clear() ; VC.clear() ;
VT.emplace_back( NextCompo.Clone()) ;
VC.emplace_back( ORANGE) ;
VT.emplace_back( CurrCompo.Clone()) ;
VC.emplace_back( LIME) ;
SaveGeoObj( VT, VC, "C:\\Temp\\LineIntersection.nge") ;
#endif
// Aggiorno gli Edges
CurrCompo.GetPointD1D2( dPar, ICurve::FROM_MINUS, ptInters) ;
SimplePatch NextEdge( ptInters, CurrCurve[nCurrEdge].ptEnd,
CurrCurve[nCurrEdge].nBorder, false) ;
CurrCurve.insert( CurrCurve.begin() + nCurrEdge + 1, NextEdge) ;
CurrCurve[nCurrEdge].ptEnd = ptInters ;
// Aggiorno le Curve
CurveComposite* pCompoAfter( CurrCompo.Clone()) ;
CurrCompo.TrimEndAtParam( dPar) ;
pCompoAfter->TrimStartAtParam( dPar) ;
matCompoPatches[nCurrCrv].insert( matCompoPatches[nCurrCrv].begin() + nCurrEdge + 1, *pCompoAfter) ;
// Aggiorno i contatori
-- nCurrEdge ;
nNextCrv = int( vvSimpleBorder.size()) ;
break ;
}
// Estremi Curr su LineNext ( sono tutti tratti lineari, quindi nel 3d va bene)
DistPointCurve DLL2( CurrCurve[nCurrEdge].ptStart, NextCompo) ;
bSplit = ( DLL2.GetDist( dDist) && dDist < dLinTol &&
DLL2.GetParamAtMinDistPoint( 0., dPar, nFlag) &&
NextCompo.GetDomain( dParS, dParE) &&
dParS + TOL_LINE_PARAM < dPar && dPar < dParE - TOL_LINE_PARAM) ;
if ( ! bSplit) {
DistPointCurve DLL3( CurrCurve[nCurrEdge].ptEnd, NextCompo) ;
bSplit = ( DLL3.GetDist( dDist) && dDist < dLinTol &&
DLL3.GetParamAtMinDistPoint( 0., dPar, nFlag) &&
NextCompo.GetDomain( dParS, dParE) &&
dParS + TOL_LINE_PARAM < dPar && dPar < dParE - TOL_LINE_PARAM) ;
}
// Split dell'Edge se richiesto
if ( bSplit) {
#if DEBUG_CHAIN_CURVES
VT.clear() ; VC.clear() ;
VT.emplace_back( NextCompo.Clone()) ;
VC.emplace_back( ORANGE) ;
VT.emplace_back( CurrCompo.Clone()) ;
VC.emplace_back( LIME) ;
SaveGeoObj( VT, VC, "C:\\Temp\\LineIntersection.nge") ;
#endif
// Aggiorno gli Edges
NextCompo.GetPointD1D2( dPar, ICurve::FROM_MINUS, ptInters) ;
SimplePatch NextEdge( ptInters, NextCurve[nNextEdge].ptEnd,
NextCurve[nNextEdge].nBorder, false) ;
NextCurve.insert( NextCurve.begin() + nNextEdge + 1, NextEdge) ;
NextCurve[nNextEdge].ptEnd = ptInters ;
// Aggiorno le curve
CurveComposite* pCompoAfter( NextCompo.Clone()) ;
NextCompo.TrimEndAtParam( dPar) ;
pCompoAfter->TrimStartAtParam( dPar) ;
matCompoPatches[nNextCrv].insert( matCompoPatches[nNextCrv].begin() + nNextEdge + 1, *pCompoAfter) ;
// Aggiorno i contatori
-- nNextEdge ;
}
}
}
}
}
#if DEBUG_CHAIN_CURVES
VC.clear() ; VT.clear() ;
for ( int i = 0 ; i < int( vvSimpleBorder.size()) ; ++ i) {
for ( int j = 0 ; j < int( vvSimpleBorder[i].size()) ; ++ j) {
VT.emplace_back( matCompoPatches[i][j].Clone()) ;
VC.emplace_back( RED) ;
IGeoPoint3d* pt = CreateGeoPoint3d() ;
pt->Set( vvSimpleBorder[i][j].ptStart) ;
VT.emplace_back( pt) ;
VC.emplace_back( AQUA) ;
pt = CreateGeoPoint3d() ;
pt->Set( vvSimpleBorder[i][j].ptEnd) ;
VT.emplace_back( pt) ;
VC.emplace_back( AQUA) ;
}
}
SaveGeoObj( VT, VC, "C:\\Temp\\BordersWithOverlaps.nge") ;
#endif
// Si eliminano ora tutte le Patch che si sovrappongono, in modo da ottenere solo un
// le Patch che rappresentano il bordo esterno
const double MAXPOINT = 10 ;
for ( int nCurrCrv = 0 ; nCurrCrv < int( vvSimpleBorder.size()) - 1 ; ++ nCurrCrv) {
// Recupero la curva corrente
SimpleBorder& CurrCurve = vvSimpleBorder[nCurrCrv] ;
// Scorro i suoi Edges
for ( int nCurrEdge = 0 ; nCurrEdge < int( CurrCurve.size()) ; ++ nCurrEdge) {
// Se Edge cancellato, passo al successivo
if ( CurrCurve[nCurrEdge].bErase)
continue ;
// Recupero i due estremi dell'Edge
Point3d& ptCurrStart = CurrCurve[nCurrEdge].ptStart ;
Point3d& ptCurrEnd = CurrCurve[nCurrEdge].ptEnd ;
// Scorro le curve successive
for ( int nNextCrv = nCurrCrv + 1 ; nNextCrv < int( vvSimpleBorder.size()) ; ++ nNextCrv) {
// Recupero la curva successiva
SimpleBorder& NextCurve = vvSimpleBorder[nNextCrv] ;
// Scorro i suoi Edges
for ( int nNextEdge = 0 ; nNextEdge < int( NextCurve.size()) ; ++ nNextEdge) {
// Se Edge cancellato, passo al successivo
#if 0
// Se pezze si superficie piccolissime, si rischia di eliminare tutti i
// tratti Next con il primo tratto Curr e lasciare poi il Secondo Curr senza
// elementi da eliminare ( TrimTractor.nge)
if ( NextCurve[nNextEdge].bErase)
continue ;
#endif
// Recupero i due estremi di riferimento
Point3d& ptNextStart = NextCurve[nNextEdge].ptStart ;
Point3d& ptNextEnd = NextCurve[nNextEdge].ptEnd ;
// Controllo se i due estremi coincidono
if ( ( AreSamePointEpsilon( ptCurrStart, ptNextStart, dLinTol) &&
AreSamePointEpsilon( ptCurrEnd, ptNextEnd, dLinTol)) ||
( AreSamePointEpsilon( ptCurrStart, ptNextEnd, dLinTol) &&
AreSamePointEpsilon( ptCurrEnd, ptNextStart, dLinTol))) {
// Controllo che i punti coincidano
CurveComposite* pCompoCurr = &matCompoPatches[nCurrCrv][nCurrEdge] ;
CurveComposite* pCompoNext = &matCompoPatches[nNextCrv][nNextEdge] ;
if ( pCompoCurr == nullptr || pCompoNext == nullptr)
return false ;
double dLenCurr ; pCompoCurr->GetLength( dLenCurr) ;
bool bErase = true ;
for ( int nP = 1 ; bErase && nP <= MAXPOINT ; ++ nP) {
double dPar = 0. ;
pCompoCurr->GetParamAtLength( ( dLenCurr / MAXPOINT) * nP, dPar) ;
Point3d ptCurr ;
pCompoCurr->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptCurr) ;
double dSqDist = 0. ;
DistPointCurve( ptCurr, *pCompoNext).GetSqDist( dSqDist) ;
bErase = ( dSqDist < dLinTol * dLinTol + SQ_EPS_SMALL) ;
}
// Disabilito i rispettivi Edges se necessario
if ( bErase) {
CurrCurve[nCurrEdge].bErase = true ;
NextCurve[nNextEdge].bErase = true ;
}
}
}
}
}
}
// Dalle PolyLine recupero delle curve composite ( quindi anch'esse come insieme di tratti linari)
ICRVCOMPOPOVECTOR vCompoPatches ; vCompoPatches.reserve( vvSimpleBorder.size()) ;
for ( const PolyLine& PL : vPLBorders) {
if ( ! vCompoPatches.emplace_back( CreateCurveComposite()) ||
! vCompoPatches.back()->FromPolyLine( PL))
return false ;
vCompoPatches.back()->SetTempProp( PL.GetTempProp( 0), 0) ;
}
// Recupero solo i sottotratti di curva validi ( quindi che non fanno overlap tra loro)
for ( int nCrv = 0 ; nCrv < int( vvSimpleBorder.size()) ; ++ nCrv) {
// Recupero la curva
SimpleBorder& CrvEdge = vvSimpleBorder[nCrv] ;
// Scorro i suoi edges
for ( int nEdge = 0 ; nEdge < int( CrvEdge.size()) ; ++ nEdge) {
// Se edge non attivo, passo al successivo
if ( CrvEdge[nEdge].bErase)
continue ;
// Se punto iniziale finale uguali
// [ Se pezze di superficie piccolissime, si rischia di eliminare tutti i
// tratti Next con il primo tratto Curr e lasciare poi il Secondo Curr senza
// elementi da eliminare ( TrimTractor.nge) ]
if ( AreSamePointApprox( CrvEdge[nEdge].ptStart, CrvEdge[nEdge].ptEnd))
vCompoResult.emplace_back( Release( vCompoPatches[nCrv])) ;
else {
// Recupero il tratto di curva e lo memorizzo
double dUStart = 0., dUEnd = 0. ;
vCompoPatches[nCrv]->GetParamAtPoint( CrvEdge[nEdge].ptStart, dUStart, dLinTol) ;
vCompoPatches[nCrv]->GetParamAtPoint( CrvEdge[nEdge].ptEnd, dUEnd, dLinTol) ;
vCompoResult.emplace_back( ConvertCurveToComposite( vCompoPatches[nCrv]->CopyParamRange( dUStart, dUEnd))) ;
vCompoResult.back()->SetTempProp( vCompoPatches[nCrv]->GetTempProp( 0), 0) ;
}
}
}
// Conservo solo le curve valide
for ( int nCrv = 0 ; nCrv < int( vCompoResult.size()) ; ++ nCrv) {
if ( IsNull( vCompoResult[nCrv]) || ! vCompoResult[nCrv]->IsValid()) {
vCompoResult.erase( vCompoResult.begin() + nCrv) ;
-- nCrv ;
}
}
#if DEBUG_CHAIN_CURVES // Debug per le Patch risultanti
VT.clear() ; VC.clear() ;
for ( int i = 0 ; i < int( vCompoResult.size()) ; ++ i) {
VT.emplace_back( vCompoResult[i]->Clone()) ;
VC.emplace_back( ORANGE) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\FinalChainedBorders.nge") ;
#endif
return true ;
}
//-----------------------------------------------------------------------------
// Funzione per concatenare nello spazio 3d le Curve Patches.
// NB. Tutte le vCompoPathes sono formate da tratti lineari.
static bool
ChainCompoPatches( ICRVCOMPOPOVECTOR& vCompoPatches, double dChainTol,
ICRVCOMPOPOVECTOR& vCompoChained)
{
// Controllo dei parametri
if ( vCompoPatches.empty())
return false ;
vCompoChained.clear() ;
// Controllo la validità delle curve
for ( const ICurveComposite* pCrvCompo : vCompoPatches) {
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return false ;
}
// La concatenazione parte dalla curva più lunga
double dMaxLen = - INFINITO ;
int nInd = 0 ;
for ( int i = 0 ; i < int( vCompoPatches.size()) ; ++ i) {
double dLen = 0. ;
vCompoPatches[i]->GetLength( dLen) ;
if ( dLen > dMaxLen) {
dMaxLen = dLen ;
nInd = i ;
}
}
swap( vCompoPatches[0], vCompoPatches[nInd]) ;
// [ TODO : Algoritmo migliorabile nei controlli ]
// Scorro le curve
vCompoChained.reserve( vCompoPatches.size()) ;
BOOLVECTOR vbCrvChained( vCompoPatches.size(), false) ;
for ( int nCurrCrv = 0 ; nCurrCrv < int( vCompoPatches.size()) ; ++ nCurrCrv) {
// Se curva già concatenata, passo alla successiva ( no biforcazioni ammesse -> errore )
if ( vbCrvChained[nCurrCrv])
continue ;
// Definisco una nuova curva di concatenazione e recupero il suo estremo finale
Point3d ptEnd ;
if ( ! vCompoChained.emplace_back( CloneCurveComposite( vCompoPatches[nCurrCrv])) ||
! vCompoChained.back()->GetEndPoint( ptEnd))
return false ;
// Trasferisco le TempProps alle sottocurve
for ( int nU = 0 ; nU < vCompoChained.back()->GetCurveCount() ; ++ nU)
vCompoChained.back()->SetCurveTempProp( nU, vCompoPatches[nCurrCrv]->GetTempProp( 0), 0) ;
// Cerco tra le altre curve disponibili una candidata alla concatenazione
for ( int nNextCrv = 0 ; nNextCrv < int( vCompoPatches.size()) ; ++ nNextCrv) {
if ( nNextCrv == nCurrCrv || vbCrvChained[nNextCrv])
continue ;
// Recupero i suoi estremi [ sono tratti lineari, la ricerca è immediata ]
Point3d ptStartN ; vCompoPatches[nNextCrv]->GetStartPoint( ptStartN) ;
Point3d ptEndN ; vCompoPatches[nNextCrv]->GetEndPoint( ptEndN) ;
// Se estremi distanti, passo alla successiva
bool bChain = AreSamePointEpsilon( ptEnd, ptStartN, dChainTol) ;
bool bChainInv = ( ( ! bChain) && AreSamePointEpsilon( ptEnd, ptEndN, dChainTol)) ;
if ( ! bChain && ! bChainInv)
continue ;
// Recupero la lunghezza della curva
double dLenN = 0. ; vCompoPatches[nNextCrv]->GetLength( dLenN) ;
// Se la lunghezza della curva è più piccola della tolleranza
if ( dLenN < dChainTol + EPS_ZERO) {
// La curva corrente non viene aggiunta, ma viene modificato l'estremo finale corrente
// nel punto medio
vCompoChained.back()->ModifyEnd( Media( ptEndN, ptEnd)) ;
}
// Se la lunghezza è maggiore della tolleranza
else {
// Recupero la curva successiva
PtrOwner<ICurveComposite> pCrv( CloneCurveComposite( vCompoPatches[nNextCrv])) ;
if ( IsNull( pCrv) || ! pCrv->IsValid())
return false ;
// Se necessario inverto ( potrebbe capitare per triangoli male orientati)
if ( bChainInv)
pCrv->Invert() ;
// Trasferisco le TempProps alle sottocurve
for ( int nU = 0 ; nU < pCrv->GetCurveCount() ; ++ nU)
pCrv->SetCurveTempProp( nU, pCrv->GetTempProp( 0), 0) ;
// Concateno
if ( ! vCompoChained.back()->AddCurve( pCrv->Clone(), true, dChainTol))
return false ;
}
// Aggiornamento dei parametri
vbCrvChained[nNextCrv] = true ; // curva in una concatenazione
nNextCrv = 0 ; // reset contatore per curva next
if ( ! vCompoChained.back()->GetEndPoint( ptEnd)) // aggiornamento punto finale della concatenazione
return false ;
}
}
// Verifico la validità delle curve ottenute
for ( int i = 0 ; i < int( vCompoChained.size()) ; ++ i) {
if ( IsNull( vCompoChained[i]) || ! vCompoChained[i]->IsValid())
return false ;
// Se curva al di sotto della tolleranza, la scarto
// ( Capita se ci sono facce/superfici molto strette. La concatenazione chiude in automatico
// la curva complessiva isolando quindi queste entità)
double dLen = 0. ;
if ( ! vCompoChained[i]->GetLength( dLen) || dLen < dChainTol) {
vCompoChained.erase( vCompoChained.begin() + i) ;
-- i ;
}
}
#if DEBUG_CHAIN_CURVES // Debug curve concatenate grezze
VT.clear() ; VC.clear() ;
for ( const ICurveComposite* pCompo : vCompoChained) {
VT.emplace_back( pCompo->Clone()) ;
VC.emplace_back( Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.)) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\ChainedCurves.nge") ;
#endif
return true ;
}
//-----------------------------------------------------------------------------
// Funzione che restituisce una prima semplificazione e concatenazione delle curve
// di bordi definiti mediante PolyLines
static bool
GetRawEdges( const POLYLINEVECTOR& vPLBorders, double dLinTol, double dAngTol,
ICRVCOMPOPOVECTOR& vCompoChained)
{
// Se non o curve di bordo, allora non faccio nulla
if ( vPLBorders.empty())
return true ;
vCompoChained.clear() ;
// Recupero le curve di Bordo che non effettuano Overlap tra loro ( sempre solo tratti lineari)
ICRVCOMPOPOVECTOR vCompoPatches ;
if ( ! ManagePatches( vPLBorders, dLinTol, dAngTol, vCompoPatches))
return false ;
// Concateno le curve risultanti
const double CHAIN_TOL = 50. * EPS_SMALL ;
if ( ! ChainCompoPatches( vCompoPatches, CHAIN_TOL, vCompoChained))
return false ;
// Se le curve risultano aperte con estremi entro la tolleranza, le chiudo
for ( int i = 0 ; i < int( vCompoChained.size()) ; ++ i) {
if ( vCompoChained[i] == nullptr || ! vCompoChained[i]->IsValid())
return false ;
Point3d ptS ; vCompoChained[i]->GetStartPoint( ptS) ;
Point3d ptE ; vCompoChained[i]->GetEndPoint( ptE) ;
if ( AreSamePointEpsilon( ptS, ptE, dLinTol)) {
vCompoChained[i]->Close() ;
// Riporto la Temp Prop
int nTmpProp0 = vCompoChained[i]->GetFirstCurve()->GetTempProp( 0) ;
vCompoChained[i]->SetCurveTempProp( vCompoChained[i]->GetCurveCount() - 1, nTmpProp0, 0) ;
}
}
return true ;
}
//-----------------------------------------------------------------------------
// Funzione per calcolare le Edge Curves per la creazione della superficie di Bezier Ruled
// mediante spessore e tolleranza associata
static bool
BreakCompoPathces( ICRVCOMPOPOVECTOR& vCompoChained, double dLinTol, double dAngTol,
double dThick, double dThickTol)
{
// Se non ho curve, non faccio nulla
if ( vCompoChained.empty())
return true ;
const double ANG_SPLIT = 65. ;
// Scorro le curve
ICRVCOMPOPOVECTOR vCrvResult ;
for ( const ICurveComposite* pCompoChained : vCompoChained) {
// Verifico la sua validità
if ( pCompoChained == nullptr || ! pCompoChained->IsValid())
return false ;
// Recupero la PolyLine associata ( senza alcuna approssimazione)
PolyLine myPL ;
if ( ! pCompoChained->ApproxWithLines( EPS_SMALL, EPS_ANG_SMALL, ICurve::APL_SPECIAL, myPL))
return false ;
// Approssimo la curva mediante Set di punti considerando la tolleranza angolare
POLYLINEVECTOR vPL ;
if ( ! GetPointSetByAngTol( myPL, ANG_SPLIT, vPL))
return false ;
// Scorro le PolyLine ricavate e recupero i punti di Split ( tratti da rimuovere)
BIPNTVECTOR vBiPntSplit ; vBiPntSplit.reserve( 2) ;
for ( const PolyLine& PL : vPL) {
double dLen ; PL.GetLength( dLen) ;
if ( abs( dLen - dThick) < dThickTol) {
Point3d ptStart ; PL.GetFirstPoint( ptStart) ;
Point3d ptEnd ; PL.GetLastPoint( ptEnd) ;
vBiPntSplit.emplace_back( make_pair( ptStart, ptEnd)) ;
}
}
// Se non ho ottenuto esattamente due tratti, non analizzo più la curva corrente
if ( int( vBiPntSplit.size()) != 2) {
LOG_INFO( GetEGkLogger(), "Warning in Trimming : Detected more Curves by Thick values") ;
break ; // lascio la curva invariata
}
if ( ! vCrvResult.emplace_back( CloneCurveComposite( pCompoChained)))
return false ;
double dU0 = 0., dU1 = 0. ;
vCrvResult.back()->GetParamAtPoint( vBiPntSplit[0].second, dU0) ;
vCrvResult.back()->ChangeStartPoint( dU0) ;
vCrvResult.back()->GetParamAtPoint( vBiPntSplit[1].first, dU1) ;
vCrvResult.back().Set( ConvertCurveToComposite( vCrvResult.back()->CopyParamRange( 0., dU1))) ;
if ( ! vCrvResult.emplace_back( CloneCurveComposite( pCompoChained)))
return false ;
vCrvResult.back()->ChangeStartPoint( dU0) ;
vCrvResult.back()->GetParamAtPoint( vBiPntSplit[1].second, dU0) ;
vCrvResult.back()->GetParamAtPoint( vBiPntSplit[0].first, dU1) ;
vCrvResult.back().Set( ConvertCurveToComposite( vCrvResult.back()->CopyParamRange( dU0, dU1))) ;
}
swap( vCrvResult, vCompoChained) ;
return true ;
}
//-----------------------------------------------------------------------------
// Funzione per calcolare le Edge Curves per la creazione della superficie di Bezier Ruled
// mediante punti di rottura
static bool
BreakCompoPathces( ICRVCOMPOPOVECTOR& vCompoChained, double dLinTol, double dAngTol,
const BIPNTVECTOR& vBreakingPts)
{
// Se non ho curve, non faccio nulla
if ( vCompoChained.empty())
return true ;
// Se non ho punti di rottura, non faccio nulla
if ( vBreakingPts.empty())
return true ;
// Se ho punti di rottura in comune, errore
for ( int i = 0 ; i < int( vBreakingPts.size()) ; ++ i) {
if ( AreSamePointEpsilon( vBreakingPts[i].first, vBreakingPts[i].second, dLinTol))
return false ;
for ( int j = i + 1 ; j < int( vBreakingPts.size()) ; ++ j) {
if ( AreSamePointEpsilon( vBreakingPts[i].first, vBreakingPts[j].first, dLinTol) ||
AreSamePointEpsilon( vBreakingPts[i].first, vBreakingPts[j].second, dLinTol) ||
AreSamePointEpsilon( vBreakingPts[i].second, vBreakingPts[j].first, dLinTol) ||
AreSamePointEpsilon( vBreakingPts[i].second, vBreakingPts[j].second, dLinTol))
return false ;
}
}
#if DEBUG_BRK_POINTS
VC.clear() ; VT.clear() ;
for ( const ICurveComposite* _pCompoChained : vCompoChained) {
VT.emplace_back( _pCompoChained->Clone()) ;
VC.emplace_back( RED) ;
}
for ( const BIPOINT& _Bipt : vBreakingPts) {
IGeoPoint3d* _ptS = CreateGeoPoint3d() ; _ptS->Set( _Bipt.first) ;
IGeoPoint3d* _ptE = CreateGeoPoint3d() ; _ptE->Set( _Bipt.second) ;
VT.emplace_back( _ptS) ;
VT.emplace_back( _ptE) ;
VC.emplace_back( AQUA) ;
VC.emplace_back( LIME) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\Brk.nge") ;
#endif
// Scorro le curve
ICRVCOMPOPOVECTOR vCrvResult ;
for ( const ICurveComposite* pCompoChained : vCompoChained) {
// Verifico che sia valida
if ( pCompoChained == nullptr || ! pCompoChained->IsValid())
return false ;
// Copio la curva, dato che potrei spezzarla
ICRVCOMPOPOVECTOR vCompoParts ; vCompoParts.reserve( vBreakingPts.size()) ;
if ( ! vCompoParts.emplace_back( CloneCurveComposite( pCompoChained)))
return false ;
for ( const BIPOINT& BiPnts : vBreakingPts) {
// Scorro i tratti ( inizialmente la curva stessa)
for ( int i = 0 ; i < int( vCompoParts.size()) ; ++ i) {
// Controllo che la coppia di punti giacia su quella curva
if ( ! vCompoParts[i]->IsPointOn( BiPnts.first, dLinTol) ||
! vCompoParts[i]->IsPointOn( BiPnts.second, dLinTol))
continue ;
// Se entrambi sulla curva, recupero il tratto più lungo da loro definito
double dUS = 0. ; vCompoParts[i]->GetParamAtPoint( BiPnts.first, dUS, dLinTol) ;
double dUE = 0. ; vCompoParts[i]->GetParamAtPoint( BiPnts.second, dUE, dLinTol) ;
PtrOwner<ICurve> pCrvA( vCompoParts[i]->CopyParamRange( dUS, dUE)) ;
PtrOwner<ICurve> pCrvB( vCompoParts[i]->CopyParamRange( dUE, dUS)) ;
// Se la curva corrente è chiusa
if ( vCompoParts[i]->IsClosed()) {
if ( IsNull( pCrvA) || IsNull( pCrvB))
return false ;
double dLenA = 0. ; pCrvA->GetLength( dLenA) ;
double dLenB = 0. ; pCrvB->GetLength( dLenB) ;
if ( dLenA > dLenB)
vCompoParts[i].Set( ConvertCurveToComposite( Release( pCrvA))) ;
else
vCompoParts[i].Set( ConvertCurveToComposite( Release( pCrvB))) ;
}
// Se la curva è aperta
else {
double dUDomS = 0., dUDomE = 0. ;
vCompoParts[i]->GetDomain( dUDomS, dUDomE) ;
PtrOwner<ICurveComposite> pCompoTmp( CloneCurveComposite( vCompoParts[i])) ;
if ( IsNull( pCompoTmp) || ! pCompoTmp->IsValid())
return false ;
if ( IsNull( pCrvA)) {
pCompoTmp->TrimStartAtParam( dUS) ;
vCompoParts.emplace_back( Release( pCompoTmp)) ;
vCompoParts[i]->TrimEndAtParam( dUE) ;
}
else if ( IsNull( pCrvB)) {
pCompoTmp->TrimStartAtParam( dUE) ;
vCompoParts.emplace_back( Release( pCompoTmp)) ;
vCompoParts[i]->TrimEndAtParam( dUS) ;
}
}
}
}
// Memorizzo tutte le curve valide ottenute dai punti di rottura
for ( int i = 0 ; i < int( vCompoParts.size()) ; ++ i) {
if ( ! IsNull( vCompoParts[i]) && vCompoParts[i]->IsValid())
vCrvResult.emplace_back( Release( vCompoParts[i])) ;
}
}
swap( vCrvResult, vCompoChained) ;
return true ;
}
//-----------------------------------------------------------------------------
static bool
BreakCompoPathces( ICRVCOMPOPOVECTOR& vCompoChained, double dLinTol, double dAngTol)
{
// Se non ho curve, non faccio nulla
if ( vCompoChained.empty())
return true ;
const double ANG_SPLIT = 65. ;
// Scorro le curve
ICRVCOMPOPOVECTOR vCrvResult ;
for ( const ICurveComposite* pCompoChained : vCompoChained) {
// Verifico la sua validità
if ( pCompoChained == nullptr || ! pCompoChained->IsValid())
return false ;
// Recupero la PolyLine associata ( senza alcuna approssimazione)
PolyLine myPL ;
if ( ! pCompoChained->ApproxWithLines( EPS_SMALL, EPS_ANG_SMALL, ICurve::APL_SPECIAL, myPL))
return false ;
// Approssimo la curva mediante Set di punti considerando la tolleranza angolare
POLYLINEVECTOR vPL ;
if ( ! GetPointSetByAngTol( myPL, ANG_SPLIT, vPL))
return false ;
// Se meno di 4 PolyLine non faccio nulla
if ( int( vPL.size()) < 4) {
LOG_INFO( GetEGkLogger(), "Warning in Trimming : Not Detected 2 Curves") ;
return true ;
}
// Scorro le PolyLine e ricavo le due più corte
INTDBLVECTOR vIndPLLen ; vIndPLLen.reserve( vPL.size()) ;
for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
double dLen ; vPL[i].GetLength( dLen) ;
vIndPLLen.emplace_back( make_pair( i, dLen)) ;
}
sort( vIndPLLen.begin(), vIndPLLen.end(), []( const INTDBL& IndA, const INTDBL& IndB){
return ( IndA.second < IndB.second) ;
}) ;
BIPNTVECTOR vBiPntSplit ; vBiPntSplit.reserve( 2) ;
for ( int i = 0 ; i < 2 ; ++ i) {
Point3d ptS ; vPL[vIndPLLen[i].first].GetFirstPoint( ptS) ;
Point3d ptE ; vPL[vIndPLLen[i].first].GetLastPoint( ptE) ;
vBiPntSplit.emplace_back( make_pair( ptS, ptE)) ;
}
#if DEBUG_BRK
VT.emplace_back( pCompoChained->Clone()) ;
VC.emplace_back( ORANGE) ;
for ( PolyLine& _PL : vPL) {
IGeoPoint3d* _ptS = CreateGeoPoint3d() ;
Point3d _ptStart ; _PL.GetFirstPoint( _ptStart) ; _ptS->Set( _ptStart) ;
VT.emplace_back( _ptS) ;
VC.emplace_back( YELLOW) ;
IGeoPoint3d* _ptE = CreateGeoPoint3d() ;
Point3d _ptEnd ; _PL.GetLastPoint( _ptEnd) ; _ptE->Set( _ptEnd) ;
VT.emplace_back( _ptE) ;
VC.emplace_back( YELLOW) ;
}
for ( BIPOINT& BiPt : vBiPntSplit) {
ICurveLine* pLine = CreateCurveLine() ;
pLine->Set( BiPt.first, BiPt.second) ;
VT.emplace_back( pLine) ;
VC.emplace_back( FUCHSIA) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\SplitRawEdges.nge") ;
#endif
if ( ! vCrvResult.emplace_back( CloneCurveComposite( pCompoChained)))
return false ;
double dU0 = 0., dU1 = 0. ;
vCrvResult.back()->GetParamAtPoint( vBiPntSplit[0].second, dU0) ;
vCrvResult.back()->ChangeStartPoint( dU0) ;
vCrvResult.back()->GetParamAtPoint( vBiPntSplit[1].first, dU1) ;
vCrvResult.back().Set( ConvertCurveToComposite( vCrvResult.back()->CopyParamRange( 0., dU1))) ;
if ( ! vCrvResult.emplace_back( CloneCurveComposite( pCompoChained)))
return false ;
vCrvResult.back()->ChangeStartPoint( dU0) ;
vCrvResult.back()->GetParamAtPoint( vBiPntSplit[1].second, dU0) ;
vCrvResult.back()->GetParamAtPoint( vBiPntSplit[0].first, dU1) ;
vCrvResult.back().Set( ConvertCurveToComposite( vCrvResult.back()->CopyParamRange( dU0, dU1))) ;
}
swap( vCrvResult, vCompoChained) ;
return true ;
}
//-----------------------------------------------------------------------------
//---------------------------- Estrazione dei Bordi ---------------------------
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Funzione che restituisce l'insieme dei Bordi di una Superficie ( TriMesh o Bezier)
static bool
InsertLoopsOfSurf( const ISurf* pSurf, POLYLINEVECTOR& vPL)
{
// Se superficie TriMesh
if ( pSurf->GetType() == SRF_TRIMESH) {
// Recupero la superficie, verificandone la validità
const ISurfTriMesh* pStm = GetSurfTriMesh( pSurf) ;
if ( pStm == nullptr || ! pStm->IsValid())
return false ;
// verifico che tutte le parti siano valide
// ( nel recupero dei Loop alcune superfici presentano delle Part non valide)
double dPartArea = 0. ;
bool bValidParts = true ;
BOOLVECTOR vValidParts ; vValidParts.reserve( pStm->GetPartCount()) ;
for ( int nP = 0 ; nP < pStm->GetPartCount() ; ++ nP) {
vValidParts.emplace_back( pStm->GetPartArea( nP, dPartArea) && dPartArea > SQ_EPS_SMALL) ;
bValidParts = bValidParts && ( vValidParts.back()) ;
}
// Recupero le PolyLine di bordo
if ( bValidParts) {
if ( ! pStm->GetLoops( vPL))
return false ;
}
else {
for ( int nP = 0 ; nP < pStm->GetPartCount() ; ++ nP) {
if ( vValidParts[nP]) {
POLYLINEVECTOR vPLPart ;
if ( ! pStm->GetPartLoops( nP, vPLPart))
return false ;
for ( const PolyLine& PL : vPLPart)
vPL.emplace_back( PL) ;
}
}
}
}
// Se superficie di Bezier
else if ( pSurf->GetType() == SRF_BEZIER) {
// Recupero la superficie, verificandone la validità
const ISurfBezier* pSbz = GetSurfBezier( pSurf) ;
if ( pSbz == nullptr || ! pSbz->IsValid())
return false ;
// Recupero i Bordi ( questa funzione restituisce dei tratti lineari)
ICRVCOMPOPOVECTOR vLoops ;
if ( ! pSbz->GetLoops( vLoops, true))
return false ;
// Li inserisco nel vettore ( come insieme di tratti lineari)
// NB. Tengo le tolleranze molto basse per ottenere dei loop rappresentativi della geometria
for ( int nL = 0 ; nL < int( vLoops.size()) ; ++ nL) {
if ( ! IsNull( vLoops[nL]) && vLoops[nL]->IsValid()) {
vPL.emplace_back( PolyLine()) ;
if ( ! vLoops[nL]->ApproxWithLines( EPS_SMALL, EPS_ANG_SMALL, ICurve::APL_STD, vPL.back()))
return false ;
}
}
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per ottenere il bordo di una superficie TriMesh definito da un insieme di facce
static bool
GetSurfTmBordersByFaces( const SurfTriMesh* pStm, const INTVECTOR& vFaces,
double dLinTol, POLYLINEVECTOR& vPL)
{
// Controllo che la superficie sia valida
if ( pStm == nullptr || ! pStm->IsValid())
return false ;
// Inserisco il primo triangolo valido di ogni faccia
INTVECTOR vTria ;
for ( const int& nF : vFaces) {
int nT = SVT_NULL ;
if ( pStm->GetTriaFromFace( nF, nT))
vTria.emplace_back( nT) ;
}
// Definisco un vettore di concatenamento delle curve ( in questo caso segmenti, lati di triangoli)
ICRVCOMPOPOVECTOR vCompoChain ; vCompoChain.reserve( 3 * pStm->GetTriangleCount()) ;
// Collezione di triangoli già visitati
unordered_set<int> SetTria ; SetTria.reserve( pStm->GetTriangleCount()) ;
// Collezione di Edges come coppia di punti
BIPNTVECTOR vEdges ; vEdges.reserve( 3 * pStm->GetTriangleCount()) ;
// Finchè ho triangoli di adiacenza non ancora visitati
while ( ! vTria.empty()) {
// Recupero il triangolo corrente
int nCurrTria = vTria.back() ;
// Elimino il triangolo corrente
vTria.pop_back() ;
// Se triangolo non presente, lo aggiungo come visitato
auto IterTria = SetTria.find( nCurrTria) ;
if ( IterTria == SetTria.end())
SetTria.insert( nCurrTria) ;
// Se triangolo già visitato, passo al successivo
else
continue ;
// Recupero il triangolo corrente ( definito dai suoi 3 vertici )
int nTriaVertices[3] ;
pStm->GetTriangle( nCurrTria, nTriaVertices) ;
// Recupero i tre triangoli adiacenti al triangolo corrente
int nIdAdjTriaId[3] ;
if ( ! pStm->GetTriangleAdjacencies( nCurrTria, nIdAdjTriaId))
return false ;
// Scorro le adiacenze
for ( int nAdj = 0 ; nAdj < 3 ; ++ nAdj) {
// Recupero l'indice del triangolo adiacente
int nTriaAdj = nIdAdjTriaId[nAdj] ;
// Inserisco il lato orientato del triangolo se :
// - Non ho adiacenze
// - L'adiacenza avviene su una faccia da non considerare
bool bInsertEdge = false ;
if ( nTriaAdj == SVT_NULL)
bInsertEdge = true ;
else {
// Recupero la faccia del triangolo adiacente
int nFaceAdj = pStm->GetFacetFromTria( nTriaAdj) ;
// Se appartiene ad una faccia da inserire
if ( find( vFaces.begin(), vFaces.end(), nFaceAdj) != vFaces.end())
vTria.push_back( nTriaAdj) ;
// Se appartiene ad una faccia da non considerare, memorizzo il suo Edge orientato
else
bInsertEdge = true ;
}
// Se richiesto, memorizzo l'Edge
if ( bInsertEdge) {
Point3d ptS ; pStm->GetVertex( nTriaVertices[nAdj % 3], ptS) ;
Point3d ptE ; pStm->GetVertex( nTriaVertices[( nAdj + 1) % 3], ptE) ;
if ( vCompoChain.emplace_back( CreateCurveComposite())) {
vCompoChain.back()->AddPoint( ptS) ;
vCompoChain.back()->AddLine( ptE) ;
}
}
}
}
// Recupero i tratti di PolyLine dei triangoli
ICRVCOMPOPOVECTOR vCompoChained ;
if ( ! ChainCompoPatches( vCompoChain, dLinTol, vCompoChained))
return false ;
for ( const ICurveComposite* pCompoChained : vCompoChain) {
if ( pCompoChained != nullptr && pCompoChained->IsValid()) {
vPL.emplace_back( PolyLine()) ;
pCompoChained->ApproxWithLines( EPS_SMALL, EPS_ANG_SMALL, ICurve::APL_SPECIAL, vPL.back()) ;
}
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per il calcolo dei bordi delle superfici
static bool
GetSurfBorders( const CISURFPVECTOR& vSurf, const SELVECTOR& vSurfFace, double dLinTol,
POLYLINEVECTOR& vPLBorders)
{
// Verifico che tutte le superfici siano valide e ben definite
for ( const ISurf* pSurf : vSurf) {
if ( pSurf == nullptr || ! pSurf->IsValid())
return false ;
}
vPLBorders.clear() ;
// Definisco l'insieme delle PolyLine ricavate dai bordi
// NB. I bordi possono derivare da :
// - Loop di una Bezier
// - Loop di una Superficie TriMesh
// - Insieme di facce di una supericie TriMesh
// Scorro il vettore delle superfici
for ( int nS = 0 ; nS < int( vSurf.size()) ; ++ nS) {
// Recupero la superficie
const ISurf* pSurf = vSurf[nS] ;
if ( pSurf == nullptr)
return false ;
// Recupero le facce associate a quella superficie dal vettore di selezione
INTVECTOR vFaces ;
for ( const SelData& SurfFace : vSurfFace) {
if ( SurfFace.nId == nS &&
find( vFaces.begin(), vFaces.end(), SurfFace.nSub) == vFaces.end())
vFaces.push_back( SurfFace.nSub) ;
}
// Recupero la dimensione del vettore delle PolyLine risultati attuale
int nSize = int( vPLBorders.size()) ;
// Se non ho nessuna faccia e nessun triangolo da scartare, estraggo i bordi complessivi della superficie
if ( int( vFaces.size()) == 1 && vFaces[0] == SEL_SUB_ALL) {
if ( ! InsertLoopsOfSurf( pSurf, vPLBorders))
return false ;
}
// Se ho più facce da inserire
else {
// Se TriMesh
if ( pSurf->GetType() == SRF_TRIMESH) {
// Recupero la regione TriMesh di base
const SurfTriMesh* pStm = GetBasicSurfTriMesh( pSurf) ;
if ( pStm == nullptr)
return false ;
// Aggiungo i tratti di curva necessari
if ( ! GetSurfTmBordersByFaces( pStm, vFaces, dLinTol, vPLBorders))
return false ;
}
// Se Bezier, errore, non ho facce per la superficie
if ( pSurf->GetType() == SRF_BEZIER)
return false ;
}
// Associo alle nuove PolyLine ricavate l'indice della superficie corrispondente
for ( int i = nSize ; i < int( vPLBorders.size()) ; ++ i)
vPLBorders[i].SetTempProp( nS, 0) ;
}
#if DEBUG_BASIC_BORDERS // Debug per Bordi
VT.clear() ; VC.clear() ;
for ( const PolyLine& _PL : vPLBorders) {
ICurveComposite* _pCrv = CreateCurveComposite() ;
_pCrv->FromPolyLine( _PL) ;
VT.emplace_back( _pCrv->Clone()) ;
VC.emplace_back( Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.)) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\BasicBorders.nge") ;
#endif
return true ;
}
// ----------------------------------------------------------------------------
// ---------------------------------- Analisi Adiacenze -----------------------
// ----------------------------------------------------------------------------
static bool
ClassifyTriangles( const SurfTriMesh& Stm, const INTVECTOR& vTBox, int nFirstTria, double dAngTol,
unordered_set<int>& setAvoidTria, unordered_set<int>& setNewTria)
{
// Collezione di triangoli già visitati
unordered_set<int> setTria ; setTria.reserve( vTBox.size()) ;
// Collezioni di triangoli da analizzare
INTVECTOR vTria ; vTria.reserve( int( vTBox.size()) + 1) ;
vTria.push_back( nFirstTria) ;
// Finchè ho triangoli da visitare
while ( ! vTria.empty()) {
// Recupero il triangolo corrente
int nCurrTria = vTria.back() ;
// Elimino il triangolo corente
vTria.pop_back() ;
// Se triangolo da evitare, passo al successivo
if ( setAvoidTria.find( nCurrTria) != setAvoidTria.end())
continue ;
// Se triangolo mai visitato lo aggiungo tra quelli visitati, altrimenti passo al successivo
if ( setTria.find( nCurrTria) != setTria.end())
continue ;
setTria.insert( nCurrTria) ;
// Inserisco il triangolo corrente
setNewTria.insert( nCurrTria) ;
// Recupero il triangolo corrente e le sue adiacenze
int nTriaVertices[3] ;
if ( ! Stm.GetTriangle( nCurrTria, nTriaVertices))
return false ;
Triangle3d Tria ;
if ( ! Stm.GetTriangle( nCurrTria, Tria))
return false ;
int nIdAdjTriaId[3] ;
if ( ! Stm.GetTriangleAdjacencies( nCurrTria, nIdAdjTriaId))
return false ;
// Scorro le adiacenze
for ( int nAdj = 0 ; nAdj < 3 ; ++ nAdj) {
// Recupero l'indice del triangolo corrente
int nTriaAdj = nIdAdjTriaId[nAdj] ;
// Se non ho adiacenza, non faccio nulla
if ( nTriaAdj == SVT_NULL)
continue ;
// Recupero il triangolo adiacente
Triangle3d TriaAdj ;
if ( ! Stm.GetTriangle( nTriaAdj, TriaAdj))
return false ;
// Se l'adiacenza non è interna al Box corrente, il triangolo rimane visitato
if ( find( vTBox.begin(), vTBox.end(), nTriaAdj) == vTBox.end())
setTria.insert( nTriaAdj) ;
// Se la normale è fuori dalla tolleranza
if ( Tria.GetN() * TriaAdj.GetN() < cos( ( dAngTol + EPS_ANG_SMALL) * DEGTORAD)) {
// Se tale non è già stato scartato
if ( find( setAvoidTria.begin(), setAvoidTria.end(), nTriaAdj) == setAvoidTria.end()) {
// Azzero i triangoli correnti e ricomincio l'algoritmo
setAvoidTria.insert( nTriaAdj) ;
vTria.clear() ;
vTria.push_back( nFirstTria) ;
setTria.clear() ;
break ;
}
continue ;
}
// Inserisco il triangolo per la ricerca futura
vTria.push_back( nTriaAdj) ;
}
}
#if DEBUG_FACE_SEARCH
for ( auto Iter = setNewTria.begin() ; Iter != setNewTria.end() ; ++ Iter) {
VT.emplace_back( Stm.CloneTriangle( *Iter)) ;
VC.emplace_back( GREEN) ;
}
for ( auto Iter = setAvoidTria.begin() ; Iter != setAvoidTria.end() ; ++ Iter) {
VT.emplace_back( Stm.CloneTriangle( *Iter)) ;
VC.emplace_back( ORANGE) ;
}
//SaveGeoObj( VT, VC, "C:\\Temp\\2.nge") ;
#endif
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per il recupero delle curve concatenate di bordo dai triangoli classificati
static bool
GetBordersByTriaInBox( const SurfTriMesh& Stm, const BBox3d& BBoxCurr, double dLinTol,
const unordered_set<int>& setNewTria, COMPOVECTOR& vCompoChain,
bool& bAmbiguous)
{
// I bordi Locali sono definiti dall'insieme degli Edges dei triangoli trovati come validi
BIPNTVECTOR vBiPnts ;
for ( auto Iter = setNewTria.begin() ; Iter != setNewTria.end() ; ++ Iter) {
int nIdVert[3] ;
if ( ! Stm.GetTriangle( *Iter, nIdVert))
return false ;
int nIdAdjTriaId[3] ;
if ( ! Stm.GetTriangleAdjacencies( *Iter, nIdAdjTriaId))
return false ;
for ( int nAdj = 0 ; nAdj < 3 ; ++ nAdj) {
int nTriaAdj = nIdAdjTriaId[nAdj] ;
if ( nTriaAdj == SVT_NULL ||
find( setNewTria.begin(), setNewTria.end(), nTriaAdj) == setNewTria.end()) {
vBiPnts.emplace_back( BIPOINT()) ;
if ( ! Stm.GetVertex( nIdVert[nAdj], vBiPnts.back().first) ||
! Stm.GetVertex( nIdVert[( nAdj + 1) % 3], vBiPnts.back().second))
return false ;
}
}
}
// Per ogni Edge ricavato, conservo solo le parti interne al Box corrente
INTVECTOR vEdgeToSave ; vEdgeToSave.reserve( vBiPnts.size()) ;
for ( int nEdge = 0 ; nEdge < int( vBiPnts.size()) ; ++ nEdge) {
Point3d& ptL1 = vBiPnts[nEdge].first ;
Point3d& ptL2 = vBiPnts[nEdge].second ;
Vector3d vtDir = ptL2 - ptL1 ;
vtDir.Normalize() ;
INTDBLVECTOR vInters ;
if ( IntersLineBox( ptL1, ptL2, BBoxCurr, vInters, true)) {
if ( int( vInters.size()) == 2) {
vEdgeToSave.push_back( nEdge) ;
// Se edge sul bordo, lo spezzo
if ( vInters[1].first == ILBT_OUT)
ptL2 = ptL1 + ( vtDir * vInters[1].second) ;
if ( vInters[0].first == ILBT_IN)
ptL1 = ptL1 + ( vtDir * vInters[0].second) ;
}
}
}
unordered_set<int> setBiPntsToSave( vEdgeToSave.begin(), vEdgeToSave.end()) ;
int nCurr = 0 ;
for ( int i = 0 ; i < int( vBiPnts.size()) ; ++ i) {
if ( setBiPntsToSave.count( i))
vBiPnts[nCurr ++] = vBiPnts[i] ;
}
vBiPnts.resize( nCurr) ;
#if DEBUG_FACE_SEARCH
for ( int i = 0 ; i < int( vBiPnts.size()) ; ++ i) {
ICurveLine* pLine = CreateCurveLine() ;
pLine->Set( vBiPnts[i].first, vBiPnts[i].second) ;
VT.emplace_back( pLine) ;
VC.emplace_back( Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.)) ;
}
// SaveGeoObj( VT, VC, "C:\\Temp\\3.nge") ;
#endif
// Concateno i Segmenti interni al Box corrente
BOOLVECTOR vIndInChain ; vIndInChain.resize( vBiPnts.size(), false) ;
vCompoChain.reserve( vBiPnts.size()) ;
for ( int i = 0 ; i < int( vBiPnts.size()) ; ++ i) {
// Se già in Chain, passo al successivo
if ( vIndInChain[i])
continue ;
vIndInChain[i] = true ;
// Recupero gli estremi correnti
Point3d ptCurrStart = vBiPnts[i].first ;
Point3d ptCurrEnd = vBiPnts[i].second ;
// Definisco la nuova curve composita di concatenamento
vCompoChain.emplace_back( CurveComposite()) ;
vCompoChain.back().AddPoint( ptCurrStart) ;
vCompoChain.back().AddLine( ptCurrEnd) ;
// Punti di controllo per Biforcazioni
PNTVECTOR vPtForks ; vPtForks.reserve( vBiPnts.size()) ;
for ( int j = 0 ; j < int( vBiPnts.size()) ; ++ j) {
// Controllo un altro Edge non in Chain, recuperando i suoi estremi
if ( i == j || vIndInChain[j])
continue ;
Point3d& ptOtherStart = vBiPnts[j].first ;
Point3d& ptOtherEnd = vBiPnts[j].second ;
// Se concatenamento ammissibile
if ( AreSamePointEpsilon( ptCurrEnd, ptOtherStart, dLinTol)) {
// Se su un punto di Biforcazione, sono in un caso ambiguo
for ( const Point3d& ptFork : vPtForks) {
if ( AreSamePointApprox( ptFork, ptCurrEnd)) {
bAmbiguous = true ;
return true ;
}
}
vPtForks.emplace_back( ptCurrEnd) ;
// Altrimenti aggiorno i parametri di ricerca
vCompoChain.back().AddLine( ptOtherEnd) ;
ptCurrEnd = ptOtherEnd ;
vIndInChain[j] = true ;
j = 0 ;
}
else if ( AreSamePointEpsilon( ptCurrEnd, ptOtherEnd, dLinTol)) {
// Se su un punto di Biforcazione, sono in un caso ambiguo
for ( const Point3d& ptFork : vPtForks) {
if ( AreSamePointApprox( ptFork, ptCurrEnd)) {
bAmbiguous = true ;
return true ;
}
}
vPtForks.emplace_back( ptCurrEnd) ;
// Altrimenti aggiorno i parametri di ricerca
vCompoChain.back().AddLine( ptOtherStart) ;
ptCurrEnd = ptOtherStart ;
vIndInChain[j] = true ;
j = 0 ;
}
else if ( AreSamePointEpsilon( ptCurrStart, ptOtherEnd, dLinTol)) {
// Se su un punto di Biforcazione, sono in un caso ambiguo
for ( const Point3d& ptFork : vPtForks) {
if ( AreSamePointApprox( ptFork, ptCurrStart)) {
bAmbiguous = true ;
return true ;
}
}
vPtForks.emplace_back( ptCurrStart) ;
// Altrimenti aggiorno i parametri di ricerca
vCompoChain.back().AddLine( ptOtherStart, false) ;
ptCurrStart = ptOtherStart ;
vIndInChain[j] = true ;
j = 0 ;
}
else if ( AreSamePointEpsilon( ptCurrStart, ptOtherStart, dLinTol)) {
// Se su un punto di Biforcazione, sono in un caso ambiguo
for ( const Point3d& ptFork : vPtForks) {
if ( AreSamePointApprox( ptFork, ptCurrStart)) {
bAmbiguous = true ;
return true ;
}
}
vPtForks.emplace_back( ptCurrStart) ;
// Altrimenti aggiorno i parametri di ricerca
vCompoChain.back().AddLine( ptOtherEnd, false) ;
ptCurrStart = ptOtherEnd ;
vIndInChain[j] = true ;
j = 0 ;
}
}
}
#if DEBUG_FACE_SEARCH
for ( int i = 0 ; i < int( vCompoChain.size()) ; ++ i) {
VT.emplace_back( vCompoChain[i].Clone()) ;
VC.emplace_back( FUCHSIA) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\4.nge") ;
#endif
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per il calcolo dei punti medi tra due curve di Bordo
static bool
CalcMidPointForBorders( const CurveComposite& CompoA, const CurveComposite& CompoB,
const SurfTriMesh& Stm, const unordered_set<int>& setNewTria,
Point3d& ptMid, Point3d& ptMid1, int& nTria, int& nTria1)
{
// Se entrambe le curve non sono valide, errore
if ( ! CompoA.IsValid() && ! CompoB.IsValid())
return false ;
// Se entrambe le curve sono valide
if ( CompoA.IsValid() && CompoB.IsValid()) {
// Recupero ptMid1 e ptMid2 e i rispettivi triangoli di ricerca
Point3d ptA ; CompoA.GetStartPoint( ptA) ;
Point3d ptB ; CompoA.GetEndPoint( ptB) ;
Point3d ptC ; CompoB.GetStartPoint( ptC) ;
Point3d ptD ; CompoB.GetEndPoint( ptD) ;
if ( SqDist( ptA, ptD) < SqDist( ptA, ptC))
swap( ptC, ptD) ;
ptMid = Media( ptB, ptD) ;
ptMid1 = Media( ptA, ptC) ;
}
// Se una sola valida
else {
const CurveComposite& CurveX = ( CompoA.IsValid() ? CompoA : CompoB) ;
Point3d ptA ; CurveX.GetStartPoint( ptA) ;
Point3d ptD ; CurveX.GetEndPoint( ptD) ;
ptMid = Media( ptA, ptD) ;
ptMid1 = P_INVALID ;
nTria1 = SVT_NULL ;
}
// Recupero il triangolo a distanza minima dai due punti ricavati
double dSqDistMin = INFINITO ;
double dSqDistMin1 = INFINITO ;
for ( auto Iter = setNewTria.begin() ; Iter != setNewTria.end() ; ++ Iter) {
Triangle3d Tria ;
if ( ! Stm.GetTriangle( *Iter, Tria))
return false ;
double dSqDist = 0., dSqDist1 = 0. ;
DistPointTriangle( ptMid, Tria).GetSqDist( dSqDist) ;
if ( dSqDist < dSqDistMin) {
dSqDistMin = dSqDist ;
nTria = *Iter ;
}
if ( ptMid1.IsValid()) {
DistPointTriangle( ptMid1, Tria).GetSqDist( dSqDist1) ;
if ( dSqDist1 < dSqDistMin1) {
dSqDistMin1 = dSqDist1 ;
nTria1 = *Iter ;
}
}
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per l'analisi locale delle curve di bordo
static bool
CheckCurvesInBox( const SurfTriMesh& Stm, const COMPOVECTOR& vCompoChain, const Point3d& ptSel,
const unordered_set<int>& setNewTria, CurveComposite& CompoA,CurveComposite& CompoB,
Point3d& ptMid, Point3d& ptMid1, int& nTria, int& nTria1)
{
const double HALF_LEN = .5 ;
const double ANG_SPLIT = 50. ;
// Se non ho curve, errore
if ( vCompoChain.empty())
return false ;
#if DEBUG_FACE_SEARCH
for ( int _i = 0 ; _i < int( vCompoChain.size()) ; ++ _i) {
VT.emplace_back( vCompoChain[_i].Clone()) ;
VC.emplace_back( PURPLE) ;
}
#endif
// Recupero le due curve di riferimento
CurveComposite CompoATmp, CompoBTmp ;
// Se ho una sola curva, allora i bordi si sono uniti
if ( int( vCompoChain.size()) == 1) {
// Approssimo la curva in Patches
PolyLine PL ;
if ( ! vCompoChain[0].ApproxWithLines( EPS_SMALL, EPS_ANG_SMALL, ICurve::APL_SPECIAL, PL))
return false ;
POLYLINEMATRIX matPL ;
if ( ! CalcPatches( { PL}, ANG_SPLIT, matPL) && ! matPL.empty() && ! matPL[0].empty())
return false ;
CompoATmp.FromPolyLine( matPL[0].front()) ;
CompoBTmp.FromPolyLine( matPL[0].back()) ;
}
// Se due curve di bordo
else if ( int( vCompoChain.size()) == 2) {
CompoATmp = vCompoChain[0] ;
CompoBTmp = vCompoChain[1] ;
}
// Se più di due, cerco le due curve più vicine
else if ( int( vCompoChain.size()) > 2) {
INTDBLVECTOR vIndSqDist ; vIndSqDist.reserve( vCompoChain.size()) ;
for ( int nCrv = 0 ; nCrv < int( vCompoChain.size()) ; ++ nCrv) {
vIndSqDist.emplace_back( make_pair( nCrv, 0.)) ;
if ( ! DistPointCurve( ptSel, vCompoChain[nCrv]).GetSqDist( vIndSqDist.back().second))
return false ;
}
sort( vIndSqDist.begin(), vIndSqDist.end(), []( const INTDBL& A, const INTDBL& B) {
return ( A.second < B.second) ;
}) ;
CompoATmp = vCompoChain[vIndSqDist[0].first] ;
CompoBTmp = vCompoChain[vIndSqDist[1].first] ;
}
// Entrambe le curve sono chiuse, non devo fare nulla
if ( CompoATmp.IsClosed() && CompoBTmp.IsClosed()) {
CompoA = CompoATmp ;
CompoB = CompoBTmp ;
return true ;
}
#if DEBUG_FACE_SEARCH
VT.emplace_back( CompoATmp.Clone()) ;
VC.emplace_back( WHITE) ;
VT.emplace_back( CompoBTmp.Clone()) ;
VC.emplace_back( WHITE) ;
#endif
// Definisco le due curve di riferimento
double dUA = 0., dUB = 0. ;
int nFlag = 0 ;
if ( ! DistPointCurve( ptSel, CompoATmp).GetParamAtMinDistPoint( 0., dUA, nFlag) ||
! DistPointCurve( ptSel, CompoBTmp).GetParamAtMinDistPoint( 0., dUB, nFlag))
return false ;
// Se le curve sono chiuse devo fare attenzione
if ( CompoATmp.IsClosed()) {
// Se lunghezza inferiore del doppio della semilunghezza, errore ( curva troppo piccola per essere lavorata)
double dLenA ;
if ( ! CompoATmp.GetLength( dLenA) || dLenA < 2. * HALF_LEN + EPS_SMALL)
return false ;
// Cambio il punto inziale della curva
CompoATmp.ChangeStartPoint( dUA) ;
double dUS, dUE ;
if ( ! CompoATmp.GetDomain( dUS, dUE))
return false ;
CompoATmp.ChangeStartPoint( ( dUS + dUE) / 2.) ;
if ( ! DistPointCurve( ptSel, CompoATmp).GetParamAtMinDistPoint( 0., dUA, nFlag))
return false ;
}
if ( CompoBTmp.IsClosed()) {
// Se lunghezza inferiore del doppio della semilunghezza, errore ( curva troppo piccola per essere lavorata)
double dLenB ;
if ( ! CompoBTmp.GetLength( dLenB) || dLenB < 2. * HALF_LEN + EPS_SMALL)
return false ;
CompoBTmp.ChangeStartPoint( dUB) ;
double dUS, dUE ;
if ( ! CompoBTmp.GetDomain( dUS, dUE))
return false ;
CompoBTmp.ChangeStartPoint( ( dUS + dUE) / 2.) ;
if ( ! DistPointCurve( ptSel, CompoBTmp).GetParamAtMinDistPoint( 0., dUB, nFlag))
return false ;
}
// Recupero la lunghezza della curva e la lunghezza in tali parametri
double dULenA, dULenB, dLenA, dLenB ;
if ( ! CompoATmp.GetLengthAtParam( dUA, dULenA) ||
! CompoBTmp.GetLengthAtParam( dUB, dULenB) ||
! CompoATmp.GetLength( dLenA) ||
! CompoBTmp.GetLength( dLenB))
return false ;
// Recupero i due tratti di curva per l'analisi
double dLenMinA = Clamp( dULenA - HALF_LEN, 0., dLenA) ;
double dLenMaxA = Clamp( dULenA + HALF_LEN, 0., dLenA) ;
double dLenMinB = Clamp( dULenB - HALF_LEN, 0., dLenB) ;
double dLenMaxB = Clamp( dULenB + HALF_LEN, 0., dLenB) ;
// Recupero i parametri e le curve
double dUAS, dUAE, dUBS, dUBE ;
if ( ! CompoATmp.GetParamAtLength( dLenMinA, dUAS) ||
! CompoATmp.GetParamAtLength( dLenMaxA, dUAE) ||
! CompoBTmp.GetParamAtLength( dLenMinB, dUBS) ||
! CompoBTmp.GetParamAtLength( dLenMaxB, dUBE))
return false ;
CompoA.CopyFrom( ConvertCurveToBasicComposite( CompoATmp.CopyParamRange( dUAS, dUAE))) ;
CompoB.CopyFrom( ConvertCurveToBasicComposite( CompoBTmp.CopyParamRange( dUBS, dUBE))) ;
#if DEBUG_FACE_SEARCH
VT.emplace_back( CompoA.Clone()) ;
VC.emplace_back( RED) ;
VT.emplace_back( CompoB.Clone()) ;
VC.emplace_back( RED) ;
#endif
// Recupero ptMid1 e ptMid2 e i rispettivi triangoli di ricerca
if ( ! CalcMidPointForBorders( CompoA, CompoB, Stm, setNewTria, ptMid, ptMid1, nTria, nTria1))
return false ;
#if DEBUG_FACE_SEARCH
IGeoPoint3d* _ptMid = CreateGeoPoint3d() ; _ptMid->Set( ptMid) ;
VT.emplace_back( _ptMid) ;
VC.emplace_back( AQUA) ;
if ( ptMid1.IsValid()) {
IGeoPoint3d* _ptMid1 = CreateGeoPoint3d() ; _ptMid1->Set( ptMid1) ;
VT.emplace_back( _ptMid1) ;
VC.emplace_back( AQUA) ;
}
VT.emplace_back( Stm.CloneTriangle( nTria)) ;
VC.emplace_back( LIME) ;
if ( nTria1 != SVT_NULL) {
VT.emplace_back( Stm.CloneTriangle( nTria1)) ;
VC.emplace_back( LIME) ;
}
//SaveGeoObj( VT, VC, "C:\\Temp\\5.nge") ;
#endif
// I punti, le curve e i triangoli ricavati, devono essere validi
return ( CompoA.IsValid() && CompoB.IsValid() && ptMid.IsValid() && ptMid1.IsValid() &&
nTria != SVT_NULL && nTria1 != SVT_NULL) ;
}
// ----------------------------------------------------------------------------
// Funzione per aggiornare il Bordo mediante adiacenze di triangoli
static bool
UpdateBorderByTriaAdj( CurveComposite& Compo, double dLinTol, const COMPOVECTOR& vCompoChain,
bool& bUpdate)
{
bUpdate = false ;
// Se Curva corrente non valida, non devo aggiornare nulla
if ( ! Compo.IsValid())
return true ;
// Se le Compo di concatenazione non sono valide, errore
for ( const CurveComposite& CompoChain : vCompoChain) {
if ( ! CompoChain.IsValid())
return false ;
}
// Recupero gli estremi della curva corrente
Point3d ptStart ; Compo.GetStartPoint( ptStart) ;
Point3d ptEnd ; Compo.GetEndPoint( ptEnd) ;
#if DEBUG_FACE_SEARCH
VT.clear() ; VC.clear() ;
VT.emplace_back( Compo.Clone()) ;
VC.emplace_back( RED) ;
for ( const CurveComposite& CompoChain : vCompoChain) {
VT.emplace_back( CompoChain.Clone()) ;
VC.emplace_back( AQUA) ;
}
#endif
// Scorro le curve di concatenazione
bool bUpdateStart = false ;
bool bUpdateEnd = false ;
for ( const CurveComposite& CompoChain : vCompoChain) {
// Verifico gli estremi della curva corrente
bool bMyUpdateStart = ( CompoChain.IsPointOn( ptStart, dLinTol)) ;
bool bMyUpdateEnd = ( CompoChain.IsPointOn( ptEnd, dLinTol)) ;
if ( bMyUpdateStart || bMyUpdateEnd) {
// Recupero il dominio della curva di concatenzione
double dUS = 0., dUE = 0. ;
if ( ! CompoChain.GetDomain( dUS, dUE))
return false ;
// Recupero gli Estremi della curva di concatenazione
Point3d ptS ; CompoChain.GetStartPoint( ptS) ;
Point3d ptE ; CompoChain.GetEndPoint( ptE) ;
// Se solo tratto antecedente valido
if ( bMyUpdateStart && ! bMyUpdateEnd) {
double dUBreak = 0. ;
if ( ! CompoChain.GetParamAtPoint( ptStart, dUBreak, dLinTol))
return false ;
CurveComposite CompoPrev ;
if ( Compo.IsPointOn( ptS) && ! Compo.IsPointOn( ptE)) {
CompoPrev.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUBreak, dUE))) ;
CompoPrev.Invert() ;
}
else if ( Compo.IsPointOn( ptE) && ! Compo.IsPointOn( ptS))
CompoPrev.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUS, dUBreak))) ;
#if DEBUG_FACE_SEARCH
VT.emplace_back( CompoPrev.Clone()) ;
VC.emplace_back( LIME) ;
#endif
bUpdateStart = ( Compo.AddCurve( CompoPrev, false, dLinTol)) ;
}
// Se solo tratto successivo valido
else if ( ! bMyUpdateStart && bMyUpdateEnd) {
double dUBreak = 0. ;
if ( ! CompoChain.GetParamAtPoint( ptEnd, dUBreak, dLinTol))
return false ;
CurveComposite CompoAft ;
if ( Compo.IsPointOn( ptS) && ! Compo.IsPointOn( ptE))
CompoAft.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUBreak, dUE))) ;
else if ( Compo.IsPointOn( ptE) && ! Compo.IsPointOn( ptS)) {
CompoAft.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUS, dUBreak))) ;
CompoAft.Invert() ;
}
#if DEBUG_FACE_SEARCH
VT.emplace_back( CompoAft.Clone()) ;
VC.emplace_back( LIME) ;
#endif
bUpdateEnd = Compo.AddCurve( CompoAft, true, dLinTol) ;
}
// Se entrambi i tratti sono validi
else {
double dUBreak = 0., dUBreak1 = 0. ;
if ( ! CompoChain.GetParamAtPoint( ptStart, dUBreak, dLinTol) ||
! CompoChain.GetParamAtPoint( ptEnd, dUBreak1, dLinTol))
return false ;
if ( ! Compo.IsPointOn( ptS) && ! Compo.IsPointOn( ptE)) {
CurveComposite CompoPrev ;
CurveComposite CompoAft ;
if ( dUBreak < dUBreak1) {
CompoPrev.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUS, dUBreak))) ;
CompoAft.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUBreak1, dUE))) ;
}
else {
CompoPrev.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUBreak, dUE))) ;
CompoPrev.Invert() ;
CompoAft.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUS, dUBreak1))) ;
CompoAft.Invert() ;
}
#if DEBUG_FACE_SEARCH
VT.emplace_back( CompoPrev.Clone()) ;
VC.emplace_back( LIME) ;
VT.emplace_back( CompoAft.Clone()) ;
VC.emplace_back( LIME) ;
#endif
bUpdateStart = ( Compo.AddCurve( CompoPrev, false, dLinTol)) ;
bUpdateEnd = ( Compo.AddCurve( CompoAft, true, dLinTol)) ;
}
else if ( Compo.IsPointOn( ptS) && Compo.IsPointOn( ptE)) {
CurveComposite CompoSingle ;
if ( dUBreak < dUBreak1) {
CompoSingle.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUBreak, dUBreak1))) ;
CompoSingle.Invert() ;
#if DEBUG_FACE_SEARCH
VT.emplace_back( CompoSingle.Clone()) ;
VC.emplace_back( LIME) ;
#endif // false
if ( Compo.AddCurve( CompoSingle, true, dLinTol)) {
bUpdateStart = true ;
bUpdateEnd = true ;
}
}
else {
CompoSingle.CopyFrom( ConvertCurveToBasicComposite( CompoChain.CopyParamRange( dUBreak1, dUBreak))) ;
#if DEBUG_FACE_SEARCH
VT.emplace_back( CompoSingle.Clone()) ;
VC.emplace_back( LIME) ;
#endif // false
if ( Compo.AddCurve( CompoSingle, true, dLinTol)) {
bUpdateStart = true ;
bUpdateEnd = true ;
}
}
}
}
}
}
#if DEBUG_FACE_SEARCH
//SaveGeoObj( VT, VC, "C:\\Temp\\6.nge") ;
#endif
bUpdate = ( bUpdateStart || bUpdateEnd) ;
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per controllare le curve di Bordo all'interno del Box
static bool
CheckBordersInBox( CurveComposite& CompoA, CurveComposite& CompoB,
const SurfTriMesh& Stm, const unordered_set<int>& setAvoidTria,
double dAngTol, double dLinTol, double dSize, double dSizeTol, bool& bBreak)
{
bBreak = false ;
// Verifico la validità delle Curve
bool bValidA = ( CompoA.IsValid()) ;
bool bValidB = ( CompoB.IsValid()) ;
// Se nessuna curva valida, errore
if ( ! bValidA && ! bValidB)
return false ;
// Recupero i due tratti di curva in analisi e le loro proprietà
CurveComposite myCompoA, myCompoB ;
// NB. la parametrizzazione deve avvenire per lunghezza, non per parametro
double dLenA = 0., dLenB = 0. ;
double dLenStartA = 0., dLenStartB = 0., dLenEndA = 0., dLenEndB = 0. ;
// Se entrambe le curve sono valide
if ( bValidA && bValidB) {
myCompoA = CompoA ;
myCompoB = CompoB ;
// Recupero la lunghezza delle due curve
if ( ! myCompoA.GetLength( dLenA) || ! myCompoB.GetLength( dLenB))
return false ;
// Recupero la lunghezza di Analisi scorrendo le curve :
// - per CompoA devo indietreggiare
// - per CompoB devo avanzare
dLenStartA = Clamp( dLenA - dSize - dSizeTol, 0., dLenA) ;
dLenEndB = Clamp( dSize + dSizeTol, 0., dLenB) ;
// Se curve troppo corte non le analizzo
if ( dLenA - dLenStartA < dSizeTol || dLenEndB < dSizeTol)
return true ;
dLenEndA = dLenA ;
dLenStartB = 0. ;
}
// Se una delle due valida
else {
// Recupero la myCompoA come estremo finale e myCompoB come estremo iniziale
const CurveComposite& CompoX = ( CompoA.IsValid() ? CompoA : CompoB) ;
double dLen ;
if ( ! CompoX.GetLength( dLen))
return false ;
if ( dLen < 2. * ( dSize + dSizeTol) + 5. * EPS_SMALL)
return true ;
double dUS, dUE, dUStartA, dUEndB ;
if ( ! CompoX.GetDomain( dUS, dUE) ||
! CompoX.GetParamAtLength( dLen - dSize - dSizeTol - 2. * EPS_SMALL, dUStartA) ||
! CompoX.GetParamAtLength( dSize + dSizeTol + 2. * EPS_SMALL, dUEndB))
return false ;
// Per sicurezza [ migliorabile se stabile]
if ( ! myCompoA.CopyFrom( CompoX.CopyParamRange( dUStartA, dUE)) ||
! myCompoB.CopyFrom( CompoX.CopyParamRange( dUS, dUEndB)))
return false ;
dLenStartA = 0. ;
dLenStartB = 0. ;
if ( ! myCompoA.GetLength( dLenEndA) || ! myCompoB.GetLength( dLenEndB))
return false ;
dLenA = dLenEndA ;
dLenB = dLenEndB ;
}
#if DEBUG_FACE_SEARCH
VT.clear() ; VC.clear() ;
// Disegno simbolico
if ( CompoA.IsValid()) {
VT.emplace_back( CompoA.Clone()) ;
VC.emplace_back( AQUA) ;
}
if ( CompoB.IsValid()) {
VT.emplace_back( CompoB.Clone()) ;
VC.emplace_back( ORANGE) ;
}
//SaveGeoObj( VT, VC, "C:\\Temp\\Divergent.nge") ;
#endif
// Campiono le Curve alla ricerca di restrizioni
const int MAX_SAMPLE = 5 ;
const int MAX_OUT_SAMPLE = 2 ; // Per ignorare le piccole imperfezioni
int nCountOut = 0 ;
bool bExpandBox = false ;
for ( int i = 0 ; i <= MAX_SAMPLE ; ++ i) {
// Recupero i parametri su tale Curva
double dLenUA = Clamp( ( dLenStartA + i * ( dLenEndA - dLenStartA) / MAX_SAMPLE), EPS_SMALL, dLenA - EPS_SMALL) ;
double dLenUB = Clamp( ( dLenEndB - i * ( dLenEndB - dLenStartB) / MAX_SAMPLE), EPS_SMALL, dLenB - EPS_SMALL) ;
// Recupero i punti associati e la loro distanza
double dUA, dUB ;
if ( ! myCompoA.GetParamAtLength( dLenUA, dUA) || ! myCompoB.GetParamAtLength( dLenUB, dUB))
return false ;
Point3d ptA, ptB ;
if ( ! myCompoA.GetPointD1D2( dUA, ICurve::FROM_MINUS, ptA) ||
! myCompoB.GetPointD1D2( dUB, ICurve::FROM_PLUS, ptB))
return false ;
if ( SqDist( ptA, ptB) < ( dSize - dSizeTol) * ( dSize - dSizeTol))
++ nCountOut ;
else
nCountOut = 0 ;
#if DEBUG_FACE_SEARCH
CurveLine _Line ; _Line.Set( ptA, ptB) ;
VT.emplace_back( _Line.Clone()) ;
VC.emplace_back( nCountOut == 0 ? LIME : RED) ;
#endif
if ( nCountOut >= MAX_OUT_SAMPLE) {
bExpandBox = true ;
break ;
}
}
#if DEBUG_FACE_SEARCH
//SaveGeoObj( VT, VC, "C:\\Temp\\Divergent.nge") ;
#endif
// Se rilevata restrizione
if ( bExpandBox) {
// Recupero i due tratti lineari in tangenza
Vector3d vtA, vtB ;
if ( ! myCompoA.GetEndDir( vtA) || ! myCompoB.GetStartDir( vtB))
return false ;
Point3d ptA, ptB ;
if ( ! myCompoA.GetEndPoint( ptA) || ! myCompoB.GetStartPoint( ptB))
return false ;
// Cerco il punto a minima distanza tra esse ( suppongo che le linee tendano a convergere
// verso lo spigolo della striscia in analisi)
Point3d ptMinDistA, ptMinDistB ;
if ( ! DistLineLine( ptA, vtA, 1., ptB, - vtB, 1., false, false).GetMinDistPoints( ptMinDistA, ptMinDistB))
return false ;
Point3d ptInt = Media( ptMinDistA, ptMinDistB) ;
// Definisco un Box centrato nel punto medio di taglio tra CompoA e CompoB sul Box
BBox3d BBoxCheck ;
Point3d ptCenter = Media( ptA, ptB) ;
BBoxCheck.Add( ptCenter) ; // dSize / cos( 60deg)
BBoxCheck.Expand( dSizeTol + min( Dist( ptCenter, ptInt), 2. * dSize)) ;
#if DEBUG_FACE_SEARCH
CurveLine _LineA, _LineB ;
_LineA.Set( ptA, ptA + 1e2 * vtA) ;
_LineB.Set( ptB, ptB - 1e2 * vtB) ;
VT.emplace_back( _LineA.Clone()) ;
VC.emplace_back( YELLOW) ;
VT.emplace_back( _LineB.Clone()) ;
VC.emplace_back( YELLOW) ;
CurveComposite pCompoBox ;
pCompoBox.AddPoint( BBoxCheck.GetMin()) ;
pCompoBox.AddLine( BBoxCheck.GetMin() + BBoxCheck.GetDimX() * X_AX) ;
pCompoBox.AddLine( BBoxCheck.GetMax() - BBoxCheck.GetDimZ() * Z_AX) ;
pCompoBox.AddLine( BBoxCheck.GetMin() + BBoxCheck.GetDimY() * Y_AX) ;
pCompoBox.Close() ;
pCompoBox.SetExtrusion( Z_AX) ;
pCompoBox.SetThickness( BBoxCheck.GetDimZ()) ;
VT.emplace_back( pCompoBox.Clone()) ;
VC.emplace_back( YELLOW) ;
SaveGeoObj( VT, VC, "C:\\Temp\\Divergent.nge") ;
#endif
// Determino le due curve all'interno di questo Box
INTVECTOR vTBox ;
if ( ! Stm.GetAllTriaOverlapBox( BBoxCheck, vTBox) || vTBox.empty())
return false ;
double dMinSqDist = INFINITO ;
int nTria = 0 ;
for ( int nT = 0 ; nT < int( vTBox.size()) ; ++ nT) {
Triangle3d Tria ;
if ( ! Stm.GetTriangle( vTBox[nT], Tria))
return false ;
double dSqDist = 0. ;
if ( DistPointTriangle( ptCenter, Tria).GetSqDist( dSqDist) && dSqDist < dMinSqDist) {
dMinSqDist = dSqDist ;
nTria = vTBox[nT] ;
}
}
unordered_set<int> MysetAvoidTria( setAvoidTria) ;
unordered_set<int> MysetNewTria ;
if ( ! ClassifyTriangles( Stm, vTBox, nTria, dAngTol, MysetAvoidTria, MysetNewTria))
return false ;
COMPOVECTOR vCompoChain ;
if ( ! GetBordersByTriaInBox( Stm, BBoxCheck, dLinTol, MysetNewTria, vCompoChain, bBreak))
return false ;
#if DEBUG_FACE_SEARCH
for ( CurveComposite& Compo : vCompoChain) {
VT.emplace_back( Compo.Clone()) ;
VC.emplace_back( FUCHSIA) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\Divergent.nge") ;
#endif
// Se ottengo una sola curva, allora la striscia si è chiusa
if ( int( vCompoChain.size()) <= 1)
return true ;
// Se ottengo ancora due curve, allora la striscia non rispetta lo spessore minimo
bBreak = ( int( vCompoChain.size()) >= 2) ;
if ( bBreak) {
// Se devo fermare la ricerca e ho ancora CompoA e CompoB valide
if ( bValidA && bValidB) {
// Collego CompoA con CompoB e pulisco CompoB
Point3d ptStartB ;
if ( ! CompoB.GetStartPoint( ptStartB))
return false ;
CompoA.AddLine( ptStartB) ;
if ( ! CompoA.AddCurve( CompoB, dLinTol))
return false ;
CompoB.Clear() ;
}
}
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per analisi locale della superficie all'interno di un Box
static bool
GetBordersInBox( const SurfTriMesh& Stm, const BBox3d& BBoxCurr, int nFirstTria, const Point3d& ptSel,
double dSize, double dSizeTol, bool bAbsFirst, bool bRelFirst, double dAngTol,
double dLinTol, unordered_set<int>& setAvoidTria, unordered_set<int>& setNewTria,
CurveComposite& CompoA, CurveComposite& CompoB, Point3d& ptMid, Point3d& ptMid1,
int& nTria, int& nTria1, bool& bBreak, bool& bStop)
{
// Controllo dei parametri
if ( ! Stm.IsValid())
return false ;
bBreak = false ;
bStop = false ;
setNewTria.clear() ;
// Recupero tutti i Triangoli all'interno del Box
INTVECTOR vTBox ;
if ( ! Stm.GetAllTriaOverlapBox( BBoxCurr, vTBox) || vTBox.empty()) {
// [Non devo mai capitare qui, non ha senso]
bStop = true ;
return true ;
}
#if DEBUG_FACE_SEARCH
VT.clear() ; VC.clear() ;
CurveComposite pCompoBox ;
pCompoBox.AddPoint( BBoxCurr.GetMin()) ;
pCompoBox.AddLine( BBoxCurr.GetMin() + BBoxCurr.GetDimX() * X_AX) ;
pCompoBox.AddLine( BBoxCurr.GetMax() - BBoxCurr.GetDimZ() * Z_AX) ;
pCompoBox.AddLine( BBoxCurr.GetMin() + BBoxCurr.GetDimY() * Y_AX) ;
pCompoBox.Close() ;
pCompoBox.SetExtrusion( Z_AX) ;
pCompoBox.SetThickness( BBoxCurr.GetDimZ()) ;
VT.emplace_back( pCompoBox.Clone()) ;
VC.emplace_back( YELLOW) ;
VT.emplace_back( Stm.CloneTriangle( nFirstTria)) ;
VC.emplace_back( YELLOW) ;
IGeoPoint3d* _ptSel = CreateGeoPoint3d() ; _ptSel->Set( ptSel) ;
VT.emplace_back( _ptSel) ;
VC.emplace_back( RED) ;
//if ( bAbsFirst)
//SaveGeoObj( VT, VC, "C:\\Temp\\1.nge") ;
#endif
// Classifico i triangoli
if ( ! ClassifyTriangles( Stm, vTBox, nFirstTria, dAngTol, setAvoidTria, setNewTria))
return false ;
// Recupero solo i bordi validi interni al Box dai triangoli classificati
COMPOVECTOR vCompoChain ;
if ( ! GetBordersByTriaInBox( Stm, BBoxCurr, dLinTol, setNewTria, vCompoChain, bBreak))
return false ;
// Se primo triangolo in assoluto, ricavo i due tratti di interesse
if ( bAbsFirst) {
if ( ! CheckCurvesInBox( Stm, vCompoChain, ptSel, setNewTria, CompoA, CompoB, ptMid, ptMid1, nTria, nTria1))
return false ;
// Se entrambe chiuse, ho finito
if ( CompoA.IsClosed() && CompoB.IsClosed()) {
bStop = true ;
return true ;
}
}
// Se non sono il primo triangolo
else {
// Se primo triangolo relativo, tengo i punti di Trimming
if ( bRelFirst) {
// TODO -> non estendere le curve e tenerere i punti di Trim
}
// Aggiorno la CompoA con il nuovo tratto trovato
bool bUpdateA = false ;
if ( ! UpdateBorderByTriaAdj( CompoA, dLinTol, vCompoChain, bUpdateA))
return false ;
// Se CompoA si è aggiornata
if ( bUpdateA) {
// Se si è chiusa su se stessa, ho individuato il bordo
if ( CompoA.IsClosed()) {
bStop = true ;
return true ;
}
// Verifico se si è unita alla CompoB
if ( CompoB.IsValid()) {
CurveComposite CompoBTest ;
CompoBTest.CopyFrom( &CompoB) ;
bool bUpdateBTmp = false ;
if ( ! UpdateBorderByTriaAdj( CompoBTest, dLinTol, { CompoA}, bUpdateBTmp))
return false ;
if ( bUpdateBTmp) {
CompoB.Clear() ;
CompoA.CopyFrom( &CompoBTest) ;
bUpdateA = true ;
bBreak = true ;
}
}
}
// Aggiorno la Compo B con il nuovo tratto trovato
bool bUpdateB = false ;
if ( CompoB.IsValid()) {
if ( ! UpdateBorderByTriaAdj( CompoB, dLinTol, vCompoChain, bUpdateB))
return false ;
// Se CompoB si è aggiornata
if ( bUpdateB) {
// Se si è chiusa su se stessa, ho individuato il bordo
if ( CompoB.IsClosed()) {
bStop = true ;
return true ;
}
// Verifico se si è unita alla CompoA
if ( CompoA.IsValid()) {
CurveComposite CompoATest ;
CompoATest.CopyFrom( &CompoA) ;
bool bUpdateATmp = false ;
if ( ! UpdateBorderByTriaAdj( CompoATest, dLinTol, { CompoB}, bUpdateATmp))
return false ;
if ( bUpdateATmp) {
CompoA.Clear() ;
CompoB.CopyFrom( &CompoATest) ;
bUpdateA = true ;
bBreak = true ;
}
}
}
}
// Se sono il primo triangolo Relativo
if ( bRelFirst) {
// Accorcio le curve originarie
}
// Se non ho aggiornato nessuna delle due curve, sono in caso di divergenza
if ( ! bUpdateA && ! bUpdateB) {
// Può capitare con il primo Cubetto per triangoli grandi !
// ( da capire che cosa fare...)
// serve ????
}
// Verifico che le curve siano tra loro alla distanza stabilita
if ( dSizeTol > EPS_SMALL) {
if ( ! CheckBordersInBox( CompoA, CompoB, Stm, setAvoidTria, dAngTol, dLinTol, dSize, dSizeTol, bBreak))
return false ;
}
if ( bBreak) {
// Se caso ambiguo nel cubetto corrente, non aggiungo i triangoli trovati
setNewTria.clear() ;
return true ;
}
// Se CompoA e CompoB sono due curve distinte, calcolo i 2 punti medi e i 2 triangoli di ricerca,
// altrimenti ptMid1 sarà invalido e nTria1 sarà un triangolo nullo
if ( ! CalcMidPointForBorders( CompoA, CompoB, Stm, setNewTria, ptMid, ptMid1, nTria, nTria1))
return false ;
}
#if DEBUG_FACE_SEARCH
VT.clear() ; VC.clear() ;
pCompoBox.Clear() ;
pCompoBox.AddPoint( BBoxCurr.GetMin()) ;
pCompoBox.AddLine( BBoxCurr.GetMin() + BBoxCurr.GetDimX() * X_AX) ;
pCompoBox.AddLine( BBoxCurr.GetMax() - BBoxCurr.GetDimZ() * Z_AX) ;
pCompoBox.AddLine( BBoxCurr.GetMin() + BBoxCurr.GetDimY() * Y_AX) ;
pCompoBox.Close() ;
pCompoBox.SetExtrusion( Z_AX) ;
pCompoBox.SetThickness( BBoxCurr.GetDimZ()) ;
VT.emplace_back( pCompoBox.Clone()) ;
VC.emplace_back( YELLOW) ;
VT.emplace_back( Stm.CloneTriangle( nFirstTria)) ;
VC.emplace_back( YELLOW) ;
_ptSel = CreateGeoPoint3d() ; _ptSel->Set( ptSel) ;
VT.emplace_back( _ptSel) ;
VC.emplace_back( RED) ;
if ( CompoA.IsValid()) {
VT.emplace_back( CompoA.Clone()) ;
VC.emplace_back( AQUA) ;
}
if ( CompoB.IsValid()) {
VT.emplace_back( CompoB.Clone()) ;
VC.emplace_back( ORANGE) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\1.nge") ;
#endif
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per muovere il BoxLocale lungo le curve di Bordo
static bool
MarchAlongPath( const BBox3d& BBoxCurr, const SurfTriMesh& Stm,
unordered_set<int>& setAvoidTria, unordered_set<int>& setValidTria,
bool bFollowA, const Point3d& ptMid, int nTria, double dSize, double dSizeTol,
double dAngTol, bool& bRelFirst, CurveComposite& CompoA, CurveComposite& CompoB, bool& bStop)
{
// Variabili di controllo per la ricerca
BBox3d BBoxLast = BBoxCurr ;
Point3d ptRef = ptMid ;
int nTriaRef = nTria ;
bool bBreak = false ;
// Costanti di ricerca e contatori associati
const double EXPAND_EXTRA_TOL = 10. * EPS_SMALL ;
const int MAX_TRY = 4 ;
int nCount = 0 ;
// Inizio della ricerca
BBox3d MyBBoxCurr ;
while ( ! bBreak) {
// Definisco il nuovo Box
MyBBoxCurr.Reset() ;
MyBBoxCurr.Add( ptRef) ;
MyBBoxCurr.Expand( dSize + dSizeTol + EXPAND_EXTRA_TOL) ;
// Ricerco i triangoli
unordered_set<int> setNewTria ; setNewTria.reserve( Stm.GetTriangleCount()) ;
Point3d myPtMid, myPtMid1 ;
int nMyTria = 0, nMyTria1 = 0 ;
if ( ! GetBordersInBox( Stm, MyBBoxCurr, nTriaRef, ptRef, dSize, dSizeTol, false, bRelFirst,
dAngTol, 2. * EPS_SMALL, setAvoidTria, setNewTria, CompoA, CompoB,
myPtMid, myPtMid1, nMyTria, nMyTria1, bBreak, bStop))
return false ;
bRelFirst = false ;
// Memorizzo i triangoli validi ricavati
for ( auto Iter = setNewTria.begin() ; Iter != setNewTria.end() ; ++ Iter)
setValidTria.insert( *Iter) ;
// Se Direzione terminata o Curva chiusa
if ( bBreak || bStop)
break ;
// Ho determinato due curve distinte, il nuovo punto è quello più distante dal Box precedente
Point3d ptLast = ptRef ;
if ( myPtMid.IsValid() && myPtMid1.IsValid()) {
if ( bFollowA) {
ptRef = myPtMid ;
nTriaRef = nMyTria ;
}
else {
ptRef = myPtMid1 ;
nTriaRef = nMyTria1 ;
}
}
else {
if ( myPtMid.IsValid()) {
ptRef = myPtMid ;
nTriaRef = nMyTria ;
}
else {
ptRef = myPtMid1 ;
nTriaRef = nMyTria1 ;
}
}
// Se il nuovo punto è vicino al precedente, aggiorno il contatore
if ( SqDist( ptLast, ptRef) < ( ( dSize + dSizeTol) * ( dSize + dSizeTol) / 16.))
++ nCount ;
else
nCount = 0 ;
// Se troppi punti vicini tra loro, blocco la ricerca per sicurezza
if ( nCount >= MAX_TRY)
bBreak = true ;
// Il Box Corrente diventa il Box precedente
BBoxLast = MyBBoxCurr ;
#if DEBUG_FACE_SEARCH
VT.clear() ; VC.clear() ;
CurveComposite CompoBox ;
CompoBox.AddPoint( MyBBoxCurr.GetMin()) ;
CompoBox.AddLine( MyBBoxCurr.GetMin() + MyBBoxCurr.GetDimX() * X_AX) ;
CompoBox.AddLine( MyBBoxCurr.GetMax() - MyBBoxCurr.GetDimZ() * Z_AX) ;
CompoBox.AddLine( MyBBoxCurr.GetMin() + MyBBoxCurr.GetDimY() * Y_AX) ;
CompoBox.Close() ;
CompoBox.SetExtrusion( Z_AX) ;
CompoBox.SetThickness( MyBBoxCurr.GetDimZ()) ;
VT.emplace_back( CompoBox.Clone()) ;
VC.emplace_back( YELLOW) ;
IGeoPoint3d* _ptRef = CreateGeoPoint3d() ; _ptRef->Set( ptRef) ;
VT.emplace_back( _ptRef) ;
VC.emplace_back( RED) ;
if ( CompoA.IsValid()) {
VT.emplace_back( CompoA.Clone()) ;
VC.emplace_back( AQUA) ;
}
if ( CompoB.IsValid()) {
VT.emplace_back( CompoB.Clone()) ;
VC.emplace_back( ORANGE) ;
}
//SaveGeoObj( VT, VC, "C:\\Temp\\CurveUpdate.nge") ;
#endif
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per definire se il bordo di una TriMesh è una circonferenza
static bool
IsBorderACircle( const PolyLine& PL, double dShapeLinTol, Point3d& ptC, Vector3d& vtN, double& dRad)
{
// Se PolyLine aperta o non piana, non è un cerchio
Plane3d PlanePL ;
if ( ! PL.IsClosed() || ! PL.IsFlat( PlanePL, dShapeLinTol))
return false ;
// Creo un sistema di riferimento centrato nella PolyLine
Point3d ptCentroid ;
Frame3d frCurr ;
CurveComposite CurveCompo ; CurveCompo.FromPolyLine( PL) ;
if ( ! CurveCompo.GetCentroid( ptCentroid) ||
! frCurr.Set( ptCentroid, PlanePL.GetVersN()))
return false ;
// Porto una copia della PL in questo frame
PolyLine PLLoc = PL ; PLLoc.ToLoc( frCurr) ;
// Per ogni tratto salvo i suoi estremi e il punto medio in successione ( senza ripetizioni)
PNTVECTOR vPts ;
Point3d ptNext ;
PLLoc.GetFirstPoint( ptNext) ;
vPts.push_back( ptNext) ;
while ( PLLoc.GetNextPoint( ptNext)) {
vPts.push_back( Media( vPts.back(), ptNext)) ;
vPts.push_back( ptNext) ;
}
// Per ogni coppia di punti calcolo la Distanza Massima e Minima dal centro del cerchio locale ( ORIG)
double dSqMaxDist = 0. ;
double dSqMinDist = INFINITO ;
for ( int i = 0 ; i < int( floor( 0.5 * int( vPts.size()))) ; i = i + 2) {
double dSqLineDist = INFINITO ;
DistPointLine( ORIG, vPts[i], vPts[i + 1]).GetSqDist( dSqLineDist) ;
if ( dSqLineDist < dSqMinDist)
dSqMinDist = dSqLineDist ;
double dSqPtDist = SqDist( ORIG, vPts[i]) ;
if ( dSqPtDist > dSqMaxDist)
dSqMaxDist = dSqPtDist ;
}
// Se distanza minima e massima entro tolleranza, allora è una circonferenza
if ( abs( dSqMaxDist - dSqMinDist) < dShapeLinTol * dShapeLinTol) {
ptC = ptCentroid ;
vtN = PlanePL.GetVersN() ;
dRad = 0.5 * ( sqrt( dSqMaxDist) + sqrt( dSqMinDist)) ;
return true ;
}
return false ;
}
// ----------------------------------------------------------------------------
// Funzione per estrarre Geometrie note da una sola TriMesh
static bool
GetShapesFromSurf( const ISurf* pSurf, double dShapeLinTol, double dShapeAngTol, double dLinTol,
double dEdgeLinTol, double dAngTol, double dFaceAngTol, const STRVECTOR& vsShapes,
ISURFPOVECTOR& vSurfSel, ICRVCOMPOPOMATRIX& matCompoBorders)
{
vSurfSel.clear() ;
matCompoBorders.clear() ;
// Verifico la validità della superficie
if ( pSurf == nullptr || ! pSurf->IsValid())
return false ;
// Recupero il Tipo
int nType = pSurf->GetType() ;
ISURFTMPOVECTOR vSurfTmSelTmp ;
// Se superficie di Besier, non faccio nulla (?)
if ( nType == SRF_BEZIER)
return true ;
// Se superficie TriMesh
else if ( nType == SRF_TRIMESH) {
// Recupero la TriMesh
const SurfTriMesh* pStmBasic = GetBasicSurfTriMesh( pSurf) ;
if ( pStmBasic == nullptr || ! pStmBasic->IsValid())
return false ;
// Ciclo di Analisi Triangoli
const int MAXTRY = 1000 ;
int nCount = 0 ;
int nTriaCheck = 0 ;
BOOLVECTOR vbTria( pStmBasic->GetTriangleCount(), false) ;
while ( nCount < MAXTRY && nTriaCheck < pStmBasic->GetTriangleCount()) {
// Recupero il primo triangolo valido disponibile non ancora analizzato
int nFirstTria = 0 ;
for ( int nT = 0 ; nT < ssize( vbTria) ; ++ nT) {
if ( ! vbTria[nT]) {
nFirstTria = nT ;
break ;
}
}
unordered_set<int> setNewTria ; setNewTria.reserve( pStmBasic->GetTriangleCount()) ;
unordered_set<int> setAvoidTria ; setAvoidTria.reserve( pStmBasic->GetTriangleCount()) ;
// Collezioni di triangoli da analizzare
INTVECTOR vTria ; vTria.reserve( pStmBasic->GetTriangleCount()) ;
vTria.push_back( nFirstTria) ;
// Finchè ho triangoli da visitare
while ( ! vTria.empty()) {
// Recupero il triangolo corrente
int nCurrTria = vTria.back() ;
// Elimino il triangolo corente
vTria.pop_back() ;
// Se triangolo da evitare, passo al successivo
if ( setAvoidTria.find( nCurrTria) != setAvoidTria.end())
continue ;
// Se triangolo mai visitato lo aggiungo tra quelli visitati, altrimenti passo al successivo
if ( vbTria[nCurrTria])
continue ;
vbTria[nCurrTria] = true ;
++ nTriaCheck ;
// Inserisco il triangolo corrente
setNewTria.insert( nCurrTria) ;
// Recupero il triangolo corrente e le sue adiacenze
int nTriaVertices[3] ;
if ( ! pStmBasic->GetTriangle( nCurrTria, nTriaVertices))
return false ;
Triangle3d Tria ;
if ( ! pStmBasic->GetTriangle( nCurrTria, Tria))
return false ;
int nIdAdjTriaId[3] ;
if ( ! pStmBasic->GetTriangleAdjacencies( nCurrTria, nIdAdjTriaId))
return false ;
// Scorro le adiacenze
for ( int nAdj = 0 ; nAdj < 3 ; ++ nAdj) {
// Recupero l'indice del triangolo corrente
int nTriaAdj = nIdAdjTriaId[nAdj] ;
// Se non ho adiacenza, non faccio nulla
if ( nTriaAdj == SVT_NULL)
continue ;
// Recupero il triangolo adiacente
Triangle3d TriaAdj ;
if ( ! pStmBasic->GetTriangle( nTriaAdj, TriaAdj))
return false ;
// Se la normale è fuori dalla tolleranza, memorizzo il triangolo tra quelli da scartare
if ( Tria.GetN() * TriaAdj.GetN() < cos( ( dFaceAngTol + EPS_ANG_SMALL) * DEGTORAD)) {
setAvoidTria.insert( nTriaAdj) ;
continue ;
}
// Inserisco il triangolo per la ricerca futura
vTria.push_back( nTriaAdj) ;
}
}
++ nCount ;
// Se ho nuovi triangoli, definisco una superficie da essi
if ( ! setNewTria.empty()) {
#if DEBUG_SHAPE_STM
VT.clear() ; VC.clear() ;
VT.emplace_back( pStmBasic->Clone()) ;
VC.emplace_back( BLACK) ;
StmFromTriangleSoup _TriaSoup ; _TriaSoup.Start() ;
for ( auto _Iter = setNewTria.begin() ; _Iter != setNewTria.end() ; ++ _Iter) {
Triangle3d _Tria ;
if ( ! pStmBasic->GetTriangle( *_Iter, _Tria))
return false ;
_TriaSoup.AddTriangle( _Tria) ;
}
_TriaSoup.End() ;
VT.emplace_back( _TriaSoup.GetSurf()) ;
VC.emplace_back( LIME) ;
//SaveGeoObj( VT, VC, "C:\\Temp\\MyShape.nge") ;
VT.clear() ; VC.clear() ;
#endif
StmFromTriangleSoup TriaSoup ; TriaSoup.Start() ;
for ( auto Iter = setNewTria.begin() ; Iter != setNewTria.end() ; ++ Iter) {
Triangle3d Tria ;
if ( ! pStmBasic->GetTriangle( *Iter, Tria))
return false ;
TriaSoup.AddTriangle( Tria) ;
}
TriaSoup.End() ;
PtrOwner<ISurfTriMesh> pStmTmp( TriaSoup.GetSurf()) ;
if ( ! IsNull( pStmTmp) && pStmTmp->IsValid() && pStmTmp->GetTriangleCount() > 0) {
if ( ! vSurfTmSelTmp.emplace_back( Release( pStmTmp)))
return false ;
}
}
}
}
// Se non ho ricavato superfici, esco
if ( vSurfTmSelTmp.empty())
return true ;
// Per ognuna di esse ricerco le geometrie compatibili
for ( int i = 0 ; i < ssize( vSurfTmSelTmp) ; ++ i) {
// Recupero i Loops
POLYLINEVECTOR vPL ;
vSurfTmSelTmp[i]->GetLoops( vPL) ;
// Elimino i Loop che non sono chiusi
vPL.erase(
remove_if( vPL.begin(), vPL.end(), []( const PolyLine& PL) {
return ( ! PL.IsClosed()) ;
}),
vPL.end()
) ;
// Se non ho esattamente due Loops, passo alla superficie successiva
if ( ssize( vPL) != 2)
continue ;
// Se devo ricercare Circonferenze
if ( find_if( vsShapes.begin(), vsShapes.end(), [&]( const string& sStr) {
return ( sStr.compare( sCircle) == 0) ;
}) != vsShapes.end()) {
// Verifico che le due PolyLine siano circonferenze
Point3d ptCA, ptCB ; Vector3d vtNA, vtNB ; double dRadA, dRadB ;
if ( IsBorderACircle( vPL[0], dShapeLinTol, ptCA, vtNA, dRadA) &&
IsBorderACircle( vPL[1], dShapeAngTol, ptCB, vtNB, dRadB)) {
// Definisco le due circonferenze
PtrOwner<ICurveArc> pCirA( CreateCurveArc()) ;
PtrOwner<ICurveArc> pCirB( CreateCurveArc()) ;
if ( ! IsNull( pCirA) && ! IsNull( pCirB) &&
pCirA->Set( ptCA, vtNA, dRadA) &&
pCirB->Set( ptCB, vtNB, dRadB)) {
vSurfSel.emplace_back( GetSurf( Release( vSurfTmSelTmp[i]))) ;
matCompoBorders.emplace_back( ICRVCOMPOPOVECTOR{}) ;
matCompoBorders.back().resize( 2) ;
matCompoBorders.back()[0].Set( ConvertCurveToComposite( Release( pCirA))) ;
matCompoBorders.back()[1].Set( ConvertCurveToComposite( Release( pCirB))) ;
// l'Approssimazione delle curve prevede che io usi sempre tratti lineari, quindi approssimo
PolyLine PLA ; matCompoBorders.back()[0]->ApproxWithLines( dLinTol, dAngTol, ICurve::APL_SPECIAL, PLA) ;
PolyLine PLB ; matCompoBorders.back()[0]->ApproxWithLines( dLinTol, dAngTol, ICurve::APL_SPECIAL, PLB) ;
matCompoBorders.back()[0]->Clear() ; matCompoBorders.back()[0]->FromPolyLine( PLA) ;
matCompoBorders.back()[1]->Clear() ; matCompoBorders.back()[1]->FromPolyLine( PLB) ;
}
}
#if DEBUG_SHAPE_STM
CurveComposite _CompoA ; _CompoA.FromPolyLine( vPL[0]) ;
CurveComposite _CompoB ; _CompoB.FromPolyLine( vPL[1]) ;
VT.emplace_back( _CompoA.Clone()) ;
VT.emplace_back( _CompoB.Clone()) ;
Color _cCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
VC.emplace_back( _cCol) ;
VC.emplace_back( _cCol) ;
#endif
}
}
// #if DEBUG_SHAPE_STM
// SaveGeoObj( VT, VC, "C:\\Temp\\myAutoBorders.nge") ;
// #endif
return true ;
}
//-----------------------------------------------------------------------------
//-------------------------------- Funzioni Export ----------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Funzione per il calcolo degli Edges Grezzi
bool
GetTrimmingRawEdges( const CISURFPVECTOR& vSurf, const SELVECTOR& vSurfFace,
double dLinTol, double dAngTol,
ICRVCOMPOPOVECTOR& vCompoRawEdges)
{
// Controllo la validità delle superfici
for ( const ISurf* pSurf : vSurf) {
if ( pSurf == nullptr || ! pSurf->IsValid()) {
LOG_ERROR( GetEGkLogger(), "Error in Trimming : Detected invalid Surf") ;
return false ;
}
}
// Pulizia dei parametri di ritorno
vCompoRawEdges.clear() ;
// Se non ho elementi di selezione, non faccio nulla
if ( vSurfFace.empty())
return true ;
// Controllo sulla tolleranza lineare
double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
// Controllo sulla tolleranza angolare
double dMyAngTol = Clamp( dAngTol, 1., 45.) ;
// Recupero i bordi semplici definiti dalle superfici e dalle loro eventuali facce selezionate
POLYLINEVECTOR vPLBorders ;
if ( ! GetSurfBorders( vSurf, vSurfFace, dMyLinTol, vPLBorders)) {
LOG_ERROR( GetEGkLogger(), "Error in Trimming : Borders extraction failed") ;
return false ;
}
// Recupero le curve di bordo grezze
if ( ! GetRawEdges( vPLBorders, dMyLinTol, dMyAngTol, vCompoRawEdges)) {
LOG_ERROR( GetEGkLogger(), "Error in Trimming : Border simplification failed") ;
return false ;
}
return true ;
}
//------------------------------------------------------------------------------
// Funzione per il calcolo automatico degli Edge finali
// Se c'è la necessità di spezzare le curve di bordo si procede in questo modo :
// 1) Si controlla l'esistenza di eventuali punti di rottura
// 2) Se non ci sono punti di rottura, si cerca un valore di Thick e ThickTol
// 3) Se non c'è una valore di Thick e ThickTol si procede per una rottura generica
// Valori di Default dei parametri per evitare i rispettivi controlli :
// - vBreakingPts = {}
// - dThick = 0., dThickTol = 0.
bool
GetTrimmingFinalBorders( ICRVCOMPOPOVECTOR& vCompoBezierEdges, double dLinTol, double dAngTol,
BIPNTVECTOR& vBreakingPts, double dThick, double dThickTol)
{
// Controllo sulla tolleranza lineare
double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
// Controllo sulla tolleranza angolare
double dMyAngTol = Clamp( dAngTol, 1., 45.) ;
// Se non ho curve, errore
if ( vCompoBezierEdges.empty()) {
LOG_INFO( GetEGkLogger(), "Warning in Trimming : No Edges detected") ;
return false ;
}
// Se ho 1 curva, allora cerco di spezzarla
else if ( int( vCompoBezierEdges.size()) == 1) {
// Se sono presenti dei punti di rottura
bool bOk = true ;
if ( ! vBreakingPts.empty())
bOk = BreakCompoPathces( vCompoBezierEdges, dMyLinTol, dMyAngTol, vBreakingPts) ;
// Se invece è presente il valore di Thick
else if ( dThick > EPS_SMALL)
bOk = BreakCompoPathces( vCompoBezierEdges, dMyLinTol, dMyAngTol, dThick, dThickTol) ;
else
// Se generica
bOk = BreakCompoPathces( vCompoBezierEdges, dMyLinTol, dMyAngTol) ;
if ( ! bOk)
LOG_INFO( GetEGkLogger(), "Warning in Trimming : Breaking curves failed") ;
}
// Se ho 2 curve, perfetto !
else if ( int( vCompoBezierEdges.size()) == 2)
return true ;
// Se più curve, errore
else {
LOG_INFO( GetEGkLogger(), "Warning in Trimming : More than 2 Edges detected") ;
return false ;
}
return true ;
}
// -----------------------------------------------------------------------------
// Funzione per ricavare i bordi a partire da un insieme di superfici; questi vengono
// calcolati mediante analisi delle normali lungo il bordo delle Patches di Surfs
bool
GetTrimmingFinalBorders( CISURFPVECTOR& vpSurf, const SELVECTOR& vSurfFaces, double dLinTol, double dAngTol, double dThick,
ICRVCOMPOPOVECTOR& vCompoBezierEdges)
{
// Pulizia dei parametri di ritorno
vCompoBezierEdges.clear() ;
// Se non ho elementi di selezione, non faccio nulla
if ( vSurfFaces.empty())
return true ;
// Lo spessore deve essere positivo
if ( dThick < 10. * EPS_SMALL) // coerente con Offset minimo
return false ;
// Verifico che le superfici siano tutte valide ed aperte
for ( const ISurf* pSurf : vpSurf) {
if ( pSurf == nullptr || ! pSurf->IsValid() || pSurf->IsClosed())
return false ;
}
// Controllo sulla tolleranza lineare
double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
// Controllo sulla tolleranza angolare
double dMyAngTol = Clamp( dAngTol, 1., 45.) ;
// Recupero la superficie TriMesh di cui fare l'Offset
PtrOwner<const SurfTriMesh> pStm( nullptr) ;
if ( int( vpSurf.size()) == 1) {
const ISurf* pSurf = vpSurf[0] ;
if ( pSurf == nullptr)
return false ;
int nType = pSurf->GetType() ;
if ( nType == SRF_TRIMESH)
pStm.Set( CloneBasicSurfTriMesh( pSurf)) ;
else if ( nType == SRF_BEZIER) {
const ISurfBezier* pSurfBz = GetSurfBezier( pSurf) ;
if ( pSurfBz != nullptr)
pStm.Set( CloneBasicSurfTriMesh( pSurfBz->GetApproxSurf( dMyLinTol))) ;
}
}
else {
// [ Soluzione temporanea ]
StmFromTriangleSoup mySoup ; mySoup.Start() ;
for ( const ISurf* pSurf : vpSurf) {
if ( pSurf == nullptr)
return false ;
int nType = pSurf->GetType() ;
if ( nType == SRF_TRIMESH)
mySoup.AddSurfTriMesh( *GetSurfTriMesh( pSurf)) ;
else if ( nType == SRF_BEZIER) {
const ISurfBezier* pSrfBz = GetSurfBezier( pSurf) ;
if ( pSrfBz == nullptr)
return false ;
PtrOwner<ISurfTriMesh> pStmTmp( pSrfBz->GetApproxSurf( dMyLinTol)) ;
if ( ! IsNull( pStmTmp) && pStmTmp->IsValid())
mySoup.AddSurfTriMesh( *pStmTmp) ;
}
}
mySoup.End() ;
pStm.Set( GetBasicSurfTriMesh( mySoup.GetSurf())) ;
}
if ( IsNull( pStm) || ! pStm->IsValid() || pStm->IsClosed())
return false ;
// Eseguo l'Offset in negativo della superficie passando per lo ZMap
double dPrec = max( min( dThick / 4., 10. * max( dMyLinTol, EPS_SMALL)), 0.5) ;
PtrOwner<ISurfTriMesh> pStmOffs( CreateSurfTriMeshesOffset( { pStm}, - dThick, dPrec)) ;
if ( IsNull( pStmOffs) || ! pStmOffs->IsValid())
return false ;
// Recupero i Loop dalla superficie originaria e i Loop della superficie di Offset
POLYLINEVECTOR vPL, vPLOffs ;
if ( ! pStm->GetLoops( vPL) || ! pStmOffs->GetLoops( vPLOffs))
return false ;
#if DEBUG_BORDERS_BY_NORMALS
for ( const ISurf* _pSurf : vpSurf) {
VT.emplace_back( _pSurf->Clone()) ;
VC.emplace_back( LIME) ;
}
VT.emplace_back( pStmOffs->Clone()) ;
VC.emplace_back( ORANGE) ;
SaveGeoObj( VT, VC, "C:\\Temp\\TwoSurfs.nge") ;
#endif
// Trasformo ogni Loop in curva composita
ICRVCOMPOPOVECTOR vCompoLoops ; vCompoLoops.reserve( vPL.size()) ;
for ( const PolyLine& PL : vPL) {
if ( PL.IsClosed()) {
if ( ! vCompoLoops.emplace_back( CreateBasicCurveComposite()) ||
! vCompoLoops.back()->FromPolyLine( PL) ||
! vCompoLoops.back()->IsValid())
return false ;
}
}
ICRVCOMPOPOVECTOR vCompoOffsLoops ; vCompoOffsLoops.reserve( vPLOffs.size()) ;
for ( const PolyLine& PLOffs : vPLOffs) {
if ( PLOffs.IsClosed()) {
if ( ! vCompoOffsLoops.emplace_back( CreateCurveComposite()) ||
! vCompoOffsLoops.back()->FromPolyLine( PLOffs) ||
! vCompoOffsLoops.back()->IsValid())
return false ;
}
}
#if DEBUG_BORDERS_BY_NORMALS
for ( ICurveComposite* pCompo : vCompoLoops) {
VT.emplace_back( pCompo->Clone()) ;
VC.emplace_back( GREEN) ;
}
for ( ICurveComposite* pCompoOffs : vCompoOffsLoops) {
VT.emplace_back( pCompoOffs->Clone()) ;
VC.emplace_back( BLUE) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\TwoSurfs.nge") ;
#endif
// Per ogni curva della superficie originale cerco la sua associata
BOOLVECTOR vIndMatched( vCompoOffsLoops.size(), false) ;
for ( const ICurveComposite* pCompoLoop : vCompoLoops) {
// sposto il punto iniziale della curva nel tratto più lungo
double dMaxLen = - INFINITO ;
int nIndCrv = 0 ;
for ( int nCrv = 0 ; nCrv < pCompoLoop->GetCurveCount() ; ++ nCrv) {
const ICurve* pCurve = pCompoLoop->GetCurve( nCrv) ;
if ( pCurve != nullptr && pCurve->IsValid()) {
double dCurrLen = 0. ;
pCurve->GetLength( dCurrLen) ;
if ( dCurrLen > dMaxLen) {
dMaxLen = dCurrLen ;
nIndCrv = nCrv ;
}
}
}
Point3d ptRef ;
pCompoLoop->GetPointD1D2( nIndCrv + 0.5, ICurve::FROM_MINUS, ptRef) ;
// dalle altre curve derivanti dalla superficie di Offset cerco quella più vicina al punto inziale
double dMinSqDist = INFINITO ;
int nIndOffsCrv = -1 ;
for ( int nOffsCrv = 0 ; nOffsCrv < int( vCompoOffsLoops.size()) ; ++ nOffsCrv) {
if ( vIndMatched[nOffsCrv])
continue ;
// recupero la curva e calcolo la distanza
const ICurveComposite* pCompoOffsLoop = vCompoOffsLoops[nOffsCrv] ;
int nFlag = 0 ;
Point3d ptCurrMinDist ;
if ( DistPointCurve( ptRef, *pCompoOffsLoop).GetMinDistPoint( 0., ptCurrMinDist, nFlag)) {
double dCurrSqDist = SqDist( ptRef, ptCurrMinDist) ;
if ( dCurrSqDist < dMinSqDist) {
dMinSqDist = dCurrSqDist ;
nIndOffsCrv = nOffsCrv ;
}
}
}
if ( nIndOffsCrv == -1)
return false ;
vIndMatched[ nIndOffsCrv] = true ;
// associo le due curve ( quindi consecutive nel vettore delle curve risultanti)
vCompoBezierEdges.emplace_back( CloneCurveComposite( pCompoLoop)) ;
if ( ! ApproxCurveWithBezier( vCompoBezierEdges.back(), dMyLinTol, dMyAngTol))
return false ;
vCompoBezierEdges.emplace_back( CloneCurveComposite( vCompoOffsLoops[nIndOffsCrv])) ;
if ( ! ApproxCurveWithBezier( vCompoBezierEdges.back(), dMyLinTol, dMyAngTol))
return false ;
}
return true ;
}
// -----------------------------------------------------------------------------
// Funzione per approssimare le curve di Bordo grezze ( tratti lineari) in
// Patch di curve di Bezier
bool
GetTrimmingBezierEdges( ICRVCOMPOPOVECTOR& vCompoRawEdges, double dLinTol, double dAngTol,
ICRVCOMPOPOVECTOR& vBezierEdges)
{
// Pulizia del parametro di ritorno
vBezierEdges.clear() ;
// Controllo sulla tolleranza lineare
double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
// Controllo sulla tolleranza angolare
double dMyAngTol = Clamp( dAngTol, 1., 45.) ;
#if DEBUG_EDGES
VC.clear() ; VT.clear() ;
for ( int _i = 0 ; _i < int( vCompoRawEdges.size()) ; ++ _i) {
VT.emplace_back( vCompoRawEdges[_i]->Clone()) ;
VC.emplace_back( RED) ;
}
#endif
// Approssimo i bordi grezzi
vBezierEdges.reserve( vCompoRawEdges.size()) ;
for ( int i = 0 ; i < int( vCompoRawEdges.size()) ; ++ i) {
PtrOwner<ICurveComposite> pCompoTmp( CloneCurveComposite( vCompoRawEdges[i])) ;
if ( IsNull( pCompoTmp) ||
! ApproxCurveWithBezier( pCompoTmp, dMyLinTol, dMyAngTol) ||
! vBezierEdges.emplace_back( Release( pCompoTmp))) {
LOG_ERROR( GetEGkLogger(), "Error in Trimming : Approxing edge failed") ;
return false ;
}
}
#if DEBUG_EDGES
VC.clear() ; VT.clear() ;
for ( int _i = 0 ; _i < int( vCompoTmpEdges.size()) ; ++ _i) {
VT.emplace_back( vCompoTmpEdges[_i]->Clone()) ;
VC.emplace_back( ORANGE) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\ApproxBorder.nge") ;
#endif
return true ;
}
//------------------------------------------------------------------------------
// Funzione per ottenere i punti di sincronizzazione tra due curve di Bezier per
// la costruzione della superficie rigata stessa
bool
GetTrimmingSurfBzSyncPoints( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
double dLinTol, BIPNTVECTOR& vSyncPoints)
{
// Verifica validità delle curve per la creazione della Bezier rigata
PtrOwner<ICurveComposite> pCompoEdge1( ConvertCurveToComposite( pCrvEdge1->Clone())) ;
PtrOwner<ICurveComposite> pCompoEdge2( ConvertCurveToComposite( pCrvEdge2->Clone())) ;
if ( ! ManageRuledBorders( pCompoEdge1, pCompoEdge2))
return false ;
vSyncPoints.clear() ;
// Controllo sulla tolleranza lineare
double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
#if DEBUG_SYNC_POINTS
VT.clear() ; VC.clear() ;
VT.emplace_back( pCompoEdge1->Clone()) ;
VC.emplace_back( AQUA) ;
VT.emplace_back( pCompoEdge2->Clone()) ;
VC.emplace_back( ORANGE) ;
#endif
// Definisco la superficie di Bezier rigata
PtrOwner<SurfBezier> pSBzRuled( GetBasicSurfBezier( GetSurfBezierRuled( pCompoEdge1, pCompoEdge2, ISurfBezier::RLT_B_MINDIST_PLUS, dMyLinTol))) ;
if ( IsNull( pSBzRuled) || ! pSBzRuled->IsValid())
return false ;
// Recupero i punti di sincronizzazione e li restituisco
ICURVEPOVECTOR vCrv ;
pSBzRuled->GetAllPatchesIsocurves( false, vCrv) ;
vSyncPoints.reserve( vCrv.size()) ;
for ( int i = 0 ; i < int( vCrv.size()) ; ++ i) {
if ( ! IsNull( vCrv[i]) && vCrv[i]->IsValid()) {
#if DEBUG_SYNC_POINTS
VT.emplace_back( vCrv[i]->Clone()) ;
VC.emplace_back( LIME) ;
#endif
Point3d ptStart ; vCrv[i]->GetStartPoint( ptStart) ;
Point3d ptEnd ; vCrv[i]->GetEndPoint( ptEnd) ;
if ( ! AreSamePointApprox( ptStart, ptEnd))
vSyncPoints.emplace_back( make_pair( ptStart, ptEnd)) ;
}
}
#if DEBUG_SYNC_POINTS
SaveGeoObj( VT, VC, "C:\\Temp\\BorderSyncPoints.nge") ;
#endif
return true ;
}
//------------------------------------------------------------------------------
// Funzione per il calcolo della superficie di Bezier rigata
// NB. Possono essere passati dei parametri opzionali come vIndPriority e vIndVisible :
// - Se non presenti, la superficie Ruled Bezier viene costruita in modo standard
// - Se sono presenti degli indici di priorità e/o degli indici di visibilità, significa che
// si vuole costruire una superficie diversa da quella standard, dove i tratti prioritari
// sono quelli che più determinano il cambiamento della superficie ( in quanto diversi da quelli
// originali) e i tratti visibili servono per determinare l'intervallo di influenza della modifica
// alla superficie nei pressi dei tratti lineari di sincronizzazione prioritari
ISurfBezier*
GetTrimmingRuledBezier( const CISURFPVECTOR& vSurf, const ICurve* pCrvEdge1,
const ICurve* pCrvEdge2, double dLinTol, const BIPNTVECTOR& vSyncPoints,
const INTVECTOR& vIndPriority, const INTVECTOR& vIndVisible)
{
// Verifica validità delle curve per la creazione della Bezier rigata
PtrOwner<ICurveComposite> pCompoEdge1( ConvertCurveToComposite( pCrvEdge1->Clone())) ;
PtrOwner<ICurveComposite> pCompoEdge2( ConvertCurveToComposite( pCrvEdge2->Clone())) ;
if ( ! ManageRuledBorders( pCompoEdge1, pCompoEdge2))
return nullptr ;
// Controllo sulla tolleranza lineare
double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
#if DEBUG_BEZIER_RULED
VT_Glob.emplace_back( pCompoEdge1->Clone()) ;
VT_Glob.emplace_back( pCompoEdge2->Clone()) ;
VC_Glob.emplace_back( ORANGE) ;
VC_Glob.emplace_back( AQUA) ;
#endif
// Creo la superficie di Bezier
PtrOwner<ISurfBezier> pSurfBz( CreateSurfBezier()) ;
if ( IsNull( pSurfBz))
return nullptr ;
// Se non ho punti di controllo forzati
if ( vSyncPoints.empty()) {
pSurfBz.Set( GetSurfBezierRuled( pCompoEdge1, pCompoEdge2, ISurfBezier::RLT_B_MINDIST_PLUS, dMyLinTol)) ;
if ( IsNull( pSurfBz) || ! pSurfBz->IsValid()) {
LOG_ERROR( GetEGkLogger(), "Error in Trimming : Ruled Bezier invalid") ;
return nullptr ;
}
}
// Se ho punti di controllo forzati
else {
// Recupero i tratti lineari di sincronizzazione
ICURVEPOVECTOR vCrv ; vCrv.reserve( vSyncPoints.size()) ;
for ( const BIPOINT& PtSPtE : vSyncPoints) {
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
if ( IsNull( pLine) || ! pLine->Set( PtSPtE.first, PtSPtE.second))
return nullptr ;
vCrv.emplace_back( Release( pLine)) ;
}
#if DEBUG_BEZIER_RULED
for ( int _i = 0 ; _i < int( vCrv.size()) ; ++ _i) {
VT_Glob.emplace_back( vCrv[_i]) ;
VC_Glob.emplace_back( LIME) ;
}
#endif
// Definisco la superficie
ICURVEPOVECTOR vNewCrv ;
INTVECTOR vShown ;
INTINTVECTOR vNewOrEdited ;
pSurfBz.Set( GetSurfBezierRuledGuided( pCompoEdge1, pCompoEdge2, vCrv, vNewCrv, vShown, vNewOrEdited, dMyLinTol)) ;
if ( IsNull( pSurfBz) || ! pSurfBz->IsValid()) {
LOG_ERROR( GetEGkLogger(), "Error in Trimming : Ruled Bezier with Sync Points invalid") ;
return nullptr ;
}
}
#if DEBUG_BEZIER_RULED
VT_Glob.emplace_back( pSurfBz->Clone()) ;
VC_Glob.emplace_back( LIME) ;
SaveGeoObj( VT_Glob, VC_Glob, "C:\\Temp\\TestBz.nge") ;
#endif
// La superficie deve essere orientata correttamente con le geometrie iniziali ( privilegio le TriMesh)
if ( ! vSurf.empty()) {
bool bOk = true ;
Point3d ptPos ;
Vector3d vtN ;
if ( pSurfBz->GetPointNrmD1D2( 0.1, 0.1, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptPos, vtN)) {
Point3d ptCheck = ptPos + 10. * EPS_SMALL * vtN ;
for ( const ISurf* pSurf : vSurf) {
if ( pSurf->GetType() == SRF_TRIMESH) {
if ( DistPointSurfTm( ptCheck, *GetSurfTriMesh( pSurf)).IsPointOnLeftSide())
pSurfBz->Invert() ;
bOk = true ;
break ;
}
}
if ( ! bOk) {
for ( const ISurf* pSurf : vSurf) {
if ( pSurf->GetType() == SRF_BEZIER) {
if ( DistPointSurfBz( ptCheck, *GetSurfBezier( pSurf)).IsPointOnLeftSide())
pSurfBz->Invert() ;
bOk = true ;
break ;
}
}
}
}
}
return ( IsNull( pSurfBz) || ! pSurfBz->IsValid() ? nullptr : Release( pSurfBz)) ;
}
//------------------------------------------------------------------------------
// Funzione per la ricerca di facce adiacenti su una superficie TriMesh.
// Dato un insieme iniziale di facce, per ciascuna di esse vengono analizzate le facce adiacenti.
// Se la normale di una faccia adiacente forma un angolo entro la tolleranza specificata,
// quella faccia viene memorizzata e considerata come nuovo punto di partenza per la ricerca
// di ulteriori adiacenze.
bool
GetTrimmingStmAdjTria( const ISurfTriMesh* pStm, const INTVECTOR& vTria, const PNTVECTOR& vPts,
double dAngTol, double dSize, double dSizeTol, INTVECTOR& vOtherTria)
{
// Verifico la validità della superficie TriMesh e l'esistenza di triangoli di riferimento
if ( ! pStm->IsValid() || vTria.empty())
return false ;
// Recupero la superficie di base
const SurfTriMesh* pStmBasic = GetBasicSurfTriMesh( pStm) ;
if ( pStmBasic == nullptr || ! pStmBasic->IsValid())
return false ;
// Definisco un Box3d nel punto di Selezione di dimensioni pari al doppio della dimensione della
// striscia di ricerca considerando la tolleranza
Triangle3d firstTria ;
if ( ! pStmBasic->GetTriangle( vTria[0], firstTria))
return false ;
BBox3d BBoxCurr ;
BBoxCurr.Add( vPts[0]) ;
const double EXPAND_EXTRA_TOL = 10. * EPS_SMALL ;
BBoxCurr.Expand( ( dSize + dSizeTol + EXPAND_EXTRA_TOL)) ;
// Recupero i triangoli validi all'interno del Box e definisco i primi due tratti lineari
// per le curve di Bordo
bool bBreak = false, bStop = false ;
unordered_set<int> setAvoidTria ; setAvoidTria.reserve( pStmBasic->GetTriangleCount()) ;
unordered_set<int> setValidTria ; setValidTria.reserve( pStmBasic->GetTriangleCount()) ;
unordered_set<int> setNewTria ; setNewTria.reserve( pStmBasic->GetTriangleCount()) ;
Point3d ptMid, ptMid1 ;
int nTria = 0, nTria1 = 0 ;
CurveComposite CompoA, CompoB ;
if ( ! GetBordersInBox( *pStmBasic, BBoxCurr, vTria[0], vPts[0], dSize, dSizeTol, true, true,
dAngTol, 2. * EPS_SMALL, setAvoidTria, setNewTria, CompoA, CompoB,
ptMid, ptMid1, nTria, nTria1, bBreak, bStop))
return false ;
// Se triangolo iniziale non significativo, devo sceglierne un altro
if ( bBreak) {
return true ; // ??? come lo comunico all'utente
}
// Se ho già ricavato tutto, ho finito
else if ( bStop) {
for ( auto Iter = setNewTria.begin() ; Iter != setNewTria.end() ; ++ Iter)
vOtherTria.push_back( *Iter) ;
return true ;
}
// I nuovi triangoli della striscia vengono memorizzati
for ( auto Iter = setNewTria.begin() ; Iter != setNewTria.end() ; ++ Iter)
setValidTria.insert( *Iter) ;
// Ricerco nella direzione di ptMid1
bool bRelFirst = true ;
if ( ! MarchAlongPath( BBoxCurr, *pStmBasic, setAvoidTria, setValidTria, true, ptMid1, nTria1,
dSize, dSizeTol, dAngTol, bRelFirst, CompoA, CompoB, bStop))
return false ;
// Se Non ho ricavato un'intera striscia chiusa, allora avvio la ricerca in direzione di ptMid
if ( ! bStop) {
if ( ! MarchAlongPath( BBoxCurr, *pStmBasic, setAvoidTria, setValidTria, false, ptMid, nTria,
dSize, dSizeTol, dAngTol, bRelFirst, CompoA, CompoB, bStop))
return false ;
}
// Per ogni triangolo recuperato, cerco le facce a cui appartiene
unordered_set<int> setValidFace ;
for ( auto Iter = setValidTria.begin() ; Iter != setValidTria.end() ; ++ Iter)
vOtherTria.push_back( *Iter) ;
return true ;
}
//------------------------------------------------------------------------------
// Funzione per la ricerca di Superfici in tangenza ( Simile a quanto descritto nella funzione sopra)
bool
GetTrimmingAdjSurfs( const CISURFPVECTOR& vSurf, const CISURFPVECTOR& vOtherSurf, double dLinTol,
double dAngTol, double dFaceAngTol, INTVECTOR& vIndOtherSurf)
{
// Verifica dei parametri
for ( const ISurf* pSurf : vSurf) {
if ( pSurf == nullptr || ! pSurf->IsValid())
return false ;
}
for ( const ISurf* pOtherSurf : vOtherSurf) {
if ( pOtherSurf == nullptr || ! pOtherSurf->IsValid())
return false ;
}
// creo l'insieme delle curve di bordo in continuità
SURFPATCHESVECTOR vSurfPatches ; vSurfPatches.reserve( vSurf.size() + vOtherSurf.size()) ;
BOXVECTOR vBBox3d ; vBBox3d.reserve( vSurf.size() + vOtherSurf.size()) ;
for ( int nS = 0 ; nS < int( vSurf.size()) ; ++ nS) {
vSurfPatches.emplace_back( SurfPatches()) ;
vSurfPatches.back().pSurf = vSurf[nS] ;
vSurfPatches.back().nIndSurf = nS ;
vBBox3d.emplace_back( BBox3d()) ;
POLYLINEVECTOR vPLBorders ;
if ( ! InsertLoopsOfSurf( vSurf[nS], vPLBorders))
return false ;
for ( int nPL = 0 ; nPL < int( vPLBorders.size()) ; ++ nPL)
vPLBorders[nPL].GetLocalBBox( vBBox3d.back()) ;
vBBox3d.back().Expand( 2. * dLinTol) ;
POLYLINEMATRIX matPLPatchBorders ;
if ( ! CalcPatches( vPLBorders, dAngTol, matPLPatchBorders))
return false ;
for ( int i = 0 ; i < int( matPLPatchBorders.size()) ; ++ i) {
for ( int j = 0 ; j < int( matPLPatchBorders[i].size()) ; ++ j) {
Point3d ptS ; matPLPatchBorders[i][j].GetFirstPoint( ptS) ;
Point3d ptE ; matPLPatchBorders[i][j].GetLastPoint( ptE) ;
vSurfPatches.back().vPatches.emplace_back( ptS, ptE, i, false) ;
vSurfPatches.back().CompoPathces.emplace_back( CurveComposite()) ;
vSurfPatches.back().CompoPathces.back().FromPolyLine( matPLPatchBorders[i][j]) ;
}
}
}
for ( int nS = 0 ; nS < int( vOtherSurf.size()) ; ++ nS) {
vSurfPatches.emplace_back( SurfPatches()) ;
vSurfPatches.back().pSurf = vOtherSurf[nS] ;
vSurfPatches.back().nIndSurf = int( vSurf.size()) + nS ;
vBBox3d.emplace_back( BBox3d()) ;
POLYLINEVECTOR vPLBorders ;
if ( ! InsertLoopsOfSurf( vOtherSurf[nS], vPLBorders))
continue ;
for ( int nPL = 0 ; nPL < int( vPLBorders.size()) ; ++ nPL)
vPLBorders[nPL].GetLocalBBox( vBBox3d.back()) ;
vBBox3d.back().Expand( 2. * dLinTol) ;
POLYLINEMATRIX matPLPatchBorders ;
if ( ! CalcPatches( vPLBorders, dAngTol, matPLPatchBorders))
return false ;
for ( int i = 0 ; i < int( matPLPatchBorders.size()) ; ++ i) {
for ( int j = 0 ; j < int( matPLPatchBorders[i].size()) ; ++ j) {
Point3d ptS ; matPLPatchBorders[i][j].GetFirstPoint( ptS) ;
Point3d ptE ; matPLPatchBorders[i][j].GetLastPoint( ptE) ;
vSurfPatches.back().vPatches.emplace_back( ptS, ptE, i, false) ;
vSurfPatches.back().CompoPathces.emplace_back( CurveComposite()) ;
vSurfPatches.back().CompoPathces.back().FromPolyLine( matPLPatchBorders[i][j]) ;
}
}
}
// Se necessario, Splitto le Patch per far combiaciare gli estremi
for ( int i = 0 ; i < int( vSurfPatches.size()) - 1 ; ++ i) {
for ( int j = i + 1 ; j < int( vSurfPatches.size()) ; ++ j) {
if ( vBBox3d[i].Overlaps( vBBox3d[j])) {
if ( ! SplitPatchWithPatch( vSurfPatches[i], vSurfPatches[j], dLinTol))
return false ;
}
}
}
#if DEBUG_SIMPLE_PATCHES
VT.clear() ; VC.clear() ;
for ( int i = 0 ; i < int( vSurfPatches.size()) ; ++ i) {
Color myCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
for ( int j = 0 ; j < int( vSurfPatches[i].CompoPathces.size()) ; ++ j) {
VT.emplace_back( vSurfPatches[i].CompoPathces[j].Clone()) ;
VC.emplace_back( myCol) ;
IGeoPoint3d* _pt = CreateGeoPoint3d() ; _pt->Set( vSurfPatches[i].vPatches[j].ptStart) ;
VT.emplace_back( _pt) ;
VC.emplace_back( AQUA) ;
IGeoPoint3d* _pt1 = CreateGeoPoint3d() ; _pt1->Set( vSurfPatches[i].vPatches[j].ptEnd) ;
VT.emplace_back( _pt1) ;
VC.emplace_back( AQUA) ;
}
}
SaveGeoObj( VT, VC, "C:\\Temp\\SimplePatch.nge") ;
#endif
// Verifico ora se le tangenze nei punti di giunzione sono al di sotto della tolleranza angolare
INTVECTOR vSurfToCheck ;
INTSET setSurf ;
for ( int i = 0 ; i < int( vSurf.size()) ; ++ i)
vSurfToCheck.push_back( i) ;
// Finchè ho una superficie da analizzare
while ( ! vSurfToCheck.empty()) {
// Recupero l'indice della superficie corrente
int nSurf = vSurfToCheck.back() ;
// Elimino l'indice corrente
vSurfToCheck.pop_back() ;
// Se superficie non analizzata, la aggiungo come visitata
auto IterSurf = setSurf.find( nSurf) ;
if ( IterSurf == setSurf.end())
setSurf.insert( nSurf) ;
// Se già visitata, passo alla successiva
else
continue ;
// Recupero la superficie corrente
const ISurf* pCurrSurf = vSurfPatches[nSurf].pSurf ;
// Scorro le sua Patches
for ( int nCurrPatch = 0 ; nCurrPatch < int( vSurfPatches[nSurf].vPatches.size()) ; ++ nCurrPatch) {
// Recupero la Patch attuale
SimplePatch& currPatch = vSurfPatches[nSurf].vPatches[nCurrPatch] ;
// Se Patch già analizzata, passo alla successiva
if ( currPatch.bErase)
continue ;
currPatch.bErase = true ;
// Scorro le altre Patches
for ( int nOtherSurf = 0 ; nOtherSurf < int( vSurfPatches.size()) ; ++ nOtherSurf) {
// Se stessa superficie, passo alla successiva
if ( nOtherSurf == nSurf)
continue ;
// Se superficie già analizzata, passo alla successiva
if ( setSurf.find( nOtherSurf) != setSurf.end())
continue ;
// Recupero la superficie di confronto
const ISurf* pOtherSurf = vSurfPatches[nOtherSurf].pSurf ;
// Scorro le sua Patches
for ( int nOtherPatch = 0 ; nOtherPatch < int( vSurfPatches[nOtherSurf].vPatches.size()) ; ++ nOtherPatch) {
// Recupero la Patch di confronto
SimplePatch& nextPatch = vSurfPatches[nOtherSurf].vPatches[nOtherPatch] ;
// Se Patch già analizzata, passo alla successiva
if ( nextPatch.bErase)
continue ;
// Se gli estremi coincidono
if ( ( AreSamePointEpsilon( currPatch.ptStart, nextPatch.ptStart, dLinTol) &&
AreSamePointEpsilon( currPatch.ptEnd, nextPatch.ptEnd, dLinTol)) ||
( AreSamePointEpsilon( currPatch.ptStart, nextPatch.ptEnd, dLinTol) &&
AreSamePointEpsilon( currPatch.ptEnd, nextPatch.ptStart, dLinTol))) {
// Controllo se le tangenze rimangono nella tolleranza
bool bTangent = true ;
// Campiono la Patch corrente
const int MAX_POINTS = 5 ;
BIPNTVECTOR vPtAPtB ; vPtAPtB.reserve( MAX_POINTS + 1) ;
CurveComposite& currCompoPatch = vSurfPatches[nSurf].CompoPathces[nCurrPatch] ;
CurveComposite& otherCompoPatch = vSurfPatches[nOtherSurf].CompoPathces[nOtherPatch] ;
double dLen = 0.;
currCompoPatch.GetLength( dLen) ;
for ( int i = 0 ; bTangent && i <= MAX_POINTS ; ++ i) {
double dU = 0. ;
currCompoPatch.GetParamAtLength( ( dLen / MAX_POINTS) * i, dU) ;
Point3d ptCurr ;
currCompoPatch.GetPointD1D2( dU, ICurve::FROM_MINUS, ptCurr) ;
Point3d ptOther ;
int nFlag = 0 ;
DistPointCurve( ptCurr, otherCompoPatch).GetMinDistPoint( 0., ptOther, nFlag) ;
// Recupero le due normali sulle curva patch campionate
Vector3d vtNCurr = V_INVALID, vtNOther = V_INVALID ;
if ( ! GetNormalAtPoint( pCurrSurf, ptCurr, vtNCurr) ||
! GetNormalAtPoint( pOtherSurf, ptOther, vtNOther))
return false ;
bTangent = ( vtNCurr * vtNOther > cos( ( dFaceAngTol - EPS_ANG_SMALL) * DEGTORAD)) ;
}
// Se superficie in tangenza, aggiorno i parametri
if ( bTangent) {
vSurfToCheck.emplace_back( nOtherSurf) ;
nextPatch.bErase = true ;
if ( nOtherSurf >= int( vSurf.size()) &&
find( vIndOtherSurf.begin(), vIndOtherSurf.end(), nOtherSurf - int( vSurf.size())) == vIndOtherSurf.end())
vIndOtherSurf.push_back( nOtherSurf - int( vSurf.size())) ;
}
}
}
}
}
}
#if DEBUG_SURF_PATCHES
VT.clear() ; VC.clear() ;
for ( const int& nInd : vIndOtherSurf) {
VT.emplace_back( vOtherSurf[nInd]->Clone()) ;
VC.emplace_back( GRAY) ;
}
for ( const ISurf* pSurf : vSurf) {
VT.emplace_back( pSurf->Clone()) ;
VC.emplace_back( YELLOW) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\SurfPatches.nge") ;
#endif
return true ;
}
//------------------------------------------------------------------------------
// Funzione per la ricerca automatica delle Geometrie di Trimming
bool
GetTrimmingAutoEntities( const CISURFPVECTOR& vSurf, double dShapeLinTol, double dShapeAngTol,
double dLinTol, double dEdgeLinTol, double dAngTol, double dAngFaceTol,
const STRVECTOR& vsShapes, ISURFPOMATRIX& matSelSurf,
ICRVCOMPOPOMATRIX& matCompoBorders, ISURFBEZPOVECTOR& vSurfBz)
{
// Pulizia dei parametri di ingresso
matSelSurf.clear() ;
matCompoBorders.clear() ;
vSurfBz.clear() ;
// Se non ho superfici non devo fare nulla
if ( vSurf.empty())
return true ;
// Verifico che le superfici presenti siano ben definite
for ( const ISurf* pSurf : vSurf) {
if ( pSurf == nullptr || ! pSurf->IsValid())
return false ;
}
// Controllo sulla tolleranza lineare
double dMyShapeLinTol = Clamp( dShapeLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
double dMyEdgeLinTol = Clamp( dEdgeLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
// Controllo sulla tolleranza angolare
double dMyShapeAngTol = Clamp( dShapeAngTol, 1., 60.) ;
double dMyAngTol = Clamp( dAngTol, 1., 45.) ;
double dMyFaceAngTol = Clamp( dAngFaceTol, 1., 60.) ;
ICRVCOMPOPOMATRIX matCompoBordersTmp ;
// Se una sola superficie, effettuo la ricerca per triangoli
if ( ssize( vSurf) == 1) {
ISURFPOVECTOR vSurfTmp ;
if ( ! GetShapesFromSurf( vSurf[0], dMyShapeLinTol, dMyShapeAngTol, dMyLinTol, dMyEdgeLinTol,
dMyAngTol, dMyFaceAngTol, vsShapes, vSurfTmp, matCompoBordersTmp))
return false ;
for ( int i = 0 ; i < ssize( vSurfTmp) ; ++ i) {
matSelSurf.emplace_back( ISURFPOVECTOR{}) ;
matSelSurf.back().emplace_back( Release( vSurfTmp[i])) ;
}
}
// Se più superfici eseguo la ricerca per Patches
else {
}
// Se non ho alcuna Geometria voluta, esco
if ( matSelSurf.empty())
return true ;
// Per ogni Geometria, approssimo le Curve mediante delle Bezier e calolo la Rigata
for ( int i = 0 ; i < ssize( matSelSurf) ; ++ i) {
matCompoBorders.emplace_back( ICRVCOMPOPOVECTOR{}) ; matCompoBorders.back().reserve( 2) ;
if ( ! GetTrimmingBezierEdges( matCompoBordersTmp[i], dLinTol, dAngTol, matCompoBorders.back()))
return false ;
vSurfBz.emplace_back( GetTrimmingRuledBezier( vSurf, matCompoBorders.back()[0], matCompoBorders.back()[1],
dMyLinTol, BIPNTVECTOR{}, INTVECTOR{}, INTVECTOR{})) ;
}
return true ;
}
Reference in New Issue View Git Blame Copy Permalink