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

EgtMachKernel :

Browse Source 
- casi ottimizzati Trapezi ( Codice non testato).
This commit is contained in:
Riccardo Elitropi
2023-10-31 16:43:04 +01:00
parent 31980fb85f
commit 072b47590e
2 changed files with 368 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+364 -65
View File
@@ -1833,11 +1833,11 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
return false ;
break ;
case POCKET_SUB_SPIRALIN:
if ( ! AddSpiralIn( pSrfPock, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs))
if ( ! AddSpiralIn( pSrfPock, vtTool, vtExtr, dDepth, dElev, dMaxElev, dOkStep, bSplitArcs))
return false ;
break ;
case POCKET_SUB_SPIRALOUT:
if ( ! AddSpiralOut( pSrfPock, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs))
if ( ! AddSpiralOut( pSrfPock, vtTool, vtExtr, dDepth, dElev, dMaxElev, dOkStep, bSplitArcs))
return false ;
break ;
}
@@ -2435,15 +2435,6 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
int nOff_index = int( vCrvInfo.size()) ;
for ( int x = 0 ; x < int( vCrvIslMergeBorders.size()) ; ++ x) {
/*CrvInfo myCrvInfo ;
myCrvInfo.pCrvCompo.Set( Release( vCrvIslMergeBorders[x])) ;
myCrvInfo.nCrvType = CRV_BORDER ;
myCrvInfo.ptStart = vPtStart[x] ;
myCrvInfo.bMidOut = vbMidOut[x] ;
myCrvInfo.vtMidOut = vVtMidOut[x] ;
myCrvInfo.nChunk = cc ;
vCrvInfo.emplace_back( myCrvInfo) ;
*/
vCrvInfo[nOff_index + x].pCrvCompo.Set( Release( vCrvIslMergeBorders[x])) ;
vCrvInfo[nOff_index + x].nCrvType = CRV_BORDER ;
vCrvInfo[nOff_index + x].ptStart = vPtStart[x] ;
@@ -2488,13 +2479,8 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
int nIndex_offs = int( vCrvInfo.size()) ;
vCrvInfo.resize( int( vpCrvs.size()) + nIndex_offs) ;
for ( int x = 0 ; x < int( vpCrvs.size()) ; ++ x) {
/*CrvInfo myCrvInfo ;
myCrvInfo.pCrvCompo.Set( Release( vpCrvs[x])) ;
myCrvInfo.nChunk = cc ;
vCrvInfo.emplace_back( myCrvInfo) ;*/
vCrvInfo[ nIndex_offs + x].pCrvCompo.Set( Release( vpCrvs[x])) ;
vCrvInfo[ nIndex_offs + x].nChunk = cc ;
}
}
// se la regione non è dentro alla curva esterna allora la ignoro
@@ -2550,14 +2536,6 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
int nIndex_offs = int( vCrvInfo.size()) ;
vCrvInfo.resize( int( vAllCrv.size()) + nIndex_offs) ;
for ( int x = 0 ; x < int( vAllCrv.size()) ; ++ x) {
/*CrvInfo myCrvInfo ;
myCrvInfo.pCrvCompo.Set( Release( vAllCrv[x])) ;
myCrvInfo.nCrvType = CRV_BORDER ;
myCrvInfo.bMidOut = vbMidOut[x] ;
myCrvInfo.ptStart = vPtStart[x] ;
myCrvInfo.vtMidOut = vVtMidOut[x] ;
vCrvInfo.emplace_back( myCrvInfo) ;
*/
vCrvInfo[ nIndex_offs + x].pCrvCompo.Set( Release( vAllCrv[x])) ;
vCrvInfo[ nIndex_offs + x].nCrvType = CRV_BORDER ;
vCrvInfo[ nIndex_offs + x].bMidOut = vbMidOut[x] ;
@@ -4629,7 +4607,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
//----------------------------------------------------------------------------
bool
Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, const Vector3d& vtExtr,
double dDepth, double dElev, double dOkStep, bool bSplitArcs)
double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs)
{
// recupero distanze di sicurezza
@@ -4871,6 +4849,9 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
int nMaxInd = pMCrv->GetCurveCount() - 1 ;
int nMaxRInd = pRCrv->GetCurveCount() - 1 ;
// determino l'affondamento attuale
double dSink = dElev - dDepth + dMaxElev - vVtTrasl[j-1].Len() ;
// ciclo sulle curve elementari
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
@@ -4901,18 +4882,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
return false ;
// determino elevazione su inizio attacco (se non trovata, elevazione è step)
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dStep ;
bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab &&
GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
bool bUhAboveRaw = ! m_bAboveHead &&
GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
//if ( bAhUnderRaw || bUhAboveRaw || m_bTiltingTab)
//dStElev = max( dStElev, dCurrAffondamento) ;
dStElev = max( dStElev, j * dStep) ;
double dStElev = dSink ;
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
if ( GetLeadInType() == POCKET_LI_ZIGZAG ||
@@ -4926,7 +4896,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ;
return false ;
}
dStElev = max( dStElev, j * dStep) ;
//dStElev = max( dStElev, j * dStep) ;
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, pRCrv, !m_Params.m_bInvert, bSplitArcs, bOutStart || bForcedOutStart)) {
@@ -5012,14 +4982,12 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
pCurve->GetEndDir( vtEnd) ;
// aggiungo uscita
Point3d ptP1 ;
double dEndElev = dElev ;
double dEndElev = dSink ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, pRCrv, bSplitArcs, false, ptP1, dEndElev, true)) {
m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ;
return false ;
}
//if ( ! m_bAboveHead)
// dEndElev = max( dEndElev, j * dStep) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) {
m_pMchMgr->SetLastError( 2417, "Error in Pocketing : Retract not computable") ;
@@ -5039,7 +5007,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
//----------------------------------------------------------------------------
bool
Pocketing::AddSpiralOut( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, const Vector3d& vtExtr,
double dDepth, double dElev, double dOkStep, bool bSplitArcs)
double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
@@ -5422,6 +5390,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
if ( ! bHasIsland && pCrvOEWithFlags != nullptr) {
// caso spirale
PtrOwner<ICurveComposite> pCrvBorder( GetCurveComposite( pSrfPock->GetLoop( 0, 0))) ;
pCrvBorder->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ;
Point3d ptCen ; Vector3d vtN ; double dRad ; bool bCCW ;
if ( pCrvBorder->IsACircle( 100 * EPS_SMALL, ptCen, vtN, dRad, bCCW)) {
double dIntRad = 0 ;
@@ -5448,32 +5417,33 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
}
bool bSomeOpen = false ;
int nTmpProp0 = -1 ;
for ( int u = 0 ; u < pCrvOEWithFlags->GetCurveCount() && !bSomeOpen; ++ u) {
pCrvOEWithFlags->GetCurveTempProp( u, nTmpProp0, 0) ;
for ( int u = 0 ; u < pCrvBorder->GetCurveCount() && !bSomeOpen; ++ u) {
pCrvBorder->GetCurveTempProp( u, nTmpProp0, 0) ;
bSomeOpen = ( nTmpProp0 == 1) ;
}
// caso trapezoide
pCrvOEWithFlags->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ;
Point3d pt ; Vector3d vtB1, vtL1, vtB2 ;
if ( pCrvOEWithFlags->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) ;
if ( AreSameOrOppositeVectorApprox( vtL1, vtL2)) {
if ( vtL1.Len() > vtB1.Len())
swap( vtDir, vtOtherDir) ;
}
vtDir.Normalize() ;
Vector3d vtOrtho = OrthoCompo( vtOtherDir, vtDir) ;
double dPocketSize = vtOrtho.Len() ;
double dMaxOptSize ;
FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) ;
if ( ( ( bSomeOpen && dPocketSize < m_TParams.m_dDiam + EPS_SMALL) ||
abs( dPocketSize - m_TParams.m_dDiam) < EPS_SMALL) &&
( ! FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) ||
dPocketSize < dMaxOptSize))
{
//if ( pCrvOEWithFlags->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) ;
// if ( AreSameOrOppositeVectorApprox( vtL1, vtL2)) {
// if ( vtL1.Len() > vtB1.Len())
// swap( vtDir, vtOtherDir) ;
// }
// vtDir.Normalize() ;
// Vector3d vtOrtho = OrthoCompo( vtOtherDir, vtDir) ;
// double dPocketSize = vtOrtho.Len() ;
// double dMaxOptSize ;
// FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) ;
// if ( ( ( bSomeOpen && dPocketSize < m_TParams.m_dDiam + EPS_SMALL) ||
// abs( dPocketSize - m_TParams.m_dDiam) < EPS_SMALL) &&
// ( ! FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) ||
// dPocketSize < dMaxOptSize))
// {
/*
if ( nReg == 0) {
CalcTrapezoidSpiral( pCrvOEWithFlags, vtDir, dPocketSize, pMCrv, pRCrv, bOptimizedTrap) ;
if ( bOptimizedTrap) {
@@ -5483,8 +5453,9 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
}
else
return true ;
}
}
*/
// }
//}
}
// porto il Chunk c-esimo nel sistema di riferimento locale (assieme al punto inziale)
@@ -14806,4 +14777,332 @@ Pocketing::GetOptCrvIndex( const vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags, int
}
return true ;
}
//----------------------------------------------------------------------------
bool
Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam, ICurveComposite* pCrvTrap,
Vector3d& vtDir, double& dPocketSize)
{
// controllo parametri
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return false ;
// controllo il numero di lati chiusi e salvo i loro indici
int nClosedSide = 0 ;
INTVECTOR vIndClosedSides ;
for ( int u = 0 ; u < pCrvCompo->GetCurveCount() ; ++ u) {
int nTmpProp ;
if ( pCrvCompo->GetCurveTempProp( u, nTmpProp, 0) && nTmpProp == 0) {
++nClosedSide ;
vIndClosedSides.push_back( u) ;
}
}
// se tutti lati aperti
if ( nClosedSide == 0) {
// ricavo il box minimo della curva aperta ( passo dalla polyLine)
PolyLine PL ;
if ( ! pCrvCompo->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
return false ;
Point3d ptCen ; double dWidth, dHeight ;
if ( ! PL.GetMinAreaRectangleXY( ptCen, vtDir, dWidth, dPocketSize))
return false ;
// controllo dimY ( dHeight)
if ( dPocketSize > 2 * dDiam - 50 * EPS_SMALL)
return true ;
// inverto il frame attuale
Frame3d frRect ; frRect.Set( ptCen, Z_AX, vtDir) ;
if ( ! frRect.IsValid())
return false ;
// creo il rettangolo del Box
pCrvTrap->AddPoint( Point3d( - 0.5 * dWidth, - 0.5 * dPocketSize, 0)) ;
pCrvTrap->AddLine( Point3d( 0.5 * dWidth, - 0.5 * dPocketSize, 0)) ;
pCrvTrap->AddLine( Point3d( 0.5 * dWidth, 0.5 * dPocketSize, 0)) ;
pCrvTrap->AddLine( Point3d( - 0.5 * dWidth, 0.5 * dPocketSize, 0)) ;
pCrvTrap->Close() ;
pCrvTrap->ToGlob( frRect) ;
// imposto tutte le curve come aperte
for ( int u = 0 ; u < pCrvTrap->GetCurveCount() ; ++ u)
pCrvTrap->SetCurveTempProp( u, 1, 0) ;
}
// se un lato aperto
else if ( nClosedSide == 1) {
// prendo la curva
const ICurve* pCrvCurr = pCrvCompo->GetCurve( vIndClosedSides[0]) ;
if ( pCrvCurr == nullptr)
return false ;
// controllo se lineare
if ( pCrvCurr->GetType() != CRV_LINE)
return true ;
// prendo la direzione del tratto lineare
pCrvCurr->GetStartDir( vtDir) ;
// prendo il punto iniziale
Point3d ptStart ; pCrvCurr->GetStartPoint( ptStart) ;
// creo il riferimento basato su questo tratto
Frame3d frCurr ;
frCurr.Set( ptStart, Z_AX, vtDir) ;
if ( ! frCurr.IsValid())
return false ;
// porto la curva compo ( clonandola) nel frame
PtrOwner<ICurveComposite> pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ;
if ( IsNull( pCrvCompo_c))
return false ;
pCrvCompo_c->ToLoc( frCurr) ;
BBox3d BBox ;
pCrvCompo_c->GetLocalBBox( BBox) ;
// controllo dimY
if ( BBox.GetDimY() > 1.5 * dDiam + 50 * EPS_SMALL ||
! ( abs( BBox.GetMin().y) > EPS_SMALL && abs( BBox.GetMax().y) > EPS_SMALL))
return true ;
// creo il rettangolo del Box
pCrvTrap->AddPoint( BBox.GetMin()) ;
pCrvTrap->AddLine( BBox.GetMin() + BBox.GetDimX() * X_AX) ;
pCrvTrap->AddLine( BBox.GetMax()) ;
pCrvTrap->AddLine( BBox.GetMin() + BBox.GetDimY() * Y_AX) ;
pCrvTrap->Close() ;
// porto in globale
pCrvTrap->ToGlob( frCurr) ;
// imposto tutte le curve come aperte tranne la prima
for ( int u = 0 ; u < pCrvTrap->GetCurveCount() ; ++ u)
pCrvTrap->SetCurveTempProp( u, u == 0 ? 0 : 1, 0) ;
dPocketSize = BBox.GetDimY() ;
}
else {
// riordino gli indici in base alla lunghezza delle curva
sort( vIndClosedSides.begin(), vIndClosedSides.end(), ([pCrvCompo] ( int nInd_a, int nInd_b) {
double dLen_a, dLen_b ;
pCrvCompo->GetCurve( nInd_a)->GetLength( dLen_a) ;
pCrvCompo->GetCurve( nInd_b)->GetLength( dLen_b) ;
return dLen_b > dLen_a ;
})) ;
// cerco la base :
// lato lineare, box nella sua direzione con DimY < 1.5 dDiam, box dei restanti chiusi con dimY < dDiam
// il lato lineare deve essere un lato del box
bool bBaseFound = false ;
int nBase = -1 ;
int nSecondBase = -1 ;
BBox3d BBox ;
Frame3d frCurr ;
for ( int i = 0 ; i < int( vIndClosedSides.size()) && !bBaseFound ; ++ i) {
nBase = i ;
// prendo la curva
const ICurve* pCrvCurr = pCrvCompo->GetCurve( vIndClosedSides[i]) ;
if ( pCrvCurr == nullptr)
return false ;
// controllo se lineare
if ( pCrvCurr->GetType() != CRV_LINE)
continue ;
// prendo la direzione del tratto lineare
pCrvCurr->GetStartDir( vtDir) ;
// prendo il punto iniziale
Point3d ptStart ; pCrvCurr->GetStartPoint( ptStart) ;
// creo il riferimento basato su questo tratto
frCurr.Set( ptStart, Z_AX, vtDir) ;
if ( ! frCurr.IsValid())
return false ;
// porto la curva compo ( clonandola) nel frame
PtrOwner<ICurveComposite> pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ;
if ( IsNull( pCrvCompo_c))
return false ;
pCrvCompo_c->ToLoc( frCurr) ;
pCrvCompo_c->GetLocalBBox( BBox) ;
// controllo dimY
if ( BBox.GetDimY() > 1.5 * dDiam + 50 * EPS_SMALL ||
! ( abs( BBox.GetMin().y) > EPS_SMALL && abs( BBox.GetMax().y) > EPS_SMALL))
continue ;
// Box dei chiusi...
bool bOk = true ;
for ( int j = 0 ; j < int( vIndClosedSides.size()) ; ++ j) {
if ( i == j)
continue ;
// prendo la curva
const ICurve* pCrvOther = pCrvCompo_c->GetCurve( vIndClosedSides[j]) ;
if ( pCrvOther == nullptr)
return false ;
// calcolo il box
BBox3d BBoxOther ;
pCrvOther->GetLocalBBox( BBoxOther) ;
// controllo dimY
if ( BBox.GetDimY() > dDiam + 50 * EPS_SMALL) {
bOk = false ;
break ;
}
}
if ( bOk) {
// cerco se ho una seconda base lineare chiusa parallela alla prima e distante circa il diametro
for ( int u = 0 ; u < int( vIndClosedSides.size()) ; ++ u) {
if ( vIndClosedSides[u] == nBase || pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetType() != CRV_LINE)
continue ;
Vector3d vtCurr_dir ; pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetStartDir( vtCurr_dir) ;
if ( AreOppositeVectorApprox( vtCurr_dir, X_AX)) {
Point3d ptS0, ptS1 ;
pCrvCurr->GetStartPoint( ptS0) ;
pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetStartPoint( ptS1) ;
if ( abs( ptS1.y - ptS0.y - dDiam) > 50 * EPS_SMALL)
bOk = false ;
else
nSecondBase = vIndClosedSides[u] ;
}
}
}
bBaseFound = bOk ;
} // ?
if ( ! bBaseFound || nBase < 0)
return true ; // non è un caso ottimizzato
dPocketSize = BBox.GetDimY() ;
// se ho due basi
if ( nSecondBase > -1) {
// le parti tra le due basi devono essere tutte omogenee ( o tutte aperte o tutte chiuse)
Point3d ptSB0, ptSB1 ;
PtrOwner<ICurveComposite> pCrvTest0( CloneCurveComposite( pCrvCompo)) ;
PtrOwner<ICurveComposite> pCrvTest1( CloneCurveComposite( pCrvCompo)) ;
pCrvCompo->GetCurve( nBase)->GetStartPoint( ptSB0) ;
pCrvCompo->GetCurve( nSecondBase)->GetStartPoint( ptSB1) ;
pCrvTest0->ChangeStartPoint( nBase) ;
pCrvTest1->ChangeStartPoint( nSecondBase) ;
double dUTrim0, dUTrim1 ;
pCrvTest0->GetParamAtPoint( ptSB1, dUTrim0) ;
pCrvTest1->GetParamAtPoint( ptSB0, dUTrim1) ;
pCrvTest0->TrimStartEndAtParam( 1, dUTrim0) ;
pCrvTest1->TrimStartEndAtParam( 1, dUTrim1) ;
for ( int u = 0 ; u < pCrvTest0->GetCurveCount() - 1 ; ++ u) {
int nPropAct, nPropSucc ;
if ( pCrvTest0->GetCurveTempProp( u, nPropAct, 0) &&
pCrvTest0->GetCurveTempProp( u + 1, nPropSucc, 0) &&
nPropAct != nPropSucc)
return true ;
}
for ( int u = 0 ; u < pCrvTest1->GetCurveCount() - 1 ; ++ u) {
int nPropAct, nPropSucc ;
if ( pCrvTest1->GetCurveTempProp( u, nPropAct, 0) &&
pCrvTest1->GetCurveTempProp( u + 1, nPropSucc, 0) &&
nPropAct != nPropSucc)
return true ;
}
// creo le due curve di base
PtrOwner<ICurve> pCrvBase0( pCrvCompo->GetCurve( nBase)->Clone()) ;
PtrOwner<ICurve> pCrvBase1( pCrvCompo->GetCurve( nSecondBase)->Clone()) ;
pCrvBase0->ToLoc( frCurr) ;
pCrvBase1->ToLoc( frCurr) ;
Point3d ptEB0, ptEB1 ;
pCrvBase0->GetStartPoint( ptSB0) ;
pCrvBase0->GetEndPoint( ptEB0) ;
pCrvBase1->GetStartPoint( ptSB1) ;
pCrvBase1->GetEndPoint( ptEB1) ;
// controllo se lato destro o sinistro sono due semicirconferenze chiuse
bool bIsRightClosedArc = false ;
if ( pCrvTest0->GetCurveCount() == 1 && pCrvTest0->GetCurve( 0)->GetType() == CRV_ARC &&
pCrvTest0->GetCurve( 0)->GetTempProp( 0) == 0 &&
abs( (( ICurveArc*) pCrvTest0->GetCurve( 0))->GetAngCenter() - 180) < 50 * EPS_SMALL)
bIsRightClosedArc = true ;
bool bIsLeftClosedArc = false ;
if ( pCrvTest1->GetCurveCount() == 1 && pCrvTest1->GetCurve( 0)->GetType() == CRV_ARC &&
pCrvTest1->GetCurve( 0)->GetTempProp( 0) == 0 &&
abs( (( ICurveArc*) pCrvTest1->GetCurve( 0))->GetAngCenter() - 180) < 50 * EPS_SMALL)
bIsLeftClosedArc = true ;
// creo la linea a metà del box in direzione X_AX
PtrOwner<ICurveLine> pMidLine( CreateCurveLine()) ;
if ( IsNull( pMidLine) ||
! pMidLine->SetPVL( BBox.GetMin() + Y_AX * dDiam * 0.5, X_AX, 1.) ||
! pMidLine->IsValid())
return false ;
// se lato destro aperto
bool bCopyRight = false ;
if ( pCrvTest0->GetCurve( 0)->GetTempProp( 0) == 1 || bIsRightClosedArc) {
ptEB0 = BBox.GetMin() + X_AX * BBox.GetDimX() ;
ptSB1 = BBox.GetMax() ;
}
// se lato destro chiuso
else
bCopyRight = true ;
// se lato sinistro aperto
bool bCopyLeft = false ;
if ( pCrvTest1->GetCurve( 0)->GetTempProp( 0) == 1 || bIsLeftClosedArc) {
ptSB0 = BBox.GetMin() ;
ptEB1 = BBox.GetMax() - X_AX * BBox.GetDimX() ;
}
else
bCopyLeft = true ;
// creo la curva da restituire
pCrvTrap->AddPoint( ptSB0) ;
pCrvTrap->AddLine( ptEB0) ;
if ( bCopyRight)
pCrvTrap->AddCurve( Release( pCrvTest0)) ;
else {
pCrvTrap->AddLine( ptSB1) ;
pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, bIsRightClosedArc ? 0 : 1, 0) ; // aperta
}
pCrvTrap->AddLine( ptEB1) ;
if ( bCopyLeft)
pCrvTrap->AddCurve( Release( pCrvTest1)) ;
else {
pCrvTrap->Close() ;
pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, bIsLeftClosedArc ? 0 : 1, 0) ; // aperta
}
}
else {
// devo avere un solo lato chiuso ( la base), oppure tre lati chiusi di cui il box deve avere DimY curva il diam
if ( nClosedSide != 1 && nClosedSide != 3)
return true ;
if ( nClosedSide == 3) {
// prendo i 3 lati chiusi
const ICurve* pCrv0 = pCrvCompo->GetCurve( vIndClosedSides[0]) ;
const ICurve* pCrv1 = pCrvCompo->GetCurve( vIndClosedSides[1]) ;
const ICurve* pCrv2 = pCrvCompo->GetCurve( vIndClosedSides[2]) ;
if ( pCrv0 == nullptr || pCrv1 == nullptr || pCrv2 == nullptr)
return false ;
// prendo i punti iniziali e finali
Point3d ptStart0 ; pCrv0->GetStartPoint( ptStart0) ;
Point3d ptEnd0 ; pCrv0->GetEndPoint( ptEnd0) ;
Point3d ptStart1 ; pCrv1->GetStartPoint( ptStart1) ;
Point3d ptEnd1 ; pCrv1->GetEndPoint( ptEnd1) ;
Point3d ptStart2 ; pCrv2->GetStartPoint( ptStart2) ;
Point3d ptEnd2 ; pCrv2->GetEndPoint( ptEnd2) ;
// controllo che siano consecutivi
if ( AreSamePointApprox( ptEnd0, ptStart1) && AreSamePointApprox( ptEnd1, ptStart2))
;
else if ( AreSamePointApprox( ptEnd1, ptStart2) && AreSamePointApprox( ptEnd2, ptStart0)) {
swap( vIndClosedSides[0], vIndClosedSides[1]) ;
swap( vIndClosedSides[1], vIndClosedSides[2]) ;
}
else if ( AreSamePointApprox( ptEnd2, ptStart0) && AreSamePointApprox( ptEnd0, ptStart1)) {
swap( vIndClosedSides[0], vIndClosedSides[2]) ;
swap( vIndClosedSides[2], vIndClosedSides[1]) ;
}
else // se non consecutivi ? ( per ora esco)
return true ;
// controllo per sicurezza
if ( vIndClosedSides[1] != nBase)
return true ;
// controllo le distanze che siano effettivamente il dDiam
PtrOwner<ICurveComposite> pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ;
if ( IsNull( pCrvCompo_c))
return false ;
pCrvCompo_c->ToLoc( frCurr) ;
Point3d ptS0 ; pCrvCompo_c->GetCurve( vIndClosedSides[0])->GetStartPoint( ptS0) ;
Point3d ptS1 ; pCrvCompo_c->GetCurve( vIndClosedSides[1])->GetStartPoint( ptS1) ; // sempre zero (!)
Point3d ptE2 ; pCrvCompo_c->GetCurve( vIndClosedSides[2])->GetEndPoint( ptE2) ;
if ( ptS0.y - ptS1.y > dDiam + 50 * EPS_SMALL ||
ptE2.y - ptS1.y > dDiam + 50 * EPS_SMALL)
return true ;
// creo la curva
pCrvTrap->AddPoint( ptS0) ;
pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[0])->Clone()) ;
pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[1])->Clone()) ;
pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[2])->Clone()) ;
pCrvTrap->Close() ;
pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, 1, 0) ;
}
}
}
return true ;
}
Pocketing.h
+4 -2
View File
@@ -91,6 +91,8 @@ class Pocketing : public Machining
Vector3d& vtMidOut, bool& bMidOut) ;
bool GetOptCrvIndex( const std::vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags, int nStep, ISurfFlatRegion* pSrfChunkFinal,
int& nIndex) ;
bool GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam, ICurveComposite* pCrvTrap, Vector3d& vtDir,
double& dPocketSize) ;
// ===================================================================
// =========================== GREZZO e GEOMETRIE ====================
@@ -205,9 +207,9 @@ class Pocketing : public Machining
// ============================ SpiralIn/Out =========================
bool AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth,
double dElev, double dOkStep, bool bSplitArcs) ;
double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ;
bool AddSpiralOut( const ISurfFlatRegion* pSrfpock, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth,
double dElev, double dOkStep, bool bSplitArcs) ;
double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ;
bool CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptStart, Vector3d& vtMidOut , bool& bMidOut,
bool bSplitArcs,ICurveComposite* pMCrv, ICurveComposite* pRCrv, ICurveComposite* pCrvOEWithFlags,
bool vbChangedPrec, bool& bOptimizedTrap) ;