DarioS
1035 lines
31 KiB
C++
1035 lines
31 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2020
|
|
//----------------------------------------------------------------------------
|
|
// File : MillingData.cpp Data : 03.06.20 Versione : 2.2f2
|
|
// Contenuto : Implementazione struttura dati lavorazione di fresatura.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 05.06.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "MillingData.h"
|
|
#include "MachiningDataFactory.h"
|
|
#include "MachiningConst.h"
|
|
#include "/EgtDev/Include/EmkToolConst.h"
|
|
#include "/EgtDev/Include/EmkSimuGenConst.h"
|
|
#include "/EgtDev/Include/EGnStringUtils.h"
|
|
#include <array>
|
|
#include <cassert>
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
enum nMillingKey {
|
|
KEY_AB = 0,
|
|
KEY_AI,
|
|
KEY_DH,
|
|
KEY_EAL,
|
|
KEY_F,
|
|
KEY_FE,
|
|
KEY_FS,
|
|
KEY_FT,
|
|
KEY_FU,
|
|
KEY_INV,
|
|
KEY_LICL,
|
|
KEY_LIEL,
|
|
KEY_LIPR,
|
|
KEY_LITG,
|
|
KEY_LITY,
|
|
KEY_LOCL,
|
|
KEY_LOEL,
|
|
KEY_LOPR,
|
|
KEY_LOTG,
|
|
KEY_LOTY,
|
|
KEY_LT,
|
|
KEY_NAME,
|
|
KEY_NNS,
|
|
KEY_NNU,
|
|
KEY_OL,
|
|
KEY_OR,
|
|
KEY_OSEN,
|
|
KEY_OSFL,
|
|
KEY_OSH,
|
|
KEY_OSRL,
|
|
KEY_OVL,
|
|
KEY_PS,
|
|
KEY_S,
|
|
KEY_SA,
|
|
KEY_SAL,
|
|
KEY_SCC,
|
|
KEY_ST,
|
|
KEY_STY,
|
|
KEY_TA,
|
|
KEY_TD,
|
|
KEY_TH,
|
|
KEY_TI,
|
|
KEY_TL,
|
|
KEY_TMAX,
|
|
KEY_TMIN,
|
|
KEY_TNAME,
|
|
KEY_TUUID,
|
|
KEY_UUID,
|
|
KEY_WS,
|
|
KEY_ZZZ} ; // rappresenta il numero di elementi
|
|
|
|
static const array<string,KEY_ZZZ> sMillingKey = {
|
|
"AB",
|
|
"AI",
|
|
"DH",
|
|
"EAL",
|
|
"F",
|
|
"FE",
|
|
"FS",
|
|
"FT",
|
|
"FU",
|
|
"INV",
|
|
"LICL",
|
|
"LIEL",
|
|
"LIPR",
|
|
"LITG",
|
|
"LITY",
|
|
"LOCL",
|
|
"LOEL",
|
|
"LOPR",
|
|
"LOTG",
|
|
"LOTY",
|
|
"LT",
|
|
"NAME",
|
|
"NNS",
|
|
"NNU",
|
|
"OL",
|
|
"OR",
|
|
"OSEN",
|
|
"OSFL",
|
|
"OSH",
|
|
"OSRL",
|
|
"OVL",
|
|
"PS",
|
|
"S",
|
|
"SA",
|
|
"SAL",
|
|
"SCC",
|
|
"ST",
|
|
"STY",
|
|
"TA",
|
|
"TD",
|
|
"TH",
|
|
"TI",
|
|
"TL",
|
|
"TMAX",
|
|
"TMIN",
|
|
"TN",
|
|
"TU",
|
|
"UUID",
|
|
"WS"} ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
MCHDATA_REGISTER( MT_MILLING, "MILLING", MillingData) ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
MillingData*
|
|
MillingData::Clone( void) const
|
|
{
|
|
// alloco oggetto
|
|
MillingData* pMdata = new(nothrow) MillingData ;
|
|
// copio i dati
|
|
if ( pMdata != nullptr) {
|
|
if ( ! pMdata->CopyFrom( this)) {
|
|
delete pMdata ;
|
|
return nullptr ;
|
|
}
|
|
}
|
|
return pMdata ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::CopyFrom( const MachiningData* pMdata)
|
|
{
|
|
// è inutile copiare se sorgente coincide con destinazione
|
|
if ( pMdata == this)
|
|
return true ;
|
|
// la sorgente deve essere dello stesso tipo
|
|
const MillingData* pSdata = GetMillingData( pMdata) ;
|
|
if ( pSdata == nullptr)
|
|
return false ;
|
|
// eseguo copia
|
|
m_Uuid = pSdata->m_Uuid ;
|
|
m_sName = pSdata->m_sName ;
|
|
m_ToolUuid = pSdata->m_ToolUuid ;
|
|
m_sToolName = pSdata->m_sToolName ;
|
|
m_sBlockedAxis = pSdata->m_sBlockedAxis ;
|
|
m_sInitAngs = pSdata->m_sInitAngs ;
|
|
m_nSolCh = pSdata->m_nSolCh ;
|
|
m_dSpeed = pSdata->m_dSpeed ;
|
|
m_dFeed = pSdata->m_dFeed ;
|
|
m_dEndFeed = pSdata->m_dEndFeed ;
|
|
m_dStartFeed = pSdata->m_dStartFeed ;
|
|
m_dTipFeed = pSdata->m_dTipFeed ;
|
|
m_dOffsL = pSdata->m_dOffsL ;
|
|
m_dOffsR = pSdata->m_dOffsR ;
|
|
m_bToolInvert = pSdata->m_bToolInvert ;
|
|
m_nFaceUse = pSdata->m_nFaceUse ;
|
|
m_bInvert = pSdata->m_bInvert ;
|
|
m_nWorkSide = pSdata->m_nWorkSide ;
|
|
m_sDepth = pSdata->m_sDepth ;
|
|
m_dStartPos = pSdata->m_dStartPos ;
|
|
m_dOverlap = pSdata->m_dOverlap ;
|
|
m_dStep = pSdata->m_dStep ;
|
|
m_nStepType = pSdata->m_nStepType ;
|
|
m_dSideAngle = pSdata->m_dSideAngle ;
|
|
m_dStartAddLen = pSdata->m_dStartAddLen ;
|
|
m_dEndAddLen = pSdata->m_dEndAddLen ;
|
|
m_bLeaveTab = pSdata->m_bLeaveTab ;
|
|
m_dTabLen = pSdata->m_dTabLen ;
|
|
m_dTabDist = pSdata->m_dTabDist ;
|
|
m_dTabHeight = pSdata->m_dTabHeight ;
|
|
m_dTabAngle = pSdata->m_dTabAngle ;
|
|
m_nTabMin = pSdata->m_nTabMin ;
|
|
m_nTabMax = pSdata->m_nTabMax ;
|
|
m_bOscEnable = pSdata->m_bOscEnable ;
|
|
m_dOscHeight = pSdata->m_dOscHeight ;
|
|
m_dOscRampLen = pSdata->m_dOscRampLen ;
|
|
m_dOscFlatLen = pSdata->m_dOscFlatLen ;
|
|
m_nLeadInType = pSdata->m_nLeadInType ;
|
|
m_dLiTang = pSdata->m_dLiTang ;
|
|
m_dLiPerp = pSdata->m_dLiPerp ;
|
|
m_dLiElev = pSdata->m_dLiElev ;
|
|
m_dLiCompLen = pSdata->m_dLiCompLen ;
|
|
m_nLeadOutType = pSdata->m_nLeadOutType ;
|
|
m_dLoTang = pSdata->m_dLoTang ;
|
|
m_dLoPerp = pSdata->m_dLoPerp ;
|
|
m_dLoElev = pSdata->m_dLoElev ;
|
|
m_dLoCompLen = pSdata->m_dLoCompLen ;
|
|
m_sSysNotes = pSdata->m_sSysNotes ;
|
|
m_sUserNotes = pSdata->m_sUserNotes ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::SameAs( const MachiningData* pMdata) const
|
|
{
|
|
// se coincide con altro -> uguali
|
|
if ( pMdata == this)
|
|
return true ;
|
|
// se sono di tipo diverso -> diversi
|
|
const MillingData* pSdata = GetMillingData( pMdata) ;
|
|
if ( pSdata == nullptr)
|
|
return false ;
|
|
// confronto termine a termine
|
|
return ( m_Uuid == pSdata->m_Uuid &&
|
|
m_sName == pSdata->m_sName &&
|
|
m_ToolUuid == pSdata->m_ToolUuid &&
|
|
m_sToolName == pSdata->m_sToolName &&
|
|
m_sBlockedAxis == pSdata->m_sBlockedAxis &&
|
|
m_sInitAngs == pSdata->m_sInitAngs &&
|
|
m_nSolCh == pSdata->m_nSolCh &&
|
|
abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR &&
|
|
abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dEndFeed - pSdata->m_dEndFeed) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dStartFeed - pSdata->m_dStartFeed) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dTipFeed - pSdata->m_dTipFeed) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dOffsL - pSdata->m_dOffsL) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dOffsR - pSdata->m_dOffsR) < EPS_MACH_LEN_PAR &&
|
|
m_bToolInvert == pSdata->m_bToolInvert &&
|
|
m_nFaceUse == pSdata->m_nFaceUse &&
|
|
m_bInvert == pSdata->m_bInvert &&
|
|
m_nWorkSide == pSdata->m_nWorkSide &&
|
|
m_sDepth == pSdata->m_sDepth &&
|
|
abs( m_dStartPos - pSdata->m_dStartPos) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dOverlap - pSdata->m_dOverlap) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dStep - pSdata->m_dStep) < EPS_MACH_LEN_PAR &&
|
|
m_nStepType == pSdata->m_nStepType &&
|
|
abs( m_dSideAngle - pSdata->m_dSideAngle) < EPS_MACH_ANG_PAR &&
|
|
abs( m_dStartAddLen - pSdata->m_dStartAddLen) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dEndAddLen - pSdata->m_dEndAddLen) < EPS_MACH_LEN_PAR &&
|
|
m_bLeaveTab == pSdata->m_bLeaveTab &&
|
|
abs( m_dTabLen - pSdata->m_dTabLen) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dTabDist - pSdata->m_dTabDist) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dTabHeight - pSdata->m_dTabHeight) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dTabAngle - pSdata->m_dTabAngle) < EPS_MACH_ANG_PAR &&
|
|
m_nTabMin == pSdata->m_nTabMin &&
|
|
m_nTabMax == pSdata->m_nTabMax &&
|
|
m_bOscEnable == pSdata->m_bOscEnable &&
|
|
abs( m_dOscHeight - pSdata->m_dOscHeight) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dOscRampLen - pSdata->m_dOscRampLen) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dOscFlatLen - pSdata->m_dOscFlatLen) < EPS_MACH_LEN_PAR &&
|
|
m_nLeadInType == pSdata->m_nLeadInType &&
|
|
abs( m_dLiTang - pSdata->m_dLiTang) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dLiPerp - pSdata->m_dLiPerp) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dLiElev - pSdata->m_dLiElev) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dLiCompLen - pSdata->m_dLiCompLen) < EPS_MACH_LEN_PAR &&
|
|
m_nLeadOutType == pSdata->m_nLeadOutType &&
|
|
abs( m_dLoTang - pSdata->m_dLoTang) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dLoPerp - pSdata->m_dLoPerp) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dLoElev - pSdata->m_dLoElev) < EPS_MACH_LEN_PAR &&
|
|
abs( m_dLoCompLen - pSdata->m_dLoCompLen) < EPS_MACH_LEN_PAR &&
|
|
m_sSysNotes == pSdata->m_sSysNotes &&
|
|
m_sUserNotes == pSdata->m_sUserNotes) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
MillingData::GetSize( void) const
|
|
{
|
|
// in debug verifico validità ultimo campo
|
|
assert( sMillingKey[KEY_WS] == "WS") ;
|
|
return KEY_ZZZ ;
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
string
|
|
MillingData::GetTitle( void) const
|
|
{
|
|
return MCHDATA_GETNAME( MillingData) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
FindMillingKey( const string& sKey)
|
|
{
|
|
auto TheRange = equal_range( sMillingKey.cbegin(), sMillingKey.cend(), sKey) ;
|
|
if ( TheRange.first == TheRange.second)
|
|
return - 1 ;
|
|
return int( TheRange.first - sMillingKey.cbegin()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::FromString( const string& sString, int& nKey)
|
|
{
|
|
// separo chiave da valore
|
|
string sKey, sVal ;
|
|
SplitFirst( sString, "=", sKey, sVal) ;
|
|
// riconosco la chiave
|
|
nKey = FindMillingKey( 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_EAL :
|
|
bOk = ::FromString( sVal, m_dEndAddLen) ;
|
|
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_FU :
|
|
bOk = ::FromString( sVal, m_nFaceUse) ;
|
|
break ;
|
|
case KEY_INV :
|
|
bOk = ::FromString( sVal, m_bInvert) ;
|
|
break ;
|
|
case KEY_LICL :
|
|
bOk = ::FromString( sVal, m_dLiCompLen) ;
|
|
break ;
|
|
case KEY_LIEL :
|
|
bOk = ::FromString( sVal, m_dLiElev) ;
|
|
break ;
|
|
case KEY_LIPR :
|
|
bOk = ::FromString( sVal, m_dLiPerp) ;
|
|
break ;
|
|
case KEY_LITG :
|
|
bOk = ::FromString( sVal, m_dLiTang) ;
|
|
break ;
|
|
case KEY_LITY :
|
|
bOk = ::FromString( sVal, m_nLeadInType) ;
|
|
break ;
|
|
case KEY_LOCL :
|
|
bOk = ::FromString( sVal, m_dLoCompLen) ;
|
|
break ;
|
|
case KEY_LOEL :
|
|
bOk = ::FromString( sVal, m_dLoElev) ;
|
|
break ;
|
|
case KEY_LOPR :
|
|
bOk = ::FromString( sVal, m_dLoPerp) ;
|
|
break ;
|
|
case KEY_LOTG :
|
|
bOk = ::FromString( sVal, m_dLoTang) ;
|
|
break ;
|
|
case KEY_LOTY :
|
|
bOk = ::FromString( sVal, m_nLeadOutType) ;
|
|
break ;
|
|
case KEY_LT :
|
|
bOk = ::FromString( sVal, m_bLeaveTab) ;
|
|
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_OSEN :
|
|
bOk = ::FromString( sVal, m_bOscEnable) ;
|
|
break ;
|
|
case KEY_OSH :
|
|
bOk = ::FromString( sVal, m_dOscHeight) ;
|
|
break ;
|
|
case KEY_OSRL :
|
|
bOk = ::FromString( sVal, m_dOscRampLen) ;
|
|
break ;
|
|
case KEY_OSFL :
|
|
bOk = ::FromString( sVal, m_dOscFlatLen) ;
|
|
break ;
|
|
case KEY_OVL :
|
|
bOk = ::FromString( sVal, m_dOverlap) ;
|
|
break ;
|
|
case KEY_PS :
|
|
bOk = ::FromString( sVal, m_dStartPos) ;
|
|
break ;
|
|
case KEY_S :
|
|
bOk = ::FromString( sVal, m_dSpeed) ;
|
|
break ;
|
|
case KEY_SA :
|
|
bOk = ::FromString( sVal, m_dSideAngle) ;
|
|
break ;
|
|
case KEY_SAL :
|
|
bOk = ::FromString( sVal, m_dStartAddLen) ;
|
|
break ;
|
|
case KEY_SCC :
|
|
bOk = ::FromString( sVal, m_nSolCh) ;
|
|
break ;
|
|
case KEY_ST :
|
|
bOk = ::FromString( sVal, m_dStep) ;
|
|
break ;
|
|
case KEY_STY :
|
|
bOk = ::FromString( sVal, m_nStepType) ;
|
|
break ;
|
|
case KEY_TA :
|
|
bOk = ::FromString( sVal, m_dTabAngle) ;
|
|
break ;
|
|
case KEY_TD :
|
|
bOk = ::FromString( sVal, m_dTabDist) ;
|
|
break ;
|
|
case KEY_TH :
|
|
bOk = ::FromString( sVal, m_dTabHeight) ;
|
|
break ;
|
|
case KEY_TI :
|
|
bOk = ::FromString( sVal, m_bToolInvert) ;
|
|
break ;
|
|
case KEY_TL :
|
|
bOk = ::FromString( sVal, m_dTabLen) ;
|
|
break ;
|
|
case KEY_TMIN :
|
|
bOk = ::FromString( sVal, m_nTabMin) ;
|
|
break ;
|
|
case KEY_TMAX :
|
|
bOk = ::FromString( sVal, m_nTabMax) ;
|
|
break ;
|
|
case KEY_TNAME :
|
|
m_sToolName = sVal ;
|
|
break ;
|
|
case KEY_TUUID :
|
|
bOk = ::FromString( sVal, m_ToolUuid) ;
|
|
break ;
|
|
case KEY_UUID :
|
|
bOk = ::FromString( sVal, m_Uuid) ;
|
|
break ;
|
|
case KEY_WS :
|
|
bOk = ::FromString( sVal, m_nWorkSide) ;
|
|
break ;
|
|
default :
|
|
bOk = false ;
|
|
break ;
|
|
}
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
string
|
|
MillingData::ToString( int nInd) const
|
|
{
|
|
switch ( nInd) {
|
|
case KEY_AB : return ( sMillingKey[KEY_AB] + "=" + m_sBlockedAxis) ;
|
|
case KEY_AI : return ( sMillingKey[KEY_AI] + "=" + m_sInitAngs) ;
|
|
case KEY_DH : return ( sMillingKey[KEY_DH] + "=" + m_sDepth) ;
|
|
case KEY_EAL : return ( sMillingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ;
|
|
case KEY_F : return ( sMillingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
|
|
case KEY_FE : return ( sMillingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ;
|
|
case KEY_FS : return ( sMillingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ;
|
|
case KEY_FT : return ( sMillingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
|
|
case KEY_FU : return ( sMillingKey[KEY_FU] + "=" + ::ToString( m_nFaceUse)) ;
|
|
case KEY_INV : return ( sMillingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
|
|
case KEY_LICL : return ( sMillingKey[KEY_LICL] + "=" + ::ToString( m_dLiCompLen)) ;
|
|
case KEY_LIEL : return ( sMillingKey[KEY_LIEL] + "=" + ::ToString( m_dLiElev)) ;
|
|
case KEY_LIPR : return ( sMillingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ;
|
|
case KEY_LITG : return ( sMillingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ;
|
|
case KEY_LITY : return ( sMillingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ;
|
|
case KEY_LOCL : return ( sMillingKey[KEY_LOCL] + "=" + ::ToString( m_dLoCompLen)) ;
|
|
case KEY_LOEL : return ( sMillingKey[KEY_LOEL] + "=" + ::ToString( m_dLoElev)) ;
|
|
case KEY_LOPR : return ( sMillingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ;
|
|
case KEY_LOTG : return ( sMillingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ;
|
|
case KEY_LOTY : return ( sMillingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ;
|
|
case KEY_LT : return ( sMillingKey[KEY_LT] + "=" + ::ToString( m_bLeaveTab)) ;
|
|
case KEY_NAME : return ( sMillingKey[KEY_NAME] + "=" + m_sName) ;
|
|
case KEY_NNS : return ( sMillingKey[KEY_NNS] + "=" + m_sSysNotes) ;
|
|
case KEY_NNU : return ( sMillingKey[KEY_NNU] + "=" + m_sUserNotes) ;
|
|
case KEY_OL : return ( sMillingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ;
|
|
case KEY_OR : return ( sMillingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ;
|
|
case KEY_OSEN : return ( sMillingKey[KEY_OSEN] + "=" + ::ToString( m_bOscEnable)) ;
|
|
case KEY_OSH : return ( sMillingKey[KEY_OSH] + "=" + ::ToString( m_dOscHeight)) ;
|
|
case KEY_OSRL : return ( sMillingKey[KEY_OSRL] + "=" + ::ToString( m_dOscRampLen)) ;
|
|
case KEY_OSFL : return ( sMillingKey[KEY_OSFL] + "=" + ::ToString( m_dOscFlatLen)) ;
|
|
case KEY_OVL : return ( sMillingKey[KEY_OVL] + "=" + ::ToString( m_dOverlap)) ;
|
|
case KEY_PS : return ( sMillingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
|
|
case KEY_S : return ( sMillingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ;
|
|
case KEY_SA : return ( sMillingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ;
|
|
case KEY_SAL : return ( sMillingKey[KEY_SAL] + "=" + ::ToString( m_dStartAddLen)) ;
|
|
case KEY_SCC : return ( sMillingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ;
|
|
case KEY_ST : return ( sMillingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ;
|
|
case KEY_STY : return ( sMillingKey[KEY_STY] + "=" + ::ToString( m_nStepType)) ;
|
|
case KEY_TA : return ( sMillingKey[KEY_TA] + "=" + ::ToString( m_dTabAngle)) ;
|
|
case KEY_TD : return ( sMillingKey[KEY_TD] + "=" + ::ToString( m_dTabDist)) ;
|
|
case KEY_TH : return ( sMillingKey[KEY_TH] + "=" + ::ToString( m_dTabHeight)) ;
|
|
case KEY_TI : return ( sMillingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ;
|
|
case KEY_TL : return ( sMillingKey[KEY_TL] + "=" + ::ToString( m_dTabLen)) ;
|
|
case KEY_TMIN : return ( sMillingKey[KEY_TMIN] + "=" + ::ToString( m_nTabMin)) ;
|
|
case KEY_TMAX : return ( sMillingKey[KEY_TMAX] + "=" + ::ToString( m_nTabMax)) ;
|
|
case KEY_TNAME : return ( sMillingKey[KEY_TNAME] + "=" + m_sToolName) ;
|
|
case KEY_TUUID : return ( sMillingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
|
|
case KEY_UUID : return ( sMillingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
|
|
case KEY_WS : return ( sMillingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ;
|
|
default : return "" ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::IsOptional( int nKey) const
|
|
{
|
|
return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_EAL || nKey == KEY_F ||
|
|
nKey == KEY_FE || nKey == KEY_FS || nKey == KEY_FT || nKey == KEY_FU ||
|
|
nKey == KEY_NNS || nKey == KEY_NNU || nKey == KEY_OL || nKey == KEY_OR ||
|
|
nKey == KEY_OSEN || nKey == KEY_OSH || nKey == KEY_OSRL || nKey == KEY_OSFL ||
|
|
nKey == KEY_S || nKey == KEY_SAL || nKey == KEY_SCC || nKey == KEY_TI ||
|
|
nKey == KEY_TMIN || nKey == KEY_TMAX) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::VerifySolCh( int nVal) const
|
|
{
|
|
return IsValidOperationScc( nVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::VerifyFaceUse( int nVal) const
|
|
{
|
|
return ( nVal == MILL_FU_NONE ||
|
|
( nVal >= MILL_FU_PARAL_DOWN && nVal <= MILL_FU_PARAL_RIGHT) ||
|
|
( nVal >= MILL_FU_ORTHO_DOWN && nVal <= MILL_FU_ORTHO_CONT) ||
|
|
( nVal >= MILL_FU_ORTUP_DOWN && nVal <= MILL_FU_ORTUP_CONT)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::VerifyWorkSide( int nVal) const
|
|
{
|
|
return ( nVal == MILL_WS_CENTER || nVal == MILL_WS_LEFT || nVal == MILL_WS_RIGHT) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::VerifyStepType( int nVal) const
|
|
{
|
|
return ( nVal == MILL_ST_ZIGZAG || nVal == MILL_ST_ONEWAY || nVal == MILL_ST_SPIRAL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::VerifyLeadInType( int nVal) const
|
|
{
|
|
return ( nVal == MILL_LI_NONE || nVal == MILL_LI_LINEAR ||
|
|
nVal == MILL_LI_TANGENT || nVal == MILL_LI_GLIDE ||
|
|
nVal == MILL_LI_ZIGZAG || nVal == MILL_LI_HELIX ||
|
|
nVal == MILL_LI_TG_PERP) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::VerifyLeadOutType( int nVal) const
|
|
{
|
|
return ( nVal == MILL_LO_NONE || nVal == MILL_LO_LINEAR ||
|
|
nVal == MILL_LO_TANGENT || nVal == MILL_LO_GLIDE ||
|
|
nVal == MILL_LO_AS_LI || nVal == MILL_LO_PERP_TG) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::VerifyTabMin( int nVal) const
|
|
{
|
|
return ( nVal >= 0 && nVal <= m_nTabMax) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::VerifyTabMax( int nVal) const
|
|
{
|
|
return ( nVal >= 0 && nVal >= m_nTabMin) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::VerifySideAngle( double dVal) const
|
|
{
|
|
return ( ( dVal > - EPS_SMALL && dVal < 90 + EPS_SMALL) || abs( dVal - 99) < EPS_SMALL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::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 && ( pTdata->m_nType & TF_SAWBLADE) == 0)
|
|
return false ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const
|
|
{
|
|
if ( pToolsMgr == nullptr)
|
|
return false ;
|
|
pTdata = pToolsMgr->GetTool( m_ToolUuid) ;
|
|
return ( pTdata != nullptr) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::SetParam( int nType, bool bVal)
|
|
{
|
|
switch ( nType) {
|
|
case MPA_INVERT :
|
|
m_bInvert = bVal ;
|
|
return true ;
|
|
case MPA_LEAVETAB :
|
|
m_bLeaveTab = bVal ;
|
|
return true ;
|
|
case MPA_TOOLINVERT :
|
|
m_bToolInvert = bVal ;
|
|
return true ;
|
|
case MPA_OSCENABLE :
|
|
m_bOscEnable = bVal ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::SetParam( int nType, int nVal)
|
|
{
|
|
switch ( nType) {
|
|
case MPA_WORKSIDE :
|
|
if ( ! VerifyWorkSide( nVal))
|
|
return false ;
|
|
m_nWorkSide = nVal ;
|
|
return true ;
|
|
case MPA_STEPTYPE :
|
|
if ( ! VerifyStepType( nVal))
|
|
return false ;
|
|
m_nStepType = nVal ;
|
|
return true ;
|
|
case MPA_LEADINTYPE :
|
|
if ( ! VerifyLeadInType( nVal))
|
|
return false ;
|
|
m_nLeadInType = nVal ;
|
|
return true ;
|
|
case MPA_LEADOUTTYPE :
|
|
if ( ! VerifyLeadOutType( nVal))
|
|
return false ;
|
|
m_nLeadOutType = nVal ;
|
|
return true ;
|
|
case MPA_TABMIN :
|
|
if ( ! VerifyTabMin( nVal))
|
|
return false ;
|
|
m_nTabMin = nVal ;
|
|
return true ;
|
|
case MPA_TABMAX :
|
|
if ( ! VerifyTabMax( nVal))
|
|
return false ;
|
|
m_nTabMax = nVal ;
|
|
return true ;
|
|
case MPA_SCC :
|
|
if ( ! VerifySolCh( nVal))
|
|
return false ;
|
|
m_nSolCh = nVal ;
|
|
return true ;
|
|
case MPA_FACEUSE :
|
|
if ( ! VerifyFaceUse( nVal))
|
|
return false ;
|
|
m_nFaceUse = nVal ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::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_OVERL :
|
|
m_dOverlap = dVal ;
|
|
return true ;
|
|
case MPA_STARTPOS :
|
|
m_dStartPos = dVal ;
|
|
return true ;
|
|
case MPA_STEP :
|
|
m_dStep = dVal ;
|
|
return true ;
|
|
case MPA_SIDEANGLE :
|
|
if ( ! VerifySideAngle( dVal))
|
|
return false ;
|
|
m_dSideAngle = dVal ;
|
|
return true ;
|
|
case MPA_STARTADDLEN :
|
|
m_dStartAddLen = dVal ;
|
|
return true ;
|
|
case MPA_ENDADDLEN :
|
|
m_dEndAddLen = dVal ;
|
|
return true ;
|
|
case MPA_TABLEN :
|
|
m_dTabLen = dVal ;
|
|
return true ;
|
|
case MPA_TABDIST :
|
|
m_dTabDist = dVal ;
|
|
return true ;
|
|
case MPA_TABHEIGHT :
|
|
m_dTabHeight = dVal ;
|
|
return true ;
|
|
case MPA_TABANGLE :
|
|
m_dTabAngle = dVal ;
|
|
return true ;
|
|
case MPA_OSCHEIGHT :
|
|
m_dOscHeight = dVal ;
|
|
return true ;
|
|
case MPA_OSCRAMPLEN :
|
|
m_dOscRampLen = dVal ;
|
|
return true ;
|
|
case MPA_OSCFLATLEN :
|
|
m_dOscFlatLen = dVal ;
|
|
return true ;
|
|
case MPA_LITANG :
|
|
m_dLiTang = dVal ;
|
|
return true ;
|
|
case MPA_LIPERP :
|
|
m_dLiPerp = dVal ;
|
|
return true ;
|
|
case MPA_LIELEV :
|
|
m_dLiElev = dVal ;
|
|
return true ;
|
|
case MPA_LICOMPLEN :
|
|
m_dLiCompLen = dVal ;
|
|
return true ;
|
|
case MPA_LOTANG :
|
|
m_dLoTang = dVal ;
|
|
return true ;
|
|
case MPA_LOPERP :
|
|
m_dLoPerp = dVal ;
|
|
return true ;
|
|
case MPA_LOELEV :
|
|
m_dLoElev = dVal ;
|
|
return true ;
|
|
case MPA_LOCOMPLEN :
|
|
m_dLoCompLen = dVal ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::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
|
|
MillingData::ResetTool( void)
|
|
{
|
|
m_sToolName.clear() ;
|
|
m_ToolUuid.Clear() ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::GetParam( int nType, bool& bVal) const
|
|
{
|
|
switch ( nType) {
|
|
case MPA_INVERT :
|
|
bVal = m_bInvert ;
|
|
return true ;
|
|
case MPA_LEAVETAB :
|
|
bVal = m_bLeaveTab ;
|
|
return true ;
|
|
case MPA_OSCENABLE :
|
|
bVal = m_bOscEnable ;
|
|
return true ;
|
|
case MPA_TOOLINVERT :
|
|
bVal = m_bToolInvert ;
|
|
return true ;
|
|
}
|
|
bVal = false ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::GetParam( int nType, int& nVal) const
|
|
{
|
|
switch ( nType) {
|
|
case MPA_TYPE :
|
|
nVal = MT_MILLING ;
|
|
return true ;
|
|
case MPA_WORKSIDE :
|
|
nVal = m_nWorkSide ;
|
|
return true ;
|
|
case MPA_STEPTYPE :
|
|
nVal = m_nStepType ;
|
|
return true ;
|
|
case MPA_LEADINTYPE :
|
|
nVal = m_nLeadInType ;
|
|
return true ;
|
|
case MPA_LEADOUTTYPE :
|
|
nVal = m_nLeadOutType ;
|
|
return true ;
|
|
case MPA_TABMIN :
|
|
nVal= m_nTabMin ;
|
|
return true ;
|
|
case MPA_TABMAX :
|
|
nVal= m_nTabMax ;
|
|
return true ;
|
|
case MPA_SCC :
|
|
nVal = m_nSolCh ;
|
|
return true ;
|
|
case MPA_FACEUSE :
|
|
nVal = m_nFaceUse ;
|
|
return true ;
|
|
}
|
|
nVal = 0 ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::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_OVERL :
|
|
dVal = m_dOverlap ;
|
|
return true ;
|
|
case MPA_STARTPOS :
|
|
dVal = m_dStartPos ;
|
|
return true ;
|
|
case MPA_STEP :
|
|
dVal = m_dStep ;
|
|
return true ;
|
|
case MPA_SIDEANGLE :
|
|
dVal = m_dSideAngle ;
|
|
return true ;
|
|
case MPA_STARTADDLEN :
|
|
dVal = m_dStartAddLen ;
|
|
return true ;
|
|
case MPA_ENDADDLEN :
|
|
dVal = m_dEndAddLen ;
|
|
return true ;
|
|
case MPA_TABLEN :
|
|
dVal = m_dTabLen ;
|
|
return true ;
|
|
case MPA_TABDIST :
|
|
dVal = m_dTabDist ;
|
|
return true ;
|
|
case MPA_TABHEIGHT :
|
|
dVal = m_dTabHeight ;
|
|
return true ;
|
|
case MPA_TABANGLE :
|
|
dVal = m_dTabAngle ;
|
|
return true ;
|
|
case MPA_OSCHEIGHT :
|
|
dVal = m_dOscHeight ;
|
|
return true ;
|
|
case MPA_OSCRAMPLEN :
|
|
dVal = m_dOscRampLen ;
|
|
return true ;
|
|
case MPA_OSCFLATLEN :
|
|
dVal = m_dOscFlatLen ;
|
|
return true ;
|
|
case MPA_LITANG :
|
|
dVal = m_dLiTang ;
|
|
return true ;
|
|
case MPA_LIPERP :
|
|
dVal = m_dLiPerp ;
|
|
return true ;
|
|
case MPA_LIELEV :
|
|
dVal = m_dLiElev ;
|
|
return true ;
|
|
case MPA_LICOMPLEN :
|
|
dVal = m_dLiCompLen ;
|
|
return true ;
|
|
case MPA_LOTANG :
|
|
dVal = m_dLoTang ;
|
|
return true ;
|
|
case MPA_LOPERP :
|
|
dVal = m_dLoPerp ;
|
|
return true ;
|
|
case MPA_LOELEV :
|
|
dVal = m_dLoElev ;
|
|
return true ;
|
|
case MPA_LOCOMPLEN :
|
|
dVal = m_dLoCompLen ;
|
|
return true ;
|
|
}
|
|
dVal = 0 ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MillingData::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 ;
|
|
}
|