//---------------------------------------------------------------------------- // EgalTech 2019-2019 //---------------------------------------------------------------------------- // File : SurfFinishingData.cpp Data : 25.05.19 Versione : 2.1e5 // Contenuto : Implementazione struttura dati lavorazione di finitura superfici. // // // // Modifiche : 25.05.19 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "SurfFinishingData.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 nSurfFinishingKey { KEY_AB = 0, KEY_AI, KEY_APPR, KEY_DH, KEY_F, KEY_FE, KEY_FS, KEY_FT, KEY_INV, KEY_LIPR, KEY_LITG, KEY_LITY, KEY_LLTY, KEY_LOPR, KEY_LOTG, KEY_LOTY, KEY_NAME, KEY_NNS, KEY_NNU, KEY_OR, KEY_OVL, KEY_PS, KEY_S, KEY_SA, KEY_SCC, KEY_SS, KEY_SUBTYPE, KEY_TNAME, KEY_TUUID, KEY_UUID, KEY_ZZZ} ; // rappresenta il numero di elementi static const array sSurfFinishingKey = { "AB", "AI", "APPR", "DH", "F", "FE", "FS", "FT", "INV", "LIPR", "LITG", "LITY", "LLTY", "LOPR", "LOTG", "LOTY", "NAME", "NNS", "NNU", "OR", "OVL", "PS", "S", "SA", "SCC", "SS", "SUB", "TN", "TU", "UUID"} ; //---------------------------------------------------------------------------- MCHDATA_REGISTER( MT_SURFFINISHING, "SURFFINISHING", SurfFinishingData) ; //---------------------------------------------------------------------------- SurfFinishingData* SurfFinishingData::Clone( void) const { // alloco oggetto SurfFinishingData* pMdata = new(nothrow) SurfFinishingData ; // copio i dati if ( pMdata != nullptr) { if ( ! pMdata->CopyFrom( this)) { delete pMdata ; return nullptr ; } } return pMdata ; } //---------------------------------------------------------------------------- bool SurfFinishingData::CopyFrom( const MachiningData* pMdata) { // è inutile copiare se sorgente coincide con destinazione if ( pMdata == this) return true ; // la sorgente deve essere dello stesso tipo const SurfFinishingData* pSdata = GetSurfFinishingData( 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_dOffsR = pSdata->m_dOffsR ; m_bInvert = pSdata->m_bInvert ; m_sDepth = pSdata->m_sDepth ; m_dStartPos = pSdata->m_dStartPos ; m_dOverlap = pSdata->m_dOverlap ; m_dSideStep = pSdata->m_dSideStep ; m_nSubType = pSdata->m_nSubType ; m_dSideAngle = pSdata->m_dSideAngle ; m_nLeadInType = pSdata->m_nLeadInType ; m_dLiTang = pSdata->m_dLiTang ; m_dLiPerp = pSdata->m_dLiPerp ; m_nLeadOutType = pSdata->m_nLeadOutType ; m_dLoTang = pSdata->m_dLoTang ; m_dLoPerp = pSdata->m_dLoPerp ; m_dApprox = pSdata->m_dApprox ; m_sSysNotes = pSdata->m_sSysNotes ; m_sUserNotes = pSdata->m_sUserNotes ; return true ; } //---------------------------------------------------------------------------- bool SurfFinishingData::SameAs(const MachiningData* pMdata) const { // se coincide con altro -> uguali if ( pMdata == this) return true ; // se sono di tipo diverso -> diversi const SurfFinishingData* pSdata = GetSurfFinishingData( 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_dOffsR - pSdata->m_dOffsR) < EPS_MACH_LEN_PAR && m_bInvert == pSdata->m_bInvert && 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_dSideStep - pSdata->m_dSideStep) < EPS_MACH_LEN_PAR && m_nSubType == pSdata->m_nSubType && abs( m_dSideAngle - pSdata->m_dSideAngle) < EPS_MACH_ANG_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 && 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_dApprox - pSdata->m_dApprox) < EPS_MACH_LEN_PAR && m_sSysNotes == pSdata->m_sSysNotes && m_sUserNotes == pSdata->m_sUserNotes) ; } //---------------------------------------------------------------------------- int SurfFinishingData::GetSize( void) const { // in debug verifico validità ultimo campo assert( sSurfFinishingKey[KEY_UUID] == "UUID") ; return KEY_ZZZ ; } //---------------------------------------------------------------------------- string SurfFinishingData::GetTitle( void) const { return MCHDATA_GETNAME( SurfFinishingData) ; } //---------------------------------------------------------------------------- int FindSurfFinishingKey( const string& sKey) { auto TheRange = equal_range( sSurfFinishingKey.cbegin(), sSurfFinishingKey.cend(), sKey) ; if ( TheRange.first == TheRange.second) return - 1 ; return int( TheRange.first - sSurfFinishingKey.cbegin()) ; } //---------------------------------------------------------------------------- bool SurfFinishingData::FromString( const string& sString, int& nKey) { // separo chiave da valore string sKey, sVal ; SplitFirst( sString, "=", sKey, sVal) ; // riconosco la chiave nKey = FindSurfFinishingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { case KEY_AB : m_sBlockedAxis = sVal ; break ; case KEY_AI : m_sInitAngs = sVal ; break ; case KEY_APPR : bOk = ::FromString( sVal, m_dApprox) ; 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_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_LLTY : // campo non più usato 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_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_OR : bOk = ::FromString( sVal, m_dOffsR) ; 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_SCC : bOk = ::FromString( sVal, m_nSolCh) ; break ; case KEY_SS : bOk = ::FromString( sVal, m_dSideStep) ; break ; case KEY_SUBTYPE : bOk = ::FromString( sVal, m_nSubType) ; 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 ; default : bOk = false ; break ; } return bOk ; } //---------------------------------------------------------------------------- string SurfFinishingData::ToString( int nInd) const { switch ( nInd) { case KEY_AB : return ( sSurfFinishingKey[KEY_AB] + "=" + m_sBlockedAxis) ; case KEY_AI : return ( sSurfFinishingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_APPR : return ( sSurfFinishingKey[KEY_APPR] + "=" + ::ToString(m_dApprox)) ; case KEY_DH : return ( sSurfFinishingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_F : return ( sSurfFinishingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; case KEY_FE : return ( sSurfFinishingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ; case KEY_FS : return ( sSurfFinishingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ; case KEY_FT : return ( sSurfFinishingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ; case KEY_INV : return ( sSurfFinishingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; case KEY_LIPR : return ( sSurfFinishingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ; case KEY_LITG : return ( sSurfFinishingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ; case KEY_LITY : return ( sSurfFinishingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ; case KEY_LLTY : return ( sSurfFinishingKey[KEY_LLTY] + "=" + ::ToString( 0)) ; case KEY_LOPR : return ( sSurfFinishingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ; case KEY_LOTG : return ( sSurfFinishingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ; case KEY_LOTY : return ( sSurfFinishingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ; case KEY_NAME : return ( sSurfFinishingKey[KEY_NAME] + "=" + m_sName) ; case KEY_NNS : return ( sSurfFinishingKey[KEY_NNS] + "=" + m_sSysNotes) ; case KEY_NNU : return ( sSurfFinishingKey[KEY_NNU] + "=" + m_sUserNotes) ; case KEY_OR : return ( sSurfFinishingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ; case KEY_OVL : return ( sSurfFinishingKey[KEY_OVL] + "=" + ::ToString( m_dOverlap)) ; case KEY_PS : return ( sSurfFinishingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ; case KEY_S : return ( sSurfFinishingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ; case KEY_SA : return ( sSurfFinishingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ; case KEY_SCC : return ( sSurfFinishingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ; case KEY_SS : return ( sSurfFinishingKey[KEY_SS] + "=" + ::ToString( m_dSideStep)) ; case KEY_SUBTYPE : return ( sSurfFinishingKey[KEY_SUBTYPE] + "=" + ::ToString( m_nSubType)) ; case KEY_TNAME : return ( sSurfFinishingKey[KEY_TNAME] + "=" + m_sToolName) ; case KEY_TUUID : return ( sSurfFinishingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; case KEY_UUID : return ( sSurfFinishingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; default : return "" ; } } //---------------------------------------------------------------------------- bool SurfFinishingData::IsOptional( int nKey) const { return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_OVL) ; } //---------------------------------------------------------------------------- bool SurfFinishingData::VerifySolCh( int nVal) const { return IsValidOperationScc( nVal) ; } //---------------------------------------------------------------------------- bool SurfFinishingData::VerifySubType( int nVal) const { return ( nVal == SURFFIN_SUB_ZIGZAG || nVal == SURFFIN_SUB_ONEWAY || nVal == SURFFIN_SUB_SPIRALIN || nVal == SURFFIN_SUB_SPIRALOUT || nVal == SURFFIN_SUB_Z_CONST || nVal == SURFFIN_SUB_OPTIMAL || nVal == SURFFIN_SUB_PROJECT || nVal == SURFFIN_SUB_PENCIL) ; } //---------------------------------------------------------------------------- bool SurfFinishingData::VerifyLeadInType( int nVal) const { return ( nVal == SURFFIN_LI_NONE || nVal == SURFFIN_LI_LINEAR || nVal == SURFFIN_LI_TANGENT) ; } //---------------------------------------------------------------------------- bool SurfFinishingData::VerifyLeadOutType( int nVal) const { return ( nVal == SURFFIN_LO_NONE || nVal == SURFFIN_LO_LINEAR || nVal == SURFFIN_LO_TANGENT || nVal == SURFFIN_LO_AS_LI) ; } //---------------------------------------------------------------------------- bool SurfFinishingData::VerifyTool( const ToolsMgr* pToolsMgr, const string& sVal, const ToolData*& pTdata) const { if ( pToolsMgr == nullptr) return false ; pTdata = pToolsMgr->GetTool( sVal) ; if ( pTdata == nullptr) return false ; if ( ( pTdata->m_nType & TF_MILL) == 0) return false ; return true ; } //---------------------------------------------------------------------------- bool SurfFinishingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const { if ( pToolsMgr == nullptr) return false ; pTdata = pToolsMgr->GetTool( m_ToolUuid) ; return ( pTdata != nullptr) ; } //---------------------------------------------------------------------------- bool SurfFinishingData::SetParam( int nType, bool bVal) { switch ( nType) { case MPA_INVERT : m_bInvert = bVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SurfFinishingData::SetParam( int nType, int nVal) { switch ( nType) { 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_SCC : if ( ! VerifySolCh( nVal)) return false ; m_nSolCh = nVal ; return true ; case MPA_SUBTYPE : if ( ! VerifySubType( nVal)) return false ; m_nSubType = nVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SurfFinishingData::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_OFFSR : m_dOffsR = dVal ; return true ; case MPA_DEPTH : m_sDepth = ::ToString( dVal) ; return true ; case MPA_STARTPOS : m_dStartPos = dVal ; return true ; case MPA_OVERL : m_dOverlap = dVal ; return true ; case MPA_SIDESTEP : m_dSideStep = dVal ; return true ; case MPA_SIDEANGLE : m_dSideAngle = dVal ; return true ; case MPA_LITANG : m_dLiTang = dVal ; return true ; case MPA_LIPERP : m_dLiPerp = dVal ; return true ; case MPA_LOTANG : m_dLoTang = dVal ; return true ; case MPA_LOPERP : m_dLoPerp = dVal ; return true ; case MPA_APPROX : m_dApprox = dVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SurfFinishingData::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 SurfFinishingData::ResetTool( void) { m_sToolName.clear() ; m_ToolUuid.Clear() ; return true ; } //---------------------------------------------------------------------------- bool SurfFinishingData::GetParam( int nType, bool& bVal) const { switch ( nType) { case MPA_INVERT : bVal = m_bInvert ; return true ; } bVal = false ; return false ; } //---------------------------------------------------------------------------- bool SurfFinishingData::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_TYPE : nVal = MT_SURFFINISHING ; return true ; case MPA_SUBTYPE : nVal = m_nSubType ; return true ; case MPA_LEADINTYPE : nVal = m_nLeadInType ; return true ; case MPA_LEADOUTTYPE : nVal = m_nLeadOutType ; return true ; case MPA_SCC : nVal = m_nSolCh ; return true ; } nVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SurfFinishingData::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_OFFSR : dVal = m_dOffsR ; return true ; case MPA_STARTPOS : dVal = m_dStartPos ; return true ; case MPA_OVERL : dVal = m_dOverlap ; return true ; case MPA_SIDESTEP : dVal = m_dSideStep ; return true ; case MPA_SIDEANGLE : dVal = m_dSideAngle ; return true ; case MPA_LITANG : dVal = m_dLiTang ; return true ; case MPA_LIPERP : dVal = m_dLiPerp ; return true ; case MPA_LOTANG : dVal = m_dLoTang ; return true ; case MPA_LOPERP : dVal = m_dLoPerp ; return true ; case MPA_APPROX : dVal = m_dApprox ; return true ; } dVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SurfFinishingData::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 ; }