From d0bbc522538534949052bcbff98ab12a311f5c7a Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Tue, 19 May 2026 10:29:54 +0200 Subject: [PATCH] EgtMachKernel 3.1e4 : - in SurfFinishing migliorate e corrette le lavorazione ZLevel. --- EgtMachKernel.rc | Bin 11774 -> 11774 bytes SurfFinishing.cpp | 150 +++++++++++++++++++++++----------------------- 2 files changed, 75 insertions(+), 75 deletions(-) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index df601b4daabd64eb1f0e2218c65ca5028913130a..d199be436fd19ab0cc82db2b0d986e93e381d868 100644 GIT binary patch delta 241 zcmewt{V#gMI%aiGhCGIJh8%`ehGHOAV9;O)W+-7u1ma8}FBB-731Uz7R&U)L$1;bB z(PZ;)Hd|&!lgSSybvLJRO<)0wTx6PjLa+cPDg+fpQs=?Ad6l#WP#;h`nqrWY@;63e oowE6~YB8f=KG?0EV7KM~-I%!9TYV!lrtsv`ss}fp(l%iN0AR>OF#rGn delta 236 zcmewt{V#gMI%aKGhCGIJh8%`WhGK>c1_cHUhESkLCPN8BDnkm89}HwAf_cT0IklxX ze_&=~W;EXXUhX2(<& nF)y2}rOv|(a;PWRX*mp)AcsxIsValid()) { @@ -1524,9 +1524,9 @@ SurfFinishing::SetCAvTlStmForSurfaces( ICAvToolSurfTm* pCAvTlStm, const ISurfFla PtrOwner 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 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 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 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 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 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 pSfrCntCopy( CloneSurfFlatRegion( pSfrCnt)) ; - if ( IsNull( pSfrCntCopy) || ! pSfrCntCopy->IsValid()) - return false ; - pSfrCnt->Clear() ; - pSfrCnt->CopyFrom( pSfrCntCopy) ; + // ricreo la regione originale + PtrOwner 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 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 pStm ; + PtrOwner 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 pCrvCompo( CreateCurveComposite()) ; if ( IsNull( pCrvCompo) || ! pCrvCompo->FromPolyLine( vPL[nPL])) return false ; @@ -2432,7 +2430,6 @@ SurfFinishing::GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR& vS PtrOwner 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 setZAmbiguos ; - PtrOwner 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 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::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 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 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 MapLock ; unordered_map 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 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> INTDBLDBL ; // > vector 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 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 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 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 ;