Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4bcdb03598e621d5e2cd4bd05e828c533310df9f
EgtGeomKernel/Trimming.cpp
T
Daniele Bariletti 4bcdb03598 EgtGeomKernel 3.1e2 : 
- piccola modifica
- cambio versione.
2026-05-07 14:28:07 +02:00

5402 lines
226 KiB
C++
Raw 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 "CurveLine.h"
#include "CurveArc.h"
#include "CurveBezier.h"
#include "CurveComposite.h"
#include "SurfTriMesh.h"
#include "SurfBezier.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/EGkIntersCurvePlane.h"
#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
#include "/EgtDev/Include/EGkRotationMinimizingFrame.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include <thread>
#include <future>
#include <numeric>
// -------------------------- Debug --------------------------------------------
#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_FACE_SEARCH_TRIA_MODIF 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_SYNC_INTERPOLATION 0
#define DEBUG_BEZIER_RULED 0
#define DEBUG_CURVATURE 0
#define DEBUG_SIMPLE_PATCHES 0
#define DEBUG_SURF_PATCHES 0
#define DEBUG_RAW_EDGES 0
#define DEBUG_EDGES 0
#define DEBUG_SHAPE_STM 0
#define DEBUG_HOLES 0
#define DEBUG_SMOOTH_CURVATURE 0
#if DEBUG_BASIC_BORDERS || DEBUG_CHAIN_CURVES || DEBUG_ANG_APPROX || DEBUG_BEZIER_INTERP || \
DEBUG_FACE_SEARCH || DEBUG_FACE_SEARCH_TRIA_MODIF || DEBUG_BRK_POINTS || DEBUG_BRK_THICK || \
DEBUG_BRK || DEBUG_BORDERS_BY_NORMALS || DEBUG_SYNC_POINTS || DEBUG_SYNC_INTERPOLATION || \
DEBUG_BEZIER_RULED || DEBUG_CURVATURE || DEBUG_SIMPLE_PATCHES || DEBUG_SURF_PATCHES || \
DEBUG_RAW_EDGES || DEBUG_EDGES || DEBUG_SHAPE_STM || DEBUG_HOLES || DEBUG_SMOOTH_CURVATURE
#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 Curve 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
typedef vector<BOXVECTOR> BOXMATRIX ;
struct SurfPatches {
const ISurf* pSurf ;
BBox3d BoxSurf ;
SimpleBorderVector vBorderPatches ;
COMPOVECTOR vCompoBorders ;
COMPOMATRIX matCompoPatches ;
BOXMATRIX matBox3dPatches ;
vector<set<double>> vSetPatchPar ;
} ;
typedef vector<SurfPatches> SURFPATCHESVECTOR ;
// Classificazione tipologia di triangoli
enum TriaClass { OK = 0, SMALL = 1, CAP = 2, HAT = 3, FLIPPED = 4} ;
//-----------------------------------------------------------------------------
//--------------------------- 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 = ssize( vPoints) ;
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 ( ssize( vvPoints) > 1) {
Point3d& ptCurr = vPoints[ssize( vPoints) - 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()[ssize( vvPoints.back()) - 1] ;
Point3d& ptLastLast = vvPoints.back()[ssize( vvPoints.back()) - 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 < ssize( vvPoints[0]) ; ++ 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( ssize( vvPoints.front()) + 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[ssize( vPoints) - 2]) ;
vvPoints.back().emplace_back( vPoints[ssize( vPoints) - 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 < ssize( vvPoints) ; ++ i) {
vPL.emplace_back( PolyLine()) ;
double dPar = -1. ;
for ( int j = 0 ; j < ssize( vvPoints[i]) ; ++ 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
//ApproxBorder( ICurveComposite* pCrvCompo, double dLinTol, double dAngTol, double dAngTolSplit)
//{
// // N.B.:in futuro bisognerebbe fare l'approssimazione direttamente con le bezier.
//
// // Controllo dei parametri
// if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
// return false ;
//
// // splitto la curva considerando la tolleranza angolare
// ICRVCOMPOPOVECTOR vCC ;
// SplitCurveCompoByAngTol( pCrvCompo, dAngTolSplit, vCC) ;
// #if DEBUG_BEZIER_INTERP
// VT.clear() ;
// for( int i = 0 ; i < ssize(vCC) ; ++i)
// VT.push_back( vCC[i]->Clone()) ;
// SaveGeoObj( VT, "D:\\Temp\\trimming\\AngBorderApprox.nge") ;
// VT.clear() ;
// #endif
//
// pCrvCompo->Clear() ;
//
// // Ogni PolyLine ricavata viene approssimata con un tratto di Bezier
// const double MAXLEN = 1.5 ;
// for ( ICurveComposite* pCC : vCC) {
// // Se meno di due curve, non la considero ( non dovrebbe mai capitare )
// if ( pCC->GetCurveCount() < 2)
// continue ;
// PolyArc PA ;
// if ( ! pCC->ApproxWithArcs( dLinTol, dAngTol, PA))
// return false ;
// CurveComposite CrvTemp ;
// if ( ! CrvTemp.FromPolyArc( PA) || ! CrvTemp.MergeCurves( dLinTol, dAngTol))
// return false ;
// #if DEBUG_BEZIER_INTERP
// VT.emplace_back( CrvTemp->Clone()) ;
// #endif
// // Converto in Bezier
// PtrOwner<ICurve> pCrvBz( CurveToBezierCurve( &CrvTemp)) ;
// if ( IsNull( pCrvBz) || ! pCrvBz->IsValid()) {
// LOG_ERROR( GetEGkLogger(), "Error : converrting curve to bezier") ;
// return false ;
// }
// // Aggiungo il tratto approssimato alla curva finale complessiva
// if ( ! pCrvCompo->AddCurve( Release( pCrvBz)))
// return false ;
// }
// #if DEBUG_BEZIER_INTERP
// SaveGeoObj( VT, VC, "D:\\Temp\\trimming\\bezier_edge.nge") ;
// #endif
//
// return ( pCrvCompo->IsValid()) ;
//}
//-----------------------------------------------------------------------------
// Funzione che approssima la curva di bordo per la costruzione della Bezier Ruled mediante
// Patches di curve di Bezier
static bool
ApproxBorder( CurveComposite& CrvCompo, double dLinTol, double dAngTol)
{
// Controllo dei parametri
if ( ! CrvCompo.IsValid())
return false ;
#if DEBUG_BEZIER_INTERP
VT.emplace_back( CrvCompo.Clone()) ;
VC.emplace_back( RED) ;
SaveGeoObj( VT, VC, "C:\\Temp\\RawEdge.nge") ;
#endif
// Dalla Curva Grezza, recupero i suoi punti grezzi e le sue Patch
PolyLine PL ;
if ( ! CrvCompo.ApproxWithLines( EPS_SMALL, EPS_ANG_SMALL, ICurve::APL_SPECIAL, PL))
return false ;
POLYLINEVECTOR vPL ;
if ( ! GetPointSetByAngTol( PL, dAngTol, vPL))
return false ;
#if DEBUG_BEZIER_INTERP
vector<Color> vColor ; vColor.reserve( vPL.size()) ;
for ( const PolyLine& PL : vPL) {
CurveComposite CCTemp ; CCTemp.FromPolyLine( PL) ;
VT.emplace_back( CCTemp.Clone()) ;
vColor.emplace_back( Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.)) ;
VC.emplace_back( vColor.back()) ;
}
int nIndCol = -1 ;
SaveGeoObj( VT, VC, "C:\\Temp\\RawEdge.nge") ;
#endif
// NB. L'approssimazione avviene prima mediante Archi e Rette e successivamente mediante
// Curve di Bezier. Entrambe vengono eseguite con un tolleranza lineare dimezzata in modo
// da rispettare la tolleranza lineare per la curva complessiva.
double dHalfLinTol = max( EPS_SMALL, dLinTol / 2.) ;
// Approssimo le Patch mediante Archi
CurveComposite CCApprox ;
for ( const PolyLine& PL : vPL) {
// Recupero la Patch Grezza
CurveComposite CCPatch ; CCPatch.FromPolyLine( PL) ;
// Creo la Patch Approssimata con Archi
PolyArc PA ;
CCPatch.ApproxWithArcs( dHalfLinTol, dAngTol, PA) ;
CurveComposite CCPatchApprox ; CCPatchApprox.FromPolyArc( PA) ;
// Rimozione delle Imperfezioni ( metà della tolleranza lineare)
CCPatchApprox.RemoveSmallDefects( dHalfLinTol / 2., dAngTol) ;
// Merge complessivo ( metà della tolleranza lineare)
CCPatchApprox.MergeCurves( dHalfLinTol / 2., dAngTol) ;
#if DEBUG_BEZIER_INTERP
VT.emplace_back( CCPatchApprox.Clone()) ;
VC.emplace_back( vColor[ ++ nIndCol]) ;
#endif
// Approssimo tale curva con una Bezier
PtrOwner<ICurve> pCrvPatchBZ( ApproxCurveWithBezier( &CCPatchApprox, dHalfLinTol)) ;
if ( IsNull( pCrvPatchBZ) || ! pCrvPatchBZ->IsValid()) {
LOG_ERROR( GetEGkLogger(), "Error : Interpolating points to bezier curve failed") ;
return false ;
}
#if DEBUG_BEZIER_INTERP
VT.emplace_back( pCrvPatchBZ->Clone()) ;
VC.emplace_back( vColor[nIndCol]) ;
#endif
// Aggiungo alla Curva complessiva Approssimata
if ( ! CCApprox.AddCurve( Release( pCrvPatchBZ)))
return false ;
}
#if DEBUG_BEZIER_INTERP
VT.emplace_back( CCApprox.Clone()) ;
VC.emplace_back( RED) ;
SaveGeoObj( VT, VC, "C:\\Temp\\RawEdge.nge") ;
#endif
if ( CCApprox.IsValid())
CrvCompo.CopyFrom( &CCApprox) ;
return true ;
}
//-----------------------------------------------------------------------------
//-------------------------------- Analisi Bordi ------------------------------
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Funzione per controllare e sistemare le curve di bordo di una rigata 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 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) ;
}
}
// Dalle PolyLine ricevute tengo il vettore di Curve Composite. Il punto iniziale coicide con
// Quello della prima Patch trovata
COMPOVECTOR vCompoBorders ; vCompoBorders.reserve( vPLBorders.size()) ;
for ( int i = 0 ; i < ssize( vPLBorders) ; ++ i) {
vCompoBorders.emplace_back( CurveComposite()) ;
vCompoBorders.back().FromPolyLine( vPLBorders[i]) ;
if ( ! vCompoBorders.back().IsValid())
return false ;
const PolyLine& PLFirstPatch = matPLPatches[i].front() ;
Point3d ptStart ;
if ( ! PLFirstPatch.GetFirstPoint( ptStart))
return false ;
double dUS = 0. ;
vCompoBorders.back().GetParamAtPoint( ptStart, dUS) ;
vCompoBorders.back().ChangeStartPoint( dUS) ;
}
// 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)
// Le Patch più corte della tolleranza vengono considerate invalide
SimpleBorderVector vSimpleBorder ; vSimpleBorder.reserve( matPLPatches.size()) ;
vector<set<double>> matPatchPar ; matPatchPar.reserve( matPLPatches.size()) ;
for ( int i = 0 ; i < ssize( matPLPatches) ; ++ i) {
vSimpleBorder.emplace_back( SimpleBorder()) ;
matPatchPar.emplace_back( set<double>()) ;
for ( int j = 0 ; j < ssize( matPLPatches[i]) ; ++ j) {
Point3d ptS ; matPLPatches[i][j].GetFirstPoint( ptS) ;
Point3d ptE ; matPLPatches[i][j].GetLastPoint( ptE) ;
vSimpleBorder.back().emplace_back( ptS, ptE, i, false) ;
double dPar = -1. ;
if ( j != ssize( matPLPatches[i]) - 1)
vCompoBorders[i].GetParamAtPoint( ptE, dPar, dLinTol) ;
else {
double dParS = 0. ;
vCompoBorders[i].GetDomain( dParS, dPar) ;
}
matPatchPar.back().insert( int( round( dPar))) ;
}
}
#if DEBUG_CHAIN_CURVES
VC.clear() ; VT.clear() ;
for ( int i = 0 ; i < ssize( vSimpleBorder) ; ++ i) {
for ( int j = 0 ; j < ssize( vSimpleBorder[i]) ; ++ j) {
VT.emplace_back( matCompoPatches[i][j].Clone()) ;
VC.emplace_back( RED) ;
IGeoPoint3d* ptS = CreateGeoPoint3d() ;
ptS->Set( vSimpleBorder[i][j].ptStart) ;
VT.emplace_back( ptS) ;
VC.emplace_back( AQUA) ;
IGeoPoint3d* ptE = CreateGeoPoint3d() ;
ptE->Set( vSimpleBorder[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 )
BOOLVECTOR vBorderModif( vSimpleBorder.size(), false) ;
for ( int nCurrBorder = 0 ; nCurrBorder < ssize( vSimpleBorder) ; ++ nCurrBorder) {
// Recupero la Composita associata al Bordo Corrente
CurveComposite& CurrCompoBorder = vCompoBorders[nCurrBorder] ;
// Recupero le Patch associate
SimpleBorder& vPatchCurrBorder = vSimpleBorder[nCurrBorder] ;
// Recupero il vettore dei Parametri di Split
set<double>& setSplitPar = matPatchPar[nCurrBorder] ;
#if DEBUG_CHAIN_CURVES
VC.clear() ; VT.clear() ;
VT.emplace_back( CurrCompoBorder.Clone()) ;
VC.emplace_back( RED) ;
for ( auto Iter = setSplitPar.begin() ; Iter != setSplitPar.end() ; ++ Iter) {
Point3d ptCurr ;
CurrCompoBorder.GetPointD1D2( *Iter, ICurve::FROM_MINUS, ptCurr) ;
PtrOwner<IGeoPoint3d> ptGeoCurr( CreateGeoPoint3d()) ; ptGeoCurr->Set( ptCurr) ;
VT.emplace_back( ptGeoCurr->Clone()) ;
VC.emplace_back( ORANGE) ;
}
#endif
// Scorro gli altri Bordi
for ( int nOtherBorder = 0 ; nOtherBorder < ssize( vSimpleBorder) ; ++ nOtherBorder) {
if ( nOtherBorder == nCurrBorder)
continue ;
#if DEBUG_CHAIN_CURVES
CurveComposite& OtherCompoBorder = vCompoBorders[nOtherBorder] ;
VT.emplace_back( OtherCompoBorder.Clone()) ;
VC.emplace_back( BLACK) ;
#endif
// Recupero l'altro bordo
SimpleBorder& OtherBorder = vSimpleBorder[nOtherBorder] ;
// Scorro le sue Patch
for ( int nOtherPatch = 0 ; nOtherPatch < ssize( OtherBorder) ; ++ nOtherPatch) {
// Recupero gli estremi della Path attuale
DistPointCurve DPTCRV( OtherBorder[nOtherPatch].ptStart, CurrCompoBorder) ;
double dDist = INFINITO ;
if ( DPTCRV.GetDist( dDist) && dDist < dLinTol) {
Point3d ptMinDist ;
int nFlag = 0 ;
if ( DPTCRV.GetMinDistPoint( 0., ptMinDist, nFlag)) {
bool bInsert = true ;
for ( int nCurrPatch = 0 ; bInsert && nCurrPatch < ssize( vPatchCurrBorder) ; ++ nCurrPatch) {
const SimplePatch& Patch = vPatchCurrBorder[nCurrPatch] ;
bInsert = ( ! AreSamePointEpsilon( Patch.ptStart, ptMinDist, dLinTol) &&
! AreSamePointEpsilon( Patch.ptEnd, ptMinDist, dLinTol)) ;
}
if ( bInsert) {
double dPar = -1. ;
if ( DPTCRV.GetParamAtMinDistPoint( 0., dPar, nFlag)) {
setSplitPar.insert( dPar) ;
vBorderModif[nCurrBorder] = true ;
#if DEBUG_CHAIN_CURVES
PtrOwner<IGeoPoint3d> ptGeoCurr( CreateGeoPoint3d()) ;
ptGeoCurr->Set( ptMinDist) ;
VT.emplace_back( ptGeoCurr->Clone()) ;
VC.emplace_back( AQUA) ;
#endif
}
}
}
}
}
}
#if DEBUG_CHAIN_CURVES
SaveGeoObj( VT, VC, "C:\\Temp\\SplitPathces.nge") ;
#endif
}
for ( int nCurrBorder = 0 ; nCurrBorder < ssize( vSimpleBorder) ; ++ nCurrBorder) {
// Se il bordo corrente non ha subito Split, passo al successivo
if ( ! vBorderModif[nCurrBorder])
continue ;
// Pulisco le Composite associate associate a tale Bordo
COMPOVECTOR& vCompoPatches = matCompoPatches[nCurrBorder] ;
vCompoPatches.clear() ;
// Recupero la Curva Composita corrente
CurveComposite& CurrCompo = vCompoBorders[nCurrBorder] ;
// Inizializzo il nuovo Bordo semplice formato dalle Patch
SimpleBorder newSimpleBorder ;
// Recupero il vettore dei Parametri di Split
set<double>& setSplitPar = matPatchPar[nCurrBorder] ;
double dLastPar = 0 ;
for ( auto Iter = setSplitPar.begin() ; Iter != setSplitPar.end() ; ++ Iter) {
PtrOwner<ICurve> pCrvPatch( CurrCompo.CopyParamRange( dLastPar, *Iter)) ;
if ( ! IsNull( pCrvPatch) && pCrvPatch->IsValid()) { // ad esempio per punti coincidenti
PtrOwner<CurveComposite> pCompoPatch( ConvertCurveToBasicComposite( Release( pCrvPatch))) ;
if ( IsNull( pCompoPatch) || ! pCompoPatch->IsValid())
return false ;
vCompoPatches.emplace_back( *Get( pCompoPatch)) ;
Point3d ptStart ; vCompoPatches.back().GetStartPoint( ptStart) ;
Point3d ptEnd ; vCompoPatches.back().GetEndPoint( ptEnd) ;
newSimpleBorder.emplace_back( ptStart, ptEnd, nCurrBorder, false) ;
dLastPar = *Iter ;
}
}
vSimpleBorder[nCurrBorder] = newSimpleBorder ;
}
// 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 < ssize( vSimpleBorder) - 1 ; ++ nCurrCrv) {
// Recupero la curva corrente
SimpleBorder& CurrCurve = vSimpleBorder[nCurrCrv] ;
// Scorro i suoi Edges
for ( int nCurrEdge = 0 ; nCurrEdge < ssize( CurrCurve) ; ++ 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 < ssize( vSimpleBorder) ; ++ nNextCrv) {
// Recupero la curva successiva
SimpleBorder& NextCurve = vSimpleBorder[nNextCrv] ;
// Scorro i suoi Edges
for ( int nNextEdge = 0 ; nNextEdge < ssize( NextCurve) ; ++ 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( vSimpleBorder.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 < ssize( vSimpleBorder) ; ++ nCrv) {
// Recupero la curva
SimpleBorder& CrvEdge = vSimpleBorder[nCrv] ;
// Scorro i suoi edges
for ( int nEdge = 0 ; nEdge < ssize( CrvEdge) ; ++ 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 < ssize( vCompoResult) ; ++ 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 < ssize( vCompoResult) ; ++ 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 < ssize( vCompoPatches) ; ++ 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 < ssize( vCompoPatches) ; ++ 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 < ssize( vCompoPatches) ; ++ 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) ;
// Se estremi più distanti della tolleranza, li cambio nel punto medio tra essi
Point3d ptEndCurr ; vCompoChained.back()->GetEndPoint( ptEndCurr) ;
Point3d ptStartNext ; pCrv->GetStartPoint( ptStartNext) ;
if ( SqDist( ptEndCurr, ptStartNext) > dChainTol * dChainTol) {
Point3d ptMid = Media( ptEndCurr, ptStartNext) ;
vCompoChained.back()->ModifyEnd( ptMid) ;
pCrv->ModifyStart( ptMid) ;
}
// 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 < ssize( vCompoChained) ; ++ 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() ; // utilizza il punto medio
// 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 ( ssize( vBiPntSplit) != 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 < ssize( vBreakingPts) ; ++ i) {
if ( AreSamePointEpsilon( vBreakingPts[i].first, vBreakingPts[i].second, dLinTol))
return false ;
for ( int j = i + 1 ; j < ssize( vBreakingPts) ; ++ 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 < ssize( vCompoParts) ; ++ 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 < ssize( vCompoParts) ; ++ 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 ( ssize( vPL) < 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 < ssize( vPL) ; ++ 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 < ssize( vLoops) ; ++ 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 < ssize( vSurf) ; ++ 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 = ssize( vPLBorders) ;
// Se non ho nessuna faccia e nessun triangolo da scartare, estraggo i bordi complessivi della superficie
if ( ssize( vFaces) == 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 < ssize( vPLBorders) ; ++ 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 ;
}
// ----------------------------------------------------------------------------
// Funzione per il calcolo dei bordi mediante spessore
static bool
GetBorderByExtrusion( const SurfTriMesh* pStm, double dThick, double dLinTol, double dAngTol,
vector<pair<PolyLine, PolyLine>>& vPLLoopPLExtr)
{
// Verifico la validità della superficie
if ( pStm == nullptr || ! pStm->IsValid())
return false ;
vPLLoopPLExtr.clear() ;
#if DEBUG_BORDERS_BY_NORMALS
VT.emplace_back( pStm->Clone()) ;
VC.emplace_back( BLACK) ;
SaveGeoObj( VT, VC, "C:\\Temp\\ExtrLoops.nge") ;
#endif
// Recupero tutti i Loop della superficie
POLYLINEVECTOR vPLLoop ;
if ( ! pStm->GetLoops( vPLLoop))
return false ;
// Se Superficie Chiusa, non faccio nulla
if ( vPLLoop.empty())
return true ;
// Scorro i Loop
for ( PolyLine& PLLoop : vPLLoop) {
PolyLine PLLoopExtr ;
// Scorro i Punti
Point3d ptP ;
double dU ;
bool bFound = PLLoop.GetFirstUPoint( &dU, &ptP) ;
double dPar = -1 ;
while ( bFound) {
// Recupero il TriangoloEx associato al punto
Triangle3dEx Tria ;
if ( ! pStm->GetTriangle( lround( dU), Tria))
return false ;
// Cerco il vertice associato al punto
int nTriaP = 0 ;
for ( ; nTriaP < 3 ; ++ nTriaP) {
if ( AreSamePointApprox( Tria.GetP( nTriaP), ptP))
break ;
}
if ( nTriaP == 3)
return false ;
PLLoopExtr.AddUPoint( ++ dPar, ptP - Tria.GetVertexNorm( nTriaP) * dThick) ;
#if DEBUG_BORDERS_BY_NORMALS
IGeoVector3d* _vtN = CreateGeoVector3d() ; _vtN->Set( Tria.GetVertexNorm( nTriaP), ptP) ;
VT.emplace_back( _vtN) ;
Color _myCol = Color( abs( Tria.GetVertexNorm( nTriaP).x), abs( Tria.GetVertexNorm( nTriaP).y), abs( Tria.GetVertexNorm( nTriaP).z)) ;
VC.emplace_back( _myCol) ;
CurveLine _Line ; _Line.Set( ptP, ptP - Tria.GetVertexNorm( nTriaP) * dThick) ;
VT.emplace_back( _Line.Clone()) ;
VC.emplace_back( _myCol) ;
#endif
bFound = PLLoop.GetNextUPoint( &dU, &ptP) ;
}
#if DEBUG_BORDERS_BY_NORMALS
ICurveComposite* pC = CreateCurveComposite() ;
pC->FromPolyLine( PLLoopExtr) ;
VT.emplace_back( pC->Clone()) ;
VC.emplace_back( AQUA) ;
#endif
// Loop valido con almeno 4 punti
if ( PLLoopExtr.GetPointNbr() >= 4) {
// Primo e ultimo punto devono coincidere
PNTULIST& lPntU = PLLoopExtr.GetUPointList() ;
Point3d ptClose = Media( lPntU.front().first, lPntU.back().first) ;
lPntU.front().first = ptClose ;
lPntU.back().first = ptClose ;
vPLLoopPLExtr.emplace_back( make_pair( PLLoop, PLLoopExtr)) ;
}
}
#if DEBUG_BORDERS_BY_NORMALS
SaveGeoObj( VT, VC, "C:\\Temp\\ExtrLoops.nge") ;
#endif
return true ;
}
// ----------------------------------------------------------------------------
// ---------------------------------- Analisi Adiacenze -----------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Funzione per calcolare le Patch di una Superficie TriMesh
static bool
CalcSurfPatch( const ISurf* pSurf, double dLinTol, double dAngTol, SurfPatches& SrfPatches)
{
// Verifico che la Superficie sia valida
if ( pSurf == nullptr || ! pSurf->IsValid())
return false ;
// Recupero il Box della superficie ( ingrandito della tolleranza lineare)
if ( ! pSurf->GetLocalBBox( SrfPatches.BoxSurf))
return false ;
SrfPatches.BoxSurf.Expand( 2. * dLinTol + 10. * EPS_SMALL) ;
// Recupero i suoi Loops come PolyLines
POLYLINEVECTOR vPLBorders ;
if ( ! InsertLoopsOfSurf( pSurf, vPLBorders))
return false ;
// Dai Bordi, recupero le Patches
POLYLINEMATRIX matPLPatchBorders ;
if ( ! CalcPatches( vPLBorders, dAngTol, matPLPatchBorders))
return false ;
#if DEBUG_SURF_PATCHES
VT.clear() ; VC.clear() ;
VT.emplace_back( pSurf->Clone()) ;
VC.emplace_back( BLACK) ;
for ( int i = 0 ; i < ssize( matPLPatchBorders) ; ++ i) {
for ( int j = 0 ; j < ssize( matPLPatchBorders[i]) ; ++ j) {
CurveComposite CompoPatch ; CompoPatch.FromPolyLine( matPLPatchBorders[i][j]) ;
VT.emplace_back( CompoPatch.Clone()) ;
VC.emplace_back( Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.)) ;
}
}
//SaveGeoObj( VT, VC, "C:\\Temp\\Patches.nge") ;
#endif
// Definisco le Patches
// Recupero la Curva Composita associata per la Patch
// Memerizzo il Box3d della Patch
// Memorizzo i Parametri delle Patch sulle Curve Composite
SrfPatches.vCompoBorders.reserve( vPLBorders.size()) ;
SrfPatches.matCompoPatches.reserve( vPLBorders.size()) ;
SrfPatches.vBorderPatches.reserve( matPLPatchBorders.size()) ;
SrfPatches.matBox3dPatches.reserve( matPLPatchBorders.size()) ;
SrfPatches.vSetPatchPar.reserve( matPLPatchBorders.size()) ;
for ( int i = 0 ; i < ssize( matPLPatchBorders) ; ++ i) {
// Recupero il Bordo Corrente
const POLYLINEVECTOR& PLBorder = matPLPatchBorders[i] ;
// Recupero la Curva Composita di Bordo
SrfPatches.vCompoBorders.emplace_back( CurveComposite()) ;
SrfPatches.vCompoBorders.back().FromPolyLine( vPLBorders[i]) ;
// Inizializzo i Parametri
SrfPatches.vBorderPatches.emplace_back( SimpleBorder()) ;
SrfPatches.matBox3dPatches.emplace_back( BOXVECTOR{}) ;
SrfPatches.vSetPatchPar.emplace_back( set<double>()) ;
SrfPatches.matCompoPatches.emplace_back( COMPOVECTOR{}) ;
for ( int j = 0 ; j < ssize( PLBorder) ; ++ j) {
// Recupero la PolyLine associata alla Patch corrente
const PolyLine& PLPatch = PLBorder[j] ;
// Definizione della Patch Semplice
Point3d ptStart ; PLPatch.GetFirstPoint( ptStart) ;
if ( j == 0) {
double dUStart = 0. ;
SrfPatches.vCompoBorders.back().GetParamAtPoint( ptStart, dUStart) ;
SrfPatches.vCompoBorders.back().ChangeStartPoint( dUStart) ;
}
Point3d ptEnd ; PLPatch.GetLastPoint( ptEnd) ;
SrfPatches.vBorderPatches.back().emplace_back( ptStart, ptEnd, i, false) ;
SrfPatches.matCompoPatches.back().emplace_back( CurveComposite()) ;
SrfPatches.matCompoPatches.back().back().FromPolyLine( PLPatch) ;
// Box Della Patch
SrfPatches.matBox3dPatches.back().emplace_back( BBox3d()) ;
PLPatch.GetLocalBBox( SrfPatches.matBox3dPatches.back().back()) ;
SrfPatches.matBox3dPatches.back().back().Expand( 2. * dLinTol + 10. * EPS_SMALL) ;
// Parametri dU associati
double dPar = -1. ;
if ( j != ssize( matPLPatchBorders[i]) - 1)
SrfPatches.vCompoBorders.back().GetParamAtPoint( ptEnd, dPar, dLinTol) ;
else {
double dParS = 0. ;
SrfPatches.vCompoBorders.back().GetDomain( dParS, dPar) ;
}
SrfPatches.vSetPatchPar.back().insert( int( round( dPar))) ;
}
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per individuare se un triangolo piccolo è trascurabile
static bool
CheckUnrelevantTriangle( const SurfTriMesh& Stm, int nCurrTria, int nTriaAdj, int nAdj, double dAngTol,
unordered_map<int, INTVECTOR>& mapAdjToAvoid, INTVECTOR& vNewTria)
{
vNewTria.clear() ; vNewTria.reserve( 2) ;
// Verifico che la TriMesh sia valida
if ( ! Stm.IsValid())
return false ;
// Verifico che il triangolo appartenga alla TriMesh
Triangle3d Tria, TriaAdj ;
if ( ! Stm.GetTriangle( nCurrTria, Tria) || ! Stm.GetTriangle( nTriaAdj, TriaAdj))
return false ;
// Verifico le sue adiacenze
int nUnrelAdjTriaIds[3] ;
if ( ! Stm.GetTriangleAdjacencies( nTriaAdj, nUnrelAdjTriaIds))
return false ;
int nInvAdj = 0 ;
for ( int nUnrelAdj = 0 ; nUnrelAdj < 3 ; ++ nUnrelAdj) {
// Se non esiste l'adiacenza, non faccio nulla
int nUnrelTriaAdj = nUnrelAdjTriaIds[nUnrelAdj] ;
if ( nUnrelTriaAdj == SVT_NULL)
continue ;
// Se l'Adiacenza è il triangolo di partenza, va scarata
if ( nUnrelTriaAdj == nCurrTria) {
nInvAdj = nUnrelAdj ;
continue ;
}
// Recupero il triangolo adiacente
Triangle3d TriaAdjUnrel ;
if ( ! Stm.GetTriangle( nUnrelTriaAdj, TriaAdjUnrel))
return false ;
// Se la normale è dentro alla tolleranza del triangolo di partenza, allora sarà
// fuori dalla tolleranza del triangolo di adiacenza corrente, quindi va scaratata
if ( Tria.GetN() * TriaAdjUnrel.GetN() > cos( ( dAngTol - EPS_ANG_SMALL) * DEGTORAD)) {
mapAdjToAvoid[nTriaAdj].push_back( nUnrelAdj) ;
int nIdAdjTriaId[3] ;
if ( ! Stm.GetTriangleAdjacencies( nUnrelTriaAdj, nIdAdjTriaId))
return false ;
for ( int nMyAdj = 0 ; nMyAdj < 3 ; ++ nMyAdj) {
if ( nIdAdjTriaId[nMyAdj] == nTriaAdj) {
mapAdjToAvoid[nUnrelTriaAdj].push_back( nMyAdj) ;
vNewTria.push_back( nUnrelTriaAdj) ;
break ;
}
}
}
}
if ( ! vNewTria.empty()) {
mapAdjToAvoid[nTriaAdj].push_back( nInvAdj) ;
mapAdjToAvoid[nCurrTria].push_back( nAdj) ;
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per analisi del singolo triangolo
static bool
AnalyzeTriangle( const Triangle3d& Tria, const Triangle3d& TriaAdj, double dAngTol, int& nTriaClass)
{
// Verifico la validità del triangolo
if ( ! Tria.IsValid())
return false ;
nTriaClass = TriaClass::OK ;
// Verifico caso Small
double dArea = TriaAdj.GetArea() ;
if ( dArea < ( 70. * EPS_SMALL) * ( 70. * EPS_SMALL)) { // ~ 0.005
nTriaClass = TriaClass::SMALL ;
return true ;
}
bool bCap, bHat = false ;
// Verifico caso Cap
double dLen0 = Dist( TriaAdj.GetP( 0), TriaAdj.GetP( 1)) ;
double dLen1 = Dist( TriaAdj.GetP( 1), TriaAdj.GetP( 2)) ;
double dLen2 = Dist( TriaAdj.GetP( 2), TriaAdj.GetP( 0)) ;
double dLenMin = min( { dLen0, dLen1, dLen2}) ;
double dLenMax = max( { dLen0, dLen1, dLen2}) ;
double dRatio = ( dLenMin > EPS_SMALL ? dLenMax / dLenMin : INFINITO) ;
bCap = ( dRatio > 100.) ; // ~ 2 ordini di grandezza
if ( bCap) {
nTriaClass = TriaClass::CAP ;
return true ;
}
// Verifico caso Hat
double dH0 = ( dLen1 > EPS_SMALL ? ( ( 2. * dArea) / dLen1) : ( ( dLen0 + dLen2) / 2.)) ;
double dH1 = ( dLen2 > EPS_SMALL ? ( ( 2. * dArea) / dLen2) : ( ( dLen0 + dLen1) / 2.)) ;
double dH2 = ( dLen0 > EPS_SMALL ? ( ( 2. * dArea) / dLen0) : ( ( dLen1 + dLen2) / 2.)) ;
double dHMin = min( { dH0, dH1, dH2}) ;
double dAvgH = ( dH0 + dH1 + dH2) / 3. ;
double dRatioH = ( dAvgH > EPS_SMALL ? ( dHMin / dAvgH) : 0.) ;
double dAvgE = ( dLen0 + dLen1 + dLen2) / 3. ;
double dRatioE = ( dAvgE > EPS_SMALL ? ( dHMin / dAvgE) : 0.) ;
bHat = ( dRatioH < 1 / 100. || dRatioE < 1 / 100.) ;
if ( bHat)
nTriaClass = TriaClass::HAT ;
// Caso Flip
bool bFlipped = ( ( - Tria.GetN()) * TriaAdj.GetN() > cos( ( dAngTol - EPS_ANG_SMALL) * DEGTORAD)) ;
if ( bFlipped) {
nTriaClass = TriaClass::FLIPPED ;
return true ;
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per correzione dei triangoli
static bool
AdjustClassifiedTriangles( unordered_set<int>& setValidTria, const SurfTriMesh* pStm,
const unordered_map<int, int>& mapTriaClass, TRIA3DVECTOR& vAllTria)
{
// Se superficie non valida, errore
if ( pStm == nullptr || ! pStm->IsValid() || pStm->GetTriangleCount() == 0)
return false ;
// se non ho triangoli nel set, non faccio nulla
if ( setValidTria.empty())
return true ;
// se non ho una Mappa di classificazione, allora i triangoli sono già tutti validi e corretti
if ( mapTriaClass.empty()) {
vAllTria.reserve( setValidTria.size()) ;
for ( auto Iter = setValidTria.begin() ; Iter != setValidTria.end() ; ++ Iter) {
Triangle3d Tria ;
if ( ! pStm->GetTriangle( *Iter, Tria))
return false ;
vAllTria.emplace_back( Tria) ;
}
return true ;
}
// Scorro gli elementi della Mappa
for ( auto &KeyVal : mapTriaClass) {
int nTria = KeyVal.first ;
int nTriaClass = KeyVal.second ;
// Recupero il Triangolo
Triangle3d Tria ;
if ( ! pStm->GetTriangle( nTria, Tria))
return false ;
// Se Triangolo Small, lo elimino
if ( nTriaClass == TriaClass::SMALL)
setValidTria.erase( nTria) ;
// Recupero le 3 adiacenze
int nIdAdjTriaId[3] ;
if ( ! pStm->GetTriangleAdjacencies( nTria, nIdAdjTriaId))
return false ;
// Controllo quali tra i miei triangoli devo analizzare
vector<pair<int, Triangle3d>> vMyAdjTria ; vMyAdjTria.reserve( 3) ;
for ( int nAdj = 0 ; nAdj < 3 ; ++ nAdj) {
int nTriaAdj = nIdAdjTriaId[nAdj] ;
if ( nTriaAdj == SVT_NULL ||
setValidTria.find( nTriaAdj) == setValidTria.end())
continue ;
Triangle3d myAdjTria ;
if ( ! pStm->GetTriangle( nTriaAdj, myAdjTria))
return false ;
vMyAdjTria.emplace_back( make_pair( nTriaAdj, myAdjTria)) ;
}
#if DEBUG_FACE_SEARCH_TRIA_MODIF
VT.clear() ; VC.clear() ;
VT.emplace_back( pStm->CloneTriangle( nTria)) ;
VC.emplace_back( RED) ;
for ( int i = 0 ; i < ssize( vMyAdjTria) ; ++ i) {
VT.emplace_back( pStm->CloneTriangle( vMyAdjTria[i].first)) ;
VC.emplace_back( GREEN) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\Vert0.nge") ;
#endif
// Se Triangolo CAP
if ( nTriaClass == TriaClass::CAP) {
// Se nessuna adiacenza valida, non faccio nulla
int nAdjTria = ssize( vMyAdjTria) ;
if ( nAdjTria == 0)
continue ;
// Se una sola,non faccio nulla
else if ( nAdjTria == 1)
continue ;
// Altrimenti
else {
// Recupero l'adiacenza più corta
int nShortestAdj = 0 ;
double dMinLen = INFINITO ;
for ( int nAdj = 0 ; nAdj < 3 ; ++ nAdj) {
double dEdgeLen = SqDist( Tria.GetP( nAdj), Tria.GetP( ( nAdj + 1) % 3)) ;
if ( dEdgeLen < dMinLen) {
dMinLen = dEdgeLen ;
nShortestAdj = nAdj ;
}
}
// Calcolo il punto medio di tale Edge, il più corto
Point3d ptA = Tria.GetP( nShortestAdj) ;
Point3d ptB = Tria.GetP( ( nShortestAdj + 1) % 3) ;
Point3d ptMid = Media( ptA, ptB) ;
// Cerco l'indice del vertice più vicino a ptA e ptB
int nVertA = -1, nVertB = -1 ;
for ( int nV = 0 ; ( nVertA == -1 || nVertB == -1) && nV < pStm->GetVertexCount() ; ++ nV) {
Point3d ptV ;
if ( ! pStm->GetVertex( nV, ptV))
return false ;
if ( AreSamePointEpsilon( ptV, ptA, 1e-6))
nVertA = nV ;
if ( AreSamePointEpsilon( ptV, ptB, 1e-6))
nVertB = nV ;
}
if ( nVertA == -1 || nVertB == -1)
continue ;
#if DEBUG_FACE_SEARCH_TRIA_MODIF
IGeoPoint3d* _ptA = CreateGeoPoint3d() ; _ptA->Set( ptA) ;
IGeoPoint3d* _ptB = CreateGeoPoint3d() ; _ptB->Set( ptB) ;
IGeoPoint3d* _ptM = CreateGeoPoint3d() ; _ptM->Set( ptMid) ;
VT.emplace_back( _ptA) ; VT.emplace_back( _ptB) ; VT.emplace_back( _ptM) ;
VC.emplace_back( FUCHSIA) ; VC.emplace_back( FUCHSIA) ; VC.emplace_back( FUCHSIA) ;
SaveGeoObj( VT, VC, "C:\\Temp\\Vert1.nge") ;
#endif
// Elimino il triangolo CAP
setValidTria.erase( nTria) ;
// Modifico tutti i triangoli attorno al Vertice A e B
INTVECTOR vTA, vTB ;
bool bCirc ;
if ( ! pStm->GetAllTriaAroundVertex( nVertA, vTA, bCirc) ||
! pStm->GetAllTriaAroundVertex( nVertB, vTB, bCirc))
return false ;
for ( const int& nVertTria : vTA) {
if ( nVertTria == SVT_NULL ||
setValidTria.find( nVertTria) == setValidTria.end())
continue ;
#if DEBUG_FACE_SEARCH_TRIA_MODIF
VT.emplace_back( pStm->CloneTriangle( nVertTria)) ;
VC.emplace_back( LIME) ;
#endif
Triangle3d newTria ;
if ( ! pStm->GetTriangle( nVertTria, newTria))
return false ;
for ( int j = 0 ; j < 3 ; ++ j) {
if ( AreSamePointApprox( newTria.GetP( j), ptA) ||
AreSamePointApprox( newTria.GetP( j), ptB)) {
newTria.SetP( j, ptMid) ;
break ;
}
}
setValidTria.erase( nVertTria) ;
vAllTria.emplace_back( newTria) ;
}
for ( const int& nVertTria : vTB) {
if ( nVertTria == SVT_NULL ||
setValidTria.find( nVertTria) == setValidTria.end())
continue ;
#if DEBUG_FACE_SEARCH_TRIA_MODIF
VT.emplace_back( pStm->CloneTriangle( nVertTria)) ;
VC.emplace_back( LIME) ;
#endif
Triangle3d newTria ;
if ( ! pStm->GetTriangle( nVertTria, newTria))
return false ;
for ( int j = 0 ; j < 3 ; ++ j) {
if ( AreSamePointApprox( newTria.GetP( j), ptA) ||
AreSamePointApprox( newTria.GetP( j), ptB)) {
newTria.SetP( j, ptMid) ;
break ;
}
}
setValidTria.erase( nVertTria) ;
vAllTria.emplace_back( newTria) ;
}
#if DEBUG_FACE_SEARCH_TRIA_MODIF
SaveGeoObj( VT, VC, "C:\\Temp\\Vert2.nge") ;
#endif
}
}
// Se triangolo di tipo HAT
else if ( nTriaClass == TriaClass::HAT) {
// TODO ...
}
// Se Triangolo Invertito
else if ( nTriaClass == TriaClass::FLIPPED) { // TODO : Testare se capita
// 2 Possibilità :
// a) Triangolo Invertito senza altre intersezioni
// b) Triangolo Invertito senza altre intersezioni
// Se nessuna adiacenza valida, non faccio nulla
int nAdjTria = ssize( vMyAdjTria) ;
if ( nAdjTria == 0)
continue ;
// Altrimenti
else {
// Cerco il triangolo in cui cade il punto centrale
bool bPointIn = false ;
for ( int i = 0 ; ! bPointIn && i < nAdjTria ; ++ i) {
Triangle3d& TriaAdj = vMyAdjTria[i].second ;
Plane3d plAdjTria ; plAdjTria.Set( TriaAdj.GetP( 0), TriaAdj.GetN()) ;
for ( int nP = 0 ; nP < 3 ; ++ nP) {
Point3d ptTest = ProjectPointOnPlane( Tria.GetP( nP), plAdjTria) ;
if ( IsPointInsideTriangle( ptTest, TriaAdj, TriangleType::OPEN)) {
#if DEBUG_FACE_SEARCH_TRIA_MODIF
IGeoPoint3d* _pt = CreateGeoPoint3d() ;
_pt->Set( ptTest) ;
VT.emplace_back( _pt) ;
VC.emplace_back( YELLOW) ;
SaveGeoObj( VT, VC, "C:\\Temp\\Vert1.nge") ;
#endif
// Recupro il vertice più distante
Point3d ptA = Tria.GetP( ( nP + 1) % 3) ;
Point3d ptB = Tria.GetP( ( nP + 2) % 3) ;
for ( int nAdjP = 0 ; nAdjP < 3 ; ++ nAdjP) {
if ( ! AreSamePointApprox( TriaAdj.GetP( nAdjP), ptA) &&
! AreSamePointApprox( TriaAdj.GetP( nAdjP), ptB)) {
Triangle3d TriaA, TriaB ;
TriaA.Set( TriaAdj.GetP( nAdjP), TriaAdj.GetP( ( nAdjP + 1) % 3), ptTest) ;
TriaB.Set( TriaAdj.GetP( ( nAdjP + 2) % 3), TriaAdj.GetP( nAdjP), ptTest) ;
#if DEBUG_FACE_SEARCH_TRIA_MODIF
CurveComposite CompoA ;
CompoA.AddPoint( TriaA.GetP( 0)) ;
CompoA.AddLine( TriaA.GetP( 1)) ;
CompoA.AddLine( TriaA.GetP( 2)) ;
CompoA.Close() ;
CurveComposite CompoB ;
CompoB.AddPoint( TriaB.GetP( 0)) ;
CompoB.AddLine( TriaB.GetP( 1)) ;
CompoB.AddLine( TriaB.GetP( 2)) ;
CompoB.Close() ;
VT.emplace_back( CompoA.Clone()) ;
VC.emplace_back( FUCHSIA) ;
VT.emplace_back( CompoB.Clone()) ;
VC.emplace_back( FUCHSIA) ;
SaveGeoObj( VT, VC, "C:\\Temp\\Vert2.nge") ;
#endif
vAllTria.emplace_back( TriaA) ;
vAllTria.emplace_back( TriaB) ;
setValidTria.erase( nTria) ;
setValidTria.erase( nAdjTria) ;
// Se il triangolo diviso è l'unico di adiacenza
if ( nAdjTria == 1) {
// Inverto il triangolo corrente e aggiungo
Triangle3d TriaFlipped ;
TriaFlipped.Set( Tria.GetP( 0), Tria.GetP( 2), Tria.GetP( 1)) ;
vAllTria.emplace_back( TriaFlipped) ;
}
else {
for ( i = 0 ; i < nAdjTria ; ++ i) {
for ( int j = 0 ; j < 3 ; ++ j) {
if ( AreSamePointApprox( TriaAdj.GetP( j), Tria.GetP( nP))) {
TriaAdj.SetP( j, ptTest) ;
break ;
}
}
}
break ;
}
}
}
break ;
}
}
}
// Se non esiste un triangolo che contiene la proiezione del punto, inverto
if ( ! bPointIn) {
Tria.Set( Tria.GetP( 0), Tria.GetP( 2), Tria.GetP( 1)) ;
vAllTria.emplace_back( Tria) ;
setValidTria.erase( nTria) ;
}
}
}
}
// Nel vettore dei triangoli nuovi, inserisco tutti i triangoli non scartati
for ( auto Iter = setValidTria.begin() ; Iter != setValidTria.end() ; ++ Iter) {
Triangle3d Tria ;
if ( ! pStm->GetTriangle( *Iter, Tria))
return false ;
vAllTria.emplace_back( Tria) ;
}
return true ;
}
// ----------------------------------------------------------------------------
// Funzione per classificare i triangoli all'interno di un Box
static bool
ClassifyTriangles( const SurfTriMesh& Stm, const INTVECTOR& vTBox, int nFirstTria, double dAngTol,
unordered_set<int>& setAvoidTria, unordered_set<int>& setNewTria,
unordered_map<int, int>& mapTriaClass)
{
// Collezione di triangoli già visitati
unordered_set<int> setTria ; setTria.reserve( vTBox.size()) ;
// Collezioni di triangoli da analizzare
INTVECTOR vTria ; vTria.reserve( ssize( vTBox) + 1) ;
vTria.push_back( nFirstTria) ;
// Collezioni di adiacenze da non riguardare
unordered_map<int, INTVECTOR> mapAdjToAvoid ; mapAdjToAvoid.reserve( ssize( vTBox) + 1) ;
// 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 adiacenza da scartare, la salto
auto mapIter = mapAdjToAvoid.find( nCurrTria) ;
if ( mapIter != mapAdjToAvoid.end()) {
bool bSkip = false ;
for ( int nAvoidAdj = 0 ; ! bSkip && nAvoidAdj < ssize( mapIter->second) ; ++ nAvoidAdj)
bSkip = ( mapIter->second[nAvoidAdj] == nAdj) ;
if ( bSkip) {
// Se presente, lo inserisco
vTria.push_back( nTriaAdj) ;
continue ;
}
}
// 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)) {
// Classifico il triangolo
int nTriaClass = TriaClass::OK ;
if ( ! AnalyzeTriangle( Tria, TriaAdj, dAngTol, nTriaClass))
return false ;
bool bUnrelTria = ( nTriaClass == TriaClass::FLIPPED ||
nTriaClass == TriaClass::CAP) ;
if ( bUnrelTria) {
INTVECTOR vNewTria ; vNewTria.reserve( 2) ;
if ( ! CheckUnrelevantTriangle( Stm, nCurrTria, nTriaAdj, nAdj, dAngTol, mapAdjToAvoid, vNewTria))
return false ;
// Se triangolo irrilevante, memorizzo tale informazione
if ( ! vNewTria.empty()) {
mapTriaClass[nTriaAdj] = nTriaClass ;
vTria.push_back( nTriaAdj) ;
vTria.push_back( vNewTria[0]) ;
if ( ssize( vNewTria) == 2)
vTria.push_back( vNewTria[1]) ;
continue ;
}
}
// 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() ;
mapAdjToAvoid.clear() ;
#if DEBUG_FACE_SEARCH
VT.clear() ; VC.clear() ;
#endif
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 < ssize( vBiPnts) ; ++ 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 ( ssize( vInters) == 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 < ssize( vBiPnts) ; ++ i) {
if ( setBiPntsToSave.count( i))
vBiPnts[nCurr ++] = vBiPnts[i] ;
}
vBiPnts.resize( nCurr) ;
#if DEBUG_FACE_SEARCH
for ( int i = 0 ; i < ssize( vBiPnts) ; ++ 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 < ssize( vBiPnts) ; ++ 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 < ssize( vBiPnts) ; ++ 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 < ssize( vCompoChain) ; ++ 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 < ssize( vCompoChain) ; ++ _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 ( ssize( vCompoChain) == 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 ( ssize( vCompoChain) == 2) {
CompoATmp = vCompoChain[0] ;
CompoBTmp = vCompoChain[1] ;
}
// Se più di due, cerco le due curve più vicine
else if ( ssize( vCompoChain) > 2) {
INTDBLVECTOR vIndSqDist ; vIndSqDist.reserve( vCompoChain.size()) ;
for ( int nCrv = 0 ; nCrv < ssize( vCompoChain) ; ++ 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 ;
PtrOwner<ICurve> pCrvATmp( CompoATmp.CopyParamRange( dUAS, dUAE)) ;
PtrOwner<ICurve> pCrvBTmp( CompoBTmp.CopyParamRange( dUBS, dUBE)) ;
CompoA.CopyFrom( pCrvATmp) ;
CompoB.CopyFrom( pCrvBTmp) ;
#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)) {
PtrOwner<ICurve> pCrv( CompoChain.CopyParamRange( dUBreak, dUE)) ;
CompoPrev.CopyFrom( pCrv) ;
CompoPrev.Invert() ;
}
else if ( Compo.IsPointOn( ptE) && ! Compo.IsPointOn( ptS)) {
PtrOwner<ICurve> pCrv( CompoChain.CopyParamRange( dUS, dUBreak)) ;
CompoPrev.CopyFrom( pCrv) ;
}
#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)) {
PtrOwner<ICurve> pCrv( CompoChain.CopyParamRange( dUBreak, dUE)) ;
CompoAft.CopyFrom( pCrv) ;
}
else if ( Compo.IsPointOn( ptE) && ! Compo.IsPointOn( ptS)) {
PtrOwner<ICurve> pCrv( CompoChain.CopyParamRange( dUS, dUBreak)) ;
CompoAft.CopyFrom( pCrv) ;
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) {
PtrOwner<ICurve> pCrvPrev( CompoChain.CopyParamRange( dUS, dUBreak)) ;
PtrOwner<ICurve> pCrvAft( CompoChain.CopyParamRange( dUBreak1, dUE)) ;
CompoPrev.CopyFrom( pCrvPrev) ;
CompoAft.CopyFrom( pCrvAft) ;
}
else {
PtrOwner<ICurve> pCrvPrev( CompoChain.CopyParamRange( dUBreak, dUE)) ;
CompoPrev.CopyFrom( pCrvPrev) ;
CompoPrev.Invert() ;
PtrOwner<ICurve> pCrvAft( CompoChain.CopyParamRange( dUS, dUBreak1)) ;
CompoAft.CopyFrom( pCrvAft) ;
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) {
PtrOwner<ICurve> pCrv( CompoChain.CopyParamRange( dUBreak, dUBreak1)) ;
CompoSingle.CopyFrom( pCrv) ;
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 {
PtrOwner<ICurve> pCrv( CompoChain.CopyParamRange( dUBreak1, dUBreak)) ;
CompoSingle.CopyFrom( pCrv) ;
#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]
PtrOwner<ICurve> pCrvA( CompoX.CopyParamRange( dUStartA, dUE)) ;
PtrOwner<ICurve> pCrvB( CompoX.CopyParamRange( dUS, dUEndB)) ;
if ( ! myCompoA.CopyFrom( pCrvA) || ! myCompoB.CopyFrom( pCrvB))
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 < ssize( vTBox) ; ++ 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 ;
unordered_map<int, int> MymapTriaClass ;
if ( ! ClassifyTriangles( Stm, vTBox, nTria, dAngTol, MysetAvoidTria, MysetNewTria, MymapTriaClass))
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 ( ssize( vCompoChain) <= 1)
return true ;
// Se ottengo ancora due curve, allora la striscia non rispetta lo spessore minimo
bBreak = ( ssize( vCompoChain) >= 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,
unordered_map<int, int>& mapTriaClass, 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, mapTriaClass))
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,
unordered_map<int, int>& mapTriaClass, 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, mapTriaClass, 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 un bordo è una circonferenza
// ( Restituisce true nel caso lo sia e la circonferenza perfetta come ultimo parametro)
static bool
IsBorderACircle( const PolyLine& PL, double dLinTol, double dAngTol, Frame3d& frCircle, double& dRad,
CurveArc& CrvCircle)
{
// Se PolyLine aperta o non piana, non è un cerchio
Plane3d PlanePL ;
if ( ! PL.IsClosed() || ! PL.IsFlat( PlanePL, dLinTol))
return false ;
// Verifico che tutti i punti rispettino la tolleranza angolare
POLYLINEVECTOR vPL ;
if ( ! GetPointSetByAngTol( PL, dAngTol, vPL) || ssize( vPL) != 1)
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)
// ( I punti vengono proeittati nel piano per una maggiore precisione)
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) ;
}
for ( POINTU& ptU : PLLoc.GetUPointList())
ptU.first.z = 0. ;
#if DEBUG_HOLES
vector<IGeoObj*> VTCircle ;
vector<Color> VCCirle ;
CurveComposite CompoPL ; CompoPL.FromPolyLine( PLLoc) ;
VTCircle.emplace_back( CompoPL.Clone()) ;
VCCirle.emplace_back( RED) ;
IGeoPoint3d* ptCenter = CreateGeoPoint3d() ; ptCenter->Set( ptCentroid) ;
ptCenter->ToLoc( frCurr) ;
VTCircle.emplace_back( ptCenter) ;
VCCirle.emplace_back( BLUE) ;
for ( int i = 0 ; i < ssize( vPts) ; ++ i) {
IGeoPoint3d* ptOnCirle = CreateGeoPoint3d() ; ptOnCirle->Set( vPts[i]) ;
VTCircle.emplace_back( ptOnCirle) ;
VCCirle.emplace_back( GREEN) ;
}
SaveGeoObj( VTCircle, VCCirle, "C:\\Temp\\CircleDebug.nge") ;
Point3d ptIMin, ptEMin, ptMaxDist ;
#endif
// 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 < ssize( vPts) / 2 ; i = i + 2) {
double dSqLineDist = INFINITO ;
DistPointLine( ORIG, vPts[i], vPts[i + 1]).GetSqDist( dSqLineDist) ;
if ( dSqLineDist < dSqMinDist) {
dSqMinDist = dSqLineDist ;
#if DEBUG_HOLES
ptIMin = vPts[i] ; ptEMin = vPts[i + 1] ;
#endif
}
double dSqPtDist = SqDist( ORIG, vPts[i]) ;
if ( dSqPtDist > dSqMaxDist) {
dSqMaxDist = dSqPtDist ;
#if DEBUG_HOLES
ptMaxDist = vPts[i] ;
#endif
}
}
#if DEBUG_HOLES
CurveLine LineMinDist ; LineMinDist.Set( ptIMin, ptEMin) ;
VTCircle.emplace_back( LineMinDist.Clone()) ;
VCCirle.emplace_back( YELLOW) ;
IGeoPoint3d* myPtMaxDist = CreateGeoPoint3d() ; myPtMaxDist->Set( ptMaxDist) ;
VTCircle.emplace_back( myPtMaxDist) ;
VCCirle.emplace_back( YELLOW) ;
SaveGeoObj( VTCircle, VCCirle, "C:\\Temp\\CircleDebug.nge") ;
#endif
// Se distanza minima e massima entro tolleranza, allora è una circonferenza
double dMinDist = sqrt( dSqMinDist) ;
double dMaxDist = sqrt( dSqMaxDist) ;
if ( abs( dMaxDist - dMinDist) < dLinTol) {
frCircle.Set( ptCentroid, PlanePL.GetVersN()) ;
dRad = ( dMinDist + dMaxDist) / 2. ;
return ( CrvCircle.Set( frCircle.Orig(), frCircle.VersZ(), dRad)) ;
}
return false ;
}
// ----------------------------------------------------------------------------
// Funzione per definire se il bordo di una TriMesh è un'asola
static bool
IsBorderAButtonHole( const PolyLine& PL, double dLinTol, double dAngTol, Frame3d& frBtHole,
double& dRectLen, double& dRad, CurveComposite& CompoBthole)
{
// Se PolyLine aperta o non piana, non è un'asola
Plane3d PlanePL ;
if ( ! PL.IsClosed() || ! PL.IsFlat( PlanePL, dLinTol))
return false ;
// Verifico che tutti i punti rispettino la tolleranza angolare
POLYLINEVECTOR vPL ;
if ( ! GetPointSetByAngTol( PL, dAngTol, vPL) || ssize( vPL) != 1)
return false ;
#if DEBUG_HOLES
vector<IGeoObj*> VTCircle ;
vector<Color> VCCirle ;
CurveComposite CompoPL ; CompoPL.FromPolyLine( PL) ;
VTCircle.emplace_back( CompoPL.Clone()) ;
VCCirle.emplace_back( RED) ;
SaveGeoObj( VTCircle, VCCirle, "C:\\Temp\\ButtonHoleDebug.nge") ;
#endif
// Creo un sistema di riferimento centrato nella PolyLine e porto una sua copia in esso
Frame3d frXY ;
if ( ! frXY.Set( PlanePL.GetPoint(), PlanePL.GetVersN()))
return false ;
PolyLine PLXY = PL ; PLXY.ToLoc( frXY) ;
for ( POINTU& ptU : PLXY.GetUPointList())
ptU.first.z = 0. ;
#if DEBUG_HOLES
CurveComposite CompoXY ; CompoXY.FromPolyLine( PLXY) ;
VTCircle.emplace_back( CompoXY.Clone()) ;
VCCirle.emplace_back( BLUE) ;
SaveGeoObj( VTCircle, VCCirle, "C:\\Temp\\ButtonHoleDebug.nge") ;
#endif
// Recupero il rettangolo ad area minima
Point3d ptCen ;
Vector3d vtRectAx ;
double dLen, dHeight ;
if ( ! PLXY.GetMinAreaRectangleXY( ptCen, vtRectAx, dLen, dHeight))
return false ;
// Verifico che non sia un rettangolo ben definito, non un quadrato
if ( dLen - dHeight < 1001. * EPS_SMALL)
return false ; // potrebbe essere una circonferenza
// Cambio il sistema di riferimento in quello definito dal rettangolo
Frame3d frRect ;
if ( ! frRect.Set( ptCen, Z_AX, vtRectAx))
return false ;
PLXY.ToLoc( frRect) ;
#if DEBUG_HOLES
CompoXY.Clear() ; CompoXY.FromPolyLine( PLXY) ;
VTCircle.emplace_back( CompoXY.Clone()) ;
VCCirle.emplace_back( AQUA) ;
SaveGeoObj( VTCircle, VCCirle, "C:\\Temp\\ButtonHoleDebug.nge") ;
#endif
// Individuo il punto in basso a sinistra del rettangolo
Point3d ptLeftBotton = ORIG - ( dLen / 2.) * X_AX - ( dHeight / 2.) * Y_AX ;
// Semicirconferenza a sinistra
Point3d ptArcLeftCenter = ptLeftBotton + X_AX * dHeight / 2. + Y_AX * dHeight / 2. ;
CurveArc ArcLeft ;
ArcLeft.Set( ptArcLeftCenter, Z_AX, dHeight / 2., Y_AX, ANG_STRAIGHT, 0.) ;
// Semicirconferenza a destra
Point3d ptArcRightCenter = ptLeftBotton + ( dLen - dHeight / 2.) * X_AX + Y_AX * dHeight / 2. ;
CurveArc ArcRight ;
ArcRight.Set( ptArcRightCenter, Z_AX, dHeight / 2., - Y_AX, ANG_STRAIGHT, 0.) ;
// Tratto Lineare Top
CurveLine LineTop ;
LineTop.Set( ptArcRightCenter + Y_AX * dHeight / 2., ptArcLeftCenter + Y_AX * dHeight / 2.) ;
// Tratto Lineare Botton
CurveLine LineBottom ;
LineBottom.Set( ptArcLeftCenter - Y_AX * dHeight / 2., ptArcRightCenter - Y_AX * dHeight / 2.) ;
// Curva Composita complessiva dell'asola
CurveComposite CompoButtonHolePerfect ;
CompoButtonHolePerfect.AddCurve( LineTop) ;
CompoButtonHolePerfect.AddCurve( ArcLeft) ;
CompoButtonHolePerfect.AddCurve( LineBottom) ;
CompoButtonHolePerfect.AddCurve( ArcRight) ;
#if DEBUG_HOLES
VTCircle.emplace_back( CompoButtonHolePerfect.Clone()) ;
VCCirle.emplace_back( WHITE) ;
SaveGeoObj( VTCircle, VCCirle, "C:\\Temp\\ButtonHoleDebug.nge") ;
#endif
// Verifico che tutti i punti dell PolyLine siano abbastanza vicini a tale curva
// Campiono usando i punti medi, altrimenti qualsiasi poligono iscritto nell'asola ideale
// sarebbe valido
PNTVECTOR vPts ;
Point3d ptNext ;
PLXY.GetFirstPoint( ptNext) ;
vPts.push_back( ptNext) ;
while ( PLXY.GetNextPoint( ptNext)) {
vPts.push_back( Media( vPts.back(), ptNext)) ;
vPts.push_back( ptNext) ;
}
#if DEBUG_HOLES
for ( int i = 0 ; i < ssize( vPts) ; ++ i) {
IGeoPoint3d* ptOnCirle = CreateGeoPoint3d() ; ptOnCirle->Set( vPts[i]) ;
VTCircle.emplace_back( ptOnCirle) ;
VCCirle.emplace_back( GREEN) ;
}
SaveGeoObj( VTCircle, VCCirle, "C:\\Temp\\ButtonHoleDebug.nge") ;
#endif
bool bButtonHole = true ;
for ( int i = 0 ; bButtonHole && i < ssize( vPts) ; ++ i) {
double dSqDist = INFINITO ;
bButtonHole = ( DistPointCurve( vPts[i], CompoButtonHolePerfect).GetSqDist( dSqDist) &&
dSqDist < dLinTol * dLinTol) ;
}
// Se Asola, restituisco i parametri
if ( bButtonHole) {
frBtHole.Set( GetToGlob( GetToGlob( ORIG, frRect), frXY),
PlanePL.GetVersN(),
GetToGlob( GetToGlob( X_AX, frRect), frXY)) ;
dRectLen = dLen - 2. * dHeight ;
dRad = dHeight / 2. ;
CompoBthole.CopyFrom( &CompoButtonHolePerfect) ;
CompoBthole.ToGlob( frRect) ;
CompoBthole.ToGlob( frXY) ;
return true ;
}
return false ;
}
//-----------------------------------------------------------------------------
//-------------------------------- Interpolazioni -----------------------------
//-----------------------------------------------------------------------------
static bool
InterpolateSyncCurvesOnEndGuidePoints( const ICurveComposite* pGuide, const ICurveComposite* pOtherGuide,
const Plane3d& plStart, const Plane3d& plEnd, double dLinTol,
BIPNTVECTOR& vBiPts)
{
vBiPts.clear() ;
// Verifico che le curve siano valide
if ( pGuide == nullptr || ! pGuide->IsValid() ||
pOtherGuide == nullptr || ! pOtherGuide->IsValid())
return false ;
// Recupero la sua lunghezza
double dGuideLen = 0. ;
if ( ! pGuide->GetLength( dGuideLen) || dGuideLen < dLinTol)
return false ;
// Scorro le curve da restituire
double dProgLen = 0. ;
vBiPts.reserve( pGuide->GetCurveCount() - 1) ;
for ( int i = 0 ; i < pGuide->GetCurveCount() - 1 ; ++ i) {
// Recupero la curva corrente
const ICurve* pCrv = pGuide->GetCurve( i) ;
if ( pCrv == nullptr || ! pCrv->IsValid())
return false ;
// Ne recupero la lunghezza e aggiorno la lunghezza progressiva
double dLen = 0. ;
if ( ! pCrv->GetLength( dLen))
return false ;
dProgLen += dLen ;
// Recupero la percentuale di interpolazione rispetto alla lunghezze
double dInterPar = dProgLen / dGuideLen ;
// Interpolo le normali dei piani rispetto a tale valore
Vector3d vtN = Media( plStart.GetVersN(), plEnd.GetVersN(), dInterPar) ;
vtN.Normalize() ;
// Definisco il piano di intersezione
Point3d ptCurr ;
if ( ! pCrv->GetEndPoint( ptCurr))
return false ;
#if DEBUG_SYNC_INTERPOLATION
Frame3d frPl ; frPl.Set( ptCurr, vtN) ;
PtrOwner<IGeoFrame3d> frCurr( CreateGeoFrame3d()) ; frCurr->Set( frPl) ;
VT.emplace_back( Release( frCurr)) ;
VC.emplace_back( WHITE) ;
SaveGeoObj( VT, VC, "C:\\Temp\\SyncLinesPlanes.nge") ;
#endif
// Recupero il parametro di intersezione tra la curva e il piano
#if 0
VT.clear() ; VC.clear() ;
PtrOwner<IGeoPoint3d> PT( CreateGeoPoint3d()) ; PT->Set( ptCurr) ;
VT.emplace_back( Release( PT)) ;
VC.emplace_back( AQUA) ;
PtrOwner<IGeoVector3d> VECT( CreateGeoVector3d()) ; VECT->Set( vtN) ;
VECT->ChangeBase( ptCurr) ;
PtrOwner<ICurveArc> pArc( CreateCurveArc()) ; pArc->Set( ptCurr, vtN, 1000.) ;
PtrOwner<ISurfFlatRegion> pSfrPlane( CreateSurfFlatRegion()) ;
pSfrPlane->AddExtLoop( Release( pArc)) ;
VT.emplace_back( Release( pSfrPlane)) ;
VC.emplace_back( Color( 0., 0., 0., .5)) ;
VT.emplace_back( Release( VECT)) ;
VC.emplace_back( BLUE) ;
VT.emplace_back( pOtherGuide->Clone()) ;
VC.emplace_back( WHITE) ;
SaveGeoObj( VT, VC, "C:\\Temp\\SyncLinesPlanes.nge") ;
#endif
IntersCurvePlane IntCP( *pOtherGuide, ptCurr, vtN) ;
if ( IntCP.GetIntersCount() == 0)
return false ; // ambiguità
// Recupero il punto della prima intersezione trovata
Point3d ptInt ;
double dPar ;
if ( ! IntCP.GetIntersPointNearTo( ptCurr, ptInt, dPar))
return false ;
#if DEBUG_SYNC_INTERPOLATION
PtrOwner<IGeoPoint3d> ptG( CreateGeoPoint3d()) ; ptG->Set( ptInt) ;
VT.emplace_back( Release( ptG)) ;
VC.emplace_back( WHITE) ;
SaveGeoObj( VT, VC, "C:\\Temp\\SyncLinesPlanes.nge") ;
#endif
// Memorizzo tale punto
vBiPts.emplace_back( make_pair( ptCurr, ptInt)) ;
}
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 ;
}
#if DEBUG_RAW_EDGES
VT.clear() ; VC.clear() ;
for ( int i = 0 ; i < ssize( vSurf) ; ++ i) {
VT.emplace_back( vSurf[i]->Clone()) ;
VC.emplace_back( BLACK) ;
}
for ( int i = 0 ; i < ssize( vCompoRawEdges) ; ++ i) {
VT.emplace_back( vCompoRawEdges[i]) ;
VC.emplace_back( RED) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\RawEdges.nge") ;
#endif
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 ( ssize( vCompoBezierEdges) == 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 ( ssize( vCompoBezierEdges) == 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 dSurfLinTol,
double dSurfAngTol, 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 complessiva
PtrOwner<const SurfTriMesh> pStm( nullptr) ;
if ( ssize( vpSurf) == 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( dSurfLinTol))) ;
}
}
else {
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( dSurfLinTol)) ;
if ( ! IsNull( pStmTmp) && pStmTmp->IsValid())
mySoup.AddSurfTriMesh( *pStmTmp) ;
}
}
mySoup.End() ;
pStm.Set( GetBasicSurfTriMesh( mySoup.GetSurf())) ;
}
if ( IsNull( pStm) || ! pStm->IsValid() || pStm->IsClosed())
return false ;
// Calcolo il Bordo mediante estrusione
vector<pair<PolyLine, PolyLine>> vPLLoopPLExtr ;
if ( ! GetBorderByExtrusion( pStm, dThick, dMyLinTol, dMyAngTol, vPLLoopPLExtr))
return false ;
// Trasformo ogni PolyLine in Curva Composita
for ( int i = 0 ; i < ssize( vPLLoopPLExtr) ; ++ i) {
PolyLine& PLLoop = vPLLoopPLExtr[i].first ;
PtrOwner<ICurveComposite> pCompoLoop( CreateCurveComposite()) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->FromPolyLine( PLLoop))
continue ;
PolyLine& PLLoopExtr = vPLLoopPLExtr[i].second ;
PtrOwner<ICurveComposite> pCompoLoopExtr( CreateCurveComposite()) ;
if ( IsNull( pCompoLoopExtr) || ! pCompoLoopExtr->FromPolyLine( PLLoopExtr))
continue ;
vCompoBezierEdges.emplace_back( Release( pCompoLoop)) ;
if ( ! ApproxBorder( *GetBasicCurveComposite( vCompoBezierEdges.back()), dMyLinTol, dMyAngTol))
return false ;
vCompoBezierEdges.emplace_back( Release( pCompoLoopExtr)) ;
if ( ! ApproxBorder( *GetBasicCurveComposite( vCompoBezierEdges.back()), dMyLinTol, dMyAngTol))
return false ;
}
// Restituisco le curve orientate correttamente per la creazione della superficie di Bezier
erase_if( vCompoBezierEdges,
[]( ICurveComposite* pBezierEdge) {
return ( pBezierEdge == nullptr || ! pBezierEdge->IsValid() || pBezierEdge->GetCurveCount() == 0) ;}) ;
for ( int i = 0 ; i < ssize( vCompoBezierEdges) - 1 ; i += 2) {
ManageRuledBorders( vCompoBezierEdges[i], vCompoBezierEdges[i+1]) ;
// Essendo l'Offset fatto in negativo, entrambe le curve vanno invertite
vCompoBezierEdges[i]->Invert() ;
vCompoBezierEdges[i+1]->Invert() ;
}
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 < ssize( vCompoRawEdges) ; ++ _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 < ssize( vCompoRawEdges) ; ++ i) {
PtrOwner<ICurveComposite> pCompoTmp( CloneCurveComposite( vCompoRawEdges[i])) ;
if ( IsNull( pCompoTmp) ||
! ApproxBorder( *GetBasicCurveComposite( pCompoTmp), dMyLinTol, dMyAngTol) ||
! vBezierEdges.emplace_back( Release( pCompoTmp))) {
LOG_ERROR( GetEGkLogger(), "Error in Trimming : Approxing edge failed") ;
return false ;
}
}
// Restituisco le curve orientate correttamente per la creazione della superficie di Bezier
erase_if( vBezierEdges,
[]( ICurveComposite* pBezierEdge) {
return ( pBezierEdge == nullptr || ! pBezierEdge->IsValid() || pBezierEdge->GetCurveCount() == 0) ;}) ;
for ( int i = 0 ; i < ssize( vBezierEdges) - 1 ; i += 2)
ManageRuledBorders( vBezierEdges[i], vBezierEdges[i+1]) ;
#if DEBUG_EDGES
VC.clear() ; VT.clear() ;
for ( int _i = 0 ; _i < ssize( vBezierEdges) ; ++ _i) {
VT.emplace_back( vBezierEdges[_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)
{
vSyncPoints.clear() ;
// Verifica validità delle curve per la creazione della Bezier rigata
PtrOwner<ICurveComposite> pCompoEdge1( ConvertCurveToComposite( pCrvEdge1->Clone())) ;
PtrOwner<ICurveComposite> pCompoEdge2( ConvertCurveToComposite( pCrvEdge2->Clone())) ;
if ( IsNull( pCompoEdge1) || IsNull( pCompoEdge2) ||
! pCompoEdge1->IsValid() || ! pCompoEdge2->IsValid())
return false ;
// 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( GetSurfBezierRuledSmooth( pCompoEdge1, pCompoEdge2, vSyncPoints, 20.0))) ;
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 < ssize( vCrv) ; ++ 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 interpolare le Curve di Sincronizzazione tra due Curve di Bordo
bool
GetTrimmingSyncInterpolation( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2,
const ICurve* pSync1, const ICurve* pSync2, double dLinTol,
double dAngTol, BIPNTVECTOR& vSyncPoints)
{
vSyncPoints.clear() ;
// Verifico la validità dei parametri
if ( pCrvEdge1 == nullptr || ! pCrvEdge1->IsValid() ||
pCrvEdge2 == nullptr || ! pCrvEdge2->IsValid() ||
pSync1 == nullptr || ! pSync1->IsValid() ||
pSync2 == nullptr || ! pSync2->IsValid())
return false ;
// Le curve di Bordo devono essere entrambe aperte o entrambe chiuse
if ( pCrvEdge1->IsClosed() != pCrvEdge2->IsClosed())
return false ;
// Verifico i valori delle tolleranze
double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
double dMyAngTol = Clamp( dAngTol, EPS_ANG_SMALL, 60.) ;
// Verifico le due curve di sincronizzazione abbiano gli estremi sulle due curve di bordo
Point3d ptS1 ; pSync1->GetStartPoint( ptS1) ;
Point3d ptE1 ; pSync1->GetEndPoint( ptE1) ;
if ( AreSamePointEpsilon( ptS1, ptE1, dMyLinTol))
return false ;
double dUA, dUB, dUC, dUD ; // [A,C]->Edge1 | [B,D]->Edge2
if ( ( ! pCrvEdge1->GetParamAtPoint( ptS1, dUA, dMyLinTol) || ! pCrvEdge2->GetParamAtPoint( ptE1, dUB, dMyLinTol)) &&
( ! pCrvEdge1->GetParamAtPoint( ptE1, dUA, dMyLinTol) || ! pCrvEdge2->GetParamAtPoint( ptS1, dUB, dMyLinTol)))
return false ;
Point3d ptS2 ; pSync2->GetStartPoint( ptS2) ;
Point3d ptE2 ; pSync2->GetEndPoint( ptE2) ;
if ( AreSamePointEpsilon( ptS2, ptE2, dMyLinTol))
return false ;
if ( ( ! pCrvEdge1->GetParamAtPoint( ptS2, dUC, dMyLinTol) || ! pCrvEdge2->GetParamAtPoint( ptE2, dUD, dMyLinTol)) &&
( ! pCrvEdge1->GetParamAtPoint( ptE2, dUC, dMyLinTol) || ! pCrvEdge2->GetParamAtPoint( ptS2, dUD, dMyLinTol)))
return false ;
// Recupero i due tratti di curva
PtrOwner<CurveComposite> pCompoGuide1( nullptr) ;
PtrOwner<CurveComposite> pCompoGuide2( nullptr) ;
// se entrambe chiuse
if ( pCrvEdge1->IsClosed() && pCrvEdge2->IsClosed()) {
// Recupero la porzione di curva di Edge1 di lunghezza minima tra il parametro A e C
PtrOwner<CurveComposite> pCompoAC( ConvertCurveToBasicComposite( pCrvEdge1->CopyParamRange( dUA, dUC))) ;
PtrOwner<CurveComposite> pCompoCA( ConvertCurveToBasicComposite( pCrvEdge1->CopyParamRange( dUC, dUA))) ;
if ( IsNull( pCompoAC) || IsNull( pCompoCA) || ! pCompoAC->IsValid() || ! pCompoCA->IsValid())
return false ;
double dLenAC ; pCompoAC->GetLength( dLenAC) ;
double dLenCA ; pCompoCA->GetLength( dLenCA) ;
if ( dLenAC < dLenCA)
pCompoGuide1.Set( Release( pCompoAC)) ;
else
pCompoGuide1.Set( Release( pCompoCA)) ;
// Recupero la porzione di curva di Edge2 di lunghezza minima tra il parametro B e D
PtrOwner<CurveComposite> pCompoBD( ConvertCurveToBasicComposite( pCrvEdge2->CopyParamRange( dUB, dUD))) ;
PtrOwner<CurveComposite> pCompoDB( ConvertCurveToBasicComposite( pCrvEdge2->CopyParamRange( dUD, dUB))) ;
if ( IsNull( pCompoBD) || IsNull( pCompoBD) || ! pCompoBD->IsValid() || ! pCompoDB->IsValid())
return false ;
double dLenBD ; pCompoBD->GetLength( dLenBD) ;
double dLenDB ; pCompoDB->GetLength( dLenDB) ;
if ( dLenBD < dLenDB)
pCompoGuide2.Set( Release( pCompoBD)) ;
else
pCompoGuide2.Set( Release( pCompoDB)) ;
}
// se entrambe aperte
else if ( ! pCrvEdge1->IsClosed() && ! pCrvEdge2->IsClosed()) {
pCompoGuide1.Set( ConvertCurveToBasicComposite( pCrvEdge1->Clone())) ;
if ( IsNull( pCompoGuide1) || ! pCompoGuide1->IsValid())
return false ;
if ( dUA < dUC)
pCompoGuide1->TrimStartEndAtParam( dUA, dUC) ;
else
pCompoGuide1->TrimStartEndAtParam( dUC, dUA) ;
pCompoGuide2.Set( ConvertCurveToBasicComposite( pCrvEdge2->Clone())) ;
if ( IsNull( pCompoGuide2) || ! pCompoGuide2->IsValid())
return false ;
if ( dUB < dUD)
pCompoGuide2->TrimStartEndAtParam( dUB, dUD) ;
else
pCompoGuide2->TrimStartEndAtParam( dUD, dUB) ;
}
if ( IsNull( pCompoGuide1) || IsNull( pCompoGuide2) ||
! pCompoGuide1->IsValid() || ! pCompoGuide2->IsValid())
return false ;
// Determino quale curva è la più lunga, servirà come riferimento per la parametrizzazione e l'interpolazione
double dLen1, dLen2 ;
if ( ! pCompoGuide1->GetLength( dLen1) || ! pCompoGuide2->GetLength( dLen2) ||
dLen1 < dMyLinTol || dLen2 < dMyLinTol)
return false ;
if ( dLen2 > dLen1) {
swap( pCompoGuide1, pCompoGuide2) ;
swap( dLen1, dLen2) ;
}
// Aggiorno gli estremi delle curve
pCompoGuide1->GetStartPoint( ptS1) ;
pCompoGuide2->GetStartPoint( ptE1) ;
pCompoGuide1->GetEndPoint( ptS2) ;
pCompoGuide2->GetEndPoint( ptE2) ;
#if DEBUG_SYNC_INTERPOLATION
VT.clear() ; VC.clear() ;
VT.emplace_back( pCompoGuide1->Clone()) ;
VC.emplace_back( AQUA) ;
VT.emplace_back( pCompoGuide2->Clone()) ;
VC.emplace_back( ORANGE) ;
PtrOwner<IGeoPoint3d> ptG( CreateGeoPoint3d()) ; ptG->Set( ptS1) ;
VT.emplace_back( ptG->Clone()) ; VC.emplace_back( AQUA) ;
ptG->Set( ptE1) ;
VT.emplace_back( ptG->Clone()) ; VC.emplace_back( ORANGE) ;
ptG->Set( ptS2) ;
VT.emplace_back( ptG->Clone()) ; VC.emplace_back( AQUA) ;
ptG->Set( ptE2) ;
VT.emplace_back( ptG->Clone()) ; VC.emplace_back( ORANGE) ;
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ; pLine->Set( ptS1, ptE1) ;
VT.emplace_back( pLine->Clone()) ; VC.emplace_back( PURPLE) ;
pLine->Set( ptS2, ptE2) ;
VT.emplace_back( pLine->Clone()) ; VC.emplace_back( PURPLE) ;
SaveGeoObj( VT, VC, "C:\\Temp\\SyncLinesPlanes.nge") ;
#endif
// Determino le Normali dei piani di taglio agli agli estremi delle due curve
Vector3d vtStart1, vtStart2 ;
if ( ! pCompoGuide1->GetStartDir( vtStart1) || ! pCompoGuide2->GetStartDir( vtStart2))
return false ;
Vector3d vtAux = ptE1 - ptS1 ; vtAux.Normalize() ;
Vector3d vtMTan = Media( vtStart1, vtStart2) ; vtMTan.Normalize() ;
Vector3d vtN = OrthoCompo( vtMTan, vtAux) ; vtN.Normalize() ;
Plane3d plStart ;
if ( ! plStart.Set( ptS1, vtN))
return false ;
Vector3d vtEnd1, vtEnd2 ;
if ( ! pCompoGuide1->GetEndDir( vtEnd1) || ! pCompoGuide2->GetEndDir( vtEnd2))
return false ;
vtAux = ptE2 - ptS2 ; vtAux.Normalize() ;
vtMTan = Media( vtEnd1, vtEnd2) ; vtMTan.Normalize() ;
vtN = OrthoCompo( vtMTan, vtAux) ; vtN.Normalize() ;
Plane3d plEnd ;
if ( ! plEnd.Set( ptS2, vtN))
return false ;
#if DEBUG_SYNC_INTERPOLATION
Frame3d frPlStart ; frPlStart.Set( ptS1, plStart.GetVersN()) ;
Frame3d frPlEnd ; frPlEnd.Set( ptS2, plEnd.GetVersN()) ;
PtrOwner<IGeoFrame3d> frS( CreateGeoFrame3d()) ; frS->Set( frPlStart) ;
PtrOwner<IGeoFrame3d> frE( CreateGeoFrame3d()) ; frE->Set( frPlEnd) ;
VT.emplace_back( Release( frS)) ;
VC.emplace_back( WHITE) ;
VT.emplace_back( Release( frE)) ;
VC.emplace_back( WHITE) ;
SaveGeoObj( VT, VC, "C:\\Temp\\SyncLinesPlanes.nge") ;
#endif
// Curve di Sincronizzazione del Bordo 1 sul Bordo 2
BIPNTVECTOR vBiPts1 ;
if ( ! InterpolateSyncCurvesOnEndGuidePoints( pCompoGuide1, pCompoGuide2, plStart, plEnd, dMyLinTol, vBiPts1))
return false ;
// Curve di Sincronizzazione del Bordo 2 sul Bordo 1
BIPNTVECTOR vBiPts2 ;
if ( ! InterpolateSyncCurvesOnEndGuidePoints( pCompoGuide2, pCompoGuide1, plStart, plEnd, dMyLinTol, vBiPts2))
return false ;
// Restituisco le Curve di Sincronizzazione
// [Da Bordo 1 a Bordo 2 originale]
vSyncPoints.reserve( ssize( vBiPts1) + ssize( vBiPts2)) ;
for ( int i = 0 ; i < ssize( vBiPts1) ; ++ i) {
vSyncPoints.emplace_back( vBiPts1[i]) ;
if ( pCrvEdge1->IsPointOn( vBiPts1[i].second, dMyLinTol))
swap( vSyncPoints.back().first, vSyncPoints.back().second) ;
}
for ( int i = 0 ; i < ssize( vBiPts2) ; ++ i) {
vSyncPoints.emplace_back( vBiPts2[i]) ;
if ( pCrvEdge1->IsPointOn( vBiPts2[i].second, dMyLinTol))
swap( vSyncPoints.back().first, vSyncPoints.back().second) ;
}
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)
{
// Verifica validità delle curve per la creazione della Bezier rigata
if ( pCrvEdge1 == nullptr || pCrvEdge2 == nullptr ||
! pCrvEdge1->IsValid() || ! pCrvEdge2->IsValid())
return nullptr ;
// Se una chiusa e una aperta, errore
if ( pCrvEdge1->IsClosed() != pCrvEdge2->IsClosed())
return nullptr ;
PtrOwner<ICurveComposite> pCompoEdge1( ConvertCurveToComposite( pCrvEdge1->Clone())) ;
PtrOwner<ICurveComposite> pCompoEdge2( ConvertCurveToComposite( pCrvEdge2->Clone())) ;
if ( IsNull( pCompoEdge1) || IsNull( pCompoEdge2))
return nullptr ;
// Se entrambe aperte potrei doverle invertire, altrimenti non le modifico
if ( ! pCrvEdge1->IsClosed() && ! pCrvEdge2->IsClosed()) {
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
// Inzializzo la superficie di Bezier
PtrOwner<ISurfBezier> pSurfBz( CreateSurfBezier()) ;
if ( IsNull( pSurfBz))
return nullptr ;
// Se non ho punti di controllo forzati
if ( vSyncPoints.empty()) {
BIPNTVECTOR vSyncLines ;
pSurfBz.Set( GetSurfBezierRuledSmooth( pCompoEdge1, pCompoEdge2, vSyncLines, 20.0)) ;
if ( IsNull( pSurfBz) || ! pSurfBz->IsValid()) {
LOG_ERROR( GetEGkLogger(), "Error in Trimming : Ruled Bezier invalid") ;
return nullptr ;
}
}
// Se ho punti di controllo forzati
else {
#if DEBUG_BEZIER_RULED
for ( int i = 0 ; i < ssize( vSyncPoints) ; ++ i) {
const Point3d& ptS = vSyncPoints[i].first ;
const Point3d& ptE = vSyncPoints[i].second ;
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
if ( IsNull( pLine) || ! pLine->Set( ptS, ptE))
return nullptr ;
VT_Glob.emplace_back( pLine->Clone()) ;
if ( find( vnShown.begin(), vnShown.end(), i) != vnShown.end()) {
if ( find( vnEdited.begin(), vnEdited.end(), i) != vnEdited.end())
VC_Glob.emplace_back( GREEN) ;
else if ( find( vnNew.begin(), vnNew.end(), i) != vnNew.end())
VC_Glob.emplace_back( ORANGE) ;
else
VC_Glob.emplace_back( LIME) ;
}
else
VC_Glob.emplace_back( GRAY) ;
}
SaveGeoObj( VT_Glob, VC_Glob, "C:\\Temp\\TestBz.nge") ;
#endif
// Definisco la superficie
INTVECTOR vInd( ssize( vSyncPoints)) ; iota( vInd.begin(), vInd.end(), 0) ;
pSurfBz.Set( GetSurfBezierRuledGuided( pCompoEdge1, pCompoEdge2, vSyncPoints, 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( BLACK) ;
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, int nStartTria, const Point3d& ptStartTria,
double dAngTol, double dSize, double dSizeTol, ISurfTriMesh* pStmAdjTria)
{
// La superfcicie deve essere inizializzata
if ( pStmAdjTria == nullptr)
return false ;
// Verifico la validità della superficie TriMesh
if ( ! pStm->IsValid())
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( nStartTria, firstTria))
return false ;
BBox3d BBoxCurr ;
BBoxCurr.Add( ptStartTria) ;
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 ;
INTVECTOR vOtherTria ; vOtherTria.reserve( pStmBasic->GetTriangleCount()) ;
unordered_set<int> setAvoidTria ; setAvoidTria.reserve( pStmBasic->GetTriangleCount()) ;
unordered_set<int> setValidTria ; setValidTria.reserve( pStmBasic->GetTriangleCount()) ;
unordered_set<int> setNewTria ; setNewTria.reserve( pStmBasic->GetTriangleCount()) ;
unordered_map<int, int> mapTriaClass ; mapTriaClass.reserve( pStmBasic->GetTriangleCount()) ;
Point3d ptMid, ptMid1 ;
int nTria = 0, nTria1 = 0 ;
CurveComposite CompoA, CompoB ;
if ( ! GetBordersInBox( *pStmBasic, BBoxCurr, nStartTria, ptStartTria, dSize, dSizeTol, true, true,
dAngTol, 2. * EPS_SMALL, setAvoidTria, setNewTria, mapTriaClass, 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) ;
}
// Altrimenti ricerco gli altri triangoli validi
else {
// 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, mapTriaClass, 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, mapTriaClass, false,
ptMid, nTria, dSize, dSizeTol, dAngTol, bRelFirst, CompoA, CompoB, bStop))
return false ;
}
}
// Aggiusto i Triangoli in base alla loro classificazione ( modificandoli se necessario)
TRIA3DVECTOR vAllTria ; vAllTria.reserve( pStmBasic->GetTriangleCount()) ;
if ( ! AdjustClassifiedTriangles( setValidTria, pStmBasic, mapTriaClass, vAllTria))
return false ;
// Creo la superficie TriMesh dai triangoli ricavati
StmFromTriangleSoup TriaSoup ;
TriaSoup.Start() ;
for ( const Triangle3d& Tria : vAllTria) {
if ( ! TriaSoup.AddTriangle( Tria))
return false ;
}
TriaSoup.End() ;
PtrOwner<ISurfTriMesh> pStmTria( TriaSoup.GetSurf()) ;
if ( IsNull( pStmTria) || ! pStmTria->IsValid() || pStmTria->GetTriangleCount() == 0)
return false ;
return ( pStmAdjTria->CopyFrom( pStmTria)) ;
}
//------------------------------------------------------------------------------
// 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 ;
}
// Recupero le Patch delle superfici
SURFPATCHESVECTOR vSurfPatches ; vSurfPatches.reserve( vSurf.size() + vOtherSurf.size()) ;
// --- Superfici Selezionate
for ( int nS = 0 ; nS < ssize( vSurf) ; ++ nS) {
vSurfPatches.emplace_back( SurfPatches()) ;
vSurfPatches.back().pSurf = vSurf[nS] ;
if ( ! CalcSurfPatch( vSurf[nS], dLinTol, dAngTol, vSurfPatches.back()))
return false ;
}
// --- Altre Superfici
for ( int nS = 0 ; nS < ssize( vOtherSurf) ; ++ nS) {
vSurfPatches.emplace_back( SurfPatches()) ;
vSurfPatches.back().pSurf = vOtherSurf[nS] ;
if ( ! CalcSurfPatch( vOtherSurf[nS], dLinTol, dAngTol, vSurfPatches.back()))
return false ;
}
#if DEBUG_SURF_PATCHES
VT.clear() ; VC.clear() ;
for ( int i = 0 ; i < ssize( vSurfPatches) ; ++ i) {
Color myCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
for ( int j = 0 ; j < ssize( vSurfPatches[i].vCompoBorders) ; ++ j) {
VT.emplace_back( vSurfPatches[i].vCompoBorders[j].Clone()) ;
VC.emplace_back( myCol) ;
set<double>& setPar = vSurfPatches[i].vSetPatchPar[j] ;
for ( auto Iter = setPar.begin() ; Iter != setPar.end() ; ++ Iter) {
Point3d ptCurr ;
vSurfPatches[i].vCompoBorders[j].GetPointD1D2( *Iter, ICurve::FROM_MINUS, ptCurr) ;
PtrOwner<IGeoPoint3d> ptGeoCurr( CreateGeoPoint3d()) ; ptGeoCurr->Set( ptCurr) ;
VT.emplace_back( ptGeoCurr->Clone()) ;
VC.emplace_back( ORANGE) ;
}
}
}
SaveGeoObj( VT, VC, "C:\\Temp\\SurfPatches.nge") ;
#endif
// Se necessario, Splitto le Patch per far combiaciare gli estremi
vector<BOOLVECTOR> matBorderModif( vSurfPatches.size()) ;
for ( int i = 0 ; i < ssize( vSurfPatches) ; ++ i) {
// Recupero la SurfPatch corrente
SurfPatches& CurrSurfPatch = vSurfPatches[i] ;
// Recupero i Suoi Bordi e i Parametri associati
const SimpleBorderVector& vSimpleBorder = CurrSurfPatch.vBorderPatches ;
matBorderModif[i].resize( vSimpleBorder.size(), false) ;
const COMPOVECTOR& vCompoBorders = CurrSurfPatch.vCompoBorders ;
vector<set<double>>& vSetSplitPar = CurrSurfPatch.vSetPatchPar ;
// Scorro i Bordi della Superficie
for ( int nCurrBorder = 0 ; nCurrBorder < ssize( vSimpleBorder) ; ++ nCurrBorder) {
// Recupero la Composita associata al Bordo Corrente e il suo Box
const CurveComposite& CurrCompoBorder = vCompoBorders[nCurrBorder] ;
BBox3d BBoxCurrCompoBorder ; CurrCompoBorder.GetLocalBBox( BBoxCurrCompoBorder) ;
// Recupero le Patch associate
const SimpleBorder& vPatchCurrBorder = vSimpleBorder[nCurrBorder] ;
// Recupero il vettore dei Parametri di Split
set<double>& setSplitPar = vSetSplitPar[nCurrBorder] ;
#if DEBUG_SURF_PATCHES
VC.clear() ; VT.clear() ;
VT.emplace_back( CurrCompoBorder.Clone()) ;
VC.emplace_back( RED) ;
for ( auto Iter = setSplitPar.begin() ; Iter != setSplitPar.end() ; ++ Iter) {
Point3d ptCurr ;
CurrCompoBorder.GetPointD1D2( *Iter, ICurve::FROM_MINUS, ptCurr) ;
PtrOwner<IGeoPoint3d> ptGeoCurr( CreateGeoPoint3d()) ; ptGeoCurr->Set( ptCurr) ;
VT.emplace_back( ptGeoCurr->Clone()) ;
VC.emplace_back( ORANGE) ;
}
#endif
// Scorro le altre SurfPatches
for ( int j = 0 ; j < ssize( vSurfPatches) ; ++ j) {
// Se stessa SurfPath, passo alla successiva
if ( i == j)
continue ;
// Recupero l'altra SurfPatch
SurfPatches& OtherSurfPatch = vSurfPatches[j] ;
// Recupero i Suoi Bordi e i Parametri associati
const SimpleBorderVector& vSimpleOtherBorder = OtherSurfPatch.vBorderPatches ;
#if DEBUG_SURF_PATCHES
const COMPOVECTOR& vCompoBorders = OtherSurfPatch.vCompoBorders ;
#endif
// Scorro i suoi bordi
for ( int nOtherBorder = 0 ; nOtherBorder < ssize( vSimpleOtherBorder) ; ++ nOtherBorder) {
// Recupero le Patch associate
const SimpleBorder& vPatchOtherBorder = vSimpleOtherBorder[nOtherBorder] ;
// Recupero la Composita associata al Bordo
#if DEBUG_SURF_PATCHES
const CurveComposite& OtherCompoBorder = vCompoBorders[nOtherBorder] ;
VT.emplace_back( OtherCompoBorder.Clone()) ;
VC.emplace_back( BLACK) ;
#endif
// Scorro le sue Patches
for ( int nOtherPatch = 0 ; nOtherPatch < ssize( vPatchOtherBorder) ; ++ nOtherPatch) {
// Recupero il Box della patch
BBox3d BBoxOtherPath = OtherSurfPatch.matBox3dPatches[nOtherBorder][nOtherPatch] ;
// Se Tali Box ( espansi già della tolleranza lineare) non interferiscono, allora passo
// alla Patch successiva
if ( ! BBoxCurrCompoBorder.Overlaps( BBoxOtherPath))
continue ;
// Recupero gli estremi della Path attuale
DistPointCurve DPTCRV( vPatchOtherBorder[nOtherPatch].ptStart, CurrCompoBorder) ;
double dDist = INFINITO ;
if ( DPTCRV.GetDist( dDist) && dDist < dLinTol) {
Point3d ptMinDist ;
int nFlag = 0 ;
if ( DPTCRV.GetMinDistPoint( 0., ptMinDist, nFlag)) {
bool bInsert = true ;
for ( int nCurrPatch = 0 ; bInsert && nCurrPatch < ssize( vPatchCurrBorder) ; ++ nCurrPatch) {
const SimplePatch& Patch = vPatchCurrBorder[nCurrPatch] ;
bInsert = ( ! AreSamePointEpsilon( Patch.ptStart, ptMinDist, dLinTol) &&
! AreSamePointEpsilon( Patch.ptEnd, ptMinDist, dLinTol)) ;
}
if ( bInsert) {
double dPar = -1. ;
if ( DPTCRV.GetParamAtMinDistPoint( 0., dPar, nFlag)) {
setSplitPar.insert( dPar) ;
matBorderModif[i][nCurrBorder] = true ;
#if DEBUG_SURF_PATCHES
PtrOwner<IGeoPoint3d> ptGeoCurr( CreateGeoPoint3d()) ;
ptGeoCurr->Set( ptMinDist) ;
VT.emplace_back( ptGeoCurr->Clone()) ;
VC.emplace_back( AQUA) ;
#endif
}
}
}
}
}
}
}
}
#if DEBUG_SURF_PATCHES
SaveGeoObj( VT, VC, "C:\\Temp\\SplitPathces.nge") ;
#endif
}
// Scorro tutte le Surf Patches
for ( int i = 0 ; i < ssize( vSurfPatches) ; ++ i) {
// Recupero la SurfPatch corrente
SurfPatches& CurrSurfPatch = vSurfPatches[i] ;
// Recupero i Suoi Bordi e i Parametri associati
SimpleBorderVector& vSimpleBorder = CurrSurfPatch.vBorderPatches ;
COMPOMATRIX& matCompoPatches = CurrSurfPatch.matCompoPatches ;
COMPOVECTOR& vCompoBorders = CurrSurfPatch.vCompoBorders ;
const vector<set<double>>& vSetSplitPar = CurrSurfPatch.vSetPatchPar ;
// Scorro i Bordi
for ( int nCurrBorder = 0 ; nCurrBorder < ssize( vSimpleBorder) ; ++ nCurrBorder) {
// Se il bordo corrente non ha subito Split, passo al successivo
if ( ! matBorderModif[i][nCurrBorder])
continue ;
// Pulisco la Composita associata a tale Bordo
COMPOVECTOR& vCompoPatches = matCompoPatches[nCurrBorder] ;
vCompoPatches.clear() ;
// Recupero la Curva Composita corrente
CurveComposite& CurrCompo = vCompoBorders[nCurrBorder] ;
// Inizializzo il nuovo Bordo semplice formato dalle Patch
SimpleBorder newSimpleBorder ;
// Recupero il vettore dei Parametri di Split
const set<double>& setSplitPar = vSetSplitPar[nCurrBorder] ;
double dLastPar = 0 ;
for ( auto Iter = setSplitPar.begin() ; Iter != setSplitPar.end() ; ++ Iter) {
PtrOwner<ICurve> pCrvPatch( CurrCompo.CopyParamRange( dLastPar, *Iter)) ;
if ( ! IsNull( pCrvPatch) && pCrvPatch->IsValid()) {
PtrOwner<CurveComposite> pCompoPatch( ConvertCurveToBasicComposite( Release( pCrvPatch))) ;
if ( IsNull( pCompoPatch) || ! pCompoPatch->IsValid())
return false ;
vCompoPatches.emplace_back( *Get( pCompoPatch)) ;
Point3d ptStart ; vCompoPatches.back().GetStartPoint( ptStart) ;
Point3d ptEnd ; vCompoPatches.back().GetEndPoint( ptEnd) ;
newSimpleBorder.emplace_back( ptStart, ptEnd, nCurrBorder, false) ;
dLastPar = *Iter ;
}
}
vSimpleBorder[nCurrBorder] = newSimpleBorder ;
}
}
#if DEBUG_SURF_PATCHES
VT.clear() ; VC.clear() ;
for ( int i = 0 ; i < ssize( vSurfPatches) ; ++ i) {
Color myCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
for ( int j = 0 ; j < ssize( vSurfPatches[i].matCompoPatches) ; ++ j) {
for ( int k = 0 ; k < ssize( vSurfPatches[i].matCompoPatches[j]) ; ++ k) {
VT.emplace_back( vSurfPatches[i].matCompoPatches[j][k].Clone()) ;
VC.emplace_back( myCol) ;
IGeoPoint3d* _pt = CreateGeoPoint3d() ; _pt->Set( vSurfPatches[i].vBorderPatches[j][k].ptStart) ;
VT.emplace_back( _pt) ;
VC.emplace_back( AQUA) ;
IGeoPoint3d* _pt1 = CreateGeoPoint3d() ; _pt1->Set( vSurfPatches[i].vBorderPatches[j][k].ptEnd) ;
VT.emplace_back( _pt1) ;
VC.emplace_back( AQUA) ;
}
}
}
SaveGeoObj( VT, VC, "C:\\Temp\\SplitPatch.nge") ;
#endif
// Verifico ora se le Normali nei Tratti di giunzione tra Patches sono al di sotto
// della tolleranza angolare
INTVECTOR vSurfToCheck ;
INTSET setSurf ;
for ( int i = 0 ; i < ssize( vSurf) ; ++ 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 Surf Patch Corrente
SurfPatches& currSurfPatch = vSurfPatches[nSurf] ;
// Recupero la Superficie corrente
const ISurf* pCurrSurf = currSurfPatch.pSurf ;
// Recupero il Box Corrente della Superficie
const BBox3d& BBoxCurrSurf = currSurfPatch.BoxSurf ;
// Scorro i suoi Bordi semplici
for ( int nCurrBorder = 0 ; nCurrBorder < ssize( currSurfPatch.vBorderPatches) ; ++ nCurrBorder) {
// Recupero il Bordo Corrente
SimpleBorder& CurrSimpleBorder = currSurfPatch.vBorderPatches[nCurrBorder] ;
// Scorro le sua Patches
for ( int nCurrPatch = 0 ; nCurrPatch < ssize( CurrSimpleBorder) ; ++ nCurrPatch) {
// Recupero la Patch attuale
SimplePatch& currPatch = CurrSimpleBorder[nCurrPatch] ;
// Se Patch già analizzata, passo alla successiva
if ( currPatch.bErase)
continue ;
currPatch.bErase = true ;
// Scorro le altre Superfici
for ( int nOtherSurf = 0 ; nOtherSurf < ssize( vSurfPatches) ; ++ 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 Surf Patch
SurfPatches OtherSurfPatch = vSurfPatches[nOtherSurf] ;
// Recupero la Superficie
const ISurf* pOtherSurf = OtherSurfPatch.pSurf ;
// Recupero il Box della Superficie
const BBox3d& BBoxOtherSurf = OtherSurfPatch.BoxSurf ;
// Se non c'è Intersezione dei Box ( opportunamente estesi), passo alla SurfPatch successiva
if ( ! BBoxCurrSurf.Overlaps( BBoxOtherSurf))
continue ;
// Scorro i suoi Bordi semplici
for ( int nOtherBorder = 0 ; nOtherBorder < ssize( OtherSurfPatch.vBorderPatches) ; ++ nOtherBorder) {
// Recupero il Bordo
SimpleBorder& OtherSimpleBorder = OtherSurfPatch.vBorderPatches[nOtherBorder] ;
// Scorro le sue Patches
for ( int nOtherPatch = 0 ; nOtherPatch < ssize( OtherSimpleBorder) ; ++ nOtherPatch) {
// Recupero la Patch di confronto
SimplePatch& OtherPatch = OtherSimpleBorder[nOtherPatch] ;
// Se Patch già analizzata, passo alla successiva
if ( OtherPatch.bErase)
continue ;
// Se gli estremi coincidono
if ( ( AreSamePointEpsilon( currPatch.ptStart, OtherPatch.ptStart, dLinTol) &&
AreSamePointEpsilon( currPatch.ptEnd, OtherPatch.ptEnd, dLinTol)) ||
( AreSamePointEpsilon( currPatch.ptStart, OtherPatch.ptEnd, dLinTol) &&
AreSamePointEpsilon( currPatch.ptEnd, OtherPatch.ptStart, dLinTol))) {
// Controllo se le tangenze rimangono nella tolleranza
bool bTangent = true ;
// Campiono la Patch corrente ( passando per la Composita associata)
const int MAX_POINTS = 5 ;
BIPNTVECTOR vPtAPtB ; vPtAPtB.reserve( MAX_POINTS + 1) ;
CurveComposite& currCompoPatch = currSurfPatch.matCompoPatches[nCurrBorder][nCurrPatch] ;
CurveComposite& otherCompoPatch = OtherSurfPatch.matCompoPatches[nOtherBorder][nOtherPatch] ;
bTangent = ( currCompoPatch.IsValid() && otherCompoPatch.IsValid()) ;
if ( bTangent) {
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 ;
if ( ! DistPointCurve( ptCurr, otherCompoPatch).GetMinDistPoint( 0., ptOther, nFlag))
bTangent = false ;
// 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) {
#if DEBUG_SURF_PATCHES
VC.clear() ; VT.clear() ;
VT.emplace_back( pCurrSurf->Clone()) ;
VC.emplace_back( LIME) ;
VT.emplace_back( pOtherSurf->Clone()) ;
VC.emplace_back( GREEN) ;
VT.emplace_back( currCompoPatch.Clone()) ;
VC.emplace_back( RED) ;
VT.emplace_back( otherCompoPatch.Clone()) ;
VC.emplace_back( BLUE) ;
SaveGeoObj( VT, VC, "C:\\Temp\\Test.nge") ;
#endif
vSurfToCheck.emplace_back( nOtherSurf) ;
OtherPatch.bErase = true ;
if ( nOtherSurf >= ssize( vSurf) &&
find( vIndOtherSurf.begin(), vIndOtherSurf.end(), nOtherSurf - ssize( vSurf)) == vIndOtherSurf.end())
vIndOtherSurf.push_back( nOtherSurf - ssize( vSurf)) ;
}
}
}
}
}
}
}
}
#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 l'estrazione dei Bordi di Fori e Asole dato un vettore di Superfici
bool
GetTrimmingHoleBorders( const CISURFPVECTOR& vpSurf, const Point3d& ptRef, double dSurfLinTol, double dSurfAngTol,
double dEdgeLinTol, double dEdgeAngTol, double dEdgeThick,
ICRVCOMPOPOVECTOR& vHoleBorders)
{
vHoleBorders.clear() ;
// Se non ho superfici, non faccio nulla
if ( vpSurf.empty())
return true ;
// Verifico che tutte le superfici siano valide
for ( const ISurf* pSurf : vpSurf) {
if ( pSurf == nullptr || ! pSurf->IsValid())
return false ;
}
#if DEBUG_HOLES
VT.clear() ; VC.clear() ;
for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
VT.emplace_back( vpSurf[i]->Clone()) ;
VC.emplace_back( Color( 0., 0., 0., 0.25)) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\HoleBorders.nge") ;
#endif
// Aggiusto le tolleranze
double dMySurfLinTol = Clamp( dSurfLinTol, EPS_SMALL, 1e5) ;
double dMySurfAngTol = Clamp( dSurfAngTol, EPS_ANG_SMALL, 60.) ;
double dMyEdgeLinTol = Clamp( dEdgeLinTol, EPS_SMALL, 1e5) ;
double dMyEdgeAngTol = Clamp( dEdgeAngTol, EPS_ANG_SMALL, 60.) ;
double dMyEdgeThick = max( 10. * EPS_SMALL, dEdgeThick) ; // coerente con Offset
// Dalle superfici ricavo i bordi Grezzi
SELVECTOR vSelIds ; vSelIds.resize( vpSurf.size()) ;
for ( int i = 0 ; i < ssize( vpSurf) ; ++ i)
vSelIds.emplace_back( SelData( i, SEL_SUB_ALL)) ;
ICRVCOMPOPOVECTOR vRawEdges ;
if ( ! GetTrimmingRawEdges( vpSurf, vSelIds, dMySurfLinTol, dMySurfAngTol, vRawEdges))
return false ;
if ( vRawEdges.empty())
return true ;
#if DEBUG_HOLES
for ( int i = 0 ; i < ssize( vRawEdges) ; ++ i) {
VT.emplace_back( CloneCurveComposite( vRawEdges[i])) ;
VC.emplace_back( RED) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\HoleBorders.nge") ;
#endif
// Tra le curve ricavate, tengo in considerazione solo Fori e Asole
enum HoleType { CIRCLE = 0, BUTTONHOLE = 1 } ;
struct Hole {
PtrOwner<ICurveComposite> pCompoHole ;
int nType ;
Frame3d frCompo ;
double dRad ;
double dLen ;
Hole( ICurveComposite* pHole, int nT, const Frame3d& frC, double dR, double dL)
: nType( nT), frCompo( frC), dRad( dR), dLen( dL) {
pCompoHole.Set( pHole) ;
}
} ;
vector<Hole> vHoles ; vHoles.reserve( vRawEdges.size()) ;
for ( int i = 0 ; i < ssize( vRawEdges) ; ++ i) {
// Verifico che la curva sia valida
if ( IsNull( vRawEdges[i]) || ! vRawEdges[i]->IsValid())
continue ;
// Recupero la PolyLine associata
PolyLine PL ;
if ( ! vRawEdges[i]->ApproxWithLines( EPS_SMALL, EPS_ANG_SMALL, ICurve::APL_SPECIAL, PL))
return false ;
// Verifico che -- CIRCONFERENZA --
Frame3d frCompo ;
double dRad = 0. ;
CurveArc CrvCircle ;
if ( IsBorderACircle( PL, dMyEdgeLinTol, dMyEdgeAngTol, frCompo, dRad, CrvCircle)) {
PtrOwner<ICurveComposite> pCompoCircle( CreateCurveComposite()) ;
if ( IsNull( pCompoCircle) || ! pCompoCircle->AddCurve( CrvCircle))
return false ;
vHoles.emplace_back( Release( pCompoCircle), 0, frCompo, dRad, -1.) ;
continue ;
}
// Verifico se -- ASOLA --
double dLen = 0. ;
CurveComposite CompoBtHole ;
if ( IsBorderAButtonHole( PL, dMyEdgeLinTol, dMyEdgeAngTol, frCompo, dLen, dRad, CompoBtHole)) {
PtrOwner<ICurveComposite> pCompoBtHole( CreateCurveComposite()) ;
if ( IsNull( pCompoBtHole) || ! pCompoBtHole->AddCurve( CompoBtHole))
return false ;
vHoles.emplace_back( Release( pCompoBtHole), HoleType::BUTTONHOLE, frCompo, dRad, dLen) ;
continue ;
}
}
// Vedo se ci sono curve da accoppiare tra di loro
vHoleBorders.reserve( vHoles.size()) ;
for ( int i = 0 ; i < ssize( vHoles) - 1 ; ++ i) {
// Recupero la curva corrente, se non presente allora passo alla successiva
if ( IsNull( vHoles[i].pCompoHole))
continue ;
int nIndJ = -1 ;
// Scorro le curve successive
for ( int j = i + 1 ; nIndJ == -1 && j < ssize( vHoles) ; ++ j) {
// Recupero la curva corrente, se non presente allora passo alla successiva
if ( IsNull( vHoles[j].pCompoHole))
continue ;
// Se il tipo è differente non possono essere in coppia
if ( vHoles[i].nType != vHoles[j].nType)
continue ;
// Essendo della stessa topologia, verifico i parametri
bool bCouple = false ;
Vector3d vtCenCen ;
if ( vHoles[i].nType == HoleType::CIRCLE) {
bCouple = ( abs( vHoles[i].dRad - vHoles[j].dRad) < dMyEdgeLinTol &&
AreSameOrOppositeVectorEpsilon( vHoles[i].frCompo.VersZ(), vHoles[j].frCompo.VersZ(), dMyEdgeLinTol)) ;
if ( bCouple) {
vtCenCen = ( vHoles[i].frCompo.Orig() - vHoles[j].frCompo.Orig()) ;
bCouple = ( vtCenCen.SqLen() > dMyEdgeLinTol * dMyEdgeLinTol) ;
if ( bCouple) {
bCouple = ( vtCenCen.Normalize() &&
AreSameOrOppositeVectorEpsilon( vtCenCen, vHoles[i].frCompo.VersZ(), dMyEdgeLinTol)) ;
}
}
}
else if ( vHoles[i].nType == HoleType::BUTTONHOLE) {
bCouple = ( abs( vHoles[i].dRad - vHoles[j].dRad) < dMyEdgeLinTol &&
abs( vHoles[i].dLen - vHoles[j].dLen) < dMyEdgeLinTol &&
AreSameOrOppositeVectorEpsilon( vHoles[i].frCompo.VersZ(), vHoles[j].frCompo.VersZ(), dMyEdgeLinTol)) ;
if ( bCouple) {
vtCenCen = ( vHoles[i].frCompo.Orig() - vHoles[j].frCompo.Orig()) ;
bCouple = ( vtCenCen.SqLen() > dMyEdgeLinTol * dMyEdgeLinTol) ;
if ( bCouple) {
bCouple = ( vtCenCen.Normalize() &&
AreSameOrOppositeVectorEpsilon( vtCenCen, vHoles[i].frCompo.VersZ(), dMyEdgeLinTol)) ;
}
}
}
if ( bCouple)
nIndJ = j ;
}
// Determino l'indice della curva da conservare
int nInd = i ;
// Se curva non in coppia, allora ho finito, altrimenti devo sceglierne una
if ( nIndJ != -1) {
int nIndToErase = nIndJ ;
// Recupero i due Box
BBox3d BBoxI ; vHoles[i].pCompoHole->GetLocalBBox( BBoxI) ;
BBox3d BBoxJ ; vHoles[nIndJ].pCompoHole->GetLocalBBox( BBoxJ) ;
// Recupero le Coordinate massime di ZGlob
double dZI = BBoxI.GetMax().z ;
double dZJ = BBoxJ.GetMax().z ;
// Se le 2 curve hanno ZGlob massime differente tra loro
if ( abs( dZI - dZJ) > 5. * EPS_SMALL) {
// Tengo la Curva con ZGlob massima
if ( dZJ > dZI)
swap( nInd, nIndToErase) ;
}
// Se invece le ZGlob sono circa uguali
else {
// Tengo la Curva più distante dal punto di Riferimento ( se Valido)
if ( ptRef.IsValid()) {
double dSqDistI = INFINITO, dSqDistJ = INFINITO ;
DistPointCurve( ptRef, *vHoles[i].pCompoHole).GetSqDist( dSqDistI) ;
DistPointCurve( ptRef, *vHoles[nIndJ].pCompoHole).GetSqDist( dSqDistJ) ;
if ( dSqDistJ > dSqDistI)
swap( nInd, nIndToErase) ;
}
}
// Elimino la curva non significativa delle 2
vHoles[nIndToErase].pCompoHole.Reset() ;
}
// Imposto Estrusione alla curva nInd-esima
Vector3d vtExtr = vHoles[nInd].frCompo.VersZ() ;
// Se Estrusione perpendicolare a Z_AX
if ( OrthoCompo( Z_AX, vtExtr).Len() > 1 - 5. * EPS_SMALL) {
// Se punto di Riferimento valido
if ( ptRef.IsValid()) {
Vector3d vtCenCen = vHoles[nInd].frCompo.Orig() - ptRef ;
vtCenCen.Normalize() ;
vHoles[nInd].pCompoHole->SetExtrusion( ( vtExtr * vtCenCen > 0.) ? vtExtr : - vtExtr) ;
}
else
vHoles[nInd].pCompoHole->SetExtrusion( vtExtr) ;
}
// Se estrusione non perpendicolare a Z_AX
else
vHoles[nInd].pCompoHole->SetExtrusion( ( vtExtr * Z_AX > 0.) ? vtExtr : - vtExtr) ;
// Imposso Spessore alla curva nInd-esima
vHoles[nInd].pCompoHole->SetThickness( - dMyEdgeThick) ;
// Memorizzo la curva nInd-esima
vHoleBorders.emplace_back( Release( vHoles[nInd].pCompoHole)) ;
}
return true ;
}
struct PntInfo{
Point3d pt ;
double dDist ;
Vector3d vtPos ;
PntInfo( const Point3d& _pt, double _dDist, const Vector3d& _vtPos) :
pt( _pt), dDist( _dDist), vtPos( _vtPos) {;}
};
typedef vector<PntInfo> PNTINFOVECTOR ;
//------------------------------------------------------------------------------
static bool
FillPntInfo( const PNTVECTOR& vPnt, const ICurveComposite* pCC, PNTINFOVECTOR& vPntInfo)
{
for ( int i = 0 ; i < ssize( vPnt) - 3 ; i+=3) {
bool bOk = false ;
const ICurveBezier* pSubCrv = GetCurveBezier( pCC->GetCurve( i / 3)) ;
for ( int j = i == 0 ? 0 : 1 ; j <= 3 ; ++j) {
Point3d pt = pSubCrv->GetControlPoint( j, &bOk) ;
double dDist = 0 ;
Vector3d vtPos = V_NULL ;
if ( j > 0 && j < 3){
DistPointCurve dpc( pt, *pSubCrv) ;
dpc.GetDist( dDist) ;
int nFlag = - 1 ;
Point3d ptMinDist ;
dpc.GetMinDistPoint( 0., ptMinDist, nFlag) ;
vtPos = pt - ptMinDist ;
}
vPntInfo.emplace_back( pt, dDist, vtPos) ;
}
}
return true ;
}
//------------------------------------------------------------------------------
static bool
RemoveInflexionPoints( PNTVECTOR& vPnt, PNTINFOVECTOR& vPntInfo, PNTINFOVECTOR& vPntRefInfo)
{
// se trovo tre punti di fila che sono dallo stesso lato, opposto a quello degli altri punti attorno, allora cerco di spostarli lungo la
// normale alla superficie in modo da evitare cambi di concavità
bool bSameSideAsPrev = true ;
double dSmallDist = 5 * EPS_SMALL ;
for ( int i = 2 ; i < ssize( vPntInfo) - 2 ; ++i) {
// se è un punto di split o sta sulla curva vado avanti
if ( vPntInfo[i].dDist < dSmallDist)
continue ;
int nPrev = vPntInfo[i-1].dDist < EPS_ZERO ? i - 2 : i - 1 ;
double dProj = vPntInfo[i].vtPos * vPntInfo[nPrev].vtPos ;
bSameSideAsPrev = dProj > EPS_ZERO ;
if ( abs(dProj) < EPS_ZERO){
int nPrevPrev = nPrev - 1 ;
dProj = vPntInfo[i].vtPos * vPntInfo[nPrevPrev].vtPos ;
bSameSideAsPrev = dProj > EPS_ZERO ;
}
if ( ! bSameSideAsPrev) {
// devo verificare anche che sia diverso anche dal successivo ( o dal quello dopo ancora, se il successivo sta sulla curva)
bool bCurrOrPrev = vPntInfo[i+1].dDist < EPS_ZERO ;
int nFirst, nSecond, nThird ;
if ( bCurrOrPrev) {
nFirst = i ;
nSecond = i + 1 ;
nThird = i + 2 ;
}
else {
nFirst = i - 2 ;
nSecond = i - 1 ;
nThird = i ;
}
int nNext = bCurrOrPrev ? i + 2 : i + 1 ;
// se il successivo è diverso ho un terzetto anomalo da aggiustare
// altrimenti ho un cambio naturale di concavità
if ( vPntInfo[i].vtPos * vPntInfo[nNext].vtPos < 0 || vPntInfo[nNext].dDist < dSmallDist) {
// ruoto il terzetto fino a matchare la tangente sull'altra curva
// ruoto il punto solo se non stava già esattamente sulla SubCrv ( che suppongo essere un tratto rettilineo)
if ( vPntInfo[nFirst].dDist > dSmallDist) {
Vector3d vtCurr = vPntInfo[nSecond].pt - vPntInfo[nFirst].pt ;
Vector3d vtRef = vPntRefInfo[nSecond].pt - vPntRefInfo[nFirst].pt ;
Vector3d vtAx = vPntRefInfo[nSecond].pt - vPntInfo[nSecond].pt ;
bool bDet = false ;
double dAng = 0 ; vtCurr.GetRotation(vtRef, vtAx, dAng, bDet) ;
if ( abs(dAng) > 170)
dAng = 180 - dAng ;
vPnt[nFirst].Rotate( vPnt[nSecond], vtAx, dAng) ;
}
if ( vPntInfo[nThird].dDist > dSmallDist) {
Vector3d vtCurr = vPntInfo[nThird].pt - vPntInfo[nSecond].pt ;
Vector3d vtRef = vPntRefInfo[nThird].pt - vPntRefInfo[nSecond].pt ;
Vector3d vtAx = vPntRefInfo[nSecond].pt - vPntInfo[nSecond].pt ;
bool bDet = false ;
double dAng = 0 ; vtCurr.GetRotation(vtRef, vtAx, dAng, bDet) ;
if ( abs(dAng) > 170)
dAng = 180 - dAng ;
vPnt[nThird].Rotate( vPnt[nSecond], vtAx, dAng) ;
}
if ( bCurrOrPrev)
i += 2 ;
}
}
}
return true ;
}
// Funzione per la regolarizzazione delle curve di bordo di una lavorazione di trim
// Le curve vengono modificate entro una data tolleranza, in modo che
ISurfBezier*
RegolarizeBordersLocallyRMF( const ISurfBezier* pSurfBz, const BIPOINT& bpIsoStart, const BIPOINT& bpIsoEnd, double dTol)
{
#if DEBUG_SMOOTH_CURVATURE
VT.clear() ;
#endif
// prendo per buone le isocurve di inizio e fine tratto e devo identificare tra loro le isocurve che creano troppo twist e che sono da raddrizzare
Point3d ptS1 = bpIsoStart.first ;
Point3d ptS2 = bpIsoEnd.first ;
Vector3d vtDir1 = bpIsoStart.second - ptS1 ;
Vector3d vtDir2 = bpIsoEnd.second - ptS2 ;
double dInterpolateAngTol = 4 ;
double dAngInterp = 0 ;
vtDir1.GetAngle( vtDir2, dAngInterp) ;
bool bInterpolate = dAngInterp > dInterpolateAngTol ;
int nDegU, nDegV, nSpanU, nSpanV ;
bool bRat, bTrimmed ;
pSurfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
if ( nDegU != 3)
return nullptr ;
// individuo quali isocurve sono state indicate come inizio e fine
PtrOwner<ICurveComposite> pCrv1( pSurfBz->GetSingleEdge3D( false, 2)) ;
PtrOwner<ICurveComposite> pCrv2( pSurfBz->GetSingleEdge3D( false, 0)) ;
// inverto la curva corrispondente al bordo 2 della bezier per avere le due guide concordi
pCrv2->Invert() ;
double dParS1 = -1 ; double dParS2 = -1 ;
if ( ! pCrv1->GetParamAtPoint( ptS1, dParS1) || ! pCrv1->GetParamAtPoint( ptS2, dParS2))
return nullptr ;
int nUS1 = int ( dParS1) * nDegU ;
int nUS2 = int ( dParS2) * nDegU ;
bool bInverted = false ;
if ( nUS1 > nUS2) {
swap( nUS1, nUS2) ;
swap( dParS1, dParS2) ;
swap( ptS1, ptS2) ;
swap( vtDir1, vtDir2) ;
bInverted = true ;
}
PtrOwner<ICurveComposite> pCrvOrig1( ConvertCurveToComposite( pCrv1->CopyParamRange( dParS1, dParS2))) ;
PtrOwner<ICurveComposite> pCrvOrig2( ConvertCurveToComposite( pCrv2->CopyParamRange( dParS1, dParS2))) ;
/////////////////////// versione con RMF
// campiono finemente la prima curva e ottengo il punto che dovrebbe stare sull'altra curva
Vector3d vtTang1 ; pCrvOrig1->GetStartDir( vtTang1) ;
Frame3d frStart1 ; frStart1.Set( ptS1, vtTang1, vtDir1) ; // uso la tangente (come z) e l'isocurva in V (come x) per il frame iniziale
RotationMinimizingFrame rmf ; rmf.Set( pCrvOrig1, frStart1) ;
double dLenTot = 0. ; pCrvOrig1->GetLength( dLenTot) ;
double dStep = dLenTot / ceil( dLenTot) ;
FRAME3DVECTOR vRMF ;
rmf.GetFramesByStep( dStep, true, vRMF) ;
PNTVECTOR vPnt1 ;
PolyLine PL2 ;
double dLenCurr = 0. ;
double dWidth = vtDir1.Len() ;
for ( int i = 0 ; i < ssize( vRMF) ; ++i) {
double dPar ; pCrvOrig1->GetParamAtLength( dLenCurr, dPar) ;
Point3d pt0 ; pCrvOrig1->GetPointD1D2( dPar, ICurve::FROM_MINUS, pt0) ;
Point3d pt1 = pt0 + vRMF[i].VersX() * dWidth ;
vPnt1.push_back( pt1) ;
PL2.AddUPoint( i, pt1) ;
dLenCurr += dStep ;
}
CurveComposite CCToApprox2 ; CCToApprox2.FromPolyLine( PL2) ;
Vector3d vtStart2 ; pCrvOrig2->GetStartDir( vtStart2) ;
Vector3d vtEnd2 ; pCrvOrig2->GetEndDir( vtEnd2) ;
PtrOwner<ICurveComposite> pCC2( ConvertCurveToComposite( ApproxCurveWithBezier( &CCToApprox2, 0.05, vtStart2, vtEnd2))) ;
if ( IsNull( pCC2) || ! pCC2->IsValid())
return nullptr ;
// dalla seconda ricostruisco la prima
Vector3d vtTang2 ; pCC2->GetStartDir( vtTang2) ;
Frame3d frStart2 ; frStart2.Set( bpIsoStart.second, vtTang2, vtDir1) ; // uso la tangente (come z) e l'isocurva in V (come x) per il frame iniziale
RotationMinimizingFrame rmf2 ; rmf2.Set( pCC2, frStart2) ;
double dLenTot2 = 0. ; pCC2->GetLength( dLenTot2) ;
double dStep2 = dLenTot2 / ceil( dLenTot2) ;
FRAME3DVECTOR vRMF2 ;
rmf2.GetFramesByStep( dStep2, true, vRMF2) ;
PNTVECTOR vPnt0 ;
PolyLine PL1 ;
double dLenCurr2 = 0. ;
for ( int i = 0 ; i < ssize( vRMF2) ; ++i) {
double dPar ; pCC2->GetParamAtLength( dLenCurr2, dPar) ;
Point3d pt1 ; pCC2->GetPointD1D2( dPar, ICurve::FROM_MINUS, pt1) ;
Point3d pt0 = pt1 - vRMF2[i].VersX() * dWidth ;
vPnt0.push_back( pt0) ;
PL1.AddUPoint( i, pt0) ;
dLenCurr2 += dStep2 ;
}
CurveComposite CCToApprox1 ; CCToApprox1.FromPolyLine( PL1) ;
Vector3d vtStart1 ; pCrvOrig1->GetStartDir( vtStart1) ;
Vector3d vtEnd1 ; pCrvOrig1->GetEndDir( vtEnd1) ;
PtrOwner<ICurveComposite> pCC1( ConvertCurveToComposite( ApproxCurveWithBezier( &CCToApprox1, 0.05, vtStart1, vtEnd1))) ;
if ( IsNull( pCC1) || ! pCC1->IsValid())
return nullptr ;
#if DEBUG_SMOOTH_CURVATURE
for( int i = 0 ; i < ssize( vPnt1) ; ++i) {
PtrOwner<IGeoPoint3d> pPT( CreateGeoPoint3d()) ; pPT->Set( vPnt1[i]) ;
VT.push_back( Release( pPT)) ;
}
for( int i = 0 ; i < ssize( vPnt0) ; ++i) {
PtrOwner<IGeoPoint3d> pPT( CreateGeoPoint3d()) ; pPT->Set( vPnt0[i]) ;
VT.push_back( Release( pPT)) ;
}
VT.push_back( pCC1->Clone()) ;
VT.push_back( pCC2->Clone()) ;
SaveGeoObj( VT, "C:\\Temp\\bezier\\ruled\\smoothness\\regolarized_RMF.nge") ;
#endif
// controllo di essere rimasto in tolleranza
double dErr = 0 ;
CalcApproxError( pCrvOrig1, pCC1, dErr, 20) ;
if ( dErr > dTol)
return nullptr ;
dErr = 0 ;
CalcApproxError( pCrvOrig2, pCC2, dErr, 20) ;
if ( dErr > dTol)
return nullptr ;
// creo una surf di bezier uguale a quella di partenza, ma a cui cambio la parte da modificare
PtrOwner<SurfBezier> pNewSurf( CreateBasicSurfBezier()) ;
int nNewCrvs = pCC1->GetCurveCount() ;
if ( pCC2->GetCurveCount() != nNewCrvs)
return nullptr ;
int nDiff = nNewCrvs - pCrvOrig1->GetCurveCount() ;
int nSpanUNew = nSpanU + nDiff ;
pNewSurf->Init( nDegU, nDegV, nSpanU, nSpanV, bRat) ;
// copio la parte uguale
for ( int i = 0 ; i < nSpanU * nDegU + 1 ; ++i) {
if ( i > nUS1 && i < nUS2)
continue ;
bool bOk = false ;
Point3d pt = pSurfBz->GetControlPoint( i, 0, &bOk) ;
int nNewI = i ;
if ( i > nUS2)
nNewI = i + nDiff ;
pNewSurf->SetControlPoint( nNewI, 0, pt) ;
pt = pSurfBz->GetControlPoint( i, 1, &bOk) ;
pNewSurf->SetControlPoint( nNewI, 1, pt) ;
}
// aggiungo la parte diversa
for ( int i = 0 ; i < nNewCrvs * nDegU + 1 ; ++i) {
bool bOk = false ;
int nSub = i / 3 ;
int nPnt = i % 3 ;
if ( nSub == nNewCrvs) {
--nSub ;
nPnt = 3 ;
}
const ICurveBezier* pSubCrv1 = GetCurveBezier( pCC1->GetCurve( nSub)) ;
Point3d pt = pSubCrv1->GetControlPoint( nPnt) ;
int nNewI = i + nUS1 ;
pNewSurf->SetControlPoint( nNewI, 0, pt) ;
const ICurveBezier* pSubCrv2 = GetCurveBezier( pCC2->GetCurve( nSub)) ;
pt = pSubCrv2->GetControlPoint( nPnt) ;
pNewSurf->SetControlPoint( nNewI, 1, pt) ;
}
return Release( pNewSurf) ;
}
//------------------------------------------------------------------------------
// Funzione per la regolarizzazione delle curve di bordo di una lavorazione di trim
// Le curve vengono modificate entro una data tolleranza, in modo che
ISurfBezier*
RegolarizeBordersLocally( const ISurfBezier* pSurfBz, const BIPOINT& bpIsoStart, const BIPOINT& bpIsoEnd, double dTol, int nType)
{
if ( nType == RegolarizeType::RMF)
return RegolarizeBordersLocallyRMF( pSurfBz, bpIsoStart, bpIsoEnd, dTol) ;
#if DEBUG_SMOOTH_CURVATURE
VT.clear() ;
#endif
// prendo per buone le isocurve di inizio e fine tratto e devo identificare tra loro le isocurve che creano troppo twist e che sono da raddrizzare
Point3d ptS1 = bpIsoStart.first ;
Point3d ptS2 = bpIsoEnd.first ;
Vector3d vtDir1 = bpIsoStart.second - ptS1 ;
Vector3d vtDir2 = bpIsoEnd.second - ptS2 ;
int nDegU, nDegV, nSpanU, nSpanV ;
bool bRat, bTrimmed ;
pSurfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
if ( nDegU != 3)
return nullptr ;
// individuo quali isocurve sono state indicate come inizio e fine
PtrOwner<ICurveComposite> pCrv1( pSurfBz->GetSingleEdge3D( false, 2)) ;
PtrOwner<ICurveComposite> pCrv2( pSurfBz->GetSingleEdge3D( false, 0)) ;
// inverto la curva corrispondente al bordo 2 della bezier per avere le due guide concordi
pCrv2->Invert() ;
double dParS1 = -1 ; double dParS2 = -1 ;
if ( ! pCrv1->GetParamAtPoint( ptS1, dParS1) || ! pCrv1->GetParamAtPoint( ptS2, dParS2))
return nullptr ;
int nUS1 = int ( dParS1) * nDegU ;
int nUS2 = int ( dParS2) * nDegU ;
bool bInverted = false ;
if ( nUS1 > nUS2) {
swap( nUS1, nUS2) ;
swap( dParS1, dParS2) ;
swap( ptS1, ptS2) ;
swap( vtDir1, vtDir2) ;
bInverted = true ;
}
PtrOwner<ICurve> pCrvOrig1( pCrv1->CopyParamRange( dParS1, dParS2)) ;
PtrOwner<ICurve> pCrvOrig2( pCrv2->CopyParamRange( dParS1, dParS2)) ;
double dLen = 0 ; pCrvOrig1->GetLength( dLen) ;
///// versione con correzioni a mano
Point3d ptPrevS = ptS1 ;
Point3d ptPrevE = ! bInverted ? bpIsoStart.second : bpIsoEnd.second ;
Vector3d vtIsoPrev = ptPrevE - ptPrevS ; vtIsoPrev.Normalize() ;
Point3d ptBez ; Vector3d vtNCurr ;
pSurfBz->GetPointNrmD1D2( dParS1, 0.5, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBez, vtNCurr) ;
int nPoints = ( nUS2 - nUS1) * nDegU + 1 ;
PNTVECTOR vPnt0 ; vPnt0.reserve( nPoints) ; vPnt0.push_back( ptPrevS) ;
PNTVECTOR vPnt1 ; vPnt1.reserve( nPoints) ; vPnt1.push_back( ptPrevE) ;
// salvo il secondo punto di controllo della patch
bool bOk = false ;
Point3d ptSecond1Curr = pSurfBz->GetControlPoint( nUS1 + 1, 0, &bOk) ;
vPnt0.push_back( ptSecond1Curr) ;
Point3d ptSecond2Curr = pSurfBz->GetControlPoint( nUS1 + 1, 1, &bOk) ;
vPnt1.push_back( ptSecond2Curr) ;
// scorro le isocurve di separazione tra patch
for ( int i = nUS1 + 3 ; i < nUS2 ; i +=3) {
// recupero precedente e successivo
Point3d ptThird1Prev = pSurfBz->GetControlPoint( i - 1, 0, &bOk) ;
Point3d ptThird2Prev = pSurfBz->GetControlPoint( i - 1, 1, &bOk) ;
Point3d ptSecond1Next = pSurfBz->GetControlPoint( i + 1, 0, &bOk) ;
Point3d ptSecond2Next = pSurfBz->GetControlPoint( i + 1, 1, &bOk) ;
// recupero corrente e verifico la torsione
Point3d ptCurr1 = pSurfBz->GetControlPoint( i, 0, &bOk) ;
Point3d ptCurr2 = pSurfBz->GetControlPoint( i, 1, &bOk) ;
Vector3d vtIsoCurr = ptCurr2 - ptCurr1 ;
double dDist = vtIsoCurr.Len() ;
vtIsoCurr.Normalize() ;
//Vector3d vtDirPrev = vtIsoPrev ^ vtNPrev ;
Vector3d vtDirCurr = ptSecond1Next - ptCurr1 ; vtDirCurr.Normalize() ;
double dLenCurr = 0 ; pCrvOrig1->GetLengthAtParam( i, dLenCurr) ;
double dCoeff = dLenCurr / dLen ;
Vector3d vtIsoInterp = Media( vtDir1, vtDir2, dCoeff) ; vtIsoInterp.Normalize() ;
bool bDet = false ;
//double dAng = 0 ; vtIsoCurr.GetRotation( vtIsoPrev, vtDirPrev, dAng, bDet) ;
double dAng = 0 ; vtIsoCurr.GetRotation( vtIsoInterp, vtDirCurr, dAng, bDet) ;
vtNCurr = vtDirCurr ^ vtIsoCurr ; vtNCurr.Rotate( vtDirCurr, dAng) ;
double dSinAngTol = sin( 5 * DEGTORAD) ;
Vector3d vtPrev1 = ptCurr1 - ptThird1Prev ; vtPrev1.Normalize() ;
Vector3d vtNext1 = ptSecond1Next - ptCurr1 ; vtNext1.Normalize() ;
bool bAngularPoint1 = ! AreSameVectorEpsilon( vtPrev1, vtNext1, dSinAngTol) ;
Vector3d vtPrev2 = ptCurr2 - ptThird2Prev ; vtPrev2.Normalize() ;
Vector3d vtNext2 = ptSecond2Next - ptCurr2 ; vtNext2.Normalize() ;
bool bAngularPoint2 = ! AreSameVectorEpsilon( vtPrev2, vtNext2, dSinAngTol) ;
if ( abs( dAng) > 0) {
// se l'isocurva di separazione dalla patch successiva è torta rispetto alla precedente
// allora prendo il penultimo punto della curva precedente, il punto di joint e il secondo della prossima e li sposto lungo la normale della superficie
dDist *= dAng * DEGTORAD / 2 ;
if ( ! bAngularPoint1) {
// se non ho un punto angoloso muovo tutto il terzetto insieme
ptThird1Prev -= vtNCurr * dDist ;
ptSecond1Next -= vtNCurr * dDist ;
ptCurr1 -= vtNCurr * dDist ;
}
else {
// altrimenti sposto solo il punto corrente verso la congiungente tra il precedente e il successivo
DistPointLine dpl( ptCurr1, ptThird1Prev, ptSecond1Next, true) ;
Point3d ptMinDist ; dpl.GetMinDistPoint( ptMinDist) ;
Vector3d vtCorrDir = ptMinDist - ptCurr1 ; vtCorrDir.Normalize() ;
double dProjDir = vtNCurr * vtCorrDir ;
if ( dProjDir < 0)
LOG_ERROR( GetEGkLogger(), "Error : regolarizing crv0 near an angular point") ;
double dDistCorr = min( dDist, Dist( ptMinDist, ptCurr1)) ;
ptCurr1 -= vtCorrDir * dDistCorr ;
}
if ( ! bAngularPoint2) {
ptThird2Prev += vtNCurr * dDist ;
ptSecond2Next += vtNCurr * dDist ;
ptCurr2 += vtNCurr * dDist ;
}
else {
// altrimenti sposto solo il punto corrente verso la congiungente tra il precedente e il successivo
DistPointLine dpl( ptCurr2, ptThird2Prev, ptSecond2Next, true) ;
Point3d ptMinDist ; dpl.GetMinDistPoint( ptMinDist) ;
Vector3d vtCorrDir = ptMinDist - ptCurr2 ; vtCorrDir.Normalize() ;
double dProjDir = vtNCurr * vtCorrDir ;
if ( dProjDir < 0)
LOG_ERROR( GetEGkLogger(), "Error : regolarizing crv1 near an angular point") ;
double dDistCorr = min( dDist, Dist( ptMinDist, ptCurr2)) ;
ptCurr2 += vtCorrDir * dDistCorr ;
}
}
vPnt0.push_back( ptThird1Prev) ;
vPnt0.push_back( ptCurr1) ;
vPnt0.push_back( ptSecond1Next) ;
vPnt1.push_back( ptThird2Prev) ;
vPnt1.push_back( ptCurr2) ;
vPnt1.push_back( ptSecond2Next) ;
//vtIsoPrev = ptCurr2 - ptCurr1 ; vtIsoPrev.Normalize() ;
//vtNPrev = ( ptSecond1Next - ptCurr1) ^ vtIsoPrev ; vtNPrev.Normalize() ;
}
// aggiungo gli ultimi due punti
Point3d ptThird1Prev = pSurfBz->GetControlPoint( nUS2 - 1, 0, &bOk) ;
vPnt0.push_back( ptThird1Prev) ;
Point3d ptFourth1Curr = pSurfBz->GetControlPoint( nUS2, 0, &bOk) ;
vPnt0.push_back( ptFourth1Curr) ;
Point3d ptThird2Prev = pSurfBz->GetControlPoint( nUS2 - 1, 1, &bOk) ;
vPnt1.push_back( ptThird2Prev) ;
Point3d ptFourth2Curr = pSurfBz->GetControlPoint( nUS2, 1, &bOk) ;
vPnt1.push_back( ptFourth2Curr) ;
PtrOwner<ICurveComposite> pCC1( CreateCurveComposite()) ;
PtrOwner<ICurveComposite> pCC2( CreateCurveComposite()) ;
for ( int i = 0 ; i < ssize( vPnt0) - 3 ; i+=3) {
PtrOwner<ICurveBezier> cb1( CreateCurveBezier()) ; cb1->Init( 3, false) ;
cb1->SetControlPoint( 0, vPnt0[i]) ;
cb1->SetControlPoint( 1, vPnt0[i+1]) ;
cb1->SetControlPoint( 2, vPnt0[i+2]) ;
cb1->SetControlPoint( 3, vPnt0[i+3]) ;
pCC1->AddCurve( Release( cb1)) ;
PtrOwner<ICurveBezier> cb2( CreateCurveBezier()) ; cb2->Init( 3, false) ;
cb2->SetControlPoint( 0, vPnt1[i]) ;
cb2->SetControlPoint( 1, vPnt1[i+1]) ;
cb2->SetControlPoint( 2, vPnt1[i+2]) ;
cb2->SetControlPoint( 3, vPnt1[i+3]) ;
pCC2->AddCurve( Release( cb2)) ;
}
////// N.B.:dovrei tener conto anche della patch PRECEDENTE e SUCCESSIVA a quelle indicate, altrimenti non vedo se ho creato flessi al bordo della zona
#if DEBUG_SMOOTH_CURVATURE
VT.push_back( pCC1->Clone()) ;
VT.push_back( pCC2->Clone()) ;
SaveGeoObj( VT, "C:\\Temp\\bezier\\ruled\\smoothness\\regolarized_first_step.nge") ;
#endif
// ora verifico l'eventuale presenza di cambi di concavità non desiderati
// se ne trovo su una curva e non sull'altra allora ruoto il terzetto di punti della curva con flesso in modo
// da matchare la tangente dell'altra curva
PNTINFOVECTOR vPntInfo1, vPntInfo2 ;
FillPntInfo( vPnt0, pCC1, vPntInfo1) ;
FillPntInfo( vPnt1, pCC2, vPntInfo2) ;
RemoveInflexionPoints( vPnt0, vPntInfo1, vPntInfo2) ;
RemoveInflexionPoints( vPnt1, vPntInfo2, vPntInfo1) ;
pCC1->Clear() ;
pCC2->Clear() ;
for ( int i = 0 ; i < ssize( vPnt0) - 3 ; i+=3) {
PtrOwner<ICurveBezier> cb1( CreateCurveBezier()) ; cb1->Init( 3, false) ;
cb1->SetControlPoint( 0, vPnt0[i]) ;
cb1->SetControlPoint( 1, vPnt0[i+1]) ;
cb1->SetControlPoint( 2, vPnt0[i+2]) ;
cb1->SetControlPoint( 3, vPnt0[i+3]) ;
pCC1->AddCurve( Release( cb1)) ;
PtrOwner<ICurveBezier> cb2( CreateCurveBezier()) ; cb2->Init( 3, false) ;
cb2->SetControlPoint( 0, vPnt1[i]) ;
cb2->SetControlPoint( 1, vPnt1[i+1]) ;
cb2->SetControlPoint( 2, vPnt1[i+2]) ;
cb2->SetControlPoint( 3, vPnt1[i+3]) ;
pCC2->AddCurve( Release( cb2)) ;
}
// controllo di essere rimasto in tolleranza
double dErr = 0 ;
CalcApproxError( pCrvOrig1, pCC1, dErr, 20) ;
if ( dErr > dTol)
return nullptr ;
CalcApproxError( pCrvOrig2, pCC2, dErr, 20) ;
if ( dErr > dTol)
return nullptr ;
PtrOwner<ISurfBezier> pNewSurf( pSurfBz->Clone()) ;
// aggiorno i punti di controllo della superficie di bezier
for ( int i = 0 ; i < ssize( vPnt0) ; ++i) {
pNewSurf->SetControlPoint( nUS1 + i, 0, vPnt0[i]) ;
pNewSurf->SetControlPoint( nUS1 + i, 1, vPnt1[i]) ;
}
#if DEBUG_SMOOTH_CURVATURE
VT.clear() ;
VT.push_back( Release(pCC1)) ;
VT.push_back( Release(pCC2)) ;
SaveGeoObj( VT, "C:\\Temp\\bezier\\ruled\\smoothness\\regolarized.nge") ;
#endif
return Release( pNewSurf) ;
}
Reference in New Issue View Git Blame Copy Permalink