From 01d3e7baa9d3a516ec79c4da868dea1c4c9dbb86 Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Mon, 21 Aug 2023 13:32:56 +0200 Subject: [PATCH] EgtMachKernel: - modifiche proiezioni con scalatura. --- Pocketing.cpp | 360 ++++++++++++++++++-------------------------------- Pocketing.h | 1 + 2 files changed, 129 insertions(+), 232 deletions(-) diff --git a/Pocketing.cpp b/Pocketing.cpp index 37d7a02..d45a743 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -9480,6 +9480,7 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vectorAddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmORIG_forCut->Clone()) ; //m_pGeomDB->SetMaterial( g, GRAY) ; - // 6) Proeitto tutte le facce ottenute sul piano di proeizione - for ( int f = 0 ; f < pStmORIG_forCut->GetFacetCount() ; ++ f) { - // 7) Estrazione del bordo della faccia -> Curva composita - POLYLINEVECTOR vPL ; - pStmORIG_forCut->GetFacetLoops( f, vPL) ; - SurfFlatRegionByContours SfrByC_Tmp ; - // 8) Creazione del Loop i-esimo della faccia f - for ( int i = 0 ; i < ( int)vPL.size() ; ++ i) { - PtrOwner pCrvCompoLoop( CreateCurveComposite()) ; - if ( IsNull( pCrvCompoLoop)) - return false ; - pCrvCompoLoop->FromPolyLine( vPL[i]) ; - pCrvCompoLoop->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ; - // NB. essendo una curva derivante da un contorno di Trimesh ho una composita derivante da una polyLine, - // devo recuperare gli archi e approssimarli - PolyArc PA ; - Frame3d frPock ; frPock.Set( ptC, vtN) ; - if ( ! frPock.IsValid()) - return false ; - pCrvCompoLoop->ToLoc( frPock) ; - pCrvCompoLoop->ApproxWithArcsEx( 0.5 , ANG_TOL_STD_DEG, LIN_FEA_STD, PA) ; - pCrvCompoLoop->Clear() ; - pCrvCompoLoop->FromPolyArc( PA) ; - pCrvCompoLoop->ToGlob( frPock) ; - pCrvCompoLoop->SetExtrusion( vtExtr) ; - pCrvCompoLoop->SetThickness( dThick) ; + // 6) Proeizione della TriMesh tagliata sul piano di svuotatura + if ( ! ProjectStmOnPlane( pStmORIG_forCut, plProj, pSfrProjUP)) + return false ; - //int o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompoLoop->Clone()) ; - //m_pGeomDB->SetMaterial( o, ORANGE) ; - - // 8) Proeizione della curva sul piano di proeizione - PtrOwner pCrvProj( ProjectCurveOnPlane( *pCrvCompoLoop, plProj)) ; - - //int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvProj->Clone()) ; - //m_pGeomDB->SetMaterial( g, GREEN) ; - - if ( ! IsNull( pCrvProj) && pCrvProj->IsValid()) { - // 9) aggiorno il vettore delle curve ( queste curve devono essere tutte chiuse...) - PtrOwner pCrvCompoForTmpProps( ConvertCurveToComposite( pCrvProj->Clone())) ; - if ( ! IsNull( pCrvCompoForTmpProps) && pCrvCompoForTmpProps->IsValid()) { - for ( int u = 0 ; u < pCrvCompoForTmpProps->GetCurveCount() ; ++ u) - pCrvCompoForTmpProps->SetCurveTempProp( u, 0, 0) ; // tutte chiuse... - SfrByC_Tmp.AddCurve( pCrvCompoForTmpProps->Clone()) ; - vAllCrv.emplace_back( Release( pCrvCompoForTmpProps)) ; - } - } - } - // 10) creazione della FlatRegion dalla proiezione - PtrOwner pSfrTmp( SfrByC_Tmp.GetSurf()) ; - if ( ! IsNull( pSfrTmp) && pSfrTmp->IsValid()) { - if ( AreOppositeVectorApprox( pSfrTmp->GetNormVersor(), pSfrORIG->GetNormVersor())) - pSfrTmp->Invert() ; - - //int l = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrTmp->Clone()) ; - //m_pGeomDB->SetMaterial( l, LIME) ; - - if ( ! pSfrProjUP->IsValid() || pSfrProjUP->GetChunkCount() == 0) - pSfrProjUP.Set( Release( pSfrTmp)) ; - else - pSfrProjUP->Add( *pSfrTmp) ; - - } - } } else return false ; @@ -9811,36 +9753,6 @@ Pocketing::GetAdaptedSfrByTrimesh( const ISurfFlatRegion* pSrfExtended, const IS else return false ; - /*int p = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProjUP->Clone()) ; - m_pGeomDB->SetMaterial( p, PURPLE) ;*/ - - // 11) dato che pSfrProjUP è attenuta dall'unione di molte superifici proiettate, meglio sistemare i bordi ( specialmente gli archi) - /*if ( pSfrProjUP->IsValid()) { - SurfFlatRegionByContours SrfByC_ProjUP ; - for ( int c = 0 ; c < pSfrProjUP->GetChunkCount() ; ++ c) { - for ( int l = 0 ; l < pSfrProjUP->GetLoopCount( c) ; ++ l) { - PtrOwner pCrvLoop( ConvertCurveToComposite( pSfrProjUP->GetLoop( c, l))) ; - if ( IsNull( pCrvLoop) || ! pCrvLoop->IsValid()) - return false ; - PolyArc PA ; - pCrvLoop->ApproxWithArcsEx( 0.5, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) ; - pCrvLoop->Clear() ; - pCrvLoop->FromPolyArc( PA) ; - SrfByC_ProjUP.AddCurve( Release( pCrvLoop)) ; - } - } - PtrOwner pSfrProjUP_Cute( CreateSurfFlatRegion()) ; - if ( IsNull( pSfrProjUP_Cute)) - return false ; - pSfrProjUP_Cute.Set( SrfByC_ProjUP.GetSurf()) ; - if ( ! IsNull( pSfrProjUP_Cute) && pSfrProjUP_Cute->IsValid()) { - pSfrProjUP->Clear() ; - pSfrProjUP->CopyFrom( pSfrProjUP_Cute) ; - if ( ! pSfrProjUP->IsValid()) - return false ; - } - }*/ - //int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProjUP->Clone()) ; //m_pGeomDB->SetMaterial( r, RED) ; @@ -9909,6 +9821,105 @@ Pocketing::GetAdaptedSfrByTrimesh( const ISurfFlatRegion* pSrfExtended, const IS } +//---------------------------------------------------------------------------- +bool +Pocketing::ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPock, ISurfFlatRegion* pSfrProj) +{ + // controllo parametri + if ( pStmAbove == nullptr || ! pStmAbove->IsValid() || pStmAbove->GetTriangleCount() == 0) + return true ; + if ( ! plPock.IsValid()) + return false ; + pSfrProj->Clear() ; + + // 1) creo il sistema di riferimento ( inerente al piano di svuotatura) + Point3d ptORIG = plPock.GetPoint() ; + Vector3d vtN = -plPock.GetVersN() ; + Frame3d frPlane ; frPlane.Set( ptORIG, vtN) ; + if ( ! frPlane.IsValid()) + return false ; + + // 2) creo una copia della superficie nel nuovo sistema di riferimento + PtrOwner pStmRef( CloneSurfTriMesh( pStmAbove)) ; + if ( IsNull( pStmRef) || ! pStmRef->IsValid()) + return false ; + + // 3) scalo la superficie rispetto al sistema di riferimento ( mettendo a 0 la conponente vtN) + if ( ! pStmRef->Scale( frPlane, 1., 1., 0.)) + return false ; + + int p = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmRef->Clone()) ; + m_pGeomDB->SetMaterial( p, PURPLE) ; + + // 4) controllo la validità della superficie ottenuta + if ( IsNull( pStmRef) || ! pStmRef->IsValid() || pStmRef->GetTriangleCount() == 0) + return true ; // la proeizione sparisce + + // 5) NB. A seconda di come sono orientate le facce, posso avere i Triangoli con normali vtN o -vtN... + // rendo le normali dei triangoli coerenti + StmFromTriangleSoup TriaSoupUp ; TriaSoupUp.Start() ; + StmFromTriangleSoup TriaSoupDown ; TriaSoupDown.Start() ; + for ( int t = 0 ; t < pStmRef->GetTriangleCount() ; ++ t) { + Triangle3d Tria ; pStmRef->GetTriangle( t, Tria) ; + if ( AreOppositeVectorApprox( Tria.GetN(), vtN)) + TriaSoupDown.AddTriangle( Tria) ; + else + TriaSoupUp.AddTriangle( Tria) ; + } + TriaSoupUp.End() ; + TriaSoupDown.End() ; + PtrOwner pStmUp( TriaSoupUp.GetSurf()) ; // superificie con i Triangoli Up + PtrOwner pStmDown( TriaSoupDown.GetSurf()) ; // superificie con i Triangoli Down + // 5.1) Controllo ausiliario... ( per possibili approssimazioni con triangoli particolari) + if ( ! IsNull( pStmUp) && pStmUp->IsValid() && pStmUp->GetTriangleCount() == 0 && + ! IsNull( pStmDown) && pStmDown->IsValid() && pStmDown->GetTriangleCount() == 0) + return true ; + //pStmUp->Repair() ; pStmDown->Repair() ; + + //int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmUp->Clone()) ; + //int o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmDown->Clone()) ; + //m_pGeomDB->SetMaterial( r, RED) ; + //m_pGeomDB->SetMaterial( o, ORANGE) ; + //m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj->Clone()) ; + + + // 6) Essendo due Trimesh piane e sullo stesso piano, converto in FlatRegion prima di unirle + PtrOwner pSfrUp( CreateSurfFlatRegion()) ; + PtrOwner pSfrUp1( CreateSurfFlatRegion()) ; + if ( IsNull( pSfrUp) || IsNull( pSfrUp1)) + return false ; + if ( ! IsNull( pStmUp) && pStmUp->IsValid() && pStmUp->GetTriangleCount() > 0) { + if ( ! GetSfrByStm( pStmUp, pSfrUp, plPock, V_NULL, 0., 0.)) + return false ; + } + if ( ! IsNull( pStmDown) && pStmDown->IsValid() && pStmDown->GetTriangleCount() > 0) { + if ( ! pStmDown->Invert() || + ! GetSfrByStm( pStmDown, pSfrUp1, plPock, V_NULL, 0., 0.)) + return false ; + } + + // 7) Controllo validità e creo la FlatRegion da restituire + if ( ! IsNull( pSfrUp) && pSfrUp->IsValid()) // se Up valida, allora inizio a sostituire + pSfrProj->CopyFrom( pSfrUp) ; + if ( ! IsNull( pSfrUp1) && pSfrUp1->IsValid()) { // se Down valida... + if ( pSfrProj != nullptr && pSfrProj->IsValid()) { // e Up valida -> aggiungo + if ( ! pSfrProj->Add( *pSfrUp1)) + return false ; + } + else // se Up non valida -> copio + pSfrProj->CopyFrom( pSfrUp1) ; + } + + int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrUp->Clone()) ; + int o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrUp1->Clone()) ; + m_pGeomDB->SetMaterial( r, RED) ; + m_pGeomDB->SetMaterial( o, ORANGE) ; + m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj->Clone()) ; + + return pSfrProj != nullptr && pSfrProj->IsValid() && pSfrProj->GetChunkCount() != 0 ; +} + + //---------------------------------------------------------------------------- bool Pocketing::CloseCurvesOnProjectionSurface( ICurveComposite* pCrvCompo, const ISurfFlatRegion* pSrfProjDanger) @@ -11485,7 +11496,7 @@ Pocketing::GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pSt pSrfRaw_clone->Cut( plNear, true) ; if ( pSrfRaw_clone->IsValid()) pSrfRaw_clone->Cut( plFar, true) ; - // se step > 1 -> chiudo la superificie dalla parte del piano di far + // chiudo la superificie dalla parte del piano di far if ( ! IsNull( pSrfRaw_clone) && pSrfRaw_clone->IsValid()) { POLYLINEVECTOR vPL ; pSrfRaw_clone->GetLoops( vPL) ; @@ -11504,7 +11515,7 @@ Pocketing::GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pSt PtrOwner pStm_SideAtFar( CreateSurfTriMesh()) ; if ( pStm_SideAtFar->CreateByFlatContour( vPL[p])) { Vector3d vtN ; - if ( pStm_SideAtFar->GetFacetNormal( 0, vtN) && AreOppositeVectorApprox( vtN, plNear.GetVersN())) + if ( pStm_SideAtFar->GetFacetNormal( 0, vtN) && AreOppositeVectorApprox( vtN, -plNear.GetVersN())) pStm_SideAtFar->Invert() ; } pSrfRaw_clone->DoSewing( *pStm_SideAtFar) ; @@ -11558,110 +11569,6 @@ Pocketing::GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pSt // quindi in posizione 0 ho una curva con i lati aperti/chiusi già settati 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 perpendicolare, nel caso la salto - Vector3d vtN_check ; pStr_real->GetFacetNormal( f, vtN_check) ; - if ( abs( vtN_check * vtNorm) < EPS_ZERO) - continue ; - POLYLINEVECTOR vPL ; - pStr_real->GetFacetLoops( f, vPL) ; - // per ogni Loop l della faccia f - for ( int l = 0 ; l < ( int) vPL.size() ; ++ l) { - PtrOwner pCrvBorder( CreateCurveComposite()) ; - if ( IsNull( pCrvBorder) || ! pCrvBorder->FromPolyLine( vPL[l])) - return false ; - PtrOwner pCrvProjFacef( ProjectCurveOnPlane( *pCrvBorder, plProj)) ; - if ( IsNull( pCrvProjFacef) || ! pCrvProjFacef->IsValid()) - return false ; - // controllo validità della curva ( che sia chiusa e non degenere) - double dArea = EPS_SMALL ; - Plane3d plCheck ; - if ( ! pCrvProjFacef->IsClosed() || - ! pCrvProjFacef->GetArea( plCheck, dArea) || - dArea <= 5 * EPS_SMALL) - continue ; - // creo la curva composita associata - PtrOwner pCrvBorderProj_f( CreateCurveComposite()) ; - pCrvBorderProj_f->AddCurve( Release( pCrvProjFacef)) ; - // 1) controllo se una sottocurva della curva composita del bordo è sufficientemente vicina ad una curva aperta - // della curva originale di bordo della superificie esterna - bool bNeedProj = false ; - for ( int i = 0 ; i < pCrvBorderProj_f->GetCurveCount() && !bNeedProj; ++ i) { - const ICurve* pCrv_i = pCrvBorderProj_f->GetCurve( i) ; - if ( pCrv_i == nullptr) - return false ; - for ( int j = 0 ; j < ( int)vCrvOpen.size() && !bNeedProj ; ++ j) { - int nStat = -1 ; - const double nMAX = 10.0 ; - for ( int i = 0 ; i <= nMAX && !bNeedProj ; ++i) { - double dPar = i / nMAX ; - Point3d ptC ; pCrv_i->GetPointD1D2( dPar, ICurve::FROM_PLUS, ptC) ; - if ( vCrvOpen[j]->IsPointOn( ptC, 150 * EPS_SMALL)) - bNeedProj = true ; - } - } - } - if ( ! bNeedProj) { - // 2) controllo se un tratto aperto è sufficientemente vicino ad una sottocurva della curva composita del bordo - // della proiezione - for ( int j = 0 ; j < ( int)vCrvOpen.size() && !bNeedProj ; ++ j) { - for ( int u = 0 ; u < ( int)vCrvOpen[j]->GetCurveCount() && !bNeedProj ; ++ u) { - const ICurve* pCrv_j_u = vCrvOpen[j]->GetCurve( u) ; - if ( pCrv_j_u == nullptr) - return false ; - int nStat = -1 ; - if ( CheckSimpleOverlap( pCrv_j_u, pCrvBorderProj_f, nStat, 150 * EPS_SMALL) && nStat == 1) - bNeedProj = true ; - } - } - } - if ( ! bNeedProj) { - // 3) controllo se la questa curva contiene o interseca un lato aperto - // 3.1) creo una flat region ausiliaria per determinare il verso corretto della curva proeittata - PtrOwner pSrf_HelpProjPart( CreateSurfFlatRegion()) ; - if ( IsNull( pSrf_HelpProjPart)) - return false ; - pSrf_HelpProjPart->AddExtLoop( pCrvBorderProj_f->Clone()) ; - if ( AreOppositeVectorApprox( pSrf_HelpProjPart->GetNormVersor(), pSrfOrig->GetNormVersor())) - pSrf_HelpProjPart->Invert() ; - // 3.2) ricavo la curva di bordo della regione ( lascio le isole invariate) <- possibile miglioria (?) - PtrOwner pCrvBorder_Check( ConvertCurveToComposite( pSfrPock->GetLoop( 0, 0))) ; - if ( IsNull( pCrvBorder_Check) || ! pCrvBorder_Check->IsValid()) - return false ; - // 3.3) classificazione - CRVCVECTOR ccClass_H ; - if ( pSrf_HelpProjPart->GetCurveClassification( *pCrvBorder_Check, EPS_SMALL, ccClass_H)) { - for ( int j = 0 ; j < ( int)ccClass_H.size() && !bNeedProj ; ++ j) { - if ( ccClass_H[j].nClass == CRVC_IN) { - // se tratto j di curva interno, controllo se c'è un sotto-tratto jj aperto - PtrOwner pCrvCompo_forOpens( - ConvertCurveToComposite( pCrvBorder_Check->CopyParamRange( ccClass_H[j].dParS, ccClass_H[j].dParE))) ; - if ( ! IsNull( pCrvCompo_forOpens) && pCrvCompo_forOpens->IsValid()) { - // scorro le sottocurve del tratto j - for ( int u = 0 ; u < pCrvCompo_forOpens->GetCurveCount() && !bNeedProj ; ++ u) { - int nTmpProp0 = 0 ; - if ( pCrvCompo_forOpens->GetCurveTempProp( u, nTmpProp0, 0) && nTmpProp0 == 1) - bNeedProj = true ; - } - } - } - } - } - } - if ( ! bNeedProj) // se non devo proiettare passo alla prossima - continue ; - - // 3) Setto tutte le sottocurve aperte - for ( int uu = 0 ; uu < pCrvBorderProj_f->GetCurveCount() ; ++ uu) - pCrvBorderProj_f->SetCurveTempProp( uu, 1, 0) ; - - // inserisco nel vettore delle curve di bordo - vCrvExtProj.emplace_back( Release( pCrvBorderProj_f)) ; // <---- dall'indice 1 in poi ho solo curve aperte e - // sono le curve di bordo delle proeizioni - } - } - // Clono la superificie di partenza ( per sicurezza lascio invariata quella passata alla funzione) PtrOwner pSrf_Clone( CloneSurfFlatRegion( pSfr)) ; if ( IsNull( pSrf_Clone) || ! pSrf_Clone->IsValid()) @@ -11672,45 +11579,31 @@ Pocketing::GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pSt if ( IsNull( pSrf_Proj_Ext)) return false ; - // ---------------- CREAZIONE DELLA VERA A PROPRIA REGIONE DI INCIDENZA, COME SOMMA DELLE - // ----------------------------- SINGOLE FLATREGIONS DI PROIEZIONE ----------------------------- - for ( int i = 1 ; i < ( int)vCrvExtProj.size() ; ++ i) { - CRVCVECTOR ccClass ; - if ( pSrf_Clone->GetCurveClassification( *vCrvExtProj[i], 150 * EPS_SMALL, ccClass)) { - bool bAdd = false ; - for ( int j = 0 ; j < ( int)ccClass.size() && !bAdd ; ++ j) - bAdd = ccClass[j].nClass == CRVC_OUT || ccClass[j].nClass == CRVC_ON_M || ccClass[j].nClass == CRVC_ON_P ; - if ( bAdd) { - PtrOwner pSrf_H( CreateSurfFlatRegion()) ; - if ( IsNull( pSrf_H)) - return false ; - pSrf_H->AddExtLoop( vCrvExtProj[i]->Clone()) ; - // inverto se le normali risultano opposte - if ( pSrf_H->IsValid()) { - if ( AreOppositeVectorApprox( pSrf_H->GetNormVersor() , pSrf_Clone->GetNormVersor())) - pSrf_H->Invert() ; - } - if ( pSrf_Proj_Ext->GetChunkCount() == 0) - pSrf_Proj_Ext.Set( Release( pSrf_H)) ; - else { - PtrOwner pSrf_Check( CloneSurfFlatRegion( pSrf_Proj_Ext)) ; - if ( IsNull( pSrf_Check)) - return false ; - if ( ! pSrf_Proj_Ext->Add( *pSrf_H) || ! pSrf_Proj_Ext->IsValid()) - pSrf_Proj_Ext.Set( Release( pSrf_Proj_Ext)) ; - } - } - } - } + //m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStr_real->Clone()) ; + if ( ! ProjectStmOnPlane( pStr_real, plProj, pSrf_Proj_Ext)) + return false ; + if ( IsNull( pSrf_Proj_Ext) || ! pSrf_Proj_Ext->IsValid()) return true ; - // creo la vera e propria regione di proiezione, sommando la proiezione esterna con la superifcie originale da svuotare + for ( int c = 0 ; c < pSrf_Proj_Ext->GetChunkCount() ; ++ c) { + for ( int l = 0 ; l < pSrf_Proj_Ext->GetLoopCount( c) ; ++ l) { + PtrOwner pCrvCompoLoop( ConvertCurveToComposite( pSrf_Proj_Ext->GetLoop( c, l))) ; + if ( IsNull( pCrvCompoLoop) || ! pCrvCompoLoop->IsValid()) + return false ; + for ( int u = 0 ; u < pCrvCompoLoop->GetCurveCount() ; ++ u) + pCrvCompoLoop->SetCurveTempProp( u, 1, 0) ; + vCrvExtProj.emplace_back( Release( pCrvCompoLoop)) ; + } + } + + // creo la vera e propria regione di proiezione, sommando la proiezione esterna con la superficie originale + // da svuotare PtrOwner pSrf_Proj( CloneSurfFlatRegion( pSrf_Proj_Ext)) ; if ( IsNull( pSrf_Proj) || ! pSrf_Proj->IsValid()) return false ; pSrf_Proj->Add( *pSfr) ; - pSrf_Proj->Add( *pSfr) ; + //pSrf_Proj->Add( *pSfr) ; // controllo i loop della superificie creata ------------------------ SurfFlatRegionByContours SrfByC ; @@ -13835,8 +13728,8 @@ Pocketing::GetDynamicClearedRegion( ISurfFlatRegion* pSrfPrec, const ICurveCompo //---------------------------------------------------------------------------- bool -Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const Plane3d plPock, const Vector3d& vtExtr, - const double dThick, double dToll) +Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const Plane3d plPock, + const Vector3d& vtExtr, const double dThick, double dToll) { // controllo validità dei parametri if ( pStm == nullptr || ! pStm->IsValid() || @@ -13878,6 +13771,9 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P PtrOwner pCrv_c( pCrv->CopyParamRange( dS, dE)) ; if ( IsNull( pCrv_c) || ! pCrv_c->IsValid()) return false ; + + //m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv_c->Clone()) ; + PtrOwner pCrv_proj( ProjectCurveOnPlane( *pCrv_c, plPock)) ; SrfChunkDef.AddCurve( Release( pCrv_proj)) ; // aggiungo le curve proiettate } diff --git a/Pocketing.h b/Pocketing.h index 994019a..7c363c8 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -102,6 +102,7 @@ class Pocketing : public Machining const double& dDepth, const double& dStep) ; bool GetAdaptedSfrByTrimesh( const ISurfFlatRegion* pSfrExtended, const ISurfFlatRegion* pSfrORIG, const ISurfTriMesh* pStmORIG, const Vector3d& vtTrasl, ISurfFlatRegion* pNewSrfPock) ; + bool ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPock, ISurfFlatRegion* pSfrProj) ; bool AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, ISurfTriMesh* pStmRaw, const double& dRawSecLen, ICRVCOMPOPOVECTOR& vCrvOEFlags, bool& bChanged, int nStep, double dStep, double dAreaToll = 500 * EPS_SMALL) ;