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

Revert "Merge commit '994658da167a7ac3f607f4b535a65febe8f308d1' into svuotature"

Browse Source 
This reverts commit e96f467b56, reversing
changes made to ec1ee961be.
This commit is contained in:
Riccardo Elitropi
2023-06-23 08:38:57 +02:00
parent e96f467b56
commit e04a05831e
7 changed files with 118 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtMachKernel.rc
BIN
View File
Binary file not shown.
Milling.cpp
+46 -73
View File
@@ -45,7 +45,6 @@ using namespace std ;
const double OSC_MIN_LEN = 0.1 ;
const double ELEV_MAX_OFFS = 25.0 ;
const double MIN_SAFEDIST = 5.0 ;
const double LIM_DOWN_APPRZ = - 0.5 ;
//------------------------------ Errors --------------------------------------
// 2301 = "Error in Milling : UpdateToolData failed"
@@ -2377,12 +2376,8 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ;
Vector3d vtAppr2 = ptP1 - ptStart ;
if ( ! vtAppr2.Normalize()) {
if ( ( m_TParams.m_nType & TF_MILL) != 0)
vtAppr2 = -vtStart ;
else
vtAppr2 = CalcCorrDir( pCompo, i) ;
}
if ( ! vtAppr2.Normalize())
vtAppr2 = CalcCorrDir( pCompo, i) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawStartElev1 = -1, dSawStartElev2 = -1 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr1, dSawStartElev1) ;
@@ -2409,7 +2404,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
bOk = false ;
}
// aggiungo opportuno approccio
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr)) {
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, dSafeZ, dSawStartElev, dAppr)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
@@ -2546,12 +2541,8 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ;
Vector3d vtRetr2 = ptP1 - ptEnd ;
if ( ! vtRetr2.Normalize()) {
if ( ( m_TParams.m_nType & TF_MILL) != 0)
vtRetr2 = vtEnd ;
else
vtRetr2 = CalcCorrDir( pCompo, i + 1) ;
}
if ( ! vtRetr2.Normalize())
vtRetr2 = CalcCorrDir( pCompo, i + 1) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawEndElev1, dSawEndElev2 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr1, dSawEndElev1) ;
@@ -2578,7 +2569,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
bOk = false ;
}
// aggiungo opportuna retrazione
if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) {
if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dAppr)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
@@ -2759,7 +2750,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
bOk = false ;
}
// aggiungo opportuno approccio
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr)) {
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, dSafeZ, dSawStartElev, dAppr)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
@@ -2924,7 +2915,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
bOk = false ;
}
// aggiungo opportuna retrazione
if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) {
if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dAppr)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
@@ -3220,7 +3211,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
bOk = false ;
}
// aggiungo opportuno approccio
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr)) {
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, dSafeZ, dSawStartElev, dAppr)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
@@ -3386,7 +3377,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
bOk = false ;
}
// aggiungo opportuna retrazione
if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) {
if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dAppr)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
@@ -4084,42 +4075,16 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
//----------------------------------------------------------------------------
bool
Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, const Vector3d& vtTool,
double dSafeZ, double dSawStElev, double dStElev, double dAppr)
Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, double dSafeZ, double dStElev, double dAppr)
{
// per approccio orizzontale vtAppr deve essere già stato sistemato dal chiamante
SetFlag( 1) ;
// 1a -> punto fuori inizio
Point3d ptP1a = ptP + vtAppr * ( dSawStElev + max( dAppr, dSafeZ)) ;
// se necessario ulteriore approccio
if ( ! m_bTiltingTab && vtAppr.z < LIM_DOWN_APPRZ) {
Vector3d vtMove = Vector3d( vtTool.x, vtTool.y, 0) ;
if ( vtMove.Normalize()) {
Point3d ptP1e = ptP1a + vtMove * ( dStElev + dSafeZ) ;
if ( AddRapidStart( ptP1e) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
if ( AddRapidMove( ptP1a) == GDB_ID_NULL)
return false ;
}
else {
if ( AddRapidStart( ptP1a) == GDB_ID_NULL)
return false ;
}
}
// caso standard
else {
if ( AddRapidStart( ptP1a) == GDB_ID_NULL)
return false ;
}
SetFlag( 0) ;
// 1b -> punto appena sopra inizio (se necessario)
if ( dSafeZ > dAppr + 10 * EPS_SMALL && dSawStElev + dAppr > 10 * EPS_SMALL) {
Point3d ptP1b = ptP + vtAppr * ( dSawStElev + dAppr) ;
if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
return false ;
}
// per approccio orizzontale vtAppr deve essere già stato sistemato dal chiamante
// 1 -> punto fuori inizio
Point3d ptP1 = ptP + vtAppr * ( dStElev + max( dAppr, dSafeZ)) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
// affondo al punto iniziale in feed
SetFlag( 0) ;
SetFeed( GetStartFeed()) ;
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
@@ -4232,29 +4197,37 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
//----------------------------------------------------------------------------
bool
Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, const Vector3d& vtTool,
double dSafeZ, double dSawEndElev, double dEndElev, double dAppr)
double dSafeZ, double dEndElev, double dAppr)
{
// per retrazione orizzontale vtAppr deve essere già stato sistemato dal chiamante
Point3d ptP4 = ptP ;
// se sopra uscita c'è spazio per approccio
if ( dSawEndElev + dAppr > 10 * EPS_SMALL) {
SetFeed( GetEndFeed()) ;
ptP4 = ptP + vtRetr * ( dSawEndElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
}
// se sopra uscita c'è spazio per sicurezza
if ( dSafeZ - dAppr > 10 * EPS_SMALL) {
ptP4 += vtRetr * ( dSafeZ - dAppr) ;
if ( AddRapidMove( ptP4) == GDB_ID_NULL)
return false ;
}
// se necessaria ulteriore uscita
if ( ! m_bTiltingTab && vtRetr.z < LIM_DOWN_APPRZ) {
Vector3d vtMove = Vector3d( vtTool.x, vtTool.y, 0) ;
if ( vtMove.Normalize()) {
Point3d ptP4b = ptP4 + vtMove * ( dEndElev + dSafeZ) ;
// se sopra uscita c'è spazio per sicurezza o approccio
if ( dEndElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) {
if ( dSafeZ < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + vtRetr * ( dEndElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + vtRetr * ( dEndElev + dAppr) ;
if ( dEndElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Vector3d vtMove = vtRetr ;
double dMove = dSafeZ - dAppr ;
if ( ! m_bTiltingTab && vtRetr.z < sin( -ANG_RIGHT / 2)) {
vtMove = Vector3d( vtTool.x, vtTool.y, 0) ;
if ( vtMove.Normalize())
dMove = dSafeZ ;
else
vtMove = vtRetr ;
}
Point3d ptP4b = ptP4a + vtMove * dMove ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
Milling.h
+2 -3
View File
@@ -98,13 +98,12 @@ class Milling : public Machining
double dDepth, double dElev, double dOkStep, bool bSplitArcs) ;
bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bOutStart, bool bAboveStart) ;
bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, const Vector3d& vtTool,
double dSafeZ, double dSawStElev, double dStElev, double dAppr) ;
bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, double dSafeZ, double dStElev, double dAppr) ;
bool AddDirectApproach( const Point3d& ptP) ;
bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bAboveEnd) ;
bool AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, const Vector3d& vtTool,
double dSafeZ, double dSawEndElev, double dEndElev, double dAppr) ;
double dSafeZ, double dEndElev, double dAppr) ;
bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool,
double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const ;
bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
Operation.cpp
+2 -2
View File
@@ -1837,7 +1837,7 @@ Operation::SetBlockedRotAxis( const string& sBlockedAxis) const
for ( int i = 0 ; i < nRotAxes && ! bFound ; ++ i) {
string sAxToken ;
if ( m_pMchMgr->GetCurrMachine()->GetCurrAxisToken( i + nLinAxes, sAxToken) &&
sKey == Trim( sAxToken, " \t\r\n=")) {
sKey == Trim( sAxToken)) {
string sAxis ;
m_pMchMgr->GetCurrMachine()->GetCurrAxisName( i + nLinAxes, sAxis) ;
m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ;
@@ -1915,7 +1915,7 @@ Operation::CalculateAxesValues( const string& sHint, bool bRotContOnNext, bool b
for ( int i = 0 ; i < nRotAxes ; ++ i) {
string sAxToken ;
if ( m_pMchMgr->GetCurrMachine()->GetCurrAxisToken( nLinAxes + i, sAxToken) &&
szKey == Trim( sAxToken, " \t\r\n=")) {
szKey == Trim( sAxToken)) {
double dVal ;
if ( FromString( szVal, dVal)) {
double dOffset = 0 ;
Pocketing.cpp
+34 -76
View File
@@ -3480,20 +3480,20 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
vpCrvs[0]->GetStartPoint( ptStart) ;
Vector3d vtDir ;
vpCrvs[0]->GetStartDir( vtDir) ;
Point3d ptTest = ptStart + ( -vtDir) * ( m_TParams.m_dDiam / 2 - dOffs + dSafeZ) ;
Point3d ptTest = ptStart + ( - vtDir) * ( m_TParams.m_dDiam / 2 + dSafeZ) ;
ptTest.ToGlob( frPocket) ;
ptTest += - vtTool * dDepth ;
double dTestElev ;
// se � nel grezzo provo a ruotare di 90 gradi
if ( GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2 - dOffs, vtTool, dTestElev) && dTestElev > EPS_SMALL) {
// se è nel grezzo provo a ruotare di 90 gradi
if ( GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, vtTool, dTestElev) && dTestElev > EPS_SMALL) {
Vector3d vtDirO = vtDir ;
vtDirO.Rotate( Z_AX, ( m_Params.m_bInvert ? -90 : 90)) ;
Point3d ptTestO = ptStart + vtDirO * ( m_TParams.m_dDiam / 2 - dOffs + dSafeZ) ;
Point3d ptTestO = ptStart + vtDirO * ( m_TParams.m_dDiam / 2 + dSafeZ) ;
ptTestO.ToGlob( frPocket) ;
ptTestO += - vtTool * dDepth ;
double dTestElevO ;
// se � fuori dal grezzo uso inizio ruotato
if ( ! GetElevation( m_nPhase, ptTestO, vtTool, m_TParams.m_dDiam / 2 - dOffs, vtTool, dTestElevO) || dTestElevO < EPS_SMALL) {
// se è fuori dal grezzo uso inizio ruotato
if ( ! GetElevation( m_nPhase, ptTestO, vtTool, m_TParams.m_dDiam / 2, vtTool, dTestElevO) || dTestElevO < EPS_SMALL) {
Point3d ptNewStart = ptStart + vtDirO ;
vpCrvs[0]->AddLine( ptNewStart, false) ;
}
@@ -3519,14 +3519,14 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
// estendo la fine del percorso
if ( ! ( nClosedSides == 3 && bTwoOpposite))
vpCrvs[0]->ExtendEndByLen( max( m_TParams.m_dDiam / 4 - dOffs, 0.)) ;
vpCrvs[0]->ExtendEndByLen( m_TParams.m_dDiam / 4) ;
return true ;
}
//------------------------------------------------------------------
bool
Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs)
Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir)
{
// individuo il segmento di retta più lungo
int nMax = -1 ;
@@ -3546,7 +3546,7 @@ Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOpt
pCrvPocket->GetCurve( nMax)->GetStartDir( vtDir) ;
// aggiorno pCrvPocket con eventuale offset per regioni residue
if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 0, {}, dOffs))
if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 0, {}))
return true ;
bOptimizedZigZag = true ;
@@ -3555,7 +3555,7 @@ Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOpt
//------------------------------------------------------------------
bool
Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs)
Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir)
{
// verifico che il lato chiuso sia una linea
PtrOwner<ICurveLine> pCrv( CloneCurveLine( pCrvPocket->GetCurve( nClosedId))) ;
@@ -3564,7 +3564,7 @@ Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClose
// aggiorno pCrvPocket con eventuale offset per regioni residue
pCrv->GetStartDir( vtDir) ;
if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, {nClosedId}, dOffs))
if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, {nClosedId}))
return true ;
// setto il vettore estrusione per eseguire correttamente offset
@@ -3587,7 +3587,7 @@ Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClose
//------------------------------------------------------------------
bool
Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag,
bool& bOpposite, Vector3d& vtDir, double& dOffs)
bool& bOpposite, Vector3d& vtDir)
{
// verifico che i lati chiusi siano linee
PtrOwner<ICurveLine> pCrv1( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[0]))) ;
@@ -3638,18 +3638,18 @@ Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INT
pCrv2->GetStartDir( vtDir) ;
// aggiorno pCrvPocket con eventuale offset per regioni residue
if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, bOpposite ? 2 : 1, vnClosedIds, dOffs))
if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, bOpposite ? 2 : 1, vnClosedIds))
return true ;
double dMyOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ;
pCrv1->SimpleOffset( -dMyOffs) ;
double dOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ;
pCrv1->SimpleOffset( -dOffs) ;
pCrv1->ExtendStartByLen( 300) ;
pCrv1->ExtendEndByLen( 300) ;
if ( ! CutCurveWithLine( pCrvPocket, pCrv1))
return false ;
// sar� la prima curva del percorso
pCrv2->SimpleOffset( -dMyOffs) ;
// sarà la prima curva del percorso
pCrv2->SimpleOffset( -dOffs) ;
pCrv2->ExtendStartByLen( 300) ;
pCrv2->ExtendEndByLen( 300) ;
if ( ! CutCurveWithLine( pCrvPocket, pCrv2))
@@ -3662,7 +3662,7 @@ Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INT
//------------------------------------------------------------------
bool
Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag,
bool& bOpposite, Vector3d& vtDir, double& dOffs)
bool& bOpposite, Vector3d& vtDir)
{
// verifico che i lati chiusi siano linee
@@ -3700,8 +3700,9 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I
double dLen1 ; pCrv1->GetLength( dLen1) ;
double dLen2 ; pCrv2->GetLength( dLen2) ;
double dLen3 ; pCrv3->GetLength( dLen3) ;
if ( dLen2 > dLen1 && dLen2 > dLen3) {
if ( dLen1 > 1.5 * m_TParams.m_dDiam || dLen3 > 1.5 * m_TParams.m_dDiam)
if ( dLen2 > dLen1 && dLen2 > dLen3) {
if ( dLen1 > /*1.5 **/ m_TParams.m_dDiam / 2 + 5 * EPS_SMALL || dLen3 > /*1.5 **/ m_TParams.m_dDiam / 2 + 5 * EPS_SMALL)
return true ;
pCrv2->GetStartDir( vtDir) ;
bOpposite = false ;
@@ -3715,7 +3716,7 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I
// aggiorno pCrvPocket con eventuale offset per regioni residue
if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, vnClosedIds, dOffs))
if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, vnClosedIds))
return true ;
// setto il vettore estrusione per eseguire correttamente offset
@@ -3725,21 +3726,21 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I
pCrv2->SetExtrusion( vtExtr) ;
pCrv3->SetExtrusion( vtExtr) ;
double dMyOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ;
pCrv1->SimpleOffset( -dMyOffs) ;
double dOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ;
pCrv1->SimpleOffset( - dOffs) ;
pCrv1->ExtendStartByLen( 300) ;
pCrv1->ExtendEndByLen( 300) ;
if ( ! CutCurveWithLine( pCrvPocket, pCrv1))
return false ;
pCrv3->SimpleOffset( -dMyOffs) ;
pCrv3->SimpleOffset( -dOffs) ;
pCrv3->ExtendStartByLen( 300) ;
pCrv3->ExtendEndByLen( 300) ;
if ( ! CutCurveWithLine( pCrvPocket, pCrv3))
return false ;
// sar� la prima curva del percorso
pCrv2->SimpleOffset( -dMyOffs) ;
// sarà la prima curva del percorso
pCrv2->SimpleOffset( -dOffs) ;
pCrv2->ExtendStartByLen( 300) ;
pCrv2->ExtendEndByLen( 300) ;
if ( ! CutCurveWithLine( pCrvPocket, pCrv2))
@@ -3752,54 +3753,15 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I
//------------------------------------------------------------------
bool
Pocketing::ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY,
const INTVECTOR& vnClosedIds, double& dOffs)
const INTVECTOR& vnClosedIds)
{
// ricavo l'estrusione
Vector3d vtExtr ; pCrvPocket->GetExtrusion( vtExtr) ;
// ricavo la Thickness
double dThick ; pCrvPocket->GetThickness( dThick) ;
// verifico se resteranno aree residue e calcolo eventuale offset per pCrvPocket
dOffs = 0 ;
for ( int i = 0 ; i < pCrvPocket->GetCurveCount() ; i ++) {
double dOffs = m_TParams.m_dDiam / 2 + 5 * EPS_SMALL;
double dOffsTmp = 0 ;
double dVal = 0 ;
if ( pCrvPocket->GetCurve(i)->GetType() == CRV_LINE) {
Vector3d vtDir ;
if ( ! pCrvPocket->GetCurve( i)->GetStartDir( vtDir))
return false ;
int nProp ;
pCrvPocket->GetCurveTempProp( i, nProp, 1) ;
double dLen ;
pCrvPocket->GetCurve( i)->GetLength( dLen) ;
if ( nProp == 1 && dLen > 1000 * EPS_SMALL) {
// gestione speciale se vicino al lato closed
double dCosAlpha = vtMainDir * vtDir ;
if ( abs( dCosAlpha) > EPS_SMALL && abs( dCosAlpha) < 1 - EPS_SMALL)
dOffsTmp = abs( 0.5 * m_TParams.m_dDiam * dCosAlpha) ;
}
else {
double dSinAlpha = ( vtMainDir ^ vtDir).Len() ;
if ( abs( dSinAlpha) > EPS_SMALL)
dVal = ( dYSideStep - 0.5 * m_TParams.m_dDiam) / dSinAlpha - 0.5 * m_TParams.m_dDiam ;
if ( dVal > EPS_SMALL) {
double dCosAlpha = vtMainDir * vtDir ;
dOffsTmp = abs( ( dYSideStep - 0.5 * m_TParams.m_dDiam) * dCosAlpha) ;
}
}
}
if ( dOffsTmp > dOffs)
dOffs = dOffsTmp ;
}
// aggiusto offset
double dMinOffs = max( 0., 0.5 * m_TParams.m_dDiam - m_Params.m_dSideStep) ;
dOffs = max( dOffs, dMinOffs) ;
if ( dOffs > EPS_SMALL) {
// calcolo offset
OffsetCurve OffsCrv ;
@@ -7701,9 +7663,8 @@ Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveC
// se il lato opposto a quello di riferimento � chiuso bisogna distinguere i casi
else {
bool bStartPnt = false ;
if ( ptP2.y < dYCoord) {
bStartPnt = pCompo->AddPoint( ptP2) ;
pCompo->AddPoint( ptP2) ;
}
else {
Vector3d vtDir ;
@@ -7711,14 +7672,11 @@ Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveC
if ( bStart)
vtDir.Invert() ;
Point3d ptP2N = ptP2 - m_TParams.m_dDiam / 2 * abs( vtDir.x / vtDir.y) * vtDir ;
if ( ptP2N.y < dYCoord)
bStartPnt = pCompo->AddPoint( ptP2N) ;
}
if ( bStartPnt) {
Point3d ptCrv ;
pMCrv->GetStartPoint( ptCrv) ;
pCompo->AddLine( ptCrv) ;
pCompo->AddPoint( ptP2N) ;
}
Point3d ptCrv ;
pMCrv->GetStartPoint( ptCrv) ;
pCompo->AddLine( ptCrv) ;
}
// setto temp prop per ricordare che è curva aggiuntiva per pulire angoli
Pocketing.h
-18
View File
@@ -76,7 +76,6 @@ class Pocketing : public Machining
bool Chain( int nGrpDestId) ;
bool ProcessPath( int nPathId, int nPvId, int nClId) ;
bool CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) const ;
<<<<<<< HEAD
bool VerifyPathFromBottom( const ISurfFlatRegion* pSrf, const Vector3d& vtTool) ;
bool GeneratePocketingPv( int nPathId, const ISurfFlatRegion* pSrfPock) ;
@@ -146,23 +145,6 @@ class Pocketing : public Machining
bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY,
const INTVECTOR& vnClosedIds) ;
bool AssignContourToPath( const ICRVCOMPOPOVECTOR& vpCrvs, const Frame3d frPocket, const ISurfFlatRegion* pSrfOffs, ICRVCOMPOPOVECTOR& vAllCrv) ;
=======
bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ;
bool GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) ;
bool AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId) ;
bool CalcZigZag( const ICurveComposite* pOffs, ICRVCOMPOPOVECTOR& vpCrvs) ;
bool OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth, double dSafeZ,
Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs, double& dOffs) ;
bool ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ;
bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ;
bool ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag,
bool& bOpposite, Vector3d& vtDir, double& dOffs) ;
bool ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag,
bool& bOpposite, Vector3d& vtDir, double& dOffs) ;
bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY,
const INTVECTOR& vnClosedIds, double& dOffs) ;
>>>>>>> 994658da167a7ac3f607f4b535a65febe8f308d1
bool CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) ;
// ===================================================================
Simulator.cpp
+34 -58
View File
@@ -25,11 +25,9 @@
#include "/EgtDev/Include/EGkCDeCylClosedSurfTm.h"
#include "/EgtDev/Include/EGkCDeSpheClosedSurfTm.h"
#include "/EgtDev/Include/EGkCDeConeFrustumClosedSurfTm.h"
#include "/EgtDev/Include/EGkCDeClosedSurfTmClosedSurfTm.h"
#include "/EgtDev/Include/EGkVolZmap.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkSurfLocal.h"
#include "/EgtDev/Include/EXeCmdLogOff.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EMkToolConst.h"
@@ -1355,62 +1353,44 @@ Simulator::ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType)
// se utensile attivo su grezzo in lavoro e non è rapido, salto
if ( bIsTool && bIsRaw && nMoveType != 0)
continue ;
// se riferimento non trovato, si salta
const IGeoFrame3d* pGeoFrame = GetGeoFrame3d( m_pGeomDB->GetGeoObj( m_CollObj[j].nFrameId)) ;
if ( pGeoFrame == nullptr)
continue ;
// esecuzione controlli di collisione
bool bOk = true ;
// oggetti che richiedono frame associato (Box, Cylinder, Sphere, Cone)
if ( m_CollObj[j].nType != MCH_SIM_COB_POLY) {
// se riferimento non trovato, si salta
const IGeoFrame3d* pGeoFrame = GetGeoFrame3d( m_pGeomDB->GetGeoObj( m_CollObj[j].nFrameId)) ;
if ( pGeoFrame == nullptr)
continue ;
Frame3d frObj = pGeoFrame->GetFrame() ;
if ( ! m_CollObj[j].vtMove.IsSmall())
frObj.Translate( m_CollObj[j].vtMove.x * frObj.VersX() +
m_CollObj[j].vtMove.y * frObj.VersY() +
m_CollObj[j].vtMove.z * frObj.VersZ()) ;
Frame3d frParent ; m_pGeomDB->GetGlobFrame( m_CollObj[j].nFrameId, frParent) ;
frObj.LocToLoc( frParent, frCd) ;
// controlli di collisione
if ( m_CollObj[j].nType == MCH_SIM_COB_BOX) {
Vector3d vtDiag( m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3) ;
if ( pVZM != nullptr)
bOk = pVZM->AvoidBox( frObj, vtDiag, m_dSafeDist) ;
else
bOk = ! CDeBoxClosedSurfTm( frObj, vtDiag, m_dSafeDist, *pSTM) ;
}
else if ( m_CollObj[j].nType == MCH_SIM_COB_CYL) {
if ( pVZM != nullptr)
bOk = pVZM->AvoidCylinder( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_dSafeDist) ;
else
bOk = ! CDeCylClosedSurfTm( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_dSafeDist, *pSTM) ;
}
else if ( m_CollObj[j].nType == MCH_SIM_COB_SPHE) {
if ( pVZM != nullptr)
bOk = pVZM->AvoidSphere( frObj.Orig(), m_CollObj[j].dPar1, m_dSafeDist) ;
else
bOk = ! CDeSpheClosedSurfTm( frObj.Orig(), m_CollObj[j].dPar1, m_dSafeDist, *pSTM) ;
}
else if ( m_CollObj[j].nType == MCH_SIM_COB_CONE) {
if ( pVZM != nullptr)
bOk = pVZM->AvoidConeFrustum( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3, m_dSafeDist) ;
else
bOk = ! CDeConeFrustumClosedSurfTm( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3, m_dSafeDist, *pSTM) ;
}
}
// altrimenti poliedro
else {
SurfLocal SurfLoc( m_pGeomDB, m_CollObj[j].nFrameId, frCd) ;
const ISurfTriMesh* pStmLoc = GetSurfTriMesh( SurfLoc) ;
if ( pStmLoc != nullptr) {
if ( pVZM != nullptr)
bOk = pVZM->AvoidSurfTm( *pStmLoc, m_dSafeDist) ;
else
bOk = ! CDeClosedSurfTmClosedSurfTm( *pStmLoc, *pSTM, m_dSafeDist) ;
}
Frame3d frObj = pGeoFrame->GetFrame() ;
if ( ! m_CollObj[j].vtMove.IsSmall())
frObj.Translate( m_CollObj[j].vtMove.x * frObj.VersX() +
m_CollObj[j].vtMove.y * frObj.VersY() +
m_CollObj[j].vtMove.z * frObj.VersZ()) ;
Frame3d frParent ; m_pGeomDB->GetGlobFrame( m_CollObj[j].nFrameId, frParent) ;
frObj.LocToLoc( frParent, frCd) ;
if ( m_CollObj[j].nType == MCH_SIM_COB_BOX) {
Vector3d vtDiag( m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3) ;
if ( pVZM != nullptr)
bOk = pVZM->AvoidBox( frObj, vtDiag, m_dSafeDist) ;
else
bOk = false ;
bOk = ! CDeBoxClosedSurfTm( frObj, vtDiag, m_dSafeDist, *pSTM) ;
}
else if ( m_CollObj[j].nType == MCH_SIM_COB_CYL) {
if ( pVZM != nullptr)
bOk = pVZM->AvoidCylinder( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_dSafeDist) ;
else
bOk = ! CDeCylClosedSurfTm( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_dSafeDist, *pSTM) ;
}
else if ( m_CollObj[j].nType == MCH_SIM_COB_SPHE) {
if ( pVZM != nullptr)
bOk = pVZM->AvoidSphere( frObj.Orig(), m_CollObj[j].dPar1, m_dSafeDist) ;
else
bOk = ! CDeSpheClosedSurfTm( frObj.Orig(), m_CollObj[j].dPar1, m_dSafeDist, *pSTM) ;
}
else if ( m_CollObj[j].nType == MCH_SIM_COB_CONE) {
if ( pVZM != nullptr)
bOk = pVZM->AvoidConeFrustum( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3, m_dSafeDist) ;
else
bOk = ! CDeConeFrustumClosedSurfTm( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3, m_dSafeDist, *pSTM) ;
}
// se trovata collisione
if ( ! bOk) {
nCdInd = i ;
nObjInd = j ;
@@ -1993,10 +1973,6 @@ Simulator::AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType, con
if ( ( dPar1 < EPS_SMALL && dPar2 < EPS_SMALL) || dPar3 < EPS_SMALL)
return false ;
break ;
case MCH_SIM_COB_POLY :
if ( ! ExeSurfIsClosed( nFrameId))
return false ;
break ;
default :
return false ;
}