From 25c382aa71d55beb8f31a61203236677929fa7f4 Mon Sep 17 00:00:00 2001 From: DarioS Date: Wed, 8 Dec 2021 16:43:32 +0100 Subject: [PATCH] EgtMachKernel : - aggiunte in interfaccia funzioni per export/import lavorazioni - modifiche varie in export/import utensili e lavorazioni. --- MachMgr.h | 6 +- MachiningsMgr.cpp | 98 ++++++-------- MachiningsMgr.h | 13 +- Milling.cpp | 6 +- Pocketing.cpp | 317 ++++++++++++++++++++++++---------------------- Pocketing.h | 6 +- ToolsMgr.cpp | 122 ++++++++++-------- ToolsMgr.h | 14 +- 8 files changed, 297 insertions(+), 285 deletions(-) diff --git a/MachMgr.h b/MachMgr.h index af9dfcb..e2be4a6 100644 --- a/MachMgr.h +++ b/MachMgr.h @@ -231,10 +231,10 @@ class MachMgr : public IMachMgr bool MdbReload( void) override ; bool MdbSave( void) const override ; bool MdbGetMachiningDir( std::string& sMchDir) const override ; - bool MdbExport( const STRVECTOR& vsMachiningsNames, const std::string& sOutFile) const ; - bool MdbToBeImported( const std::string& sFile, STRVECTOR& vsMachiningsNames, INTVECTOR& vMachiningsTypes) const ; + bool MdbExport( const STRVECTOR& vsMachiningsNames, const std::string& sOutFile) const override ; + bool MdbToBeImported( const std::string& sFile, STRVECTOR& vsMachiningsNames, INTVECTOR& vMachiningsTypes) const override ; bool MdbImport( const std::string& sFile, const STRVECTOR& vsMachiningsToImport, const STRVECTOR& vsMachiningsNames, - STRVECTOR& vsImported) ; + STRVECTOR& vsImported) override ; // Operations : general int GetOperationCount( void) const override ; int GetFirstOperation( void) const override ; diff --git a/MachiningsMgr.cpp b/MachiningsMgr.cpp index daf6be9..928a45a 100644 --- a/MachiningsMgr.cpp +++ b/MachiningsMgr.cpp @@ -31,7 +31,6 @@ #include "/EgtDev/Include/EGnFileUtils.h" #include "/EgtDev/Include/EGnScanner.h" #include "/EgtDev/Include/EGnWriter.h" -#include "/EgtDev/Include/EgtPointerOwner.h" #include #include @@ -189,11 +188,25 @@ MachiningsMgr::Reload( void) // Ciclo di lettura delle lavorazioni do { - if ( ! LoadOneMachining( TheScanner, bEnd)) { + PtrOwner pMch ; + if ( LoadOneMachining( TheScanner, pMch, bEnd)) { + // salvo i dati della lavorazione + if ( ! IsNull( pMch)) { + if ( ! m_umData.emplace( pMch->m_Uuid, Get( pMch)).second || + ! m_suData.emplace( pMch->m_sName, pMch->m_Uuid).second) { + bOk = false ; + string sOut = "ReloadMachinings : Error adding machining " + pMch->m_sName ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) + } + Release( pMch) ; + } + } + else { bOk = false ; string sOut = "ReloadMachinings : Error on line " + ToString( TheScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEMkLogger(), sOut.c_str()) } + } while ( bOk && ! bEnd) ; // Termino lo scanner @@ -207,7 +220,7 @@ MachiningsMgr::Reload( void) //---------------------------------------------------------------------------- bool -MachiningsMgr::LoadHeader( Scanner& TheScanner, int& nVersion, int& nTotal, bool& bEnd) +MachiningsMgr::LoadHeader( Scanner& TheScanner, int& nVersion, int& nTotal, bool& bEnd) const { // leggo la prossima linea string sLine ; @@ -311,11 +324,12 @@ MachiningsMgr::LoadGeneral( Scanner& TheScanner, bool& bEnd) //---------------------------------------------------------------------------- bool -MachiningsMgr::LoadOneMachining( Scanner& TheScanner, bool& bEnd, MachiningData** ppMch) +MachiningsMgr::LoadOneMachining( Scanner& TheScanner, PtrOwner& pMch, bool& bEnd) const { // leggo la prossima linea string sLine ; if ( ! TheScanner.GetLine( sLine)) { + pMch.Reset() ; // fine file bEnd = true ; return true ; @@ -329,7 +343,7 @@ MachiningsMgr::LoadOneMachining( Scanner& TheScanner, bool& bEnd, MachiningData* SplitFirst( sLine, "_", sType, sCount) ; ToUpper( sType) ; // alloco la lavorazione del tipo corrispondente - PtrOwner pMch( MCHDATA_CREATE( MCHDATA_NAMETOTYPE( sType))) ; + pMch.Set( MCHDATA_CREATE( MCHDATA_NAMETOTYPE( sType))) ; if ( IsNull( pMch)) return false ; bool bOk = true ; @@ -366,14 +380,6 @@ MachiningsMgr::LoadOneMachining( Scanner& TheScanner, bool& bEnd, MachiningData* } // verifico di aver letto tutti i campi bOk = bOk && ( Flag.count() == nSize) ; - // salvo i dati della lavorazione - if ( ppMch == nullptr ) { - bOk = bOk && m_umData.emplace( pMch->m_Uuid, Get( pMch)).second ; - bOk = bOk && m_suData.emplace( pMch->m_sName, pMch->m_Uuid).second ; - Release( pMch) ; - } - else - *ppMch = Release( pMch) ; return bOk ; } @@ -1247,7 +1253,7 @@ MachiningsMgr::Export( const STRVECTOR& vsMachiningsNames, const string& sOutFil //---------------------------------------------------------------------------- bool -MachiningsMgr::ToBeImported( const string& sFile, STRVECTOR& vsMachiningsNames, INTVECTOR& vMachiningsTypes) +MachiningsMgr::ToBeImported( const string& sFile, STRVECTOR& vsMachiningsNames, INTVECTOR& vMachiningsTypes) const { // inizializzo lo scanner Scanner TheScanner ; @@ -1373,22 +1379,27 @@ MachiningsMgr::Import( const string& sFile, const STRVECTOR& vsMachiningsToImpor return false ; } - // leggo i dati generali (da versione 1002) e li confronto con quelli della classe - if ( nVersion >= 1002 && ! CheckGeneral( TheScanner, bEnd)) { + // leggo i dati generali (da versione 1002) e li ignoro + if ( nVersion >= 1002 && ! SkipGeneral( TheScanner, bEnd)) { LOG_ERROR( GetEMkLogger(), " Error Importing Machinings on General") ; return false ; } // ciclo di lettura delle lavorazioni while ( ! bEnd) { - MachiningData* pMch = nullptr ; - if ( ! LoadOneMachining( TheScanner, bEnd, &pMch) || pMch == nullptr) - // se errore nel leggere la lavorazione, proseguo con la successiva + PtrOwner pMch ; + if ( ! LoadOneMachining( TheScanner, pMch, bEnd)) { + LOG_ERROR( GetEMkLogger(), ( " Error Importing Machinings : reading at line" + ToString( TheScanner.GetCurrLineNbr())).c_str()) ; + continue ; + } + + // se non c'è lavorazione (si è alla fine), si prosegue + if ( IsNull( pMch)) continue ; - auto it = find( vsMachiningsToImport.begin(), vsMachiningsToImport.end(), pMch->m_sName) ; // se la lavorazione non deve essere importata proseguo con la successiva - if ( it == vsMachiningsToImport.end()) + auto it = find( vsMachiningsToImport.begin(), vsMachiningsToImport.end(), pMch->m_sName) ; + if ( it == vsMachiningsToImport.end()) continue ; // assegno il nuovo nome @@ -1400,12 +1411,12 @@ MachiningsMgr::Import( const string& sFile, const STRVECTOR& vsMachiningsToImpor } // aggiungo la lavorazione - bool bOk = m_umData.emplace( pMch->m_Uuid, pMch).second ; - bOk = bOk && m_suData.emplace( pMch->m_sName, pMch->m_Uuid).second ; - if ( ! bOk) { - LOG_ERROR( GetEMkLogger(), ( " Error Importing Machinings : adding " + pMch->m_sName + " failed" ).c_str()) ; + if ( ! m_umData.emplace( pMch->m_Uuid, pMch).second || + ! m_suData.emplace( pMch->m_sName, pMch->m_Uuid).second) { + LOG_ERROR( GetEMkLogger(), ( " Error Importing Machinings : failed adding " + pMch->m_sName).c_str()) ; continue ; - } + } + Release( pMch) ; vsImported.push_back( pMch->m_sName) ; } @@ -1418,7 +1429,7 @@ MachiningsMgr::Import( const string& sFile, const STRVECTOR& vsMachiningsToImpor //---------------------------------------------------------------------------- bool -MachiningsMgr::CheckGeneral( Scanner& TheScanner, bool& bEnd) const +MachiningsMgr::SkipGeneral( Scanner& TheScanner, bool& bEnd) const { // leggo la prossima linea string sLine ; @@ -1440,38 +1451,7 @@ MachiningsMgr::CheckGeneral( Scanner& TheScanner, bool& bEnd) const bEnd = false ; break ; } - // separo chiave da valore - string sKey, sVal ; - bool bVal ; - int nVal ; - double dVal ; - SplitFirst( sLine, "=", sKey, sVal) ; - // riconosco la chiave e verifico che il valore corrisponda a quello salvato nella classe - if ( ToUpper( sKey) == MF_3AXCOMP) - bOk = FromString( sVal, bVal) && bVal == m_b3AxComp ; - else if ( ToUpper( sKey) == MF_5AXCOMP) - bOk = FromString( sVal, bVal) && bVal == m_b5AxComp ; - else if ( ToUpper( sKey) == MF_SAFEZ) - bOk = FromString( sVal, dVal) && abs( m_dSafeZ - dVal) < EPS_SMALL ; - else if ( ToUpper( sKey) == MF_SAFEAGGRBOTTZ) - bOk = FromString( sVal, dVal) && abs( m_dSafeAggrBottZ - dVal) < EPS_SMALL ; - else if ( ToUpper( sKey) == MF_EXTRALCR) - bOk = FromString( sVal, dVal) && abs( m_dExtraLOnCutRegion - dVal) < EPS_SMALL ; - else if ( ToUpper( sKey) == MF_EXTRARDR) - bOk = FromString( sVal, dVal) && abs( m_dExtraROnDrillRegion - dVal) < EPS_SMALL ; - else if ( ToUpper( sKey) == MF_HOLEDTOL) - bOk = FromString( sVal, dVal) && abs( m_dHoleDiamToler - dVal) < EPS_SMALL ; - else if ( ToUpper( sKey) == MF_EXTSAWARCMINRAD) - bOk = FromString( sVal, dVal) && abs( m_dExtSawArcMinRad - dVal) < EPS_SMALL ; - else if ( ToUpper( sKey) == MF_INTSAWARCMAXSIDEANG) - bOk = FromString( sVal, dVal) && abs( m_dIntSawArcMaxSideAng - dVal) < EPS_SMALL ; - else if ( ToUpper( sKey) == MF_SPLITARCS) - bOk = FromString( sVal, nVal) && m_nSplitArcs == nVal ; - else if ( ToUpper( sKey) == MF_MAXDEPTHSAFE) - bOk = FromString( sVal, dVal) && abs( m_dMaxDepthSafe - dVal) < EPS_SMALL ; - else - bOk = true ; } return bOk ; -} \ No newline at end of file +} diff --git a/MachiningsMgr.h b/MachiningsMgr.h index b77d07a..21b2bf4 100644 --- a/MachiningsMgr.h +++ b/MachiningsMgr.h @@ -14,6 +14,7 @@ #pragma once #include "MachiningData.h" +#include "/EgtDev/Include/EgtPointerOwner.h" #include #include @@ -29,9 +30,6 @@ class MachiningsMgr bool Load( const std::string& sMachsFile, const ToolsMgr* pTsMgr) ; bool Reload( void) ; bool Save( bool bCompressed = true) const ; - bool Export( const STRVECTOR& vsMachiningsNames, const std::string& sOutFile, bool bCompressed = true) const ; - bool ToBeImported( const std::string& sFile, STRVECTOR& vsMachiningsNames, INTVECTOR& vMachiningsTypes) ; - bool Import( const std::string& sFile, const STRVECTOR& vsMachiningsToImport, const STRVECTOR& vsMachiningsNames, STRVECTOR& vsImported) ; bool GetMachiningNewName( std::string& sName) const ; bool AddMachining( const std::string& sName, int nType) ; bool CopyMachining( const std::string& sSource, const std::string& sName) ; @@ -84,13 +82,16 @@ class MachiningsMgr bool SetMaxDepthSafe( double dSafe) ; double GetMaxDepthSafe( void) const { return m_dMaxDepthSafe ; } + bool Export( const STRVECTOR& vsMachiningsNames, const std::string& sOutFile, bool bCompressed = true) const ; + bool ToBeImported( const std::string& sFile, STRVECTOR& vsMachiningsNames, INTVECTOR& vMachiningsTypes) const ; + bool Import( const std::string& sFile, const STRVECTOR& vsMachiningsToImport, const STRVECTOR& vsMachiningsNames, STRVECTOR& vsImported) ; private : bool Clear( bool bReset) ; - bool LoadHeader( Scanner& TheScanner, int& nVersion, int& nTotal, bool& bEnd) ; + bool LoadHeader( Scanner& TheScanner, int& nVersion, int& nTotal, bool& bEnd) const ; bool LoadGeneral( Scanner& TheScanner, bool& bEnd) ; - bool CheckGeneral( Scanner& TheScanner, bool& bEnd) const ; - bool LoadOneMachining( Scanner& TheScanner, bool& bEnd, MachiningData** ppMch = nullptr) ; + bool SkipGeneral( Scanner& TheScanner, bool& bEnd) const ; + bool LoadOneMachining( Scanner& TheScanner, PtrOwner& pMch, bool& bEnd) const ; bool SaveHeader( Writer& TheWriter, const int nTotal = -1) const ; bool SaveGeneral( Writer& TheWriter) const ; bool SaveOneMachining( const EgtUUID& Uuid, int& nCounter, Writer& TheWriter) const ; diff --git a/Milling.cpp b/Milling.cpp index 7ec3924..9f9104c 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -1214,6 +1214,8 @@ Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC) return false ; // la duplico pCurve.Set( pOriCurve->Clone()) ; + if ( IsNull( pCurve)) + return false ; // se estrusione mancante, imposto default Vector3d vtExtr ; if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall()) @@ -1231,6 +1233,8 @@ Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC) return false ; // la duplico pCurve.Set( pOriCurve->Clone()) ; + if ( IsNull( pCurve)) + return false ; // recupero estrusione e spessore Vector3d vtExtr ; if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall()) @@ -1240,8 +1244,6 @@ Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC) if ( pCompo->GetThickness( dThick)) pCurve->SetThickness( dThick) ; } - if ( IsNull( pCurve)) - return false ; // la porto in globale pCurve->ToGlob( frGlob) ; // la restituisco diff --git a/Pocketing.cpp b/Pocketing.cpp index 75b5dd8..f4215a4 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -1824,7 +1824,7 @@ bool Pocketing::GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) { // creo copia della curva composita - PtrOwner< ICurve> pCrv( pCompo->Clone()) ; + PtrOwner pCrv( pCompo->Clone()) ; if ( IsNull( pCrv)) return false ; // calcolo la regione @@ -1893,7 +1893,7 @@ GetCurveRadius( const ICurve* pCrv) //---------------------------------------------------------------------------- bool Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, - double dDepth, double dElev, double dOkStep, bool bSplitArcs, const int& nPathId) + double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId) { // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; @@ -1929,11 +1929,18 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con return false ; if ( bOptimizedZigZag) { nOffsCrvNbr = 1 ; - vpCrvs[0]->ExtendStartByLen( 0.5 * m_TParams.m_dDiam + dSafeZ) ; + if ( ! m_Params.m_bInvert) { + vpCrvs[0]->ExtendStartByLen( m_TParams.m_dDiam / 2 + dSafeZ) ; + vpCrvs[0]->ExtendEndByLen( m_TParams.m_dDiam / 4) ; + } + else { + vpCrvs[0]->ExtendStartByLen( m_TParams.m_dDiam / 4) ; + vpCrvs[0]->ExtendEndByLen( m_TParams.m_dDiam / 2 + dSafeZ) ; + } } // se caso non ottimizzato calcolo curva offsettata del raggio utensile + sovramateriale + (se non lucidatura) extra - double dTRad = 0.5 * m_TParams.m_dDiam ; + double dTRad = m_TParams.m_dDiam / 2 ; double dOffs = dTRad + GetOffsR() ; double dExtra = (( m_TParams.m_nType != TT_MILL_POLISHING) ? min( 0.1 * m_TParams.m_dDiam, 2.0) : 0) ; OffsetCurve OffsCrv ; @@ -2031,8 +2038,8 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con return false ; // determino elevazione su inizio attacco double dStElev ; - if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) - dStElev = j * dStep ; + GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev) ; + dStElev = max( dStElev, j * dStep) ; bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; if ( bUnderRaw) @@ -2094,8 +2101,9 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; return false ; } - // se lucidatura e ultimo step, aggiungo retrazione - if ( m_TParams.m_nType == TT_MILL_POLISHING && j == nStep) { + dEndElev = max( dEndElev, j * dStep) ; + // se lucidatura o caso ottimizzato e ultimo step, aggiungo retrazione + if ( ( m_TParams.m_nType == TT_MILL_POLISHING || bOptimizedZigZag) && j == nStep) { if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Retract not computable") ; return false ; @@ -2114,152 +2122,149 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con } } - if ( ! bOptimizedZigZag) { + // se lucidatura o caso ottimizzato, non aggiungo contorno + if ( m_TParams.m_nType == TT_MILL_POLISHING || bOptimizedZigZag) + return true ; - // se lucidatura, non aggiungo contorno - if ( m_TParams.m_nType == TT_MILL_POLISHING) - return true ; + // calcolo seconda curva offsettata del raggio utensile + sovramateriale + OffsetCurve OffsCrv2 ; + if ( ! OffsCrv2.Make( pCompo, - dOffs, ICurve::OFF_FILLET)) { + m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ; + return false ; + } - // calcolo seconda curva offsettata del raggio utensile + sovramateriale - OffsetCurve OffsCrv2 ; - if ( ! OffsCrv2.Make( pCompo, - dOffs, ICurve::OFF_FILLET)) { - m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ; + // ciclo sulle curve risultanti + while ( OffsCrv2.GetCurveCount() > 0) { + + // recupero la prima curva di offset + PtrOwner pOffs2( CreateCurveComposite()) ; + if ( IsNull( pOffs2) || ! pOffs2->AddCurve( OffsCrv2.GetLongerCurve())) { + m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ; return false ; } + VerifyArcs( pOffs2) ; - // ciclo sulle curve risultanti - while ( OffsCrv2.GetCurveCount() > 0) { + // se richiesto, la inverto + if ( m_Params.m_bInvert) + pOffs2->Invert() ; - // recupero la prima curva di offset - PtrOwner pOffs2( CreateCurveComposite()) ; - if ( IsNull( pOffs2) || ! pOffs2->AddCurve( OffsCrv2.GetLongerCurve())) { - m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ; - return false ; - } - VerifyArcs( pOffs2) ; + // sposto l'inizio a metà del tratto più lungo + AdjustContourStart( pOffs2) ; - // se richiesto, la inverto - if ( m_Params.m_bInvert) - pOffs2->Invert() ; - - // sposto l'inizio a metà del tratto più lungo - AdjustContourStart( pOffs2) ; - - // aggiungo la lavorazione di questa curva - Point3d ptP1 ; - for ( int j = 1 ; j <= nStep ; ++ j) { - // ciclo sulle curve elementari - int nMaxInd = pOffs2->GetCurveCount() - 1 ; - for ( int i = 0 ; i <= nMaxInd ; ++ i) { - // curva corrente - const ICurve* pCrvC = pOffs2->GetCurve( i) ; - // copio la curva - PtrOwner pCurve( pCrvC->Clone()) ; - if ( IsNull( pCurve)) + // aggiungo la lavorazione di questa curva + Point3d ptP1 ; + for ( int j = 1 ; j <= nStep ; ++ j) { + // ciclo sulle curve elementari + int nMaxInd = pOffs2->GetCurveCount() - 1 ; + for ( int i = 0 ; i <= nMaxInd ; ++ i) { + // curva corrente + const ICurve* pCrvC = pOffs2->GetCurve( i) ; + // copio la curva + PtrOwner pCurve( pCrvC->Clone()) ; + if ( IsNull( pCurve)) + return false ; + // aggiungo affondamento + pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ; + // se prima entità + if ( i == 0 ) { + // dati inizio entità + Point3d ptStart ; + pCurve->GetStartPoint( ptStart) ; + Vector3d vtStart ; + pCurve->GetStartDir( vtStart) ; + // se primo step, approccio e affondo + if ( j == 1) { + // determino inizio attacco + if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, nullptr, ptP1)) + return false ; + // determino elevazione su inizio attacco + double dStElev ; + if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) + dStElev = dStep ; + bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && + GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + if ( bUnderRaw) + dStElev = max( dStElev, 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 || + GetLeadInType() == POCKET_LI_HELIX || + GetLeadInType() == POCKET_LI_GLIDE) { + ptP1 += vtExtr * dStElev ; + dStElev = 0 ; + } + // approccio al punto iniziale + if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr)) { + m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ; + return false ; + } + // aggiungo attacco + SetFeed( GetStartFeed()) ; + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, bSplitArcs)) { + m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ; + return false ; + } + } + // altrimenti solo collegamento + else { + SetFeed( GetStartFeed()) ; + GetCurrPos( ptP1) ; + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, bSplitArcs)) { + m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ; + return false ; + } + } + } + // elaborazioni sulla curva corrente + if ( pCurve->GetType() == CRV_LINE) { + ICurveLine* pLine = GetCurveLine( pCurve) ; + Point3d ptP3 = pLine->GetEnd() ; + SetFeed( GetFeed()) ; + if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; - // aggiungo affondamento - pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ; - // se prima entità - if ( i == 0 ) { - // dati inizio entità - Point3d ptStart ; - pCurve->GetStartPoint( ptStart) ; - Vector3d vtStart ; - pCurve->GetStartDir( vtStart) ; - // se primo step, approccio e affondo - if ( j == 1) { - // determino inizio attacco - if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, nullptr, ptP1)) - return false ; - // determino elevazione su inizio attacco - double dStElev ; - if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) - dStElev = dStep ; - bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; - if ( bUnderRaw) - dStElev = max( dStElev, 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 || - GetLeadInType() == POCKET_LI_HELIX || - GetLeadInType() == POCKET_LI_GLIDE) { - ptP1 += vtExtr * dStElev ; - dStElev = 0 ; - } - // approccio al punto iniziale - if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr)) { + } + else if ( pCurve->GetType() == CRV_ARC) { + ICurveArc* pArc = GetCurveArc( pCurve) ; + Point3d ptCen = pArc->GetCenter() ; + double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; + Point3d ptP3 ; + pArc->GetEndPoint( ptP3) ; + SetFeed( GetFeed()) ; + if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) + return false ; + } + // se ultima entità + if ( i == nMaxInd) { + // se ultimo step, uscita e retrazione di collegamento + if ( j == nStep) { + // dati fine entità + Point3d ptEnd ; + pCurve->GetEndPoint( ptEnd) ; + Vector3d vtEnd ; + pCurve->GetEndDir( vtEnd) ; + // aggiungo uscita + double dEndElev = dElev ; + SetFeed( GetEndFeed()) ; + if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, ptP1, dEndElev)) { + m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; + return false ; + } + // se ci sono ancora curve, aggiungo retrazione di collegamento + if ( OffsCrv2.GetCurveCount() > 0) { + if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ; return false ; } - // aggiungo attacco - SetFeed( GetStartFeed()) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, bSplitArcs)) { - m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ; - return false ; - } } - // altrimenti solo collegamento + // altrimenti retrazione finale else { - SetFeed( GetStartFeed()) ; - GetCurrPos( ptP1) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, bSplitArcs)) { - m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ; + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { + m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Retract not computable") ; return false ; } } } - // elaborazioni sulla curva corrente - if ( pCurve->GetType() == CRV_LINE) { - ICurveLine* pLine = GetCurveLine( pCurve) ; - Point3d ptP3 = pLine->GetEnd() ; - SetFeed( GetFeed()) ; - if ( AddLinearMove( ptP3) == GDB_ID_NULL) - return false ; - } - else if ( pCurve->GetType() == CRV_ARC) { - ICurveArc* pArc = GetCurveArc( pCurve) ; - Point3d ptCen = pArc->GetCenter() ; - double dAngCen = pArc->GetAngCenter() ; - Vector3d vtN = pArc->GetNormVersor() ; - Point3d ptP3 ; - pArc->GetEndPoint( ptP3) ; - SetFeed( GetFeed()) ; - if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) - return false ; - } - // se ultima entità - if ( i == nMaxInd) { - // se ultimo step, uscita e retrazione di collegamento - if ( j == nStep) { - // dati fine entità - Point3d ptEnd ; - pCurve->GetEndPoint( ptEnd) ; - Vector3d vtEnd ; - pCurve->GetEndDir( vtEnd) ; - // aggiungo uscita - double dEndElev = dElev ; - SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, ptP1, dEndElev)) { - m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; - return false ; - } - // se ci sono ancora curve, aggiungo retrazione di collegamento - if ( OffsCrv2.GetCurveCount() > 0) { - if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { - m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ; - return false ; - } - } - // altrimenti retrazione finale - else { - if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { - m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Retract not computable") ; - return false ; - } - } - } - } } } } @@ -2464,11 +2469,13 @@ Pocketing::CalcZigZag( const ICurveComposite* pOffs, //---------------------------------------------------------- bool -Pocketing::OptimizedZigZag( const int& nPathId, Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs) +Pocketing::OptimizedZigZag( int nPathId, Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs) { // recupero la curva originale che delimita la svuotatura int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ; - ICurveComposite* pCrvPocket = CloneCurveComposite( m_pGeomDB->GetGeoObj( nCrvId)) ; + PtrOwner pCrvPocket( CloneCurveComposite( m_pGeomDB->GetGeoObj( nCrvId))) ; + if ( IsNull( pCrvPocket)) + return false ; pCrvPocket->ToLoc( frPocket) ; // recupero gli id dei lati chiusi @@ -2505,23 +2512,27 @@ Pocketing::OptimizedZigZag( const int& nPathId, Frame3d& frPocket, bool& bOptimi pCrvPocket->ToGlob( frPocket) ; Point3d ptCen = frPocket.Orig() ; Vector3d vtExtr = frPocket.VersZ() ; - frPocket.Rotate( ptCen, vtExtr, - dAng) ; + frPocket.Rotate( ptCen, vtExtr, -dAng) ; pCrvPocket->ToLoc( frPocket) ; - // calcolo i percorsi di svuotatura + // calcolo il percorso di svuotatura if ( ! CalcZigZag( pCrvPocket, vpCrvs)) return false ; + // se un solo lato chiuso lo inverto per partire dall'esterno + if ( vnInfoClosed.size() == 1) + vpCrvs[0]->Invert() ; + return true ; } //------------------------------------------------------------------ bool -Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, const int& nClosedId, bool& bOptimizedZigZag) +Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag) { // verifico sia una linea - ICurveLine * pCrv = CloneCurveLine( pCrvPocket->GetCurve( nClosedId)) ; - if ( ! pCrv) + PtrOwner pCrv( CloneCurveLine( pCrvPocket->GetCurve( nClosedId))) ; + if ( IsNull( pCrv)) return true ; // setto il vettore estrusione per eseguire correttamente offset @@ -2544,17 +2555,17 @@ Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, const int& bool Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag) { - ICurveLine * pCrv1 = CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[0])) ; - ICurveLine * pCrv2 = CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[1])) ; - + // recupero le due curve chiuse + PtrOwner pCrv1( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[0]))) ; + PtrOwner pCrv2( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[1]))) ; // verifico siano linee - if ( ! pCrv1 || ! pCrv2) + if ( IsNull( pCrv1) || IsNull( pCrv2)) return true ; + // verifico abbiano direzioni opposte Vector3d vtDir1, vtDir2 ; pCrv1->GetStartDir( vtDir1) ; pCrv2->GetStartDir( vtDir2) ; - // verifico siano opposti - if ( abs( vtDir1 * vtDir2 + 1) > EPS_SMALL) + if ( ! AreOppositeVectorApprox( vtDir1, vtDir2)) return true ; // setto il vettore estrusione per eseguire correttamente offset @@ -2587,7 +2598,7 @@ Pocketing::CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) CRVCVECTOR ccClass ; IntersCC.GetCurveClassification( 1, EPS_SMALL, ccClass) ; - if ( ccClass.size() != 3 || ccClass[0].nClass != CRVC_OUT || ccClass[1].nClass == CRVC_OUT || ccClass[2].nClass != CRVC_OUT) + if ( ccClass.size() != 3 || ccClass[0].nClass != CRVC_OUT || ccClass[1].nClass == CRVC_OUT || ccClass[2].nClass != CRVC_OUT) return false ; Point3d ptS, ptE ; @@ -2597,7 +2608,9 @@ Pocketing::CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) pCrvA->GetParamAtPoint( ptS, dParS) ; pCrvA->GetParamAtPoint( ptE, dParE) ; - ICurveComposite* pCrvTmp( CloneCurveComposite( pCrvA)) ; + PtrOwner pCrvTmp( CloneCurveComposite( pCrvA)) ; + if ( IsNull( pCrvTmp)) + return false ; pCrvA->Clear() ; pCrvA->AddCurve( pCrvB->CopyParamRange( ccClass[1].dParS, ccClass[1].dParE)) ; pCrvA->AddCurve( pCrvTmp->CopyParamRange( dParE, dParS)) ; diff --git a/Pocketing.h b/Pocketing.h index 81c8ac9..8094852 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -76,10 +76,10 @@ class Pocketing : public Machining bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ; bool GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) ; bool AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, - double dDepth, double dElev, double dOkStep, bool bSplitArcs, const int& nPathId) ; + double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId) ; bool CalcZigZag( const ICurveComposite* pOffs, ICRVCOMPOPOVECTOR& vpCrvs) ; - bool OptimizedZigZag( const int& nPathId, Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs) ; - bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, const int& nClosedId, bool& bOptimizedZigZag) ; + bool OptimizedZigZag( int nPathId, Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs) ; + bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag) ; bool ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag) ; bool CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) ; bool AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, diff --git a/ToolsMgr.cpp b/ToolsMgr.cpp index 404bc1b..a8fe347 100644 --- a/ToolsMgr.cpp +++ b/ToolsMgr.cpp @@ -112,7 +112,19 @@ ToolsMgr::Reload( void) // ciclo di lettura degli utensili do { - if ( ! LoadOneTool( TheScanner, nToolSize, bEnd)) { + ToolData tData ; + if ( LoadOneTool( TheScanner, nToolSize, tData, bEnd)) { + if ( ! tData.m_sName.empty()) { + // salvo i dati dell'utensile + if ( ! m_utData.emplace( tData.m_Uuid, tData).second || + ! m_suData.emplace( tData.m_sName, tData.m_Uuid).second) { + bOk = false ; + string sOut = "ReloadTools : Error adding tool " + tData.m_sName ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) + } + } + } + else { bOk = false ; string sOut = "ReloadTools : Error on line " + ToString( TheScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEMkLogger(), sOut.c_str()) @@ -133,7 +145,7 @@ ToolsMgr::Reload( void) //---------------------------------------------------------------------------- bool -ToolsMgr::LoadHeader( Scanner& TheScanner, int& nVersion, int& nToolSize, int& nTotal, bool& bEnd) +ToolsMgr::LoadHeader( Scanner& TheScanner, int& nVersion, int& nToolSize, int& nTotal, bool& bEnd) const { // leggo la prossima linea string sLine ; @@ -176,12 +188,12 @@ ToolsMgr::LoadHeader( Scanner& TheScanner, int& nVersion, int& nToolSize, int& n //---------------------------------------------------------------------------- bool -ToolsMgr::LoadOneTool( Scanner& TheScanner, int nToolSize, bool& bEnd) +ToolsMgr::LoadOneTool( Scanner& TheScanner, int nToolSize, ToolData& tData, bool& bEnd) const { - ToolData tData ; // leggo la prossima linea string sLine ; if ( ! TheScanner.GetLine( sLine)) { + tData.m_sName = "" ; // fine file bEnd = true ; return true ; @@ -213,9 +225,6 @@ ToolsMgr::LoadOneTool( Scanner& TheScanner, int nToolSize, bool& bEnd) } // verifico di aver letto tutti i campi bOk = bOk && ( Flag.count() == nToolSize) ; - // salvo i dati dell'utensile - bOk = bOk && m_utData.emplace( tData.m_Uuid, tData).second ; - bOk = bOk && m_suData.emplace( tData.m_sName, tData.m_Uuid).second ; return bOk ; } @@ -781,7 +790,7 @@ ToolsMgr::GetCurrToolThLength( double& dThLen) const //---------------------------------------------------------------------------- bool -ToolsMgr::Export( const STRVECTOR& vsToolsNames, const string& sOutFile, bool bCompressed) +ToolsMgr::Export( const STRVECTOR& vsToolsNames, const string& sOutFile, bool bCompressed) const { LOG_INFO( GetEMkLogger(), ( "Export Tools " + sOutFile).c_str()) ; @@ -845,7 +854,7 @@ ToolsMgr::Export( const STRVECTOR& vsToolsNames, const string& sOutFile, bool bC //---------------------------------------------------------------------------- bool -ToolsMgr::ExportOneTool( const string& sToolName, Writer& TheWriter, const int& nCounter, const string& sOutDir) +ToolsMgr::ExportOneTool( const string& sToolName, Writer& TheWriter, int nCounter, const string& sOutDir) const { // se il tool non esiste nel DB lo ignoro if ( m_suData.find( sToolName) == m_suData.end()){ @@ -889,7 +898,7 @@ ToolsMgr::ExportOneTool( const string& sToolName, Writer& TheWriter, const int& //---------------------------------------------------------------------------- bool -ToolsMgr::ToBeImported( const string& sFile, STRVECTOR& vsToolsNames, INTVECTOR& vToolsTypes) +ToolsMgr::ToBeImported( const string& sFile, STRVECTOR& vsToolsNames, INTVECTOR& vToolsTypes) const { Scanner TheScanner ; if ( ! TheScanner.Init( sFile, ";")) { @@ -902,7 +911,7 @@ ToolsMgr::ToBeImported( const string& sFile, STRVECTOR& vsToolsNames, INTVECTOR& int nToolSize = 0 ; int nTotal = 0 ; bool bEnd = false ; - if ( ! LoadHeader( TheScanner, nVersion, nToolSize, nTotal, bEnd)){ + if ( ! LoadHeader( TheScanner, nVersion, nToolSize, nTotal, bEnd)) { LOG_ERROR( GetEMkLogger(), "Tools ToBeImported : Error on Header") ; } @@ -951,7 +960,7 @@ ToolsMgr::ToBeImported( const string& sFile, STRVECTOR& vsToolsNames, INTVECTOR& } // aggiungo ultimo tool se ok - if ( bAdd && bToolType && bToolName) { + if ( bAdd && bToolType && bToolName) { vsToolsNames.push_back( sName) ; vToolsTypes.push_back( stoi( sType)) ; } @@ -977,14 +986,14 @@ ToolsMgr::Import( const string& sFile, const STRVECTOR& vsToolsToImport, const S return false ; } } - // Verfico che il nome non sia ripetuto nella lista dei vsToolsNames + // Verifico che il nome non sia ripetuto nella lista dei vsToolsNames if ( i != vsToolsNames.size() - 1 && find( vsToolsNames.begin() + i + 1, vsToolsNames.end(), vsToolsNames[i]) != vsToolsNames.end()) { LOG_ERROR( GetEMkLogger(), ( " Error : name \"" + vsToolsNames[i] + "\" is already used").c_str()) ; return false ; } } - // sFile directory + // File directory size_t pos = sFile.rfind( "\\") ; if ( pos == string::npos) return false ; @@ -1009,7 +1018,7 @@ ToolsMgr::Import( const string& sFile, const STRVECTOR& vsToolsToImport, const S // leggo i tool string sLine ; - if( ! TheScanner.GetLine( sLine)) + if ( ! TheScanner.GetLine( sLine)) return false ; if ( sLine.front() != '[' || sLine.back() != ']') return false ; @@ -1023,7 +1032,7 @@ ToolsMgr::Import( const string& sFile, const STRVECTOR& vsToolsToImport, const S vector::const_iterator it = find( vsToolsToImport.begin(), vsToolsToImport.end(), tData.m_sName) ; // Se il tool non deve essere importato proseguo con il successivo - if ( it == vsToolsToImport.end()) + if ( it == vsToolsToImport.end()) continue ; // Se errore nel leggere il tool, proseguo con il successivo @@ -1076,7 +1085,7 @@ ToolsMgr::Import( const string& sFile, const STRVECTOR& vsToolsToImport, const S //-------------------------------------------------------------------------- bool -ToolsMgr::ReadTool( Scanner& TheScanner, ToolData& tData, const int& nToolSize) const +ToolsMgr::ReadTool( Scanner& TheScanner, ToolData& tData, int nToolSize) const { string sLine ; TheScanner.GetLine( sLine) ; @@ -1113,49 +1122,56 @@ ToolsMgr::ReadTool( Scanner& TheScanner, ToolData& tData, const int& nToolSize) //---------------------------------------------------------------------------- bool -ToolsMgr::CopyToolDraw( const string& sDraw, const string& sOutDraw, const string& sToolName) +ToolsMgr::CopyToolDraw( const string& sDraw, const string& sOutDraw, const string& sToolName) const { // se il file del disegno esiste lo copio nella nuova cartella - if ( ExistsFile( sDraw)){ + if ( ExistsFile( sDraw)) { if ( ! CopyFileEgt( sDraw, sOutDraw)) { string sOut = " Error in copying " + sToolName + " draw" ; LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; return false ; - } - } - else { - // se il file non esiste e non è standard restituisco errore - if ( ! IsUUID( GetFileTitleEgt( sDraw))) { - string sOut = " Error : " + sToolName + " draw not found" ; - LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; - return false ; - } - // se il file non esiste ma è standard lo ricreo - else { - int nGenCtx = ExeGetCurrentContext() ; - int nToolCtx = ExeInitContext() ; - - bool bOk = SetCurrTool( sToolName) ; // setto il tool corrente per farne il disegno - if ( ! bOk){ - string sOut = " Error in " + sToolName + " draw" ; - LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; - return false ; - } - - if ( ExeTdbCurrToolDraw( nGenCtx, nToolCtx)) { - string sOut = " Error : " + sToolName + " CurrToolDraw" ; - LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; - return false ; - } - if ( ! ExeSaveFile( sOutDraw, GDB_SV_CMPTXT)) { - string sOut = " Error : saving " + sToolName + " tool draw" ; - LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; - return false ; - } - ExeSetCurrentContext( nGenCtx) ; - ExeDeleteContext( nToolCtx) ; } + return true ; } - return true ; + + // se il file non esiste e non è standard restituisco errore + if ( ! IsUUID( GetFileTitleEgt( sDraw))) { + string sOut = " Error : " + sToolName + " draw not found" ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; + return false ; + } + + // altrimenti il file non esiste ma è standard lo ricreo + // recupero indice contesto corrente e creo nuovo contesto per disegno utensile + int nGenCtx = ExeGetCurrentContext() ; + int nToolCtx = ExeInitContext() ; + // salvo dati utensile corrente + bool bCurrToolOld = m_bCurrTool ; + ToolData tdCurrToolOld = m_tdCurrTool ; + // imposto utensile da esportare come corrente + bool bOk = true ; + if ( bOk && ! const_cast(this)->SetCurrTool( sToolName)) { + string sOut = " Error in " + sToolName + " draw" ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; + bOk = false ; + } + if ( bOk && ! ExeTdbCurrToolDraw( nGenCtx, nToolCtx)) { + string sOut = " Error : " + sToolName + " CurrToolDraw" ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; + bOk = false ; + } + if ( bOk && ! ExeSaveFile( sOutDraw, GDB_SV_CMPTXT)) { + string sOut = " Error : saving " + sToolName + " tool draw" ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; + bOk = false ; + } + // ripristino utensile corrente + const_cast(this)->m_bCurrTool = bCurrToolOld ; + const_cast(this)->m_tdCurrTool = tdCurrToolOld ; + // ripristino contesto corrente e cancello quello creato ad hoc + ExeSetCurrentContext( nGenCtx) ; + ExeDeleteContext( nToolCtx) ; + + return bOk ; } diff --git a/ToolsMgr.h b/ToolsMgr.h index 4ab95cb..cee6fb8 100644 --- a/ToolsMgr.h +++ b/ToolsMgr.h @@ -62,20 +62,20 @@ class ToolsMgr bool GetCurrToolThLength( double& dThLen) const ; const ToolData* GetCurrTool(void) const { return (m_bCurrTool ? &m_tdCurrTool : nullptr) ; } - bool Export( const STRVECTOR& vsToolsNames, const std::string& sOutFile, bool bCompressed = true) ; - bool ToBeImported( const std::string& sFile, STRVECTOR& vsToolsNames, INTVECTOR& vToolsTypes) ; + bool Export( const STRVECTOR& vsToolsNames, const std::string& sOutFile, bool bCompressed = true) const ; + bool ToBeImported( const std::string& sFile, STRVECTOR& vsToolsNames, INTVECTOR& vToolsTypes) const ; bool Import( const std::string& sFile, const STRVECTOR& vsToolsToImport, const STRVECTOR& vsToolsNames, STRVECTOR& vsImported) ; private : bool Clear( void) ; - bool LoadHeader( Scanner& TheScanner, int& nVersion, int& nToolSize, int& nTotal, bool& bEnd) ; - bool LoadOneTool( Scanner& TheScanner, int nToolSize, bool& bEnd) ; + bool LoadHeader( Scanner& TheScanner, int& nVersion, int& nToolSize, int& nTotal, bool& bEnd) const ; + bool LoadOneTool( Scanner& TheScanner, int nToolSize, ToolData& tData, bool& bEnd) const ; bool SaveHeader( Writer& TheWriter) const ; bool SaveOneTool( const EgtUUID& Uuid, int& nCounter, Writer& TheWriter) const ; bool VerifyTool( int nFamily, std::string& sName, int& nType) const ; - bool ExportOneTool( const std::string& sToolName, Writer& TheWriter, const int& nCounter, const std::string& sOutDir) ; - bool ReadTool( Scanner& TheScanner, ToolData& tData, const int& nToolSize) const ; - bool CopyToolDraw( const std::string& sDraw, const std::string& sOutDraw, const std::string& sToolName) ; + bool ExportOneTool( const std::string& sToolName, Writer& TheWriter, int nCounter, const std::string& sOutDir) const ; + bool ReadTool( Scanner& TheScanner, ToolData& tData, int nToolSize) const ; + bool CopyToolDraw( const std::string& sDraw, const std::string& sOutDraw, const std::string& sToolName) const ; private : typedef std::unordered_map< EgtUUID, ToolData> UUIDTDATA_UMAP ;