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

EgtMachKernel :

Browse Source 
- primo prototipo per funzione Feed.
This commit is contained in:
Riccardo Elitropi
2023-03-31 17:08:38 +02:00
parent 25b940927e
commit ed4a9ec745
2 changed files with 161 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+152 -10
View File
@@ -98,6 +98,7 @@ using namespace std ;
static string KEY_OPEN = "OPEN" ;
static const std::string BOX_NAME = "Box" ;
static int LINK_CURVE_PROP = -3 ;
static int FEED_DIVISOR = 1000 ;
//----------------------------------------------------------------------------
USEROBJ_REGISTER( GetOperationClass( OPER_POCKETING), Pocketing) ;
@@ -1236,7 +1237,7 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
INTVECTOR vBannedId{ -1, nFacet} ;
// 2) scorro tutte le curve del bordo esterno
for( int j = 0 ; j < pCrvCompo->GetCurveCount() ; ++j) {
for( int j = 0 ; j < pCrvCompo->GetCurveCount() ; ++ j) {
int nProp = 0 ;
// 3) controllo che nella seconda temp prop ho una faccia adiancente non già considerata da un altro bordo
// e creo un vettore con gli Id delle facce del bordo laterale adiacente alla curva j della pCrvCompo
@@ -4429,6 +4430,9 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, /*PNTVECTOR vPtStart,*/
&& ( j % 2 == 0))
pMCrv->Invert() ;
// superficie per scelta Feed
PtrOwner<ISurfFlatRegion> pSrfForFeed( CreateSurfFlatRegion()) ;
// ciclo sulle curve elementari
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
@@ -4992,7 +4996,6 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
PtrOwner<ISurfFlatRegion> pSrfPrec( CloneSurfFlatRegion( pSrfToWork)) ; // regione precedente
if( IsNull( pSrfAct) || IsNull( pSrfPrec) || pSrfAct->GetChunkCount() == 0 || pSrfPrec->GetChunkCount() == 0)
return false ;
PtrOwner<ISurfFlatRegion> pCutRegion( CreateSurfFlatRegion()) ; // regione lavorata dall'utensile
while ( nIter < MAX_ITER) {
// salvo la regione
@@ -5011,7 +5014,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
int nChunks = pSrfAct->GetChunkCount();
for ( int i = 0 ; i < nChunks; ++ i) {
for ( int i = 0 ; i < nChunks ; ++ i) {
// per ogni chunk...
int nLoops = pSrfAct->GetLoopCount( i) ;
for ( int j = 0 ; j < nLoops ; ++ j) {
@@ -5023,9 +5026,9 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
bool bInsert = true ;
if( ! CheckIfOffsetIsNecessary( ptoCCBorder, dOffs, ( int)vOffs.size(), nIter, vtExtr, bInsert))
return false ;
if ( bInsert)
if ( bInsert) {
vOffs.emplace_back( Release( ptoCCBorder)) ;
}
PtrOwner<ICurveComposite> ptoCCExtBorder( GetCurveComposite( pSrfAct->GetLoop( i, j))) ;
if ( nIter == 0) { // salvo il bordo per i link (non invertiti)
vOffsFirstCurve.emplace_back( Release( ptoCCExtBorder)) ;
@@ -5185,7 +5188,6 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
// 3) controllo eventuali parti non svuotate...
PtrOwner<ISurfFlatRegion> pSrfToCut( CreateSurfFlatRegion()) ;
if ( GetUnclearedRegion( vOffsFirstCurve, vOffs, vLinks, pSrfToCut)) {
m_pGeomDB->AddGeoObj(GDB_ID_NULL, GDB_ID_ROOT, pSrfToCut->Clone()) ;
// 4) Modifico i percorsi
if ( ! RemoveExtraParts( pSrfToCut, vOffs, vOffsClosedCurves, vOffsFirstCurve, vLinks))
return false ;
@@ -10308,12 +10310,15 @@ Pocketing::CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const doub
const int nIter, const Vector3d& vtN, bool& bInsert)
{
return true ;
// controllo dei parametri
if ( pCrvOffs == nullptr || ! pCrvOffs->IsValid() || pCrvOffs->GetCurveCount() == 0 || dOffs < EPS_SMALL)
return false ;
bInsert = true ; // di base inserisco
// controllo se richiesta ottimizzazione sul numero di Offsets
if ( ! m_bOptOffset)
return true ;
if ( nIter != 0) { // controllo se sono almeno al secondo offset...
// per ogni curva controllo se il controOffset + 5 * EPS_SMALL genera una regione ...
@@ -10328,9 +10333,8 @@ Pocketing::CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const doub
else
return true ;
// <- primo test
if( OffsCrv.GetCurveCount() > 1)
// controllo se richista ottimizzazione per Offsets mediante centroidi e medial Axis
if( ! m_bOptOffsetCM || OffsCrv.GetCurveCount() > 1)
return true ;
PtrOwner<ICurve> pCrvOffLonger( OffsCrv.GetLongerCurve()) ;
@@ -10381,3 +10385,141 @@ Pocketing::CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const doub
return true ;
}
//----------------------------------------------------------------------------
bool
Pocketing::SetApproxFeedAsTmpProp0( const int nPocketType, ICurveComposite* pCrv, ICurveComposite* pCrvOriOffSpiral,
const int nCrvType, const bool bIsFirst, const ISurfFlatRegion* PSrfRemoved,
const ICurveComposite* pCrvOrig, const double dOffs, const double dMinFeed,
const double dMaxFeed)
{
// =====================================================================================================
// nCrvType : 0 -> Curva Caratteristica | 1 -> Link | 2 -> Bordo di finitura
// =====================================================================================================
double dFeed = dMinFeed ;
INTVECTOR vIndCrvOE ;
for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u) {
const ICurve* pCrvAct = pCrv->GetCurve( u) ;
if ( pCrvAct != nullptr) {
int nStat = 0 ;
// controllo se ho la sottocurva che coincide con un lato aperto
if ( CheckSimpleOverlap( pCrvAct, pCrvOrig, nStat, 1500 * EPS_SMALL) && nStat == 1) {
pCrv->SetCurveTempProp( u, FEED_DIVISOR * 0.5 * ( dMaxFeed + dMinFeed)) ;
vIndCrvOE.push_back( u) ;
}
// controllo che la sottocurva non sia una curva per zona non svuotata
else if( nCrvType == POCKET_SUB_SPIRALIN || nCrvType == POCKET_SUB_SPIRALOUT) {
if ( CheckSimpleOverlap( pCrvAct, pCrvOriOffSpiral, nStat, 10 * EPS_SMALL) && nStat == 0) {
pCrv->SetCurveTempProp( u, FEED_DIVISOR * dMaxFeed ) ;
vIndCrvOE.push_back( u) ;
}
}
}
}
switch ( nPocketType)
{
case POCKET_SUB_SPIRALIN :
case POCKET_SUB_SPIRALOUT :
switch ( nCrvType)
{
case 0 : // Curva di Offset
if ( bIsFirst)
dFeed = dMinFeed ;
else // ...
dFeed = dMinFeed + (( dMaxFeed - dMinFeed) / ( m_TParams.m_dDiam / 2) ) * dOffs ;
case 1 : // Link
if ( PSrfRemoved != nullptr && PSrfRemoved->IsValid() && PSrfRemoved->GetChunkCount() != 0 &&
pCrv != nullptr && pCrv->IsValid() && pCrv->GetCurveCount() != 0) {
CRVCVECTOR ccClass ;
if ( PSrfRemoved->GetCurveClassification( *pCrv, EPS_SMALL, ccClass)) {
double dLenInside = EPS_SMALL ; double dLenOutSide = EPS_SMALL ;
for ( int i = 0 ; i < ( int)ccClass.size() ; ++ i) {
double dLen = EPS_SMALL ;
PtrOwner<ICurve> pCrvSub( pCrv->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE)) ;
if ( ! IsNull( pCrvSub) && pCrvSub->IsValid())
pCrvSub->GetLength( dLen) ;
else
dFeed = dMinFeed ;
if ( ccClass[i].nClass == CRVC_IN)
dLenInside += dLen ;
else
dLenOutSide += dLen ;
}
if ( dLenInside < 100 * EPS_SMALL) // curva circa tutta fuori
dFeed = dMaxFeed ;
else if ( dLenOutSide < 100 * EPS_ANG_SMALL) // curva circa tutta dentro
dFeed = dMinFeed ;
else
dFeed = dMinFeed + ( dLenOutSide / ( dLenInside + dLenOutSide)) * ( dMaxFeed - dMinFeed) ;
}
else
dFeed = dMinFeed ;
}
else
dFeed = dMinFeed ;
default :
break ;
}
break ;
case POCKET_SUB_ZIGZAG :
switch ( nCrvType )
{
case 0 : // Linea percorso ZigZag
if ( bIsFirst)
dFeed = dMinFeed ;
else
dFeed = dMinFeed + (( dMaxFeed - dMinFeed) / ( m_TParams.m_dDiam / 2)) * dOffs ;
case 1 : // Link
dFeed = dMaxFeed ;
case 2 : // Bordo di finitura
dFeed = dMinFeed + ( 2.0 / 3.0) * ( dMaxFeed - dMinFeed) ;
default :
break ;
}
break ;
case POCKET_SUB_ONEWAY :
switch ( nCrvType )
{
case 0 : // Linea percorso OneWay
if ( bIsFirst)
dFeed = dMinFeed ;
else
dFeed = dMinFeed + (( dMaxFeed - dMinFeed) / ( m_TParams.m_dDiam / 2)) * dOffs ;
case 2 : // Bordo di finitura
dFeed = dMaxFeed ;
default :
break ;
}
default :
break ;
}
for ( int u = 0 ; u < ( int)pCrv->GetCurveCount() ; ++ u) {
if ( find( vIndCrvOE.begin(), vIndCrvOE.end(), u) == vIndCrvOE.end())
pCrv->SetCurveTempProp( u, dFeed * FEED_DIVISOR, 0) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Pocketing::GetDynamicClearedRegion( ISurfFlatRegion* pSrfPrec, const ICurveComposite* pCrv)
{
PtrOwner<ICurve> pCrvPath( pCrv->Clone()) ;
if ( IsNull( pCrvPath))
return false ;
PtrOwner<ISurfFlatRegion> PSrfRemoved( GetSurfFlatRegionFromFatCurve( Release( pCrvPath), m_TParams.m_dDiam / 2, true, false)) ;
if ( pSrfPrec->GetChunkCount() == 0)
pSrfPrec->CopyFrom( Release( PSrfRemoved)) ;
else
pSrfPrec->Add( *Release( PSrfRemoved)) ;
return true ;
}
Pocketing.h
+9
View File
@@ -160,6 +160,7 @@ class Pocketing : public Machining
const int nOffsCount, const Vector3d& vtN, bool& bInsert) ;
bool GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR& vCrvs, ICURVEPOVECTOR& vLinks,
ISurfFlatRegion* pSrfToCut) ;
bool GetDynamicClearedRegion( ISurfFlatRegion* pSrfPrec, const ICurveComposite* pCrv) ;
bool RemoveFirstLoopFromSfr( ISurfFlatRegion* pSrfOrig ) ;
bool RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOffs, ICRVCOMPOPOVECTOR& vOffsClosedCurves,
ICRVCOMPOPOVECTOR& vOffsFirstCurve, ICURVEPOVECTOR& vLinks) ;
@@ -202,6 +203,10 @@ class Pocketing : public Machining
// =========================================================================
// ============================ IN/OUT =====================================
bool SetApproxFeedAsTmpProp0( const int nPocketType, ICurveComposite* pCrv, ICurveComposite* pCrvOriOffSpiral,
const int nCrvType, const bool bIsFirst, const ISurfFlatRegion* PSrfRemoved,
const ICurveComposite* pCrvOrig, const double dOffs, const double dMinFeed,
const double dMaxFeed) ;
bool VerifyLeadInHelix( ISurfFlatRegion* pSrfChunk, const Point3d& ptCen, double dRad) const ;
bool VerifyLeadInZigZag( ISurfFlatRegion* pSrfChunk, const Point3d& ptPa, const Point3d& ptPb) const ;
bool CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist, Vector3d& vtNorm) ;
@@ -279,5 +284,9 @@ class Pocketing : public Machining
Vector3d m_vtAggrBottom ; // vettore direzione ausiliaria aggregato da sotto
AggrBottom m_AggrBottom ; // dati eventuale aggregato da sotto
bool m_bOpenOutRaw ; // flag forzatura lati aperti sempre fuori dal grezzo
bool m_bOptOffset = true ; // flag per ottimizzazione numero di Offset necessari
bool m_bOptOffsetCM = false ; // flag per ottimizzazione numero di Offset necessari con centroidi e medial Axis
double m_dDiam_Prec ; // diametro utensile per precedente svuotatura
double m_dOffsetR_Prec ; // Offset radiale della svuotatura precedente
} ;