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

Merge remote-tracking branch 'origin/HEAD' into feature/SvuotatureConIsole

Browse Source
This commit is contained in:
SaraP
2021-08-26 08:36:14 +02:00
parent 83cbe5b299 b18c309344
commit 260b35c7e3
4 changed files with 110 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Disposition.cpp
+1 -1
View File
@@ -306,7 +306,7 @@ Disposition::Load( const STRVECTOR& vString, int nBaseGdbId)
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
Disposition::Disposition( void)
: m_bTabOk( false), m_nExit( 0), m_nStatus( MCH_ST_TO_VERIFY), m_nShifts( 0), m_bSomeByHand( false), m_dAreaOffset({{0,0,0,0}})
: m_bTabOk( false), m_dAreaOffset({{0,0,0,0}}), m_nExit( 0), m_nStatus( MCH_ST_TO_VERIFY), m_nShifts( 0), m_bSomeByHand( false)
{
}
EgtMachKernel.rc
BIN
View File
Binary file not shown.
MachineLua.cpp
+3 -3
View File
@@ -589,7 +589,7 @@ Machine::LuaEmtStdHead( lua_State* L)
double dRot1W = 1 ;
LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
// lettura eventuale campo 'Rot2Stroke' dalla tabella
STROKE Rot2Stroke{ -INFINITO, INFINITO} ;
STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
// lettura eventuale campo 'SolCh' dalla tabella
int nSolCh = MCH_SCC_NONE ;
@@ -667,7 +667,7 @@ Machine::LuaEmtMultiHead( lua_State* L)
double dRot1W = 1 ;
LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
// lettura eventuale campo 'Rot2Stroke' dalla tabella
STROKE Rot2Stroke{ -INFINITO, INFINITO} ;
STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
// lettura eventuale campo 'SolCh' dalla tabella
int nSolCh = MCH_SCC_NONE ;
@@ -734,7 +734,7 @@ Machine::LuaEmtSpecialHead( lua_State* L)
double dRot1W = 1 ;
LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
// lettura eventuale campo 'Rot2Stroke' dalla tabella
STROKE Rot2Stroke{ -INFINITO, INFINITO} ;
STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
// lettura eventuale campo 'SolCh' dalla tabella
int nSolCh = MCH_SCC_NONE ;
Milling.cpp
+106 -54
View File
@@ -2243,10 +2243,14 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL)
dStElev = min( dStElev, dNewStElev) ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ;
@@ -2356,10 +2360,14 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL)
dEndElev = min( dEndElev, dNewEndElev) ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
@@ -2462,7 +2470,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
double dStElev ;
if ( j == 1) {
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
dStElev = dStep ;
}
else
dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ;
@@ -2479,10 +2487,14 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
// se primo step aggiungo approccio per frese normali
if ( j == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL)
dStElev = min( dStElev, dNewStElev) ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ;
@@ -2606,10 +2618,14 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL)
dEndElev = min( dEndElev, dNewEndElev) ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
@@ -2718,6 +2734,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
if ( ! bAboveStartEnd)
dStElev = max( dStElev, j * dStep) ;
// determino inizio attacco
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1))
return false ;
@@ -2726,10 +2744,14 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL)
dStElev = min( dStElev, dNewStElev) ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ;
@@ -2827,6 +2849,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
if ( ! bAboveStartEnd)
dEndElev = max( dEndElev, j * dStep) ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
@@ -2837,10 +2861,14 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
// aggiungo retrazione per frese normali (esclusi step intermedi senza retrazione)
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0 && ( j == nStep || bMidRetract)) {
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL)
dEndElev = min( dEndElev, dNewEndElev) ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
@@ -2931,10 +2959,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL)
dStElev = min( dStElev, dNewStElev) ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ;
@@ -3030,10 +3062,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL)
dEndElev = min( dEndElev, dNewEndElev) ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
@@ -3095,10 +3131,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL)
dStElev = min( dStElev, dNewStElev) ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
@@ -3193,10 +3233,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
Vector3d vtEscape = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL)
dEndElev = min( dEndElev, dNewEndElev) ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
@@ -3717,7 +3761,8 @@ Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const
case MILL_LI_LINEAR :
case MILL_LI_TANGENT : {
Vector3d vtPerp = vtStart ;
vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
Vector3d vtRot = vtN - vtN * vtStart * vtStart ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtN * dElev ;
return true ;
}
@@ -4005,7 +4050,8 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
case MILL_LO_LINEAR :
{
Vector3d vtPerp = vtEnd ;
vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
Vector3d vtRot = vtN - vtN * vtEnd * vtEnd ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ;
return ( AddLinearMove( ptP1, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
@@ -4013,7 +4059,8 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
{
// calcolo punto finale dell'uscita
Vector3d vtPerp = vtEnd ;
vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
Vector3d vtRot = vtN - vtN * vtEnd * vtEnd ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ;
// inserisco uscita
PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ;
@@ -5001,8 +5048,8 @@ Milling::GetRadiusForStartEndElevation( bool bExtra) const
if ( ! bExtra)
return ( 0.5 * m_TParams.m_dTDiam) ;
// aumentato
const double DELTA_ELEV_RAD = 20.0 ;
double dDeltaRad = DELTA_ELEV_RAD + max( max( m_Params.m_dStartAddLen, m_Params.m_dEndAddLen), 0.0) ;
const double DELTA_ELEV_RAD = 2.0 ;
double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ;
return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ;
}
@@ -5167,22 +5214,27 @@ Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs)
}
if ( m_Params.m_bLeaveTab || m_Params.m_bOscEnable)
nFlag |= ICurve::OFF_MEDIA_INTDZ ;
// eseguo offset semplice
if ( pCompo->SimpleOffset( dSignOffs, nFlag))
return true ;
// se curva piatta, provo con offset avanzato
bool bOk = false ;
// determino se curva piatta e recupero suo vettore estrusione
Plane3d plPlane ;
if ( pCompo->IsFlat( plPlane, true, 100 * EPS_SMALL)) {
bool bIsFlat = pCompo->IsFlat( plPlane, false, 10 * EPS_SMALL) ;
Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;
// se curva piatta con estrusione non perpendicolare forzo offset avanzato
bool bAdvOffs = ( bIsFlat && abs( vtExtr * plPlane.GetVersN()) < cos( 0.1 * DEGTORAD)) ;
// eseguo offset semplice
if ( ! bAdvOffs && pCompo->SimpleOffset( dSignOffs, nFlag))
return true ;
// eseguo offset avanzato
if ( bIsFlat) {
OffsetCurve OffsCrv ;
if ( OffsCrv.Make( pCompo, dSignOffs, nFlag)) {
ICurve* pOffs = OffsCrv.GetLongerCurve() ;
if ( pOffs != nullptr) {
pCompo->Clear() ;
pCompo->AddCurve( pOffs) ;
bOk = true ;
pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ;
return true ;
}
}
}
return bOk ;
return false ;
}