From a53ead679e7e8bd207e81425f107beeee4dca59a Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Thu, 18 Jun 2026 10:55:24 +0200 Subject: [PATCH] =?UTF-8?q?EgtGeomKernel=20:=20-=20in=20CalcPocketing=20pe?= =?UTF-8?q?r=20lavorazioni=20conformal=20aggiunta=20la=20possibilit=C3=A0?= =?UTF-8?q?=20di=20lavorare=20una=20regione=20mantenendo=20l'utensile=20al?= =?UTF-8?q?=20suo=20interno.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CalcPocketing.cpp | 461 ++++++++++++++++++++++++++++------------------ 1 file changed, 281 insertions(+), 180 deletions(-) diff --git a/CalcPocketing.cpp b/CalcPocketing.cpp index 6ba5a1e..a5fb0ca 100644 --- a/CalcPocketing.cpp +++ b/CalcPocketing.cpp @@ -77,6 +77,7 @@ struct PocketParams { // ------------------------------------------------------- bool bAllClosed = true ; // flag per indicare se tutti i bordi della *pSfr da svuotare sono chiusi bool bAllOpen = true ; // flag per indicare se tutti i bordi della *pSfr da svuotare sono aperti + bool bToolInRegion = false ; // flag per forzare l'utensile a rimanere all'interno della regione (usato per Conformal) double dOffsExtra = 2. ; // Offset aggiuntivo per percosi a ZigZag/OneWay se richieste le curve di bordo Frame3d frLocXY ; // frame per conti nel piano XY int nOffsType = ICurve::OFF_FILLET ; // tipologia di Offset per estensione degli aperti @@ -136,7 +137,10 @@ typedef vector VICRVCOMPOPOVECTOR ; for ( int nU = 0 ; nU < pCrvCompo->GetCurveCount() ; ++ nU) { int nProp0 ; pCrvCompo->GetCurveTempProp( nU, nProp0, 0) ; VT.emplace_back( static_cast( pCrvCompo->GetCurve( nU)->Clone())) ; - VC.emplace_back( nProp0 == 0 ? BLUE : RED) ; + VC.emplace_back( nProp0 == TEMP_PROP_CLOSE_EDGE ? BLUE : + nProp0 == TEMP_PROP_OPEN_EDGE ? RED : + nProp0 == TEMP_PROP_OPEN_AS_CLOSE ? ORANGE : + BLACK) ; } return ; } @@ -188,8 +192,8 @@ AssignMaxFeed( ICurveComposite* pCrv, const PocketParams& PockParams) return false ; // assegno la Feed massima ad ogni sottocurva di pCrv - for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u) - pCrv->SetCurveTempParam( u, GetMaxFeed( PockParams), 0) ; + for ( int nU = 0 ; nU < pCrv->GetCurveCount() ; ++ nU) + pCrv->SetCurveTempParam( nU, GetMaxFeed( PockParams), 0) ; return true ; } @@ -220,8 +224,8 @@ AssignCustomFeed( ICurveComposite* pCrv, const PocketParams& PockParams, double dFeed = Clamp( dFeed, GetMinFeed( PockParams), GetMaxFeed( PockParams)) ; // assegno la Feed ad ogni sottocurva di pCrv - for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u) - pCrv->SetCurveTempParam( u, dFeed, 0) ; + for ( int nU = 0 ; nU < pCrv->GetCurveCount() ; ++ nU) + pCrv->SetCurveTempParam( nU, dFeed, 0) ; return true ; } @@ -286,15 +290,15 @@ AssignFeedZigZagOneWay( ICurveComposite* pCompo, const bool bIsLink, const ICURV // se è un link tra livelli diversi, allora esco ( con Feed Minima ) if ( bIsLink) { - Point3d ptS_link ; pCompo->GetStartPoint( ptS_link) ; - Point3d ptE_link ; pCompo->GetEndPoint( ptE_link) ; - if ( abs( ptE_link.y - ptS_link.y) > 500 * EPS_SMALL) + Point3d ptSLink ; pCompo->GetStartPoint( ptSLink) ; + Point3d ptELink ; pCompo->GetEndPoint( ptELink) ; + if ( abs( ptELink.y - ptSLink.y) > 500. * EPS_SMALL) return true ; } // se la curva è piccola, allora esco ( con Feed Minima) double dLen = EPS_SMALL ; - if ( ! pCompo->GetLength( dLen) || dLen < 0.6 * ( 2 * PockParams.dRad)) + if ( ! pCompo->GetLength( dLen) || dLen < 0.6 * ( 2. * PockParams.dRad)) return true ; Point3d ptS, ptE ; @@ -306,9 +310,9 @@ AssignFeedZigZagOneWay( ICurveComposite* pCompo, const bool bIsLink, const ICURV // creo un vettore contenente i tratti sopra e i tratti sotto attivi ICURVEPOVECTOR vAllInt ; vAllInt.reserve( int( vLUnder.size()) + int( vLAbove.size())) ; - for ( int i = 0 ; i < int( vLUnder.size()) ; ++ i) + for ( int i = 0 ; i < ssize( vLUnder) ; ++ i) vAllInt.emplace_back( vLUnder[i]->Clone()) ; - for ( int i = 0 ; i < int( vLAbove.size()) ; ++ i) + for ( int i = 0 ; i < ssize( vLAbove) ; ++ i) vAllInt.emplace_back( vLAbove[i]->Clone()) ; int nDim = int( vAllInt.size()) ; @@ -316,36 +320,36 @@ AssignFeedZigZagOneWay( ICurveComposite* pCompo, const bool bIsLink, const ICURV // aggiungo le parti dei link interessate double dCurrY = ptS.y ; BBox3d bBoxLink ; - for ( int l = 0 ; l < int( vAddedLinks.size()) ; ++ l) { - vAddedLinks[l]->GetLocalBBox( bBoxLink) ; - if (( dCurrY - bBoxLink.GetMin().y) < PockParams.dSideStep + 50 * EPS_SMALL || - ( dCurrY - bBoxLink.GetMax().y) < PockParams.dSideStep + 50 * EPS_SMALL) { + for ( int nL = 0 ; nL < ssize( vAddedLinks) ; ++ nL) { + vAddedLinks[nL]->GetLocalBBox( bBoxLink) ; + if (( dCurrY - bBoxLink.GetMin().y) < PockParams.dSideStep + 50. * EPS_SMALL || + ( dCurrY - bBoxLink.GetMax().y) < PockParams.dSideStep + 50. * EPS_SMALL) { // determino la direzione del Link - Vector3d vtLinkDir( - 25, 0, 0) ; + Vector3d vtLinkDir( - 25., 0., 0.) ; // recupero gli estremi - Point3d ptS_l ; vAddedLinks[l]->GetStartPoint( ptS_l) ; - Point3d ptE_l ; vAddedLinks[l]->GetEndPoint( ptE_l) ; - if ( ptE_l.x - ptS_l.x < EPS_SMALL) - vtLinkDir.x -= ptS_l.x - ptE_l.x ; + Point3d ptSL ; vAddedLinks[nL]->GetStartPoint( ptSL) ; + Point3d ptEL ; vAddedLinks[nL]->GetEndPoint( ptEL) ; + if ( ptEL.x - ptSL.x < EPS_SMALL) + vtLinkDir.x -= ptSL.x - ptEL.x ; // superficie a rettangolo definita dal Box - PtrOwner pSfrRectUp( GetSurfFlatRegionRectangle( bBoxLink.GetDimX() + 50, PockParams.dSideStep)) ; - pSfrRectUp->Translate(( ptS_l - ORIG) + vtLinkDir) ; + PtrOwner pSfrRectUp( GetSurfFlatRegionRectangle( bBoxLink.GetDimX() + 50., PockParams.dSideStep)) ; + pSfrRectUp->Translate(( ptSL - ORIG) + vtLinkDir) ; // link sopra o sotto alla curva currente ? bool bIsDown = true ; - if ( dCurrY - ptS_l.y < EPS_SMALL) + if ( dCurrY - ptSL.y < EPS_SMALL) bIsDown = false ; // classificazione con la superficie a rettangolo CRVCVECTOR ccClass ; - pSfrRectUp->GetCurveClassification( *vAddedLinks[l], EPS_SMALL, ccClass) ; - for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) { + pSfrRectUp->GetCurveClassification( *vAddedLinks[nL], EPS_SMALL, ccClass) ; + for ( int i = 0 ; i < ssize( ccClass) ; ++ i) { if (( ccClass[i].nClass == CRVC_IN && bIsDown) || ( ccClass[i].nClass == CRVC_OUT && ! bIsDown)) { - PtrOwner pCrvInt( ConvertCurveToComposite( vAddedLinks[l]->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE))) ; + PtrOwner pCrvInt( ConvertCurveToComposite( vAddedLinks[nL]->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE))) ; if ( ! IsNull( pCrvInt) || pCrvInt->IsValid()) vAllInt.emplace_back( Release( pCrvInt)) ; } @@ -354,21 +358,21 @@ AssignFeedZigZagOneWay( ICurveComposite* pCompo, const bool bIsLink, const ICURV } // scorro tutti i tratti Attivi - for ( int i = 0 ; i < int( vAllInt.size()) ; ++ i) { + for ( int i = 0 ; i < ssize( vAllInt) ; ++ i) { // controllo che il tratto lineare sotto sia sufficientemente lungo - double dLen_iU = EPS_SMALL ; - if ( ! vAllInt[i]->GetLength( dLen_iU) || ( dLen_iU < 1.1 * ( 2 * PockParams.dRad) && i < nDim)) + double dLen = EPS_SMALL ; + if ( ! vAllInt[i]->GetLength( dLen) || ( dLen < 1.1 * ( 2. * PockParams.dRad) && i < nDim)) continue ; // estremi dell'intervallo - Point3d ptS_iU, ptE_iU ; - vAllInt[i]->GetStartPoint( ptS_iU) ; - vAllInt[i]->GetEndPoint( ptE_iU) ; + Point3d ptS, ptE ; + vAllInt[i]->GetStartPoint( ptS) ; + vAllInt[i]->GetEndPoint( ptE) ; // la vtDir per Above e Under è sempre invertita rispetto alla linea corrente // sottraggo questo intervallo a quello originale - IntMinFeed.Subtract( ptS_iU.x, ptE_iU.x) ; + IntMinFeed.Subtract( ptS.x, ptE.x) ; } // l'intervallo orginale ora conterrà i sottointervalli con feed Minima, tolgo quelli troppo piccoli @@ -376,7 +380,7 @@ AssignFeedZigZagOneWay( ICurveComposite* pCompo, const bool bIsLink, const ICURV double dParS = EPS_SMALL ; double dParE = EPS_SMALL ; bool bFound = IntMinFeed.GetFirst( dParS, dParE) ; while ( bFound) { - if ( dParE - dParS > PockParams.dRad - 5 * EPS_SMALL) + if ( dParE - dParS > PockParams.dRad - 5. * EPS_SMALL) IntMinFeed_noSmall.Add( dParS, dParE) ; bFound = IntMinFeed.GetNext( dParS, dParE) ; } @@ -390,7 +394,7 @@ AssignFeedZigZagOneWay( ICurveComposite* pCompo, const bool bIsLink, const ICURV Intervals IntMaxFeed_noSmall ; bFound = IntMaxFeed.GetFirst( dParS, dParE) ; while ( bFound) { - if ( dParE - dParS > PockParams.dRad - 5 * EPS_SMALL) + if ( dParE - dParS > PockParams.dRad - 5. * EPS_SMALL) IntMaxFeed_noSmall.Add( dParS, dParE) ; bFound = IntMaxFeed.GetNext( dParS, dParE) ; } @@ -403,7 +407,7 @@ AssignFeedZigZagOneWay( ICurveComposite* pCompo, const bool bIsLink, const ICURV // trasformo questi intervalli nei parametri corrispondenti sulla linea originale bool bFMax = false ; bFound = IntMaxFeed_noSmall.GetFirst( dParS, dParE) ; - if ( bFound && IntMaxFeed_noSmall.IsInside( ptS.x + vtDir.x * 20 * EPS_SMALL)) + if ( bFound && IntMaxFeed_noSmall.IsInside( ptS.x + vtDir.x * 20. * EPS_SMALL)) bFMax = true ; if ( ! bFound && bIsLink) // se non ho intervalli a Feed Massima, allora esco ( con Feed Minima) return true ; @@ -411,21 +415,21 @@ AssignFeedZigZagOneWay( ICurveComposite* pCompo, const bool bIsLink, const ICURV while ( bFound) { if ( ! bIsLink) { // se segmento di ZigZag - double du_js = EPS_SMALL ; pCompo->GetParamAtPoint( Point3d( dParS, ptS.y, ptS.z), du_js) ; - pCompo->AddJoint( du_js) ; - double du_je = EPS_SMALL ; pCompo->GetParamAtPoint( Point3d( dParE, ptE.y, ptE.z), du_je) ; - pCompo->AddJoint( du_je) ; + double dUS = EPS_SMALL ; pCompo->GetParamAtPoint( Point3d( dParS, ptS.y, ptS.z), dUS) ; + pCompo->AddJoint( dUS) ; + double dUE = EPS_SMALL ; pCompo->GetParamAtPoint( Point3d( dParE, ptE.y, ptE.z), dUE) ; + pCompo->AddJoint( dUE) ; } bFound = IntMaxFeed_noSmall.GetNext( dParS, dParE) ; } // aggiorno le proprietà temporanee con la feed if ( ! bIsLink) { - for ( int u = 0 ; u < pCompo->GetCurveCount() ; ++ u) { - if ( IsEven( u) == bFMax) - pCompo->SetCurveTempParam( u, GetMaxFeed( PockParams) , 0) ; + for ( int nU = 0 ; nU < pCompo->GetCurveCount() ; ++ nU) { + if ( IsEven( nU) == bFMax) + pCompo->SetCurveTempParam( nU, GetMaxFeed( PockParams) , 0) ; else - pCompo->SetCurveTempParam( u, GetMinFeed( PockParams), 0) ; + pCompo->SetCurveTempParam( nU, GetMinFeed( PockParams), 0) ; } } return true ; @@ -452,7 +456,7 @@ CheckSimpleOverlap( const ICurve* pCrv, const ICurveComposite* pCrvOri, int& nSt // controllo se una sottocurva della composita è abbastanza vicina a tutti i punti trovati const double nMAX = 10.0 ; - for ( int i = 0 ; i <= nMAX ; ++i) { + for ( int i = 0 ; i <= nMAX ; ++ i) { double dPar = i / nMAX ; Point3d ptC ; pCrv->GetPointD1D2( dPar, ICurve::FROM_PLUS, ptC) ; if ( ! pCrvOri->IsPointOn( ptC, dToll)) { @@ -485,7 +489,7 @@ AssignFeedForOpenEdge( ICurveComposite* pCrv, const ISurfFlatRegion* pSfrOpenEdg PtrOwner pNewCrv( CreateCurveComposite()) ; if ( IsNull( pNewCrv)) return false ; - for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) { + for ( int i = 0 ; i < ssize( ccClass) ; ++ i) { // recupero il tratto di curva corrente PtrOwner pCrvRange( ConvertCurveToComposite( pCrv->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE))) ; if ( ! IsNull( pCrvRange) && pCrvRange->IsValid()) { @@ -813,6 +817,35 @@ ResetCurveTempProps( ICurveComposite* pCrvCompo) return true ; } +//---------------------------------------------------------------------------- +static bool +IsToolInRegion( const ISurfFlatRegion* pSfr, int nType) +{ + // Verifico se la regione presenta solo TempProp TEMP_PROP_CLOSE_EDGE e TEMP_PROP_OPEN_AS_CLOSE. + // La lavorazione può essere solo di tipo conformal e deve presentare un solo Chunk + if ( pSfr == nullptr || ! pSfr->IsValid()) + return false ; + if ( ! ( nType == POCKET_CONFORMAL_ZIGZAG || nType == POCKET_CONFORMAL_ONEWAY)) + return false ; + int nChunkCnt = pSfr->GetChunkCount() ; + if ( nChunkCnt != 1) + return false ; + bool bExistClose = false ; + bool bExistOpen = false ; + bool bExistOpenAsClose = false ; + for ( int nL = 0 ; nL < pSfr->GetLoopCount( nL) ; ++ nL) { + for ( int nU = 0 ; nU < pSfr->GetLoopCurveCount( 0, nL) ; ++ nU) { + int nTmpProp0 = TEMP_PROP_INVALID ; pSfr->GetCurveTempProp( 0, nL, nU, nTmpProp0, 0) ; + bExistOpen = ( bExistOpen || ( nTmpProp0 == TEMP_PROP_OPEN_EDGE)) ; + if ( bExistOpen) + return false ; + bExistClose = ( bExistClose || ( nTmpProp0 == TEMP_PROP_CLOSE_EDGE)) ; + bExistOpenAsClose = ( bExistOpenAsClose || ( nTmpProp0 == TEMP_PROP_OPEN_AS_CLOSE)) ; + } + } + return ( bExistClose && bExistOpenAsClose) ; +} + //---------------------------------------------------------------------------- static bool IsCurveCompoHomogeneous( const ICurveComposite* pCrvCompo, bool& bAllClosed, bool& bAllOpen) @@ -1205,10 +1238,72 @@ GetHomogeneousParts( ICurveComposite* pCrvCompo, const PocketParams& PockParams, return true ; } +//---------------------------------------------------------------------------- +static bool +SetConformalSurfShapedByOpen( const PocketParams& PockParams, ISurfFlatRegion* pSfrChunk, ISurfFlatRegion* pSfrToRemove) +{ + // verifico la validità dei parametri + if ( pSfrChunk == nullptr || ! pSfrChunk->IsValid() || pSfrToRemove == nullptr || ! pSfrToRemove->IsValid()) + return false ; + + // verifico che il controllo sia necessario + if ( ! PockParams.bToolInRegion) + return false ; + + double dOffs = PockParams.dRad + PockParams.dRadialOffset ; + + // scorro i Loop della regione + for ( int nL = 0 ; nL < pSfrChunk->GetLoopCount( 0) ; ++ nL) { + // recupero il Loop corrente + PtrOwner pCompoLoop( ConvertCurveToComposite( pSfrChunk->GetLoop( 0, nL))) ; + if ( IsNull( pCompoLoop) || ! pCompoLoop->IsValid()) + return false ; + // recupero i tratti omogenei di tale loop + ICRVCOMPOPOVECTOR vpCrvs ; + GetHomogeneousParts( pCompoLoop, PockParams, vpCrvs) ; + if ( ssize( vpCrvs) > 1) { + Point3d ptE ; vpCrvs.back()->GetEndPoint( ptE) ; + Point3d ptS ; vpCrvs[0]->GetStartPoint( ptS) ; + if ( AreSamePointApprox( ptS, ptE)) { + vpCrvs[0]->AddCurve( Release( vpCrvs.back()), false) ; + vpCrvs.erase( vpCrvs.end() - 1) ; + } + } + for ( int i = 0 ; i < ssize( vpCrvs) ; ++ i) { + // se tratto formato da aperti da considerare come chiusi + if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_AS_CLOSE) { + // recupero la FatCurve associata all'utensile + PtrOwner pSfrFat( GetSurfFlatRegionFromFatCurve( vpCrvs[i]->Clone(), dOffs - 5. * EPS_SMALL, false, false)) ; + if ( IsNull( pSfrFat) || ! pSfrFat->IsValid()) + return false ; + // I lati della regione corrente vengono impostati come Aperti, in questo modo con l'operazione booleana seguente + // la nuova regione avrà sui nuovi tratti le proprietà di TEMP_PROP_OPEN_EDGE + for ( int nFatC = 0 ; nFatC < pSfrFat->GetChunkCount() ; ++ nFatC) { + for ( int nFatL = 0 ; nFatL < pSfrFat->GetLoopCount( nFatC) ; ++ nFatL) { + for ( int nFatU = 0 ; nFatU < pSfrFat->GetLoopCurveCount( nFatC, nFatL) ; ++ nFatU) + pSfrFat->SetCurveTempProp( nFatC, nFatL, nFatU, TEMP_PROP_OPEN_EDGE, 0) ; + } + } + // tale regione viene sottratta al Chunk corrente e all'effettiva regione da rimuovere + // NB. In questo caso si privilegia il fatto che l'utensile rimanga dentro al bordo corrente + if ( pSfrChunk->IsValid()) { + if ( ! pSfrChunk->Subtract( *pSfrFat)) // le TempProp sui lati vengono mantenute + return false ; + } + if ( pSfrToRemove->IsValid()) { + if ( ! pSfrToRemove->Subtract( *pSfrFat)) // le TempProp sui lati vengono mantenute + return false ; + } + } + } + } + + return true ; +} + //--------------------------------------------------------------------------- static bool -CreateSurfFrIncidence( const ICurveComposite* pCrv, const PocketParams& PockParams, - const double dRad, ISurfFlatRegion* pSfrInc) +CreateSurfFrIncidence( const ICurveComposite* pCrv, const PocketParams& PockParams, const double dRad, ISurfFlatRegion* pSfrInc) { // controllo dei parametri if ( pCrv == nullptr || ! pCrv->IsValid()) @@ -1875,7 +1970,7 @@ AdvanceExtendCurves( ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfr, //---------------------------------------------------------------------------- static bool GetPocketCurvesByClosedEdges( const ISurfFlatRegion* pSfrChunk, const PocketParams& PockParams, - ICRVCOMPOPOVECTOR& vCrvCompoRes, bool& bAllRemoved) + ICRVCOMPOPOVECTOR& vCrvCompoRes, bool& bAllRemoved) { // controllo parametri if ( pSfrChunk == nullptr || ! pSfrChunk->IsValid()) @@ -2090,14 +2185,17 @@ GetPocketCurvesByClosedEdges( const ISurfFlatRegion* pSfrChunk, const PocketPara //---------------------------------------------------------------------------- static bool -GetSinglePocketingCurves( ISurfFlatRegion* pSfr, PocketParams& PockParams, - ICRVCOMPOPOVECTOR& vCrvSingleCurves) +GetSinglePocketingCurves( ISurfFlatRegion* pSfr, PocketParams& PockParams, ICRVCOMPOPOVECTOR& vCrvSingleCurves) { // controllo dei parametri if ( pSfr == nullptr || ! pSfr->IsValid()) return false ; vCrvSingleCurves.clear() ; + // se superficie con lati aperti da considerare me chiusi, per ora non calcolo le curve singole + if ( PockParams.bToolInRegion) + return true ; + // tengo una copia della superficie ( serve per l'estensione dei percorsi fuori dal grezzo) PtrOwner pSfrClone( CloneSurfFlatRegion( pSfr)) ; if ( IsNull( pSfrClone) || ! pSfrClone->IsValid()) @@ -2180,8 +2278,8 @@ ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, PocketParams& PockParams) if ( pSfr == nullptr || ! pSfr->IsValid()) return true ; - // se lati tutti chiusi, allora non devo fare nulla - if ( PockParams.bAllClosed) + // se lati tutti chiusi o se lati aperti da considerare come chiusi, allora non devo fare nulla + if ( PockParams.bAllClosed || PockParams.bToolInRegion) return true ; // NB. Tutti i Loop che presentano dei lati aperti possono essere estesi ; sia per loop esterni che per isole... @@ -4023,6 +4121,9 @@ GetPocketingOptimizedCurves( ISurfFlatRegion* pSfr, PocketParams& PockParam, ICR // se non sono richiesti i casi ottimizzati esco if ( PockParam.bAvoidOpt) return true ; + // se aperti da trattare come chiusi, per ora esco + if ( PockParam.bToolInRegion) + return true ; // scorro i Chunk della superficie int nChunks = pSfr->GetChunkCount() ; @@ -6050,8 +6151,7 @@ CheckIfOffsetIsNecessary( const ISurfFlatRegion* pSfrAct, const ICurveComposite* //---------------------------------------------------------------------------- static bool -IsCompoMadeBy2DifferentHomogeneousParts( const ICurveComposite* pCompo, const PocketParams& PockParams, - bool& bOk, ICRVCOMPOPOVECTOR& vpCrvs) +IsCompoMadeBy2DifferentHomogeneousParts( const ICurveComposite* pCompo, const PocketParams& PockParams, bool& bOk, ICRVCOMPOPOVECTOR& vpCrvs) { // controllo dei parametri if ( pCompo == nullptr || ! pCompo->IsValid()) @@ -6077,7 +6177,7 @@ IsCompoMadeBy2DifferentHomogeneousParts( const ICurveComposite* pCompo, const Po } // controllo che la curva abbia esattamente due tratti omogenei - bOk = ( int( vpCrvs.size()) == 2) ; + bOk = ( ssize( vpCrvs) == 2) ; if ( ! bOk) vpCrvs.clear() ; @@ -8317,12 +8417,11 @@ SmoothLinkByOffs( ICurveComposite* pCrvOffs0, ICurveComposite* pCrvOffs1, ICurve static bool GetConformalLinkForOpenCrv( const ICurveComposite* pCrvOffs0, const ICurveComposite* pCrvOffs1, - const ICRVCOMPOPOVECTOR& vCrvClassBorder, const PocketParams& PockParams, - double dTol, ICurveComposite* pCrvLink) + const ICRVCOMPOPOVECTOR& vCrvClassBorder, const PocketParams& PockParams, double dTol, + ICurveComposite* pCrvLink) { // controllo dei parametri - if ( pCrvOffs0 == nullptr || ! pCrvOffs0->IsValid() || - pCrvOffs1 == nullptr || ! pCrvOffs1->IsValid()) + if ( pCrvOffs0 == nullptr || ! pCrvOffs0->IsValid() || pCrvOffs1 == nullptr || ! pCrvOffs1->IsValid()) return false ; pCrvLink->Clear() ; @@ -8331,8 +8430,7 @@ GetConformalLinkForOpenCrv( const ICurveComposite* pCrvOffs0, const ICurveCompos Point3d ptLinkE ; pCrvOffs1->GetStartPoint( ptLinkE) ; // ricavo i parametri sulla curva di bordo che interessa i due estremi ( 1 sola !) for ( int i = 0 ; i < int( vCrvClassBorder.size()) ; ++ i) { - if ( vCrvClassBorder[i]->IsPointOn( ptLinkS, dTol) && - vCrvClassBorder[i]->IsPointOn( ptLinkE, dTol)) { + if ( vCrvClassBorder[i]->IsPointOn( ptLinkS, dTol) && vCrvClassBorder[i]->IsPointOn( ptLinkE, dTol)) { double dPar0 ; vCrvClassBorder[i]->GetParamAtPoint( ptLinkS, dPar0, dTol) ; double dPar1 ; vCrvClassBorder[i]->GetParamAtPoint( ptLinkE, dPar1, dTol) ; // ricavo le due curve possibili di Link @@ -8368,11 +8466,10 @@ CalcConformalLink( ICurveComposite* pCrvOffs0, ICurveComposite* pCrvOffs1, Pocke const ICRVCOMPOPOVECTOR& vCrvClassBorder, ICurveComposite* pCrvLink) { // controllo validità delle due curve di Offset - if ( pCrvOffs0 == nullptr || ! pCrvOffs0->IsValid() || - pCrvOffs1 == nullptr || ! pCrvOffs1->IsValid()) + if ( pCrvOffs0 == nullptr || ! pCrvOffs0->IsValid() || pCrvOffs1 == nullptr || ! pCrvOffs1->IsValid()) return false ; pCrvLink->Clear() ; - const double TOL = 150 * EPS_SMALL ; + const double TOL = 150. * EPS_SMALL ; // flag per curve di Offset aperte o chiuse bool bOpen0 = ( ! pCrvOffs0->IsClosed()) ; @@ -8389,9 +8486,9 @@ CalcConformalLink( ICurveComposite* pCrvOffs0, ICurveComposite* pCrvOffs1, Pocke } else { // clono le due curve di Offset - PtrOwner pCrvOffs0_cl( CloneCurveComposite( pCrvOffs0)) ; - PtrOwner pCrvOffs1_cl( CloneCurveComposite( pCrvOffs1)) ; - if ( IsNull( pCrvOffs0_cl) || IsNull( pCrvOffs1_cl) || ! pCrvOffs0_cl->IsValid() || ! pCrvOffs1_cl->IsValid()) + PtrOwner pCrvOffs0CL( CloneCurveComposite( pCrvOffs0)) ; + PtrOwner pCrvOffsCL( CloneCurveComposite( pCrvOffs1)) ; + if ( IsNull( pCrvOffs0CL) || IsNull( pCrvOffsCL) || ! pCrvOffs0CL->IsValid() || ! pCrvOffsCL->IsValid()) return false ; // controllo se gli Offset sono stati ricavati alla prima iterazione bool bFirstIterOffs0 = ( pCrvOffs0->GetTempProp( 0) == 0) ; @@ -8430,8 +8527,8 @@ CalcConformalLink( ICurveComposite* pCrvOffs0, ICurveComposite* pCrvOffs1, Pocke ! pCrvLink->IsValid()) { // se curva di Link non valida, cerco una strada più semplice pCrvLink->Clear() ; - pCrvOffs0->CopyFrom( pCrvOffs0_cl) ; - pCrvOffs1->CopyFrom( pCrvOffs1_cl) ; + pCrvOffs0->CopyFrom( pCrvOffs0CL) ; + pCrvOffs1->CopyFrom( pCrvOffsCL) ; // recupero i vettori tangente iniziali ( le curve sono chiuse ) Vector3d vtS, vtE ; Point3d ptS, ptE ; @@ -8485,13 +8582,11 @@ CalcConformalLink( ICurveComposite* pCrvOffs0, ICurveComposite* pCrvOffs1, Pocke //---------------------------------------------------------------------------- static bool -CheckConformalRetractLink( const ICurveComposite* pCrvOffs0, const ICurveComposite* pCrvOffs1, - const ICRVCOMPOPOVECTOR& vCrvClassBorder, const PocketParams& PockParams, - bool& bCalcLink) +CheckConformalRetractLink( const ICurveComposite* pCrvOffs0, const ICurveComposite* pCrvOffs1, const ICRVCOMPOPOVECTOR& vCrvClassBorder, + const PocketParams& PockParams, bool& bCalcLink) { // controllo dei parametri - if ( pCrvOffs0 == nullptr || ! pCrvOffs0->IsValid() || - pCrvOffs1 == nullptr || ! pCrvOffs1->IsValid()) + if ( pCrvOffs0 == nullptr || ! pCrvOffs0->IsValid() || pCrvOffs1 == nullptr || ! pCrvOffs1->IsValid()) return false ; bCalcLink = true ; // di base calcolo il Link @@ -8499,20 +8594,19 @@ CheckConformalRetractLink( const ICurveComposite* pCrvOffs0, const ICurveComposi Point3d ptA ; pCrvOffs0->GetEndPoint( ptA) ; Point3d ptB ; pCrvOffs1->GetStartPoint( ptB) ; // se vicini -> no retroazione - if ( SqDist( ptA, ptB) < 4 * PockParams.dRad * PockParams.dRad + 50 * EPS_SMALL) + if ( SqDist( ptA, ptB) < 4. * PockParams.dRad * PockParams.dRad + 50. * EPS_SMALL) return true ; // se distanti else { // controllo se sono aperte - bool bOpen_i = ( ! pCrvOffs0->IsClosed()) ; - bool bOpen_ii = ( ! pCrvOffs1->IsClosed()) ; + bool bOpen0 = ( ! pCrvOffs0->IsClosed()) ; + bool bOpen1 = ( ! pCrvOffs1->IsClosed()) ; // se entrambe aperte - if ( bOpen_i && bOpen_ii) { + if ( bOpen0 && bOpen1) { // calcolo il collegamento tra le due curve PtrOwner pCrvLink( CreateCurveComposite()) ; if ( IsNull( pCrvLink) || - ! GetConformalLinkForOpenCrv( pCrvOffs0, pCrvOffs1, vCrvClassBorder, PockParams, - 25 * EPS_SMALL, pCrvLink)) + ! GetConformalLinkForOpenCrv( pCrvOffs0, pCrvOffs1, vCrvClassBorder, PockParams, 25. * EPS_SMALL, pCrvLink)) return false ; // se Link valido calcolo la sua lunghezza double dLinkLen = 0. ; @@ -8522,15 +8616,15 @@ CheckConformalRetractLink( const ICurveComposite* pCrvOffs0, const ICurveComposi DistPointCurve DistPtACrv( ptA, *pCrvOffs1) ; double dMyDist ; if ( DistPtACrv.GetSqDist( dMyDist) && - dMyDist < 4 * PockParams.dRad * PockParams.dRad + 50 * EPS_SMALL) { - bCalcLink = ( dLinkLen < 4 * PockParams.dRad) ; + dMyDist < 4. * PockParams.dRad * PockParams.dRad + 50. * EPS_SMALL) { + bCalcLink = ( dLinkLen < 4. * PockParams.dRad) ; return true ; } // minima distanza da ptB DistPointCurve DistPtBCrv( ptB, *pCrvOffs0) ; if ( DistPtBCrv.GetSqDist( dMyDist) && - dMyDist < 4 * PockParams.dRad * PockParams.dRad + 50 * EPS_SMALL) { - bCalcLink = ( dLinkLen < 4 * PockParams.dRad) ; + dMyDist < 4. * PockParams.dRad * PockParams.dRad + 50. * EPS_SMALL) { + bCalcLink = ( dLinkLen < 4. * PockParams.dRad) ; return true ; } } @@ -8723,7 +8817,7 @@ AdjustCloseEdgesForConformalGuide( ICurveComposite* pCrvCompo, const PocketParam // piccolo Offset per la superficie di classificazione PtrOwner pSfrLimit( CloneSurfFlatRegion( &PockParams.SfrLimit)) ; if ( IsNull( pSfrLimit) || ! pSfrLimit->IsValid() || - ! pSfrLimit->Offset( 150 * EPS_SMALL, ICurve::OFF_FILLET)) + ! pSfrLimit->Offset( 150. * EPS_SMALL, ICurve::OFF_FILLET)) return false ; // recupero le parti omogenee della curva @@ -8734,7 +8828,7 @@ AdjustCloseEdgesForConformalGuide( ICurveComposite* pCrvCompo, const PocketParam PtrOwner pCrvFinal( CreateCurveComposite()) ; if ( IsNull( pCrvFinal)) return false ; - for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) { + for ( int i = 0 ; i < ssize( vpCrvs) ; ++ i) { if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) { // nuovo curva PtrOwner pMyCompo( CreateCurveComposite()) ; @@ -8742,7 +8836,7 @@ AdjustCloseEdgesForConformalGuide( ICurveComposite* pCrvCompo, const PocketParam return false ; CRVCVECTOR ccClass ; if ( pSfrLimit->GetCurveClassification( *vpCrvs[i], EPS_SMALL, ccClass)) { - for ( int j = 0 ; j < int( ccClass.size()) ; ++ j) { + for ( int j = 0 ; j < ssize( ccClass) ; ++ j) { // recupero il tratto di curva PtrOwner pMyCurve( ConvertCurveToComposite( vpCrvs[i]->CopyParamRange( ccClass[j].dParS, ccClass[j].dParE))) ; if ( ! IsNull( pMyCurve) && pMyCurve->IsValid()) { @@ -8752,14 +8846,14 @@ AdjustCloseEdgesForConformalGuide( ICurveComposite* pCrvCompo, const PocketParam pMyCurve->SetCurveTempProp( k, TEMP_PROP_CLOSE_EDGE, 0) ; } if ( ! pMyCompo->AddCurve( Release( pMyCurve))) - return true ; // non faccio nulla... + return true ; // non faccio nulla } } } vpCrvs[i].Set( pMyCompo) ; } if ( ! pCrvFinal->AddCurve( Release( vpCrvs[i]))) - return true ; // non faccio nulla... + return true ; // non faccio nulla } if ( pCrvFinal->IsValid()) pCrvCompo->CopyFrom( pCrvFinal) ; @@ -8831,13 +8925,11 @@ ModifyConformalStartPoint( ICurveComposite* pCrvFirst, const PocketParams& PockP //---------------------------------------------------------------------------- static bool -CalcConformalOffsAndLinks( VICRVCOMPOPOVECTOR& vvCrvOffs, const ISurfFlatRegion* pSfrChunk, - const ISurfFlatRegion* pSfrClass, PocketParams& PockParams, ICRVCOMPOPOVECTOR& vCrvOffs, - ICURVEPOVECTOR& vCrvLink) +CalcConformalOffsAndLinks( VICRVCOMPOPOVECTOR& vvCrvOffs, const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pSfrClass, + PocketParams& PockParams, ICRVCOMPOPOVECTOR& vCrvOffs, ICURVEPOVECTOR& vCrvLink) { // controllo dei parametri - if ( pSfrChunk == nullptr || ! pSfrChunk->IsValid() || - pSfrClass == nullptr || ! pSfrClass->IsValid()) + if ( pSfrChunk == nullptr || ! pSfrChunk->IsValid() || pSfrClass == nullptr || ! pSfrClass->IsValid()) return false ; vCrvOffs.clear() ; vCrvLink.clear() ; @@ -8845,8 +8937,8 @@ CalcConformalOffsAndLinks( VICRVCOMPOPOVECTOR& vvCrvOffs, const ISurfFlatRegion* return true ; // rendo attive tutte le curve di Offset mediante prima TmpProp - for ( int i = 0 ; i < int( vvCrvOffs.size()) ; ++ i) { - for ( int j = 0 ; j < int( vvCrvOffs[i].size()) ; ++ j) + for ( int i = 0 ; i < ssize( vvCrvOffs) ; ++ i) { + for ( int j = 0 ; j < ssize( vvCrvOffs[i]) ; ++ j) vvCrvOffs[i][j]->SetTempProp( TEMP_PROP_CURVE_ACTIVE, 0) ; } @@ -8931,7 +9023,7 @@ CalcConformalOffsAndLinks( VICRVCOMPOPOVECTOR& vvCrvOffs, const ISurfFlatRegion* // NB. Il link i-esimo collega l'Offset (i-1)-esimo con l'i-esimo // per definizione il primo Link è nullo vCrvLink.resize( 1) ; - for ( int i = 0 ; i < int( vCrvOffs.size()) - 1 ; ++ i) { + for ( int i = 0 ; i < ssize( vCrvOffs) - 1 ; ++ i) { // controllo se bisogna calcolare il Link tra i due Offset bool bCalcLink = true ; // se Conformal ZigZag @@ -8948,8 +9040,7 @@ CalcConformalOffsAndLinks( VICRVCOMPOPOVECTOR& vvCrvOffs, const ISurfFlatRegion* if ( bCalcLink) { IntersCurveCurve ICC( *vCrvOffs[i], *vCrvOffs[i+1]) ; CRVCVECTOR ccClass ; - bCalcLink = ( ICC.GetCurveClassification( 0, EPS_SMALL, ccClass) && - int( ccClass.size()) == 1) ; + bCalcLink = ( ICC.GetCurveClassification( 0, EPS_SMALL, ccClass) && ssize( ccClass) == 1) ; if ( bCalcLink) { if ( vCrvOffs[i]->GetTempProp( 1) == MDS_LEFT) bCalcLink = ( ccClass[0].nClass == CRVC_IN) ; @@ -8998,7 +9089,6 @@ ExtendConformalOffsAndSetFeed( const ISurfFlatRegion* pSfrPock, const ISurfFlatR // dalla superficie originale, rimuovo le parti definite dai lati chiusi double dOffs = PockParams.dRad + PockParams.dRadialOffset - 2. * EPS_SMALL ; - ICRVCOMPOPOVECTOR vpCrvs ; for ( int nC = 0 ; nC < pSfrPock->GetChunkCount() ; ++ nC) { for ( int nL = 0 ; nL < pSfrPock->GetLoopCount( nC) ; ++ nL) { PtrOwner pCompoLoop( ConvertCurveToComposite( pSfrPock->GetLoop( nC, nL))) ; @@ -9054,30 +9144,33 @@ AddLeadInLeadOutToCurveConformalPaths( const ISurfFlatRegion* pSfrOrig, const IS const PocketParams& PockParams, ICRVCOMPOPOVECTOR& vCrvPaths) { // controllo dei parametri - if ( pSfrOrig == nullptr || ! pSfrOrig->IsValid() || - pSfrPock == nullptr || ! pSfrPock->IsValid()) + if ( pSfrOrig == nullptr || ! pSfrOrig->IsValid() || pSfrPock == nullptr || ! pSfrPock->IsValid()) return false ; for ( int i = 0 ; i < int( vCrvPaths.size()) ; ++ i) { if ( vCrvPaths[i] == nullptr || ! vCrvPaths[i]->IsValid()) return false ; } + // se lati aperti da considerare come chiusi, non estendo i percorsi + if ( PockParams.bToolInRegion) + return true ; + // ricavo le curve aperte della superficie di pocketing ICRVCOMPOPOVECTOR vCrvLoops ; if ( ! GetSfrCrvCompoLoops( pSfrPock, vCrvLoops)) return false ; ICRVCOMPOPOVECTOR vCrvOpenEdge ; - for ( int i = 0 ; i < int( vCrvLoops.size()) ; ++ i) { + for ( int i = 0 ; i < ssize( vCrvLoops) ; ++ i) { ICRVCOMPOPOVECTOR vpCrvs ; GetHomogeneousParts( vCrvLoops[i], PockParams, vpCrvs) ; - for ( int j = 0 ; j < int( vpCrvs.size()) ; ++ j) { + for ( int j = 0 ; j < ssize( vpCrvs) ; ++ j) { if ( vpCrvs[j]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) vCrvOpenEdge.emplace_back( Release( vpCrvs[j])) ; } } // scorro i percorsi ricavati - for ( int i = 0 ; i < int( vCrvPaths.size()) ; ++ i) { + for ( int i = 0 ; i < ssize( vCrvPaths) ; ++ i) { // recupero il punto iniziale del percorso Point3d ptStart ; vCrvPaths[i]->GetStartPoint( ptStart) ; // se il punto inziale è interno alla superficie originaria @@ -9089,7 +9182,7 @@ AddLeadInLeadOutToCurveConformalPaths( const ISurfFlatRegion* pSfrOrig, const IS return false ; double dSqLenMin = INFINITO ; // ricavo il punto più vicino alle curve aperte della superficie di classificazione - for ( int j = 0 ; j < int( vCrvOpenEdge.size()) ; ++ j) { + for ( int j = 0 ; j < ssize( vCrvOpenEdge) ; ++ j) { DistPointCurve DistPtCrv( ptStart, *vCrvOpenEdge[j]) ; Point3d ptMinDist ; int nFlag ; @@ -9114,7 +9207,7 @@ AddLeadInLeadOutToCurveConformalPaths( const ISurfFlatRegion* pSfrOrig, const IS return false ; // controllo distanza segmento CRVCVECTOR ccClass ; - bSafe = ( pSfrLimit->GetCurveClassification( *pSeg, 25 * EPS_SMALL, ccClass) && + bSafe = ( pSfrLimit->GetCurveClassification( *pSeg, 25. * EPS_SMALL, ccClass) && int( ccClass.size()) == 1 && ccClass[0].nClass == CRVC_OUT) ; } if ( bSafe && dSqSegLen < dSqLenMin) { @@ -9125,7 +9218,7 @@ AddLeadInLeadOutToCurveConformalPaths( const ISurfFlatRegion* pSfrOrig, const IS } // se segmento trovato, lo aggiungo alla curva if ( pSeg->IsValid()) { - if ( ! vCrvPaths[i]->AddCurve( Release( pSeg), false, 25 * EPS_SMALL)) + if ( ! vCrvPaths[i]->AddCurve( Release( pSeg), false, 25. * EPS_SMALL)) return false ; vCrvPaths[i]->SetCurveTempParam( 0, GetMinFeed( PockParams), 0) ; } @@ -9161,8 +9254,7 @@ OrderAndExtendConformalPaths( ICRVCOMPOPOVECTOR& vCrvPaths, const ISurfFlatRegio PocketParams& PockParams) { // controllo dei parametri - if ( pSfrChunk == nullptr || ! pSfrChunk->IsValid() || - pSfrOrig == nullptr || ! pSfrOrig->IsValid()) + if ( pSfrChunk == nullptr || ! pSfrChunk->IsValid() || pSfrOrig == nullptr || ! pSfrOrig->IsValid()) return false ; // superficie di controllo per parti isolate @@ -9170,7 +9262,7 @@ OrderAndExtendConformalPaths( ICRVCOMPOPOVECTOR& vCrvPaths, const ISurfFlatRegio if ( IsNull( pSfrToRemove) || ! pSfrToRemove->IsValid() || ! pSfrToRemove->Intersect( *pSfrOrig)) { // riprovo con una leggera tolleranza - pSfrToRemove->Offset( - 10 * EPS_SMALL, ICurve::OFF_FILLET) ; + pSfrToRemove->Offset( - 10. * EPS_SMALL, ICurve::OFF_FILLET) ; if ( ! pSfrToRemove->Intersect( *pSfrOrig)) return false ; } @@ -9192,7 +9284,7 @@ OrderAndExtendConformalPaths( ICRVCOMPOPOVECTOR& vCrvPaths, const ISurfFlatRegio for ( int i = 0 ; i < int( vInds.size()) ; ++ i) { int j = 0 ; INTVECTOR vTempInds ; - for ( ; j < int( vCrvPaths.size()) ; ++ j) { + for ( ; j < ssize( vCrvPaths) ; ++ j) { // se indice già presente if ( find( vInds.begin(), vInds.end(), j) != vInds.end()) continue ; @@ -9208,7 +9300,7 @@ OrderAndExtendConformalPaths( ICRVCOMPOPOVECTOR& vCrvPaths, const ISurfFlatRegio } // 1) se non ho trovato curve candidate, prendo l'indice disponibile più basso if ( vTempInds.empty()) { - for ( int k = 0 ; k < int( vInds.size()) ; ++ k) { + for ( int k = 0 ; k < ssize( vInds) ; ++ k) { if ( find( vInds.begin(), vInds.end(), k) != vInds.end()) continue ; vInds[i] = k ; @@ -9216,14 +9308,14 @@ OrderAndExtendConformalPaths( ICRVCOMPOPOVECTOR& vCrvPaths, const ISurfFlatRegio } } // 2) se la candidata è singola, allora è lei - else if ( int( vTempInds.size()) == 1) + else if ( ssize( vTempInds) == 1) vInds[i] = vTempInds[0] ; // 3) se trovate più curve, allora effettuo algoritmi euristici else { // 3.1) cerco la curva che effettua meno overlap con la regione da limite double dMinLen = INFINITO ; double dMinArea = INFINITO ; - for ( int k = 0 ; k < int( vTempInds.size()) ; ++ k) { + for ( int k = 0 ; k < ssize( vTempInds) ; ++ k) { // privilegio le aperte if ( vCrvPaths[vTempInds[k]]->IsClosed()) continue ; @@ -9269,12 +9361,11 @@ OrderAndExtendConformalPaths( ICRVCOMPOPOVECTOR& vCrvPaths, const ISurfFlatRegio vCrvExtBorder[j].nIndex = vTempInds[j] ; vCrvExtBorder[j].nBorders = 0 ; } - for ( int j = 0 ; j < int( vCrvExtBorder.size()) - 1 ; ++ j) { - for ( int k = j + 1 ; k < int( vCrvExtBorder.size()) ; ++ k) { + for ( int j = 0 ; j < ssize( vCrvExtBorder) - 1 ; ++ j) { + for ( int k = j + 1 ; k < ssize( vCrvExtBorder) ; ++ k) { IntersCurveCurve ICC( *vCrvExtBorder[j].pCrvExtLoop, *vCrvExtBorder[k].pCrvExtLoop) ; CRVCVECTOR ccClass ; - if ( ICC.GetCurveClassification( 0, EPS_SMALL, ccClass) && - int( ccClass.size()) == 1) { + if ( ICC.GetCurveClassification( 0, EPS_SMALL, ccClass) && ssize( ccClass) == 1) { // se i-esima interna a j-esima if ( ccClass[0].nClass == CRVC_IN) ++ vCrvExtBorder[k].nBorders ; @@ -9294,7 +9385,7 @@ OrderAndExtendConformalPaths( ICRVCOMPOPOVECTOR& vCrvPaths, const ISurfFlatRegio } // cerco solo tra le chiuse se non ho aperte if ( dMinLen > INFINITO - 1) { - for ( int k = 0 ; k < int( vTempInds.size()) ; ++ k) { + for ( int k = 0 ; k < ssize( vTempInds) ; ++ k) { if ( vCrvPaths[vTempInds[k]]->IsClosed()) { double dLen ; vCrvPaths[vTempInds[k]]->GetLength( dLen) ; if ( dLen < dMinLen) { @@ -9490,12 +9581,11 @@ ExtendGuideByIteration( ICurveComposite* pCompoTempGuide, const ICurveComposite* //---------------------------------------------------------------------------- static bool -CalcConformalGuide( const ICurveComposite* pCrvCloseEdge, const ICurveComposite* pCrvOpenEdge, - const PocketParams& PockParams, ICurveComposite* pCrvGuide) +CalcConformalGuide( const ICurveComposite* pCrvCloseEdge, const ICurveComposite* pCrvOpenEdge, const PocketParams& PockParams, + ICurveComposite* pCrvGuide) { // controllo dei parametri - if ( pCrvCloseEdge == nullptr || ! pCrvCloseEdge->IsValid() || - pCrvOpenEdge == nullptr || ! pCrvOpenEdge->IsValid()) + if ( pCrvCloseEdge == nullptr || ! pCrvCloseEdge->IsValid() || pCrvOpenEdge == nullptr || ! pCrvOpenEdge->IsValid()) return false ; pCrvGuide->Clear() ; @@ -9546,8 +9636,8 @@ CalcConformalGuide( const ICurveComposite* pCrvCloseEdge, const ICurveComposite* } } - // le due estensioni vanno tagliate presso i bordi dei lati aperti estesi; rischierei di non - // riuscire a passare presso dei lati aperti vicini ai tratti lineari di estensione + // le due estensioni vanno tagliate presso i bordi dei lati aperti estesi; rischierei di non riuscire a passare presso dei + // lati aperti vicini ai tratti lineari di estensione IntersCurveCurve ICCLS( *pLineStart, *pCrvOP) ; if ( ICCLS.GetIntersCount() > 0) { IntCrvCrvInfo aInfo ; @@ -9637,28 +9727,21 @@ CombineClosedEdgesForConformalOffsets( const ISurfFlatRegion* pSfrChunk, const P //---------------------------------------------------------------------------- static bool -GetConformalOffsets( const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pSfrClass, - const ISurfFlatRegion* pSfrOrig, const PocketParams& PockParam, - VICRVCOMPOPOVECTOR& vCrvOffs) +GetConformalOffsets( const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pSfrClass, const ISurfFlatRegion* pSfrOrig, + const PocketParams& PockParam, VICRVCOMPOPOVECTOR& vCrvOffs) { // controllo dei parametri - if ( pSfrClass == nullptr || ! pSfrClass->IsValid() || - pSfrChunk == nullptr || ! pSfrChunk->IsValid()) + if ( pSfrClass == nullptr || ! pSfrClass->IsValid() || pSfrChunk == nullptr || ! pSfrChunk->IsValid()) return false ; vCrvOffs.clear() ; - /* NB - vCrvOffs è un vettore di vettori di curve composite. Per ogni Offset progressivo i-esimo - vengono salvate tutte le parti interne j-esime alla pSfrClass. - ( la posizione del vettore ICRVCOMPOPOVECTOR in VICRVCOMPOPOVECTOR è il numero di iterazione - progressiva di Offset) - */ + // NB. vCrvOffs è un vettore di vettori di curve composite. Per ogni Offset progressivo i-esimo vengono salvate tutte le parti interne + // j-esime alla pSfrClass. la posizione del vettore ICRVCOMPOPOVECTOR in VICRVCOMPOPOVECTOR è il numero di iterazione progressiva di Offset - /* controllo se il chunk è svuotabile con lavorazione conformal - Sono previsti due casi di lavorazioni conformal : - 1) Non esistono Isole e il bordo esterno è formato da due tratti disomogenei - 2) Esistono solo Isole chiuse e il bordo esterno è tutto aperto - */ + // Controllo se il chunk è svuotabile con lavorazione conformal + // Sono previsti due casi di lavorazioni conformal : + // 1) Non esistono Isole e il bordo esterno è formato da due tratti disomogenei + // 2) Esistono solo Isole chiuse e il bordo esterno è tutto aperto bool bOk = false ; ICRVCOMPOPOVECTOR vCrvCloseEdges ; // tratti chiusi da cui calcolare gli Offset @@ -9691,15 +9774,14 @@ GetConformalOffsets( const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pS if ( ! CombineClosedEdgesForConformalOffsets( pSfrChunk, PockParam, bOk, vCrvCloseEdges)) return false ; if ( ! bOk) - return true ; // sarà in SpiralIn/Out... + return true ; // sarà in SpiralIn/Out } } - /* Calcolo degli Offsets */ - // Oggetto Voronoi per curve chiuse + // Calcolo degli Offsets, Oggetto Voronoi per curve chiuse Voronoi myVRONI ; - for ( int i = 0 ; i < int( vCrvCloseEdges.size()) ; ++ i) { - vCrvCloseEdges[i]->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ; + for ( int i = 0 ; i < ssize( vCrvCloseEdges) ; ++ i) { + vCrvCloseEdges[i]->MergeCurves( 10. * EPS_SMALL, 10. * EPS_ANG_SMALL) ; myVRONI.AddCurve( vCrvCloseEdges[i]) ; } @@ -9710,7 +9792,7 @@ GetConformalOffsets( const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pS if ( PockParam.SfrLimit.IsValid()) { if ( ! pSfrLimit.Set( PockParam.SfrLimit.Clone()) || ! pSfrLimit->IsValid() || - ! pSfrLimit->Offset( PockParam.dRad + PockParam.dRadialOffset - 5 * EPS_SMALL, ICurve::OFF_FILLET)) + ! pSfrLimit->Offset( PockParam.dRad + PockParam.dRadialOffset - 5. * EPS_SMALL, ICurve::OFF_FILLET)) return false ; } @@ -9721,8 +9803,7 @@ GetConformalOffsets( const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pS if ( IsNull( pSfrToRemove) || ! pSfrToRemove->IsValid()) return false ; while ( nIter < MAX_ITER) { - // determino se le curve vanno invertite o meno - // essendo FatCurve, la parte interna alla regione di classificazione è invertita + // determino se le curve vanno invertite o meno; essendo FatCurve, la parte interna alla regione di classificazione è invertita bool bInvert = false ; if ( PockParam.nType == POCKET_CONFORMAL_ZIGZAG) bInvert = ! ( ( ! IsEven( nIter) && ! PockParam.bInvert) || ( IsEven( nIter) && PockParam.bInvert)) ; @@ -9736,23 +9817,23 @@ GetConformalOffsets( const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pS ICRVCOMPOPOVECTOR vCrvOffsInside ; // per tutte le curve ottenute, tengo solo per le parti interne alla regione di classificazione bool bStop = true ; - for ( int j = 0 ; j < int( vFatCrv.size()) ; ++ j) { + for ( int j = 0 ; j < ssize( vFatCrv) ; ++ j) { CRVCVECTOR ccClass ; if ( ! pSfrClass->GetCurveClassification( *vFatCrv[j], EPS_SMALL, ccClass)) return false ; - for ( int k = 0 ; k < int( ccClass.size()) ; ++ k) { - if ( ccClass[k].nClass == CRVC_IN) { + for ( int nClass = 0 ; nClass < int( ccClass.size()) ; ++ nClass) { + if ( ccClass[nClass].nClass == CRVC_IN) { // recupero il tratto di curva - PtrOwner pMyCrv( vFatCrv[j]->CopyParamRange( ccClass[k].dParS, ccClass[k].dParE)) ; + PtrOwner pMyCrv( vFatCrv[j]->CopyParamRange( ccClass[nClass].dParS, ccClass[nClass].dParE)) ; if ( ! IsNull( pMyCrv) && pMyCrv->IsValid()) { if ( ! IsNull( pSfrLimit) && pSfrLimit->IsValid()) { - // controllo che tale tratto sia esterno alla regione di incidenza + // controllo che tale tratto sia esterno alla regione limite CRVCVECTOR ccClass1 ; if ( ! pSfrLimit->GetCurveClassification( *pMyCrv, EPS_SMALL, ccClass1)) return false ; - for ( int kk = 0 ; kk < int( ccClass1.size()) ; ++ kk) { - if ( ccClass1[kk].nClass != CRVC_IN) { - PtrOwner pMyCrv1( pMyCrv->CopyParamRange( ccClass1[kk].dParS, ccClass1[kk].dParE)) ; + for ( int nClass1 = 0 ; nClass1 < ssize( ccClass1) ; ++ nClass1) { + if ( ccClass1[nClass1].nClass != CRVC_IN) { + PtrOwner pMyCrv1( pMyCrv->CopyParamRange( ccClass1[nClass1].dParS, ccClass1[nClass1].dParE)) ; if ( ! IsNull( pMyCrv1) && pMyCrv1->IsValid()) { // almeno una curva in trovata bStop = false ; @@ -9782,12 +9863,12 @@ GetConformalOffsets( const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pS } } } - // concateno se necessario ( per tolleranza Offset) + // concateno se necessario (per tolleranza Offset non è detto che le curve siano tutte unite) int nTempProp0 = ( ! vCrvOffsInside.empty() ? vCrvOffsInside[0]->GetTempProp( 0) : TEMP_PROP_INVALID) ; int nTempProp1 = ( ! vCrvOffsInside.empty() ? vCrvOffsInside[0]->GetTempProp( 1) : TEMP_PROP_INVALID) ; if ( ! ChainCompoCurves( vCrvOffsInside)) return false ; - for ( auto& CrvCompo : vCrvOffsInside) { + for ( PtrOwner& CrvCompo : vCrvOffsInside) { CrvCompo->SetTempProp( nTempProp0, 0) ; CrvCompo->SetTempProp( nTempProp1, 1) ; } @@ -9795,8 +9876,8 @@ GetConformalOffsets( const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pS if ( ! bStop) { // inserisco le curva ricavate all'iterazione nIter nel vettore vCrvOffs.resize( ++ nIter) ; // incremento nIter - for ( int i = 0 ; i < int( vCrvOffsInside.size()) ; ++ i) { - vCrvOffsInside[i]->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ; + for ( int i = 0 ; i < ssize( vCrvOffsInside) ; ++ i) { + vCrvOffsInside[i]->MergeCurves( 10. * EPS_SMALL, 10. * EPS_ANG_SMALL) ; // recupero la regione rimossa da tale curva PtrOwner pSfrFatCurve( GetSurfFlatRegionFromFatCurve( vCrvOffsInside[i]->Clone(), PockParam.dRad, false, false)) ; if ( IsNull( pSfrFatCurve) || ! pSfrFatCurve->IsValid()) @@ -9832,8 +9913,8 @@ GetConformalOffsets( const ISurfFlatRegion* pSfrChunk, const ISurfFlatRegion* pS } // smusso le curve di Offset ( ad eccezione di quelle generate alla prima iterazione) - for ( int i = 1 ; i < int( vCrvOffs.size()) ; ++ i) { - for ( int j = 0 ; j < int( vCrvOffs[i].size()) ; ++ j) + for ( int i = 1 ; i < ssize( vCrvOffs) ; ++ i) { + for ( int j = 0 ; j < ssize( vCrvOffs[i]) ; ++ j) ModifyCurveToSmoothed( vCrvOffs[i][j], PockParam, PockParam.dSmooth, PockParam.dSmooth, false) ; } @@ -9929,12 +10010,10 @@ CreateSurfFromOtherChunks( ISurfFlatRegion* pSfr, const ISurfFlatRegion* pSfrOth //---------------------------------------------------------------------------- static bool -AddConformal( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, - PocketParams& PockParams, ICRVCOMPOPOVECTOR& vCrvCompoRes) +AddConformal( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, PocketParams& PockParams, ICRVCOMPOPOVECTOR& vCrvCompoRes) { // controllo dei parametri - if ( pSfrPock == nullptr || ! pSfrPock->IsValid() || - pSfrOrig == nullptr || ! pSfrOrig->IsValid()) + if ( pSfrPock == nullptr || ! pSfrPock->IsValid() || pSfrOrig == nullptr || ! pSfrOrig->IsValid()) return true ; // se superifice tutta aperta, lavoro in SPIRAL_IN @@ -9952,8 +10031,8 @@ AddConformal( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, // NB. La supercicie pSfrPock è estesa presso i lati aperti, quindi il suo numero di Chunk potrebbe // essere differente dal numero di Chunk della superficie originale di svuotatura. Tengo un insieme di // di indici dei Chunk che devono essere lavorati in SpiralIn e in SpiralOut - set setIndChunkSpiralIn ; - set setIndChunkSpiralOut ; + INTSET setIndChunkSpiralIn ; + INTSET setIndChunkSpiralOut ; // scorro i chunk della superficie da lavorare for ( int nC = 0 ; nC < pSfrPock->GetChunkCount() ; ++ nC) { @@ -9979,14 +10058,32 @@ AddConformal( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, if ( ! GetOrigChunkForConformal( pSfrChunk, pSfrOrig, setIndChunkSpiralOut)) continue ; } + + // definisco la superficie da rimuovere + PtrOwner pSfrToRemove( CloneSurfFlatRegion( pSfrOrig)) ; + if ( IsNull( pSfrToRemove) || ! pSfrToRemove->IsValid()) + return false ; + PtrOwner pSfrClass( nullptr) ; + if ( PockParams.bToolInRegion) { + if ( ! pSfrClass.Set( CloneSurfFlatRegion( pSfrPock))) + return false ; + } + + // --- se superficie con lati aperti da considerare come chiusi, aggiorno i lati della superficie + if ( PockParams.bToolInRegion) { + // modifico la forma della superficie in modo da rimanere sempre all'interno della regione originale + if ( ! SetConformalSurfShapedByOpen( PockParams, pSfrChunk, pSfrToRemove)) + return false ; + } + // --- se chunk non omogoneo, ricavo gli Offset ( se possibili) dei tratti chiusi del Chunk VICRVCOMPOPOVECTOR vvCrvOffs ; - if ( ! GetConformalOffsets( pSfrChunk, pSfrChunk, pSfrOrig, PockParams, vvCrvOffs)) + if ( ! GetConformalOffsets( pSfrChunk, pSfrChunk, pSfrToRemove, PockParams, vvCrvOffs)) return false ; // se non ottengo Curve di Offset, lavoro in SpiralIn ( il Chunk ha dei lati aperti) if ( vvCrvOffs.empty()) { - if ( ! GetOrigChunkForConformal( pSfrChunk, pSfrOrig, setIndChunkSpiralIn)) + if ( ! GetOrigChunkForConformal( pSfrChunk, pSfrToRemove, setIndChunkSpiralIn)) return false ; continue ; } @@ -9994,8 +10091,9 @@ AddConformal( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, // definisco i vettori ordinati degli Offset e dei Link ICRVCOMPOPOVECTOR vCrvOffs ; ICURVEPOVECTOR vCrvLink ; - if ( ! CalcConformalOffsAndLinks( vvCrvOffs, pSfrChunk, pSfrPock, PockParams, vCrvOffs, vCrvLink)) { - if ( ! GetOrigChunkForConformal( pSfrChunk, pSfrOrig, setIndChunkSpiralIn)) + if ( ! CalcConformalOffsAndLinks( vvCrvOffs, pSfrChunk, ( ! PockParams.bToolInRegion ? pSfrPock : pSfrToRemove), + PockParams, vCrvOffs, vCrvLink)) { + if ( ! GetOrigChunkForConformal( pSfrChunk, pSfrToRemove, setIndChunkSpiralIn)) return false ; continue ; } @@ -10003,21 +10101,21 @@ AddConformal( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, // flag per controllo bool bOk = true ; // estendo i percorsi per eventuali regioni non svuotate e calcolo le Feed - bOk = bOk && ExtendConformalOffsAndSetFeed( pSfrPock, pSfrOrig, PockParams, vCrvOffs, vCrvLink) ; + bOk = bOk && ExtendConformalOffsAndSetFeed( pSfrPock, pSfrToRemove, PockParams, vCrvOffs, vCrvLink) ; // concateno Offset e Links ICRVCOMPOPOVECTOR vCrvPaths ; bOk = bOk && ChainConformalOffsWithLinks( vCrvOffs, vCrvLink, vCrvPaths) ; // estendo per lati aperti ed ordino i percorsi trovati - bOk = bOk && OrderAndExtendConformalPaths( vCrvPaths, pSfrChunk, pSfrOrig, PockParams) ; + bOk = bOk && OrderAndExtendConformalPaths( vCrvPaths, pSfrChunk, pSfrToRemove, PockParams) ; // se qualche passaggio restituisce errore, provo in SpiralIn if ( ! bOk) { - if ( ! GetOrigChunkForConformal( pSfrChunk, pSfrOrig, setIndChunkSpiralIn)) + if ( ! GetOrigChunkForConformal( pSfrChunk, pSfrToRemove, setIndChunkSpiralIn)) return false ; continue ; } // altrimenti aggiungo i percorsi ricavati - for ( int i = 0 ; i < int( vCrvPaths.size()) ; ++ i) + for ( int i = 0 ; i < ssize( vCrvPaths) ; ++ i) vCrvCompoRes.emplace_back( Release( vCrvPaths[i])) ; } @@ -10032,7 +10130,7 @@ AddConformal( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, ICRVCOMPOPOVECTOR vCrvSpiralIn ; if ( ! CalcSpiralPocketing( pSfrSpiralIn, POCKET_SPIRALIN, PockParams, vCrvSpiralIn)) return false ; - for ( int i = 0 ; i < int( vCrvSpiralIn.size()) ; ++ i) { + for ( int i = 0 ; i < ssize( vCrvSpiralIn) ; ++ i) { if ( vCrvSpiralIn[i] != nullptr && vCrvSpiralIn[i]->IsValid()) vCrvCompoRes.emplace_back( Release( vCrvSpiralIn[i])) ; } @@ -10261,6 +10359,9 @@ CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double // controllo se la superficie è tutta chiusa o tutta aperta if ( ! IsSfrAllHomogeneous( pSfr, myParams.bAllClosed, myParams.bAllOpen)) return false ; + // controllo se la superficie corrente presenta lati aperti da considerare come chiusi + if ( ! myParams.bAllOpen && ! myParams.bAllClosed) + myParams.bToolInRegion = IsToolInRegion( pSfr, myParams.nType) ; // Se richiesti contorni tengo una copia della supericie attuale ( le funzioni sotto potrebbero rimuoverne dei Chunks) PtrOwner pSfrContour( nullptr) ;