diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index c3a359e..dde33f5 100644 Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ diff --git a/PocketingNT.cpp b/PocketingNT.cpp index 6414007..85623d7 100644 --- a/PocketingNT.cpp +++ b/PocketingNT.cpp @@ -2220,9 +2220,45 @@ PocketingNT::GetExtrusionStm( const ISurfFlatRegion* pSfr, const Vector3d& vtExt return ( Release( pStmExtrusion)) ; } +//---------------------------------------------------------------------------- +ISurfTriMesh* +PocketingNT::GetStmRawSliced( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool) const +{ + // controllo dei parametri + if ( pStmRaw == nullptr || ! pStmRaw->IsValid()) + return nullptr ; + if ( pSfr == nullptr || ! pSfr->IsValid()) + return CloneSurfTriMesh( pStmRaw) ; + + PtrOwner pStmRawSliced( CloneSurfTriMesh( pStmRaw)) ; + Point3d ptCenPrev ; pSfr->GetCentroid( ptCenPrev) ; + Plane3d plProjPrev ; + if ( ! plProjPrev.Set( ptCenPrev, vtTool)) + return nullptr ; + pStmRawSliced->Cut( plProjPrev, true) ; + if ( pStmRawSliced->IsValid() && pStmRawSliced->GetTriangleCount() > 0 ) { + // chiudo la TriMesh + POLYLINEVECTOR vPL ; + if ( ! pStmRawSliced->GetLoops( vPL)) + return CloneSurfTriMesh( pStmRaw) ; + for ( const PolyLine& PL : vPL) { + PtrOwner pCompoLoop( CreateCurveComposite()) ; + if ( IsNull( pCompoLoop) || ! pCompoLoop->FromPolyLine( PL)) + return CloneSurfTriMesh( pStmRaw) ; + PtrOwner pStmCap( GetSurfTriMeshByFlatContour( pCompoLoop, EPS_SMALL)) ; + if ( IsNull( pStmCap) || ! pStmCap->IsValid() || ! pStmCap->Invert()) + return CloneSurfTriMesh( pStmRaw) ; + if ( ! pStmRawSliced->DoSewing( *pStmCap)) + return CloneSurfTriMesh( pStmRaw) ; + } + } + + return ( ( ! IsNull( pStmRawSliced) && pStmRawSliced->IsValid()) ? Release( pStmRawSliced) : nullptr) ; +} + //---------------------------------------------------------------------------- ISurfFlatRegion* -PocketingNT::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs) +PocketingNT::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs) const { // interseco la superficie alla quota corrente PNTVECTOR vPnt ; @@ -2302,8 +2338,8 @@ PocketingNT::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, doubl //---------------------------------------------------------------------------- ISurfFlatRegion* -PocketingNT::GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool, - const Frame3d& frAtTop, ICAvParSilhouettesSurfTm** ppCavParSil) +PocketingNT::GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, + const Vector3d& vtTool, const Frame3d& frAtTop, ICAvParSilhouettesSurfTm** ppCavParSil) { // controllo dei parametri if ( pStmRaw == nullptr || ! pStmRaw->IsValid() || pSfr == nullptr || ! pSfr->IsValid()) @@ -2967,7 +3003,7 @@ PocketingNT::ExtendOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm) //---------------------------------------------------------------------------- bool -PocketingNT::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion) +PocketingNT::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion) const { // controllo parametri : if ( pSfr == nullptr || ! pSfr->IsValid() || pStmExtrusion == nullptr) @@ -3246,6 +3282,54 @@ PocketingNT::ChooseRawPart( const ISurfFlatRegion* pSfrChunk, ISurfTriMesh* pStm return true ; } +//---------------------------------------------------------------------------- +bool +PocketingNT::TrimRawByMaxElev( ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dMaxElev) const +{ + // se grezzo non definito, errore + if ( pStmRaw == nullptr || ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0) + return false ; + // se regione non definita, errore + if ( pSfr == nullptr || ! pSfr->IsValid()) + return false ; + // se massima elevazione poco significativa, non faccio nulla + if ( dMaxElev < 10. * EPS_SMALL) + return true ; + + // dalla regione definisco un piano di taglio tenendo conto della massima elevazione + Point3d ptCentroid ; pSfr->GetCentroid( ptCentroid) ; + Plane3d plCut ; plCut.Set( ptCentroid + vtTool * dMaxElev, vtTool) ; + + // eseguo il taglio del grezzo + if ( ! pStmRaw->Cut( plCut, true)) + return false ; + + // se non è rimasto un grezzo valido, ho finito + if ( ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0) + return true ; + + // chiudo il grezzo trimmato definnendo un volume + POLYLINEVECTOR vPL ; + if ( ! pStmRaw->GetLoops( vPL)) + return false ; + for ( const PolyLine& PL : vPL) { + PtrOwner pCompoLoop( CreateCurveComposite()) ; + if ( IsNull( pCompoLoop) || ! pCompoLoop->FromPolyLine( PL)) + return false ; + PtrOwner pStmCap( GetSurfTriMeshByFlatContour( pCompoLoop)) ; + if ( IsNull( pStmCap) || ! pStmCap->IsValid() || pStmCap->GetTriangleCount() == 0) + return false ; + // verifico che la superficie sia orientata correttamente per la cucitura + Triangle3d Tria ; pStmCap->GetFirstTriangle( Tria) ; + if ( AreOppositeVectorApprox( Tria.GetN(), vtTool)) + pStmCap->Invert() ; + if ( ! pStmRaw->DoSewing( *pStmCap)) + return false ; + } + + return ( pStmRaw->IsValid() && pStmRaw->GetTriangleCount() > 0) ; +} + //---------------------------------------------------------------------------- bool PocketingNT::ManageOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm) @@ -3568,7 +3652,7 @@ PocketingNT::ManageOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm) bool PocketingNT::CheckMaxDepth( const ISurfFlatRegion* pSfr, double dDepth, const Vector3d& vtTool, const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmExtrusion, - const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth) + const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth) const { // controllo dei parametri if ( pSfr == nullptr || ! pSfr->IsValid() || @@ -3947,66 +4031,34 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId) const double MIN_ZSTEP = 1.0 ; if ( dOkStep >= EPS_SMALL && dOkStep < MIN_ZSTEP) { dOkStep = MIN_ZSTEP + EPS_SMALL ; - string sInfo = "Warning in PocketingNT : machining step too small (" + - ToString( m_Params.m_dStep, 2) + ")" ; + string sInfo = "Warning in PocketingNT : machining step too small (" + ToString( m_Params.m_dStep, 2) + ")" ; m_pMchMgr->SetWarning( 2456, sInfo) ; } - // calcolo l'elevazione inversa per definire la Depth massima - double dInvElev = 0. ; - pSfr->Invert() ; - if ( ! CalcRegionElevation( pSfr, vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, dInvElev)) { - m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ; - return false ; - } - pSfr->Invert() ; - double dExtraDepth = ( dOkStep < EXTRA_DEPTH ? dOkStep / 2. : EXTRA_DEPTH) ; - if ( dOkStep < EPS_SMALL) - dExtraDepth = EXTRA_DEPTH ; - dDepth = min( dDepth, dInvElev + dExtraDepth) ; - - // calcolo l'elevazione massima - double dElev = 0. ; - if ( ! CalcRegionElevation( pSfr, vtTool, dDepth, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev)) { - m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ; - return false ; - } - double dMaxElev ; - if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev) && dElev > dMaxElev) - dElev = dMaxElev ; - - // verifico che il massimo materiale dell'utensile sia sensato - const double MIN_MAXMAT = 1.0 ; - if ( m_TParams.m_dMaxMat < dElev && m_TParams.m_dMaxMat < MIN_MAXMAT) { - string sInfo = "Error in PocketingNT : Tool MaxMaterial too small (" + - ToString( m_TParams.m_dMaxMat, 2) + ")" ; - m_pMchMgr->SetLastError( 2422, sInfo) ; - return false ; - } - - // verifico di non superare il massimo materiale (se lo step supera la capacità dell'utensile) - if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) { - dOkStep = m_TParams.m_dMaxMat + EPS_SMALL ; - string sInfo = "Warning in PocketingNT : machining step (" + ToString( m_Params.m_dStep, 1) + - ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ; - m_pMchMgr->SetWarning( 2457, sInfo) ; - } - // recupero il grezzo e la superficie di Trim [nullptr se non presente] PtrOwner pStmRaw( GetRaw()) ; - if ( IsNull( pStmRaw) || ! ChooseRawPart( pSfr, pStmRaw) || - ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0) { + if ( IsNull( pStmRaw) || ! ChooseRawPart( pSfr, pStmRaw) || ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0) { m_pMchMgr->SetLastError( 2436, "Error in PocketingNT : not valid Raw") ; return false ; } PtrOwner pStmTrim( GetStmTrim()) ; if ( ! IsNull( pStmTrim)) { - if ( ! ChooseRawPart( pSfr, pStmTrim) || ! pStmTrim->IsValid() || - pStmTrim->GetTriangleCount() == 0) { + if ( ! ChooseRawPart( pSfr, pStmTrim) || ! pStmTrim->IsValid() || pStmTrim->GetTriangleCount() == 0) { m_pMchMgr->SetLastError( 2436, "Error in PocketingNT : not valid Raw") ; return false ; } } + double dMaxElev = 0. ; + if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev) && dMaxElev > EPS_SMALL) { + if ( m_Params.m_bToolInvert) + pSfr->Translate( - vtTool * dDepth) ; + if ( ! TrimRawByMaxElev( ( pStmTrim == nullptr ? pStmRaw : pStmTrim), pSfr, vtTool, dMaxElev)) { + m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ; + return false ; + } + if ( m_Params.m_bToolInvert) + pSfr->Translate( vtTool * dDepth) ; + } #if DEBUG_SFR_RAW int nGrpSR = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ; int nLaySR = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpSR, GLOB_FRM) ; @@ -4019,6 +4071,50 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId) } #endif + // calcolo l'elevazione inversa per definire la Depth massima + ISurfTriMesh* pStmElev = ( dMaxElev > EPS_SMALL ? ( pStmTrim == nullptr ? pStmRaw : pStmTrim) : nullptr) ; + double dInvElev = 0. ; + pSfr->Invert() ; + if ( ! CalcRegionElevation( pSfr, vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, pStmElev, dInvElev)) { + m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ; + return false ; + } + pSfr->Invert() ; + double dExtraDepth = ( dOkStep < EXTRA_DEPTH ? dOkStep / 2. : EXTRA_DEPTH) ; + if ( dOkStep < EPS_SMALL) + dExtraDepth = EXTRA_DEPTH ; + dDepth = min( dDepth, dInvElev + dExtraDepth) ; + + // calcolo l'elevazione massima + double dElev = 0. ; + if ( ! CalcRegionElevation( pSfr, vtTool, dDepth, m_TParams.m_dDiam / 2., m_TParams.m_dLen, pStmElev, dElev)) { + m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ; + return false ; + } + + // calcolo l'elevazione al di sopra della geometria originale + double dOrigElev = 0. ; + if ( ! CalcOrigRegionElevation( pSfr, ( pStmTrim == nullptr ? pStmRaw : pStmTrim), vtTool, dDepth, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dOrigElev)) { + m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ; + return false ; + } + + // verifico che il massimo materiale dell'utensile sia sensato + const double MIN_MAXMAT = 1.0 ; + if ( m_TParams.m_dMaxMat < dOrigElev && m_TParams.m_dMaxMat < MIN_MAXMAT) { + string sInfo = "Error in PocketingNT : Tool MaxMaterial too small (" + ToString( m_TParams.m_dMaxMat, 2) + ")" ; + m_pMchMgr->SetLastError( 2422, sInfo) ; + return false ; + } + + // verifico di non superare il massimo materiale (se lo step supera la capacità dell'utensile) + if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) { + dOkStep = m_TParams.m_dMaxMat + EPS_SMALL ; + string sInfo = "Warning in PocketingNT : machining step (" + ToString( m_Params.m_dStep, 1) + ") bigger than MaxMaterial (" + + ToString( m_TParams.m_dMaxMat, 1) + ")" ; + m_pMchMgr->SetWarning( 2457, sInfo) ; + } + // definisco la classe di calcolo della Silhoette del grezzo nel caso mi servisse PtrOwner pCavParSil( nullptr) ; Point3d ptAtTop ; pSfr->GetCentroid( ptAtTop) ; @@ -4057,43 +4153,47 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId) m_pGeomDB->SetStatus( _a, GDB_ST_OFF) ; #endif - // se lavorazione singola - if ( dOkStep < EPS_SMALL || dOkStep > dElev) { - // se l'elevazione supera la capacità dell'utensile - if ( dElev > m_TParams.m_dMaxMat + EPS_SMALL) { + // se l'elevazione sopra alla faccia è maggiore del massimo materiale, limito la faccia + bool bBlockStepByElev = false ; + if ( dOrigElev < dElev + 10. * EPS_SMALL && dOrigElev > m_TParams.m_dMaxMat + EPS_SMALL) { + // se lavorazione singola + if ( dOkStep < EPS_SMALL || dOkStep > dElev) { + // se l'elevazione supera la capacità dell'utensile string sInfo = "Warning in Pocketing : machining depth (" + ToString( dElev, 1) + ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ; m_pMchMgr->SetWarning( 2458, sInfo) ; dDepth -= dElev - m_TParams.m_dMaxMat ; dElev = m_TParams.m_dMaxMat ; } - } - // altrimenti lavorazione a step - else { - // se l'elevazione supera il massimo affondamento dell'utensile - double dSafe = GetMaxDepthSafe() ; - double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? m_dTHoldBase : m_dTHoldLen) - dSafe ; - if ( dElev > dMaxDepth + EPS_SMALL) { - // controllo se posso evitare il controllo - Frame3d frSfr ; - Point3d ptCen ; pSfr->GetCentroid( ptCen) ; - Frame3d frPocket ; - if ( ! frPocket.Set( ptCen, vtTool) || ! frPocket.IsValid()) - return false ; - IntersParPlanesSurfTm IPPStm( frPocket, *pStmRaw) ; - bool bSkipMaxDepth = false ; - if ( ! CheckMaxDepth( pSfr, dDepth, vtTool, pStmRaw, pStmExtrusion, IPPStm, bSkipMaxDepth)) - return false ; - if ( ! bSkipMaxDepth) { - // segnalo, riduco e continuo - string sInfo = "Warning in PocketingNT : machining depth (" + ToString( dElev, 1) + - ") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ; - m_pMchMgr->SetWarning( 2458, sInfo) ; - dDepth -= dElev - dMaxDepth ; - dElev = dMaxDepth ; + // altrimenti lavorazione a step + else { + // se l'elevazione supera il massimo affondamento dell'utensile + double dSafe = GetMaxDepthSafe() ; + double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? m_dTHoldBase : m_dTHoldLen) - dSafe ; + if ( dElev > dMaxDepth + EPS_SMALL) { + // controllo se posso evitare il controllo + Frame3d frSfr ; + Point3d ptCen ; pSfr->GetCentroid( ptCen) ; + Frame3d frPocket ; + if ( ! frPocket.Set( ptCen, vtTool) || ! frPocket.IsValid()) + return false ; + IntersParPlanesSurfTm IPPStm( frPocket, *pStmRaw) ; + bool bSkipMaxDepth = false ; + if ( ! CheckMaxDepth( pSfr, dDepth, vtTool, pStmRaw, pStmExtrusion, IPPStm, bSkipMaxDepth)) + return false ; + if ( ! bSkipMaxDepth) { + // segnalo, riduco e continuo + string sInfo = "Warning in PocketingNT : machining depth (" + ToString( dElev, 1) + + ") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ; + m_pMchMgr->SetWarning( 2458, sInfo) ; + dDepth -= dElev - dMaxDepth ; + dElev = dMaxDepth ; + } } } } + else + bBlockStepByElev = true ; // verifico se tavola basculante bool bTiltTab = false ; @@ -4217,8 +4317,10 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId) // adatto la regione piana alla geometria del grezzo ICAvParSilhouettesSurfTm* pCavParSilTmp = Get( pCavParSil) ; - PtrOwner pSfrTrim( GetSfrRawProjection( ( pStmTrim == nullptr ? pStmRaw : pStmTrim), pSfrPock, vtTool, frAtTop, - &pCavParSilTmp)) ; + PtrOwner pStmRawSliced( GetStmRawSliced( pStmRaw, vStepInfo.empty() ? nullptr : vStepInfo.back().pSfrPock, vtTool)) ; + PtrOwner pSfrTrim( GetSfrRawProjection( ( pStmTrim == nullptr ? pStmRawSliced : pStmTrim), pSfrPock, + vtTool, frAtTop, + &pCavParSilTmp)) ; if ( IsNull( pSfrTrim)) { m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Slicing Raw failed") ; return false ; @@ -4248,6 +4350,18 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId) // se regione risultante non vuota if ( pSfrPock->IsValid() && pSfrPock->GetChunkCount() > 0) { + + // Verifico se bloccare gli step in base all'elevazione o meno + if ( bBlockStepByElev) { + double dStepElev = 0. ; + if ( ! CalcRegionElevation( pSfrPock, vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, pStmRaw, dStepElev)) { + m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ; + return false ; + } + if ( dStepElev > m_TParams.m_dMaxMat + EPS_SMALL) + break ; + } + // determino i lati aperti if ( ! ChooseCloseOrOpenEdge( pSfrPock, pStmExtrusion)) { m_pMchMgr->SetLastError( 2441, "Error in PocketingNT : Detecting open edges failed") ; @@ -4327,7 +4441,7 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId) //---------------------------------------------------------------------------- bool PocketingNT::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dDepth, - double dRad, double dLen, double& dElev) + double dRad, double dLen, const ISurfTriMesh* pStmRaw, double& dElev) const { // controllo dei parametri if ( pSfr == nullptr || ! pSfr->IsValid()) @@ -4359,37 +4473,46 @@ PocketingNT::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& v // inizializzo elevazioni per ogni grezzo INTDBLVECTOR vRawElev ; - // ciclo sui grezzi della fase - int nRawId = m_pMchMgr->GetFirstRawPart() ; - while ( nRawId != GDB_ID_NULL) { - // verifico che il grezzo compaia nella fase - if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) { - // recupero la trimesh del grezzo - int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; - const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nStmId)) ; - if ( pStm != nullptr) { - // recupero il riferimento della trimesh - Frame3d frStm ; - m_pGeomDB->GetGlobFrame( nStmId, frStm) ; - // porto il poligono in questo riferimento - Polygon3d pgFacetL = pgFacet ; - pgFacetL.ToLoc( frStm) ; - // calcolo l'elevazione - double dCurrElev ; - if ( ! PolygonElevationInClosedSurfTm( pgFacetL, *pStm, true, dCurrElev)) - return false ; - if ( dCurrElev > EPS_SMALL) - vRawElev.emplace_back( nStmId, dCurrElev) ; + + if ( pStmRaw == nullptr) { + // ciclo sui grezzi della fase + int nRawId = m_pMchMgr->GetFirstRawPart() ; + while ( nRawId != GDB_ID_NULL) { + // verifico che il grezzo compaia nella fase + if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) { + // recupero la trimesh del grezzo + int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; + const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nStmId)) ; + if ( pStm != nullptr) { + // recupero il riferimento della trimesh + Frame3d frStm ; + m_pGeomDB->GetGlobFrame( nStmId, frStm) ; + // porto il poligono in questo riferimento + Polygon3d pgFacetL = pgFacet ; + pgFacetL.ToLoc( frStm) ; + // calcolo l'elevazione + double dCurrElev ; + if ( ! PolygonElevationInClosedSurfTm( pgFacetL, *pStm, true, dCurrElev)) + return false ; + if ( dCurrElev > EPS_SMALL) + vRawElev.emplace_back( nStmId, dCurrElev) ; + } } + // passo al grezzo successivo + nRawId = m_pMchMgr->GetNextRawPart( nRawId) ; } - // passo al grezzo successivo - nRawId = m_pMchMgr->GetNextRawPart( nRawId) ; + } + else { + double dCurrElev ; + if ( ! PolygonElevationInClosedSurfTm( pgFacet, *pStmRaw, true, dCurrElev)) + return false ; + if ( dCurrElev > EPS_SMALL) + vRawElev.emplace_back( GDB_ID_NULL, dCurrElev) ; } // se trovate elevazioni if ( ! vRawElev.empty()) { // ordino il vettore secondo l'elevazione crescente - sort( vRawElev.begin(), vRawElev.end(), []( const INTDBL& a, const INTDBL& b) - { return a.second < b.second ; }) ; + sort( vRawElev.begin(), vRawElev.end(), []( const INTDBL& a, const INTDBL& b) { return a.second < b.second ; }) ; // box dell'insieme delle posizioni utensile all'inizioe const double MAX_DIST_RAW = 200.0 ; BBox3d b3Tool ; @@ -4410,10 +4533,13 @@ PocketingNT::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& v } b3Tool.Expand( MAX_DIST_RAW) ; // verifico la reale interferenza dell'utensile con i diversi grezzi - for ( int i = 0 ; i < int( vRawElev.size()) ; ++ i) { + for ( int i = 0 ; i < ssize( vRawElev) ; ++ i) { // box del grezzo - BBox3d b3Raw ; - m_pGeomDB->GetGlobalBBox( vRawElev[i].first, b3Raw) ; + BBox3d b3Raw ; + if ( pStmRaw == nullptr) + m_pGeomDB->GetGlobalBBox( vRawElev[i].first, b3Raw) ; + else + pStmRaw->GetLocalBBox( b3Raw) ; // confronto con il box dell'utensile nella posizione precedente BBox3d b3CurrTool = b3Tool ; b3CurrTool.Translate( dMyElev * vtTool) ; @@ -4428,6 +4554,51 @@ PocketingNT::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& v return true ; } +//---------------------------------------------------------------------------- +bool +PocketingNT::CalcOrigRegionElevation( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw, const Vector3d& vtTool, double dDepth, + double dRad, double dLen, double& dElev) const +{ + // controllo dei parametri + if ( pSfr == nullptr || ! pSfr->IsValid() || + pStmRaw == nullptr || ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0) + return false ; + + // taglio il grezzo sulla faccia corrispondente + Point3d ptCentroid ; pSfr->GetCentroid( ptCentroid) ; + Plane3d plCut ; plCut.Set( ptCentroid, - vtTool) ; + PtrOwner pStmCut( CloneSurfTriMesh( pStmRaw)) ; + if ( IsNull( pStmCut) || ! pStmCut->IsValid() || ! pStmCut->Cut( plCut, false)) + return false ; + + // recupero il bordo come regione + POLYLINEVECTOR vPL ; + if ( ! pStmCut->GetLoops( vPL)) + return false ; + // se il piano di taglio non ha intersecato il grezzo, allora la superficie origale è definita al fuori di esso + if ( vPL.empty()) + return CalcRegionElevation( pSfr, vtTool, dDepth, dRad, dLen, pStmRaw, dElev) ; + // altrimenti recupero il bordo corrente come regione + SurfFlatRegionByContours SfrByC ; + for ( const PolyLine& PL : vPL) { + PtrOwner pCompoLoop( CreateCurveComposite()) ; + if ( IsNull( pCompoLoop) || ! pCompoLoop->FromPolyLine( PL)) + return false ; + SfrByC.AddCurve( ::Release( pCompoLoop)) ; + } + PtrOwner pSfrOrigFace( SfrByC.GetSurf()) ; + if ( IsNull( pSfrOrigFace) || ! pSfrOrigFace->IsValid()) + return false ; + // per sicurezza oriento correttamente + if ( AreOppositeVectorApprox( pSfrOrigFace->GetNormVersor(), pSfr->GetNormVersor())) + pSfrOrigFace->Invert() ; + // la faccia originale è l'intersezione + if ( ! pSfrOrigFace->Intersect( *pSfr) || ! pSfrOrigFace->IsValid()) + return CalcRegionElevation( pSfr, vtTool, dDepth, dRad, dLen, pStmRaw, dElev) ; + + return ( CalcRegionElevation( pSfrOrigFace, vtTool, dDepth, dRad, dLen, pStmRaw, dElev)) ; +} + //---------------------------------------------------------------------------- bool PocketingNT::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) @@ -4922,21 +5093,6 @@ PocketingNT::CalcPaths( STEPINFOPOVECTOR& vStepInfo, bool& bEmpty) m_pMchMgr->SetLastError( 2431, "Error in Pocketing : LeadIn with Mill NoTip in material") ; return false ; } - if ( vStepInfo[i].vPaths[j].bOutStart && ! m_bOpenOutRaw) { - // se richiesto, controllo di essere davvero fuori dal grezzo [controllo basilare, migliorabile] - Point3d ptStart ; vCrvPaths[j]->GetStartPoint( ptStart) ; - double dElev ; - PtrOwner pCrvArc( CreateCurveArc()) ; - pCrvArc->Set( ptStart, m_vtTool, 50. * EPS_SMALL) ; - PtrOwner pSfrCheck( CreateSurfFlatRegion()) ; - if ( IsNull( pSfrCheck) || ! pSfrCheck->AddExtLoop( Release( pCrvArc))) - return false ; - if ( CalcRegionElevation( pSfrCheck, m_vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev) && - dElev > EPS_SMALL) { - vStepInfo[i].vPaths[j].bOutStart = false ; - delete( vCrvPaths[j]->RemoveFirstOrLastCurve( false)) ; - } - } // controllo se il percorso ha un'uscita presso un lato aperto vStepInfo[i].vPaths[j].bOutEnd = ( vCrvPaths[j]->GetCurveCount() > 0 && vCrvPaths[j]->GetLastCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ; diff --git a/PocketingNT.h b/PocketingNT.h index fd34296..62a707d 100644 --- a/PocketingNT.h +++ b/PocketingNT.h @@ -115,23 +115,26 @@ class PocketingNT : public Machining ISurfTriMesh* GetRaw( void) ; ISurfTriMesh* GetStmTrim( void) ; ISurfTriMesh* GetExtrusionStm( const ISurfFlatRegion* pSfr, const Vector3d& vtExtr) ; - ISurfFlatRegion* GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs = 0) ; - ISurfFlatRegion* GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool, - const Frame3d& frAtTop, ICAvParSilhouettesSurfTm** ppCavParSil = nullptr) ; + ISurfTriMesh* GetStmRawSliced( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool) const ; + ISurfFlatRegion* GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs = 0) const ; + ISurfFlatRegion* GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, + const Vector3d& vtTool, const Frame3d& frAtTop, ICAvParSilhouettesSurfTm** ppCavParSil = nullptr) ; Point3d GetStartPointByUser( const ISurfFlatRegion* pSfr) const ; Point3d GetStartPointsByHead( const STEPINFOPOVECTOR& vStepInfo) const ; Point3d GetStartPointsBySteps( const STEPINFOPOVECTOR& vStepInfo, int nCrvType) const ; bool ChooseRawPart( const ISurfFlatRegion* pSfrChunk, ISurfTriMesh* pStm) const ; + bool TrimRawByMaxElev( ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dMaxElev) const ; bool ManageOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmPart) ; bool GetHomogeneousParts( const ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCrvs) const ; bool ExtendOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm) ; - bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion) ; - bool CheckMaxDepth( const ISurfFlatRegion* pSfr, double dDepth, const Vector3d& vtTool, - const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmExtrusion, - const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth) ; + bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion) const ; + bool CheckMaxDepth( const ISurfFlatRegion* pSfr, double dDepth, const Vector3d& vtTool, const ISurfTriMesh* pStmRaw, + const ISurfTriMesh* pStmExtrusion, const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth) const ; bool ProcessPath( int nPathId, int nPvId, int nClId) ; bool CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dDepth, - double dRad, double dLen, double& dElev) ; + double dRad, double dLen, const ISurfTriMesh* pStmRaw, double& dElev) const ; + bool CalcOrigRegionElevation( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw, const Vector3d& vtTool, double dDepth, + double dRad, double dLen, double& dElev) const ; bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ; bool GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) ; bool CalcGeoExtSurfFr( const ISurfFlatRegion* pSfrPock, const Vector3d& vtTool, double dDepth, const ISurfTriMesh* pStmRaw,