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

EgtMachKernel 3.1e4 :

Browse Source 
- in SurfFinishing migliorate e corrette le lavorazione ZLevel.
This commit is contained in:
Riccardo Elitropi
2026-05-19 10:29:54 +02:00
parent b1e7534b28
commit d0bbc52253
2 changed files with 75 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtMachKernel.rc
BIN
View File
Binary file not shown.
SurfFinishing.cpp
+75 -75
View File
@@ -1477,7 +1477,7 @@ SurfFinishing::SetCAvTlStmForSurfaces( ICAvToolSurfTm* pCAvTlStm, const ISurfFla
}
// aggiungo tutte le superfici di lavoro
for ( int i = 0 ; i < int( vSurfLoc.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vSurfLoc) ; ++ i) {
// superfici ammesse : TriMesh, Bezier
const ISurf* pSurf = GetSurf( vSurfLoc[i].Get()) ;
if ( pSurf != nullptr && pSurf->IsValid()) {
@@ -1524,9 +1524,9 @@ SurfFinishing::SetCAvTlStmForSurfaces( ICAvToolSurfTm* pCAvTlStm, const ISurfFla
PtrOwner<ISurfTriMesh> pStmContainment( CreateSurfTriMesh()) ;
if ( IsNull( pStmContainment))
return false ;
if ( pSfrCnt != nullptr && pSfrCnt->IsValid() && abs( dDepth) > 10 * EPS_SMALL) {
if ( pSfrCnt != nullptr && pSfrCnt->IsValid() && abs( dDepth) > 10. * EPS_SMALL) {
// considero la regione complessiva di lavoro dell'utensile all'interno della quale non può uscire
double dOffs = dToolDiam / 2. + m_Params.m_dOverlap + SUPP_SURF_RADIAL_OFFS + 50 * EPS_SMALL ;
double dOffs = dToolDiam / 2. + m_Params.m_dOverlap + SUPP_SURF_RADIAL_OFFS + 50. * EPS_SMALL ;
PtrOwner<ISurfFlatRegion> pSfrFreeMove( pSfrCnt->CreateOffsetSurf( dOffs, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrFreeMove) || ! pSfrFreeMove->IsValid())
return false ;
@@ -1606,7 +1606,7 @@ SurfFinishing::EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d&
// calcolo silhouette dell'insieme di superfici
CISURFTMPVECTOR vpStm ; vpStm.reserve( vSurfLoc.size()) ;
for ( int i = 0 ; i < int( vSurfLoc.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vSurfLoc) ; ++ i) {
// recupero la superficie
const ISurf* pSurf = GetSurf( vSurfLoc[i].Get()) ;
if ( pSurf == nullptr || ! pSurf->IsValid())
@@ -1647,25 +1647,23 @@ SurfFinishing::EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d&
const double SILH_ARC_TOL = SILH_TOL / 10. ;
const double SILH_ARC_FEA_MAX = 100. ;
SurfFlatRegionByContours SfrMaker ;
for ( auto& PL : vPL) {
for ( const PolyLine& PL : vPL) {
// recupero la curva dalla silhouette
PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
if ( IsNull( pSilCrv))
return false ;
pSilCrv->FromPolyLine( PL) ;
// approssimo con archi
PolyArc PA ;
if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
if ( ! IsNull( pTempCrv) &&
pTempCrv->FromPolyArc( PA) &&
pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG) &&
pTempCrv->MergeCurves( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG))
pSilCrv.Set( pTempCrv) ;
}
// aggiungo per regione
if ( ! SfrMaker.AddCurve( Release( pSilCrv)))
return false ;
// approssimo con archi
PolyArc PA ;
if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
if ( ! IsNull( pTempCrv) && pTempCrv->FromPolyArc( PA) && pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG) &&
pTempCrv->MergeCurves( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG))
pSilCrv.Set( pTempCrv) ;
}
// aggiungo per regione
if ( ! SfrMaker.AddCurve( Release( pSilCrv)))
return false ;
}
PtrOwner<ISurfFlatRegion> pSfrSil( SfrMaker.GetSurf()) ;
if ( ! IsNull( pSfrSil)) {
@@ -1674,12 +1672,12 @@ SurfFinishing::EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d&
pSfrSil->Offset( dPockRadOffs, ICurve::OFF_CHAMFER) ;
// intersezione tra contorno e regione
if ( ! pSfrCnt->Intersect( *pSfrSil)) {
// ricreo la regione originale
PtrOwner<ISurfFlatRegion> pSfrCntCopy( CloneSurfFlatRegion( pSfrCnt)) ;
if ( IsNull( pSfrCntCopy) || ! pSfrCntCopy->IsValid())
return false ;
pSfrCnt->Clear() ;
pSfrCnt->CopyFrom( pSfrCntCopy) ;
// ricreo la regione originale
PtrOwner<ISurfFlatRegion> pSfrCntCopy( CloneSurfFlatRegion( pSfrCnt)) ;
if ( IsNull( pSfrCntCopy) || ! pSfrCntCopy->IsValid())
return false ;
pSfrCnt->Clear() ;
pSfrCnt->CopyFrom( pSfrCntCopy) ;
}
// azzero le proprietà delle curve semplici dei contorni delle regioni ( se 1 lato aperto)
for ( int nC = 0 ; nC < pSfrCnt->GetChunkCount() ; ++ nC) {
@@ -1888,7 +1886,7 @@ SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
m_pMchMgr->SetLastError( 3005, "Error in SurfFinishing : Contour Not Flat") ;
return false ;
}
if ( abs( plPlane.GetVersN() * vtExtr) < cos( 10 * EPS_ANG_SMALL)) {
if ( abs( plPlane.GetVersN() * vtExtr) < cos( 10. * EPS_ANG_SMALL)) {
m_pMchMgr->SetLastError( 3006, "Error in SurfFinishing : Tool Dir not perpendicular to Flat Area") ;
return false ;
}
@@ -2006,8 +2004,7 @@ SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
// se richiesto, elimino le parti al massimo affondamento
bool bSkipMaxDown = true ;
GetValInNotes( m_Params.m_sUserNotes, UN_SKIPMAXDOWN, bSkipMaxDown) ;
if ( bSkipMaxDown && m_Params.m_nSubType != SURFFIN_SUB_Z_CONST &&
m_Params.m_nSubType != SURFFIN_SUB_PENCIL) {
if ( bSkipMaxDown && m_Params.m_nSubType != SURFFIN_SUB_Z_CONST && m_Params.m_nSubType != SURFFIN_SUB_PENCIL) {
PtrOwner<ISurfFlatRegion> pSfrMaxDown( CloneSurfFlatRegion( pSfrCnt)) ;
if ( IsNull( pSfrMaxDown) || ! pSfrMaxDown->IsValid() ||
! EraseMaxDownSurf( vSrfLoc, frSurf, vtTool, dDepth, pSfrMaxDown)) {
@@ -2375,28 +2372,28 @@ SurfFinishing::GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR& vS
return false ;
// scorro le superfici trimesh selezionate
for ( int nS = 0 ; nS < int( vSrfLoc.size()) ; ++ nS) {
for ( int nS = 0 ; nS < ssize( vSrfLoc) ; ++ nS) {
// recupero la superficie
const ISurf* pSurf = GetSurf( vSrfLoc[nS].Get()) ;
if ( pSurf == nullptr || ! pSurf->IsValid())
continue ;
int nType = pSurf->GetType() ;
PtrOwner<ISurfTriMesh> pStm ;
PtrOwner<ISurfTriMesh> pStm( nullptr) ;
// se TriMesh
if ( nType == SRF_TRIMESH) {
const ISurfTriMesh* pSurftm = GetSurfTriMesh( pSurf) ;
if ( pSurftm != nullptr && pSurftm->IsValid() && pSurftm->GetTriangleCount() > 0) {
if ( ! pStm.Set( CloneSurfTriMesh( pStm)))
if ( ! pStm.Set( CloneSurfTriMesh( pSurftm)))
continue ;
}
}
// se Bezier
else if ( nType == SRF_BEZIER) {
const ISurfBezier* pSBz = GetSurfBezier( pSurf) ;
if ( pSBz != nullptr && pSBz->IsValid()) {
const ISurfBezier* pSurfBz = GetSurfBezier( pSurf) ;
if ( pSurfBz != nullptr && pSurfBz->IsValid()) {
double dOldTol = GetSurfBezierAuxSurfRefinedTol() ;
SetSurfBezierAuxSurfRefinedTol( 5. * EPS_SMALL) ;
const ISurfTriMesh* pSurftm = pSBz->GetAuxSurfRefined() ;
const ISurfTriMesh* pSurftm = pSurfBz->GetAuxSurfRefined() ;
SetSurfBezierAuxSurfRefinedTol( dOldTol) ;
if ( pSurftm != nullptr && pSurftm->IsValid() && pSurftm->GetTriangleCount() > 0) {
if ( ! pStm.Set( CloneSurfTriMesh( pSurftm)))
@@ -2416,9 +2413,10 @@ SurfFinishing::GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR& vS
// recupero i contorni della faccia
POLYLINEVECTOR vPL ;
if ( pStm->GetFacetLoops( nF, vPL)) {
// recupero la superficie piana dalle curve
// devo verificare che tale faccia effettivamente sia contenuta all'interno della *pSfr.
// Essendo la normale della faccia orientata circa la direzione utensile, posso effettuare un confronto diretto
SurfFlatRegionByContours SfrByC ;
for ( int nPL = 0 ; nPL < int( vPL.size()) ; ++ nPL) {
for ( int nPL = 0 ; nPL < ssize( vPL) ; ++ nPL) {
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo) || ! pCrvCompo->FromPolyLine( vPL[nPL]))
return false ;
@@ -2432,7 +2430,6 @@ SurfFinishing::GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR& vS
PtrOwner<ISurfFlatRegion> pSfrFace( SfrByC.GetSurf()) ;
if ( IsNull( pSfrFace) || ! pSfrFace->IsValid()) {
// in questo caso potrei avere geometrie complesse per le facce della pStm
// inserisco la Z del piano locale nell'insieme
setZAmbiguos.insert( ptCenter.z) ;
continue ;
}
@@ -2445,6 +2442,7 @@ SurfFinishing::GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR& vS
}
}
}
return true ;
}
@@ -2522,11 +2520,9 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU
// NB. Essendo una finitura a Z costante, devo controllare che i piani di finitura non facciano
// overlap con facce delle TriMesh selezionate con normale simile a vtTool
set<double> setZAmbiguos ;
PtrOwner<ISurfFlatRegion> pSfrZAmb( CloneSurfFlatRegion( pSfrClass)) ;
if ( IsNull( pSfrZAmb) || ! pSfrZAmb->IsValid() ||
! pSfrZAmb->Offset( m_TParams.m_dDiam / 2. + abs( m_Params.m_dOverlap), ICurve::OFF_FILLET))
return false ;
if ( ! GetZConstQuotesInsideSfrParallelToTool( vSrfLoc, frSurf, pSfrZAmb, vtTool, setZAmbiguos))
PtrOwner<ISurfFlatRegion> pSfrZCheck( CloneSurfFlatRegion( pSfrClass)) ;
if ( IsNull( pSfrZCheck) || ! pSfrZCheck->IsValid() ||
! GetZConstQuotesInsideSfrParallelToTool( vSrfLoc, frSurf, pSfrZCheck, vtTool, setZAmbiguos))
return false ;
// aggiorno la ProgressBar al 40%
@@ -2539,8 +2535,8 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU
// definisco la Zlocale per il calcolo della silhouette
double dZLoc = - nPlane * m_Params.m_dSideStep ;
for ( set<double>::iterator it = setZAmbiguos.begin() ; it != setZAmbiguos.end() ; ++ it) {
if ( abs( *it - dZLoc) < 5 * EPS_SMALL)
dZLoc += ( nPlane == 1 ? - 10 * EPS_SMALL : + 10 * EPS_SMALL) ;
if ( abs( *it - dZLoc) < 5. * EPS_SMALL)
dZLoc += ( nPlane == 1 ? - 10. * EPS_SMALL : + 10. * EPS_SMALL) ;
}
// calcolo vettore di PolyLine ottenute al piano corrente
POLYLINEVECTOR vPL ;
@@ -2548,7 +2544,7 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU
return false ;
// classifico le PolyLine in base alla regione
POLYLINEVECTOR vPLInsideSfr ;
for ( auto& PL : vPL) {
for ( PolyLine& PL : vPL) {
// porto la PolyLine a contatto con la regione
PL.Translate( - dZLoc * pSfrClass->GetNormVersor()) ;
// converto in curva composita
@@ -2560,7 +2556,7 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU
if ( ! pSfrClass->GetCurveClassification( *pCrvPL, EPS_SMALL, ccClass))
return false ;
// tengo tutti i tratti non esterni alla superficie
for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( ccClass) ; ++ i) {
if ( ccClass[i].nClass != CRVC_OUT) {
PtrOwner<ICurveComposite> pCrvCompoPartIn( ConvertCurveToComposite( pCrvPL->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE))) ;
if ( ! IsNull( pCrvCompoPartIn) && pCrvCompoPartIn->IsValid()) {
@@ -2573,7 +2569,7 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU
}
}
swap( vPL, vPLInsideSfr) ;
for ( auto& PL : vPL) {
for ( PolyLine& PL : vPL) {
// recupero la curva dalla silhouette
PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
if ( IsNull( pSilCrv))
@@ -2595,27 +2591,27 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU
vCrvCompo.back().emplace_back( Release( pSilCrv)) ;
}
// controllo validità delle curve
for ( int i = 0 ; i < int( vCrvCompo.back().size()) ; ++ i)
for ( int i = 0 ; i < ssize( vCrvCompo.back()) ; ++ i)
if ( vCrvCompo.back()[i] == nullptr || ! vCrvCompo.back()[i]->IsValid())
return false ;
// preparo i dati per il concatenamento
bool bFirst = true ;
Point3d ptNear = ORIG ;
double dToler = 500 * EPS_SMALL ;
double dToler = 500. * EPS_SMALL ;
ChainCurves chainC ;
chainC.Init( false, dToler, int( vCrvCompo.back().size())) ;
for ( int i = 0 ; i < int( vCrvCompo.back().size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vCrvCompo.back()) ; ++ i) {
// recupero i dati della curva necessari al concatenamento e li assegno
Point3d ptStart, ptEnd ;
Vector3d vtStart, vtEnd ;
if ( ! vCrvCompo.back()[i]->GetStartPoint( ptStart) || ! vCrvCompo.back()[i]->GetStartDir( vtStart) ||
! vCrvCompo.back()[i]->GetEndPoint( ptEnd) || ! vCrvCompo.back()[i]->GetEndDir( vtEnd))
return false ;
if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd))
if ( ! chainC.AddCurve( i + 1, ptStart, vtStart, ptEnd, vtEnd))
return false ;
// se prima curva, assegno inizio della ricerca
if ( bFirst) {
ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
ptNear = ptStart + 10. * EPS_SMALL * vtStart ;
bFirst = false ;
}
}
@@ -2643,7 +2639,7 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU
}
swap( vCrvCompoChained, vCrvCompo.back()) ;
// salvo lo Step come primo temp param della curva e inverto se necessario
for ( int i = 0 ; i < int( vCrvCompo.back().size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vCrvCompo.back()) ; ++ i) {
vCrvCompo.back()[i]->SetTempParam( - nPlane * m_Params.m_dSideStep, 0) ;
if ( m_Params.m_bInvert)
vCrvCompo.back()[i]->Invert() ;
@@ -2693,10 +2689,10 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
m_pGeomDB->SetName( nGrp, "Crv & Sfr") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
#endif
for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vCrvCompo) ; ++ i) {
vSfrRemMatCol[i].resize( vCrvCompo[i].size()) ;
for ( int j = 0 ; j < int( vCrvCompo[i].size()) ; ++ j) {
// --- Frame locale XY
for ( int j = 0 ; j < ssize( vCrvCompo[i]) ; ++ j) {
// Frame locale XY
vCrvCompo[i][j]->ToLoc( frXY) ;
vCrvCompo[i][j]->SetExtrusion( m_Params.m_bInvert ? - Z_AX : Z_AX) ;
SurfFlatRegionByContours SfrBC ;
@@ -2757,9 +2753,9 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
nColSize = max( nColSize, int( vCrvCompo[i].size())) ;
unordered_map<int, INTINTVECTOR> MapLock ;
unordered_map<int, INTINTVECTOR> MapUnlock ;
for ( int nR = int( vCrvCompo.size()) - 1 ; nR >= 1 ; -- nR) {
for ( int nC = 0 ; nC < int( vCrvCompo[nR].size()) ; ++ nC) {
for ( int nCol = 0 ; nCol < int( vCrvCompo[nR - 1].size()) ; ++ nCol) {
for ( int nR = ssize( vCrvCompo) - 1 ; nR >= 1 ; -- nR) {
for ( int nC = 0 ; nC < ssize( vCrvCompo[nR]) ; ++ nC) {
for ( int nCol = 0 ; nCol < ssize( vCrvCompo[nR - 1]) ; ++ nCol) {
PtrOwner<ISurfFlatRegion> pSfrCheck( CloneSurfFlatRegion( vSfrRemMatCol[nR][nC])) ;
if ( ! IsNull( pSfrCheck)) {
pSfrCheck->Intersect( *vSfrRemMatCol[nR - 1][nCol]) ;
@@ -2784,9 +2780,9 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
++ nCont ;
bGroup = false ;
// cerco la prima curva non ancora inserita in un gruppo
for ( int nR = int( vCrvCompo.size()) - 1 ; nR >= 0 && ! bGroup ; -- nR) {
for ( int nR = ssize( vCrvCompo) - 1 ; nR >= 0 && ! bGroup ; -- nR) {
// scorro sulle colonne ( dalla prima all'ultima) [ordine casuale]
for ( int nC = 0 ; nC < int( vCrvCompo[nR].size()) && ! bGroup ; ++ nC) {
for ( int nC = 0 ; nC < ssize( vCrvCompo[nR]) && ! bGroup ; ++ nC) {
// se la curva attuale già in un gruppo ( quindi nullptr), passo alla successiva
if ( vCrvCompo[nR][nC] == nullptr)
continue ;
@@ -2812,14 +2808,14 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
// --- altrimenti
else {
// --- scorro le curve che bloccano quella corrente
for ( int i = 0 ; i < int( itLock->second.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( itLock->second) ; ++ i) {
int nBR = itLock->second[i].first ;
int nBC = itLock->second[i].second ;
INTINT Key = make_pair( nBR, nBC) ;
auto itUnLock = MapUnlock.find( nBR * nColSize + nBC) ;
// verifico che non ci siano altre curve bloccate
bool bLock = false ;
for ( int j = 0 ; j < int( itUnLock->second.size()) && ! bLock ; ++ j)
for ( int j = 0 ; j < ssize( itUnLock->second) && ! bLock ; ++ j)
bLock = ( vCrvCompo[itUnLock->second[j].first][itUnLock->second[j].second] != nullptr) ;
if ( ! bLock)
vMapIndCheck.emplace_back( Key) ;
@@ -2857,7 +2853,7 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
typedef pair<int, pair<double, double>> INTDBLDBL ; // <Ind, <ZMax, ZMin>>
vector<INTDBLDBL> vMapGrpZLoc ;
vMapGrpZLoc.reserve( vIndependentCurveGroup.size()) ;
for ( int i = 0 ; i < int( vIndependentCurveGroup.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vIndependentCurveGroup) ; ++ i) {
// scorro le curve del gruppo cercando quella più in alto ( rispetto alla Zlocale di frXY)
double dZMax = - INFINITO ;
double dZMin = INFINITO ;
@@ -2871,7 +2867,7 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
// ordino
sort( vMapGrpZLoc.begin(), vMapGrpZLoc.end(), []( const INTDBLDBL& GrpA, const INTDBLDBL& GrpB) {
// Se ZMax coincidenti, viene prima quello con ZMin superiore
if ( abs( GrpA.second.first - GrpB.second.first) < 10 * EPS_SMALL)
if ( abs( GrpA.second.first - GrpB.second.first) < 10. * EPS_SMALL)
return ( GrpA.second.second > GrpB.second.second) ;
// Se diffeenti, viene prima quello con ZMax superiore
return ( GrpA.second > GrpB.second) ;
@@ -2920,7 +2916,7 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
#endif
const double LINK_TOL = 25. * EPS_SMALL ;
Point3d ptRef = P_INVALID ;
for ( int i = 0 ; i < int( vMapGrpZLoc.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vMapGrpZLoc) ; ++ i) {
// recupero l'indice ordinato del percorso
int nPath = vMapGrpZLoc[i].first ;
// inverto il vettore delle curve di bordo del percorso corrente
@@ -2972,7 +2968,7 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
}
// --- se ho più curve di bordo, scorro le curve a due a due per creare i collegamenti
for ( int nCompo = 0 ; nCompo < int( vIndependentCurveGroup[nPath].size()) - 1 ; ++ nCompo) {
for ( int nCompo = 0 ; nCompo < ssize( vIndependentCurveGroup[nPath]) - 1 ; ++ nCompo) {
// se prima curva di bordo e ho un punto di riferimento valido
if ( nCompo == 0 && ptRef.IsValid()) {
// --- se la prima curva di bordo è aperta
@@ -3022,7 +3018,7 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
// --- se il Link è parallelo a vtTool ( Z_AX in locale), allora ho una parete verticale ( localemente)
Vector3d vtDirLink ; pLineLink->GetStartDir( vtDirLink) ;
if ( AreSameOrOppositeVectorEpsilon( vtDirLink, Z_AX, 100 * EPS_SMALL)) {
if ( AreSameOrOppositeVectorEpsilon( vtDirLink, Z_AX, 100. * EPS_SMALL)) {
// la proiezione del Link è automaticamente all'interno della superficie di classificazione
vCompoLink[nCompo + 1].Set( ConvertCurveToComposite( Release( pLineLink))) ;
}
@@ -3042,7 +3038,7 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
// inizializzo il link come curva vuota e scorro le classificazioni ottenute
vCompoLink[nCompo + 1].Set( CreateCurveComposite()) ;
for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( ccClass) ; ++ i) {
// recupero il tratto di curve corrente
PtrOwner<ICurve> pSubCrv( pLineLinkProj->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE)) ;
if ( IsNull( pSubCrv) || ! pSubCrv->IsValid()) // troppo piccolo...
@@ -3058,7 +3054,7 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
Point3d ptS_sfr ; pLineLinkProj->GetPointD1D2( ccClass[i].dParS, ICurve::FROM_MINUS, ptS_sfr) ;
Point3d ptE_sfr ; pLineLinkProj->GetPointD1D2( ccClass[i].dParE, ICurve::FROM_MINUS, ptE_sfr) ;
// scorro tutti i loop della regione di classificazione
for ( int j = 0 ; j < int( vCrvSfrLoops.size()) ; ++ j) {
for ( int j = 0 ; j < ssize( vCrvSfrLoops) ; ++ j) {
// se i punti trovati sono sul loop corrente
if ( vCrvSfrLoops[j]->IsPointOn( ptS_sfr, LINK_TOL) &&
vCrvSfrLoops[j]->IsPointOn( ptE_sfr, LINK_TOL)) {
@@ -3105,7 +3101,7 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
int nLay = GDB_ID_NULL ;
Color myCol = INVISIBLE ;
#endif
for ( int nCompo = 0 ; nCompo < int( vIndependentCurveGroup[nPath].size()) - 1 ; ++ nCompo) {
for ( int nCompo = 0 ; nCompo < ssize( vIndependentCurveGroup[nPath]) - 1 ; ++ nCompo) {
if ( IsNull( vCompoLink[nCompo]) || ! vCompoLink[nCompo]->IsValid()) {
#if ENABLE_ZCONST_PATH_DEBUG
nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
@@ -3130,7 +3126,7 @@ SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSu
}
// riporto i percorsi nel frame originale
for ( int i = 0 ; i < int( vCrvPath.size()) ; ++ i)
for ( int i = 0 ; i < ssize( vCrvPath) ; ++ i)
vCrvPath[i]->ToGlob( frXY) ;
return true ;
@@ -3206,7 +3202,6 @@ bool
SurfFinishing::AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{
// controllo che la regione sia definita correttamente
if ( pSfrCnt == nullptr || ! pSfrCnt->IsValid())
return false ;
@@ -3222,14 +3217,19 @@ SurfFinishing::AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrf
frSfr.ToLoc( frSurf) ; // in locale alle SrfLoc
// aggiusto la regione a seconda dei parametri e la porto nel frame locale delle superfici
PtrOwner<ISurfFlatRegion> pSfrClass( CloneSurfFlatRegion( pSfrCnt)) ;
// NB. Per rendere questa superficie coerente con le superfici degli altri tipi di lavorazione, devo effettuare un ControOffset
// del raggio utensile. Se la lavorazione fosse a ZigZag le curve si trovano all'interno di questa regione del raggio utensile
// ( questo passaggio è calcolato implicitamente dalla lavorazione di Pocketing ZigZag). Nel caso di Lavorazione a ZLevel bissogna
// aggiungere questo passaggio in modo tale che dalla curva originaria Offsettata del parametro di Overlap, tutto l'utensile stia
// al suo interno. Quindi le curve all'esterno della pSfrClass ( pSfrCnt è già estesa del parametro Overlap)
PtrOwner<ISurfFlatRegion> pSfrClass( pSfrCnt->CreateOffsetSurf( - m_TParams.m_dDiam / 2. + EPS_SMALL, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrClass) || ! pSfrClass->IsValid() || ! pSfrClass->ToLoc( frSurf))
return false ;
// inizializzo la classe di calcolo delle silhouette
CISURFTMPVECTOR vpStm ; vpStm.reserve( vSrfLoc.size()) ;
// scorro le superfici
for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vSrfLoc) ; ++ i) {
// recupero la superficie
const ISurf* pSurf = GetSurf( vSrfLoc[i].Get()) ;
if ( pSurf == nullptr || ! pSurf->IsValid())
@@ -3274,7 +3274,7 @@ SurfFinishing::AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrf
}
// se non ho curve, esco
bool bNoCrv = true ;
for ( int i = 0 ; i < int( vCrvCompo.size()) && bNoCrv ; ++ i)
for ( int i = 0 ; i < ssize( vCrvCompo) && bNoCrv ; ++ i)
bNoCrv = ( vCrvCompo[i].empty()) ;
if ( bNoCrv)
return true ;