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

EgtMachKernel 2.4c1 :

Browse Source 
- in svuotatura a spirale ottimizzata per trapezoidi aggiunta rimozione di materiale residuo negli angoli.
This commit is contained in:
SaraP
2022-03-16 09:26:21 +01:00
parent b059fe9486
commit d8f72d02f7
3 changed files with 293 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtMachKernel.rc
BIN
View File
Binary file not shown.
Pocketing.cpp
+289 -69
View File
@@ -3720,7 +3720,7 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs,
Point3d pt ;
Vector3d vtB1, vtL1, vtB2 ;
if ( false && pCrvPocket->IsATrapezoid( 100 * EPS_SMALL, pt, vtB1, vtL1, vtB2)) {
if ( pCrvPocket->IsATrapezoid( 100 * EPS_SMALL, pt, vtB1, vtL1, vtB2)) {
Vector3d vtDir( vtB1), vtOtherDir( vtL1) ;
// se parallelogramma scelgo come base i lati lunghi
Vector3d vtL2( -vtB1 + vtL1 + vtB2) ;
@@ -3732,8 +3732,11 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs,
Vector3d vtOrtho = OrthoCompo( vtOtherDir, vtDir) ;
double dPocketSize = vtOrtho.Len() ;
if ( dPocketSize < m_TParams.m_dDiam + EPS_SMALL) {
if ( nReg == 0)
return CalcTrapezoidSpiral( pCrvPocket, vtDir, dPocketSize, pMCrv, pRCrv, bOptimizedTrap) ;
if ( nReg == 0) {
CalcTrapezoidSpiral( pCrvPocket, vtDir, dPocketSize, pMCrv, pRCrv, bOptimizedTrap) ;
if ( bOptimizedTrap)
return true ;
}
else
return true ;
}
@@ -4097,7 +4100,7 @@ Pocketing::CalcCircleSpiral( const Point3d& ptCen, const Vector3d& vtN, double d
bool
Pocketing::CalcTrapezoidSpiral( ICurveComposite * pCrvPocket, const Vector3d& vtDir, double dPocketSize,
ICurveComposite * pMCrv, ICurveComposite * pRCrv, bool& bOptimizedTrap)
{
{
Vector3d vtExtr ; pCrvPocket->GetExtrusion( vtExtr) ;
// eventuale approssimazione della curva con polyline per ottenere la stessa curva calcolata in ICurveComposite::IsATrapezoid
if ( pCrvPocket->GetCurveCount() > 4) {
@@ -4122,40 +4125,58 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite * pCrvPocket, const Vector3d& vt
return false ;
pCrvPocket->ToLoc( frLoc) ;
int nProp0 = 0, nProp1 = 0, nProp3 = 0 ;
pCrvPocket->GetCurveTempProp( 0, nProp0) ;
pCrvPocket->GetCurveTempProp( 1, nProp1) ;
pCrvPocket->GetCurveTempProp( 3, nProp3) ;
INTVECTOR vnProp( 4, 0) ;
for ( int i = 0 ; i < 4 ; i++)
pCrvPocket->GetCurveTempProp( i, vnProp[i]) ;
// verifico le dimensioni della svuotatura
if ( ! nProp0 && abs( dPocketSize - m_TParams.m_dDiam) > EPS_SMALL)
if ( ! vnProp[0] && abs( dPocketSize - m_TParams.m_dDiam) > EPS_SMALL)
return false ;
if ( ! vnProp[1] && ! vnProp[3]) {
double dLen0 = 0, dLen2 = 0 ;
pCrvPocket->GetCurve( 0)->GetLength( dLen0) ;
pCrvPocket->GetCurve( 2)->GetLength( dLen2) ;
if ( dLen0 < m_TParams.m_dDiam + EPS_SMALL || dLen2 < m_TParams.m_dDiam + EPS_SMALL)
return false ;
}
// calcolo percorso di svuotatura
double dYCoord = dPocketSize - 0.5 * m_TParams.m_dDiam ;
if ( nProp0)
dYCoord -= GetOffsR() ;
if ( vnProp[0])
dYCoord -= GetOffsR() ;
if ( vnProp[0] && vnProp[2])
dYCoord = 0.5 * dPocketSize ; // se entrambi i lati paralleli sono aperti mi posiziono a metà della svuotatura
double dXCoordStart, dXCoordEnd ;
if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, true, dYCoord, dXCoordStart))
if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, true, dYCoord, dXCoordStart, dPocketSize))
return false ;
if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, false, dYCoord, dXCoordEnd))
if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, false, dYCoord, dXCoordEnd, dPocketSize))
return false ;
Point3d ptStart( dXCoordStart, dYCoord) ;
if ( dXCoordStart > dXCoordEnd)
return false ;
Point3d ptStart( dXCoordStart, dYCoord) ;
Point3d ptEnd( dXCoordEnd, dYCoord) ;
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
if ( IsNull( pLine))
return false ;
pLine->Set( ptStart, ptEnd) ;
pMCrv->AddPoint( ptStart) ;
pMCrv->AddLine( ptEnd) ;
// aggiustamenti al percorso per rimuovere materiale residuo negli angoli
if ( vnProp[0]) {
if ( ! vnProp[3])
AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, true) ;
if ( ! vnProp[1])
AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, false) ;
}
pMCrv->AddCurve( Release( pLine)) ;
pMCrv->ToGlob( frLoc) ;
if ( ! m_Params.m_bInvert) {
pMCrv->Invert() ;
// inverto le proprietà in modo che nProp3 sia sempre legata al punto iniziale e nProp1 a quello finale
swap( nProp1, nProp3) ;
swap( vnProp[1], vnProp[3]) ;
}
// segno i lati aperti come temp prop della curva
int nOpenEdges = nProp0 + nProp1 * 2 + nProp3 * 8 ;
int nOpenEdges = vnProp[0] + vnProp[1] * 2 + vnProp[3] * 8 ;
pMCrv->SetTempProp( nOpenEdges, 0) ;
pMCrv->SetExtrusion( vtExtr) ;
@@ -4200,7 +4221,7 @@ Pocketing::CalcTrapezoidSpiralLocalFrame( ICurveComposite * pCrvPocket, const Ve
//------------------------------------------------------
bool
Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord)
Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord, double dPocketSize)
{
int nCrvId = bStart ? 3 : 1 ;
int nProp ;
@@ -4221,16 +4242,21 @@ Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool b
double dVal ;
Vector3d vtRef ;
pCrvPocket->GetCurve( nCrvId)->GetStartDir( vtRef) ;
double dCosAlpha = vtRef * X_AX ;
if ( dRad * dCosAlpha < dYCoord) {
double dCosAlpha = vtRef * X_AX ;
if ( dRad * dCosAlpha < dYCoord && dYCoord < dPocketSize + dRad * dCosAlpha) {
double dSinAlpha = ( vtRef ^ X_AX).Len() ;
if ( abs( dSinAlpha) < EPS_SMALL)
return false ;
dVal = 1 / dSinAlpha * ( dRad - dYCoord * dCosAlpha) ;
}
else
dVal = sqrt( dRad * dRad - dYCoord * dYCoord) ;
else if ( dYCoord < dRad * dCosAlpha)
dVal = sqrt( dRad * dRad - dYCoord * dYCoord) ;
else {
double dLen ;
pCrvPocket->GetCurve( nCrvId)->GetLength( dLen) ;
dVal = - dLen * dCosAlpha + sqrt( dRad * dRad - dYCoord * dYCoord) ;
}
Point3d ptRef ;
if ( bStart) {
@@ -4245,17 +4271,163 @@ Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool b
return true ;
}
//----------------------------------------------------
bool
Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite * pMCrv, const ICurveComposite * pCrvPocket, bool bStart)
{
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( ! bStart)
pMCrv->Invert() ;
Point3d ptTmp ;
pMCrv->GetStartPoint( ptTmp) ;
double dYCoord = ptTmp.y ; // quota verticale del percorso di svuotatura
pCrvPocket->GetCurve( 2)->GetStartPoint( ptTmp) ;
double dPocketSize = ptTmp.y ;
int nCrvId = bStart ? 3 : 1 ;
PtrOwner<ICurveLine> pLine( GetCurveLine( pCrvPocket->GetCurve( nCrvId)->Clone())) ;
pLine->SimpleOffset( - 0.5 * m_TParams.m_dDiam - GetOffsR()) ;
Point3d ptP1, ptP2 ;
pLine->GetStartPoint( ptP1) ;
pLine->GetEndPoint( ptP2) ;
if ( ! bStart)
swap( ptP1, ptP2) ;
int nProp2 ;
// lato opposto a quello di riferimento aperto
if ( pCrvPocket->GetCurveTempProp( 2, nProp2) && nProp2) {
// caso 1 : pLine ha un estremo sopra e uno sotto il percorso di svuotatura pMCrv
if ( ptP2.y < dYCoord && dYCoord < ptP1.y) {
// creo tratto da ptP2 a ptP1
pCompo->AddPoint( ptP2) ;
pCompo->AddLine( ptP1) ;
// trovo il punto di pMCrv da cui ripartire per non lasciare aree residue
pLine->SimpleOffset( - 0.5 * m_TParams.m_dDiam) ;
pLine->ExtendStartByLen( EPS_SMALL) ;
pLine->ExtendEndByLen( EPS_SMALL) ;
IntersCurveCurve intCC( *pLine, *pCrvPocket) ;
if ( intCC.GetIntersCount() == 0)
return false ;
IntCrvCrvInfo aInfo ;
intCC.GetIntCrvCrvInfo( 0, aInfo) ;
double dDeltaX = sqrt( m_TParams.m_dDiam * m_TParams.m_dDiam / 4 - dYCoord * dYCoord) ;
if ( ! bStart)
dDeltaX *= -1 ;
Point3d ptCrv( aInfo.IciA[0].ptI.x + dDeltaX, dYCoord) ;
double dPar = 0 ;
if ( ! pMCrv->GetParamAtPoint( ptCrv, dPar)) {
dPar = 0.5 ;
pMCrv->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptCrv) ;
}
pMCrv->TrimStartAtParam( dPar) ;
if ( ptP1.y > dPocketSize) {
// se ptP1 è esterno alla svuotatura scambio i punti in modo da usare ptP2 per il biarco ( così da non farlo fuoriuscire troppo)
swap( ptP1, ptP2) ;
pCompo->Invert() ;
}
// creo biarco fra ptP1 e ptCrv
Vector3d vtDir ;
pCompo->GetStartDir( vtDir) ;
double dAng ;
vtDir.GetAngleXY( X_AX, dAng) ;
PtrOwner<ICurve> pBiArc( GetBiArc( ptP1, - dAng, ptCrv, bStart ? 0 : 180, 0.8)) ;
bool bUseBiArc = false ;
if ( ! IsNull( pBiArc)) {
// verifico che con il biarco non si oltrepassi il lato obliquo chiuso della svuotatura
IntersCurveCurve intCC2( *pBiArc, *pCompo) ;
if ( intCC2.GetIntersCount() == 1)
bUseBiArc = true ;
}
if ( bUseBiArc)
pCompo->AddCurve( Release( pBiArc)) ;
else {
double dParLine = ( dYCoord - ptP2.y) / ( ptP1.y - ptP2.y) ;
Point3d ptOnLine = Media( ptP2, ptP1, dParLine) ;
pCompo->AddLine( ptOnLine) ;
pCompo->AddLine( ptCrv) ;
}
}
// caso 2 : pLine è completamente sopra/sotto la linea di svuotatura
else {
// se è sopra modifiche per ricondurmi al caso in cui è sotto
if ( ptP2.y > dYCoord) {
pLine->Invert() ;
swap( ptP1, ptP2) ;
}
// trovo l'intersezione fra il prolungamento della linea e pMCrv
if ( bStart)
pLine->ExtendStartByLen( 1000) ;
else
pLine->ExtendEndByLen( 1000) ;
IntersCurveCurve intCC ( *pLine, *pMCrv) ;
IntCrvCrvInfo aInfo ;
intCC.GetIntCrvCrvInfo( 0, aInfo) ;
Point3d ptInt ;
ptInt = aInfo.IciA[0].ptI ;
double dPar = 0 ;
pMCrv->GetParamAtPoint( ptInt, dPar) ;
pMCrv->TrimStartAtParam( dPar) ;
pCompo->AddPoint( ptP2) ;
pCompo->AddLine( ptInt) ;
}
}
// se il lato opposto a quello di riferimento è chiuso ha senso aggiungere solo se il punto è sotto la linea di svuotatura
else {
if ( ptP2.y < dYCoord) {
pCompo->AddPoint( ptP2) ;
Point3d ptCrv ;
pMCrv->GetStartPoint( ptCrv) ;
pCompo->AddLine( ptCrv) ;
}
}
// setto temp prop per ricordare che è curva aggiuntiva per pulire angoli
for ( int i = 0 ; i < pCompo->GetCurveCount() ; i++)
pCompo->SetCurveTempProp( i, 1) ;
pMCrv->AddCurve( Release( pCompo), false) ;
if ( ! bStart)
pMCrv->Invert() ; // ripristino la direzione originaria
return true ;
}
//----------------------------------------------------
bool
Pocketing::AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICurveComposite * pRCrv, const Vector3d& vtTool, double dDepth,
int& nOutsideRaw)
{
// start point
{
// recupero la direzione principale della svuotatura
Vector3d vtMainDir ;
for ( int i = 0 ; i < pCompo->GetCurveCount() ; i++) {
int nProp ;
if ( pCompo->GetCurveTempProp( i, nProp) && nProp == 0) {
// se non è lato aggiuntivo per la pulitura angoli recupero la sua direzione
pCompo->GetCurve( i)->GetStartDir( vtMainDir) ;
break ;
}
}
// start point
bool bStartOutside = false ;
ComputeTrapezoidSpiralLeadInLeadOut( pCompo, true, vtTool, dDepth, bStartOutside) ;
ComputeTrapezoidSpiralLeadInLeadOut( pCompo, vtMainDir, true, vtTool, dDepth, bStartOutside) ;
// end point
bool bEndOutside = false ;
ComputeTrapezoidSpiralLeadInLeadOut( pCompo, false, vtTool, dDepth, bEndOutside) ;
ComputeTrapezoidSpiralLeadInLeadOut( pCompo, vtMainDir, false, vtTool, dDepth, bEndOutside) ;
// eventuale inversione della curva per partire sempre dall'esterno del grezzo
if ( bEndOutside && ! bStartOutside)
@@ -4264,17 +4436,13 @@ Pocketing::AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICur
nOutsideRaw = 0 ;
if ( bStartOutside && bEndOutside)
nOutsideRaw = 2 ;
else if ( bStartOutside || bEndOutside ) {
else if ( bStartOutside || bEndOutside) {
nOutsideRaw = 1 ;
// calcolo percorso di ritorno
pRCrv->Clear() ;
Point3d ptS, ptE ;
pCompo->GetStartPoint( ptS) ;
pCompo->GetEndPoint( ptE) ;
PtrOwner<ICurveLine> pRLine( CreateCurveLine()) ;
pRLine->Set( ptE, ptS) ;
pRCrv->AddCurve( Release( pRLine)) ;
pRCrv->AddCurve( pCompo->Clone()) ;
pRCrv->Invert() ;
}
return true ;
@@ -4282,9 +4450,11 @@ Pocketing::AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICur
//----------------------------------------------------
bool
Pocketing::ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw)
Pocketing::ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw)
{
Vector3d vtDir ;
bIsOutsideRaw = false ;
Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;
Vector3d vtDir ;
Point3d pt ;
if ( bLeadIn) {
pCompo->GetStartPoint( pt) ;
@@ -4299,48 +4469,77 @@ Pocketing::ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, bool b
int nPropOpen = pCompo->GetTempProp( 0) ;
bool bEdgeOpen = ( nPropOpen & ( bLeadIn ? 8 : 2)) > 0 ;
bool bBaseOpen = ( nPropOpen & 1) > 0 ;
// recupero info per capire se sto considerando un lato aggiuntivo per pulire angoli
int nIdCrv = bLeadIn ? 0 : pCompo->GetCurveCount() - 1 ;
int nExtraEdge ;
pCompo->GetCurveTempProp( nIdCrv, nExtraEdge) ;
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
if ( bEdgeOpen) {
// se lato inclinato è apert tento con prolungamento della curva lungo vtDir
Point3d ptTest ;
if ( bLeadIn)
ptTest = pt - vtDir * ( 0.5 * m_TParams.m_dDiam + dSafeZ) ;
else
ptTest = pt + vtDir * ( 0.5 * m_TParams.m_dDiam + dSafeZ) ;
ptTest += - vtTool * dDepth ;
// tento con allungamento se lato inclinato è aperto oppure se sto considerando un lato aggiuntivo per pulire angoli
if ( bEdgeOpen || nExtraEdge == 1) {
Vector3d vtDirP = bLeadIn ? -vtDir : vtDir ;
double dTestElev ;
// se fuori dal grezzo
if ( ! GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTestElev) || dTestElev < EPS_SMALL) {
if ( bLeadIn)
pCompo->ExtendStartByLen( 0.5 * m_TParams.m_dDiam + dSafeZ) ;
else
pCompo->ExtendEndByLen( 0.5 * m_TParams.m_dDiam + dSafeZ) ;
bIsOutsideRaw = true ;
}
}
if ( bBaseOpen && ! bIsOutsideRaw) {
// se base è aperta provo a ruotare di 90 gradi
Vector3d vtDirO = vtDir ;
Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;
vtDirO.Rotate( vtExtr, ( m_Params.m_bInvert ? -90 : 90)) ;
// recupero la distanza dal bordo del grezzo lungo la direzione di allungamento
double dDist ;
GetDistanceFromRawSide( m_nPhase, pt, vtDirO, dDist) ;
if ( ! CalcDistanceFromRawSurface( m_nPhase, pt, vtDirP, dDist))
return false ;
// calcolo eventuali fattori correttivi
double dCorr = 1 ;
double dDistRef = dDist ;
Vector3d vtDirO = vtMainDir ;
vtDirO.Rotate( vtExtr, 90) ;
if ( vtDirO * vtDirP < EPS_SMALL)
vtDirO.Rotate( vtExtr, 180) ;
if ( ! AreSameOrOppositeVectorApprox( vtDir, vtDirO) && ! AreOrthoApprox( vtDir, vtDirO) && abs( dDist) > EPS_SMALL) {
double dDistMin = 0 ;
CalcDistanceFromRawSurface( m_nPhase, pt, vtDirO, dDistMin) ;
if ( abs( dDistMin) < abs( dDist)) {
dDistRef = dDistMin ;
dCorr = dDist / dDistMin ;
}
}
// se vicino al bordo del grezzo
if ( dDistRef < 0.5 * m_TParams.m_dDiam + EPS_SMALL) {
Point3d ptTest = pt + vtDirP * ( dDist + ( 0.5 * m_TParams.m_dDiam + dSafeZ) * dCorr) ;
ptTest += - vtTool * dDepth ;
double dTestElev ;
// se è fuori dal grezzo
if ( ! GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTestElev) || dTestElev < EPS_SMALL) {
Point3d ptNewStart = pt + vtDirP * ( dDist + ( 0.5 * m_TParams.m_dDiam + dSafeZ) * dCorr) ;
pCompo->AddLine( ptNewStart, ! bLeadIn) ;
bIsOutsideRaw = true ;
}
}
}
// tento con attacco ruotato di 90° se non sto considerando un tratto aggiuntivo per pulire angoli
if ( bBaseOpen && ! bIsOutsideRaw && nExtraEdge == 0) {
Vector3d vtDirO = vtDir ;
vtDirO.Rotate( vtExtr, ( m_Params.m_bInvert ? -90 : 90)) ;
// calcolo distanza dal bordo del grezzo lungo vtDirO
double dDist ;
if ( ! CalcDistanceFromRawSurface( m_nPhase, pt, vtDirO, dDist))
return false ;
// se vicino al bordo del grezzo
if ( dDist < 0.5 * m_TParams.m_dDiam + EPS_SMALL) {
Point3d ptTestO = pt + vtDirO * ( dDist + 0.5 * m_TParams.m_dDiam + dSafeZ) ;
ptTestO += - vtTool * dDepth ;
double dTestElevO ;
// se è fuori dal grezzo uso inizio ruotato
if ( ! GetElevation( m_nPhase, ptTestO, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTestElevO) || dTestElevO < EPS_SMALL) {
Point3d ptNewStart = pt + vtDirO * ( dDist + 0.5 * m_TParams.m_dDiam + dSafeZ) ;
pCompo->AddLine( ptNewStart, ! bLeadIn) ;
bIsOutsideRaw = true ;
Point3d ptNewStart = pt + vtDirO * ( dDist + 0.5 * m_TParams.m_dDiam + dSafeZ) ;
pCompo->AddLine( ptNewStart, ! bLeadIn) ;
bIsOutsideRaw = true ;
}
}
}
}
return true ;
}
@@ -5221,3 +5420,24 @@ Pocketing::VerifyLeadInZigZag( const ICurveComposite* pCompo, const Point3d& ptP
return false ;
return ( dMinDistPa > 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL && dMinDistPb > 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL) ;
}
//----------------------------------------------------------------------------
bool
Pocketing::CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist)
{
if ( ! GetElevation( nPhase, ptP, vtDir, dDist))
return false ;
// se punto esterno al grezzo
if ( abs( dDist) < EPS_SMALL) {
double dDist1, dDist2 ;
if ( ! GetElevation( nPhase, ptP, -vtDir, dDist1))
return false ;
if ( ! GetElevation( nPhase, ptP - vtDir * ( dDist1), vtDir, dDist2))
return false ;
if ( abs( dDist2) > EPS_SMALL && abs( dDist1) > EPS_SMALL)
dDist = dDist2 - dDist1 ;
}
return true ;
}
Pocketing.h
+4 -2
View File
@@ -104,10 +104,11 @@ class Pocketing : public Machining
bool CalcTrapezoidSpiral( ICurveComposite * pCrvPocket, const Vector3d& vtDir, double dPocketSize,
ICurveComposite * pMCrv, ICurveComposite * pRCrv, bool& bOptimizedTrap) ;
bool CalcTrapezoidSpiralLocalFrame( ICurveComposite * pCrvPocket, const Vector3d& vtDir, Frame3d& frLoc) ;
bool CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord) ;
bool CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord, double dPocketSize) ;
bool AdjustTrapezoidSpiralForAngles( ICurveComposite * pMCrv, const ICurveComposite * pCrvPocket, bool bStart) ;
bool AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICurveComposite * pRCrv, const Vector3d& vtTool,
double dDepth, int& nOutsideRaw) ;
bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw) ;
bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw) ;
bool ComputePolishingPath( ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool bSplitArcs) ;
bool AddEpicycles( ICurveComposite * pCompo, ICurveComposite * pCrv, ICurveComposite * pCrvBound = nullptr) ;
bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
@@ -131,6 +132,7 @@ class Pocketing : public Machining
bool AdjustContourStart( ICurveComposite* pCompo) ;
bool VerifyLeadInHelix( const ICurveComposite* pCompo, const Point3d& ptCen, double dRad) const ;
bool VerifyLeadInZigZag( const ICurveComposite* pCompo, const Point3d& ptPa, const Point3d& ptPb) const ;
bool CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist) ;
private :
double GetSpeed( void) const