diff --git a/Pocketing.cpp b/Pocketing.cpp index 61cfd51..cb0c2db 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -5078,7 +5078,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt // caso spirale PtrOwner pCrvBorder( GetCurveComposite( pSrfPock->GetLoop( 0, 0))) ; Point3d ptCen ; Vector3d vtN ; double dRad ; bool bCCW ; - m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvBorder->Clone()) ; + //m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvBorder->Clone()) ; if ( pCrvBorder->IsACircle( 100 * EPS_SMALL, ptCen, vtN, dRad, bCCW)) { double dIntRad = 0 ; if ( m_Params.m_nSubType == POCKET_SUB_SPIRALOUT && GetLeadInType() == POCKET_LI_HELIX) { @@ -8634,8 +8634,59 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO return false ; } int nCrv_offs = OffsCrv.GetCurveCount() ; - if ( nCrv_offs == 0) - continue ; + if ( nCrv_offs == 0) { + // determino la curva ad amo + Point3d ptEnd ; vpCrvs[i-1]->GetEndPoint( ptEnd) ; + Vector3d vtTg ; vpCrvs[i-1]->GetEndDir( vtTg) ; + Vector3d vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, -1) ; + Point3d ptArc = ptEnd + ( 1.05 * dTool_Diam + 2 * dOffR ) * vtOrt ; + //Point3d ptLine = ptArc - 5 * dDiam * vtTg ; + PtrOwner pCrvArc( CreateCurveArc()) ; + if ( IsNull( pCrvArc)) + return false ; + pCrvArc->SetExtrusion( vtExtr) ; + pCrvArc->Set2PVN( ptEnd, ptArc, vtTg, vtExtr) ; + PtrOwner pJCrv( CreateCurveComposite()) ; + if ( IsNull( pJCrv)) + return false ; + pJCrv->AddCurve( Release( pCrvArc)) ; + // determino la curva ad amo + vpCrvs[i+1]->GetStartDir( vtTg) ; + vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, -1) ; + ptArc = ptStart + ( 1.05 * dTool_Diam + 2 * dOffR ) * vtOrt ; + Point3d ptLine = ptArc + 5 * ( 1.05 * dTool_Diam + 2 * dOffR ) * vtTg ; + PtrOwner pJCrv1( CreateCurveComposite()) ; + if ( IsNull( pJCrv1)) + return false ; + pJCrv1->SetExtrusion( vtExtr) ; + pJCrv1->AddPoint( ptLine) ; + pJCrv1->AddLine( ptArc) ; + pJCrv1->AddArcTg( ptStart) ; + + pJCrv->ToLoc( frPocket) ; + pJCrv1->ToLoc( frPocket) ; + IntersCurveCurve intCC( *pJCrv, *pJCrv1) ; + pJCrv->ToGlob( frPocket) ; + pJCrv1->ToGlob( frPocket) ; + + IntCrvCrvInfo aInfo ; + if ( intCC.GetIntersCount() > 0) { + if ( intCC.GetIntCrvCrvInfo( 0, aInfo)) { + PtrOwner pCrvFinal( CreateCurveComposite()) ; + PtrOwner PJ_Cut( pJCrv->CopyParamRange( 0, aInfo.IciA[0].dU)) ; + PtrOwner PJ1_Cut( pJCrv1->CopyParamRange( 0, aInfo.IciB[0].dU)) ; + PJ1_Cut->Invert() ; + pCrvFinal->AddCurve( Release( PJ_Cut)) ; + pCrvFinal->AddCurve( Release( PJ1_Cut)) ; + for ( int u = 0 ; u < pCrvFinal->GetCurveCount() ; ++ u) + pCrvFinal->SetCurveTempProp( u, 0, 0) ; + vpCrvs[i].Set( Release( pCrvFinal)) ; + vpCrvs[i]->SetTempProp( 0) ; + } + } + else + continue ; + } PtrOwner pCrvlonger( OffsCrv.GetLongerCurve()) ; //int W = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvlonger->Clone()) ; //m_pGeomDB->SetMaterial( W, WHITE) ; @@ -8691,7 +8742,7 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO Point3d ptS ; pCompo->GetEndPoint( ptS) ; Point3d ptE ; vpCrvs[i+1]->GetStartPoint( ptE) ; PtrOwner pCrvNew( CreateCurveComposite()) ; - if ( ! bInVsOut && AdjustPathOutsideRawForOpenEdges( pCompo_clone, vCrvIsl, pHHHH, ptS, ptE, dRad, dDiam, + if ( ! bInVsOut && AdjustPathOutsideRawForOpenEdges( pCompo_clone, vCrvIsl, pHHHH, ptS, ptE, dRad, dDiam, pCrvNew, vtTrasl, pStmRaw, bInVsOut)) { vpCrvs[i].Set( Release( pCrvNew)) ; vpCrvs[i]->GetStartPoint( ptStart) ; @@ -9385,7 +9436,7 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const doubl if ( ! ModifySurfByOpenEdge( pSrf, vCrvOEFlags, vtTrasl, pStmRaw)) return false ; - for ( int c = 0 ; c < pSrf->GetChunkCount() ; ++ c) { + /*for ( int c = 0 ; c < pSrf->GetChunkCount() ; ++ c) { for ( int l = 0 ; l < pSrf->GetLoopCount( c) ; ++ l) { const ICurveComposite* pCrvCompo( GetCurveComposite( pSrf->GetLoop( c, l))) ; for ( int u = 0 ; u < pCrvCompo->GetCurveCount() ; ++ u) { @@ -9394,7 +9445,7 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const doubl m_pGeomDB->SetMaterial( aaa, nProp0 == 0 ? BLUE : RED) ; } } - } + }*/ //PtrOwner pSrf_toDraw( CloneSurfFlatRegion( pSrf)) ; //pSrf_toDraw->Translate( vtTrasl) ; @@ -10306,8 +10357,6 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* PtrOwner pSrfRaw_clone( CloneSurfTriMesh( pStmRaw)) ; if ( IsNull( pSrfRaw_clone)) return false ; - //if ( ! pSrfRaw_clone->Cut( plProj, true)) - // return false ; if ( ! pSrfRaw_clone->CutWithOtherSurf( *pSrf_ForCuttingRaw, true, true)) return false ; if ( ! pSrfRaw_clone->IsValid() || pSrfRaw_clone->GetTriangleCount() == 0) { @@ -10343,16 +10392,25 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* } // creo una Regione piana a partire da tutte le curve ( superificie che restituisco) - PtrOwner pSfrProj( CreateSurfFlatRegion()) ; - if ( IsNull( pSfrProj)) - return false ; + SurfFlatRegionByContours pSrf_H_Final ; + //pSrf_H_Final.AddCurve( GetCurveComposite( pSfr->GetLoop( 0,0))) ; + //PtrOwner pSfrProj( CloneSurfFlatRegion( pSfr)) ; + //if ( IsNull( pSfrProj) || ! pSfrProj->IsValid()) + // return false ; //int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStr_real->Clone()) ; //m_pGeomDB->SetMaterial( g, GREEN) ; + + + // creo un vettore con le curve esterne + // in posizione 0 metto la curva esterna della superificie da svuoatre originale + // nelle posizioni successive inserisco le curve esterne dei chunk creati ( aperti per definizione) + ICRVCOMPOPOVECTOR vCrvExtProj ; + vCrvExtProj.emplace_back( GetCurveComposite( pSfr->GetLoop( 0, 0))) ; // Proietto ora le curve, delle facce della superificie ottenuta, sul piano della svuotatura for ( int f = 0 ; f < pStr_real->GetFacetCount() ; ++ f) { - // controllo se la faccia è quasi percpendicolare, nel caso la salto + // controllo se la faccia è quasi perpendicolare, nel caso la salto Vector3d vtN_check ; pStr_real->GetFacetNormal( f, vtN_check) ; if ( abs( vtN_check * vtNorm) < EPS_ZERO) continue ; @@ -10371,10 +10429,9 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* Plane3d plCheck ; if ( ! pCrvProjFacef->IsClosed() || ! pCrvProjFacef->GetArea( plCheck, dArea) || dArea <= EPS_SMALL) continue ; - // aggiungo questa curva solo se : bool bNeedProj = false ; - // 1) cerco se ho dei tratti sulla curva di proiezione che fanno overlap con il bordo della superificie da svuoatare + // 1) cerco se ho dei tratti sulla curva di proiezione che fanno overlap con il bordo della superificie da svuotare for ( int cc_ = 0 ; cc_ < pSfr->GetChunkCount() && !bNeedProj ; ++ cc_) { // recupero il bordo esterno PtrOwner pCrvEB_Ccc_( GetCurveComposite( pSfr->GetLoop( cc_, 0))) ; @@ -10410,7 +10467,7 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* if ( ! bNeedProj) continue ; - // 2) ha almeno una sottocurva sovrapposta ad un lato aperto della superfcicie originale + // 2) ha almeno una sottocurva sovrapposta ad un lato aperto della superificie originale CRVCVECTOR ccClass ; if ( pSfrPock->GetCurveClassification( *pCrvProjFacef, EPS_SMALL, ccClass)) { for ( int j = 0 ; j < ( int)ccClass.size() && bNeedProj ; ++ j) { @@ -10421,30 +10478,40 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* if ( ! bNeedProj) continue ; + // 3) setto tutte le sottocurve aperte ( sono proiezioni...) + PtrOwner pCrvCompo_ProjFacef( CreateCurveComposite()) ; + if ( IsNull( pCrvCompo_ProjFacef)) + return false ; + pCrvCompo_ProjFacef->AddCurve( Release( pCrvProjFacef)) ; + for ( int uu = 0 ; uu < pCrvCompo_ProjFacef->GetCurveCount() ; ++ uu) + pCrvCompo_ProjFacef->SetCurveTempProp( uu, 1, 0) ; - if ( l == 0) - pSfr_ff->AddExtLoop( pCrvProjFacef->Clone()) ; - else - pSfr_ff->AddIntLoop( pCrvProjFacef->Clone()) ; - - //if ( IsNull( pSfr_ff) || ! pSfr_ff->IsValid()) { - //int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvProjFacef->Clone()) ; - //m_pGeomDB->SetMaterial( r, RED) ; - //} + if ( l == 0) // se primo allora loop esterno... + pSfr_ff->AddExtLoop( pCrvCompo_ProjFacef->Clone()) ; + else // ... altrimenti loop interno + pSfr_ff->AddIntLoop( pCrvCompo_ProjFacef->Clone()) ; + // inserisco nel vettore la curva trovata + vCrvExtProj.emplace_back( Release( pCrvCompo_ProjFacef)) ; } + if ( IsNull( pSfr_ff) || ! pSfr_ff->IsValid()) continue ; if ( AreOppositeVectorApprox( pSfr_ff->GetNormVersor(), vtNorm)) pSfr_ff->Invert() ; - if ( ! pSfrProj->IsValid() || pSfrProj->GetChunkCount() == 0) - pSfrProj.Set( Release( pSfr_ff)) ; - else - pSfrProj->Add( *Release( pSfr_ff)) ; + //pSfrProj->Add( *Release( pSfr_ff)) ; + pSrf_H_Final.AddCurve( pSfr_ff->GetLoop( 0, 0)) ; } - // Recupero la regione e controllo la validità - //pSfrProj.Set( pSrf_Help.GetSurf()) ; + for ( int o = 0 ; o < ( int)vCrvExtProj.size() ; ++ o) { + int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvExtProj[o]->Clone()) ; + m_pGeomDB->SetMaterial( g, BLACK) ; + } + + // controllo la validità della regione + + PtrOwner pSfrProj( CloneSurfFlatRegion( pSfr)) ; + pSfrProj->Add( *pSrf_H_Final.GetSurf()) ; if ( IsNull( pSfrProj) || ! pSfrProj->IsValid()) return true ; @@ -10453,19 +10520,72 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* if ( AreOppositeVectorApprox( vtN_check, vtNorm)) pSfrProj->Invert() ; - // estendo la regione iniziale mediante i lati aperti + // ----------------------------------------------------------------------------------------- + PtrOwner pCrvExt( GetCurveComposite( pSfr->GetLoop( 0, 0))) ; + if ( IsNull( pCrvExt) || ! pCrvExt->IsValid()) + return false ; + ICRVCOMPOPOVECTOR vCrvNull ; + // allargo la copia della superificie iniziale estendendola presso i lati aperti + // ( semplice AdjustContourWithOpenEdges, senza grezzo e senza regione di incidenza, verrà tutto fatto in seguito) + if ( AdjustContourWithOpenEdges( pCrvExt, vCrvNull, m_dMaxLenRawProj, 0.0, 0.0, V_NULL, nullptr, true)) { + PtrOwner pSrfWithOEModified( CreateSurfFlatRegion()) ; + if ( IsNull( pSrfWithOEModified)) + return false ; + pSrfWithOEModified->AddExtLoop( Release( pCrvExt)) ; // la modifico con la curva appena restituita ( allargata dai lati aperti) + if ( pSrfWithOEModified->IsValid()) { // se la superificie ottenuta è valida... + // ... la clono... + PtrOwner pSfrProj_Clone( CloneSurfFlatRegion( pSfrProj)) ; + if ( IsNull( pSfrProj_Clone) || ! pSfrProj_Clone->IsValid()) + return false ; + // controllo che le normali siano compatibili + if ( AreOppositeVectorApprox( pSfrProj_Clone->GetNormVersor(), pSrfWithOEModified->GetNormVersor())) + pSfrProj_Clone->Invert() ; + int ga = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj_Clone->Clone()) ; + m_pGeomDB->SetMaterial( ga, RED) ; + int gaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfWithOEModified->Clone()) ; + m_pGeomDB->SetMaterial( gaa, PURPLE) ; + // ... e Interseco la superificie di proiezione con questa nuova superificie + if ( pSfrProj_Clone->Intersect( *pSrfWithOEModified) && ! IsNull( pSfrProj_Clone) && pSfrProj_Clone->IsValid()) { + int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj_Clone->Clone()) ; + m_pGeomDB->SetMaterial( g, GREEN) ; + // Recupero le TmpProp e creo la nuova superificie mediante questo loop esterno + PtrOwner pCrv_NewExt( pSfrProj_Clone->GetLoop( 0, 0)) ; + if ( IsNull( pCrv_NewExt) || ! pCrv_NewExt->IsValid()) + return false ; + PtrOwner pCrvCompo_NewExt( CreateCurveComposite()) ; // trasformo in composita + if ( IsNull( pCrvCompo_NewExt)) + return false ; + pCrvCompo_NewExt->AddCurve( Release( pCrv_NewExt)) ; + if ( pCrvCompo_NewExt->IsValid()) { + // imposto le proprietà temporanee delle curve + for ( int u = 0 ; u < pCrvCompo_NewExt->GetCurveCount() ; ++ u) { + bool bFound = false ; + for ( int i = 0 ; i < ( int)vCrvExtProj.size() && !bFound ; ++ i) { + int nStat = -1 ; + if ( SetTmpPropByOverlap( pCrvCompo_NewExt, u, vCrvExtProj[i], nStat, 100 * EPS_SMALL) && nStat == 1) + bFound = true ; + } + if ( ! bFound) + pCrvCompo_NewExt->SetCurveTempProp( u, 0, 0) ; // chiusa per sicurezza + } + // creo la superificie finale + PtrOwner pSrfProj_Final( CreateSurfFlatRegion()) ; + if ( IsNull( pSrfProj_Final)) + return false ; + pSrfProj_Final->AddExtLoop( Release( pCrvCompo_NewExt)) ; + if ( pSrfProj_Final->IsValid()) { + if ( AreOppositeVectorApprox( pSrfProj_Final->GetNormVersor(), pSfr->GetNormVersor())) + pSrfProj_Final->Invert() ; + } + pSfrRawBoxProj->Clear() ; + pSfrRawBoxProj->CopyFrom( pSrfProj_Final) ; + return pSfrRawBoxProj->IsValid() ; + } + } + } + } - // la proiezione che serve è solamente l'intersezione tra la proiezione del grezzo ricavato e la supericie allargata - // dai lati aperti - - // restituisco la FlatRegion della proiezione del grezzo - pSfrRawBoxProj->Clear() ; - pSfrRawBoxProj->CopyFrom( pSfrProj) ; - - //int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrRawBoxProj->Clone()) ; - //m_pGeomDB->SetMaterial( g, GREEN) ; - - return pSfrRawBoxProj->IsValid() && pSfrRawBoxProj->GetChunkCount() > 0 ; + return false ; } @@ -10543,27 +10663,20 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl, if ( IsNull( pSrfOnPlPlus) || ! pSrfOnPlPlus->IsValid() || pSrfOnPlPlus->GetChunkCount() == 0) continue ; - int aaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ; - m_pGeomDB->SetMaterial( aaa, RED) ; - int aaag = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_clone_ChunkC->Clone()) ; - m_pGeomDB->SetMaterial( aaag, GREEN) ; - - if ( ! pSrf_clone_ChunkC->Add( *Release( pSrfOnPlPlus))) - continue ; - - int aaab = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_clone_ChunkC->Clone()) ; - m_pGeomDB->SetMaterial( aaab, ORANGE) ; - - // recupero la curva esterna - PtrOwner pNewCrvExt( GetCurveComposite( pSrf_clone_ChunkC->GetLoop( 0, 0))) ; - int nStat = - 1 ; - for ( int u = 0 ; u < pNewCrvExt->GetCurveCount() ; ++ u) { - int nStat = -1 ; - if ( SetTmpPropByOverlap( pNewCrvExt, u, pCrvExt_Loop, nStat, 5 * EPS_SMALL) && - ( nStat == 0 || nStat == 2)) - pNewCrvExt->SetCurveTempProp( u, 1, 0) ; + //int aaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ; + //m_pGeomDB->SetMaterial( aaa, RED) ; + for ( int cc = 0 ; cc < pSrfOnPlPlus->GetChunkCount() ; ++ cc) { + for ( int ll = 0 ; ll < pSrfOnPlPlus->GetLoopCount( cc) ; ++ ll) { + const ICurveComposite* pCrvCompo( GetCurveComposite( pSrfOnPlPlus->GetLoop( cc, ll))) ; + for ( int uu = 0 ; uu < pCrvCompo->GetCurveCount() ; ++ uu) { + int nProp0 ; pCrvCompo->GetCurveTempProp( uu, nProp0, 0) ; + int aaak = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo->GetCurve( uu)->Clone()) ; + m_pGeomDB->SetMaterial( aaak, nProp0 == 0 ? AQUA :ORANGE) ; + } + } } - + // recupero la curva esterna + PtrOwner pNewCrvExt( GetCurveComposite( pSrfOnPlPlus->GetLoop( 0, 0))) ; // recupero la nuova superificie con la curva esterna modificata e le isole originali pSrf_Help.AddCurve( Release( pNewCrvExt)) ; for ( int i = 0 ; i < ( int)vCrvIsl.size() ; ++ i) diff --git a/Pocketing.h b/Pocketing.h index e461230..77bc751 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -320,7 +320,7 @@ class Pocketing : public Machining double m_dOpenMinSafe ; // minima distanza di sicurezza di attacco su lato aperto bool m_bIntersRaw = true ; // flag per intersezione con grezzo bool m_bProjectRaw = true ; // flag di proiezione del grezzo - double m_dMaxLenRawProj = 40 ; // lunghezza massima per contatto di proiezione + double m_dMaxLenRawProj = 20 ; // lunghezza massima per contatto di proiezione bool m_bOptOffset = true ; // flag per ottimizzazione numero di Offset necessari bool m_bOptOffsetCM = false ; // flag per ottimizzazione numero di Offset necessari con centroidi e medial Axis bool m_bAssignFeed = true ; // flag per controllo della Feed