diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index c476428..5a9c2d4 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/EgtMachKernel.vcxproj b/EgtMachKernel.vcxproj
index 1fcec9e..11fa86c 100644
--- a/EgtMachKernel.vcxproj
+++ b/EgtMachKernel.vcxproj
@@ -237,6 +237,8 @@ copy $(TargetPath) \EgtProg\Dll64
+
+
@@ -397,6 +399,8 @@ copy $(TargetPath) \EgtProg\Dll64
+
+
diff --git a/EgtMachKernel.vcxproj.filters b/EgtMachKernel.vcxproj.filters
index 93369db..f96cb44 100644
--- a/EgtMachKernel.vcxproj.filters
+++ b/EgtMachKernel.vcxproj.filters
@@ -234,6 +234,12 @@
Source Files\Machine
+
+ Source Files\Machinings
+
+
+ Source Files\Operations
+
@@ -668,6 +674,12 @@
Header Files\Include
+
+ Header Files
+
+
+ Header Files
+
diff --git a/FiveAxisMilling.cpp b/FiveAxisMilling.cpp
new file mode 100644
index 0000000..5c70a0d
--- /dev/null
+++ b/FiveAxisMilling.cpp
@@ -0,0 +1,977 @@
+//----------------------------------------------------------------------------
+// EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : FiveAxisMilling.cpp Data : 22.05.24 Versione : 2.6e5
+// Contenuto : Implementazione gestione lavorazione 5 assi.
+//
+//
+//
+// Modifiche : 22.05.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "MachMgr.h"
+#include "DllMain.h"
+#include "FiveAxisMilling.h"
+#include "OperationConst.h"
+#include "/EgtDev/Include/EGkCurveLine.h"
+#include "/EgtDev/Include/EGkCurveArc.h"
+#include "/EgtDev/Include/EGkCurveComposite.h"
+#include "/EgtDev/Include/EGkArcSpecial.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
+#include "/EgtDev/Include/EGkUserObjFactory.h"
+#include "/EgtDev/Include/EGnStringKeyVal.h"
+#include "/EgtDev/Include/EgtPointerOwner.h"
+#include "/EgtDev/Include/EgtIniFile.h"
+
+using namespace std ;
+
+//------------------------------ Errors --------------------------------------
+// 2801 = "Error in FiveAxisMilling : UpdateToolData failed"
+// 2802 = "Error in FiveAxisMilling : missing Script (xxx)"
+// 2803 = "Error in FiveAxisMilling : Error in xxx (nnn)"
+// 2804 = "Error in FiveAxisMilling : axes values not calculable"
+// 2805 = "Error in FiveAxisMilling : outstroke xx"
+// 2806 = "Error in FiveAxisMilling : link movements not calculable"
+// 2807 = "Error in FiveAxisMilling : link outstroke xx"
+// 2808 = "Error in FiveAxisMilling : post apply not calculable"
+// 2809 = "Error in FiveAxisMilling : Tool loading failed"
+// 2851 = "Warning in FiveAxisMilling : Skipped entity (xx)"
+// 2852 = "Warning in FiveAxisMilling : No machinable path"
+// 2853 = "Warning in FiveAxisMilling : Tool name changed (xx)"
+// 2854 = "Warning in FiveAxisMilling : Tool data changed (xx)"
+
+//------------------------------ Constants -----------------------------------
+static const string EMC_VAR = "EMC" ; // tabella variabili locali per calcolo
+static const string EVAR_MACHID = ".MACHID" ; // IN (int) identificativo della lavorazione
+static const string EVAR_GEOM = ".GEOM" ; // IN (table) tabella delle entità da lavorare
+static const string EVAR_DEPTH = ".DEPTH" ; // IN (string) affondamento (espressione numerica)
+static const string EVAR_TINVERT = ".TOOLINVERT" ; // IN (bool) flag di inversione direzione utensile
+static const string EVAR_INVERT = ".INVERT" ; // IN (bool) flag di inversione direzione lavorazione
+static const string EVAR_STARTPOS = ".STARTPOS" ; // IN (num) quota di inizio lavorazione (sempre >= 0)
+static const string EVAR_OFFSR = ".OFFSR" ; // IN (num) offset radiale
+static const string EVAR_OFFSL = ".OFFSL" ; // IN (num) offset longitudinale
+static const string EVAR_SYSNOTES = ".SYSNOTES" ; // IN (string) note interne
+static const string EVAR_USERNOTES = ".USERNOTES" ;// IN (string) note dell'utente
+static const string EVAR_TOOL = ".TOOL" ; // IN (string) nome dell'utensile
+static const string EVAR_HEAD = ".HEAD" ; // IN (string) nome testa
+static const string EVAR_EXIT = ".EXIT" ; // IN (int) indice uscita
+static const string EVAR_TTYPE = ".TTYPE" ; // IN (int) tipo utensile
+static const string EVAR_TMAXMAT = ".TMAXMAT" ; // IN (num) massimo materiale
+static const string EVAR_TDIAM = ".TDIAM" ; // IN (num) diametro utensile
+static const string EVAR_TTOTDIAM = ".TTOTDIAM" ; // IN (num) diametro totale utensile
+static const string EVAR_TLEN = ".TLEN" ; // IN (num) lunghezza utensile
+static const string EVAR_TTOTLEN = ".TTOTLEN" ; // IN (num) lunghezza totale utensile
+static const string EVAR_TTHICK = ".THICK" ; // IN (num) spessore per lame o altezza taglienti
+static const string EVAR_TCORNRAD = ".TCORNRAD" ; // IN (num) raggio corner
+static const string EVAR_TSIDEANG = ".TSIDEANG" ; // IN (num) angolo del fianco rispetto all'asse
+static const string EVAR_FEED = ".FEED" ; // IN (num) feed dell'utensile
+static const string EVAR_STARTFEED = ".STARTFEED" ;// IN (num) feed di inizio dell'utensile
+static const string EVAR_ENDFEED = ".ENDFEED" ; // IN (num) feed di fine dell'utensile
+static const string EVAR_TIPFEED = ".TIPFEED" ; // IN (num) feed di punta dell'utensile
+static const string EVAR_ISROBOT = ".ISROBOT" ; // IN (bool) flag per indicare che la cinematica è di tipo robot
+static const string EVAR_ERROR = ".ERR" ; // OUT (int) codice di errore ( 0 = ok)
+static const string EVAR_MILLS = ".MILLS" ; // OUT (int) numero di percorsi di lavoro
+static const string ON_PREVIEW = "OnPreview_" ;
+static const string ON_APPLY = "OnApply_" ;
+
+//----------------------------------------------------------------------------
+USEROBJ_REGISTER( GetOperationClass( OPER_FIVEAXISMILLING), FiveAxisMilling) ;
+
+//----------------------------------------------------------------------------
+const string&
+FiveAxisMilling::GetClassName( void) const
+{
+ return USEROBJ_GETNAME( FiveAxisMilling) ;
+}
+
+//----------------------------------------------------------------------------
+FiveAxisMilling*
+FiveAxisMilling::Clone( void) const
+{
+ // alloco oggetto
+ FiveAxisMilling* pGenM = new(nothrow) FiveAxisMilling ;
+ // eseguo copia dei dati
+ if ( pGenM != nullptr) {
+ try {
+ pGenM->m_vId = m_vId ;
+ pGenM->m_pMchMgr = m_pMchMgr ;
+ pGenM->m_nPhase = m_nPhase ;
+ pGenM->m_Params = m_Params ;
+ pGenM->m_TParams = m_TParams ;
+ pGenM->m_nStatus = m_nStatus ;
+ pGenM->m_nMills = m_nMills ;
+ }
+ catch( ...) {
+ delete pGenM ;
+ return nullptr ;
+ }
+ }
+ // ritorno l'oggetto
+ return pGenM ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::Dump( string& sOut, bool bMM, const char* szNewLine) const
+{
+ sOut += GetClassName() + "[mm]" + szNewLine ;
+ sOut += KEY_PHASE + EQUAL + ToString( m_nPhase) + szNewLine ;
+ sOut += KEY_IDS + EQUAL + ToString( m_vId) + szNewLine ;
+ for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
+ sOut += m_Params.ToString( i) + szNewLine ;
+ for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
+ sOut += m_TParams.ToString( i) + szNewLine ;
+ sOut += KEY_NUM + EQUAL + ToString( m_nMills) + szNewLine ;
+ sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ;
+
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::Save( int nBaseId, STRVECTOR& vString) const
+{
+ try {
+ int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 3 ;
+ vString.insert( vString.begin(), nSize, "") ;
+ int k = - 1 ;
+ if ( ! SetVal( KEY_IDS, m_vId, vString[++k]))
+ return false ;
+ for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
+ vString[++k] = m_Params.ToString( i) ;
+ for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
+ vString[++k] = m_TParams.ToString( i) ;
+ if ( ! SetVal( KEY_PHASE, m_nPhase, vString[++k]))
+ return false ;
+ if ( ! SetVal( KEY_NUM, m_nMills, vString[++k]))
+ return false ;
+ if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k]))
+ return false ;
+ }
+ catch( ...) {
+ return false ;
+ }
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::Load( const STRVECTOR& vString, int nBaseGdbId)
+{
+ int nSize = int( vString.size()) ;
+ // lista identificativi geometrie da lavorare
+ int k = - 1 ;
+ if ( k >= nSize - 1 || ! GetVal( vString[++k], KEY_IDS, m_vId))
+ return false ;
+ for ( auto& Sel : m_vId)
+ Sel.nId += nBaseGdbId ;
+ // parametri lavorazione
+ for ( int i = 0 ; i < m_Params.GetSize() ; ++ i) {
+ int nKey ;
+ if ( k >= nSize - 1 || ! m_Params.FromString( vString[++k], nKey) || nKey != i) {
+ if ( m_Params.IsOptional( i))
+ -- k ;
+ else
+ return false ;
+ }
+ }
+ // parametri utensile
+ for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) {
+ int nKey ;
+ if ( k >= nSize - 1 || ! m_TParams.FromString( vString[++k], nKey) || nKey != i)
+ return false ;
+ }
+ // parametri di stato
+ while ( k < nSize - 1) {
+ // separo chiave da valore
+ string sKey, sVal ;
+ SplitFirst( vString[++k], "=", sKey, sVal) ;
+ // leggo
+ if ( sKey == KEY_PHASE) {
+ if ( ! FromString( sVal, m_nPhase))
+ return false ;
+ }
+ else if ( sKey == KEY_NUM) {
+ if ( ! FromString( sVal, m_nMills))
+ return false ;
+ }
+ else if ( sKey == KEY_STAT) {
+ if ( ! FromString( sVal, m_nStatus))
+ return false ;
+ }
+ }
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+FiveAxisMilling::FiveAxisMilling( void)
+{
+ m_Params.m_sName = "*" ;
+ m_Params.m_sToolName = "*" ;
+ m_TParams.m_sName = "*" ;
+ m_TParams.m_sHead = "*" ;
+ m_nStatus = MCH_ST_TO_VERIFY ;
+ m_nMills = 0 ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::Prepare( const string& sGenMchName)
+{
+ // verifico il gestore lavorazioni
+ if ( m_pMchMgr == nullptr)
+ return false ;
+ // recupero il gestore DB utensili della macchina corrente
+ ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
+ if ( pTMgr == nullptr)
+ return false ;
+ // recupero il gestore DB lavorazioni della macchina corrente
+ MachiningsMgr* pMMgr = m_pMchMgr->GetCurrMachiningsMgr() ;
+ if ( pMMgr == nullptr)
+ return false ;
+ // ricerca della lavorazione di libreria con il nome indicato
+ const FiveAxisMillingData* pDdata = GetFiveAxisMillingData( pMMgr->GetMachining( sGenMchName)) ;
+ if ( pDdata == nullptr)
+ return false ;
+ m_Params = *pDdata ;
+ // ricerca dell'utensile usato dalla lavorazione
+ const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
+ if ( pTdata == nullptr)
+ return false ;
+ m_TParams = *pTdata ;
+ m_Params.m_sToolName = m_TParams.m_sName ;
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::SetParam( int nType, bool bVal)
+{
+ switch ( nType) {
+ case MPA_INVERT :
+ if ( bVal != m_Params.m_bInvert)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_bInvert = bVal ;
+ return true ;
+ case MPA_TOOLINVERT :
+ if ( bVal != m_Params.m_bToolInvert)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_bToolInvert = bVal ;
+ return true ;
+ }
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::SetParam( int nType, int nVal)
+{
+ switch ( nType) {
+ case MPA_SCC :
+ if ( ! m_Params.VerifySolCh( nVal))
+ return false ;
+ if ( nVal != m_Params.m_nSolCh)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_nSolCh = nVal ;
+ return true ;
+ case MPA_SUBTYPE :
+ if ( nVal != m_Params.m_nSubType)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_nSubType = nVal ;
+ return true ;
+ }
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::SetParam( int nType, double dVal)
+{
+ switch ( nType) {
+ case MPA_SPEED :
+ if ( ! m_TParams.VerifySpeed( dVal))
+ return false ;
+ if ( abs( m_TParams.m_dSpeed - dVal) < EPS_MACH_ANG_PAR)
+ dVal = 0 ;
+ if ( abs( dVal - m_Params.m_dSpeed) > EPS_MACH_ANG_PAR)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_dSpeed = dVal ;
+ return true ;
+ case MPA_FEED :
+ if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR)
+ dVal = 0 ;
+ if ( abs( dVal - m_Params.m_dFeed) > EPS_MACH_LEN_PAR)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_dFeed = dVal ;
+ return true ;
+ case MPA_STARTFEED :
+ if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
+ dVal = 0 ;
+ if ( abs( dVal - m_Params.m_dStartFeed) > EPS_MACH_LEN_PAR)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_dStartFeed = dVal ;
+ return true ;
+ case MPA_ENDFEED :
+ if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
+ dVal = 0 ;
+ if ( abs( dVal - m_Params.m_dEndFeed) > EPS_MACH_LEN_PAR)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_dEndFeed = dVal ;
+ return true ;
+ case MPA_TIPFEED :
+ if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
+ dVal = 0 ;
+ if ( abs( dVal - m_Params.m_dTipFeed) > EPS_MACH_LEN_PAR)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_dTipFeed = dVal ;
+ return true ;
+ case MPA_OFFSR :
+ if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR)
+ dVal = UNKNOWN_PAR ;
+ if ( abs( dVal - m_Params.m_dOffsR) > EPS_MACH_LEN_PAR)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_dOffsR = dVal ;
+ return true ;
+ case MPA_OFFSL :
+ if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
+ dVal = UNKNOWN_PAR ;
+ if ( abs( dVal - m_Params.m_dOffsL) > EPS_MACH_LEN_PAR)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_dOffsL = dVal ;
+ return true ;
+ case MPA_DEPTH: {
+ string sVal = ToString( dVal) ;
+ if ( sVal != m_Params.m_sDepth)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_sDepth = sVal ;
+ } return true ;
+ case MPA_STARTPOS :
+ if ( abs( dVal - m_Params.m_dStartPos) > EPS_MACH_LEN_PAR)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_dStartPos = dVal ;
+ return true ;
+ }
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::SetParam( int nType, const string& sVal)
+{
+ switch ( nType) {
+ case MPA_TOOL : {
+ const ToolData* pTdata ;
+ if ( ! m_Params.VerifyTool( m_pMchMgr->GetCurrToolsMgr(), sVal, pTdata))
+ return false ;
+ if ( ! SameTool( m_TParams, *pTdata))
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_sToolName = sVal ;
+ m_Params.m_ToolUuid = pTdata->m_Uuid ;
+ m_TParams = *pTdata ;
+ } return true ;
+ case MPA_DEPTH_STR :
+ if ( sVal != m_Params.m_sDepth)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_sDepth = sVal ;
+ return true ;
+ case MPA_SYSNOTES :
+ if ( sVal != m_Params.m_sSysNotes)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_sSysNotes = sVal ;
+ return true ;
+ case MPA_USERNOTES :
+ if ( sVal != m_Params.m_sUserNotes)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_sUserNotes = sVal ;
+ return true ;
+ case MPA_INITANGS :
+ if ( sVal != m_Params.m_sInitAngs)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_sInitAngs = sVal ;
+ return true ;
+ case MPA_BLOCKEDAXIS :
+ if ( sVal != m_Params.m_sBlockedAxis)
+ m_nStatus |= MCH_ST_PARAM_MODIF ;
+ m_Params.m_sBlockedAxis = sVal ;
+ return true ;
+ }
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::SetGeometry( const SELVECTOR& vIds)
+{
+ // verifico validità gestore DB geometrico
+ if ( m_pGeomDB == nullptr)
+ return false ;
+ // reset della geometria corrente
+ m_vId.clear() ;
+ // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve o tutte facce)
+ int nType = GEO_NONE ;
+ for ( const auto& Id : vIds) {
+ // test sull'entità
+ int nSubs ;
+ if ( ! VerifyGeometry( Id, nSubs, nType)) {
+ string sInfo = "Warning in FiveAxisMilling : Skipped entity " + ToString( Id) ;
+ m_pMchMgr->SetWarning( 2851, sInfo) ;
+ continue ;
+ }
+ // posso aggiungere alla lista
+ m_vId.emplace_back( Id) ;
+ }
+ // aggiorno lo stato
+ m_nStatus |= MCH_ST_GEO_MODIF ;
+ // restituisco presenza geometria da lavorare
+ return ( ! m_vId.empty() || vIds.empty()) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::Preview( bool bRecalc)
+{
+ // reset numero percorsi di lavoro generati
+ m_nMills = 0 ;
+
+ // verifico validità gestore DB geometrico e Id del gruppo
+ if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
+ return false ;
+
+ // aggiorno dati geometrici dell'utensile
+ if ( ! UpdateToolData()) {
+ m_pMchMgr->SetLastError( 2801, "Error in FiveAxisMilling : UpdateToolData failed") ;
+ return false ;
+ }
+
+ // rendo corrente l'utensile usato nella lavorazione
+ if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) {
+ m_pMchMgr->SetLastError( 2809, "Error in FiveAxisMilling : Tool loading failed") ;
+ return false ;
+ }
+
+ // recupero gruppo per geometria di Preview
+ int nPvId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_PV) ;
+ // se non c'è, lo aggiungo
+ if ( nPvId == GDB_ID_NULL) {
+ nPvId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
+ if ( nPvId == GDB_ID_NULL)
+ return false ;
+ m_pGeomDB->SetName( nPvId, MCH_PV) ;
+ }
+ // altrimenti lo svuoto
+ else
+ m_pGeomDB->EmptyGroup( nPvId) ;
+
+ // recupero la macchina corrente
+ Machine* pMch = m_pMchMgr->GetCurrMachine() ;
+ if ( pMch == nullptr)
+ return false ;
+
+ // nome della funzione lua da Ini della macchina
+ string sMachIni = pMch->GetMachineDir() + "\\" + pMch->GetMachineName() + ".ini" ;
+ string sKey = FIVEAXISMILLING_SCRIPT_KEY + ToString( m_Params.m_nSubType) ;
+ string sName = GetPrivateProfileStringUtf8( FIVEAXISMILLING_SEC.c_str(), sKey.c_str(), "", sMachIni.c_str()) ;
+ string sPreview = ON_PREVIEW + sName ;
+
+ // verifico esistenza funzione
+ if ( ! pMch->LuaExistsFunction( sPreview)) {
+ string sErr = "Error in FiveAxisMilling : missing Script " + sPreview ;
+ m_pMchMgr->SetLastError( 2802, sErr) ;
+ return false ;
+ }
+
+ // imposto stato
+ bool bOk = true ;
+ int nErr = 99 ;
+ // imposto valori parametri
+ bOk = bOk && pMch->LuaCreateGlobTable( EMC_VAR) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_MACHID, m_nOwnerId) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_GEOM, m_vId) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_DEPTH, m_Params.m_sDepth) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TINVERT, m_Params.m_bToolInvert) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_INVERT, m_Params.m_bInvert) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTPOS, m_Params.m_dStartPos) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSR, GetOffsR()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSL, GetOffsL()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_SYSNOTES, m_Params.m_sSysNotes) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_USERNOTES, m_Params.m_sUserNotes) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TOOL, m_TParams.m_sName) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_HEAD, m_TParams.m_sHead) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_EXIT, m_TParams.m_nExit) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTYPE, m_TParams.m_nType) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TMAXMAT, m_TParams.m_dMaxMat) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TDIAM, m_TParams.m_dDiam) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTDIAM, m_TParams.m_dTDiam) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TLEN, m_TParams.m_dLen) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTLEN, m_TParams.m_dTLen) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTHICK, m_TParams.m_dThick) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TCORNRAD, m_TParams.m_dCornRad) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TSIDEANG, m_TParams.m_dSideAng) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_FEED, GetFeed()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTFEED, GetStartFeed()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ENDFEED, GetEndFeed()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TIPFEED, GetTipFeed()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ISROBOT, m_pMchMgr->GetCurrIsRobot()) ;
+ // eseguo
+ bOk = bOk && pMch->LuaCallFunction( sPreview, false) ;
+ // recupero valori parametri obbligatori
+ bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
+ bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MILLS, m_nMills) ;
+ // reset
+ bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
+ // segnalo errori
+ if ( ! bOk || nErr != 0) {
+ m_nMills = 0 ;
+ string sErr = "Error in FiveAxisMilling : Error in " + sPreview + " (" + ToString( nErr) + ")" ;
+ m_pMchMgr->SetLastError( 2803, sErr) ;
+ return false ;
+ }
+
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::Apply( bool bRecalc, bool bPostApply)
+{
+ // reset numero percorsi di lavoro generati
+ int nCurrMills = m_nMills ;
+ m_nMills = 0 ;
+
+ // verifico validità gestore DB geometrico e Id del gruppo
+ if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
+ return false ;
+
+ // aggiorno dati geometrici dell'utensile
+ bool bToolChanged = true ;
+ if ( ! UpdateToolData( &bToolChanged)) {
+ m_pMchMgr->SetLastError( 2801, "Error in FiveAxisMilling : UpdateToolData failed") ;
+ return false ;
+ }
+
+ // verifico se necessario continuare nell'aggiornamento
+ if ( ! bRecalc && ! bToolChanged &&
+ ( m_nStatus == MCH_ST_OK || ( ! bPostApply && m_nStatus == MCH_ST_NO_POSTAPPL))) {
+ // confermo i percorsi di lavorazione
+ m_nMills = nCurrMills ;
+ LOG_DBG_INFO( GetEMkLogger(), "FiveAxisMilling apply skipped : status already ok") ;
+ // eseguo aggiornamento assi macchina e collegamento con operazione precedente
+ if ( ! Update( bPostApply))
+ return false ;
+ LOG_DBG_INFO( GetEMkLogger(), "Update done") ;
+ // esco con successo
+ return true ;
+ }
+ m_nStatus = MCH_ST_TO_VERIFY ;
+
+ // rendo corrente l'utensile usato nella lavorazione
+ if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) {
+ m_pMchMgr->SetLastError( 2809, "Error in FiveAxisMilling : Tool loading failed") ;
+ return false ;
+ }
+
+ // recupero gruppo per geometria di lavorazione (Cutter Location)
+ int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ;
+ // se non c'è, lo aggiungo
+ if ( nClId == GDB_ID_NULL) {
+ nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
+ if ( nClId == GDB_ID_NULL)
+ return false ;
+ m_pGeomDB->SetName( nClId, MCH_CL) ;
+ }
+ // altrimenti lo svuoto
+ else
+ m_pGeomDB->EmptyGroup( nClId) ;
+
+ // recupero la macchina corrente
+ Machine* pMch = m_pMchMgr->GetCurrMachine() ;
+ if ( pMch == nullptr)
+ return false ;
+
+ // nome della funzione lua da Ini della macchina
+ string sMachIni = pMch->GetMachineDir() + "\\" + pMch->GetMachineName() + ".ini" ;
+ string sKey = FIVEAXISMILLING_SCRIPT_KEY + ToString( m_Params.m_nSubType) ;
+ string sName = GetPrivateProfileStringUtf8( FIVEAXISMILLING_SEC.c_str(), sKey.c_str(), "", sMachIni.c_str()) ;
+ string sApply = ON_APPLY + sName ;
+
+ // verifico esistenza funzione
+ if ( ! pMch->LuaExistsFunction( sApply)) {
+ string sErr = "Error in FiveAxisMilling : missing Script " + sApply ;
+ m_pMchMgr->SetLastError( 2802, sErr) ;
+ return false ;
+ }
+
+ // imposto stato
+ bool bOk = true ;
+ int nErr = 99 ;
+ // imposto valori parametri
+ bOk = bOk && pMch->LuaCreateGlobTable( EMC_VAR) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_MACHID, m_nOwnerId) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_GEOM, m_vId) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_DEPTH, m_Params.m_sDepth) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TINVERT, m_Params.m_bToolInvert) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_INVERT, m_Params.m_bInvert) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTPOS, m_Params.m_dStartPos) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSR, GetOffsR()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSL, GetOffsL()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_SYSNOTES, m_Params.m_sSysNotes) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_USERNOTES, m_Params.m_sUserNotes) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TOOL, m_TParams.m_sName) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_HEAD, m_TParams.m_sHead) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_EXIT, m_TParams.m_nExit) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTYPE, m_TParams.m_nType) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TMAXMAT, m_TParams.m_dMaxMat) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TDIAM, m_TParams.m_dDiam) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTDIAM, m_TParams.m_dTDiam) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TLEN, m_TParams.m_dLen) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTLEN, m_TParams.m_dTLen) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTHICK, m_TParams.m_dThick) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TCORNRAD, m_TParams.m_dCornRad) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TSIDEANG, m_TParams.m_dSideAng) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_FEED, GetFeed()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTFEED, GetStartFeed()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ENDFEED, GetEndFeed()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TIPFEED, GetTipFeed()) ;
+ bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ISROBOT, m_pMchMgr->GetCurrIsRobot()) ;
+ // eseguo
+ bOk = bOk && pMch->LuaCallFunction( sApply, false) ;
+ // recupero valori parametri obbligatori
+ bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
+ bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MILLS, m_nMills) ;
+ // reset
+ bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
+ // segnalo errori
+ if ( ! bOk || nErr != 0) {
+ m_nMills = 0 ;
+ string sErr = "Error in FiveAxisMilling : Error in " + sApply + " (" + ToString( nErr) + ")" ;
+ m_pMchMgr->SetLastError( 2803, sErr) ;
+ return false ;
+ }
+
+ // assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+ CalcAndSetBBox( nClId) ;
+
+ // eseguo aggiornamento assi macchina e collegamento con operazione precedente
+ if ( ! Update( bPostApply))
+ return false ;
+
+ // aggiorno stato della lavorazione
+ m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
+ // dichiaro successiva da aggiornare
+ UpdateFollowingOperationsStatus( MCH_ST_OTH_MODIF) ;
+
+ LOG_DBG_INFO( GetEMkLogger(), "FiveAxisMilling apply done") ;
+
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::Update( bool bPostApply)
+{
+ // verifico validità gestore DB geometrico e Id del gruppo
+ if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
+ return false ;
+
+ // se lavorazione vuota, esco
+ if ( m_nMills == 0) {
+ m_pMchMgr->SetWarning( 2852, "Warning in FiveAxisMilling : No machinable path") ;
+ return true ;
+ }
+
+ // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo)
+ RemoveClimbRiseHome() ;
+
+ // imposto eventuale asse bloccato da lavorazione
+ SetBlockedRotAxis( m_Params.m_sBlockedAxis) ;
+
+ // calcolo gli assi macchina
+ string sHint = ExtractHint( m_Params.m_sUserNotes) ;
+ if ( ! m_Params.m_sInitAngs.empty())
+ sHint = m_Params.m_sInitAngs ;
+ if ( ! CalculateAxesValues( sHint)) {
+ string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
+ if ( sInfo.empty())
+ m_pMchMgr->SetLastError( 2804, "Error in FiveAxisMilling : axes values not calculable") ;
+ else
+ m_pMchMgr->SetLastError( 2805, "Error in FiveAxisMilling : outstroke ") ;
+ return false ;
+ }
+
+ // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
+ bool bVpl ;
+ if ( ! FromString( ExtractInfo( m_Params.m_sUserNotes, "Vpl:"), bVpl))
+ bVpl = true ;
+ if ( ! AdjustStartEndMovements( bVpl)) {
+ string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
+ if ( sInfo.empty())
+ m_pMchMgr->SetLastError( 2806, "Error in FiveAxisMilling : link movements not calculable") ;
+ else
+ m_pMchMgr->SetLastError( 2807, "Error in FiveAxisMilling : link outstroke ") ;
+ return false ;
+ }
+
+ // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+ CalcAndSetAxesBBox() ;
+
+ // esecuzione eventuali personalizzazioni
+ string sErr ;
+ if ( bPostApply && ! PostApply( sErr)) {
+ if ( ! IsEmptyOrSpaces( sErr))
+ m_pMchMgr->SetLastError( 2808, sErr) ;
+ else
+ m_pMchMgr->SetLastError( 2808, "Error in FiveAxisMilling : post apply not calculable") ;
+ return false ;
+ }
+
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::GetParam( int nType, bool& bVal) const
+{
+ switch ( nType) {
+ case MPA_INVERT :
+ bVal = m_Params.m_bInvert ;
+ return true ;
+ case MPA_TOOLINVERT :
+ bVal = m_Params.m_bToolInvert ;
+ return true ;
+ }
+ bVal = false ;
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::GetParam( int nType, int& nVal) const
+{
+ switch ( nType) {
+ case MPA_TYPE :
+ nVal = MT_GENMACHINING ;
+ return true ;
+ case MPA_SCC :
+ nVal = m_Params.m_nSolCh ;
+ return true ;
+ case MPA_SUBTYPE :
+ nVal = m_Params.m_nSubType ;
+ return true ;
+ }
+ nVal = 0 ;
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::GetParam( int nType, double& dVal) const
+{
+ switch ( nType) {
+ case MPA_SPEED :
+ dVal = GetSpeed() ;
+ return true ;
+ case MPA_FEED :
+ dVal = GetFeed() ;
+ return true ;
+ case MPA_STARTFEED :
+ dVal = GetStartFeed() ;
+ return true ;
+ case MPA_ENDFEED :
+ dVal = GetEndFeed() ;
+ return true ;
+ case MPA_TIPFEED :
+ dVal = GetTipFeed() ;
+ return true ;
+ case MPA_OFFSR :
+ dVal = GetOffsR() ;
+ return true ;
+ case MPA_OFFSL :
+ dVal = GetOffsL() ;
+ return true ;
+ case MPA_STARTPOS :
+ dVal = m_Params.m_dStartPos ;
+ return true ;
+ }
+ dVal = 0 ;
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::GetParam( int nType, string& sVal) const
+{
+ switch ( nType) {
+ case MPA_NAME :
+ sVal = m_Params.m_sName ;
+ return true ;
+ case MPA_TOOL :
+ sVal = m_Params.m_sToolName ;
+ return true ;
+ case MPA_DEPTH_STR :
+ sVal = m_Params.m_sDepth ;
+ return true ;
+ case MPA_TUUID :
+ sVal = ToString( m_Params.m_ToolUuid) ;
+ return true ;
+ case MPA_UUID :
+ sVal = ToString( m_Params.m_Uuid) ;
+ return true ;
+ case MPA_SYSNOTES :
+ sVal = m_Params.m_sSysNotes ;
+ return true ;
+ case MPA_USERNOTES :
+ sVal = m_Params.m_sUserNotes ;
+ return true ;
+ case MPA_INITANGS :
+ sVal = m_Params.m_sInitAngs ;
+ return true ;
+ case MPA_BLOCKEDAXIS :
+ sVal = m_Params.m_sBlockedAxis ;
+ return true ;
+ }
+ sVal = "" ;
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+const ToolData&
+FiveAxisMilling::GetToolData( void) const
+{
+ return m_TParams ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::UpdateToolData( bool* pbChanged)
+{
+ // recupero il gestore DB utensili della macchina corrente
+ ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
+ if ( pTMgr == nullptr)
+ return false ;
+ // recupero l'utensile nel DB utensili
+ const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
+ if ( pTdata == nullptr)
+ return false ;
+ // salvo posizione TC, testa e uscita originali
+ string sOrigTcPos = m_TParams.m_sTcPos ;
+ string sOrigHead = m_TParams.m_sHead ;
+ int nOrigExit = m_TParams.m_nExit ;
+ // verifico se sono diversi (ad esclusione di nome, posizione TC, testa e uscita)
+ bool bChanged = ( ! SameTool( m_TParams, *pTdata, false)) ;
+ // aggiorno comunque i parametri
+ m_TParams = *pTdata ;
+ // se definito attrezzaggio, aggiorno i parametri che ne possono derivare
+ string sTcPos ; string sHead ; int nExit ;
+ if ( m_pMchMgr->GetCurrSetupMgr().GetToolData( m_TParams.m_sName, sTcPos, sHead, nExit)) {
+ if ( sOrigTcPos != sTcPos ||
+ sOrigHead != sHead ||
+ nOrigExit != nExit)
+ bChanged = true ;
+ m_TParams.m_sTcPos = sTcPos ;
+ m_TParams.m_sHead = sHead ;
+ m_TParams.m_nExit = nExit ;
+ }
+ else {
+ if ( sOrigTcPos != pTdata->m_sTcPos ||
+ sOrigHead != pTdata->m_sHead ||
+ nOrigExit != pTdata->m_nExit)
+ bChanged = true ;
+ }
+ // eventuali segnalazioni
+ if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) {
+ string sInfo = "Warning in FiveAxisMilling : tool name changed (" +
+ m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
+ m_pMchMgr->SetWarning( 2853, sInfo) ;
+ m_Params.m_sToolName = m_TParams.m_sName ;
+ }
+ if ( bChanged) {
+ string sInfo = "Warning in FiveAxisMilling : tool data changed (" +
+ m_Params.m_sToolName + ")" ;
+ m_pMchMgr->SetWarning( 2854, sInfo) ;
+ }
+ // se definito parametro di ritorno, lo assegno
+ if ( pbChanged != nullptr)
+ *pbChanged = bChanged ;
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::GetGeometry( SELVECTOR& vIds) const
+{
+ // restituisco l'elenco delle entità
+ vIds = m_vId ;
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMilling::VerifyGeometry( SelData Id, int& nSubs, int& nType)
+{
+ // ammessi : tutte curve o tutte facce di trimesh
+ const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
+ if ( pGObj == nullptr)
+ return false ;
+ // se ammesse curve ed è tale
+ if ( nType != GEO_SURF && ( pGObj->GetType() & GEO_CURVE) != 0) {
+ const ICurve* pCurve = nullptr ;
+ // se direttamente la curva
+ if ( Id.nSub == SEL_SUB_ALL) {
+ pCurve = ::GetCurve( pGObj) ;
+ if ( pCurve != nullptr) {
+ if ( pCurve->GetType() == CRV_COMPO)
+ nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
+ else
+ nSubs = 0 ;
+ }
+ }
+ // altrimenti sottocurva di composita
+ else {
+ const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
+ if ( pCompo != nullptr)
+ pCurve = pCompo->GetCurve( Id.nSub) ;
+ nSubs = 0 ;
+ }
+ return ( pCurve != nullptr) ;
+ }
+ // se altrimenti ammesse superfici trimesh ed è tale
+ else if ( nType != GEO_CURVE && ( pGObj->GetType() & GEO_SURF) != 0) {
+ const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
+ if ( pSurf == nullptr)
+ return false ;
+ // se direttamente la superficie
+ if ( Id.nSub == SEL_SUB_ALL) {
+ nSubs = pSurf->GetFacetCount() ;
+ return true ;
+ }
+ // altrimenti faccia di superficie trimesh
+ else {
+ // se faccia non esistente
+ if ( Id.nSub > pSurf->GetFacetCount())
+ return false ;
+ // tutto bene
+ nSubs = 0 ;
+ return true ;
+ }
+ }
+ // altrimenti errore
+ else
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+double
+FiveAxisMilling::GetApproxLinTol( void) const
+{
+ double dLinTol ;
+ if ( GetValInNotes( m_Params.m_sUserNotes, "LinTol", dLinTol))
+ return dLinTol ;
+ else
+ return Operation::GetApproxLinTol() ;
+}
diff --git a/FiveAxisMilling.h b/FiveAxisMilling.h
new file mode 100644
index 0000000..ef3058e
--- /dev/null
+++ b/FiveAxisMilling.h
@@ -0,0 +1,94 @@
+//----------------------------------------------------------------------------
+// EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : FiveAxisMilling.h Data : 22.05.24 Versione : 2.6e5
+// Contenuto : Dichiarazione della classe FiveAxisMilling.
+//
+//
+//
+// Modifiche : 22.05.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "Machining.h"
+#include "FiveAxisMillingData.h"
+#include "ToolData.h"
+
+class ICurve ;
+class ICurveComposite ;
+
+//----------------------------------------------------------------------------
+class FiveAxisMilling : public Machining
+{
+ public : // IUserObj
+ FiveAxisMilling* Clone( void) const override ;
+ const std::string& GetClassName( void) const override ;
+ bool Dump( std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const override ;
+ bool ToSave( void) const override
+ { return true ; }
+ bool Save( int nBaseId, STRVECTOR& vString) const override ;
+ bool Load( const STRVECTOR& vString, int nBaseGdbId) override ;
+
+ public : // Operation
+ int GetType( void) const override
+ { return OPER_FIVEAXISMILLING ; }
+ bool IsEmpty( void) const override
+ { return ( m_nMills == 0) ; }
+ bool UpdateStatus( int nModif) override
+ { m_nStatus |= nModif ; return true ; }
+
+ protected : // Operation
+ int GetSolCh( void) const override
+ { return m_Params.m_nSolCh ; }
+
+ public : // Machining
+ bool Prepare( const std::string& sMillName) override ;
+ bool SetParam( int nType, bool bVal) override ;
+ bool SetParam( int nType, int nVal) override ;
+ bool SetParam( int nType, double dVal) override ;
+ bool SetParam( int nType, const std::string& sVal) override ;
+ bool SetGeometry( const SELVECTOR& vIds) override ;
+ bool Preview( bool bRecalc) override ;
+ bool Apply( bool bRecalc, bool bPostApply) override ;
+ bool Update( bool bPostApply) override ;
+ bool GetParam( int nType, bool& bVal) const override ;
+ bool GetParam( int nType, int& nVal) const override ;
+ bool GetParam( int nType, double& dVal) const override ;
+ bool GetParam( int nType, std::string& sVal) const override ;
+ bool UpdateToolData( bool* pbChanged = nullptr) override ;
+ const ToolData& GetToolData( void) const override ;
+ bool GetGeometry( SELVECTOR& vIds) const override ;
+
+ public :
+ FiveAxisMilling( void) ;
+
+ private :
+ bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
+ double GetApproxLinTol( void) const override ;
+
+ private :
+ double GetSpeed() const
+ { return ( IsNullAngValue( m_Params.m_dSpeed) ? m_TParams.m_dSpeed : m_Params.m_dSpeed) ; }
+ double GetFeed() const
+ { return ( IsNullLenValue( m_Params.m_dFeed) ? m_TParams.m_dFeed : m_Params.m_dFeed) ; }
+ double GetStartFeed() const
+ { return ( IsNullLenValue( m_Params.m_dStartFeed) ? m_TParams.m_dStartFeed : m_Params.m_dStartFeed) ; }
+ double GetEndFeed() const
+ { return ( IsNullLenValue( m_Params.m_dEndFeed) ? m_TParams.m_dEndFeed : m_Params.m_dEndFeed) ; }
+ double GetTipFeed() const
+ { return ( IsNullLenValue( m_Params.m_dTipFeed) ? m_TParams.m_dTipFeed : m_Params.m_dTipFeed) ; }
+ double GetOffsL() const
+ { return ( IsUnknownValue( m_Params.m_dOffsL) ? m_TParams.m_dOffsL : m_Params.m_dOffsL) ; }
+ double GetOffsR() const
+ { return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
+
+ private :
+ SELVECTOR m_vId ; // identificativi entità geometriche da lavorare
+ FiveAxisMillingData m_Params ; // parametri lavorazione
+ ToolData m_TParams ; // parametri utensile
+ int m_nStatus ; // stato di aggiornamento della lavorazione
+ int m_nMills ; // numero di percorsi di lavoro generati
+} ;
diff --git a/FiveAxisMillingData.cpp b/FiveAxisMillingData.cpp
new file mode 100644
index 0000000..e1a03c9
--- /dev/null
+++ b/FiveAxisMillingData.cpp
@@ -0,0 +1,557 @@
+//----------------------------------------------------------------------------
+// EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : FiveAxisMillingData.cpp Data : 22.05.24 Versione : 2.6e5
+// Contenuto : Implementazione struttura dati fresatura a 5 assi.
+//
+//
+//
+// Modifiche : 22.05.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "FiveAxisMillingData.h"
+#include "MachiningDataFactory.h"
+#include "MachiningConst.h"
+#include "/EgtDev/Include/EmkToolConst.h"
+#include "/EgtDev/Include/EmkSimuGenConst.h"
+#include "/EgtDev/Include/EGnStringUtils.h"
+#include
+#include
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+enum nFiveAxisMillingKey {
+ KEY_AB = 0,
+ KEY_AI,
+ KEY_DH,
+ KEY_F,
+ KEY_FE,
+ KEY_FS,
+ KEY_FT,
+ KEY_INV,
+ KEY_NAME,
+ KEY_NNS,
+ KEY_NNU,
+ KEY_OL,
+ KEY_OR,
+ KEY_PS,
+ KEY_S,
+ KEY_SCC,
+ KEY_SUBTYPE,
+ KEY_TI,
+ KEY_TNAME,
+ KEY_TUUID,
+ KEY_UUID,
+ KEY_ZZZ} ; // rappresenta il numero di elementi
+
+static const array sFiveAxisMillingKey = {
+ "AB",
+ "AI",
+ "DH",
+ "F",
+ "FE",
+ "FS",
+ "FT",
+ "INV",
+ "NAME",
+ "NNS",
+ "NNU",
+ "OL",
+ "OR",
+ "PS",
+ "S",
+ "SCC",
+ "SUB",
+ "TI",
+ "TN",
+ "TU",
+ "UUID"} ;
+
+//----------------------------------------------------------------------------
+MCHDATA_REGISTER( MT_FIVEAXISMILLING, "FIVEAXISMILLING", FiveAxisMillingData) ;
+
+//----------------------------------------------------------------------------
+FiveAxisMillingData*
+FiveAxisMillingData::Clone( void) const
+{
+ // alloco oggetto
+ FiveAxisMillingData* pDdata = new(nothrow) FiveAxisMillingData ;
+ // copio i dati
+ if ( pDdata != nullptr) {
+ if ( ! pDdata->CopyFrom( this)) {
+ delete pDdata ;
+ return nullptr ;
+ }
+ }
+ return pDdata ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::CopyFrom( const MachiningData* pMdata)
+{
+ // è inutile copiare se sorgente coincide con destinazione
+ if ( pMdata == this)
+ return true ;
+ // la sorgente deve essere dello stesso tipo
+ const FiveAxisMillingData* pFdata = GetFiveAxisMillingData( pMdata) ;
+ if ( pFdata == nullptr)
+ return false ;
+ // eseguo copia
+ m_Uuid = pFdata->m_Uuid ;
+ m_sName = pFdata->m_sName ;
+ m_ToolUuid = pFdata->m_ToolUuid ;
+ m_sToolName = pFdata->m_sToolName ;
+ m_sBlockedAxis = pFdata->m_sBlockedAxis ;
+ m_sInitAngs = pFdata->m_sInitAngs ;
+ m_nSolCh = pFdata->m_nSolCh ;
+ m_dSpeed = pFdata->m_dSpeed ;
+ m_dFeed = pFdata->m_dFeed ;
+ m_dEndFeed = pFdata->m_dEndFeed ;
+ m_dStartFeed = pFdata->m_dStartFeed ;
+ m_dTipFeed = pFdata->m_dTipFeed ;
+ m_dOffsL = pFdata->m_dOffsL ;
+ m_dOffsR = pFdata->m_dOffsR ;
+ m_bToolInvert = pFdata->m_bToolInvert ;
+ m_bInvert = pFdata->m_bInvert ;
+ m_sDepth = pFdata->m_sDepth ;
+ m_dStartPos = pFdata->m_dStartPos ;
+ m_nSubType = pFdata->m_nSubType ;
+ m_sSysNotes = pFdata->m_sSysNotes ;
+ m_sUserNotes = pFdata->m_sUserNotes ;
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::SameAs(const MachiningData* pMdata) const
+{
+ // se coincide con altro -> uguali
+ if ( pMdata == this)
+ return true ;
+ // se sono di tipo diverso -> diversi
+ const FiveAxisMillingData* pFdata = GetFiveAxisMillingData( pMdata) ;
+ if ( pFdata == nullptr)
+ return false ;
+ // confronto termine a termine
+ return ( m_Uuid == pFdata->m_Uuid &&
+ m_sName == pFdata->m_sName &&
+ m_ToolUuid == pFdata->m_ToolUuid &&
+ m_sToolName == pFdata->m_sToolName &&
+ m_sBlockedAxis == pFdata->m_sBlockedAxis &&
+ m_sInitAngs == pFdata->m_sInitAngs &&
+ m_nSolCh == pFdata->m_nSolCh &&
+ abs( m_dSpeed - pFdata->m_dSpeed) < EPS_MACH_ANG_PAR &&
+ abs( m_dFeed - pFdata->m_dFeed) < EPS_MACH_LEN_PAR &&
+ abs( m_dEndFeed - pFdata->m_dEndFeed) < EPS_MACH_LEN_PAR &&
+ abs( m_dStartFeed - pFdata->m_dStartFeed) < EPS_MACH_LEN_PAR &&
+ abs( m_dTipFeed - pFdata->m_dTipFeed) < EPS_MACH_LEN_PAR &&
+ abs( m_dOffsL - pFdata->m_dOffsL) < EPS_MACH_LEN_PAR &&
+ abs( m_dOffsR - pFdata->m_dOffsR) < EPS_MACH_LEN_PAR &&
+ m_bToolInvert == pFdata->m_bToolInvert &&
+ m_bInvert == pFdata->m_bInvert &&
+ m_sDepth == pFdata->m_sDepth &&
+ abs( m_dStartPos - pFdata->m_dStartPos) < EPS_MACH_LEN_PAR &&
+ m_nSubType == pFdata->m_nSubType &&
+ m_sSysNotes == pFdata->m_sSysNotes &&
+ m_sUserNotes == pFdata->m_sUserNotes) ;
+}
+
+//----------------------------------------------------------------------------
+int
+FiveAxisMillingData::GetSize( void) const
+{
+ // in debug verifico validità ultimo campo
+ assert( sFiveAxisMillingKey[KEY_UUID] == "UUID") ;
+ return KEY_ZZZ ;
+}
+//----------------------------------------------------------------------------
+string
+FiveAxisMillingData::GetTitle( void) const
+{
+ return MCHDATA_GETNAME( FiveAxisMillingData) ;
+}
+
+//----------------------------------------------------------------------------
+int
+FindFiveAxisMillingKey( const string& sKey)
+{
+ auto TheRange = equal_range( sFiveAxisMillingKey.cbegin(), sFiveAxisMillingKey.cend(), sKey) ;
+ if ( TheRange.first == TheRange.second)
+ return - 1 ;
+ return int( TheRange.first - sFiveAxisMillingKey.cbegin()) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::FromString( const string& sString, int& nKey)
+{
+ // separo chiave da valore
+ string sKey, sVal ;
+ SplitFirst( sString, "=", sKey, sVal) ;
+ // riconosco la chiave
+ nKey = FindFiveAxisMillingKey( ToUpper( sKey)) ;
+ bool bOk = ( nKey >= 0) ;
+ switch ( nKey) {
+ case KEY_AB :
+ m_sBlockedAxis = sVal ;
+ break ;
+ case KEY_AI :
+ m_sInitAngs = sVal ;
+ break ;
+ case KEY_DH :
+ m_sDepth = sVal ;
+ if ( m_sDepth.empty())
+ m_sDepth = "0" ;
+ break ;
+ case KEY_F :
+ bOk = ::FromString( sVal, m_dFeed) ;
+ break ;
+ case KEY_FE :
+ bOk = ::FromString( sVal, m_dEndFeed) ;
+ break ;
+ case KEY_FS :
+ bOk = ::FromString( sVal, m_dStartFeed) ;
+ break ;
+ case KEY_FT :
+ bOk = ::FromString( sVal, m_dTipFeed) ;
+ break ;
+ case KEY_INV :
+ bOk = ::FromString( sVal, m_bInvert) ;
+ break ;
+ case KEY_NAME :
+ m_sName = sVal ;
+ bOk = ! m_sName.empty() ;
+ break ;
+ case KEY_NNS :
+ m_sSysNotes = sVal ;
+ break ;
+ case KEY_NNU :
+ m_sUserNotes = sVal ;
+ break ;
+ case KEY_OL :
+ bOk = ::FromString( sVal, m_dOffsL) ;
+ break ;
+ case KEY_OR :
+ bOk = ::FromString( sVal, m_dOffsR) ;
+ break ;
+ case KEY_PS :
+ bOk = ::FromString( sVal, m_dStartPos) ;
+ break ;
+ case KEY_S :
+ bOk = ::FromString( sVal, m_dSpeed) ;
+ break ;
+ case KEY_SCC :
+ bOk = ::FromString( sVal, m_nSolCh) ;
+ break ;
+ case KEY_SUBTYPE :
+ bOk = ::FromString( sVal, m_nSubType) ;
+ break ;
+ case KEY_TNAME :
+ m_sToolName = sVal ;
+ break ;
+ case KEY_TI :
+ bOk = ::FromString( sVal, m_bToolInvert) ;
+ break ;
+ case KEY_TUUID :
+ bOk = ::FromString( sVal, m_ToolUuid) ;
+ break ;
+ case KEY_UUID :
+ bOk = ::FromString( sVal, m_Uuid) ;
+ break ;
+ default :
+ bOk = false ;
+ break ;
+ }
+ return bOk ;
+}
+
+//----------------------------------------------------------------------------
+string
+FiveAxisMillingData::ToString( int nKey) const
+{
+ switch ( nKey) {
+ case KEY_AB : return ( sFiveAxisMillingKey[KEY_AB] + "=" + m_sBlockedAxis) ;
+ case KEY_AI : return ( sFiveAxisMillingKey[KEY_AI] + "=" + m_sInitAngs) ;
+ case KEY_DH : return ( sFiveAxisMillingKey[KEY_DH] + "=" + m_sDepth) ;
+ case KEY_F : return ( sFiveAxisMillingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
+ case KEY_FE : return ( sFiveAxisMillingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ;
+ case KEY_FS : return ( sFiveAxisMillingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ;
+ case KEY_FT : return ( sFiveAxisMillingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
+ case KEY_INV : return ( sFiveAxisMillingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
+ case KEY_NAME : return ( sFiveAxisMillingKey[KEY_NAME] + "=" + m_sName) ;
+ case KEY_NNS : return ( sFiveAxisMillingKey[KEY_NNS] + "=" + m_sSysNotes) ;
+ case KEY_NNU : return ( sFiveAxisMillingKey[KEY_NNU] + "=" + m_sUserNotes) ;
+ case KEY_OL : return ( sFiveAxisMillingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ;
+ case KEY_OR : return ( sFiveAxisMillingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ;
+ case KEY_PS : return ( sFiveAxisMillingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
+ case KEY_S : return ( sFiveAxisMillingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ;
+ case KEY_SCC : return ( sFiveAxisMillingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ;
+ case KEY_SUBTYPE : return ( sFiveAxisMillingKey[KEY_SUBTYPE] + "=" + ::ToString( m_nSubType)) ;
+ case KEY_TI : return ( sFiveAxisMillingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ;
+ case KEY_TNAME : return ( sFiveAxisMillingKey[KEY_TNAME] + "=" + m_sToolName) ;
+ case KEY_TUUID : return ( sFiveAxisMillingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
+ case KEY_UUID : return ( sFiveAxisMillingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
+ default : return "" ;
+ }
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::IsOptional( int nKey) const
+{
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::VerifySolCh( int nVal) const
+{
+ return IsValidOperationScc( nVal) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::VerifyTool( const ToolsMgr* pToolsMgr, const string& sVal, const ToolData*& pTdata) const
+{
+ if ( pToolsMgr == nullptr)
+ return false ;
+ pTdata = pToolsMgr->GetTool( sVal) ;
+ if ( pTdata == nullptr)
+ return false ;
+ if ( ( pTdata->m_nType & TF_MILL) == 0)
+ return false ;
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const
+{
+ if ( pToolsMgr == nullptr)
+ return false ;
+ pTdata = pToolsMgr->GetTool( m_ToolUuid) ;
+ return ( pTdata != nullptr) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::SetParam( int nType, bool bVal)
+{
+ switch ( nType) {
+ case MPA_INVERT :
+ m_bInvert = bVal ;
+ return true ;
+ case MPA_TOOLINVERT :
+ m_bToolInvert = bVal ;
+ return true ;
+ }
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::SetParam( int nType, int nVal)
+{
+ switch ( nType) {
+ case MPA_SCC :
+ if ( ! VerifySolCh( nVal))
+ return false ;
+ m_nSolCh = nVal ;
+ return true ;
+ case MPA_SUBTYPE :
+ m_nSubType = nVal ;
+ return true ;
+ }
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::SetParam( int nType, double dVal)
+{
+ switch ( nType) {
+ case MPA_SPEED :
+ m_dSpeed = dVal ;
+ return true ;
+ case MPA_FEED :
+ m_dFeed = dVal ;
+ return true ;
+ case MPA_STARTFEED :
+ m_dStartFeed = dVal ;
+ return true ;
+ case MPA_ENDFEED :
+ m_dEndFeed = dVal ;
+ return true ;
+ case MPA_TIPFEED :
+ m_dTipFeed = dVal ;
+ return true ;
+ case MPA_OFFSL :
+ m_dOffsL = dVal ;
+ return true ;
+ case MPA_OFFSR :
+ m_dOffsR = dVal ;
+ return true ;
+ case MPA_DEPTH :
+ m_sDepth = ::ToString( dVal) ;
+ return true ;
+ case MPA_STARTPOS :
+ m_dStartPos = dVal ;
+ return true ;
+ }
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::SetParam( int nType, const string& sVal)
+{
+ switch ( nType) {
+ case MPA_NAME :
+ m_sName = sVal ;
+ return true ;
+ case MPA_TOOL :
+ m_sToolName = sVal ;
+ return true ;
+ case MPA_DEPTH_STR :
+ m_sDepth = sVal ;
+ return true ;
+ case MPA_TUUID :
+ return ::FromString( sVal, m_ToolUuid) ;
+ case MPA_UUID :
+ return ::FromString( sVal, m_Uuid) ;
+ case MPA_SYSNOTES :
+ m_sSysNotes = sVal ;
+ return true ;
+ case MPA_USERNOTES :
+ m_sUserNotes = sVal ;
+ return true ;
+ case MPA_INITANGS :
+ m_sInitAngs = sVal ;
+ return true ;
+ case MPA_BLOCKEDAXIS :
+ m_sBlockedAxis = sVal ;
+ return true ;
+ }
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::ResetTool( void)
+{
+ m_sToolName.clear() ;
+ m_ToolUuid.Clear() ;
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::GetParam( int nType, bool& bVal) const
+{
+ switch ( nType) {
+ case MPA_INVERT :
+ bVal = m_bInvert ;
+ return true ;
+ case MPA_TOOLINVERT :
+ bVal = m_bToolInvert ;
+ return true ;
+ }
+ bVal = false ;
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::GetParam( int nType, int& nVal) const
+{
+ switch ( nType) {
+ case MPA_TYPE :
+ nVal = MT_GENMACHINING ;
+ return true ;
+ case MPA_SCC :
+ nVal = m_nSolCh ;
+ return true ;
+ case MPA_SUBTYPE :
+ nVal = m_nSubType ;
+ return true ;
+ }
+ nVal = 0 ;
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::GetParam( int nType, double& dVal) const
+{
+ switch ( nType) {
+ case MPA_SPEED :
+ dVal = m_dSpeed ;
+ return true ;
+ case MPA_FEED :
+ dVal = m_dFeed ;
+ return true ;
+ case MPA_STARTFEED :
+ dVal = m_dStartFeed ;
+ return true ;
+ case MPA_ENDFEED :
+ dVal = m_dEndFeed ;
+ return true ;
+ case MPA_TIPFEED :
+ dVal = m_dTipFeed ;
+ return true ;
+ case MPA_OFFSL :
+ dVal = m_dOffsL ;
+ return true ;
+ case MPA_OFFSR :
+ dVal = m_dOffsR ;
+ return true ;
+ case MPA_STARTPOS :
+ dVal = m_dStartPos ;
+ return true ;
+ }
+ dVal = 0 ;
+ return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FiveAxisMillingData::GetParam( int nType, string& sVal) const
+{
+ switch ( nType) {
+ case MPA_NAME :
+ sVal = m_sName ;
+ return true ;
+ case MPA_TOOL :
+ sVal = m_sToolName ;
+ return true ;
+ case MPA_DEPTH_STR :
+ sVal = m_sDepth ;
+ return true ;
+ case MPA_TUUID :
+ sVal = ::ToString( m_ToolUuid) ;
+ return true ;
+ case MPA_UUID :
+ sVal = ::ToString( m_Uuid) ;
+ return true ;
+ case MPA_SYSNOTES :
+ sVal = m_sSysNotes ;
+ return true ;
+ case MPA_USERNOTES :
+ sVal = m_sUserNotes ;
+ return true ;
+ case MPA_INITANGS :
+ sVal = m_sInitAngs ;
+ return true ;
+ case MPA_BLOCKEDAXIS :
+ sVal = m_sBlockedAxis ;
+ return true ;
+ }
+ sVal = "" ;
+ return false ;
+}
diff --git a/FiveAxisMillingData.h b/FiveAxisMillingData.h
new file mode 100644
index 0000000..83cd2ee
--- /dev/null
+++ b/FiveAxisMillingData.h
@@ -0,0 +1,76 @@
+//----------------------------------------------------------------------------
+// EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : FiveAxisMillingData.h Data : 22.05.24 Versione : 2.6e5
+// Contenuto : Dichiarazione della struct FiveAxisMillingData e costanti associate.
+//
+//
+//
+// Modifiche : 22.05.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "MachiningData.h"
+
+//----------------------------------------------------------------------------
+struct FiveAxisMillingData : public MachiningData
+{
+ EgtUUID m_ToolUuid ; // identificativo universale dell'utensile
+ std::string m_sToolName ; // nome dell'utensile
+ std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2)
+ std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val)
+ int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici)
+ double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile)
+ double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile)
+ double m_dStartFeed ; // velocità di lavorazione iniziale ( se 0 da utensile)
+ double m_dEndFeed ; // velocità di lavorazione finale ( se 0 da utensile)
+ double m_dTipFeed ; // velocità di lavorazione di sfondamento ( se 0 da utensile)
+ double m_dOffsR ; // offset radiale ( se UNKNOWN_PAR da utensile)
+ double m_dOffsL ; // offset longitudinale ( se UNKNOWN_PAR da utensile)
+ bool m_bToolInvert ; // flag per inversione direzione utensile da geometria
+ bool m_bInvert ; // flag di inversione direzione lavorazione
+ std::string m_sDepth ; // affondamento (espressione numerica)
+ double m_dStartPos ; // quota di inizio lavorazione (sempre >= 0)
+ int m_nSubType ; // da [GenMachining] di Ini di macchina
+ std::string m_sSysNotes ; // note interne
+ std::string m_sUserNotes ; // note dell'utente
+
+ FiveAxisMillingData( void)
+ : m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0),
+ m_dOffsR( 0), m_dOffsL( 0), m_bToolInvert( false), m_bInvert( false), m_dStartPos( 0), m_nSubType( 0) {}
+ FiveAxisMillingData* Clone( void) const override ;
+ bool CopyFrom( const MachiningData* pMdata) override ;
+ bool SameAs(const MachiningData* pMdata) const override ;
+ int GetType( void) const override
+ { return MT_FIVEAXISMILLING ; }
+ int GetSize( void) const override ;
+ std::string GetTitle( void) const override ;
+ bool FromString( const std::string& sString, int& nKey) override ;
+ std::string ToString( int nKey) const override ;
+ bool IsOptional( int nKey) const override ;
+ bool SetParam( int nType, bool bVal) override ;
+ bool SetParam( int nType, int nVal) override ;
+ bool SetParam( int nType, double dVal) override ;
+ bool SetParam( int nType, const std::string& sVal) override ;
+ bool ResetTool( void) override ;
+ bool GetParam( int nType, bool& bVal) const override ;
+ bool GetParam( int nType, int& nVal) const override ;
+ bool GetParam( int nType, double& dVal) const override ;
+ bool GetParam( int nType, std::string& sVal) const override ;
+ bool GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const override ;
+ bool VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const override ;
+ bool VerifySolCh( int nVal) const ;
+} ;
+
+//----------------------------------------------------------------------------
+inline const FiveAxisMillingData* GetFiveAxisMillingData( const MachiningData* pMdata)
+ { if ( pMdata == nullptr || pMdata->GetType() != MT_FIVEAXISMILLING)
+ return nullptr ;
+ return ( static_cast( pMdata)) ; }
+inline FiveAxisMillingData* GetFiveAxisMillingData( MachiningData* pMdata)
+ { if ( pMdata == nullptr || pMdata->GetType() != MT_FIVEAXISMILLING)
+ return nullptr ;
+ return ( static_cast( pMdata)) ; }
diff --git a/MachConst.h b/MachConst.h
index 48a9f80..364f0b0 100644
--- a/MachConst.h
+++ b/MachConst.h
@@ -84,6 +84,12 @@ const std::string GENMACHINING_SEC = "GenMachining" ;
// Chiave (radice) per nome lavorazione generica i-esima
const std::string GENMACHINING_SCRIPT_KEY = "GenScript" ;
+//----------------------------------------------------------------------------
+// Sezione fresature 5assi nel file INI di macchina
+const std::string FIVEAXISMILLING_SEC = "5AxMilling" ;
+// Chiave (radice) per nome lavorazione 5assi i-esima
+const std::string FIVEAXISMILLING_SCRIPT_KEY = "5AxScript" ;
+
//----------------------------------------------------------------------------
// Sezione di attrezzaggio nel file INI di macchina
const std::string SETUP_SEC = "Setup" ;
diff --git a/MachiningConst.h b/MachiningConst.h
index a665d69..824f126 100644
--- a/MachiningConst.h
+++ b/MachiningConst.h
@@ -107,7 +107,7 @@ GetMachiningTitle( int nMchType)
"SurfRoughing",
"SurfFinishing",
"Waterjetting",
- "5axMachining"} ;
+ "5AxisMilling"} ;
switch ( nMchType) {
case MT_DRILLING : return MchTitle[1] ;
case MT_SAWING : return MchTitle[2] ;
@@ -121,7 +121,7 @@ GetMachiningTitle( int nMchType)
case MT_SURFROUGHING : return MchTitle[10] ;
case MT_SURFFINISHING : return MchTitle[11] ;
case MT_WATERJETTING : return MchTitle[12] ;
- case MT_5AXMACHINING : return MchTitle[13] ;
+ case MT_FIVEAXISMILLING : return MchTitle[13] ;
}
return MchTitle[0] ;
diff --git a/OperationConst.h b/OperationConst.h
index 511ea98..845bdf1 100644
--- a/OperationConst.h
+++ b/OperationConst.h
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
-// EgalTech 2017-2019
+// EgalTech 2017-2024
//----------------------------------------------------------------------------
-// File : OperationConst.h Data : 08.07.19 Versione : 2.1g2
+// File : OperationConst.h Data : 22.05.24 Versione : 2.6e5
// Contenuto : Costanti per le operazioni.
//
//
@@ -9,6 +9,7 @@
// Modifiche : 17.08.17 DS Creazione modulo.
// 25.05.19 DS Aggiunte SurfRoughing e SurfFinishing.
// 25.05.19 DS Aggiunta WaterJetting.
+// 22.05.24 DS Aggiunta FiveAxisMilling.
//
//----------------------------------------------------------------------------
@@ -32,7 +33,8 @@ static const std::string s_OpeClass[] = {"",
"EMkChiseling",
"EMkSurfRoughing",
"EMkSurfFinishing",
- "EMkWaterJetting"} ;
+ "EMkWaterJetting",
+ "EMkFiveAxisMilling"} ;
//----------------------------------------------------------------------------
// Dal tipo numerico restituisce la classe della operazione
@@ -53,6 +55,7 @@ GetOperationClass( int nOpeType)
case OPER_SURFROUGHING : return s_OpeClass[11] ;
case OPER_SURFFINISHING : return s_OpeClass[12] ;
case OPER_WATERJETTING : return s_OpeClass[13] ;
+ case OPER_FIVEAXISMILLING : return s_OpeClass[14] ;
}
return s_OpeClass[0] ;
}
@@ -88,6 +91,8 @@ GetOperationType( const std::string& sOpeClass)
return OPER_SURFFINISHING ;
else if ( sOpeClass == s_OpeClass[13])
return OPER_WATERJETTING ;
+ else if ( sOpeClass == s_OpeClass[14])
+ return OPER_FIVEAXISMILLING ;
else
return OPER_NULL ;
-}
\ No newline at end of file
+}