Dario Sassi
d4e4ea3871
- gestita posizione Tavola Home diversa da posizione 0 Macchina in disposizione - in generazione si assegna il nome macchina - nel confronto attrezzaggio utensili si tiene conto della posizione in ToolChanger - se angoli indeterminati ma si determinano con asse ausiliario, li rendo tali direttamente - aggiunto comando per ricaricare DB utensili e lavorazioni - aggiunta funzione GetPhaseLastOperation - ora inserimento lavorazione avviene alla fine della fase corrente - migliorato split di grezzo con lavorazioni - in taglio di lama e fresatura irrobustito allungamenti/accorciamenti percorso.
1008 lines
32 KiB
C++
1008 lines
32 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2016
|
|
//----------------------------------------------------------------------------
|
|
// File : MachiningsMgr.cpp Data : 13.07.16 Versione : 1.6r8
|
|
// Contenuto : Implementazione gestore database lavorazioni.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 02.06.15 DS Creazione modulo.
|
|
// 13.07.16 DS Aggiunta gestione SplitArcs (MF_CURR_VER = 1005).
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "MachiningsMgr.h"
|
|
#include "MachiningDataFactory.h"
|
|
#include "MachiningConst.h"
|
|
#include "DllMain.h"
|
|
#include "/EgtDEv/Include/EGkGeoConst.h"
|
|
#include "/EgtDEv/Include/EMkMachiningConst.h"
|
|
#include "/EgtDEv/Include/EGnStringKeyVal.h"
|
|
#include "/EgtDEv/Include/EGnStringUtils.h"
|
|
#include "/EgtDEv/Include/EGnFileUtils.h"
|
|
#include "/EgtDEv/Include/EGnScanner.h"
|
|
#include "/EgtDEv/Include/EGnWriter.h"
|
|
#include "/EgtDEv/Include/EgtPointerOwner.h"
|
|
#include <cassert>
|
|
#include <bitset>
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
const string MF_HEADER = "[HEADER]" ;
|
|
const string MF_VERSION = "VERSION" ;
|
|
const string MF_TOTAL = "TOTAL" ;
|
|
const string MF_SIZE = "SIZE" ;
|
|
const int MF_CURR_VER = 1005 ;
|
|
const string MF_GENERAL = "[GENERAL]" ;
|
|
const string MF_3AXCOMP = "3AXCOMP" ;
|
|
const bool MF_CURR_3AXCOMP = false ;
|
|
const string MF_5AXCOMP = "5AXCOMP" ;
|
|
const bool MF_CURR_5AXCOMP = false ;
|
|
const string MF_SAFEZ = "SAFEZ" ;
|
|
const double MF_CURR_SAFEZ = 100 ;
|
|
const string MF_EXTRALCR = "EXTRALCR" ;
|
|
const double MF_CURR_EXTRALCR = 0 ;
|
|
const string MF_EXTRARDR = "EXTRARDR" ;
|
|
const double MF_CURR_EXTRARDR = 0 ;
|
|
const string MF_HOLEDTOL = "HOLEDTOL" ;
|
|
const double MF_CURR_HOLEDTOL = 10 * EPS_SMALL ;
|
|
const string MF_EXTSAWARCMINRAD = "EXTSAWARCMINRAD" ;
|
|
const double MF_CURR_EXTSAWARCMINRAD = 200 ;
|
|
const string MF_SPLITARCS = "SPLITARCS" ;
|
|
const int MF_CURR_SPLITARCS = SPLAR_NEVER ;
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
MachiningsMgr::MachiningsMgr( void)
|
|
{
|
|
m_pTsMgr = nullptr ;
|
|
m_suCIter = m_suData.cend() ;
|
|
m_pCurrMach = nullptr ;
|
|
m_bModified = false ;
|
|
m_dSafeZ = MF_CURR_SAFEZ ;
|
|
m_b3AxComp = MF_CURR_3AXCOMP ;
|
|
m_b5AxComp = MF_CURR_5AXCOMP ;
|
|
m_dExtraLOnCutRegion = MF_CURR_EXTRALCR ;
|
|
m_dExtraROnDrillRegion = MF_CURR_EXTRARDR ;
|
|
m_dHoleDiamToler = MF_CURR_HOLEDTOL ;
|
|
m_dExtSawArcMinRad = MF_CURR_EXTSAWARCMINRAD ;
|
|
m_nSplitArcs = MF_CURR_SPLITARCS ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
MachiningsMgr::~MachiningsMgr( void)
|
|
{
|
|
Clear( true) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::Clear( bool bReset)
|
|
{
|
|
// libero la memoria dalle lavorazioni
|
|
for ( auto iIter = m_umData.begin() ; iIter != m_umData.end() ; ++ iIter) {
|
|
if ( iIter->second != nullptr)
|
|
delete iIter->second ;
|
|
}
|
|
// reset puntatore a gestore utensili
|
|
if ( bReset)
|
|
m_pTsMgr = nullptr ;
|
|
// pulisco le tabelle
|
|
m_umData.clear() ;
|
|
m_suData.clear() ;
|
|
// reinizializzo stato
|
|
m_suCIter = m_suData.cend() ;
|
|
if ( m_pCurrMach != nullptr) {
|
|
delete m_pCurrMach ;
|
|
m_pCurrMach = nullptr ;
|
|
}
|
|
m_bModified = false ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::Load( const string& sMachsFile, const ToolsMgr* pTsMgr)
|
|
{
|
|
// Salvo la path del file con i dati
|
|
m_sMachsFile = sMachsFile ;
|
|
string sOut = "MachiningsMgr Init : " + m_sMachsFile ;
|
|
LOG_INFO( GetEMkLogger(), sOut.c_str())
|
|
|
|
// Verifico il gestore degli utensili
|
|
if ( pTsMgr == nullptr) {
|
|
LOG_ERROR( GetEMkLogger(), "LoadMachinings : Error on ToolsMgr")
|
|
return false ;
|
|
}
|
|
m_pTsMgr = pTsMgr ;
|
|
|
|
// carico
|
|
return Reload() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::Reload( void)
|
|
{
|
|
// Pulisco
|
|
Clear( false) ;
|
|
|
|
// Verifico il gestore degli utensili
|
|
if ( m_pTsMgr == nullptr) {
|
|
LOG_ERROR( GetEMkLogger(), "ReloadMachinings : Error on ToolsMgr")
|
|
return false ;
|
|
}
|
|
|
|
// Inizializzo lo scanner
|
|
Scanner TheScanner ;
|
|
if ( ! TheScanner.Init( m_sMachsFile, ";")) {
|
|
LOG_ERROR( GetEMkLogger(), "ReloadMachinings : Error on Init")
|
|
return false ;
|
|
}
|
|
|
|
// variabili di stato della lettura
|
|
bool bOk = true ;
|
|
bool bEnd = false ;
|
|
|
|
// Leggo l'intestazione
|
|
int nVersion = 0 ;
|
|
int nTotal = 0 ;
|
|
if ( ! LoadHeader( TheScanner, nVersion, nTotal, bEnd)) {
|
|
bOk = false ;
|
|
string sOut = "ReloadMachinings : Error on Header" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str())
|
|
}
|
|
{
|
|
string sOut = "ReloadMachinings : FileVer = " + ToString( nVersion) + " CurrVer = " + ToString( MF_CURR_VER) ;
|
|
LOG_INFO( GetEMkLogger(), sOut.c_str())
|
|
}
|
|
|
|
// Leggo i dati generali (da versione 1002)
|
|
if ( nVersion >= 1002 && ! LoadGeneral( TheScanner, bEnd)) {
|
|
bOk = false ;
|
|
string sOut = "ReloadMachinings : Error on General" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str())
|
|
}
|
|
|
|
// Dimensiono map
|
|
const int MIN_BUCKETS = 163 ;
|
|
m_umData.rehash( MIN_BUCKETS) ;
|
|
|
|
// Ciclo di lettura delle lavorazioni
|
|
do {
|
|
if ( ! LoadOneMachining( TheScanner, bEnd)) {
|
|
bOk = false ;
|
|
string sOut = "ReloadMachinings : Error on line " + ToString( TheScanner.GetCurrLineNbr()) ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str())
|
|
}
|
|
} while ( bOk && ! bEnd) ;
|
|
|
|
// Termino lo scanner
|
|
TheScanner.Terminate() ;
|
|
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::LoadHeader( Scanner& TheScanner, int& nVersion, int& nTotal, bool& bEnd)
|
|
{
|
|
// leggo la prossima linea
|
|
string sLine ;
|
|
if ( ! TheScanner.GetLine( sLine)) {
|
|
// fine file
|
|
bEnd = true ;
|
|
return true ;
|
|
}
|
|
// deve essere intestazione
|
|
if ( sLine != MF_HEADER)
|
|
return false ;
|
|
bool bOk = true ;
|
|
// leggo le linee successive
|
|
bEnd = true ;
|
|
nVersion = 1000 ;
|
|
nTotal = 0 ;
|
|
while ( bOk && TheScanner.GetLine( sLine)) {
|
|
// se sezione successiva
|
|
if ( sLine.front() == '[' && sLine.back() == ']') {
|
|
TheScanner.UngetLine( sLine) ;
|
|
bEnd = false ;
|
|
break ;
|
|
}
|
|
// separo chiave da valore
|
|
string sKey, sVal ;
|
|
SplitFirst( sLine, "=", sKey, sVal) ;
|
|
// riconosco la chiave
|
|
if ( ToUpper( sKey) == MF_VERSION)
|
|
bOk = FromString( sVal, nVersion) ;
|
|
else if ( ToUpper( sKey) == MF_TOTAL)
|
|
bOk = FromString( sVal, nTotal) ;
|
|
else
|
|
bOk = false ;
|
|
}
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::LoadGeneral( Scanner& TheScanner, bool& bEnd)
|
|
{
|
|
// leggo la prossima linea
|
|
string sLine ;
|
|
if ( ! TheScanner.GetLine( sLine)) {
|
|
// fine file
|
|
bEnd = true ;
|
|
return true ;
|
|
}
|
|
// deve essere dati generali
|
|
if ( sLine != MF_GENERAL)
|
|
return false ;
|
|
bool bOk = true ;
|
|
// leggo le linee successive
|
|
bEnd = true ;
|
|
while ( bOk && TheScanner.GetLine( sLine)) {
|
|
// se sezione successiva
|
|
if ( sLine.front() == '[' && sLine.back() == ']') {
|
|
TheScanner.UngetLine( sLine) ;
|
|
bEnd = false ;
|
|
break ;
|
|
}
|
|
// separo chiave da valore
|
|
string sKey, sVal ;
|
|
SplitFirst( sLine, "=", sKey, sVal) ;
|
|
// riconosco la chiave
|
|
if ( ToUpper( sKey) == MF_3AXCOMP)
|
|
bOk = FromString( sVal, m_b3AxComp) ;
|
|
else if ( ToUpper( sKey) == MF_5AXCOMP)
|
|
bOk = FromString( sVal, m_b5AxComp) ;
|
|
else if ( ToUpper( sKey) == MF_SAFEZ)
|
|
bOk = FromString( sVal, m_dSafeZ) ;
|
|
else if ( ToUpper( sKey) == MF_EXTRALCR)
|
|
bOk = FromString( sVal, m_dExtraLOnCutRegion) ;
|
|
else if ( ToUpper( sKey) == MF_EXTRARDR)
|
|
bOk = FromString( sVal, m_dExtraROnDrillRegion) ;
|
|
else if ( ToUpper( sKey) == MF_HOLEDTOL)
|
|
bOk = FromString( sVal, m_dHoleDiamToler) ;
|
|
else if ( ToUpper( sKey) == MF_EXTSAWARCMINRAD)
|
|
bOk = FromString( sVal, m_dExtSawArcMinRad) ;
|
|
else if ( ToUpper( sKey) == MF_SPLITARCS)
|
|
bOk = FromString( sVal, m_nSplitArcs) ;
|
|
else
|
|
bOk = false ;
|
|
}
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::LoadOneMachining( Scanner& TheScanner, bool& bEnd)
|
|
{
|
|
// leggo la prossima linea
|
|
string sLine ;
|
|
if ( ! TheScanner.GetLine( sLine)) {
|
|
// fine file
|
|
bEnd = true ;
|
|
return true ;
|
|
}
|
|
// deve essere intestazione
|
|
if ( sLine.front() != '[' || sLine.back() != ']')
|
|
return false ;
|
|
Trim( sLine, "[]") ;
|
|
// separo tipo da contatore
|
|
string sType, sCount ;
|
|
SplitFirst( sLine, "_", sType, sCount) ;
|
|
ToUpper( sType) ;
|
|
// alloco la lavorazione del tipo corrispondente
|
|
PtrOwner<MachiningData> pMch( MCHDATA_CREATE( MCHDATA_NAMETOTYPE( sType))) ;
|
|
if ( IsNull( pMch))
|
|
return false ;
|
|
bool bOk = true ;
|
|
// imposto dimensione di default
|
|
int nSize = 0 ;
|
|
switch ( pMch->GetType()) {
|
|
case MT_DRILLING : nSize = 11 ; break ;
|
|
case MT_SAWING : nSize = 15 ; break ;
|
|
case MT_MILLING : nSize = 26 ; break ;
|
|
}
|
|
// eventuale lettura da file
|
|
if ( TheScanner.GetLine( sLine)) {
|
|
if ( ! GetVal( sLine, MF_SIZE, nSize))
|
|
TheScanner.UngetLine( sLine) ;
|
|
}
|
|
// leggo i dati della lavorazione
|
|
bEnd = true ;
|
|
const int DIM_BS = 64 ;
|
|
bitset<DIM_BS> Flag ;
|
|
assert( nSize <= DIM_BS) ;
|
|
while ( bOk && TheScanner.GetLine( sLine)) {
|
|
// se lavorazione successiva
|
|
if ( sLine.front() == '[' && sLine.back() == ']') {
|
|
TheScanner.UngetLine( sLine) ;
|
|
bEnd = false ;
|
|
break ;
|
|
}
|
|
// interpreto la linea
|
|
int nKey = - 1 ;
|
|
bOk = pMch->FromString( sLine, nKey) ;
|
|
// se tutto bene, dichiaro letto il campo
|
|
if ( bOk)
|
|
Flag.set( nKey) ;
|
|
}
|
|
// verifico di aver letto tutti i campi
|
|
bOk = bOk && ( Flag.count() == nSize) ;
|
|
// salvo i dati della lavorazione
|
|
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) ;
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::Save( bool bCompressed) const
|
|
{
|
|
// Se non ci sono state modifiche, esco subito
|
|
if ( ! m_bModified)
|
|
return true ;
|
|
|
|
// Faccio copia di backup del file originale
|
|
CopyFileEgt( m_sMachsFile, m_sMachsFile + ".bak") ;
|
|
|
|
// Inizializzo il writer
|
|
Writer TheWriter ;
|
|
if ( ! TheWriter.Init( m_sMachsFile, bCompressed)) {
|
|
LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on Init")
|
|
return false ;
|
|
}
|
|
|
|
// Scrivo linea di inizio file
|
|
string sOut = "; --- " + m_sMachsFile + " " + CurrDateTime() + " ---" ;
|
|
if ( ! TheWriter.OutText( sOut)) {
|
|
LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on Start")
|
|
return false ;
|
|
}
|
|
|
|
// Scrivo l'intestazione
|
|
if ( ! SaveHeader( TheWriter)) {
|
|
LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on Header")
|
|
return false ;
|
|
}
|
|
|
|
// Scrivo i dati generali
|
|
if ( ! SaveGeneral( TheWriter)) {
|
|
LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on General")
|
|
return false ;
|
|
}
|
|
|
|
// Ciclo su tutti i nomi delle lavorazioni
|
|
int nCounter = 0 ;
|
|
for ( auto iIter = m_suData.cbegin() ; iIter != m_suData.cend() ; ++ iIter) {
|
|
// salvo l'utensile
|
|
if ( ! SaveOneMachining( iIter->second, nCounter, TheWriter)) {
|
|
string sOut = "SaveMachinings : Error on machining " + iIter->first ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str())
|
|
return false ;
|
|
}
|
|
}
|
|
|
|
// Scrivo linea di fine file
|
|
if ( ! TheWriter.OutText( "; --- End ---")) {
|
|
LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on End")
|
|
return false ;
|
|
}
|
|
|
|
// Chiudo la scrittura
|
|
TheWriter.Close() ;
|
|
|
|
// Dichiaro non più modificato rispetto al file
|
|
m_bModified = false ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SaveHeader( Writer& TheWriter) const
|
|
{
|
|
// scrivo l'intestazione
|
|
bool bOk = true ;
|
|
string sOut ;
|
|
sOut = MF_HEADER ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_VERSION + "=" + ToString( MF_CURR_VER) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_TOTAL + "=" + ToString( int( m_umData.size())) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SaveGeneral( Writer& TheWriter) const
|
|
{
|
|
// scrivo l'intestazione
|
|
bool bOk = true ;
|
|
string sOut ;
|
|
sOut = MF_GENERAL ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_3AXCOMP + "=" + ToString( m_b3AxComp) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_5AXCOMP + "=" + ToString( m_b5AxComp) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_SAFEZ + "=" + ToString( m_dSafeZ) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_EXTRALCR + "=" + ToString( m_dExtraLOnCutRegion) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_EXTRARDR + "=" + ToString( m_dExtraROnDrillRegion) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_HOLEDTOL + "=" + ToString( m_dHoleDiamToler) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_EXTSAWARCMINRAD + "=" + ToString( m_dExtSawArcMinRad) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
sOut = MF_SPLITARCS + "=" + ToString( m_nSplitArcs) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SaveOneMachining( const EgtUUID& Uuid, int& nCounter, Writer& TheWriter) const
|
|
{
|
|
// recupero i dati della lavorazione
|
|
auto iIter = m_umData.find( Uuid) ;
|
|
if ( iIter == m_umData.end())
|
|
return false ;
|
|
const MachiningData* pmData = iIter->second ;
|
|
// scrivo i dati della lavorazione
|
|
string sOut = "[" + pmData->GetTitle() + "_" + ToString( ++ nCounter, 3) + "]" ;
|
|
bool bOk = TheWriter.OutText( sOut) ;
|
|
sOut = MF_SIZE + "=" + ToString( pmData->GetSize()) ;
|
|
bOk = bOk && TheWriter.OutText( sOut) ;
|
|
for ( int i = 0 ; i < pmData->GetSize() ; ++ i) {
|
|
string sOut = pmData->ToString( i) ;
|
|
bOk = bOk && ! sOut.empty() && TheWriter.OutText( sOut) ;
|
|
}
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::GetMachiningNewName( string& sName) const
|
|
{
|
|
// il parametro nome deve essere valido
|
|
if ( &sName == nullptr)
|
|
return false ;
|
|
// se nome vuoto, assegno radice standard
|
|
if ( sName.empty())
|
|
sName = "Mach" ;
|
|
// verifico che il nome sia unico
|
|
int nCount = 0 ;
|
|
string sOrigName = sName ;
|
|
if ( sOrigName.length() > 2 && sOrigName.rfind( "_1") == sOrigName.length() - 2)
|
|
sOrigName.erase( sOrigName.length() - 2) ;
|
|
while ( GetMachining( sName) != nullptr) {
|
|
++ nCount ;
|
|
sName = sOrigName + "_" + ToString( nCount) ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::AddMachining( const string& sName, int nType)
|
|
{
|
|
// annullo lavorazione corrente
|
|
if ( m_pCurrMach != nullptr)
|
|
delete m_pCurrMach ;
|
|
// verifico unicità del nome
|
|
if ( m_suData.find( sName) != m_suData.end())
|
|
return false ;
|
|
// verifico validità del tipo
|
|
if ( ! IsValidMachiningType( nType))
|
|
return false ;
|
|
// alloco la lavorazione del tipo corrispondente
|
|
PtrOwner<MachiningData> pMch( MCHDATA_CREATE( nType)) ;
|
|
if ( IsNull( pMch))
|
|
return false ;
|
|
bool bOk = true ;
|
|
// assegno nome
|
|
pMch->m_sName = sName ;
|
|
CreateEgtUUID( pMch->m_Uuid) ;
|
|
// salvo i dati della lavorazione
|
|
bOk = bOk && m_umData.emplace( pMch->m_Uuid, Get( pMch)).second ;
|
|
bOk = bOk && m_suData.emplace( pMch->m_sName, pMch->m_Uuid).second ;
|
|
m_bModified = true ;
|
|
// la rendo la nuova lavorazione corrente
|
|
m_pCurrMach = pMch->Clone() ;
|
|
Release( pMch) ;
|
|
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::CopyMachining( const string& sSource, const string& sName)
|
|
{
|
|
// annullo lavorazione corrente
|
|
if ( m_pCurrMach != nullptr)
|
|
delete m_pCurrMach ;
|
|
// verifico unicità del nome
|
|
if ( m_suData.find( sName) != m_suData.end())
|
|
return false ;
|
|
// recupero la lavorazione sorgente
|
|
const MachiningData* pMdata = GetMachining( sSource) ;
|
|
if ( pMdata == nullptr)
|
|
return false ;
|
|
// ne faccio una copia
|
|
PtrOwner<MachiningData> pMch( pMdata->Clone()) ;
|
|
if ( IsNull( pMch))
|
|
return false ;
|
|
bool bOk = true ;
|
|
// modifico nome e UUID
|
|
pMch->m_sName = sName ;
|
|
CreateEgtUUID( pMch->m_Uuid) ;
|
|
// salvo i dati della lavorazione
|
|
bOk = bOk && m_umData.emplace( pMch->m_Uuid, Get( pMch)).second ;
|
|
bOk = bOk && m_suData.emplace( pMch->m_sName, pMch->m_Uuid).second ;
|
|
m_bModified = true ;
|
|
// la rendo la nuova lavorazione corrente
|
|
m_pCurrMach = pMch->Clone() ;
|
|
Release( pMch) ;
|
|
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::RemoveMachining( const string& sName)
|
|
{
|
|
// cerco la lavorazione nell'elenco dei nomi e degli UUID
|
|
auto iNameIter = m_suData.find( sName) ;
|
|
if ( iNameIter == m_suData.end())
|
|
return true ;
|
|
auto iIter = m_umData.find( iNameIter->second) ;
|
|
// se era anche la lavorazione corrente, la resetto
|
|
if ( m_pCurrMach != nullptr && m_pCurrMach->m_Uuid == iNameIter->second) {
|
|
delete m_pCurrMach ;
|
|
m_pCurrMach = nullptr ;
|
|
}
|
|
if ( iIter != m_umData.end()) {
|
|
// libero la memoria della lavorazione
|
|
delete iIter->second ;
|
|
// rimuovo la lavorazione dal dizionario degli UUID
|
|
m_umData.erase( iIter) ;
|
|
}
|
|
// rimuovo la lavorazione dall'elenco dei nomi
|
|
m_suData.erase( iNameIter) ;
|
|
// dichiaro la modifica
|
|
m_bModified = true ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const MachiningData*
|
|
MachiningsMgr::GetMachining( const EgtUUID& Uuid) const
|
|
{
|
|
auto iIter = m_umData.find( Uuid) ;
|
|
if ( iIter == m_umData.end())
|
|
return nullptr ;
|
|
return iIter->second ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const MachiningData*
|
|
MachiningsMgr::GetMachining( const string& sName) const
|
|
{
|
|
auto iIter = m_suData.find( sName) ;
|
|
if ( iIter == m_suData.end())
|
|
return nullptr ;
|
|
return GetMachining( iIter->second) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::GetFirstMachining( int nType, string& sName) const
|
|
{
|
|
// recupero primo nome
|
|
m_suCIter = m_suData.begin() ;
|
|
// lo verifico
|
|
if ( VerifyCurrMachining( nType, sName))
|
|
return true ;
|
|
// continuo ricerca
|
|
return GetNextMachining( nType, sName) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::GetNextMachining( int nType, string& sName) const
|
|
{
|
|
// mentre esiste utensile
|
|
while ( m_suCIter != m_suData.end()) {
|
|
// nome successivo
|
|
++ m_suCIter ;
|
|
// lo verifico
|
|
if ( VerifyCurrMachining( nType, sName))
|
|
return true ;
|
|
}
|
|
// non trovato
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::VerifyCurrMachining( int nType, string& sName) const
|
|
{
|
|
// il corrente deve esistere
|
|
if ( m_suCIter == m_suData.end())
|
|
return false ;
|
|
// relativa lavorazione
|
|
auto iIter = m_umData.find( m_suCIter->second) ;
|
|
if ( iIter == m_umData.end()) {
|
|
m_suCIter = m_suData.end() ;
|
|
return false ;
|
|
}
|
|
// se è del tipo richiesto, trovato
|
|
if ( iIter->second->GetType() == nType) {
|
|
sName = iIter->second->m_sName ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetCurrMachining( const string& sName)
|
|
{
|
|
// se c'è lavorazione corrente, la elimino
|
|
if ( m_pCurrMach != nullptr)
|
|
delete m_pCurrMach ;
|
|
m_pCurrMach = nullptr ;
|
|
// recupero i dati della lavorazione
|
|
const MachiningData* pMdata = GetMachining( sName) ;
|
|
if ( pMdata == nullptr)
|
|
return false ;
|
|
// li copio come correnti
|
|
m_pCurrMach = pMdata->Clone() ;
|
|
return ( m_pCurrMach != nullptr) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SaveCurrMachining( void)
|
|
{
|
|
// verifico validità lavorazione corrente
|
|
if ( m_pCurrMach == nullptr)
|
|
return false ;
|
|
// recupero puntatore a lavorazione corrente nel DB
|
|
auto iIter = m_umData.find( m_pCurrMach->m_Uuid) ;
|
|
if ( iIter == m_umData.end())
|
|
return false ;
|
|
// la lavorazione corrente e la sua origine nel DB devono essere dello stesso tipo
|
|
if ( m_pCurrMach->GetType() != iIter->second->GetType())
|
|
return false ;
|
|
// se cambiato nome, devo aggiornare tabella relativa
|
|
if ( m_pCurrMach->m_sName != iIter->second->m_sName) {
|
|
// cerco la lavorazione nell'elenco dei nomi
|
|
auto iNameIter = m_suData.find( iIter->second->m_sName) ;
|
|
if ( iNameIter != m_suData.end()) {
|
|
// rimuovo vecchio nome
|
|
m_suData.erase( iNameIter) ;
|
|
// inserisco nuovo
|
|
m_suData.emplace( m_pCurrMach->m_sName, m_pCurrMach->m_Uuid) ;
|
|
}
|
|
}
|
|
// eseguo salvataggio
|
|
m_bModified = true ;
|
|
iIter->second->CopyFrom( m_pCurrMach) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::IsCurrMachiningModified( void) const
|
|
{
|
|
// verifico validità lavorazione corrente
|
|
if ( m_pCurrMach == nullptr)
|
|
return false ;
|
|
// recupero puntatore a lavorazione corrente nel DB
|
|
auto iIter = m_umData.find( m_pCurrMach->m_Uuid) ;
|
|
if ( iIter == m_umData.end())
|
|
return false ;
|
|
// eseguo confronto
|
|
return ( ! SameMachining( m_pCurrMach, iIter->second)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetCurrMachiningParam( int nType, bool bVal)
|
|
{
|
|
return ( ( m_pCurrMach != nullptr) ? m_pCurrMach->SetParam( nType, bVal) : false) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetCurrMachiningParam( int nType, int nVal)
|
|
{
|
|
return ( ( m_pCurrMach != nullptr) ? m_pCurrMach->SetParam( nType, nVal) : false) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetCurrMachiningParam( int nType, double dVal)
|
|
{
|
|
// deve esistere lavorazione corrente
|
|
if ( m_pCurrMach == nullptr)
|
|
return false ;
|
|
// se speed
|
|
if ( nType == MPA_SPEED) {
|
|
// recupero valore da utensile
|
|
const ToolData* pTdata ;
|
|
if ( ! m_pCurrMach->GetTool( m_pTsMgr, pTdata))
|
|
return false ;
|
|
// verifico non superi il massimo consentito
|
|
if ( abs( dVal) > pTdata->m_dMaxSpeed + EPS_SMALL)
|
|
return false ;
|
|
// verifico se valore coincide con impostazione da utensile
|
|
double dTVal ;
|
|
if ( pTdata->GetParam( MPA2TPA( nType), dTVal) && abs( dVal - dTVal) < EPS_MACH_LEN_PAR)
|
|
dVal = 0 ;
|
|
return m_pCurrMach->SetParam( nType, dVal) ;
|
|
}
|
|
// se feed
|
|
else if ( nType == MPA_FEED ||
|
|
nType == MPA_STARTFEED || nType == MPA_ENDFEED || nType == MPA_TIPFEED) {
|
|
// recupero valore da utensile
|
|
const ToolData* pTdata ;
|
|
if ( ! m_pCurrMach->GetTool( m_pTsMgr, pTdata))
|
|
return false ;
|
|
// verifico se valore coincide con impostazione da utensile
|
|
double dTVal ;
|
|
if ( pTdata->GetParam( MPA2TPA( nType), dTVal) && abs( dVal - dTVal) < EPS_MACH_LEN_PAR)
|
|
dVal = 0 ;
|
|
return m_pCurrMach->SetParam( nType, dVal) ;
|
|
}
|
|
// se sovramateriale
|
|
else if ( nType == MPA_OFFSR || nType == MPA_OFFSL) {
|
|
// recupero valore da utensile
|
|
const ToolData* pTdata ;
|
|
if ( ! m_pCurrMach->GetTool( m_pTsMgr, pTdata))
|
|
return false ;
|
|
// verifico se valore coincide con impostazione da utensile
|
|
double dTVal ;
|
|
if ( pTdata->GetParam( MPA2TPA( nType), dTVal) && abs( dVal - dTVal) < EPS_MACH_LEN_PAR)
|
|
dVal = UNKNOWN_PAR ;
|
|
return m_pCurrMach->SetParam( nType, dVal) ;
|
|
}
|
|
// se step su taglio con lama inclinato
|
|
else if ( nType == MPA_STEPSIDEANG) {
|
|
// recupero step generico
|
|
double dStep ;
|
|
if ( ! m_pCurrMach->GetParam( MPA_STEP, dStep))
|
|
return false ;
|
|
// verifico se valore coincide con questo
|
|
if ( abs( dVal - dStep) < EPS_MACH_LEN_PAR)
|
|
dVal = UNKNOWN_PAR ;
|
|
return m_pCurrMach->SetParam( nType, dVal) ;
|
|
}
|
|
// in generale
|
|
return m_pCurrMach->SetParam( nType, dVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetCurrMachiningParam( int nType, const std::string& sVal)
|
|
{
|
|
// deve esistere lavorazione corrente
|
|
if ( m_pCurrMach == nullptr)
|
|
return false ;
|
|
// non è possibile cambiare UUID e Tool UUID
|
|
if ( nType == MPA_UUID || nType == MPA_TUUID)
|
|
return false ;
|
|
// è possibile cambiare il nome, solo se il nuovo non è già presente nel DB (esclusa lavorazione corrente)
|
|
if ( nType == MPA_NAME) {
|
|
const MachiningData* pMch = GetMachining( sVal) ;
|
|
if ( pMch != nullptr && pMch->m_Uuid != m_pCurrMach->m_Uuid)
|
|
return false ;
|
|
}
|
|
// è possibile cambiare l'utensile, solo se esiste o è nullo
|
|
else if ( nType == MPA_TOOL) {
|
|
// se nome vuoto, voglio cancellare l'utensile
|
|
if ( sVal.empty())
|
|
return m_pCurrMach->ResetTool() ;
|
|
// verifico utensile e assegno
|
|
const ToolData* pTdata ;
|
|
if ( ! m_pCurrMach->VerifyTool( m_pTsMgr, sVal, pTdata))
|
|
return false ;
|
|
return ( m_pCurrMach->SetParam( MPA_TOOL, sVal) &&
|
|
m_pCurrMach->SetParam( MPA_TUUID, ::ToString( pTdata->m_Uuid))) ;
|
|
}
|
|
// eseguo
|
|
return m_pCurrMach->SetParam( nType, sVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::GetCurrMachiningParam( int nType, bool& bVal) const
|
|
{
|
|
return ( ( m_pCurrMach != nullptr) ? m_pCurrMach->GetParam( nType, bVal) : false) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::GetCurrMachiningParam( int nType, int& nVal) const
|
|
{
|
|
return ( ( m_pCurrMach != nullptr) ? m_pCurrMach->GetParam( nType, nVal) : false) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::GetCurrMachiningParam( int nType, double& dVal) const
|
|
{
|
|
// deve esistere lavorazione corrente
|
|
if ( m_pCurrMach == nullptr)
|
|
return false ;
|
|
// se speed o feed
|
|
if ( nType == MPA_SPEED ||
|
|
nType == MPA_FEED || nType == MPA_STARTFEED || nType == MPA_ENDFEED || nType == MPA_TIPFEED) {
|
|
// recupero il valore
|
|
if ( ! m_pCurrMach->GetParam( nType, dVal))
|
|
return false ;
|
|
// se valore autonomo
|
|
if ( abs( dVal) > EPS_ANG_SMALL)
|
|
return true ;
|
|
// devo recuperare valore da utensile
|
|
const ToolData* pTdata ;
|
|
if ( ! m_pCurrMach->GetTool( m_pTsMgr, pTdata))
|
|
return false ;
|
|
// recupero il corretto valore
|
|
return pTdata->GetParam( MPA2TPA( nType), dVal) ;
|
|
}
|
|
// se sovramateriale
|
|
else if ( nType == MPA_OFFSR || nType == MPA_OFFSL) {
|
|
// recupero il valore
|
|
if ( ! m_pCurrMach->GetParam( nType, dVal))
|
|
return false ;
|
|
// se valore autonomo
|
|
if ( abs( dVal - UNKNOWN_PAR) > EPS_ANG_SMALL)
|
|
return true ;
|
|
// devo recuperare valore da utensile
|
|
dVal = 0 ;
|
|
const ToolData* pTdata ;
|
|
if ( ! m_pCurrMach->GetTool( m_pTsMgr, pTdata))
|
|
return false ;
|
|
// recupero il corretto valore
|
|
return pTdata->GetParam( MPA2TPA( nType), dVal) ;
|
|
}
|
|
// se step su taglio con lama inclinato
|
|
else if ( nType == MPA_STEPSIDEANG) {
|
|
// recupero il valore
|
|
if ( ! m_pCurrMach->GetParam( nType, dVal))
|
|
return false ;
|
|
// se valore autonomo
|
|
if ( abs( dVal - UNKNOWN_PAR) > EPS_ANG_SMALL)
|
|
return true ;
|
|
// altrimenti step generico
|
|
return m_pCurrMach->GetParam( MPA_STEP, dVal) ;
|
|
}
|
|
// in generale
|
|
return m_pCurrMach->GetParam( nType, dVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::GetCurrMachiningParam( int nType, std::string& sVal) const
|
|
{
|
|
return ( ( m_pCurrMach != nullptr) ? m_pCurrMach->GetParam( nType, sVal) : false) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::Set3AxComp( bool b3AxComp)
|
|
{
|
|
// salvo e setto modifica
|
|
m_b3AxComp = b3AxComp ;
|
|
m_bModified = true ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::Set5AxComp( bool b5AxComp)
|
|
{
|
|
// salvo e setto modifica
|
|
m_b5AxComp = b5AxComp ;
|
|
m_bModified = true ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetSafeZ( double dSafeZ)
|
|
{
|
|
// deve essere un valore positivo o nullo
|
|
if ( dSafeZ < - EPS_SMALL)
|
|
return false ;
|
|
// se cambiato, salvo e setto modifica
|
|
if ( fabs( dSafeZ - m_dSafeZ) > EPS_SMALL) {
|
|
m_dSafeZ = dSafeZ ;
|
|
m_bModified = true ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetExtraLOnCutRegion( double dExtraL)
|
|
{
|
|
// deve essere un valore positivo o nullo
|
|
if ( dExtraL < - EPS_SMALL)
|
|
return false ;
|
|
// se cambiato, salvo e setto modifica
|
|
if ( fabs( dExtraL - m_dExtraLOnCutRegion) > EPS_SMALL) {
|
|
m_dExtraLOnCutRegion = dExtraL ;
|
|
m_bModified = true ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetExtraROnDrillRegion( double dExtraR)
|
|
{
|
|
// deve essere un valore positivo o nullo
|
|
if ( dExtraR < - EPS_SMALL)
|
|
return false ;
|
|
// se cambiato, salvo e setto modifica
|
|
if ( fabs( dExtraR - m_dExtraROnDrillRegion) > EPS_SMALL) {
|
|
m_dExtraROnDrillRegion = dExtraR ;
|
|
m_bModified = true ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetHoleDiamToler( double dToler)
|
|
{
|
|
// Tolleranza > 0 -> la punta può essere uguale, più piccola o più grande
|
|
// Tolleranza < 0 -> la punta può essere solo uguale o più piccola
|
|
// minimo valore assoluto EPS_SMALL
|
|
if ( abs( dToler) < EPS_SMALL)
|
|
dToler = EPS_SMALL ;
|
|
// se cambiato, salvo e setto modifica
|
|
if ( fabs( dToler - m_dHoleDiamToler) > EPS_SMALL) {
|
|
m_dHoleDiamToler = dToler ;
|
|
m_bModified = true ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetExtSawArcMinRad( double dRad)
|
|
{
|
|
// deve essere un valore positivo o nullo
|
|
if ( dRad < - EPS_SMALL)
|
|
return false ;
|
|
// se cambiato, salvo e setto modifica
|
|
if ( fabs( dRad - m_dExtSawArcMinRad) > EPS_SMALL) {
|
|
m_dExtSawArcMinRad = dRad ;
|
|
m_bModified = true ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachiningsMgr::SetSplitArcs( int nFlag)
|
|
{
|
|
if ( nFlag < SPLAR_NEVER || nFlag > SPLAR_ALWAYS)
|
|
return false ;
|
|
m_nSplitArcs = nFlag ;
|
|
return true ;
|
|
}
|