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

EgtMachKernel 1.6k8 :

Browse Source 
- modifiche per tagli di lama inclinati.
This commit is contained in:
Dario Sassi
2015-11-20 13:41:10 +00:00
parent 843282c234
commit 8dd67afcb7
10 changed files with 156 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtMachKernel.rc
BIN
View File
Binary file not shown.
MachMgr.h
+1
View File
@@ -183,6 +183,7 @@ class MachMgr : public IMachMgr
int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) ;
virtual bool GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB,
int& nStat, double& dX, double& dY, double& dZ) ;
virtual bool GetNearestAngleInStroke( int nId, double dAngRef, double& dAng) ;
virtual bool VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) ;
// Machine Move
virtual bool SetAxisPos( const std::string& sAxis, double dVal) ;
MachMgrMachines.cpp
+10
View File
@@ -299,6 +299,16 @@ MachMgr::GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB,
return m_vMachines[m_nCurrMch].pMachine->GetPositions( ptP, dAngA, dAngB, nStat, dX, dY, dZ) ;
}
//----------------------------------------------------------------------------
bool
MachMgr::GetNearestAngleInStroke( int nId, double dAngRef, double& dAng)
{
if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) ||
m_vMachines[m_nCurrMch].pMachine == nullptr)
return false ;
return m_vMachines[m_nCurrMch].pMachine->GetNearestAngleInStroke( nId, dAngRef, dAng) ;
}
//----------------------------------------------------------------------------
bool
MachMgr::VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat)
Machine.h
+1
View File
@@ -64,6 +64,7 @@ class Machine
int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) ;
bool GetPositions( const Point3d& ptP, double dA, double dB,
int& nStat, double& dX, double& dY, double& dZ) ;
bool GetNearestAngleInStroke( int nId, double dAngRef, double& dAng) ;
bool VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) ;
bool LuaCallFunction( const std::string& sFun) ;
bool LuaCreateGlobTable( const std::string& sName) ;
MachineCalc.cpp
+29
View File
@@ -469,6 +469,35 @@ Machine::AdjustAngleInStroke( int nId, double& dAng)
return false ;
}
//----------------------------------------------------------------------------
bool
Machine::GetNearestAngleInStroke( int nId, double dAngRef, double& dAng)
{
// se non ci sono assi rotanti, non c'è alcunchè da fare
if ( m_vCalcRotAx.size() == 0)
return true ;
// se primo angolo ed esiste primo asse rotante
if ( nId == 1 && m_vCalcRotAx.size() >= 1) {
while ( dAng - dAngRef > ANG_STRAIGHT && dAng - ANG_FULL >= m_vCalcRotAx[0].stroke.Min)
dAng -= ANG_FULL ;
while ( dAng - dAngRef < - ANG_STRAIGHT && dAng + ANG_FULL <= m_vCalcRotAx[0].stroke.Max)
dAng += ANG_FULL ;
return ( dAng >= m_vCalcRotAx[0].stroke.Min &&
dAng <= m_vCalcRotAx[0].stroke.Max) ;
}
// se secondo angolo ed esiste secondo asse rotante
if ( nId == 2 && m_vCalcRotAx.size() >= 2) {
while ( dAng - dAngRef > ANG_STRAIGHT && dAng - ANG_FULL >= m_vCalcRotAx[1].stroke.Min)
dAng -= ANG_FULL ;
while ( dAng - dAngRef < - ANG_STRAIGHT && dAng + ANG_FULL <= m_vCalcRotAx[1].stroke.Max)
dAng += ANG_FULL ;
return ( dAng >= m_vCalcRotAx[1].stroke.Min &&
dAng <= m_vCalcRotAx[1].stroke.Max) ;
}
// errore
return false ;
}
//----------------------------------------------------------------------------
bool
Machine::VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat)
Machining.cpp
+11
View File
@@ -441,7 +441,18 @@ Machining::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes,
pCamData->SetAxes( CamData::AS_ERR, vAxVal) ;
continue ;
}
if ( nRStat == 1) {
// porto gli angoli ai valori più vicini ai precedenti con offset di uno o più giri
m_pMchMgr->GetNearestAngleInStroke( 1, dAngAprec, dAngA1) ;
m_pMchMgr->GetNearestAngleInStroke( 2, dAngBprec, dAngB1) ;
}
if ( nRStat == 2) {
// porto gli angoli ai valori più vicini ai precedenti con offset di uno o più giri
m_pMchMgr->GetNearestAngleInStroke( 1, dAngAprec, dAngA1) ;
m_pMchMgr->GetNearestAngleInStroke( 2, dAngBprec, dAngB1) ;
m_pMchMgr->GetNearestAngleInStroke( 1, dAngAprec, dAngA2) ;
m_pMchMgr->GetNearestAngleInStroke( 2, dAngBprec, dAngB2) ;
// scelgo la soluzione più vicina ai precedenti
double dDeltaA1 = dRot1W * fabs( dAngA1 - dAngAprec) ;
double dDeltaB1 = fabs( dAngB1 - dAngBprec) ;
double dDeltaA2 = dRot1W * fabs( dAngA2 - dAngAprec) ;
Machining.h
+1 -1
View File
@@ -51,7 +51,7 @@ class Machining : public IUserObj
Machining( void) ;
protected :
double GetApproachDist( void) { return 30.0 ; }
double GetApproachDist( void) { return 60.0 ; }
bool GetElevation( const Point3d& ptP, const Vector3d& vtDir, double& dElev) ;
bool GetElevation( const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtDir, double& dElev) ;
bool GetFinalAxesValues( DBLVECTOR& vAxVal) ;
Sawing.cpp
+99 -13
View File
@@ -329,6 +329,10 @@ Sawing::Apply( void)
else
m_pGeomDB->EmptyGroup( nAuxId) ;
// verifiche per angolo di sbandamento
if ( ! VerifySideAngle())
return false ;
// eseguo concatenamento, inserisco i percorsi sotto la geometria ausiliaria
if ( ! Chain( nAuxId))
return false ;
@@ -543,6 +547,51 @@ Sawing::GetCurve( SelData Id)
return Release( pCurve) ;
}
//----------------------------------------------------------------------------
bool
Sawing::VerifySideAngle( void)
{
// verifiche per angolo di sbandamento
if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) {
// non ammesso lato di lavoro in centro
if ( m_Params.m_nWorkSide == SAW_WS_CENTER) {
LOG_INFO( GetEMkLogger(), "Center work not allowed with side angle") ;
return false ;
}
// se angolo esterno lato mandrino deve uguagliare lato di lavoro
if ( m_Params.m_dSideAngle > 0) {
if ( m_Params.m_nWorkSide == SAW_WS_RIGHT) {
if ( m_Params.m_nHeadSide == SAW_HS_LEFT) {
LOG_INFO( GetEMkLogger(), "External side angle HeadSide must equal WorkSide") ;
m_Params.m_nHeadSide = SAW_HS_RIGHT ;
}
}
if ( m_Params.m_nWorkSide == SAW_WS_LEFT) {
if ( m_Params.m_nHeadSide == SAW_HS_RIGHT) {
LOG_INFO( GetEMkLogger(), "External side angle HeadSide must equal WorkSide") ;
m_Params.m_nHeadSide = SAW_HS_LEFT ;
}
}
}
// altrimenti angolo interno, lato mandrino deve essere opposto a lato di lavoro
else {
if ( m_Params.m_nWorkSide == SAW_WS_RIGHT) {
if ( m_Params.m_nHeadSide == SAW_HS_RIGHT) {
LOG_INFO( GetEMkLogger(), "Internal side angle HeadSide must opposite WorkSide") ;
m_Params.m_nHeadSide = SAW_HS_LEFT ;
}
}
if ( m_Params.m_nWorkSide == SAW_WS_LEFT) {
if ( m_Params.m_nHeadSide == SAW_HS_LEFT) {
LOG_INFO( GetEMkLogger(), "Internal side angle HeadSide must opposite WorkSide") ;
m_Params.m_nHeadSide = SAW_HS_RIGHT ;
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Sawing::Chain( int nGrpDestId)
@@ -721,7 +770,21 @@ Sawing::PathApply( int nPathId, int nClId)
ExeLuaExecLine( sExec) ;
double dDepth ;
if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) {
string sOut = "Depth non calculable by Sawing" ;
string sOut = "Depth not computable by Sawing" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
return false ;
}
// correzione per angolo di fianco
if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) {
// generale
dDepth /= cos( m_Params.m_dSideAngle * DEGTORAD) ;
// se sottosquadra (controllo il lato opposto della lama, quindi ...)
if ( m_Params.m_dSideAngle < 0)
dDepth += m_TParams.m_dThick * tan( abs( m_Params.m_dSideAngle) * DEGTORAD) ;
}
// verifico di non superare il massimo materiale
if ( dDepth > m_TParams.m_dMaxMat) {
string sOut = "Depth bigger than MaxMaterial" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
return false ;
}
@@ -770,13 +833,13 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr
// calcolo i versori fresa e correzione
Vector3d vtTool, vtCorr ;
if ( ! CalculateToolAndCorrVersors( Get( pLine), vtTool, vtCorr)) {
string sOut = "Entity non versorable by Sawing" ;
string sOut = "Entity not versorable by Sawing" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
return false ;
}
// correzioni per lato lama, lato mandrino
if ( ! AdjustForSide( Get( pLine))) {
string sOut = "Entity non offsetable by Sawing" ;
string sOut = "Entity not offsetable by Sawing" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
return false ;
}
@@ -785,7 +848,7 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr
// calcolo elevazione
double dElev ;
if ( ! GetElevation( pLine->GetStart(), pLine->GetEnd(), vtCorr, dElev)) {
string sOut = "Entity non elevation-enabled by Sawing" ;
string sOut = "Entity not elevation-enabled by Sawing" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
return false ;
}
@@ -818,6 +881,9 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr
AdjustForEdges( Get( pLine), dElev, bIsFirst, bIsLast, bExtAngPC, bExtAngCN) ;
// recupero distanza di approccio
double dAppr = GetApproachDist() ;
// correzione per angolo di fianco
if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL)
dAppr /= cos( m_Params.m_dSideAngle * DEGTORAD) ;
// imposto dati comuni
SetPathId( nPxId) ;
SetToolDir( vtTool) ;
@@ -848,19 +914,36 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr
bool
Sawing::CalculateToolAndCorrVersors( const ICurve* pCurve, Vector3d& vtTool, Vector3d& vtCorr)
{
// recupero la direzione della linea
pCurve->GetStartDir( vtTool) ;
// annullo la componente in Z e normalizzo
vtTool.z = 0 ;
if ( ! vtTool.Normalize())
// Recupero la direzione della linea e la proietto nel piano XY
Vector3d vtTang ;
pCurve->GetStartDir( vtTang) ;
vtTang.z = 0 ;
if ( ! vtTang.Normalize())
return false ;
// Versore fresa : annullo la componente in Z e normalizzo
vtTool = vtTang ;
// ruoto attorno a Zglob+ a seconda del lato mandrino
if ( m_Params.m_nHeadSide == SAW_HS_LEFT)
vtTool.Rotate( Z_AX, 0, 1) ;
if ( m_Params.m_nHeadSide == SAW_HS_LEFT)
vtTool.Rotate( Z_AX, 90) ;
else
vtTool.Rotate( Z_AX, 0, -1) ;
// versore correzione
vtTool.Rotate( Z_AX, -90) ;
// Versore correzione
vtCorr = Z_AX ;
// Se lama sbandata
if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) {
if ( m_Params.m_nWorkSide == SAW_WS_RIGHT) {
vtTool.Rotate( vtTang, - m_Params.m_dSideAngle) ;
vtCorr.Rotate( vtTang, - m_Params.m_dSideAngle) ;
}
else {
vtTool.Rotate( vtTang, m_Params.m_dSideAngle) ;
vtCorr.Rotate( vtTang, m_Params.m_dSideAngle) ;
}
}
return true ;
}
@@ -882,6 +965,9 @@ Sawing::AdjustForSide( ICurve* pCurve)
dOffs = 0.5 * m_TParams.m_dThick ;
else // testa a destra e lama in centro
dOffs = - 0.5 * m_TParams.m_dThick ;
// correzione per angolo di fianco
if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL)
dOffs /= cos( m_Params.m_dSideAngle * DEGTORAD) ;
// eseguo offset curva ( nel piano XY globale)
return pCurve->SimpleOffset( dOffs) ;
}
Sawing.h
+1
View File
@@ -52,6 +52,7 @@ class Sawing : public Machining
private :
bool VerifyGeometry( SelData Id, int& nSubs) ;
ICurve* GetCurve( SelData Id) ;
bool VerifySideAngle( void) ;
bool Chain( int nGrpDestId) ;
bool PathApply( int nPathId, int nClId) ;
bool EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCrvN,
SawingData.cpp
+3 -1
View File
@@ -300,7 +300,9 @@ SawingData::VerifyCurveUse( int nVal) const
bool
SawingData::VerifySideAngle( double dVal) const
{
return ( ( dVal > - EPS_SMALL && dVal < 60 + EPS_SMALL) || fabs( dVal - 99) < EPS_SMALL) ;
const double MAX_SIDE_ANG = 60 + EPS_ANG_SMALL ;
const double AUTO_SIDE_ANG = 99 ;
return ( ( dVal > - MAX_SIDE_ANG && dVal < MAX_SIDE_ANG) || fabs( dVal - AUTO_SIDE_ANG) < EPS_ANG_SMALL) ;
}
//----------------------------------------------------------------------------