Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge commit '9f7ba94811dd621b8a38378b3c22f0c0f09601ce' into feature/Svuotature

Browse Source
This commit is contained in:
Riccardo Elitropi
2024-11-27 11:50:32 +01:00
parent 61fa524332 9f7ba94811
commit 6ad07c2443
11 changed files with 135 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Drilling.cpp
+77 -45
View File
@@ -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)
Drilling.h
+2 -1
View File
@@ -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
} ;
EgtMachKernel.rc
BIN
View File
Binary file not shown.
MachMgr.h
+3 -1
View File
@@ -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 ;
MachMgrOperations.cpp
+16
View File
@@ -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
Machining.h
+2
View File
@@ -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 ;
Milling.cpp
+11 -7
View File
@@ -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 ;
Milling.h
+2 -2
View File
@@ -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 :
OutputConst.h
+2 -1
View File
@@ -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" ;
SimulatorMP.cpp
+19 -5
View File
@@ -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) {
SimulatorMP.h
+1
View File
@@ -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