diff --git a/Pocketing.cpp b/Pocketing.cpp index a3d6495..3c65dfb 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -1365,6 +1365,11 @@ Pocketing::ResetCurveAllTempProp( ICurve* pCurve) bool Pocketing::Chain( int nGrpDestId) { + // controllo quanti elementi ho nel vettore degli indici selezionati + int nSelId = ( int)m_vId.size() ; + if ( nSelId > 1 && ! CheckSelectedId()) + return false ; + // vettore puntatori alle curve ICURVEPOVECTOR vpCrvs ; vpCrvs.reserve( m_vId.size()) ; @@ -2053,6 +2058,31 @@ Pocketing::GeneratePocketingPv( int nPathId, const ISurfFlatRegion* pSrfPock) return true ; } +//---------------------------------------------------------------------------- +bool +Pocketing::CheckSelectedId( ) { + + // se non ho almeno due Id selezionati, allora esco + if (( int)m_vId.size() <= 1) + return true ; + + // Controllo Tra gli Id Selezionati se ho una Trimesh + // NB. Il primo Id selezionato ( o i primi Id selezionati nel caso di curve) rapprensentano la geometria che + // voglio svuotare; cerco, se presente, una TriMesh dopo l'indice 0 + for ( int i = 1 ; i < ( int)m_vId.size() ; ++ i) { + int nCurrId = m_vId[i].nId ; + // recupero l'oggetto geometrico associato a tale Id + const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nCurrId) ; + if ( pGObj == nullptr) + return false ; + // se tale oggetto esiste ed è una TriMesh, allora rappresenta il risultato della svuotatura voluto + if ( pGObj->GetType() == SRF_TRIMESH) + return DetectShape( nCurrId, GLOB_FRM) ; + } + + return true ; +} + //---------------------------------------------------------------------------- static double GetCurveRadius( const ICurve* pCrv) @@ -2179,8 +2209,10 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c bool bOptimizedZigZag = false ; bool bOutRawLeadIn = false ; ICRVCOMPOPOVECTOR vpCrvs ; // vettore con i paths a ZigZag per il Chunk (c)-esimo allo step (j)-esimo + ICRVCOMPOPOVECTOR vCrvIslMergeBorders ; // vettore delle possibili isole mergiate per il Chunk (c)-esimo allo step (j)-esimo double dOptZigZagOffs ; - if ( ! OptimizedZigZag( pSrfChunkFinal, vtTool, dDepth, dSafeZ, frPocket, vCrvOEWithFlags[j-1][nInd], bOptimizedZigZag, vpCrvs, dOptZigZagOffs)) + if ( ! OptimizedZigZag( pSrfChunkFinal, vtTool, dDepth, dSafeZ, frPocket, vCrvOEWithFlags[j-1][nInd], + bOptimizedZigZag, vpCrvs, vCrvIslMergeBorders, dOptZigZagOffs)) return false ; if ( bOptimizedZigZag && ! vpCrvs.empty()) { // se sono in un caso ottimizzato ... @@ -2450,15 +2482,17 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c // Una volta percorse le curve di ZigZag devo aggiungere le curve per il bordo // creo un vettore con tutti i loop formati, aggiustando i loro punti iniziali e portandoli nel frame della svuotatura - // NB. se sono in un caso ottimizzato uso solo i loop interni + // NB. se sono in un caso ottimizzato uso solo i loop interni ( se non rivatai mergiati) ICRVCOMPOPOVECTOR vAllCrv ; for ( int l = bOptimizedZigZag ? 1 : 0 ; l < pSrfForCrv->GetLoopCount( cfc) ; ++ l) - vAllCrv.emplace_back( GetCurveComposite( pSrfForCrv->GetLoop( cfc, l))) ; + vAllCrv.emplace_back( ConvertCurveToComposite( pSrfForCrv->GetLoop( cfc, l))) ; + for ( int u = 0 ; u < ( int)vCrvIslMergeBorders.size() ; ++ u) + vAllCrv.emplace_back( ConvertCurveToComposite( vCrvIslMergeBorders[u]->Clone())) ; // Sistemo i punti iniziali per i nuovi Chunks ------------------------------------------ VCT3DVECTOR vVtMidOut(( int) vAllCrv.size(), V_NULL) ; BOOLVECTOR vbMidOut(( int) vAllCrv.size(), false) ; - PNTVECTOR vPtStart(( int) vAllCrv.size(), Point3d( 0,0,0)) ; + PNTVECTOR vPtStart(( int) vAllCrv.size(), Point3d( 0, 0, 0)) ; BOOLVECTOR vbForcedOutStart(( int) vAllCrv.size(), false) ; // se sono in un caso ottimizzato e non ho isole non ho bisogno di fare nulla... @@ -2470,7 +2504,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c bool bOutTmp = false ; if ( ! SetBetterPtStartForSubChunks( vAllCrv[u], pSrfChunkFinal, - vPtStart[u], vVtMidOut[u], bOutTmp, dOffs)) + vPtStart[u], vVtMidOut[u], bOutTmp, dOffs)) return false ; vbMidOut[u] = bOutTmp ; // vector::reference da Bit a Bool @@ -3233,8 +3267,8 @@ Pocketing::CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurv //---------------------------------------------------------- bool Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, double dDepth, double dSafeZ, - Frame3d& frPocket, ICurveComposite* pCrvOrig, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs, - double& dOffs) + Frame3d& frPocket, ICurveComposite* pCrvOrig, bool& bOptimizedZigZag, + ICRVCOMPOPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvIslMergeBorders, double& dOffs) { // clono la superficie (chunk c-esimo dell'originale) PtrOwner pSrfPocket( CloneSurfFlatRegion( pSrf)) ; @@ -3298,10 +3332,12 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl break ; } + // se non sono in un caso ottimizzato, allora esco if ( ! bOptimizedZigZag) return true ; - if ( vtDir.IsZero()) + // frame per direzione più lunga per la svuotatura a ZigZag + if ( vtDir.IsZero()) pCrvPocket->GetStartDir( vtDir) ; double dAng ; vtDir.GetAngleXY( X_AX, dAng) ; @@ -3320,6 +3356,7 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl ICRVCOMPOPOVECTOR vFirstOffsets ; vFirstOffsets.emplace_back( Release( pCrvPocket)) ; // la curva esterna modificata + // parametri per Offset double dTRad = m_TParams.m_dDiam / 2 ; double dMyOffs = dTRad + GetOffsR() ; double dExtra = (( m_TParams.m_nType != TT_MILL_POLISHING) ? min( 0.1 * m_TParams.m_dDiam, 2.0) : 0) ; @@ -3328,47 +3365,182 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl if ( IsNull( pSrfPocketClone)) return false ; + // Offsetto la superficie per ricavare informazioni su eventuali isole e sulle loro possibili unioni if ( ! pSrfPocketClone->Offset( - dMyOffs - dExtra, ICurve::OFF_FILLET)) { // le isole interne vanno Offsettate m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ; return false ; } + // NB. Se il numero di Loop interni ora è cambiato, vuol dire che le isole si sono unite tra loro o con il bordo + // -> conto il numero di Loop interni prima e dopo l'Offset + int nLoopBef = 0 ; + for ( int c = 0 ; c < pSrfPocket->GetChunkCount() ; ++ c) + for ( int l = 1 ; l < pSrfPocket->GetLoopCount( c) ; ++ l) + ++ nLoopBef ; + int nLoopAft = 0 ; + for ( int c = 0 ; c < pSrfPocketClone->GetChunkCount() ; ++ c) + for ( int l = 1 ; l < pSrfPocketClone->GetLoopCount( c) ; ++ l) + ++ nLoopAft ; + + // vettore delle curve da tenere in considerazione... ICRVCOMPOPOVECTOR vCrvAllLoops ; - double dMaxArea = -INFINITO; int nIndex = -1; int p = 0 ; // p è il # di loop totali + double dMaxArea = -INFINITO ; int nIndex = -1 ; int p = 0 ; // p è il # di loop totali - for ( int cu = 0 ; cu < pSrfPocketClone->GetChunkCount() ; ++ cu) { - for ( int l = 0 ; l < pSrfPocketClone->GetLoopCount( cu) ; ++ l) { - // inserisco i loops portandoli nel nuovo sistema di riferimento - PtrOwner pCrvLoop( GetCurveComposite( pSrfPocketClone->GetLoop( cu, l))) ; - if ( IsNull( pCrvLoop)) - return false ; - pCrvLoop->ToGlob( frameH) ; - pCrvLoop->ToLoc( frPocket) ; + // superificie generata dalle isole + PtrOwner pSrfIslandsOff1( CreateSurfFlatRegion()) ; + PtrOwner pSrfIslandsOff2( CreateSurfFlatRegion()) ; + if ( IsNull( pSrfIslandsOff1) || IsNull( pSrfIslandsOff2)) + return false ; - double dArea ; pCrvLoop->GetAreaXY( dArea) ; - if ( dArea > dMaxArea) { - dMaxArea = dArea ; - nIndex = p ; + // Se il numero di Loop è rimasto uguale allora tengo le curve così come sono... + if ( nLoopAft == nLoopBef) { + for ( int cu = 0 ; cu < pSrfPocketClone->GetChunkCount() ; ++ cu) { + for ( int l = 0 ; l < pSrfPocketClone->GetLoopCount( cu) ; ++ l) { + // inserisco i loops portandoli nel nuovo sistema di riferimento + PtrOwner pCrvLoop( GetCurveComposite( pSrfPocketClone->GetLoop( cu, l))) ; + if ( IsNull( pCrvLoop)) + return false ; + pCrvLoop->ToGlob( frameH) ; + pCrvLoop->ToLoc( frPocket) ; + + double dArea ; pCrvLoop->GetAreaXY( dArea) ; + if ( dArea > dMaxArea) { + dMaxArea = dArea ; + nIndex = p ; + } + + vCrvAllLoops.emplace_back( Release( pCrvLoop)) ; + p++ ; } - - vCrvAllLoops.emplace_back( Release( pCrvLoop)) ; - p++ ; } } + // se il numero di curve è cambiato, allora creo una superficie da tutte le isole + else { + ICRVCOMPOPOVECTOR vCrvOff1Islands ; + for ( int cu = 0 ; cu < pSrfPocket->GetChunkCount() ; ++ cu) { + for ( int l = 1 ; l < pSrfPocket->GetLoopCount( cu) ; ++ l) { + PtrOwner pCrvIslLoop( ConvertCurveToComposite( pSrfPocket->GetLoop( cu, l))) ; + if ( IsNull( pCrvIslLoop) || ! pCrvIslLoop->IsValid()) + return false ; + pCrvIslLoop->ToGlob( frameH) ; + pCrvIslLoop->ToLoc( frPocket) ; + // Offset 1 dell'isola ------------ + OffsetCurve OffCrv1 ; + if ( ! OffCrv1.Make( pCrvIslLoop, - dMyOffs, ICurve::OFF_FILLET)) { + m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ; + return false ; + } + PtrOwner pCrvlonger1( OffCrv1.GetLongerCurve()) ; + while ( ! IsNull( pCrvlonger1)) { + if ( pCrvlonger1->IsClosed()) { + PtrOwner pCrvCompo( CreateCurveComposite()) ; + pCrvCompo->AddCurve( Release( pCrvlonger1)) ; + PtrOwner pSrfIsland_i( CreateSurfFlatRegion()) ; + if ( IsNull( pSrfIsland_i)) + return false ; + pSrfIsland_i->AddExtLoop( Release( pCrvCompo)) ; + if ( pSrfIsland_i->IsValid()) { + if ( AreOppositeVectorApprox( pSrfIsland_i->GetNormVersor(), vtTool)) + pSrfIsland_i->Invert() ; + } + if ( ! pSrfIslandsOff1->IsValid() || pSrfIslandsOff1->GetChunkCount() == 0) + pSrfIslandsOff1.Set( Release( pSrfIsland_i)) ; + else + pSrfIslandsOff1->Add( *pSrfIsland_i) ; + } + pCrvlonger1.Set( OffCrv1.GetLongerCurve()) ; + } + + // Offset 2 dell'isola -------------- + OffsetCurve OffCrv2 ; + if ( ! OffCrv2.Make( pCrvIslLoop, - dMyOffs - dExtra, ICurve::OFF_FILLET)) { + m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ; + return false ; + } + // le curve chiuse che ottengo le aggiungo al vettore delle curve di bordo + PtrOwner pCrvlonger2( OffCrv2.GetLongerCurve()) ; + while ( ! IsNull( pCrvlonger2)) { + if ( pCrvlonger2->IsClosed()) { + PtrOwner pCrvCompo( CreateCurveComposite()) ; + pCrvCompo->AddCurve( Release( pCrvlonger2)) ; + PtrOwner pSrfIsland_i( CreateSurfFlatRegion()) ; + if ( IsNull( pSrfIsland_i)) + return false ; + pSrfIsland_i->AddExtLoop( Release( pCrvCompo)) ; + if ( pSrfIsland_i->IsValid()) { + if ( AreOppositeVectorApprox( pSrfIsland_i->GetNormVersor(), vtTool)) + pSrfIsland_i->Invert() ; + } + if ( ! pSrfIslandsOff2->IsValid() || pSrfIslandsOff2->GetChunkCount() == 0) + pSrfIslandsOff2.Set( Release( pSrfIsland_i)) ; + else + pSrfIslandsOff2->Add( *pSrfIsland_i) ; + } + pCrvlonger2.Set( OffCrv2.GetLongerCurve()) ; + } + } + } + // aggiungo tutti i Loop al vettore delle curve utili + for ( int c = 0 ; c < pSrfIslandsOff2->GetChunkCount() ; ++ c) + for ( int l = 0 ; l < pSrfIslandsOff2->GetLoopCount( c) ; ++ l) + vCrvAllLoops.emplace_back( ConvertCurveToComposite( pSrfIslandsOff2->GetLoop( c, l))) ; + + } + + // vettore contentente il bordo esterno opportunamente allargato e le curve utili ( isole) for ( int i = 0 ; i < int( vCrvAllLoops.size()) ; ++ i) { if ( i != nIndex) { vFirstOffsets.emplace_back( vCrvAllLoops[i]->Clone()) ; } } - // creo la superficie da svuotare ottimizzata - SurfFlatRegionByContours pSrfMod ; - for ( int i = 0 ; i < int( vFirstOffsets.size()) ; ++ i) - pSrfMod.AddCurve( vFirstOffsets[i]->Clone()) ; - PtrOwner pSrfZigZag( pSrfMod.GetSurf()) ; + PtrOwner pSrfZigZag( CreateSurfFlatRegion()) ; if ( IsNull( pSrfZigZag)) return false ; + + if (( int)vFirstOffsets.size() > 0) { + pSrfZigZag->AddExtLoop( *vFirstOffsets[0]) ; + if ( pSrfZigZag->IsValid()) { + if ( AreOppositeVectorApprox( vtExtr, pSrfZigZag->GetNormVersor())) + pSrfZigZag->Invert() ; + // sottraggo le isole ( se presenti) + if ( pSrfIslandsOff2->IsValid() || pSrfIslandsOff2->GetChunkCount() > 0) { + if ( AreOppositeVectorApprox( pSrfZigZag->GetNormVersor(), pSrfIslandsOff2->GetNormVersor())) + pSrfIslandsOff2->Invert() ; + m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfZigZag->Clone()) ; + m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfIslandsOff2->Clone()) ; + if ( ! pSrfZigZag->Subtract( *pSrfIslandsOff2)) + return false ; + m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfZigZag->Clone()) ; + // aggiungo le curve della superficie delle isole alle curve da percorrere ( se necessario) + if ( nLoopAft != nLoopBef) { + if ( AreSameVectorApprox( pSrfZigZag->GetNormVersor(), pSrfIslandsOff2->GetNormVersor())) + pSrfIslandsOff2->Invert() ; + pSrfIslandsOff1->Invert() ; + pSrfIslandsOff1->ToGlob( frameH) ; + pSrfIslandsOff1->ToLoc( frPocket) ; + for ( int c = 0 ; c < pSrfIslandsOff1->GetChunkCount() ; ++ c) + for ( int l = 0 ; l < pSrfIslandsOff1->GetLoopCount( c) ; ++ l) + vCrvIslMergeBorders.emplace_back( ConvertCurveToComposite( pSrfIslandsOff1->GetLoop( c, l))) ; + } + } + else { + // creo la superficie da svuotare ottimizzata + SurfFlatRegionByContours pSrfMod ; + for ( int i = 0 ; i < int( vFirstOffsets.size()) ; ++ i) + pSrfMod.AddCurve( vFirstOffsets[i]->Clone()) ; + pSrfZigZag.Set( pSrfMod.GetSurf()) ; + if ( IsNull( pSrfZigZag) || ! pSrfZigZag->IsValid()) + return false ; + if ( AreOppositeVectorApprox( vtExtr, pSrfZigZag->GetNormVersor())) + pSrfZigZag->Invert() ; + } + } + } + else + return false ; + if ( AreOppositeVectorApprox( vtExtr, pSrfZigZag->GetNormVersor())) pSrfZigZag->Invert() ; @@ -4541,8 +4713,9 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, bool bUhAboveRaw = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - if ( bAhUnderRaw || bUhAboveRaw ) - dStElev = max( dStElev, dCurrAffondamento) ; + //if ( bAhUnderRaw || bUhAboveRaw ) + //dStElev = max( dStElev, dCurrAffondamento) ; + dStElev = max( dStElev, j * dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco if ( GetLeadInType() == POCKET_LI_ZIGZAG || @@ -4556,7 +4729,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ; return false ; } - dStElev = max( dStElev, dCurrAffondamento) ; + dStElev = max( dStElev, j * dStep) ; // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, pRCrv, !m_Params.m_bInvert, bSplitArcs, bOutStart || bForcedOutStart)) { @@ -9491,18 +9664,7 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector pStmShape( CreateSurfTriMesh()) ; - pStmShape->AdjustTopology() ; - if ( m_bHasShape) { - if ( ! DetectShape( nProp0, pStmShape, GLOB_FRM)) - return false ; - int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmShape->Clone()) ; - m_pGeomDB->SetMaterial( r, Color( 1.0, 0.0, 0.0, 0.5)) ; - } // ====================================================================================== - // ======================== AD OGNI STEP ADATTO LA SUPERIFICIE ========================== // ADATTAMENTO A TRIMESH ( se necessario) o SHAPE, INTERSEZIONE, PROIEZIONE // ED ESTENSIONE PRESSO LATI APERTI @@ -9529,7 +9691,7 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vectorClone()) ; // la superificie potrebbe non essere valida ( ad esempio se già svuotata tutta con un Tool in precedenza...) @@ -9560,42 +9722,37 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vectorGetParentId( nId) ; - if ( nProcessingId != GDB_ID_NULL) { - int nPartId = m_pGeomDB->GetParentId( nProcessingId) ; - if ( nPartId != GDB_ID_NULL) { - int nIdIter = m_pGeomDB->GetFirstNameInGroup( nPartId, "Proc" ) ; - if ( nIdIter != GDB_ID_NULL) { - int nIdShape = m_pGeomDB->GetFirstInGroup( nIdIter) ; - if ( nIdShape != GDB_ID_NULL) { - const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nIdShape) ; - Frame3d frRawPart ; - m_pGeomDB->GetGlobFrame( nIdIter, frRawPart) ; - if ( pGObj == nullptr) - return false ; - if ( pGObj->GetType() == SRF_TRIMESH) { - PtrOwner pSrfRawPart( CloneSurfTriMesh( pGObj)) ; - if ( IsNull( pSrfRawPart)) - return false ; - pSrfRawPart->LocToLoc( frRawPart, frPocket) ; - pSrfTMShape->CopyFrom( pSrfRawPart) ; - // se shape presente ma non valida, errore - if ( pSrfTMShape == nullptr || ! pSrfTMShape->IsValid() || pSrfTMShape->GetTriangleCount() == 0) - return false ; - } - } - } - } - } + // recupero l'oggetto geometrico + const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nId) ; + if ( pGObj == nullptr) + return false ; + + // se l'oggetto geometrico non è una trimesh, allora errore + if ( pGObj->GetType() != SRF_TRIMESH) + return false ; - return true ; + // recupero il Frame in cui si trova + Frame3d frRawPart ; + m_pGeomDB->GetGlobFrame( nId, frRawPart) ; + + // recupero la TriMesh ( shape) associata all'oggetto geometrico + PtrOwner pSrfRawPart( CloneSurfTriMesh( pGObj)) ; + if ( IsNull( pSrfRawPart)) + return false ; + + // porto la TriMesh ( shape) dal suo frame al frame richiesto + pSrfRawPart->LocToLoc( frRawPart, frPocket) ; + + // assegno la TriMesh ( shape) al parametro della funzione e controllo la sua validità + m_pStmShape.Set( Release( pSrfRawPart)) ; + return m_pStmShape != nullptr && m_pStmShape->IsValid() && m_pStmShape->GetTriangleCount() > 0 ; } @@ -9999,7 +10156,7 @@ Pocketing::ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPoc for ( int t = 0 ; t < pStmRef->GetTriangleCount() ; ++ t) { Vector3d vtNTria ; if ( pStmRef->GetFacetNormal( pStmRef->GetFacetFromTria( t), vtNTria) && - vtNTria * vtN > 10 * EPS_ANG_SMALL) { + vtNTria * vtN > EPS_SMALL) { Triangle3d Tria ; pStmRef->GetTriangle( t, Tria) ; TriaSoupEasy.AddTriangle( Tria) ; } @@ -10012,13 +10169,9 @@ Pocketing::ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPoc // 3) scalo la superficie rispetto al sistema di riferimento ( mettendo a 0 la componente vtN) pStmRef->ToLoc( frPlane) ; - //int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmRef->Clone()) ; - //m_pGeomDB->SetMaterial( G, GREEN) ; if ( ! pStmRef->Scale( GLOB_FRM, 1., 1., 0.)) return false ; pStmRef->ToGlob( frPlane) ; - //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) @@ -10068,24 +10221,13 @@ Pocketing::ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPoc pSfrProj->CopyFrom( pSfrUp) ; if ( ! IsNull( pSfrUp1) && pSfrUp1->IsValid()) { // se Down valida... if ( pSfrProj != nullptr && pSfrProj->IsValid()) { // e Up valida -> aggiungo - if ( ! pSfrProj->Add( *pSfrUp1)) { - int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj->Clone()) ; - m_pGeomDB->SetMaterial( a, ORANGE) ; - int v = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrUp1->Clone()) ; - m_pGeomDB->SetMaterial( v, PURPLE) ; + 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 ; } @@ -10293,15 +10435,15 @@ Pocketing::SubtractFinalShape( ISurfFlatRegion* pSfrCurr, const Vector3d& vtTras if ( IsNull( pSfrCurr_c) || ! pSfrCurr_c->IsValid()) return false ; - int W = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrCurr_c->Clone()) ; - m_pGeomDB->SetMaterial( W, WHITE) ; - int F = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrShape_c->Clone()) ; - m_pGeomDB->SetMaterial( F, BLACK) ; + //int W = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrCurr_c->Clone()) ; + //m_pGeomDB->SetMaterial( W, WHITE) ; + //int F = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrShape_c->Clone()) ; + //m_pGeomDB->SetMaterial( F, BLACK) ; if ( ! pSfrCurr_c->Subtract( *pSfrShape_c)) return false ; - int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrCurr_c->Clone()) ; - m_pGeomDB->SetMaterial( G, GRAY) ; + //int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrCurr_c->Clone()) ; + //m_pGeomDB->SetMaterial( G, GRAY) ; // ricalcolo le TmpProp SurfFlatRegionByContours sfrBC ; @@ -14036,6 +14178,9 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P // essendo una curva derivante da un'intersezione di Trimesh ho una composita derivante da una polyLine, // devo recuperare gli archi PolyArc PA ; + pCrv->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ; + //int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ; + //m_pGeomDB->SetMaterial( b, BLUE) ; pCrv->ToLoc( frPock) ; pCrv->ApproxWithArcsEx( 500 * EPS_SMALL, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) ; // 5 * EPS_SMALL pCrv->Clear() ; @@ -14050,8 +14195,10 @@ 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 ; + //int p = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ; + //m_pGeomDB->SetMaterial( p, PURPLE) ; - // se la curva è "stretta" la trascuro, rende sono difficili i conti senza dare valore aggiunto + // se la curva è "stretta" la trascuro, rende solo difficili i conti senza dare valore aggiunto PtrOwner pCrv_proj( ProjectCurveOnPlane( *pCrv_c, plPock)) ; double dAreaCheck = EPS_SMALL ; Plane3d plCheck ; if ( ! IsNull( pCrv_proj) && @@ -14062,6 +14209,8 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P } + //int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv_c->Clone()) ; + //m_pGeomDB->SetMaterial( g, GREEN) ; SrfChunkDef.AddCurve( Release( pCrv_proj)) ; // aggiungo le curve proiettate } @@ -14088,9 +14237,9 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P } } - // pSrfByCurves.Set( SFRFINAL.GetSurf()) ; - // if ( IsNull( pSrfByCurves) || pSrfByCurves->GetChunkCount() == 0) // controllo ancora validità della FlatRegion - // return true ; // non ho ricavato nulla, la TriMesh è troppo sottile o piccola + pSrfByCurves.Set( SFRFINAL.GetSurf()) ; + if ( IsNull( pSrfByCurves) || pSrfByCurves->GetChunkCount() == 0) // controllo ancora validità della FlatRegion + return true ; // non ho ricavato nulla, la TriMesh è troppo sottile o piccola // restituisco la FlatRegion pSfr->Clear() ; diff --git a/Pocketing.h b/Pocketing.h index 3fe3381..fe3b376 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -79,6 +79,8 @@ class Pocketing : public Machining bool CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) const ; bool VerifyPathFromBottom( const ISurfFlatRegion* pSrf, const Vector3d& vtTool) ; bool GeneratePocketingPv( int nPathId, const ISurfFlatRegion* pSrfPock) ; + bool CheckSelectedId( void) ; + bool DetectShape( int nId, Frame3d frPocket) ; // =========================== MIGLIORIE GENERALI ==================== bool ModifyCurveToSmoothed( ICurveComposite* pCrvOffset, double dRightPer, double dleftPer) ; @@ -103,7 +105,6 @@ 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 DetectShape( int nId, ISurfTriMesh* pSrfTMShape, Frame3d frPocket) ; bool ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPock, ISurfFlatRegion* pSfrProj) ; bool CalcExtraSteps( const ISurfFlatRegion* pSfrAct, const ISurfTriMesh* pStmORIG, const Vector3d vtTool, const double& dElev, const double& dDepth, const int& nStep, @@ -173,7 +174,7 @@ class Pocketing : public Machining bool CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurveComposite* pCrvLink) ; bool OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d & vtTool, double dDepth, double dSafeZ, Frame3d& frPocket, ICurveComposite* pCrvOrig, bool& bOptimizedZigZag, - ICRVCOMPOPOVECTOR& vpCrvs, double& dOffs) ; + ICRVCOMPOPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvIslMergeBorders, double& dOffs) ; bool ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ; bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ; @@ -354,6 +355,7 @@ class Pocketing : public Machining bool m_bIntersRaw = true ; // flag per intersezione con grezzo bool m_bProjectRaw = true ; // flag di proiezione del grezzo bool m_bHasShape = true ; // flag per presenza di geometria voluta + PtrOwner m_pStmShape ; // puntatore alla superficie TriMesh da seguire double m_dMaxLenRawProj = 200 ; // 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