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

EgtMachKernel 1.6k5 :

Browse Source 
- aggiunta gestione DB lavorazioni.
This commit is contained in:
Dario Sassi
2015-11-14 16:24:20 +00:00
parent 2a7370bde8
commit 7640eab85e
23 changed files with 1652 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MillingData.cpp
+399 -15
View File
@@ -15,6 +15,8 @@
#include "stdafx.h"
#include "MillingData.h"
#include "MachiningDataFactory.h"
#include "/EgtDev/Include/EmkToolConst.h"
#include "/EgtDev/Include/EgkGeoConst.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include <array>
#include <cassert>
@@ -38,7 +40,6 @@ enum nMillingKey {
KEY_LT,
KEY_NAME,
KEY_OL,
KEY_OM,
KEY_SA,
KEY_ST,
KEY_STY,
@@ -68,7 +69,6 @@ static const std::array<std::string,KEY_ZZZ> sMillingKey = {
"LT",
"NAME",
"OL",
"OM",
"SA",
"ST",
"STY",
@@ -82,7 +82,104 @@ static const std::array<std::string,KEY_ZZZ> sMillingKey = {
"WS"} ;
//----------------------------------------------------------------------------
MCHDATA_REGISTER( "MILLING", MillingData) ;
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 = dynamic_cast<const MillingData*>( 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_bInvert = pSdata->m_bInvert ;
m_nWorkSide = pSdata->m_nWorkSide ;
m_sDepth = pSdata->m_sDepth ;
m_dOverlap = pSdata->m_dOverlap ;
m_dStep = pSdata->m_dStep ;
m_nStepType = pSdata->m_nStepType ;
m_dSideAngle = pSdata->m_dSideAngle ;
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_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 ;
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 = dynamic_cast<const MillingData*>( 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_bInvert == pSdata->m_bInvert &&
m_nWorkSide == pSdata->m_nWorkSide &&
m_sDepth == pSdata->m_sDepth &&
m_dOverlap == pSdata->m_dOverlap &&
m_dStep == pSdata->m_dStep &&
m_nStepType == pSdata->m_nStepType &&
m_dSideAngle == pSdata->m_dSideAngle &&
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_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) ;
}
//----------------------------------------------------------------------------
int
@@ -121,7 +218,9 @@ MillingData::FromString( const string& sString, int& nKey)
bool bOk = ( nKey >= 0) ;
switch ( nKey) {
case KEY_DH :
bOk = ::FromString( sVal, m_dDepth) ;
m_sDepth = sVal ;
if ( m_sDepth.empty())
m_sDepth = "0" ;
break ;
case KEY_INV :
bOk = ::FromString( sVal, m_bInvert) ;
@@ -136,7 +235,7 @@ MillingData::FromString( const string& sString, int& nKey)
bOk = ::FromString( sVal, m_dLiPerp) ;
break ;
case KEY_LITG :
bOk = ::FromString( sVal, m_dLiTan) ;
bOk = ::FromString( sVal, m_dLiTang) ;
break ;
case KEY_LITY :
bOk = ::FromString( sVal, m_nLeadInType) ;
@@ -151,7 +250,7 @@ MillingData::FromString( const string& sString, int& nKey)
bOk = ::FromString( sVal, m_dLoPerp) ;
break ;
case KEY_LOTG :
bOk = ::FromString( sVal, m_dLoTan) ;
bOk = ::FromString( sVal, m_dLoTang) ;
break ;
case KEY_LOTY :
bOk = ::FromString( sVal, m_nLeadOutType) ;
@@ -166,9 +265,6 @@ MillingData::FromString( const string& sString, int& nKey)
case KEY_OL :
bOk = ::FromString( sVal, m_dOverlap) ;
break ;
case KEY_OM :
bOk = ::FromString( sVal, m_dOverMat) ;
break ;
case KEY_SA :
bOk = ::FromString( sVal, m_dSideAngle) ;
break ;
@@ -192,7 +288,6 @@ MillingData::FromString( const string& sString, int& nKey)
break ;
case KEY_TNAME :
m_sToolName = sVal ;
bOk = ! m_sToolName.empty() ;
break ;
case KEY_TUUID :
bOk = ::FromString( sVal, m_ToolUuid) ;
@@ -215,22 +310,21 @@ string
MillingData::ToString( int nInd) const
{
switch ( nInd) {
case KEY_DH : return ( sMillingKey[KEY_DH] + "=" + ::ToString( m_dDepth)) ;
case KEY_DH : return ( sMillingKey[KEY_DH] + "=" + m_sDepth) ;
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_dLiTan)) ;
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_dLoTan)) ;
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_OL : return ( sMillingKey[KEY_OL] + "=" + ::ToString( m_dOverlap)) ;
case KEY_OM : return ( sMillingKey[KEY_OM] + "=" + ::ToString( m_dOverMat)) ;
case KEY_SA : return ( sMillingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ;
case KEY_ST : return ( sMillingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ;
case KEY_STY : return ( sMillingKey[KEY_STY] + "=" + ::ToString( m_nStepType)) ;
@@ -244,4 +338,294 @@ MillingData::ToString( int nInd) const
case KEY_WS : return ( sMillingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ;
default : return "" ;
}
}
}
//----------------------------------------------------------------------------
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_STEP || 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) ;
}
//----------------------------------------------------------------------------
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) ;
}
//----------------------------------------------------------------------------
bool
MillingData::VerifySideAngle( double dVal) const
{
return ( ( dVal > - EPS_SMALL && dVal < 90 + EPS_SMALL) || fabs( dVal - 99) < EPS_SMALL) ;
}
//----------------------------------------------------------------------------
bool
MillingData::VerifyTool( const ToolsMgr* pToolsMgr, const std::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::SetParam( int nType, bool bVal)
{
switch ( nType) {
case MPA_INVERT :
m_bInvert = bVal ;
return true ;
case MPA_LEAVETAB :
m_bLeaveTab = 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 ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
MillingData::SetParam( int nType, double dVal)
{
switch ( nType) {
case MPA_DEPTH :
m_sDepth = ::ToString( dVal) ;
return true ;
case MPA_OVERLAP :
m_dOverlap = 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_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_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) ;
}
return false ;
}
//----------------------------------------------------------------------------
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 ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
MillingData::GetParam( int nType, int& nVal) const
{
switch ( nType) {
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 ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
MillingData::GetParam( int nType, double& dVal) const
{
switch ( nType) {
case MPA_OVERLAP :
dVal = m_dOverlap ;
return true ;
case MPA_STEP :
dVal = m_dStep ;
return true ;
case MPA_SIDEANGLE :
dVal = m_dSideAngle ;
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_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 ;
}
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 ;
}
return false ;
}