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 ;