diff --git a/SurfRoughing.cpp b/SurfRoughing.cpp index ae7771c..6077566 100644 --- a/SurfRoughing.cpp +++ b/SurfRoughing.cpp @@ -35,14 +35,12 @@ #include "/EgtDev/Include/EGkStringUtils3d.h" #include "/EgtDev/Include/EGkUserObjFactory.h" #include "/EgtDev/Include/EGnStringKeyVal.h" -#include "/EgtDev/Include/EgtPointerOwner.h" #include "/EgtDev/Include/EGkDistPointCurve.h" #include "/EgtDev/Include/EGkDistPointSurfFr.h" #include "/EgtDev/Include/EGkCurveAux.h" #include "/EgtDev/Include/EGkDistPointSurfTm.h" #include "/EgtDev/Include/EGkIntersPlaneSurfTm.h" #include "/EgtDev/Include/EGkStmFromCurves.h" -#include "/EgtDev/Include/EXeExecutor.h" // per far dimenticare macro di WinUser.h #undef GetClassName @@ -80,6 +78,7 @@ using namespace std ; // 3029 = "Error in SurfRoughing : Error in Classifying border" // 3029 = "Error in SurfRoughing : Simplify Chunks for SubSteps failed" // 3030 = "Error in SurfRoughing : Conformal ZigZag not valid at step (xx)" +// 3131 = "Error in SurfRoughing : LeadIn with Mill NoTip in material" // 3051 = "Warning in SurfRoughing : Skipped entity (xx)" // 3052 = "Warning in SurfRoughing : No machinable path" // 3053 = "Warning in SurfRoughing : Tool name changed (xx)" @@ -1244,8 +1243,19 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId) } // inizializzo la classe di intersezione tra grezzo e piani paralleli ( quelli di lavoro) + // traslo leggermente il grezzo per gestire il primo e l'ultimo Step + pStmRaw->Translate( - vtTool * 5 * EPS_SMALL) ; IntersParPlanesSurfTm IPPStm( fr_pCompo, *pStmRaw) ; + // costruisco una superficie di estrusione della curva (devo determinare parte della regione limite) + Vector3d vtLimitExtr = - vtTool * 1.5 * max( b3Raw.GetDimX(), max( b3Raw.GetDimY(), b3Raw.GetDimZ())) ; + PtrOwner pStmLimit( GetStmOutSideCompo( pCompo, pStmRaw, vtLimitExtr)) ; + if ( IsNull( pStmLimit)) + return false ; + + // inizializzo la classe di intersezione tra la superficie trimesh limite e piani paralleli ( quelli di lavoro) + IntersParPlanesSurfTm IPPStm1( fr_pCompo, *pStmLimit) ; + // inizializzo la classe di calcolo delle silhouette nei piani come sopra SURFLOCALVECTOR vSurfL ; vSurfL.reserve( vSurfId.size()) ; CISURFTMPVECTOR vpStm ; vpStm.reserve( vSurfId.size()) ; @@ -1381,6 +1391,18 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId) else continue ; // step fuori dal grezzo, passo al successivo + /* ***************** Regione piana esterna a pCompo ****************** */ + PtrOwner pSfrOutCompo( CreateSurfFlatRegion()) ; + if ( IsNull( pSfrOutCompo)) + return false ; + if ( pStmLimit->IsValid() && pStmLimit->GetTriangleCount() > 0) { + pSfrOutCompo.Set( GetSfrByStmIntersection( IPPStm1, it->dDepth + GetOffsL(), 0)) ; + if ( IsNull( pSfrRaw)) { + m_pMchMgr->SetLastError( 3027, "Error in SurfRoughing : Slicing Raw failed") ; + return false ; + } + } + /* *************************** Silhouette **************************** */ // determino la regione da non lavorare e la sottraggo POLYLINEVECTOR vPL ; @@ -1388,7 +1410,6 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId) m_pMchMgr->SetLastError( 3024, "Error in SurfRoughing : region not computable") ; return false ; } - // creo la regione piana dalle PolyLine ricavate dalla Silhouette SurfFlatRegionByContours SfrMaker ; for ( auto& PL : vPL) { @@ -1481,12 +1502,6 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId) it->pSfrRemoved = nullptr ; continue ; } - // estendo la superficie di riferimento considerando le sottocurve chiuse della - // curva di sgrossatura - if ( ! ModifySurfRefForOpenCloseEdges( pSfrOpenClose, pCompoPocket)) { - m_pMchMgr->SetLastError( 3026, "Error in SurfRoughing : Detecting open edges failed") ; - return false ; - } } // determino i lati aperti ( mediante vicinanza dei tratti di curva al volume progressivo non svuotato) @@ -1526,10 +1541,21 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId) m_pGeomDB->SetMaterial( nNew_SfrPock_Id, GREEN) ; m_pGeomDB->SetName( nNew_SfrPock_Id, KEY_SURF_POCK + ToString( nPocket)) ; - // nel gruppo temporaneo salvo anche la Shilouette ( per superficie Limite) + // nel gruppo temporaneo salvo anche la superficie Limite) int nNew_SfrLimit_Id = GDB_ID_NULL ; + PtrOwner pSfrLimit( CreateSurfFlatRegion()) ; + if ( IsNull( pSfrLimit)) + return false ; + if ( ! IsNull( pSfrOutCompo) && pSfrOutCompo->IsValid()) + pSfrLimit.Set( pSfrOutCompo) ; if ( ! IsNull( pSfrSil) && pSfrSil->IsValid()) { - nNew_SfrLimit_Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nTempId, Release( pSfrSil)) ; + if ( ! IsNull( pSfrLimit) && pSfrLimit->IsValid()) + pSfrLimit->Add( *pSfrSil) ; + else + pSfrLimit.Set( pSfrSil) ; + } + if ( ! IsNull( pSfrLimit) && pSfrLimit->IsValid()) { + nNew_SfrLimit_Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nTempId, Release( pSfrLimit)) ; if ( nNew_SfrLimit_Id == GDB_ID_NULL) { m_pMchMgr->SetLastError( 3024, "Error in SurfRoughing : region not computable") ; return false ; @@ -1614,6 +1640,62 @@ SurfRoughing::GetRaw( void) const return ( ( pStmRaw->IsValid() && pStmRaw->GetTriangleCount() > 0) ? Release( pStmRaw) : nullptr) ; } +//---------------------------------------------------------------------------- +ISurfTriMesh* +SurfRoughing::GetStmOutSideCompo( ICurveComposite* pCompo, const ISurfTriMesh* pStmRaw, const Vector3d& vtExtr) const +{ + // controllo dei parametri + if ( pCompo == nullptr || ! pCompo->IsValid() || + pStmRaw == nullptr || ! pStmRaw->IsValid()) + return nullptr ; + + // recupero la PolyLine dalla curva + PolyLine PL ; + pCompo->ApproxWithLines( 10 * EPS_SMALL, 15, ICurve::APL_STD, PL) ; + + // determino la superficie di estrusione + PtrOwner pStmExtr( CreateSurfTriMesh()) ; + bool bOk = ( ! IsNull( pStmExtr)) ; + bOk = bOk && pStmExtr->AdjustTopology() ; + bOk = bOk && pStmExtr->CreateByExtrusion( PL, vtExtr) ; + bOk = bOk && ( pStmExtr->IsValid() && pStmExtr->GetTriangleCount() > 0) ; + if ( ! bOk) + return nullptr ; + // aggiungo i caps + PtrOwner pStmCap0( CreateSurfTriMesh()) ; + bOk = ( ! IsNull( pStmCap0)) ; + bOk = bOk && pStmCap0->CreateByFlatContour( PL) ; + bOk = bOk && ( pStmCap0->IsValid() && pStmCap0->GetTriangleCount() > 0) ; + if ( ! bOk) + return nullptr ; + Vector3d vtN ; pStmCap0->GetFacetNormal( 0, vtN) ; + Vector3d vtN_ref = vtExtr ; vtN_ref.Normalize() ; + if ( AreOppositeVectorApprox( vtN, vtN_ref)) + pStmCap0->Invert() ; + PtrOwner pStmCap1( CloneSurfTriMesh( pStmCap0)) ; + bOk = ( ! IsNull( pStmCap1) && pStmCap1->IsValid() && pStmCap1->GetTriangleCount() > 0) ; + bOk = bOk && ( pStmCap1->Translate( vtExtr) && pStmCap1->Invert()) ; + bOk = bOk && pStmExtr->DoSewing( *pStmCap0) ; + bOk = bOk && pStmExtr->DoSewing( *pStmCap1) ; + if ( ! bOk) + return nullptr ; + + // la superficie deeve definire un volume + double dVol = 0. ; pStmExtr->GetVolume( dVol) ; + if ( dVol < EPS_ZERO) + pStmExtr->Invert() ; + + // sottraggo al grezzo la regione di estrusione + PtrOwner pStmLimit( CloneSurfTriMesh( pStmRaw)) ; + bOk = ! IsNull( pStmLimit) ; + bOk = bOk && pStmLimit->IsValid() ; + bOk = bOk && pStmLimit->Subtract( *pStmExtr) ; + if ( ! bOk) + return nullptr ; + + return Release( pStmLimit) ; +} + //---------------------------------------------------------------------------- ISurfFlatRegion* SurfRoughing::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs) const @@ -1746,14 +1828,14 @@ SurfRoughing::GetActiveSurfaces( INTVECTOR& vSurfId) const //---------------------------------------------------------------------------- bool SurfRoughing::CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& vCrvPocketCompo, - STEPINFOVECTOR& vStepInfo) const + STEPINFOSRVECTOR& vStepInfo) const { /* funzione per calcolo dei percorsi di Pockets e delle loro proprietà */ // inizializzo vettore dei percorsi - vStepInfo.clear() ; vStepInfo.resize( int( vPocket.size())) ; + vStepInfo.resize( vPocket.size()) ; // punto finale di riferimento per il percorso attuale ( serve per trovare il punto iniziale // del percorso successivo) @@ -1857,15 +1939,11 @@ SurfRoughing::CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& v vStepInfo[nInd].vPaths[i].bOutStart = ( vCrvPaths[i]->GetCurveCount() > 0 && vCrvPaths[i]->GetFirstCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ; - // controllo se il punto di ingresso è valido - bool bValidOutLeadIn = true ; - if ( vStepInfo[nInd].vPaths[i].bOutStart) { - if ( ! VerifyLeadInLeadOut( vCrvPaths[i]->GetFirstCurve(), vStepInfo[nInd].pCompo, bValidOutLeadIn)) + // se utensile che non lavora di testa e ingresso non fuori dal pezzo, errore + if ( m_TParams.m_nType == TT_MILL_NOTIP && ! vStepInfo[nInd].vPaths[i].bOutStart) { + if ( ! LeadInRawIsOk()) { + m_pMchMgr->SetLastError( 2431, "Error in SurfRoughing : LeadIn with Mill NoTip in material") ; return false ; - if ( ! bValidOutLeadIn) { - // se non valido, rimuovo il primo tratto - vStepInfo[nInd].vPaths[i].bOutStart = false ; - vCrvPaths[i]->RemoveFirstOrLastCurve( false) ; } } @@ -1873,16 +1951,6 @@ SurfRoughing::CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& v bool bOutEnd = ( vCrvPaths[i]->GetCurveCount() > 0 && vCrvPaths[i]->GetLastCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ; - // controllo se il punto d'uscita va limitata - bool bValidOutLeadOut = true ; - if ( bOutEnd) { - if ( ! VerifyLeadInLeadOut( vCrvPaths[i]->GetLastCurve(), vStepInfo[nInd].pCompo, bValidOutLeadOut)) - return false ; - // se non valido, rimuovo l'ultimo tratto - if ( ! bValidOutLeadOut) - vCrvPaths[i]->RemoveFirstOrLastCurve( true) ; - } - // controllo se il percorso è formato da una singola curva seguente il lato chiuso vStepInfo[nInd].vPaths[i].bSingleCrv = ( vCrvPaths[i]->GetCurveCount() > 0 && vCrvPaths[i]->GetTempProp( 0) == TEMP_PROP_SINGLE_CURVE) ; @@ -1941,7 +2009,7 @@ SurfRoughing::AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, co return true ; // calcolo i percorsi di svuotatura per ogni Step/SubStep - STEPINFOVECTOR vStepInfo ; + STEPINFOSRVECTOR vStepInfo ; if ( ! CalcPaths( vPocket, vCrvPocketCompo, vStepInfo)) return false ; @@ -1958,12 +2026,12 @@ SurfRoughing::AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, co for ( int i = 0 ; i < int( vStepInfo.size()) ; ++ i) { // riferimento alle informazioni relative allo step i-esimo - StepInfo& currStep = vStepInfo[i] ; + StepInfoSR& currStep = vStepInfo[i] ; // scorro i percorsi calcolati per il piano di pocketing i-esimo for ( int j = 0 ; j < int( currStep.vPaths.size()) ; ++ j) { // riferimento alle informazioni relative al percorso j-esimo del piano di pocketing i-esimo - PathInfo& currPath = currStep.vPaths[j] ; + PathInfoSR& currPath = currStep.vPaths[j] ; // ciclo sulle curve elementari del percorso attuale int nMaxInd = currPath.pCrvPath->GetCurveCount() - 1 ; for ( int k = 0 ; k <= nMaxInd ; ++ k) { @@ -2721,11 +2789,14 @@ SurfRoughing::CloseOpenEdgesUnderTolerance( ISurfFlatRegion* pSfr, double dToler //---------------------------------------------------------------------------- bool -SurfRoughing::ModifySurfRefForOpenCloseEdges( ISurfFlatRegion* pSfrRef, const ICurveComposite* pCrvCompo) const +SurfRoughing::ModifySurfForOpenCloseEdges( ISurfFlatRegion* pSfr, const Vector3d& vtTool, + const ICurveComposite* pCrvCompo) const { // controllo dei parametri - if ( pSfrRef == nullptr || pCrvCompo == nullptr || ! pCrvCompo->IsValid()) + if ( pSfr == nullptr || pCrvCompo == nullptr || ! pCrvCompo->IsValid()) return false ; + if ( ! pSfr->IsValid()) + return true ; /* NB. Questa funzione è richiamata per i sub steps. @@ -2738,15 +2809,17 @@ SurfRoughing::ModifySurfRefForOpenCloseEdges( ISurfFlatRegion* pSfrRef, const IC ICRVCOMPOPOVECTOR vpCrvs ; if ( ! GetHomogeneousParts( pCrvCompo, vpCrvs)) return false ; - // scorro tutti i tratti chiusi e li aggiungo alla pSfrDanger + // scorro tutti i tratti chiusi e li aggiungo alla superficie da non rovinare for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) { if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) { + vpCrvs[i]->SetExtrusion( vtTool) ; PtrOwner pSfrFat( GetSurfFlatRegionFromFatCurve( vpCrvs[i]->Clone(), m_TParams.m_dDiam / 2, false, false)) ; if ( ! IsNull( pSfrFat) && pSfrFat->IsValid()) { - if ( ! pSfrRef->IsValid()) - pSfrRef->CopyFrom( pSfrFat) ; - else - pSfrRef->Add( *pSfrFat) ; + if ( pSfr->IsValid()) { + pSfr->Subtract( *pSfrFat) ; + if ( ! pSfr->IsValid()) + return true ; + } } } } @@ -2781,13 +2854,13 @@ SurfRoughing::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegio } ; vector vSfrRef_info ; // assegno le info dei Loop della superficie di riferimento - for ( int c = 0 ; c < pSfrRef_Offs->GetChunkCount() ; ++ c) { - for ( int l = 0 ; l < pSfrRef_Offs->GetLoopCount( c) ; ++ l) { + for ( int nC = 0 ; nC < pSfrRef_Offs->GetChunkCount() ; ++ nC) { + for ( int nL = 0 ; nL < pSfrRef_Offs->GetLoopCount( nC) ; ++ nL) { SurfRef_Info mySurfRef_Info ; - mySurfRef_Info.bIsExternal = ( l == 0) ; + mySurfRef_Info.bIsExternal = ( nL == 0) ; if ( mySurfRef_Info.bIsExternal) - mySurfRef_Info.nInternalLoops = pSfrRef_Offs->GetLoopCount( c) - 1 ; - PtrOwner pCrv( pSfrRef_Offs->GetLoop( c, l)) ; + mySurfRef_Info.nInternalLoops = pSfrRef_Offs->GetLoopCount( nC) - 1 ; + PtrOwner pCrv( pSfrRef_Offs->GetLoop( nC, nL)) ; pCrv->ApproxWithLines( 10 * EPS_SMALL, 15, ICurve::APL_STD, mySurfRef_Info.PL_Loop) ; if ( ! mySurfRef_Info.bIsExternal) mySurfRef_Info.PL_Loop.Invert() ; @@ -2810,24 +2883,24 @@ SurfRoughing::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegio const int NUM_POINTS = 4 ; // scorro tutti i loop - for ( int c = 0 ; c < pSfr->GetChunkCount() ; ++ c) { - for ( int l = 0 ; l < pSfr->GetLoopCount( c) ; ++ l) { + for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) { + for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) { // recupero la curva composita del Loop - PtrOwner pCrvCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( c, l))) ; + PtrOwner pCrvCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ; if ( IsNull( pCrvCompoLoop) || ! pCrvCompoLoop->IsValid()) return false ; // scorro ogni sua sottocurva - for ( int u = 0 ; u < pCrvCompoLoop->GetCurveCount() ; ++ u) { + for ( int nU = 0 ; nU < pCrvCompoLoop->GetCurveCount() ; ++ nU) { // metto a 1 la TmpProp della sottocurva corrente della superficie - pSfr->SetCurveTempProp( c, l, u, TEMP_PROP_OPEN_EDGE, 0) ; + pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_OPEN_EDGE, 0) ; // recupero la sottocurva - const ICurve* pCrv = pCrvCompoLoop->GetCurve( u) ; + const ICurve* pCrv = pCrvCompoLoop->GetCurve( nU) ; if ( pCrv == nullptr) return false ; // recupero i NUM_POINTS punti bool bIsOut = true ; - for ( int p = 0 ; p < NUM_POINTS + 1 ; ++ p) { - double dPar = ( 1. / ( 1. * NUM_POINTS)) * p ; + for ( int nP = 0 ; nP < NUM_POINTS + 1 ; ++ nP) { + double dPar = ( 1. / ( 1. * NUM_POINTS)) * nP ; Point3d ptPar ; if ( ! pCrv->GetPointD1D2( dPar, ICurve::FROM_PLUS, ptPar)) return false ; @@ -2855,7 +2928,7 @@ SurfRoughing::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegio } } if ( ! bIsOut) { - pSfr->SetCurveTempProp( c, l, u, TEMP_PROP_CLOSE_EDGE, 0) ; + pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_CLOSE_EDGE, 0) ; break ; } } @@ -2929,62 +3002,6 @@ SurfRoughing::GetRadiusForStartEndElevation( void) const return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; } -//---------------------------------------------------------------------------- -bool -SurfRoughing::AdjustPathForLeadInLeadOut( ICurveComposite* pCrvCompo, int nSubType, const ICurveComposite* pCrvPocket, - bool& bOutStart, bool& bSingleCrv, bool& bOptTrap, bool& bIsZigZagOneWayBorder) const -{ - // controllo dei parametri - if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid()) - return false ; - - // controllo se il percorso ha un ingresso presso un lato aperto - bOutStart = ( pCrvCompo->GetCurveCount() > 0 && - pCrvCompo->GetFirstCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ; - - // controllo se il punto di ingresso è valido - bool bValidOutLeadIn = true ; - if ( bOutStart) { - if ( ! VerifyLeadInLeadOut( pCrvCompo->GetFirstCurve(), pCrvPocket, bValidOutLeadIn)) - return false ; - if ( ! bValidOutLeadIn) { - // se non valido, rimuovo il primo tratto - bOutStart = false ; - pCrvCompo->RemoveFirstOrLastCurve( false) ; - } - } - - // controllo se il percorso ha un'uscita presso un lato aperto - bool bOutEnd = ( pCrvCompo->GetCurveCount() > 0 && - pCrvCompo->GetLastCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ; - - // controllo se il punto d'uscita va limitata - bool bValidOutLeadOut = true ; - if ( bOutEnd) { - if ( ! VerifyLeadInLeadOut( pCrvCompo->GetLastCurve(), pCrvPocket, bValidOutLeadOut)) - return false ; - // se non valido, rimuovo l'ultimo tratto - if ( ! bValidOutLeadOut) - pCrvCompo->RemoveFirstOrLastCurve( true) ; - } - - // controllo se il percorso è formato da una singola curva seguente il lato chiuso - bSingleCrv = ( pCrvCompo->GetCurveCount() > 0 && - pCrvCompo->GetTempProp( 0) == TEMP_PROP_SINGLE_CURVE) ; - - // controllo se caso ottimizzato a trapezio - bOptTrap = ( pCrvCompo->GetCurveCount() > 0 && - pCrvCompo->GetTempProp( 0) == TEMP_PROP_OPT_TRAPEZOID) ; - - // controllo se è un percorso a ZigZag/OneWay ( non curva di bordo) - bIsZigZagOneWayBorder = ( pCrvCompo->GetCurveCount() > 0 && - ( nSubType == SURFROU_SUB_ONEWAY || nSubType == SURFROU_SUB_ZIGZAG) && - pCrvCompo->GetTempProp( 0) == TEMP_PROP_BORDER_CURVE) ; - - return true ; - -} - //---------------------------------------------------------------------------- bool SurfRoughing::CheckSafetyLinearLink( const Point3d& ptCurr, const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool, @@ -3000,6 +3017,10 @@ SurfRoughing::CheckSafetyLinearLink( const Point3d& ptCurr, const ISurfFlatRegio if ( ! plProj.Set( ptCurr, vtTool)) return false ; Point3d ptDestProj = ProjectPointOnPlane( ptDest, plProj) ; + if ( AreSamePointApprox( ptDestProj, ptCurr)) { + bSafe = true ; + return true ; + } // controllo se la retta che collega ptCurr a ptDesProj è interna o esterna alla regione limite // devo prima creare un frame Locale XY @@ -3114,63 +3135,6 @@ SurfRoughing::GetHomogeneousParts( const ICurveComposite* pCrvCompo, ICRVCOMPOPO } -//---------------------------------------------------------------------------- -bool -SurfRoughing::VerifyLeadInLeadOut( const ICurve* pCrv, const ICurveComposite* pCrvPock, bool& bValidLeadIn) const -{ - /* - Verifica se il segmento di LeadIn per entrate da fuori sia valido - */ - - // controllo dei parametri - if ( pCrv == nullptr || ! pCrv->IsValid() || - pCrvPock == nullptr || ! pCrvPock->IsValid()) - return false ; - - // recupero i tratti chiusi della curva di pocketing - ICRVCOMPOPOVECTOR vpCrvs ; - if ( ! GetHomogeneousParts( pCrvPock, vpCrvs)) - return false ; - - // porto tutto nel piano XY ( la Fat curve di una Linea è ambigua) - Frame3d frLoc ; - Point3d ptFrLoc ; pCrvPock->GetStartPoint( ptFrLoc) ; - double dArea ; - Plane3d plPlane ; - pCrvPock->GetArea( plPlane, dArea) ; - Vector3d vtFrLoc = plPlane.GetVersN() ; - if ( ! frLoc.Set( ptFrLoc, vtFrLoc)) - return false ; - - // porto la curva in locale - PtrOwner pCrvLoc( pCrv->Clone()) ; - if ( IsNull( pCrvLoc) || ! pCrvLoc->IsValid() || ! pCrvLoc->ToLoc( frLoc)) - return false ; - - // calcolo la Fat Curve del tratto lineare e la porto in globale - PtrOwner pSfrFat( GetSurfFlatRegionFromFatCurve( pCrvLoc->Clone(), m_TParams.m_dDiam / 2 - 50 * EPS_SMALL, false, false)) ; - if ( IsNull( pSfrFat) || ! pSfrFat->IsValid()) - return false ; - - bValidLeadIn = true ; - for ( int i = 0 ; i < int( vpCrvs.size()) && bValidLeadIn ; ++ i) { - // se tratto chiuso... - if ( vpCrvs[i]->GetTempProp( 0) == 0) { - // porto nel frame locale - vpCrvs[i]->ToLoc( frLoc) ; - // controllo se interseca la fat curve - CRVCVECTOR ccClass ; - if ( pSfrFat->GetCurveClassification( *vpCrvs[i], EPS_SMALL, ccClass)) - bValidLeadIn = ( int( ccClass.size()) == 1 && ccClass[0].nClass == CRVC_OUT) ; - else - bValidLeadIn = false ; - } - } - - return true ; - -} - //---------------------------------------------------------------------------- // Debug Functions //---------------------------------------------------------------------------- diff --git a/SurfRoughing.h b/SurfRoughing.h index a6f474b..ee7f6b5 100644 --- a/SurfRoughing.h +++ b/SurfRoughing.h @@ -26,7 +26,7 @@ class ICAvToolSurfTm ; // struttura informazioni sui singoli percorsi -struct PathInfo { +struct PathInfoSR { bool bOutStart ; // flag per entrata da fuori bool bSingleCrv ; // se percorso formato da una curva singola ( in generale per SubSteps) bool bOptTrap ; // flag per casi ottimizzati a trapezio ( per Spiral) @@ -35,10 +35,10 @@ struct PathInfo { PtrOwner pCvrRet ; // curva di ritorno per LeadIn/Out a guida } ; // tipo percorso -typedef std::vector PATHINFOVECTOR ; +typedef std::vector PATHINFOSRVECTOR ; // struttura informazioni per Step/SubSteps complessivi -struct StepInfo { +struct StepInfoSR { double dDepth ; // profondità dello step attuale double dRelativeDepth ; // profondità relativa allo step al di sopra double dZlocCoeffFeed ; // coeffiziente riduzione Feed lungo Zloc @@ -48,10 +48,10 @@ struct StepInfo { PtrOwner pSfrPock ; // regione piana di svuotatura PtrOwner pSfrLimit ; // regione piana da non svuotare PtrOwner pCompo ; // curva selezionata per sgrossatura - PATHINFOVECTOR vPaths ; // percorsi di Pocketing + PATHINFOSRVECTOR vPaths ; // percorsi di Pocketing } ; // tipo step -typedef std::vector STEPINFOVECTOR ; +typedef std::vector STEPINFOSRVECTOR ; //---------------------------------------------------------------------------- class SurfRoughing : public Machining @@ -104,7 +104,7 @@ class SurfRoughing : public Machining bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ; bool Chain( int nGrpDestId) ; bool ProcessPath( int nPathId, int nTempId, int nPvId, int nClId) ; - bool CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& vCrvPocketCompo, STEPINFOVECTOR& vStepInfo) const ; + bool CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& vCrvPocketCompo, STEPINFOSRVECTOR& vStepInfo) const ; bool AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, const ICRVCOMPOPOVECTOR& vCrvPocketCompo, double dElev, double dStep, double dSubStep, bool bSplitArcs) ; bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ; @@ -112,24 +112,22 @@ class SurfRoughing : public Machining bool AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ; bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ; bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtTool, const ICurveComposite* pCrvPath, Point3d& ptP1) const ; - bool VerifyLeadInLeadOut( const ICurve* pCrv, const ICurveComposite* pCrvPock, bool& bSkip) const ; bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, const ISurfFlatRegion* pSfr, const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs, bool bNoneForced, bool bSkipControl) ; bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, Point3d& ptP1) ; ISurfTriMesh* GetRaw( void) const ; + ISurfTriMesh* GetStmOutSideCompo( ICurveComposite* pCompo, const ISurfTriMesh* pStmRaw, const Vector3d& vtExtr) const ; ISurfFlatRegion* GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs = 0) const ; bool GetActiveSurfaces( INTVECTOR& vSurfId) const ; double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ; double GetRadiusForStartEndElevation( void) const ; - bool AdjustPathForLeadInLeadOut( ICurveComposite* pCrvCompo, int nSubType, const ICurveComposite* pCrvPocket, bool& bOutStart, - bool& bSingleCrv, bool& bOptTrap, bool& bIsZigZagOneWayBorder) const ; bool AssignOpenEdgesForPocketCrvCompo( ICurveComposite* pCrvCompo, const ISurfFlatRegion* pSfr) const ; bool ResetCurveAllTempProp( ICurve* pCurve) const ; bool RemoveChunksUnderTolerance( ISurfFlatRegion* pSfr) const ; bool CloseOpenEdgesUnderTolerance( ISurfFlatRegion* pSfr, double dToler) ; - bool ModifySurfRefForOpenCloseEdges( ISurfFlatRegion* pSfrRef, const ICurveComposite* pCrvCompo) const ; + bool ModifySurfForOpenCloseEdges( ISurfFlatRegion* pSfr, const Vector3d& vtTool, const ICurveComposite* pCrvCompo) const ; bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegion* pSfrRef) const ; bool SimplifyCurve( ICurveComposite* pCompo) const ; bool SimplyfySfr( ISurfFlatRegion* pSfr) const ; @@ -165,6 +163,11 @@ class SurfRoughing : public Machining if ( m_Params.m_nLeadInType != SURFROU_LI_GLIDE && m_Params.m_dLiElev < 10 * EPS_SMALL) return SURFROU_LI_NONE ; return m_Params.m_nLeadInType ; } + bool LeadInRawIsOk( void) const + { if ( m_TParams.m_nType != TT_MILL_NOTIP) + return true ; + return (( GetLeadInType() == SURFROU_LI_ZIGZAG || GetLeadInType() == SURFROU_LI_HELIX) && + m_Params.m_dLiTang >= 0.9 * m_TParams.m_dDiam && m_Params.m_dLiElev <= 2) ; } int GetLeadOutType( void) const { if ( m_Params.m_dLoTang < std::min( 0.1 * m_TParams.m_dDiam, 1.0)) return SURFROU_LO_NONE ;