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

EgtMachKernel 2.1g2 :

Browse Source 
- aggiunta lavorazione WaterJet e relativo utensile.
This commit is contained in:
Dario Sassi
2019-07-10 12:53:20 +00:00
parent 404105518f
commit 30476aa412
12 changed files with 3276 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtMachKernel.rc
BIN
View File
Binary file not shown.
EgtMachKernel.vcxproj
+4
View File
@@ -287,6 +287,8 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClCompile Include="Table.cpp" />
<ClCompile Include="ToolData.cpp" />
<ClCompile Include="ToolsMgr.cpp" />
<ClCompile Include="WaterJetting.cpp" />
<ClCompile Include="WaterJettingData.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\Include\EGkAngle.h" />
@@ -429,6 +431,8 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="Table.h" />
<ClInclude Include="ToolData.h" />
<ClInclude Include="ToolsMgr.h" />
<ClInclude Include="WaterJetting.h" />
<ClInclude Include="WaterJettingData.h" />
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtMachKernel.rc" />
EgtMachKernel.vcxproj.filters
+12
View File
@@ -222,6 +222,12 @@
<ClCompile Include="SurfFinishing.cpp">
<Filter>Source Files\Operations</Filter>
</ClCompile>
<ClCompile Include="WaterJettingData.cpp">
<Filter>Source Files\Machinings</Filter>
</ClCompile>
<ClCompile Include="WaterJetting.cpp">
<Filter>Source Files\Operations</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="DllMain.h">
@@ -644,6 +650,12 @@
<ClInclude Include="SurfFinishing.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="WaterJettingData.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="WaterJetting.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtMachKernel.rc">
MachConst.h
+2
View File
@@ -97,6 +97,8 @@ const std::string MILLMAKER_KEY = "MillMaker" ;
const std::string MORTISEMAKER_KEY = "MortiseMaker" ;
// Chiave per generatore disegno scalpelli
const std::string CHISELMAKER_KEY = "ChiselMaker" ;
// Chiave per generatore disegno waterjet
const std::string WATERJETMAKER_KEY = "WaterJetMaker" ;
// Chiave per porta utensili punte a forare (marmo)
const std::string DRILLHOLDER_KEY = "DrillHolder" ;
// Chiave per porta utensili lame (marmo)
MachMgrDBTools.cpp
+3
View File
@@ -522,6 +522,7 @@ MachMgr::UpdateStandardToolDraw( const ToolData* pTdata, int nGenCtx, int nToolC
break ;
case TT_MILL_STD :
case TT_MILL_NOTIP :
case TT_WATERJET :
bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.TOOLHOLDER", sThPath) ;
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.TOTLEN", dTotLen) ;
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.LEN", dLen) ;
@@ -615,6 +616,8 @@ MachMgr::GetToolMakerKeyFromType( int nType) const
return MORTISEMAKER_KEY ;
case TT_CHISEL_STD :
return CHISELMAKER_KEY ;
case TT_WATERJET :
return WATERJETMAKER_KEY ;
case TT_COMPO :
return "" ;
}
MillingData.cpp
+1 -1
View File
@@ -195,7 +195,7 @@ MillingData::CopyFrom( const MachiningData* pMdata)
//----------------------------------------------------------------------------
bool
MillingData::SameAs(const MachiningData* pMdata) const
MillingData::SameAs( const MachiningData* pMdata) const
{
// se coincide con altro -> uguali
if ( pMdata == this)
OperationConst.h
+7 -2
View File
@@ -1,13 +1,14 @@
//----------------------------------------------------------------------------
// EgalTech 2017-2019
//----------------------------------------------------------------------------
// File : OperationConst.h Data : 28.05.19 Versione : 2.1e5
// File : OperationConst.h Data : 08.07.19 Versione : 2.1g2
// Contenuto : Costanti per le operazioni.
//
//
//
// Modifiche : 17.08.17 DS Creazione modulo.
// 25.05.19 DS Aggiunte SurfRoughing e SurfFinishing.
// 25.05.19 DS Aggiunta WaterJetting.
//
//----------------------------------------------------------------------------
@@ -30,7 +31,8 @@ static const std::string s_OpeClass[] = {"",
"EMkGenMachining",
"EMkChiseling",
"EMkSurfRoughing",
"EMkSurfFinishing"} ;
"EMkSurfFinishing",
"EMkWaterJetting"} ;
//----------------------------------------------------------------------------
// Dal tipo numerico restituisce la classe della operazione
@@ -50,6 +52,7 @@ GetOperationClass( int nOpeType)
case OPER_CHISELING : return s_OpeClass[10] ;
case OPER_SURFROUGHING : return s_OpeClass[11] ;
case OPER_SURFFINISHING : return s_OpeClass[12] ;
case OPER_WATERJETTING : return s_OpeClass[13] ;
}
return s_OpeClass[0] ;
}
@@ -83,6 +86,8 @@ GetOperationType( const std::string& sOpeClass)
return OPER_SURFROUGHING ;
else if ( sOpeClass == s_OpeClass[12])
return OPER_SURFFINISHING ;
else if ( sOpeClass == s_OpeClass[13])
return OPER_WATERJETTING ;
else
return OPER_NULL ;
}
ToolsMgr.cpp
+10 -4
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2017
// EgalTech 2015-2019
//----------------------------------------------------------------------------
// File : ToolsMgr.cpp Data : 02.03.17 Versione : 1.8c1
// File : ToolsMgr.cpp Data : 08.07.19 Versione : 2.1g2
// Contenuto : Implementazione gestore database utensili.
//
//
@@ -10,6 +10,7 @@
// 21.10.15 DS Aggiunti VERSION e TOOLSIZE in HEADER (default VERSION = 1000 e TOOLSIZE = 26).
// Ora VERSION = 1001 e TOOLSIZE = 29.
// 02.03.17 DS Aggiunto controllo nome.
// 08.07.19 DS Aggiunto water jet. Ora VERSION = 1002.
//
//----------------------------------------------------------------------------
@@ -35,7 +36,7 @@ const string TF_HEADER = "[HEADER]" ;
const string TF_VERSION = "VERSION" ;
const string TF_TOOLSIZE = "TOOLSIZE" ;
const string TF_TOTAL = "TOTAL" ;
const int TF_CURR_VER = 1001 ;
const int TF_CURR_VER = 1002 ;
//----------------------------------------------------------------------------
ToolsMgr::ToolsMgr( void)
@@ -700,7 +701,12 @@ ToolsMgr::GetCurrToolMaxDepth( double& dMaxDepth) const
dMaxDepth = m_tdCurrTool.m_dMaxMat ;
return true ;
}
// utensile composito
// se utensile waterjet
else if ( ( m_tdCurrTool.m_nType & TF_WATERJET) != 0) {
dMaxDepth = m_tdCurrTool.m_dMaxMat ;
return true ;
}
// se utensile composito
else if ( ( m_tdCurrTool.m_nType & TF_COMPO) != 0) {
// non ancora gestito
return false ;
WaterJetting.cpp
+2239
View File
File diff suppressed because it is too large Load Diff
WaterJetting.h
+125
View File
@@ -0,0 +1,125 @@
//----------------------------------------------------------------------------
// EgalTech 2019-2019
//----------------------------------------------------------------------------
// File : WaterJetting.h Data : 08.07.19 Versione : 2.1gf2
// Contenuto : Dichiarazione della classe WaterJetting.
//
//
//
// Modifiche : 08.07.19 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "Machining.h"
#include "WaterJettingData.h"
#include "ToolData.h"
#include "/EgtDev/Include/EGkCurve.h"
class ICurveComposite ;
//----------------------------------------------------------------------------
class WaterJetting : public Machining
{
public : // IUserObj
WaterJetting* 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_WATERJETTING ; }
bool IsEmpty( void) const override
{ return ( m_nMills == 0) ; }
bool UpdateStatus( int nModif) override
{ m_nStatus |= nModif ; return true ; }
protected : // Operation
int GetSolCh( void) const override
{ return m_Params.m_nSolCh ; }
bool AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const override ;
bool AdjustArcCenterForAxesCalc( const CamData* pCamData, Point3d& ptCen) const override ;
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 :
WaterJetting( void) ;
private :
bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
bool Chain( int nGrpDestId) ;
bool ProcessPath( int nPathId, int nPvId, int nClId) ;
bool CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) const ;
bool GenerateMillingPv( int nPathId, const ICurveComposite* pCompo) ;
bool AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, bool bSplitArcs) ;
bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bOutStart, bool bAboveStart) ;
bool AddDirectApproach( const Point3d& ptP) ;
bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bAboveEnd) ;
bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const ;
bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
const Vector3d& vtN, bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs) ;
bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, double dEndElev,
bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs, Point3d& ptP1) ;
double GetRadiusForStartEndElevation( void) const ;
bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev) const ;
bool GetPointAboveRaw( const Point3d& ptP) const ;
bool CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU) ;
Vector3d CalcCorrDir( const ICurveComposite* pCompo, double dU) ;
bool CalcOffset( ICurveComposite* pCompo, double dSignOffs) ;
private :
double GetSpeed() const
{ return ( IsNullAngValue( m_Params.m_dSpeed) ? m_TParams.m_dSpeed : m_Params.m_dSpeed) ; }
double GetFeed() const
{ return ( IsNullLenValue( m_Params.m_dFeed) ? m_TParams.m_dFeed : m_Params.m_dFeed) ; }
double GetStartFeed() const
{ return ( IsNullLenValue( m_Params.m_dStartFeed) ? m_TParams.m_dStartFeed : m_Params.m_dStartFeed) ; }
double GetEndFeed() const
{ return ( IsNullLenValue( m_Params.m_dEndFeed) ? m_TParams.m_dEndFeed : m_Params.m_dEndFeed) ; }
double GetTipFeed() const
{ return ( IsNullLenValue( m_Params.m_dTipFeed) ? m_TParams.m_dTipFeed : m_Params.m_dTipFeed) ; }
double GetOffsL() const
{ return ( IsUnknownValue( m_Params.m_dOffsL) ? m_TParams.m_dOffsL : m_Params.m_dOffsL) ; }
double GetOffsR() const
{ return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
int GetLeadInType( void) const ;
int GetLeadOutType( void) const ;
friend class LeadIOStatus ;
private :
SELVECTOR m_vId ; // identificativi entità geometriche da lavorare
WaterJettingData m_Params ; // parametri lavorazione
ToolData m_TParams ; // parametri utensile
double m_dTHoldLen ; // lunghezza del porta-utensile
double m_dTHoldDiam ; // diametro del porta-utensile
int m_nStatus ; // stato di aggiornamento della lavorazione
int m_nMills ; // numero di percorsi di lavoro generati
int m_nHeadSolCh ; // criterio scelta soluzione impostato nella testa
} ;
WaterJettingData.cpp
+779
View File
@@ -0,0 +1,779 @@
//----------------------------------------------------------------------------
// EgalTech 2019-2019
//----------------------------------------------------------------------------
// File : WaterJettingData.cpp Data : 08.07.19 Versione : 2.1g2
// Contenuto : Implementazione struttura dati lavorazione di taglio water jet.
//
//
//
// Modifiche : 08.07.19 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "WaterJettingData.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 nWaterJetting {
KEY_AB = 0,
KEY_AI,
KEY_DH,
KEY_EAL,
KEY_F,
KEY_FE,
KEY_FS,
KEY_FT,
KEY_INV,
KEY_LICL,
KEY_LIEL,
KEY_LIPR,
KEY_LITG,
KEY_LITY,
KEY_LOCL,
KEY_LOEL,
KEY_LOPR,
KEY_LOTG,
KEY_LOTY,
KEY_NAME,
KEY_NNS,
KEY_NNU,
KEY_OL,
KEY_OR,
KEY_OVL,
KEY_PS,
KEY_S,
KEY_SA,
KEY_SAL,
KEY_SCC,
KEY_TNAME,
KEY_TUUID,
KEY_UUID,
KEY_WS,
KEY_ZZZ} ; // rappresenta il numero di elementi
static const std::array<std::string,KEY_ZZZ> sWaterJettingKey = {
"AB",
"AI",
"DH",
"EAL",
"F",
"FE",
"FS",
"FT",
"INV",
"LICL",
"LIEL",
"LIPR",
"LITG",
"LITY",
"LOCL",
"LOEL",
"LOPR",
"LOTG",
"LOTY",
"NAME",
"NNS",
"NNU",
"OL",
"OR",
"OVL",
"PS",
"S",
"SA",
"SAL",
"SCC",
"TN",
"TU",
"UUID",
"WS"} ;
//----------------------------------------------------------------------------
MCHDATA_REGISTER( MT_WATERJETTING, "WATERJETTING", WaterJettingData) ;
//----------------------------------------------------------------------------
WaterJettingData*
WaterJettingData::Clone( void) const
{
// alloco oggetto
WaterJettingData* pMdata = new(nothrow) WaterJettingData ;
// copio i dati
if ( pMdata != nullptr) {
if ( ! pMdata->CopyFrom( this)) {
delete pMdata ;
return nullptr ;
}
}
return pMdata ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::CopyFrom( const MachiningData* pMdata)
{
// è inutile copiare se sorgente coincide con destinazione
if ( pMdata == this)
return true ;
// la sorgente deve essere dello stesso tipo
const WaterJettingData* pSdata = GetWaterJettingData( 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_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_dSideAngle = pSdata->m_dSideAngle ;
m_dStartAddLen = pSdata->m_dStartAddLen ;
m_dEndAddLen = pSdata->m_dEndAddLen ;
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
WaterJettingData::SameAs( const MachiningData* pMdata) const
{
// se coincide con altro -> uguali
if ( pMdata == this)
return true ;
// se sono di tipo diverso -> diversi
const WaterJettingData* pSdata = GetWaterJettingData( 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_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_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_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
WaterJettingData::GetSize( void) const
{
// in debug verifico validità ultimo campo
assert( sWaterJettingKey[KEY_WS] == "WS") ;
return KEY_ZZZ ;
}
//----------------------------------------------------------------------------
string
WaterJettingData::GetTitle( void) const
{
return MCHDATA_GETNAME( WaterJettingData) ;
}
//----------------------------------------------------------------------------
int
FindWaterJettingKey( const string& sKey)
{
auto TheRange = equal_range( sWaterJettingKey.cbegin(), sWaterJettingKey.cend(), sKey) ;
if ( TheRange.first == TheRange.second)
return - 1 ;
return int( TheRange.first - sWaterJettingKey.cbegin()) ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::FromString( const string& sString, int& nKey)
{
// separo chiave da valore
string sKey, sVal ;
SplitFirst( sString, "=", sKey, sVal) ;
// riconosco la chiave
nKey = FindWaterJettingKey( 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_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_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_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_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
WaterJettingData::ToString( int nInd) const
{
switch ( nInd) {
case KEY_AB : return ( sWaterJettingKey[KEY_AB] + "=" + m_sBlockedAxis) ;
case KEY_AI : return ( sWaterJettingKey[KEY_AI] + "=" + m_sInitAngs) ;
case KEY_DH : return ( sWaterJettingKey[KEY_DH] + "=" + m_sDepth) ;
case KEY_EAL : return ( sWaterJettingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ;
case KEY_F : return ( sWaterJettingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
case KEY_FE : return ( sWaterJettingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ;
case KEY_FS : return ( sWaterJettingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ;
case KEY_FT : return ( sWaterJettingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
case KEY_INV : return ( sWaterJettingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
case KEY_LICL : return ( sWaterJettingKey[KEY_LICL] + "=" + ::ToString( m_dLiCompLen)) ;
case KEY_LIEL : return ( sWaterJettingKey[KEY_LIEL] + "=" + ::ToString( m_dLiElev)) ;
case KEY_LIPR : return ( sWaterJettingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ;
case KEY_LITG : return ( sWaterJettingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ;
case KEY_LITY : return ( sWaterJettingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ;
case KEY_LOCL : return ( sWaterJettingKey[KEY_LOCL] + "=" + ::ToString( m_dLoCompLen)) ;
case KEY_LOEL : return ( sWaterJettingKey[KEY_LOEL] + "=" + ::ToString( m_dLoElev)) ;
case KEY_LOPR : return ( sWaterJettingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ;
case KEY_LOTG : return ( sWaterJettingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ;
case KEY_LOTY : return ( sWaterJettingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ;
case KEY_NAME : return ( sWaterJettingKey[KEY_NAME] + "=" + m_sName) ;
case KEY_NNS : return ( sWaterJettingKey[KEY_NNS] + "=" + m_sSysNotes) ;
case KEY_NNU : return ( sWaterJettingKey[KEY_NNU] + "=" + m_sUserNotes) ;
case KEY_OL : return ( sWaterJettingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ;
case KEY_OR : return ( sWaterJettingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ;
case KEY_OVL : return ( sWaterJettingKey[KEY_OVL] + "=" + ::ToString( m_dOverlap)) ;
case KEY_PS : return ( sWaterJettingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
case KEY_S : return ( sWaterJettingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ;
case KEY_SA : return ( sWaterJettingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ;
case KEY_SAL : return ( sWaterJettingKey[KEY_SAL] + "=" + ::ToString( m_dStartAddLen)) ;
case KEY_SCC : return ( sWaterJettingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ;
case KEY_TNAME : return ( sWaterJettingKey[KEY_TNAME] + "=" + m_sToolName) ;
case KEY_TUUID : return ( sWaterJettingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
case KEY_UUID : return ( sWaterJettingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
case KEY_WS : return ( sWaterJettingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ;
default : return "" ;
}
}
//----------------------------------------------------------------------------
bool
WaterJettingData::IsOptional( int nKey) const
{
return false ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::VerifySolCh( int nVal) const
{
return IsValidOperationScc( nVal) ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::VerifyWorkSide( int nVal) const
{
return ( nVal == MILL_WS_CENTER || nVal == MILL_WS_LEFT || nVal == MILL_WS_RIGHT) ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::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) ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::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
WaterJettingData::VerifySideAngle( double dVal) const
{
return ( ( dVal > - EPS_SMALL && dVal < 90 + EPS_SMALL) || abs( dVal - 99) < EPS_SMALL) ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::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_WATERJET) == 0)
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const
{
if ( pToolsMgr == nullptr)
return false ;
pTdata = pToolsMgr->GetTool( m_ToolUuid) ;
return ( pTdata != nullptr) ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::SetParam( int nType, bool bVal)
{
switch ( nType) {
case MPA_INVERT :
m_bInvert = bVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::SetParam( int nType, int nVal)
{
switch ( nType) {
case MPA_WORKSIDE :
if ( ! VerifyWorkSide( nVal))
return false ;
m_nWorkSide = 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_SCC :
if ( ! VerifySolCh( nVal))
return false ;
m_nSolCh = nVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::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_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_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
WaterJettingData::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
WaterJettingData::ResetTool( void)
{
m_sToolName.clear() ;
m_ToolUuid.Clear() ;
return true ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::GetParam( int nType, bool& bVal) const
{
switch ( nType) {
case MPA_INVERT :
bVal = m_bInvert ;
return true ;
}
bVal = false ;
return false ;
}
//----------------------------------------------------------------------------
bool
WaterJettingData::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_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
WaterJettingData::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_SIDEANGLE :
dVal = m_dSideAngle ;
return true ;
case MPA_STARTADDLEN :
dVal = m_dStartAddLen ;
return true ;
case MPA_ENDADDLEN :
dVal = m_dEndAddLen ;
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
WaterJettingData::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 ;
}
WaterJettingData.h
+94
View File
@@ -0,0 +1,94 @@
//----------------------------------------------------------------------------
// EgalTech 2019-2019
//----------------------------------------------------------------------------
// File : WaterJettingData.h Data : 08.07.19 Versione :2.1g2
// Contenuto : Dichiarazione della struct WaterJettingData e costanti associate.
//
//
//
// Modifiche : 08.07.19 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "MachiningData.h"
//----------------------------------------------------------------------------
struct WaterJettingData : public MachiningData
{
EgtUUID m_ToolUuid ; // identificativo universale dell'utensile
std::string m_sToolName ; // nome dell'utensile
std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2)
std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val)
int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici)
double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile)
double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile)
double m_dStartFeed ; // velocità di lavorazione iniziale ( se 0 da utensile)
double m_dEndFeed ; // velocità di lavorazione finale ( se 0 da utensile)
double m_dTipFeed ; // velocità di lavorazione di testa ( se 0 da utensile)
double m_dOffsR ; // offset radiale ( se UNKNOWN_PAR da utensile)
double m_dOffsL ; // offset longitudinale ( se UNKNOWN_PAR da utensile)
bool m_bInvert ; // flag di inversione direzione lavorazione
int m_nWorkSide ; // lato di lavoro (destra, sinistra, centro)
std::string m_sDepth ; // affondamento (espressione numerica)
double m_dStartPos ; // quota di inizio lavorazione (sempre >= 0)
double m_dOverlap ; // lunghezza di sovrapposizione se percorso chiuso
double m_dSideAngle ; // angolo di sbandamento (0-60deg)
double m_dStartAddLen ; // lunghezza da aggiungere/togliere all'inizio
double m_dEndAddLen ; // lunghezza da aggiungere/togliere alla fine
int m_nLeadInType ; // tipo di attacco (nessuno, lineare, tangente, inseguimento)
double m_dLiTang ; // distanza tangente da inizio attacco
double m_dLiPerp ; // distanza perpendicolare da inizio attacco
double m_dLiElev ; // elevazione da inizio attacco
double m_dLiCompLen ; // lunghezza del tratto di inserimento correttore raggio utensile
int m_nLeadOutType ; // tipo di uscita (come attacco, nessuno, lineare, tangente, inseguimento)
double m_dLoTang ; // distanza tangente verso fine uscita
double m_dLoPerp ; // distanza perpendicolare verso fine uscita
double m_dLoElev ; // elevazione verso fine uscita
double m_dLoCompLen ; // lunghezza del tratto di disinserimento correttore raggio utensile
std::string m_sSysNotes ; // note interne
std::string m_sUserNotes ; // note dell'utente
WaterJettingData( void)
: m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0),
m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR),
m_bInvert( false), m_nWorkSide( 0),
m_dStartPos( 0), m_dOverlap( 0), m_dSideAngle( 0),
m_dStartAddLen( 0), m_dEndAddLen( 0),
m_nLeadInType( 0), m_dLiTang( 0), m_dLiPerp( 0), m_dLiElev( 0), m_dLiCompLen( 0),
m_nLeadOutType( 0), m_dLoTang( 0), m_dLoPerp( 0), m_dLoElev( 0), m_dLoCompLen( 0) {}
WaterJettingData* Clone( void) const override ;
bool CopyFrom( const MachiningData* pMdata) override ;
bool SameAs(const MachiningData* pMdata) const override ;
int GetType( void) const override
{ return MT_WATERJETTING ; }
int GetSize( void) const override ;
std::string GetTitle( void) const override ;
bool FromString( const std::string& sString, int& nKey) override ;
std::string ToString( int nInd) 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 ;
bool VerifyWorkSide( int nVal) const ;
bool VerifyLeadInType( int nVal) const ;
bool VerifyLeadOutType( int nVal) const ;
bool VerifySideAngle( double dVal) const ;
} ;
//----------------------------------------------------------------------------
inline const WaterJettingData* GetWaterJettingData( const MachiningData* pMdata)
{ return (dynamic_cast<const WaterJettingData*>( pMdata)) ; }
inline WaterJettingData* GetWaterJettingData( MachiningData* pMdata)
{ return (dynamic_cast<WaterJettingData*>( pMdata)) ; }