diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index 4f30223..16a7da7 100644 Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ diff --git a/EgtMachKernel.vcxproj b/EgtMachKernel.vcxproj index 6a16509..1fc963d 100644 --- a/EgtMachKernel.vcxproj +++ b/EgtMachKernel.vcxproj @@ -276,6 +276,8 @@ copy $(TargetPath) \EgtProg\Dll64 + + @@ -451,6 +453,8 @@ copy $(TargetPath) \EgtProg\Dll64 + + diff --git a/EgtMachKernel.vcxproj.filters b/EgtMachKernel.vcxproj.filters index 511298e..67eb203 100644 --- a/EgtMachKernel.vcxproj.filters +++ b/EgtMachKernel.vcxproj.filters @@ -252,6 +252,12 @@ Source Files\Operations + + Source Files\Machinings + + + Source Files\Operations + @@ -770,6 +776,12 @@ Header Files + + Header Files + + + Header Files + diff --git a/FiveAxisMillingData.cpp b/FiveAxisMillingData.cpp index 9409a4a..f458521 100644 --- a/FiveAxisMillingData.cpp +++ b/FiveAxisMillingData.cpp @@ -178,7 +178,7 @@ FiveAxisMillingData::GetTitle( void) const } //---------------------------------------------------------------------------- -int +static int FindFiveAxisMillingKey( const string& sKey) { auto TheRange = equal_range( sFiveAxisMillingKey.cbegin(), sFiveAxisMillingKey.cend(), sKey) ; diff --git a/GenMachiningData.cpp b/GenMachiningData.cpp index 2b41635..d5a979c 100644 --- a/GenMachiningData.cpp +++ b/GenMachiningData.cpp @@ -178,7 +178,7 @@ GenMachiningData::GetTitle( void) const } //---------------------------------------------------------------------------- -int +static int FindGenMachiningKey( const string& sKey) { auto TheRange = equal_range( sGenMachiningKey.cbegin(), sGenMachiningKey.cend(), sKey) ; diff --git a/MachConst.h b/MachConst.h index 7170113..91e0391 100644 --- a/MachConst.h +++ b/MachConst.h @@ -78,6 +78,12 @@ const std::string MACHININGS_DIR = "Machinings" ; // Nome file delle lavorazioni const std::string MACHININGS_FILE = "Machinings.data" ; +//---------------------------------------------------------------------------- +// Sezione tastature nel file INI di macchina +const std::string PROBING_SEC = "Probing" ; +// Chiave (radice) per nome tastatura i-esima +const std::string PROBING_SCRIPT_KEY = "PrbScript" ; + //---------------------------------------------------------------------------- // Sezione lavorazioni generiche nel file INI di macchina const std::string GENMACHINING_SEC = "GenMachining" ; @@ -111,6 +117,8 @@ const std::string MORTISEMAKER_KEY = "MortiseMaker" ; const std::string CHISELMAKER_KEY = "ChiselMaker" ; // Chiave per generatore disegno waterjet const std::string WATERJETMAKER_KEY = "WaterJetMaker" ; +// Chiave per generatore disegno tastatori +const std::string PROBEMAKER_KEY = "ProbeMaker" ; // Chiave per porta utensili punte a forare (marmo) const std::string DRILLHOLDER_KEY = "DrillHolder" ; // Chiave per porta utensili lame (marmo) diff --git a/MachMgrDBTools.cpp b/MachMgrDBTools.cpp index 9949d03..5af1a16 100644 --- a/MachMgrDBTools.cpp +++ b/MachMgrDBTools.cpp @@ -715,6 +715,15 @@ MachMgr::UpdateStandardToolDraw( const ToolData* pTdata, int nGenCtx, int nToolC bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.THICK", dThick) ; bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.CORNRAD", dCornRad) ; break ; + case TT_PROBE : + bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.TOOLHOLDER", sThPath) ; + bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.TOTLEN", dTotLen) ; + bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.LEN", dLen) ; + bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIAM", dDiam) ; + bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.STEMDIAM", dStemDiam) ; + bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.HEIGHT", dThick) ; + bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.CORNRAD", dCornRad) ; + break ; default : return TD_INT_ERR ; } @@ -811,6 +820,8 @@ MachMgr::GetToolMakerKeyFromType( int nType) const return WATERJETMAKER_KEY ; case TT_COMPO : return "" ; + case TT_PROBE : + return PROBEMAKER_KEY ; } return "" ; } @@ -852,6 +863,10 @@ MachMgr::GetToolHolderPath( const string& sHeadName, int nExit, int nType, const string sKey2 = sKey + ":MILL_POLISHING" ; sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey2.c_str(), "", sMachIni.c_str()) ; } + else if ( nType == TT_PROBE) { + string sKey2 = sKey + ":PROBE" ; + sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey2.c_str(), "", sMachIni.c_str()) ; + } if ( sToolHolder.empty()) sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey.c_str(), "", sMachIni.c_str()) ; // Se non trovato, provo da sezione Tools di Ini di macchina diff --git a/MachiningConst.h b/MachiningConst.h index 824f126..060a2da 100644 --- a/MachiningConst.h +++ b/MachiningConst.h @@ -107,7 +107,8 @@ GetMachiningTitle( int nMchType) "SurfRoughing", "SurfFinishing", "Waterjetting", - "5AxisMilling"} ; + "5AxisMilling", + "Probing"} ; switch ( nMchType) { case MT_DRILLING : return MchTitle[1] ; case MT_SAWING : return MchTitle[2] ; @@ -122,7 +123,7 @@ GetMachiningTitle( int nMchType) case MT_SURFFINISHING : return MchTitle[11] ; case MT_WATERJETTING : return MchTitle[12] ; case MT_FIVEAXISMILLING : return MchTitle[13] ; - + case MT_PROBING : return MchTitle[14] ; } return MchTitle[0] ; } diff --git a/MachiningsMgr.cpp b/MachiningsMgr.cpp index 0664ba7..f9672fb 100644 --- a/MachiningsMgr.cpp +++ b/MachiningsMgr.cpp @@ -1,7 +1,7 @@ //---------------------------------------------------------------------------- -// EgalTech 2015-2024 +// EgalTech 2015-2025 //---------------------------------------------------------------------------- -// File : MachiningsMgr.cpp Data : 29.03.24 Versione : 2.6d1 +// File : MachiningsMgr.cpp Data : 09.06.25 Versione : 2.7f2 // Contenuto : Implementazione gestore database lavorazioni. // // @@ -17,6 +17,7 @@ // 09.11.20 DS Agg. per nuovi parametri tagli di lama (MF_CURR_VER = 1011). // 04.02.22 DS Agg. per nuovi parametri svuotature con epicicli (MF_CURR_VER = 1012). // 29.03.24 DS Agg. parametro APPROX_LINTOL (MF_CURR_VER = 1013). +// 29.03.24 DS Agg. tastatura (MF_CURR_VER = 1014). // //---------------------------------------------------------------------------- @@ -43,7 +44,7 @@ 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 = 1013 ; +const int MF_CURR_VER = 1014 ; const string MF_GENERAL = "[GENERAL]" ; const string MF_3AXCOMP = "3AXCOMP" ; const bool MF_CURR_3AXCOMP = false ; diff --git a/Operation.cpp b/Operation.cpp index 5fd935d..f5b30c3 100644 --- a/Operation.cpp +++ b/Operation.cpp @@ -1867,6 +1867,8 @@ Operation::CalculateAxesValues( const string& sHint, bool bRotContOnNext, bool b STRVECTOR vsTok ; Tokenize( sHint, ",;", vsTok) ; for ( const auto& sTok : vsTok) { + if ( sTok.empty()) + continue ; string szKey, szVal ; Split( sTok, "=", true, szKey, szVal) ; Trim( szKey) ; diff --git a/OperationConst.h b/OperationConst.h index 8c79e18..8e126bf 100644 --- a/OperationConst.h +++ b/OperationConst.h @@ -33,7 +33,8 @@ static const std::string s_OpeClass[] = {"", "EMkSurfRoughing", "EMkSurfFinishing", "EMkWaterJetting", - "EMkFiveAxisMilling"} ; + "EMkFiveAxisMilling", + "EMkProbing"} ; //---------------------------------------------------------------------------- // Dal tipo numerico restituisce la classe della operazione @@ -55,6 +56,7 @@ GetOperationClass( int nOpeType) case OPER_SURFFINISHING : return s_OpeClass[12] ; case OPER_WATERJETTING : return s_OpeClass[13] ; case OPER_FIVEAXISMILLING : return s_OpeClass[14] ; + case OPER_PROBING : return s_OpeClass[15] ; } return s_OpeClass[0] ; } @@ -92,6 +94,8 @@ GetOperationType( const std::string& sOpeClass) return OPER_WATERJETTING ; else if ( sOpeClass == s_OpeClass[14]) return OPER_FIVEAXISMILLING ; + else if ( sOpeClass == s_OpeClass[15]) + return OPER_PROBING ; else return OPER_NULL ; } diff --git a/Probing.cpp b/Probing.cpp new file mode 100644 index 0000000..7b843f3 --- /dev/null +++ b/Probing.cpp @@ -0,0 +1,948 @@ +//---------------------------------------------------------------------------- +// EgalTech 2025-2025 +//---------------------------------------------------------------------------- +// File : Probing.cpp Data : 10.06.25 Versione : 2.7f2 +// Contenuto : Implementazione gestione tastatura. +// +// +// +// Modifiche : 10.06.25 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "MachMgr.h" +#include "DllMain.h" +#include "Probing.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 -------------------------------------- +// 3401 = "Error in Probing : UpdateToolData failed" +// 3402 = "Error in Probing : missing Script (xxx)" +// 3403 = "Error in Probing : Error in xxx (nnn)" +// 3404 = "Error in Probing : axes values not calculable" +// 3405 = "Error in Probing : outstroke xx" +// 3406 = "Error in Probing : link movements not calculable" +// 3407 = "Error in Probing : link outstroke xx" +// 3408 = "Error in Probing : post apply not calculable" +// 3409 = "Error in Probing : Tool loading failed" +// 3451 = "Warning in Probing : Skipped entity (xx)" +// 3452 = "Warning in Probing : No machinable path" +// 3453 = "Warning in Probing : Tool name changed (xx)" +// 3454 = "Warning in Probing : 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_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_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_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_PROBING), Probing) ; + +//---------------------------------------------------------------------------- +const string& +Probing::GetClassName( void) const +{ + return USEROBJ_GETNAME( Probing) ; +} + +//---------------------------------------------------------------------------- +Probing* +Probing::Clone( void) const +{ + // alloco oggetto + Probing* pGenM = new(nothrow) Probing ; + // 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 +Probing::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 +Probing::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 +Probing::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 ; +} + +//---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +Probing::Probing( 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 +Probing::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 ProbingData* pDdata = GetProbingData( 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 +Probing::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 +Probing::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 +Probing::SetParam( int nType, double dVal) +{ + switch ( nType) { + 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_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 +Probing::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 +Probing::SetGeometry( const SELVECTOR& vIds) +{ + // verifico validità gestore DB geometrico + if ( m_pGeomDB == nullptr) + return false ; + // copia temporanea e reset della geometria corrente + SELVECTOR vOldId = m_vId ; + 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 Probing : Skipped entity " + ToString( Id) ; + m_pMchMgr->SetWarning( 3451, sInfo) ; + continue ; + } + // posso aggiungere alla lista + m_vId.emplace_back( Id) ; + } + // aggiorno lo stato + if ( m_vId != vOldId) + m_nStatus |= MCH_ST_GEO_MODIF ; + // restituisco presenza geometria da lavorare + return ( ! m_vId.empty() || vIds.empty()) ; +} + +//---------------------------------------------------------------------------- +bool +Probing::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( 3401, "Error in Probing : 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( 3409, "Error in Probing : 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 = PROBING_SCRIPT_KEY + ToString( m_Params.m_nSubType) ; + string sName = GetPrivateProfileStringUtf8( PROBING_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 Probing : missing Script " + sPreview ; + m_pMchMgr->SetLastError( 3402, 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_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_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_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 Probing : Error in " + sPreview + " (" + ToString( nErr) + ")" ; + m_pMchMgr->SetLastError( 3403, sErr) ; + return false ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Probing::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( 3401, "Error in Probing : UpdateToolData failed") ; + return false ; + } + + // se modificata geometria, necessario ricalcolo + if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0) + bRecalc = true ; + + // verifico se necessario continuare nell'aggiornamento + if ( ! bRecalc && ! bToolChanged && + ( m_nStatus == MCH_ST_OK || m_nStatus == MCH_ST_NO_POSTAPPL)) { + // confermo i percorsi di lavorazione + m_nMills = nCurrMills ; + string sLog = string( "Probing apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ; + LOG_DBG_INFO( GetEMkLogger(), sLog.c_str()) ; + // eseguo aggiornamento assi macchina e collegamento con operazione precedente + if ( ! Update( bPostApply)) + return false ; + m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ; + 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( 3409, "Error in Probing : 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 = PROBING_SCRIPT_KEY + ToString( m_Params.m_nSubType) ; + string sName = GetPrivateProfileStringUtf8( PROBING_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 Probing : missing Script " + sApply ; + m_pMchMgr->SetLastError( 3402, 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_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_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_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 Probing : Error in " + sApply + " (" + ToString( nErr) + ")" ; + m_pMchMgr->SetLastError( 3403, 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(), "Probing apply done") ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Probing::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( 3452, "Warning in Probing : 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( 3404, "Error in Probing : axes values not calculable") ; + else + m_pMchMgr->SetLastError( 3405, "Error in Probing : 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( 3406, "Error in Probing : link movements not calculable") ; + else + m_pMchMgr->SetLastError( 3407, "Error in Probing : 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( 3408, sErr) ; + else + m_pMchMgr->SetLastError( 3408, "Error in Probing : post apply not calculable") ; + return false ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Probing::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 +Probing::GetParam( int nType, int& nVal) const +{ + switch ( nType) { + case MPA_TYPE : + nVal = MT_PROBING ; + 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 +Probing::GetParam( int nType, double& dVal) const +{ + switch ( nType) { + case MPA_SPEED : + dVal = 0 ; + 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_STARTPOS : + dVal = m_Params.m_dStartPos ; + return true ; + } + dVal = 0 ; + return false ; +} + +//---------------------------------------------------------------------------- +bool +Probing::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& +Probing::GetToolData( void) const +{ + return m_TParams ; +} + +//---------------------------------------------------------------------------- +bool +Probing::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 (se fallisce con UUID provo con il nome) + const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ; + if ( pTdata == nullptr) { + pTdata = pTMgr->GetTool( m_Params.m_sToolName) ; + if ( pTdata == nullptr) + return false ; + m_Params.m_ToolUuid = m_TParams.m_Uuid ; + } + // 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 Probing : tool name changed (" + + m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ; + m_pMchMgr->SetWarning( 3453, sInfo) ; + m_Params.m_sToolName = m_TParams.m_sName ; + } + if ( bChanged) { + string sInfo = "Warning in Probing : tool data changed (" + + m_Params.m_sToolName + ")" ; + m_pMchMgr->SetWarning( 3454, sInfo) ; + } + // se definito parametro di ritorno, lo assegno + if ( pbChanged != nullptr) + *pbChanged = bChanged ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +Probing::GetGeometry( SELVECTOR& vIds) const +{ + // restituisco l'elenco delle entità + vIds = m_vId ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +Probing::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 +Probing::GetApproxLinTol( void) const +{ + double dLinTol ; + if ( GetValInNotes( m_Params.m_sUserNotes, "LinTol", dLinTol)) + return dLinTol ; + else + return Operation::GetApproxLinTol() ; +} diff --git a/Probing.h b/Probing.h new file mode 100644 index 0000000..69f96b5 --- /dev/null +++ b/Probing.h @@ -0,0 +1,94 @@ +//---------------------------------------------------------------------------- +// EgalTech 2025-2025 +//---------------------------------------------------------------------------- +// File : Probing.h Data : 10.06.25 Versione : 2.7f2 +// Contenuto : Dichiarazione della classe Probing. +// +// +// +// Modifiche : 10.06.25 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "Machining.h" +#include "ProbingData.h" +#include "ToolData.h" + +class ICurve ; +class ICurveComposite ; + +//---------------------------------------------------------------------------- +class Probing : public Machining +{ + public : // IUserObj + Probing* 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_PROBING ; } + bool IsEmpty( int nEmptyType = NEED_GEOM) const override + { if ( m_nMills == 0) + return true ; + if ( nEmptyType == NEED_ONE_TP_OK) + return ( ! IsAtLeastOnePathOk()) ; + if ( nEmptyType == NEED_ALL_TP_OK) + return ( ! AreAllPathsOk()) ; + return false ; } + 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 : + Probing( void) ; + + private : + bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ; + double GetApproxLinTol( void) const override ; + + private : + 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) ; } + + private : + SELVECTOR m_vId ; // identificativi entità geometriche da lavorare + ProbingData 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 +} ; \ No newline at end of file diff --git a/ProbingData.cpp b/ProbingData.cpp new file mode 100644 index 0000000..2b3afe8 --- /dev/null +++ b/ProbingData.cpp @@ -0,0 +1,515 @@ +//---------------------------------------------------------------------------- +// EgalTech 2025-2025 +//---------------------------------------------------------------------------- +// File : ProbingData.cpp Data : 09.06.25 Versione : 2.7f2 +// Contenuto : Implementazione struttura dati tastatura. +// +// +// +// Modifiche : 09.06.25 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "ProbingData.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 nProbingKey { + KEY_AB = 0, + KEY_AI, + KEY_DH, + KEY_F, + KEY_FE, + KEY_FS, + KEY_FT, + KEY_INV, + KEY_NAME, + KEY_NNS, + KEY_NNU, + KEY_PS, + KEY_SCC, + KEY_SUBTYPE, + KEY_TI, + KEY_TNAME, + KEY_TUUID, + KEY_UUID, + KEY_ZZZ} ; // rappresenta il numero di elementi + +static const array sProbingKey = { + "AB", + "AI", + "DH", + "F", + "FE", + "FS", + "FT", + "INV", + "NAME", + "NNS", + "NNU", + "PS", + "SCC", + "SUB", + "TI", + "TN", + "TU", + "UUID"} ; + +//---------------------------------------------------------------------------- +MCHDATA_REGISTER( MT_PROBING, "PROBING", ProbingData) ; + +//---------------------------------------------------------------------------- +ProbingData* +ProbingData::Clone( void) const +{ + // alloco oggetto + ProbingData* pDdata = new(nothrow) ProbingData ; + // copio i dati + if ( pDdata != nullptr) { + if ( ! pDdata->CopyFrom( this)) { + delete pDdata ; + return nullptr ; + } + } + return pDdata ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::CopyFrom( const MachiningData* pMdata) +{ + // è inutile copiare se sorgente coincide con destinazione + if ( pMdata == this) + return true ; + // la sorgente deve essere dello stesso tipo + const ProbingData* pGdata = GetProbingData( pMdata) ; + if ( pGdata == nullptr) + return false ; + // eseguo copia + m_Uuid = pGdata->m_Uuid ; + m_sName = pGdata->m_sName ; + m_ToolUuid = pGdata->m_ToolUuid ; + m_sToolName = pGdata->m_sToolName ; + m_sBlockedAxis = pGdata->m_sBlockedAxis ; + m_sInitAngs = pGdata->m_sInitAngs ; + m_nSolCh = pGdata->m_nSolCh ; + m_dFeed = pGdata->m_dFeed ; + m_dStartFeed = pGdata->m_dStartFeed ; + m_dEndFeed = pGdata->m_dEndFeed ; + m_dTipFeed = pGdata->m_dTipFeed ; + m_bToolInvert = pGdata->m_bToolInvert ; + m_bInvert = pGdata->m_bInvert ; + m_sDepth = pGdata->m_sDepth ; + m_dStartPos = pGdata->m_dStartPos ; + m_nSubType = pGdata->m_nSubType ; + m_sSysNotes = pGdata->m_sSysNotes ; + m_sUserNotes = pGdata->m_sUserNotes ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::SameAs(const MachiningData* pMdata) const +{ + // se coincide con altro -> uguali + if ( pMdata == this) + return true ; + // se sono di tipo diverso -> diversi + const ProbingData* pGdata = GetProbingData( pMdata) ; + if ( pGdata == nullptr) + return false ; + // confronto termine a termine + return ( m_Uuid == pGdata->m_Uuid && + m_sName == pGdata->m_sName && + m_ToolUuid == pGdata->m_ToolUuid && + m_sToolName == pGdata->m_sToolName && + m_sBlockedAxis == pGdata->m_sBlockedAxis && + m_sInitAngs == pGdata->m_sInitAngs && + m_nSolCh == pGdata->m_nSolCh && + abs( m_dFeed - pGdata->m_dFeed) < EPS_MACH_LEN_PAR && + abs( m_dStartFeed - pGdata->m_dStartFeed) < EPS_MACH_LEN_PAR && + abs( m_dEndFeed - pGdata->m_dEndFeed) < EPS_MACH_LEN_PAR && + abs( m_dTipFeed - pGdata->m_dTipFeed) < EPS_MACH_LEN_PAR && + m_bToolInvert == pGdata->m_bToolInvert && + m_bInvert == pGdata->m_bInvert && + m_sDepth == pGdata->m_sDepth && + abs( m_dStartPos - pGdata->m_dStartPos) < EPS_MACH_LEN_PAR && + m_nSubType == pGdata->m_nSubType && + m_sSysNotes == pGdata->m_sSysNotes && + m_sUserNotes == pGdata->m_sUserNotes) ; +} + +//---------------------------------------------------------------------------- +int +ProbingData::GetSize( void) const +{ + // in debug verifico validità ultimo campo + assert( sProbingKey[KEY_UUID] == "UUID") ; + return KEY_ZZZ ; +} +//---------------------------------------------------------------------------- +string +ProbingData::GetTitle( void) const +{ + return MCHDATA_GETNAME( ProbingData) ; +} + +//---------------------------------------------------------------------------- +static int +FindProbingKey( const string& sKey) +{ + auto TheRange = equal_range( sProbingKey.cbegin(), sProbingKey.cend(), sKey) ; + if ( TheRange.first == TheRange.second) + return - 1 ; + return int( TheRange.first - sProbingKey.cbegin()) ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::FromString( const string& sString, int& nKey) +{ + // separo chiave da valore + string sKey, sVal ; + SplitFirst( sString, "=", sKey, sVal) ; + // riconosco la chiave + nKey = FindProbingKey( 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_PS : + bOk = ::FromString( sVal, m_dStartPos) ; + 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 +ProbingData::ToString( int nKey) const +{ + switch ( nKey) { + case KEY_AB : return ( sProbingKey[KEY_AB] + "=" + m_sBlockedAxis) ; + case KEY_AI : return ( sProbingKey[KEY_AI] + "=" + m_sInitAngs) ; + case KEY_DH : return ( sProbingKey[KEY_DH] + "=" + m_sDepth) ; + case KEY_F : return ( sProbingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; + case KEY_FE : return ( sProbingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ; + case KEY_FS : return ( sProbingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ; + case KEY_FT : return ( sProbingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ; + case KEY_INV : return ( sProbingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; + case KEY_NAME : return ( sProbingKey[KEY_NAME] + "=" + m_sName) ; + case KEY_NNS : return ( sProbingKey[KEY_NNS] + "=" + m_sSysNotes) ; + case KEY_NNU : return ( sProbingKey[KEY_NNU] + "=" + m_sUserNotes) ; + case KEY_PS : return ( sProbingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ; + case KEY_SCC : return ( sProbingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ; + case KEY_SUBTYPE : return ( sProbingKey[KEY_SUBTYPE] + "=" + ::ToString( m_nSubType)) ; + case KEY_TI : return ( sProbingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ; + case KEY_TNAME : return ( sProbingKey[KEY_TNAME] + "=" + m_sToolName) ; + case KEY_TUUID : return ( sProbingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; + case KEY_UUID : return ( sProbingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; + default : return "" ; + } +} + +//---------------------------------------------------------------------------- +bool +ProbingData::IsOptional( int nKey) const +{ + return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_TI) ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::VerifySolCh( int nVal) const +{ + return IsValidOperationScc( nVal) ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::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_PROBE) == 0) + return false ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const +{ + if ( pToolsMgr == nullptr) + return false ; + pTdata = pToolsMgr->GetTool( m_ToolUuid) ; + return ( pTdata != nullptr) ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::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 +ProbingData::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 +ProbingData::SetParam( int nType, double dVal) +{ + switch ( nType) { + 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_DEPTH : + m_sDepth = ::ToString( dVal) ; + return true ; + case MPA_STARTPOS : + m_dStartPos = dVal ; + return true ; + } + return false ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::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 +ProbingData::ResetTool( void) +{ + m_sToolName.clear() ; + m_ToolUuid.Clear() ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::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 +ProbingData::GetParam( int nType, int& nVal) const +{ + switch ( nType) { + case MPA_TYPE : + nVal = MT_PROBING ; + return true ; + case MPA_SCC : + nVal = m_nSolCh ; + return true ; + case MPA_SUBTYPE : + nVal = m_nSubType ; + return true ; + } + nVal = 0 ; + return false ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::GetParam( int nType, double& dVal) const +{ + switch ( nType) { + 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_STARTPOS : + dVal = m_dStartPos ; + return true ; + } + dVal = 0 ; + return false ; +} + +//---------------------------------------------------------------------------- +bool +ProbingData::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/ProbingData.h b/ProbingData.h new file mode 100644 index 0000000..6af40bc --- /dev/null +++ b/ProbingData.h @@ -0,0 +1,73 @@ +//---------------------------------------------------------------------------- +// EgalTech 2025-2025 +//---------------------------------------------------------------------------- +// File : ProbingData.h Data : 09.06.25 Versione : 2.7f2 +// Contenuto : Dichiarazione della struct ProbingData e costanti associate. +// +// +// +// Modifiche : 09.06.25 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "MachiningData.h" + +//---------------------------------------------------------------------------- +struct ProbingData : 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_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) + 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 [Probing] di Ini di macchina + std::string m_sSysNotes ; // note interne + std::string m_sUserNotes ; // note dell'utente + + ProbingData( void) + : m_ToolUuid(), m_nSolCh( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0), + m_bToolInvert( false), m_bInvert( false), m_dStartPos( 0), m_nSubType( 0) {} + ProbingData* Clone( void) const override ; + bool CopyFrom( const MachiningData* pMdata) override ; + bool SameAs(const MachiningData* pMdata) const override ; + int GetType( void) const override + { return MT_PROBING ; } + 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 ProbingData* GetProbingData( const MachiningData* pMdata) + { if ( pMdata == nullptr || pMdata->GetType() != MT_PROBING) + return nullptr ; + return ( static_cast( pMdata)) ; } +inline ProbingData* GetProbingData( MachiningData* pMdata) + { if ( pMdata == nullptr || pMdata->GetType() != MT_PROBING) + return nullptr ; + return ( static_cast( pMdata)) ; }