From f095d6caaf51b268938592a03ac3206b006fbfec Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Mon, 18 Nov 2024 10:56:43 +0100 Subject: [PATCH 1/3] =?UTF-8?q?EgtMachKernel=202.6k4=20:=20-=20modifiche?= =?UTF-8?q?=20a=20SimulatorMP=20per=20file=20stima=20speciale=20con=20path?= =?UTF-8?q?=20specifica=20(EMT.MPSEST)=20per=20poter=20funzionare=20in=20m?= =?UTF-8?q?odalit=C3=A0=20multitask.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- EgtMachKernel.rc | Bin 11782 -> 11782 bytes OutputConst.h | 3 ++- SimulatorMP.cpp | 24 +++++++++++++++++++----- SimulatorMP.h | 1 + 4 files changed, 22 insertions(+), 6 deletions(-) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index 87cf3133a49989f46516b1dc061b8d0316a0b8ad..2a928673ee7e22da83a38388fe4f9c9f8c75f62a 100644 GIT binary patch delta 97 zcmZpRX^YwLhmFx>^ItYwW=50Aj>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh Hr8(RHQ1Kv2 delta 97 zcmZpRX^YwLhmFyA^ItYwW=7-5j>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh Hr8(RHPhB8F diff --git a/OutputConst.h b/OutputConst.h index 9dbf140..0fce80f 100644 --- a/OutputConst.h +++ b/OutputConst.h @@ -185,8 +185,9 @@ static const std::string GVAR_SAFEDIST = ".SAFEDIST" ; // (num) distanza static const std::string GVAR_SIMVMID = ".SIMVMID" ; // (int) identificativo grezzo Vmill in collisione static const std::string GVAR_SIMCOBIND = ".SIMCOBIND" ; // (int) indice oggetto in collisione static const std::string GVAR_MPSIM = ".MPSIM" ; // (bool) flag simulazione multiprocesso +static const std::string GVAR_MPSEST = ".MPSEST" ; // (string) path del file di stima speciale per simulazione multiprocesso static const std::string GVAR_RECORD = ".RECORD" ; // (bool) flag modalità registrazione comandi in simulazione -static const std::string GVAR_OPERID = ".OPERID" ; // (int/s) identificativi ordinati operazioni per simulazione multiprocesso +static const std::string GVAR_OPERID = ".OPERID" ; // (int/s) identificativi ordinati operazioni per simulazione multiprocesso // Funzioni generazione static const std::string ON_START = "OnStart" ; static const std::string ON_END = "OnEnd" ; diff --git a/SimulatorMP.cpp b/SimulatorMP.cpp index 854bf7c..50414a1 100644 --- a/SimulatorMP.cpp +++ b/SimulatorMP.cpp @@ -205,11 +205,24 @@ SimulatorMP::Start( bool bFirst) if ( ! VerifySetup()) bOk = false ; // Eseguo stima speciale - string sEstFile ; - ExeGetTempDir( sEstFile) ; - sEstFile += "\\Simul.sest" ; - EraseFile( sEstFile) ; - if ( ! m_pMchMgr->Estimate( sEstFile, "")) + string sTemp ; + if ( ExeGetCurrFilePath( sTemp)) { + // direttorio + string sDir = GetDirectory( sTemp) ; + ReplaceString( sDir, "/", "\\") ; + // nome + string sName = GetFileTitleEgt( sTemp) ; + // nome macchinata + string sMGrp = m_pMchMgr->GetMachGroupName( m_pMchMgr->GetCurrMachGroup()) ; + // path completa + m_sSpecEstim = sDir + "\\" + sName + "_" + sMGrp + ".sest" ; + } + else { + ExeGetTempDir( sTemp) ; + m_sSpecEstim = sTemp + "\\Simul.sest" ; + } + EraseFile( m_sSpecEstim) ; + if ( ! m_pMchMgr->Estimate( m_sSpecEstim, "")) bOk = false ; } @@ -242,6 +255,7 @@ SimulatorMP::Start( bool bFirst) m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_VER, GetEMkVer()) ; m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MACHNAME, m_pMachine->GetMachineName()) ; m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MPSIM, true) ; + m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MPSEST, m_sSpecEstim) ; // Se appena entrati in simulazione if ( m_nStatus == SIS_INITIALIZED) { diff --git a/SimulatorMP.h b/SimulatorMP.h index 22aa3ab..fea8c2d 100644 --- a/SimulatorMP.h +++ b/SimulatorMP.h @@ -162,6 +162,7 @@ class SimulatorMP : public ISimulator IGeomDB* m_pGeomDB ; // puntatore al DB geometrico Machine* m_pMachine ; // puntatore alla macchina PerformanceCounter* m_pPerfCnt ; // timer per calcolo FPS + std::string m_sSpecEstim ; // path del file con i dati della stima speciale int m_nStatus ; // stato interno del simulatore (creato, inizializzato, pronto al movimento) double m_dStep ; // lunghezza di riferimento per la velocità di simulazione int m_nUiStatus ; // stato simulazione a livello utente From 1d20f9afe0ee05e46131e670e3d5e8ada2dac617 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Wed, 20 Nov 2024 12:16:48 +0100 Subject: [PATCH 2/3] EgtMachKernel 2.6k5 : - in fresatura corretto approccio/retrazione per utensili tipo lama (distanza iniziale da inizializzare). --- EgtMachKernel.rc | Bin 11782 -> 11782 bytes Milling.cpp | 18 +++++++++++------- Milling.h | 4 ++-- 3 files changed, 13 insertions(+), 9 deletions(-) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index 2a928673ee7e22da83a38388fe4f9c9f8c75f62a..7e996f83203fac76017d0afce692cca30051a139 100644 GIT binary patch delta 97 zcmZpRX^YwLhmFy6^ItYwW=7M=j>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh Hr8(RHQiUK= delta 97 zcmZpRX^YwLhmFx>^ItYwW=50Aj>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh Hr8(RHQ1Kv2 diff --git a/Milling.cpp b/Milling.cpp index 993fc0c..6574bda 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -107,7 +107,7 @@ Milling* Milling::Clone( void) const { // alloco oggetto - Milling* pMill = new(nothrow) Milling ; + Milling* pMill = new( nothrow) Milling ; // eseguo copia dei dati if ( pMill != nullptr) { try { @@ -4414,7 +4414,8 @@ Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, co Vector3d vtMove = Vector3d( vtTool.x, vtTool.y, 0) ; if ( vtMove.Normalize()) { if ( m_bAboveHead && vtAppr.z < LIM_DOWN_APPRZ) { - double dExtraElev ; + // deve essere inizializzata a zero + double dExtraElev = 0 ; if ( GetAhPointUnderRaw( ptP1a, vtTool, m_TParams.m_dTDiam / 2, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) { @@ -4436,7 +4437,8 @@ Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, co } } else if ( ! m_bAboveHead && vtAppr.z > -LIM_DOWN_APPRZ) { - double dExtraElev ; + // deve essere inizializzata a zero + double dExtraElev = 0 ; if ( GetUhPointAboveRaw( ptP1a, vtTool, m_TParams.m_dTDiam / 2, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) { @@ -4630,7 +4632,8 @@ Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, con vtMove = Vector3d( vtTool.x, vtTool.y, 0) ; if ( vtMove.Normalize()) { if ( m_bAboveHead && vtRetr.z < LIM_DOWN_APPRZ) { - double dExtraElev ; + // deve essere inizializzata a zero + double dExtraElev = 0 ; if ( GetAhPointUnderRaw( ptP4, vtTool, m_TParams.m_dTDiam / 2, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) { @@ -4641,7 +4644,8 @@ Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, con } } else if ( ! m_bAboveHead && vtRetr.z > -LIM_DOWN_APPRZ) { - double dExtraElev ; + // deve essere inizializzata a zero + double dExtraElev = 0 ; if ( GetUhPointAboveRaw( ptP4, vtTool, m_TParams.m_dTDiam / 2, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) { @@ -6394,7 +6398,7 @@ Milling::CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU, bool bI //---------------------------------------------------------------------------- Vector3d -Milling::CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide, bool bSawSpecial) +Milling::CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide, bool bSawSpecial) const { // verifico curva if ( pCompo == nullptr) @@ -6465,7 +6469,7 @@ Milling::CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide //---------------------------------------------------------------------------- bool -Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs) +Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs) const { // determino opzioni di offset int nFlag = ICurve::OFF_FILLET ; diff --git a/Milling.h b/Milling.h index 71d7955..ca5080f 100644 --- a/Milling.h +++ b/Milling.h @@ -129,8 +129,8 @@ class Milling : public Machining bool GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const ; bool GetPointBelowRaw( const Point3d& ptP, const Vector3d& vtTool) const ; bool CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU, bool bInvertSide = false, bool bSawSpecial = false) ; - Vector3d CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide = false, bool bSawSpecial = false) ; - bool CalcOffset( ICurveComposite* pCompo, double dSignOffs) ; + Vector3d CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide = false, bool bSawSpecial = false) const ; + bool CalcOffset( ICurveComposite* pCompo, double dSignOffs) const ; bool TrimExtendCurveToClosedStm( ICurveComposite* pCompo, int nCstmId, bool bInvert) ; private : From 9f7ba94811dd621b8a38378b3c22f0c0f09601ce Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Mon, 25 Nov 2024 15:02:41 +0100 Subject: [PATCH 3/3] EgtMachKernel : - correzione foratura multipla (Riccardo E.) - aggiunta gestione fori non lavorati per foratura multipla (GetMachiningSkippedGeometry). --- Drilling.cpp | 122 ++++++++++++++++++++++++++---------------- Drilling.h | 3 +- MachMgr.h | 4 +- MachMgrOperations.cpp | 16 ++++++ Machining.h | 2 + 5 files changed, 100 insertions(+), 47 deletions(-) diff --git a/Drilling.cpp b/Drilling.cpp index 2aa13fb..7e37dad 100644 --- a/Drilling.cpp +++ b/Drilling.cpp @@ -87,11 +87,11 @@ struct HoleInfo { bool bTempDrill = false ; // [per test maschera ( se durante un test viene lavorato o no)] int nTempTool = IND_TOOL_INVALID ; // [per test maschera ( indice utensile che lo lavora durante un test)] bool bForToolM = false ; // flag per indicare se il tool main lavorerà questo foro - int nIndHoleToolM = IND_HOLE_INVALID ; // se il foro verrà svuotato, contiene l'indice del foro del tool principale + int nIndHoleToolM = IND_HOLE_INVALID ; // se il foro verrà lavorato, contiene l'indice del foro del tool principale // --- vettori ordinati --- INTVECTOR vToolHole ; // []-> indice del foro di inserimento del tool principale - INTVECTOR vIndTools ; // []-> indice del tool che svuoterà il foro corrente + INTVECTOR vIndTools ; // []-> indice del tool che lavorerà il foro corrente VCT3DVECTOR vVtAux ; // []-> vettore ausiliario per tale condifgurazione int nIndTool = IND_TOOL_INVALID ; // indice del tool che alla fine lavorerà il foro @@ -149,7 +149,7 @@ Drilling::Clone( void) const pDri->m_vtTiltingAx = m_vtTiltingAx ; pDri->m_bAboveHead = m_bAboveHead ; pDri->m_bAggrBottom = m_bAggrBottom ; - pDri->m_vIdUndrilledHoles = m_vIdUndrilledHoles ; + pDri->m_vUndrilledId = m_vUndrilledId ; } catch( ...) { delete pDri ; @@ -173,6 +173,7 @@ Drilling::Dump( string& sOut, bool bMM, const char* szNewLine) const sOut += m_TParams.ToString( i) + szNewLine ; sOut += KEY_NUM + EQUAL + ToString( m_nDrillings) + szNewLine ; sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ; + sOut += KEY_SKIPS + EQUAL + ToString( m_vUndrilledId) + szNewLine ; return true ; } @@ -182,7 +183,7 @@ bool Drilling::Save( int nBaseId, STRVECTOR& vString) const { try { - int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 3 ; + int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 3 + ( m_vUndrilledId.empty() ? 0 : 1) ; vString.insert( vString.begin(), nSize, "") ; int k = - 1 ; if ( ! SetVal( KEY_IDS, m_vId, vString[++k])) @@ -197,6 +198,8 @@ Drilling::Save( int nBaseId, STRVECTOR& vString) const return false ; if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k])) return false ; + if ( ! m_vUndrilledId.empty() && ! SetVal( KEY_SKIPS, m_vUndrilledId, vString[++k])) + return false ; } catch( ...) { return false ; @@ -249,6 +252,10 @@ Drilling::Load( const STRVECTOR& vString, int nBaseGdbId) if ( ! FromString( sVal, m_nStatus)) return false ; } + else if ( sKey == KEY_SKIPS) { + if ( ! FromString( sVal, m_vUndrilledId)) + return false ; + } } return true ; } @@ -268,7 +275,6 @@ Drilling::Drilling( void) m_bAboveHead = true ; m_bAggrBottom = false ; m_dDistBottom = 0 ; - m_vIdUndrilledHoles = {} ; } //---------------------------------------------------------------------------- @@ -542,6 +548,8 @@ Drilling::Preview( bool bRecalc) { // reset numero forature nella lavorazione m_nDrillings = 0 ; + // reset fori non lavorati + m_vUndrilledId.clear() ; // verifico validità gestore DB geometrico e Id del gruppo if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId)) return false ; @@ -554,7 +562,7 @@ Drilling::Preview( bool bRecalc) return false ; m_pGeomDB->SetName( nPvId, MCH_PV) ; } - // altrimenti lo svuoto + // altrimenti lo lavoro else m_pGeomDB->EmptyGroup( nPvId) ; @@ -582,6 +590,9 @@ Drilling::Apply( bool bRecalc, bool bPostApply) // reset numero forature nella lavorazione int nCurrDrillings = m_nDrillings ; m_nDrillings = 0 ; + // reset fori non lavorati + INTVECTOR vCurrUndrilledId = m_vUndrilledId ; + m_vUndrilledId.clear() ; // verifico validità gestore DB geometrico e Id del gruppo if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId)) @@ -597,8 +608,9 @@ Drilling::Apply( bool bRecalc, bool bPostApply) // verifico se necessario continuare nell'aggiornamento if ( ! bRecalc && ! bToolChanged && ( m_nStatus == MCH_ST_OK || m_nStatus == MCH_ST_NO_POSTAPPL)) { - // confermo i percorsi di lavorazione + // confermo i percorsi di lavorazione e i fori non lavorati m_nDrillings = nCurrDrillings ; + m_vUndrilledId = vCurrUndrilledId ; string sLog = string( "Drilling apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ; LOG_DBG_INFO( GetEMkLogger(), sLog.c_str()) ; // eseguo aggiornamento assi macchina e collegamento con operazione precedente @@ -620,7 +632,7 @@ Drilling::Apply( bool bRecalc, bool bPostApply) return false ; m_pGeomDB->SetName( nClId, MCH_CL) ; } - // altrimenti lo svuoto + // altrimenti lo lavoro else m_pGeomDB->EmptyGroup( nClId) ; @@ -833,7 +845,7 @@ bool Drilling::CalcDrilledHolesByConfig( VECTORHOLE& vHoles, int nMyInd, int nIndConfig, INTVECTOR& vIndDrilled) { /* - restituisce quali fori non ancora svuotati vengono svuotati con la configurazione di indice nIndConfig + restituisce quali fori non ancora lavorati vengono lavorati con la configurazione di indice nIndConfig per il foro nMyInd-esimo */ @@ -853,7 +865,7 @@ Drilling::CalcDrilledHolesByConfig( VECTORHOLE& vHoles, int nMyInd, int nIndConf // se foro i-esimo già lavorato, passo al successivo if ( vHoles[i].bDrill) continue ; - // se il foro i-esimo è il corrente, lo inserisco ( è svuotato in quanto nella configurazione) + // se il foro i-esimo è il corrente, lo inserisco ( è lavorato in quanto nella configurazione) if ( i == nMyInd) { vIndDrilled.emplace_back( i) ; continue ; @@ -864,7 +876,7 @@ Drilling::CalcDrilledHolesByConfig( VECTORHOLE& vHoles, int nMyInd, int nIndConf continue ; } else { - // se foro i-esimo viene svuotato mettendo il tool principale nel foro nMainHole-esimo e con lo + // se foro i-esimo viene lavorato mettendo il tool principale nel foro nMainHole-esimo e con lo // stesso orientamento della configurazione corrente, inserisco il foro for ( int j = 0 ; j < int( vHoles[i].vToolHole.size()) ; ++ j) { if ( vHoles[i].vToolHole[j] == nMainHole && AreSameVectorApprox( vHoles[i].vVtAux[j], vtMainAux)) @@ -900,6 +912,15 @@ Drilling::GetClosestHolesToHole( const VECTORHOLE& vHoles, int nMyInd, bool bDri // se foro di tipologia opposta, passo al successivo if ( vHoles[i].bDrill != bDrilled) continue ; + // se il foro non è lavorabile, non lo conto + bool bUndrillable = true ; + for ( int j = 0 ; j < int( vHoles[i].vIndTools.size()) && bUndrillable ; ++ j) { + bUndrillable = ( vHoles[i].vToolHole[j] == IND_TOOL_INVALID && + vHoles[i].vIndTools[j] == IND_TOOL_INVALID && + ! vHoles[i].vVtAux[j].IsValid()) ; + } + if ( bUndrillable) + continue ; // calcolo la distanza tra i due fori double dSqDist = SqDist( vHoles[nMyInd].hole.ptIni, vHoles[i].hole.ptIni) ; if ( dSqDist < dMinDist) { @@ -1021,7 +1042,7 @@ Drilling::KeepMinRotatedConfigs( VECTORHOLE& vHoles, const Vector3d vtAux, const bool Drilling::CalcMultyHeadUndrilledHoles( const VECTORHOLE& vHoles, INTVECTOR& vIdUndrilledHoles) { - /* funzione per calcolare gli Id dei fori fori non svuotati */ + /* funzione per calcolare gli Id dei fori fori non lavorati */ // se non ho fori, ho finito vIdUndrilledHoles.clear() ; @@ -1036,7 +1057,7 @@ Drilling::CalcMultyHeadUndrilledHoles( const VECTORHOLE& vHoles, INTVECTOR& vIdU bIsUndrilled = ( vHoles[i].vIndTools[j] == IND_TOOL_INVALID && vHoles[i].vToolHole[j] == IND_TOOL_INVALID && ! vHoles[i].vVtAux[j].IsValid()) ; - // se foro non svuotabile, lo inserisco nel vettore + // se foro non lavorabile, lo inserisco nel vettore if ( bIsUndrilled) vIdUndrilledHoles.emplace_back( vHoles[i].hole.nOriId) ; } @@ -1159,7 +1180,7 @@ bool Drilling::GetHoleBestConfig( VECTORHOLE& vHoles, int nInd, TABMHDRILL& tabDrills, const Vector3d& vtAux, const Vector3d& vtTool, int& nOkHole) { - // salvo gli indici dei fori ( non ancora svuotati) che vengono svuotati con la sola consifugrazione presente + // salvo gli indici dei fori ( non ancora lavorati) che vengono lavorati con la sola consifugrazione presente int nMaxDrilledHoles = - 1 ; INTVECTOR vInds ; int nRefConfig = -1 ; @@ -1191,7 +1212,7 @@ Drilling::GetHoleBestConfig( VECTORHOLE& vHoles, int nInd, TABMHDRILL& tabDrills } } } - // assegno flag per fori svuotati + // assegno flag per fori lavorati for ( int i = 0 ; i < int( vInds.size()) ; ++ i) vHoles[vInds[i]].bDrill = true ; // assegno posizioni di ToolMain @@ -1322,24 +1343,24 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri if ( ! CalcMask( vHoles, vTools, nMainToolInd, vtTool, vtAux)) return false ; - // riduco il numeor di configurazioni in base a vtAux + // riduco il numero di configurazioni in base a vtAux if ( ! KeepMinRotatedConfigs( vHoles, vtAux, vtTool)) return false ; - // calcolo i fori non svuotati - if ( ! CalcMultyHeadUndrilledHoles( vHoles, m_vIdUndrilledHoles)) + // calcolo i fori non lavorati + if ( ! CalcMultyHeadUndrilledHoles( vHoles, m_vUndrilledId)) return false ; - // per ogni foro non svuotato, segnalo il Warning - int nNoDrillHoles = int( m_vIdUndrilledHoles.size()) ; - if ( ! m_vIdUndrilledHoles.empty()) { + // per ogni foro non lavorato, segnalo il Warning + int nUndrilleds = int( m_vUndrilledId.size()) ; + if ( nUndrilleds > 0) { string sIndHoles = "" ; - for ( int i = 0 ; i < nNoDrillHoles ; ++ i) - sIndHoles.append( ToString( m_vIdUndrilledHoles[i]) + ( i != nNoDrillHoles - 1 ? ", " : "")) ; + for ( int i = 0 ; i < nUndrilleds ; ++ i) + sIndHoles += ToString( m_vUndrilledId[i]) + ( i != nUndrilleds - 1 ? ", " : "") ; string sInfo = "Warning in Drilling : Skipped entities " + sIndHoles ; m_pMchMgr->SetWarning( 2151, sInfo) ; } - // se non posso svuotare nessun foro, esco - if ( nNoDrillHoles == int( vHoles.size())) + // se non posso lavorare nessun foro, esco + if ( nUndrilleds == int( vHoles.size())) return true ; // numero di fori lavorati @@ -1355,7 +1376,7 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri // calcolo la massima differenza di lunghezza tra il primo tool e gli altri ( così l'elevazione finale rimane compatibile) double dRefLen = vTools[nMainToolInd].pTool->m_dTLen ; double dOffMax = 0 ; - for ( int nT = 0 ; nT < int( vTools.size()) && nNoDrillHoles != int( vHoles.size()) ; ++ nT) { + for ( int nT = 0 ; nT < int( vTools.size()) && nUndrilleds != int( vHoles.size()) ; ++ nT) { if ( vTools[nT].pTool == nullptr || nT == nMainToolInd) continue ; if ( vTools[nT].pTool->m_dTLen > dRefLen + dOffMax) @@ -1363,10 +1384,9 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri } dMHOff = dOffMax ; - /* Inizio a considerare i fori che presentano meno configurazioni per essere svuotati. - Esso sono i più critici, quindi vengono gestiti per primi, scremando quindi le configurazioni - degli altri fori. - Parto ad analizzare i fori svuotabili con una sola possibile configurazione */ + // Inizio a considerare i fori che presentano meno configurazioni per essere lavorati. + // Essi sono i più critici, quindi vengono gestiti per primi, scremando quindi le configurazioni degli altri. + // Parto ad analizzare i fori lavorabili con una sola possibile configurazione // cerco le configurazioni di base ( quelle con 1 o due configurazioni opposte) for ( int i = 0 ; i < int( vHoles.size()) ; ++ i) { @@ -1380,20 +1400,20 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri return false ; if ( ! bBaseCase) continue ; - // salvo gli indici dei fori ( non ancora svuotati) che vengono svuotati con la sola configurazione presente + // salvo gli indici dei fori ( non ancora lavorati) che vengono lavorati con la sola configurazione presente if ( ! GetHoleBestConfig( vHoles, i, tabDrills, vtAux, vtTool, nOkHole)) return false ; } - // se nessun foro svuotabile, esco ( fino a prova contraria non esco mai...) + // se nessun foro lavorabile, esco ( fino a prova contraria non esco mai...) if ( tabDrills.empty()) return false ; - /* Una volta scremate le configurazioni critiche, cerco i fori non svuotati più vicini ad essi. - L'idea è che avendo svuotato i fori a signola configurazione, ottengo meno combinazioni - per i fori ad esso adiacenti... l'idea si ripete per tutti i fori successivi */ + // Una volta scremate le configurazioni critiche, cerco i fori non lavorati più vicini ad essi. + // L'idea è che avendo lavorato i fori a signola configurazione, ottengo meno combinazioni + // per i fori ad esso adiacenti... l'idea si ripete per tutti i fori successivi // per vicinanza cerco gli altri fori oltre ai casi base - while ( nOkHole < int( vHoles.size()) - nNoDrillHoles) { + while ( nOkHole < int( vHoles.size()) - nUndrilleds) { INTVECTOR vNextInds ; if ( ! GetClosestHolesToHole( vHoles, tabDrills.back().nInd_id_hole, false, vNextInds) || vNextInds.empty() || @@ -1404,9 +1424,9 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri if ( tabDrills.empty()) return false ; - /* Analizzando i fori in base alle possibili combinazioni, ho riempito la tabella delle forature - multiple con lavorazioni sparse tra loro, riordino quindi le discese degli utensili in base - alla vicinanza dei fori svuotati dal Tool principale */ + // Analizzando i fori in base alle possibili combinazioni, ho riempito la tabella delle forature + // multiple con lavorazioni sparse tra loro, riordino quindi le discese degli utensili in base + // alla vicinanza dei fori lavorati dal Tool principale if ( ! MultiHeadOrderConfig( tabDrills, vHoles, vtTool, vtAux)) return false ; @@ -1439,7 +1459,7 @@ Drilling::CalcMask( VECTORHOLE& vHoles, const VECTORTOOL& vTools, int nIndMT, co // in ogni foro i-esimo inserisco il Tool principale for ( int i = 0 ; i < int( vHoles.size()) ; ++ i) { - // resetto le variabili di controllo di svuotatura temporanea per tutti i fori + // resetto le variabili di controllo di lavorazione temporanea per tutti i fori for ( int j = 0 ; j < int( vHoles.size()) ; ++ j) { vHoles[j].bTempDrill = false ; vHoles[j].nTempTool = -1 ; @@ -1482,12 +1502,12 @@ Drilling::CalcMask( VECTORHOLE& vHoles, const VECTORTOOL& vTools, int nIndMT, co // controllo la compatibilità tra le geometrie dei Tool e dei fori CheckOtherHolesWithTools( vHoles, vTools, nIndMT, i, Hole_i, frMT, frHMT, dDiamToler, nDrills) ; - // controllo quanti fori sono riuscito a svuotare e setto i loro parametri di foratura - if ( nDrills == nExitCnt - nNullTools) { // se ho svuotato il numero corretto di fori ... + // controllo quanti fori sono riuscito a lavorare e setto i loro parametri di foratura + if ( nDrills == nExitCnt - nNullTools) { // se ho lavorato il numero corretto di fori ... for ( int nD = 0 ; nD < int( vHoles.size()) ; ++ nD) { if ( vHoles[nD].bTempDrill) { vHoles[nD].vToolHole.push_back( i) ; // indice del foro per il tool principale - vHoles[nD].vIndTools.push_back( vHoles[nD].nTempTool) ; // indice del tool che svuota questo foro + vHoles[nD].vIndTools.push_back( vHoles[nD].nTempTool) ; // indice del tool che lavora questo foro vHoles[nD].vVtAux.push_back( frHMT.VersX()) ; // versore ausiliario A del tool principale } else { @@ -1687,7 +1707,7 @@ Drilling::AlongCurveProcess( bool bRecalc, int nPvId, int nClId) m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ; bChain = true ; } - // altrimenti, se chiesto ricalcolo, lo svuoto + // altrimenti, se chiesto ricalcolo, lo lavoro else if ( bRecalc) { m_pGeomDB->EmptyGroup( nAuxId) ; bChain = true ; @@ -1869,7 +1889,7 @@ Drilling::ProcessPath( int nPathId, int nPvId, int nClId) return false ; m_pGeomDB->SetName( nTempId, GRP_TEMP) ; } - // altrimenti lo svuoto + // altrimenti lo lavoro else m_pGeomDB->EmptyGroup( nTempId) ; // in ogni caso lo dichiaro temporaneo e non visibile @@ -2343,6 +2363,18 @@ Drilling::GetGeometry( SELVECTOR& vIds) const return true ; } +//---------------------------------------------------------------------------- +bool +Drilling::GetSkippedGeometry( SELVECTOR& vIds) const +{ + // pulisco elenco entità non lavorate + vIds.clear() ; + // inserisco le entità non lavorate + for ( const auto& nId : m_vUndrilledId) + vIds.emplace_back( nId, SEL_SUB_ALL) ; + return true ; +} + //---------------------------------------------------------------------------- bool Drilling::GetHoleData( SelData Id, Hole& hole) diff --git a/Drilling.h b/Drilling.h index eb50455..244388c 100644 --- a/Drilling.h +++ b/Drilling.h @@ -68,6 +68,7 @@ class Drilling : public Machining bool UpdateToolData( bool* pbChanged = nullptr) override ; const ToolData& GetToolData( void) const override ; bool GetGeometry( SELVECTOR& vIds) const override ; + bool GetSkippedGeometry( SELVECTOR& vIds) const override ; public : Drilling( void) ; @@ -126,5 +127,5 @@ class Drilling : public Machining Vector3d m_vtAggrBottom ; // vettore direzione ausiliaria aggregato da sotto double m_dDistBottom ; // distanza del foro dal bordo del grezzo AggrBottom m_AggrBottom ; // dati eventuale aggregato da sotto - INTVECTOR m_vIdUndrilledHoles ; // vettore degli indici dei fori non svuotati + INTVECTOR m_vUndrilledId ; // vettore degli identificativi dei fori non svuotati } ; diff --git a/MachMgr.h b/MachMgr.h index e4d76bd..f35fcbd 100644 --- a/MachMgr.h +++ b/MachMgr.h @@ -1,7 +1,7 @@ //---------------------------------------------------------------------------- // EgalTech 2015-2024 //---------------------------------------------------------------------------- -// File : MachMgr.h Data : 22.04.24 Versione : 2.6d4 +// File : MachMgr.h Data : 25.11.24 Versione : 2.6k5 // Contenuto : Dichiarazione della classe MachMgr. // // @@ -16,6 +16,7 @@ // 30.03.24 DS Aggiunte GetAllAxesNames e GetCalcTable. // 02.04.24 DS Aggiunta GetClEntAxesMask. // 22.04.24 DS Aggiunta GetExitId. +// 25.11.24 DS Aggiunta GetMachiningSkippedGeometry. // //---------------------------------------------------------------------------- @@ -310,6 +311,7 @@ class MachMgr : public IMachMgr bool GetMachiningParam( int nType, double& dVal) const override ; bool GetMachiningParam( int nType, std::string& sVal) const override ; bool GetMachiningGeometry( SELVECTOR& vIds) const override ; + bool GetMachiningSkippedGeometry( SELVECTOR& vIds) const override ; bool IsMachiningEmpty( void) const override ; bool GetMachiningStartPoint( Point3d& ptStart) const override ; bool GetMachiningEndPoint( Point3d& ptEnd) const override ; diff --git a/MachMgrOperations.cpp b/MachMgrOperations.cpp index 8c99988..bb386b6 100644 --- a/MachMgrOperations.cpp +++ b/MachMgrOperations.cpp @@ -1261,6 +1261,22 @@ MachMgr::GetMachiningGeometry( SELVECTOR& vIds) const return pMch->GetGeometry( vIds) ; } +//---------------------------------------------------------------------------- +bool +MachMgr::GetMachiningSkippedGeometry( SELVECTOR& vIds) const +{ + // recupero la lavorazione corrente + int nCurrMchId = GetCurrMachining() ; + if ( nCurrMchId == GDB_ID_NULL) + return false ; + // ne recupero il gestore + Machining* pMch = GetMachining( m_pGeomDB->GetUserObj( nCurrMchId)) ; + if ( pMch == nullptr) + return false ; + // restituisco la geometria non lavorata + return pMch->GetSkippedGeometry( vIds) ; +} + //---------------------------------------------------------------------------- bool MachMgr::IsMachiningEmpty( void) const diff --git a/Machining.h b/Machining.h index 3979cc5..e67b222 100644 --- a/Machining.h +++ b/Machining.h @@ -43,6 +43,8 @@ class Machining : public Operation virtual bool UpdateToolData( bool* pbChanged = nullptr) = 0 ; virtual const ToolData& GetToolData( void) const = 0 ; virtual bool GetGeometry( SELVECTOR& vIds) const = 0 ; + virtual bool GetSkippedGeometry( SELVECTOR& vIds) const + { vIds.clear() ; return false ; } public : bool GetStartPoint( Point3d& ptStart) const ;