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

EgtMachKernel :

Browse Source 
- migliorie codice con test reali.
This commit is contained in:
Riccardo Elitropi
2023-11-09 17:11:39 +01:00
parent ce704bdcbc
commit c8cd417dac
2 changed files with 115 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+113 -200
View File
@@ -637,8 +637,8 @@ Pocketing::Apply( bool bRecalc, bool bPostApply)
}
// verifico se necessario continuare nell'aggiornamento
if ( !bRecalc && !bToolChanged &&
( m_nStatus == MCH_ST_OK || ( !bPostApply && m_nStatus == MCH_ST_NO_POSTAPPL))) {
if ( !bRecalc && !bToolChanged &&
( m_nStatus == MCH_ST_OK || ( !bPostApply && m_nStatus == MCH_ST_NO_POSTAPPL))) {
// confermo i percorsi di lavorazione
m_nPockets = nCurrPockets ;
LOG_DBG_INFO( GetEMkLogger(), "Pocketing apply skipped : status already ok") ;
@@ -753,7 +753,7 @@ Pocketing::Update( bool bPostApply)
return true ;
}
// elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo)
// elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo)
RemoveClimbRiseHome() ;
// imposto eventuale asse bloccato da lavorazione
@@ -966,7 +966,7 @@ Pocketing::UpdateToolData( bool* pbChanged)
if ( m_pMchMgr->GetCurrSetupMgr().GetToolData( m_TParams.m_sName, sTcPos, sHead, nExit)) {
if ( sOrigTcPos != sTcPos ||
sOrigHead != sHead ||
nOrigExit != nExit)
nOrigExit != nExit)
bChanged = true ;
m_TParams.m_sTcPos = sTcPos ;
m_TParams.m_sHead = sHead ;
@@ -1114,12 +1114,15 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
const ICurve* pOriCurve = ::GetCurve( pGObj) ;
if ( pOriCurve == nullptr)
return false ;
// converto in composita
PtrOwner<ICurveComposite> pOriCurveCompo( CreateCurveComposite()) ;
pOriCurveCompo->AddCurve( pOriCurve->Clone()) ;
// recupero estrusione e spessore
double dThick ; pOriCurve->GetThickness( dThick) ;
Vector3d vtExtr ; pOriCurve->GetExtrusion( vtExtr) ;
pOriCurveCompo->SetExtrusion( vtExtr) ;
pOriCurveCompo->SetThickness( dThick) ;
// rilascio
pCurve.Set( pOriCurveCompo) ;
// recupero eventuali informazioni per lati aperti
SetCurveAllTempProp( Id.nId, false, pCurve) ;
@@ -1177,7 +1180,7 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
// porto le curve in globale
for ( auto pCrv : lstPC)
pCrv->ToGlob( frGlob) ;
// salvo come TmpProp0 -> l'id della superificie ( per ogni loop )
// salvo come TmpProp0 -> l'id della superificie ( per ogni loop)
// salvo come TmpProp1 -> -1 ( non ho lati adiacenti)
for ( auto pCrv : lstPC) {
pCrv->SetTempProp( Id.nId, 0) ;
@@ -1193,7 +1196,7 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
if ( pSurf == nullptr)
return false ;
// recupero l'indice della faccia
int nFacet = ( ( Id.nSub == SEL_SUB_ALL) ? 0 : Id.nSub) ;
int nFacet = (( Id.nSub == SEL_SUB_ALL) ? 0 : Id.nSub) ;
// recupero i contorni della faccia
POLYLINEVECTOR vPL ;
pSurf->GetFacetLoops( nFacet, vPL) ;
@@ -1236,7 +1239,7 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
}
else
// salvo come prop 1 la faccia adiacente
pCrvCompo->SetCurveTempProp( nInd, nFlag, 1) ; // --> il lato chiuso è 0 per default
pCrvCompo->SetCurveTempProp( nInd, nFlag, 1) ; // --> il lato chiuso ha TmpProp0 0 per default
}
// passo al successivo
++nInd ;
@@ -1250,9 +1253,9 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ;
// sistemazioni varie
AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, 0) ;
// salvo come TmpProp0 -> l'id della superificie
// salvo come TmpProp0 della curva composita -> l'id della superificie
pCrvCompo->SetTempProp( Id.nId, 0) ;
// salvo come TmpProp1 -> il numero della faccia selezionata
// salvo come TmpProp1 della curva composita -> il numero della faccia selezionata
pCrvCompo->SetTempProp( nFacet, 1) ;
// la restituisco
lstPC.emplace_back( Release( pCrvCompo)) ;
@@ -1284,6 +1287,7 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
if ( ! pCrvCompo.Set( ConvertCurveToComposite( pReg->GetLoop( nC, nL))))
return false ;
// reset proprietà temporanee ( per ogni sottocurva -> nProp0 = 0, nProp1 = -1)
// la curva risulta tutta chiusa
ResetCurveAllTempProp( pCrvCompo) ;
// assegno l'estrusione dalla normale alla regione
pCrvCompo->SetExtrusion( vtN) ;
@@ -1367,10 +1371,6 @@ Pocketing::ResetCurveAllTempProp( ICurve* pCurve)
if ( pCC != nullptr) {
for ( int i = 0 ; i < pCC->GetCurveCount() ; ++ i) {
pCC->SetCurveTempProp( i, 0, 0) ;
//int nTmpProp1 ; pCC->GetCurveTempProp( i, nTmpProp1, 1) ;
//if ( nTmpProp1 != -2)
// pCC->SetCurveTempProp( i, -1, 1) ;
}
}
return true ;
@@ -1476,7 +1476,7 @@ Pocketing::Chain( int nGrpDestId)
pCrvCompo->SetExtrusion( vtExtr) ;
pCrvCompo->SetThickness( dThick) ;
// aggiorno il nuovo punto vicino
pCrvCompo->GetEndPoint( ptNear) ;
pCrvCompo->GetEndPoint( ptNear) ;
// se utile, approssimo con archi
//if ( ! ApproxWithArcsIfUseful( pCrvCompo, true))
// return false ;
@@ -1541,16 +1541,16 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
// indici da associare alla SurfFlatRegion da svuotare :
// Ogni curva che definirà un loop nella flat Region avrà la seguente struttura :
// { nProp0, nProp1 } = { Id elemento selezionato, id faccia adiacente (solo per Trimesh) }
// Per ogni curva di questi loop avrò :
// { nProp0, nProp1 } = { (0 -> chiuso, 1 -> aperto) , id faccia adiacente ( solo per Trimesh )}
// { nProp0, nProp1 } = { Id elemento selezionato, Id faccia adiacente (solo per Trimesh) }
// Per ogni curva di questi loop ( CurveCompo) avrò :
// { nProp0, nProp1 } = { (0 -> chiuso, 1 -> aperto) , id faccia adiacente ( solo per Trimesh)}
int nProp0 = -1 ;
int nProp1 = -1 ;
while ( nPathId != GDB_ID_NULL) { // Scorro tutte le curve concatenate per creare la superficie da lavorare
int nPi = m_pGeomDB->GetFirstInGroup( nPathId) ; //nCrvId
int nPi = m_pGeomDB->GetFirstInGroup( nPathId) ;
if ( m_pGeomDB->GetGeoType( nPi) != CRV_COMPO)
return false ;
const ICurve* pOriCurve = ::GetCurve( m_pGeomDB->GetGeoObj( nPi)) ;
@@ -1561,7 +1561,7 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
return false ;
// ricavo le proprietà della curva
nProp0 = pCompoOriCrv->GetTempProp( 0) ; // id selezionato
nProp0 = pCompoOriCrv->GetTempProp( 0) ; // Id selezionato
nProp1 = pCompoOriCrv->GetTempProp( 1) ; // lato adiancente per Trimesh
// annullo i flag di tratto aperto
@@ -1597,10 +1597,10 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
pCompoOriCrv->SetThickness( dThick_p) ;
// setto come proprietà temperanea il suo Id
pCompoOriCrv->SetTempProp( nProp0, 0) ; // a tutta la curva ( id selezionato )
pCompoOriCrv->SetTempProp( nProp1, 1) ; // a tutta la curva ( se Trimesh, faccia adiacente )
pCompoOriCrv->SetTempProp( nProp0, 0) ; // a tutta la curva ( id selezionato)
pCompoOriCrv->SetTempProp( nProp1, 1) ; // a tutta la curva ( se Trimesh, faccia adiacente)
// controllo che le curve siano complanari e con stessa estrusione (la prima come riferimento)
// controllo che le curve siano complanari e con stessa estrusione ( la prima come riferimento)
Plane3d plAct ;
pCompoOriCrv->IsFlat( plAct) ;
if ( bFirstPlane) {
@@ -1608,7 +1608,7 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
bFirstPlane = false ;
pCompoOriCrv->GetThickness( dThick_p) ;
dThick = dThick_p ; // prima come riferimento
vtExtr = vtExtr_p ; // prima come riferimento
vtExtr = vtExtr_p ; // prima come riferimento
SrfByC.AddCurve( pCompoOriCrv->Clone()) ;
}
else {
@@ -1641,13 +1641,14 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
pSrfPock->Invert() ;
if ( m_Params.m_bToolInvert) {
// eventuale inversione direzione utensile
// eventuale inversione direzione utensile
vtExtr.Invert() ;
pSrfPock->Invert() ;
dThick = -dThick ;
dThick = - dThick ;
}
// controllo se la superificie contiene lati aperti interno al grezzo
// controllo se la superificie contiene lati aperti interni al grezzo
#if 0
// 1) recupero la Trimesh del grezzo
PtrOwner<ISurfTriMesh> pStmRaw( CreateSurfTriMesh()) ;
if ( IsNull( pStmRaw))
@@ -1658,6 +1659,7 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
// 2) Imposto TmpProp1 = -2 a tutti i lati aperti ( TmpProp0 = 1 ) interno al grezzo
if ( ! DetectOpenEdgeInsideRaw ( pSrfPock, pStmRaw))
return false ;
#endif
// recupero il box del grezzo in globale
BBox3d b3Raw ;
@@ -1714,7 +1716,7 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
// eventuale imposizione massima elevazione da note utente
double dMaxElev ;
if ( FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxElev="), dMaxElev) && dElev > dMaxElev)
if ( FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxElev="), dMaxElev) && dElev > dMaxElev)
dElev = dMaxElev ;
// verifico che lo step dell'utensile sia sensato
@@ -1852,10 +1854,10 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
//----------------------------------------------------------------------------
bool
Pocketing::DetectOpenEdgeInsideRaw ( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw) {
return true ;
Pocketing::DetectOpenEdgeInsideRaw( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw)
{
#if 0
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid() || pSfr->GetChunkCount() == 0 ||
pStmRaw == nullptr || ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0)
@@ -1954,6 +1956,8 @@ Pocketing::DetectOpenEdgeInsideRaw ( ISurfFlatRegion* pSfr, const ISurfTriMesh*
}
// 6) controllo validità
return pSfr != nullptr && pSfr->IsValid() && pSfr->GetChunkCount() != 0 ;
#endif
return true ;
}
@@ -2381,21 +2385,11 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
vCrvInfo.resize( int( vpCrvs.size()) + int( vCrvIslMergeBorders.size())) ;
// aggiorno le curve per lo step attuale ( potrebbero essere usate per il successivo)
for ( int x = 0 ; x < int( vpCrvs.size()) ; ++ x) {
/*
CrvInfo myCrvInfo ;
myCrvInfo.pCrvCompo.Set( vpCrvs[x]->Clone()) ;
Point3d ptS ;
myCrvInfo.pCrvCompo->GetStartPoint( ptS) ;
myCrvInfo.ptStart = ptS ;
myCrvInfo.nChunk = cc ;
vCrvInfo.emplace_back( myCrvInfo) ;
*/
vCrvInfo[x].pCrvCompo.Set( vpCrvs[x]->Clone()) ;
Point3d ptS ;
vCrvInfo[x].pCrvCompo->GetStartPoint( ptS) ;
vCrvInfo[x].ptStart = ptS ;
vCrvInfo[x].nChunk = cc ;
}
// creo localmente i parametri della funzione
VCT3DVECTOR vVtMidOut(( int)vCrvIslMergeBorders.size()) ;
@@ -2514,8 +2508,6 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSrfForCrv->GetLoop( cfc, l))) ;
if ( IsNull( pCrvLoop))
return false ;
if ( l > 0)
pCrvLoop->Invert() ;
bool bOutTmp = false ;
@@ -2597,7 +2589,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
pCrvCurr->GetStartPoint( ptStart) ;
Vector3d vtDir ;
pCrvCurr->GetStartDir( vtDir) ;
Point3d ptTest = ptStart + ( - vtDir) * ( m_TParams.m_dDiam / 2 - dOffsOpt + dSafeZ) ;
Point3d ptTest = ptStart + ( - vtDir) * ( m_TParams.m_dDiam / 2 - dOffsOpt + max( dSafeZ, m_dOpenMinSafe)) ;
ptTest.Translate( vVtTrasl[j-1]) ;
double dTestElev ;
// se è nel grezzo provo a ruotare di 90 gradi
@@ -2607,7 +2599,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
Vector3d vtDirO = vtDir ;
vtDirO.Rotate( vtTool, ( m_Params.m_bInvert ? -90 : 90)) ;
Point3d ptTestO = ptStart + vtDirO *
( m_TParams.m_dDiam / 2 - dOffsOpt + dSafeZ) ;
( m_TParams.m_dDiam / 2 - dOffsOpt + max( dSafeZ, m_dOpenMinSafe)) ;
ptTestO += - vtTool * dDepth ;
double dTestElevO ;
// se è fuori dal grezzo uso inizio ruotato
@@ -2648,7 +2640,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
pCrvCurr->GetStartPoint( ptStart) ;
Vector3d vtDir ;
pCrvCurr->GetStartDir( vtDir) ;
ptStart += -vtDir * ( m_TParams.m_dDiam / 2 - dOffsOpt + dSafeZ) ;
ptStart += -vtDir * ( m_TParams.m_dDiam / 2 - dOffsOpt + max( dSafeZ, m_dOpenMinSafe)) ;
ptStart += -vtTool * dDepth ;
// controllo l'elevazione
double dTestElev ;
@@ -2657,7 +2649,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
bOutRawLeadIn = true ;
// sistemo attacco ( per essere completamente fuori dal grezzo)
if ( bOutRawLeadIn || m_bOpenOutRaw)
pCrvCurr->ExtendStartByLen( m_TParams.m_dDiam / 2 - dOffsOpt + dSafeZ) ;
pCrvCurr->ExtendStartByLen( m_TParams.m_dDiam / 2 - dOffsOpt + max( dSafeZ, m_dOpenMinSafe)) ;
}
@@ -2802,7 +2794,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
// se la curva è valida per entrata da fuori, aggiungo un piccolo tratto lineare
if ( vCrvInfo[u].bMidOut) {
// calcolo il punto fuori
Point3d ptOut = vCrvInfo[u].ptStart + vCrvInfo[u].vtMidOut * ( 0.5 * m_TParams.m_dDiam + dSafeZ) ;
Point3d ptOut = vCrvInfo[u].ptStart + vCrvInfo[u].vtMidOut * ( 0.5 * m_TParams.m_dDiam + max( dSafeZ, m_dOpenMinSafe)) ;
ptOut.ToGlob( frCurr) ;
ptOut.Translate( vVtTrasl[j-1]) ;
double dStElev ;
@@ -3501,31 +3493,10 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
if ( IsNull( pSrfPocket))
return false ;
// recupero la curva ORIGINALE che delimita la svuotatura (questa curva non risente dell'offset fatto dalla superificie creata dopo)
/*PtrOwner<ICurveComposite> pCrvForId( GetCurveComposite( pSrfPocket->GetLoop( 0, 0))) ;
int nCrvId = pCrvForId->GetTempProp( 0) ;
PtrOwner<ICurveComposite> pCrvPocket( CloneCurveComposite( m_pGeomDB->GetGeoObj( nCrvId))) ;
bool bSrfOriIsCut = false ;
if ( IsNull( pCrvPocket)) {
pCrvPocket.Set( pCrvOrig->Clone()) ;
if ( IsNull( pCrvPocket) || pCrvPocket->GetCurveCount() == 0)
return true ;
bSrfOriIsCut = true ;
}*/
// recupero la curva dal bordo della superficie
PtrOwner<ICurveComposite> pCrvPocket( ConvertCurveToComposite( pSrfPocket->GetLoop( 0, 0))) ;
if ( IsNull( pCrvPocket))
return false ;
// porto la curva nel sistema di riferimento locale
//pCrvPocket->ToLoc( frPocket) ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvPocket->Clone()) ;
// setto proprietà sulle curve
//if ( ! bSrfOriIsCut)
// SetCurveAllTempProp( nCrvId, GetForcedClosed(), pCrvPocket) ;
pCrvPocket->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
// sistemo senso antiorario visto dalla direzione di estrusione
@@ -3564,8 +3535,6 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
break ;
}
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvPocket->Clone()) ;
// se non sono in un caso ottimizzato, allora esco
if ( ! bOptimizedZigZag)
return true ;
@@ -3635,7 +3604,7 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
// calcolo il percorso di svuotatura
pSfrZigZag->ToGlob( frPocket) ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrZigZag->Clone()) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrZigZag->Clone()) ;
pSfrZigZag->ToLoc( frPocket) ;
if ( ! CalcZigZag( pSfrZigZag, vpCrvs))
return false ;
@@ -4252,8 +4221,6 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
PtrOwner<ICurveComposite> pCrvCompoLoop( ConvertCurveToComposite( pSrfChuck_c->GetLoop( cc, l))) ;
if ( IsNull( pCrvCompoLoop) || ! pCrvCompoLoop->IsValid())
return false ;
if ( l > 0)
pCrvCompoLoop->Invert() ;
vAllCrv.emplace_back( Release( pCrvCompoLoop)) ;
vInd.emplace_back( c) ;
}
@@ -4306,7 +4273,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
// se la curva è valida per entrata da fuori, aggiungo un piccolo tratto lineare
if ( vbMidOut[u]) {
// calcolo il punto fuori
Point3d ptOut = vPtStart[u] + vVtMidOut[u] * ( 0.5 * m_TParams.m_dDiam + dSafeZ) ;
Point3d ptOut = vPtStart[u] + vVtMidOut[u] * ( 0.5 * m_TParams.m_dDiam + max( dSafeZ, m_dOpenMinSafe)) ;
ptOut.Translate( vVtTrasl[j-1]) ; // lo traslo allo step corrente
double dStElev ;
bool bOutStart = ( ! GetElevation( m_nPhase, ptOut, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dStElev) ||
@@ -4649,6 +4616,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
if ( IsNull( pSrfChunk))
return false ;
// modifico le superifici in base alla geometria del grezzo e alla geometria dell'entità selezionata
ISURFFRPOVECTOR vSrfSliced( nStep) ;
vector<ICRVCOMPOPOVECTOR> vCrvOEWithFlags( nStep) ;
@@ -4658,15 +4626,14 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
nStep, vtTool, dElev, dDepth, dStep))
return false ;
Point3d ptP1, ptStartPrec ; // per LeadIn attuale e precedente
bool bMidOutPrec ; // flag per entrata precedente da fuori dal grezzo
BOOLVECTOR vbMidOutPrec ; // flags per effettiva entrata precedente da fuori dal grezzo
Point3d ptP1, ptStartPrec ; // per LeadIn attuale e precedente
BOOLVECTOR vbMidOutPrec ; // flags per effettiva entrata precedente da fuori dal grezzo
ICRVCOMPOPOVECTOR vMCrv_step_prec ; // vettore delle curve dei percorsidi svuotatura dello step precedente
ICRVCOMPOPOVECTOR vRCrv_step_prec ; // vettore delle curve dei percorsi di ritorno dello step precedente
vector<Vector3d> vvtMidOutPrec ; // vettore dei versori delle direzioni di uscita dello step precedente
INTVECTOR vnRegTot_prec ; // vettore dei numeri delle regioni formate dal primo Offset nello step precedente
BOOLVECTOR vbOptTrap_prec ; // flags per caso ottimizzato svuotratura dello step precedente
int nOffs_act = 0 ;
INTVECTOR vnRegTot_prec ; // vettore dei numeri delle regioni formate dal primo Offset nello step precedente
BOOLVECTOR vbOptTrap_prec ; // flags per caso ottimizzato svuotratura dello step precedente
int nOffs_act = 0 ; // Shift indice dei vettori causato da nReg
// ciclo su tutti gli step
for ( int j = 1 ; j <= nStep ; ++ j) {
@@ -4693,18 +4660,18 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
vbOptTrap_prec.clear() ;
}
for ( int cc = 0 ; cc < ( int)pSrfFinal->GetChunkCount() ; ++ cc) { // per ogni suo chunk cc-esimo...
for ( int cc = 0 ; cc < pSrfFinal->GetChunkCount() ; ++cc) { // per ogni suo chunk cc-esimo...
// il numero di chunk dopo aver intersecato e proiettato può cambiare
// essendo una svuotatura a spirale, facendo il primo offset del chunk cc-esimo potrei ottenere
// ulteriori chunks ( ad esempio se la superificie presenta delle parti molto strette)
// MAX_REGS = 50 -> # massimo di Chunks nuovi accettati
// MAX_REGS = 50 -> numero massimo di Chunks nuovi accettati
const int MAX_REGS = 50 ;
int nReg = 0 ; // chunk nuovo corrente da svuotare
PtrOwner<ISurfFlatRegion> pSrfChunkFinal( pSrfFinal->CloneChunk( cc)) ;
// ciclo su tutte le regioni che posso ottenere col primo Offset del chunc cc-esimo
// ciclo su tutte le regioni che posso ottenere col primo Offset del chunk cc-esimo
while ( nReg < MAX_REGS) {
// superifice per ingressi ed uscite
@@ -4733,7 +4700,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
// NB. se la superficie è rimasta la stessa, utilizzo pMCrv e pRCrv dello step precedente
// ( non c'è bisogno di ricalcolare tutti i percorsi)
if ( ! vbChangedPrec[j-1] && j != 1) {
if ( nOffs_act > ( int)vMCrv_step_prec.size() - 1)
if ( nOffs_act > int( vMCrv_step_prec.size()) - 1)
break ;
pMCrv.Set( vMCrv_step_prec[nOffs_act]->Clone()) ;
pRCrv.Set( vRCrv_step_prec[nOffs_act]->Clone()) ;
@@ -4755,32 +4722,13 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
m_TParams.m_dDiam += 2 * m_Params.m_dEpicyclesRad ;
}
// cerco la curva originale del chunk cc-esimo ( PER CASI OTTIMIZZATI)
// cerco la curva originale del chunk cc-esimo ( per casi ottimizzati)
int nInd = 0 ; // indice del vettore delle curve esterne relativo al chunk cc-esimo
// cerco la curva originale del chunk cc-esimo
if (( int)vCrvOEWithFlags[j-1].size() == 1)
nInd = 0 ;
else {
for ( int k = 0 ; k < ( int)vCrvOEWithFlags[j-1].size() ; ++ k) {
CRVCVECTOR ccClass ;
if ( pSrfChunkFinal->GetCurveClassification( *vCrvOEWithFlags[j-1][k], EPS_SMALL, ccClass)) {
bool bIsThis = true ;
for ( int kk = 0 ; kk < ( int)ccClass.size() && bIsThis ; ++ kk) {
if ( ccClass[kk].nClass == CRVC_OUT)
bIsThis = false ;
}
if ( bIsThis) {
nInd = k ;
break ;
}
}
}
}
if ( ! GetOptCrvIndex( vCrvOEWithFlags, j, pSrfChunkFinal, nInd))
return false ;
// ------------------------------------------------------------------------------------
nRegTot = nReg ;
// calcolo il percorso di svuotatura
if ( ! CalcSpiral( pSrfChunkFinal, nRegTot, ptStart, vtMidOut, bMidOut, bSplitArcs, pMCrv, pRCrv,
vCrvOEWithFlags[j-1][nInd], j == 1 ? true : vbChangedPrec[j-1],
@@ -4815,10 +4763,11 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
}
// controlli per entrate da fuori al grezzo
// NB. Anche se la superficie è rimasta invariata le entrate vanno controllate caso per caso
bOutStart = bMidOut ;
if ( bOutStart && ! bOptimizedTrap) {
// calcolo il punto fuori per il LeadIn
Point3d ptOut = ptStart + vtMidOut * ( 0.5 * m_TParams.m_dDiam + dSafeZ) ;
Point3d ptOut = ptStart + vtMidOut * ( 0.5 * m_TParams.m_dDiam + max( dSafeZ, m_dOpenMinSafe)) ;
ptOut.Translate( vVtTrasl[j-1]) ; // lo traslo allo step corrente
double dStElev ;
// controllo l'elevazione
@@ -4862,15 +4811,15 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
}
}
// se sono nel caso ottimizzato e ho attacco e uscita entrambi dentro/fuori dal grezzo,
// se sono nel caso ottimizzato per Trapezi e ho attacco e uscita entrambi dentro/fuori dal grezzo,
// ad ogni step pari inverto la direzione della curva solamente se ho un solo chunk e la superificie successiva
// non è cambiata
if ( bOptimizedTrap && nOutsideRaw != 1 && j > 1 && vSrfSliced[j-2]->GetChunkCount() == 1 && ! vbChangedPrec[j-1]
&& ( j % 2 == 0))
pMCrv->Invert() ;
++nReg ;
++ nOffs_act ;
++nReg ; // incremento del numero di regioni trovate
++ nOffs_act ; // shift indice
int nMaxInd = pMCrv->GetCurveCount() - 1 ;
int nMaxRInd = pRCrv->GetCurveCount() - 1 ;
@@ -4896,17 +4845,16 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
pCurve->GetStartDir( vtStart) ;
// Entrata ...
if ( j == 1 || vbChangedPrec[j-1] || vSrfSliced[j-2]->GetChunkCount() > 1 || nRegTot > 1) {
// Ricalcolo il punto di attacco sopra al PtStart ( modificato in precedenza dal PtOut ) quando :
// Ricalcolo il punto di attacco sopra al PtStart ( modificato in precedenza dal PtOut) quando :
// 1) sono nel primo Step o ...
// 2) la superificie è diversa da quello dello step precedente o ...
// 3) il numero di chunk allo step precedente è maggiore di 1 o ...
// 4) dal primo offset del chunk cc-esimo ottengo più regioni o ...
// determino inizio attacco
// 4) dal primo offset del chunk cc-esimo ottengo più regioni
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, pRCrv, ptP1))
return false ;
// determino elevazione su inizio attacco (se non trovata, elevazione è step)
// determino elevazione su inizio attacco
double dStElev = dSink ;
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
@@ -4921,7 +4869,6 @@ 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) ;
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, pRCrv, !m_Params.m_bInvert, bSplitArcs, bOutStart || bForcedOutStart)) {
@@ -4943,13 +4890,12 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
double dMinFeed = GetFeed() * GetSideStep() / m_TParams.m_dDiam ;
double dFeed = pCurve->GetTempProp( 0) / FEED_DIVISOR < dMinFeed - 50 * EPS_SMALL ?
GetFeed() : pCurve->GetTempProp( 0) / FEED_DIVISOR ;
DrawColoredCrvForFeedTest( pCurve, dFeed) ;
SetFeed( dFeed) ;
// DrawColoredCrvForFeedTest( pCurve, dFeed) ;
SetFeed( dFeed) ; // <---
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptP3 = pLine->GetEnd() ;
//SetFeed( GetFeed()) ;
//SetFeed( pCurve->GetTempProp( 0) / FEED_DIVISOR) ;
// SetFeed( pCurve->GetTempProp( 0) / FEED_DIVISOR) ; // <----
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
@@ -4960,7 +4906,6 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ;
pArc->GetEndPoint( ptP3) ;
//SetFeed( GetFeed()) ;
//SetFeed( pCurve->GetTempProp( 0) / FEED_DIVISOR) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
@@ -4971,8 +4916,8 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
if ( j < nStep && vSrfSliced[j-1]->GetChunkCount() == 1 && ! vbChangedPrec[j] && nRegTot == 1) {
// Effettuo l'uscita quando :
// 1) non sono nello step intermedio e ...
// 2) il numero di Chunk allo step attuale è 1 e...
// 3) la superificie non è cambiata dalla precedente e...
// 2) il numero di Chunk allo step attuale è 1 e ...
// 3) la superificie non è cambiata dalla precedente e ...
// 4) dal primo offset del chunk cc-esimo non si sono create altre regioni da svuotare
// se necessario ritorno all'inizio
@@ -4986,9 +4931,10 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
// se attacco a scivolo, accorcio della lunghezza dell'attacco
if ( GetLeadInType() == POCKET_LI_GLIDE) {
double dLen ; pRet->GetLength( dLen) ;
if ( dLen > m_Params.m_dLiTang + 10 * EPS_SMALL)
if ( dLen > m_Params.m_dLiTang + 10 * EPS_SMALL) {
if ( ! pRet->TrimEndAtLen( dLen - m_Params.m_dLiTang))
pRet->Clear() ;
}
else
pRet->Clear() ;
}
@@ -5154,26 +5100,8 @@ Pocketing::AddSpiralOut( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool
bool bOptimizedTrap = false ;
int nInd = 0 ;
// cerco la curva originale del chunk cc-esimo ( PER CASI OTTIMIZZATI)
if (( int)vCrvOEWithFlags[j-1].size() == 1)
nInd = 0 ;
else {
for ( int k = 0 ; k < ( int)vCrvOEWithFlags[j-1].size() ; ++ k) {
CRVCVECTOR ccClass ;
if ( pSrfChunkFinal->GetCurveClassification( *vCrvOEWithFlags[j-1][k], EPS_SMALL, ccClass)) {
bool bIsThis = true ;
for ( int kk = 0 ; kk < ( int)ccClass.size() && bIsThis ; ++ kk) {
if ( ccClass[kk].nClass == CRVC_OUT)
bIsThis = false ;
}
if ( bIsThis) {
nInd = k ;
break ;
}
}
}
}
if ( ! GetOptCrvIndex( vCrvOEWithFlags, j, pSrfChunkFinal, nInd))
return false ;
nRegTot = nReg ;
@@ -5419,12 +5347,14 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
// se non ho isole e curva valida allora controllo casi ottimizzati
if ( ! bHasIsland && pCrvOEWithFlags != nullptr) {
// caso spirale
PtrOwner<ICurveComposite> pCrvBorder( GetCurveComposite( pSrfPock->GetLoop( 0, 0))) ;
PtrOwner<ICurveComposite> pCrvBorder( ConvertCurveToComposite( pSrfPock->GetLoop( 0, 0))) ;
if ( IsNull( pCrvBorder) || ! pCrvBorder->IsValid())
return false ;
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 ;
if ( m_Params.m_nSubType == POCKET_SUB_SPIRALOUT && GetLeadInType() == POCKET_LI_HELIX) {
if ( m_Params.m_nSubType == POCKET_SUB_SPIRALOUT && GetLeadInType() == POCKET_LI_HELIX) {
dIntRad = min( 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam), dRad - dOffs) ;
m_dMaxHelixRad = dIntRad ;
}
@@ -5453,9 +5383,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
Frame3d frTrap ;
double dPocketSize ;
int nBase, nSecondBase ;
if ( ! GetTrapezoidFromShape( pCrvOEWithFlags, m_dDiam_Prec > 0 ? m_dDiam_Prec + m_dOffsetR_Prec :
m_TParams.m_dDiam + GetOffsR(),
pCrvTrap, frTrap, dPocketSize, nBase, nSecondBase))
if ( ! GetTrapezoidFromShape( pCrvOEWithFlags, pCrvTrap, frTrap, dPocketSize, nBase, nSecondBase))
return false ;
if ( pCrvTrap->IsValid()) {
pCrvTrap->SetExtrusion( vtExtr) ;
@@ -7570,10 +7498,9 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Frame3d& frTr
int nSecondBase, ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool& bOptimizedTrap)
{
// parametri
double dDiam = m_dDiam_Prec > 0 ? m_dDiam_Prec : m_TParams.m_dDiam ;
double dOffsR = m_dDiam_Prec > 0 ? m_dOffsetR_Prec : GetOffsR() ;
double dDiam = m_TParams.m_dDiam ;
double dOffsR = GetOffsR() ;
double dRad = 0.5 * dDiam + dOffsR ;
const double TOLL = 50 * EPS_SMALL ;
bOptimizedTrap = false ;
Vector3d vtExtr ; pCrvPocket->GetExtrusion( vtExtr) ;
@@ -9373,7 +9300,7 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO
PtrOwner<ICurveComposite> pCrvNew( CreateCurveComposite()) ;
if ( ! bInVsOut &&
AdjustPathOutsideRawForOpenEdges( pCompo_clone, vCrvIsl, pCompo, ptS, ptE, dRad, dDiam,
pCrvNew, vtTrasl, pStmRaw, !bInVsOut)) {
pCrvNew, vtTrasl, pStmRaw, bInVsOut)) {
pCompo->Clear() ;
pCompo->CopyFrom( pCrvNew) ;
}
@@ -10043,6 +9970,7 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector<ICRVCOMPOPOV
pStmRaw->AdjustTopology() ;
if ( ! GetStmRawPart( nProp0 , pStmRaw, GLOB_FRM))
return false ;
// ======================================================================================
// ======================================================================================
@@ -10075,26 +10003,6 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector<ICRVCOMPOPOV
// adatto la superficie dello step corrente con la geometria del grezzo
if ( AdaptSfrWithRaw( pSrfToPock, vtTrasl, pStmRaw, vCrvOEF, bChanged, j, dStep, 500 * EPS_SMALL, m_pStmShape)) {
// // 8) DISEGNO =========== TOGLIEREEEEEEEEEEEEEEEEEEEEEEEE ================================
/* PtrOwner<ISurfFlatRegion> pSrf_toDraw( CloneSurfFlatRegion( pSrfToPock)) ;
pSrf_toDraw->Translate( vtTrasl) ;
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_toDraw->Clone()) ;
m_pGeomDB->SetMaterial( a, Color( 0.0, 0.0, 1.0, 0.45)) ;
for ( int c = 0 ; c < pSrf_toDraw->GetChunkCount() ; ++ c) {
for ( int l = 0 ; l < pSrf_toDraw->GetLoopCount( c) ; ++ l) {
PtrOwner<ICurveComposite> pCrvCompo( GetCurveComposite( pSrf_toDraw->GetLoop( c, l))) ;
for ( int u = 0 ; u < pCrvCompo->GetCurveCount() ; ++ u) {
int nProp0 ; pCrvCompo->GetCurveTempProp( u, nProp0, 0) ;
int nProp1 ; pCrvCompo->GetCurveTempProp( u, nProp1, 1) ;
int aaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo->GetCurve( u)->Clone()) ;
m_pGeomDB->SetMaterial( aaa, nProp0 == 0 ? BLUE : RED) ;
}
}
}*/
//return false ;
//// ===================================================================
vSrfSliced[j-1].Set( pSrfToPock->Clone()) ;
// la superificie potrebbe non essere valida ( ad esempio se già svuotata tutta con un Tool in precedenza...)
if ( ! IsNull( vSrfSliced[j-1])) {
@@ -10112,6 +10020,8 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector<ICRVCOMPOPOV
else
vbChangedPrec[j-1] = true ;
}
// per ora e per meggiore sicurezza...
vbChangedPrec[j-1] = true ;
}
}
@@ -10887,8 +10797,11 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, ISurfTriMes
// 2) PROIEZIONE CON GREZZO
if ( m_bProjectRaw) {
// recupero la Trimesh di partenza
double dAreaBef ; pSrf->GetArea( dAreaBef) ;
if ( ! ProjectRaw( pSrf, vtTrasl, pStmRaw, nProp0, pSrfOrig, nStep, dStep))
return false ;
double dAreaAft ; pSrf->GetArea( dAreaAft) ;
bChanged = bChanged && abs( dAreaBef - dAreaAft) > 500 * EPS_SMALL ;
if ( pSrf->GetChunkCount() == 0 || ! pSrf->IsValid())
return true ;
}
@@ -11441,6 +11354,7 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
return false ;
}
}
// 4) aggiungo le curve alla nuova superificie
// NB Controllo se la curva si Autointerseca... alcuni lati aperti potrebbero mergiarsi
SelfIntersCurve SiC( *pCrvExt) ;
@@ -11461,7 +11375,6 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
vCrvIsl.emplace_back( Release( pCrvClosedIsland)) ;
}
}
// 5) Controllo i bordi delle isole ottenute e modifico quelli in cui sono presenti lati aperti
for ( int i = 0 ; i < ( int)vCrvIsl.size() ; ++ i) {
bSomeOpen = false ;
@@ -11491,7 +11404,6 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
vCrvModIsland.emplace_back( pCrvIsl->Clone()) ;
vCrvToTIsl.emplace_back( pCrvIsl->Clone()) ;
}
// 6) Creo la nuova superificie da svuotare
// NB. I vari chunk, dopo esseresi allargati nei lati aperti, potrebbero unirsi tra loro in alcuni parti...
SurfFlatRegionByContours SfrBC_Def ;
@@ -11506,7 +11418,6 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
else
pSrfFinal->Add( *pSrfHelp_) ;
}
// ora che ho la superificie finale, questa potrebbe contenere più isole rispetto a quelle originarie
// ( Se la superficie, dopo intersezione e proeizione, è formata da c-Chunks e questi una volta allargati presso
// i lati aperti dalla funzione AdjustContourWithOpenEdges si sono uniti -> possono esseresi formate ulteriori isole
@@ -11545,7 +11456,6 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
}
}
}
// aggiorno la superficie originaria
pSrfFinal.Set( pSrf_noFakeIslands.GetSurf()) ;
if ( IsNull( pSrfFinal))
@@ -11555,7 +11465,9 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
for ( int c = 0 ; c < pSrfFinal->GetChunkCount() ; ++ c) {
int nChunk_contained = 0 ;
int nIndex = -1 ;
const ISurfFlatRegion* pSfrChunk = pSrfFinal->CloneChunk( c) ;
PtrOwner<ISurfFlatRegion> pSfrChunk( pSrfFinal->CloneChunk( c)) ;
if ( IsNull( pSfrChunk) || ! pSfrChunk->IsValid())
return false ;
for ( int x = 0 ; x < int( vCrvOrig_tmp.size()) ; ++x) {
CRVCVECTOR ccClass ;
if ( pSfrChunk->GetCurveClassification( *vCrvOrig_tmp[x], EPS_SMALL, ccClass)) {
@@ -11570,11 +11482,6 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
}
}
//if ( nChunk_contained == 1)
//vCrvOEFlags.emplace_back( vCrvOrig_tmp[nIndex]->Clone()) ;
//else
// inserisco il loop del chunk attuale
}
pSrf->Clear() ;
@@ -11635,8 +11542,8 @@ Pocketing::IntersSurfWithRaw( ISurfFlatRegion* pSfrPock, const ISurfTriMesh* pSt
if ( IsNull( pStm))
return false ;
// calcolo l'area della superificie da svuotare
double dAreaBefore = 0 ;
if ( ! pStm->GetArea( dAreaBefore))
double dAreaBefore = 0 ;
if ( ! pSfrPock->GetArea( dAreaBefore))
return false ;
// salvo una copia della superificie Trimesh ( nel caso in cui la sottrazione non funzioni)
PtrOwner<ISurfTriMesh> pStmCopy( CloneSurfTriMesh( pStm)) ;
@@ -11657,10 +11564,6 @@ Pocketing::IntersSurfWithRaw( ISurfFlatRegion* pSfrPock, const ISurfTriMesh* pSt
return true ;
}
// calcolo la nuova area e la confronto con la precedente ( capisco se la superificie è cambiata o meno)
double dAreaAfter = 0 ;
bIsChanged = true ;
// recupero thickness ed estrusione dalle curve della superificie originaria
PtrOwner<ICurve> pCrvEL( pSfrPock->GetLoop( 0, 0)) ;
double dThick ; pCrvEL->GetThickness( dThick) ;
@@ -11681,6 +11584,12 @@ Pocketing::IntersSurfWithRaw( ISurfFlatRegion* pSfrPock, const ISurfTriMesh* pSt
pSrfByCurves->GetChunkCount() == 0)
return false ;
// calcolo la nuova area e la confronto con la precedente
// NB ( questo controllo andrebbe migliorato controllando che in realtà le due FlatRegion non siano simili
// a meno di una roto-traslazione)
double dAreaAfter = 0. ; pSrfByCurves->GetArea( dAreaAfter) ;
bIsChanged = abs( dAreaAfter - dAreaBefore) > 500 * EPS_SMALL ;
// riporto la superificie tagliata alla quota originale
pSrfByCurves->Translate( - vtTrasl) ;
@@ -14390,7 +14299,7 @@ Pocketing::AssignFeedSpiral( ICurveComposite* pCrv, const ISurfFlatRegion* pSrfR
continue ;
// cerco tra le curve successive vicine se ne trovo una con Feed Minima
int nProp ; pCrvCompo->GetCurveTempProp( uu, nProp, 0) ;
if ( abs ( nProp - int( FEED_DIVISOR * GetMinFeed()) < 5 * EPS_SMALL)) {
if ( abs( nProp - int( FEED_DIVISOR * GetMinFeed()) < 5 * EPS_SMALL)) {
pCrv->SetCurveTempProp( u, FEED_DIVISOR * GetMinFeed(), 0) ;
bFound = true ;
break ;
@@ -14399,7 +14308,7 @@ Pocketing::AssignFeedSpiral( ICurveComposite* pCrv, const ISurfFlatRegion* pSrfR
if ( ! bFound && u != 0) {
// arrivato qui, so che successivamente non ho curve con Feed Minima vicine
int nProp ; pCrv->GetCurveTempProp( u - 1, nProp, 0) ;
if ( abs ( nProp - int( FEED_DIVISOR * GetMaxFeed()) < 5 * EPS_SMALL))
if ( abs( nProp - int( FEED_DIVISOR * GetMaxFeed()) < 5 * EPS_SMALL))
// se anche la precedente ha Feed Massima -> la curva u-esima è piccola ed Isolata
pCrv->SetCurveTempProp( u, nProp, 0) ;
}
@@ -14474,7 +14383,7 @@ Pocketing::AssignDefaultFeed( ICurveComposite* pCrv) {
bool
Pocketing::DrawColoredCrvForFeedTest( ICurve* pCurve, double dFeed)
{
return true ;
#if 0
if ( abs( dFeed - GetMinFeed()) < EPS_SMALL) {
int rosso = m_pGeomDB->AddGeoObj(GDB_ID_NULL, GDB_ID_ROOT, pCurve->Clone()) ;
m_pGeomDB->SetMaterial( rosso, RED) ;
@@ -14492,6 +14401,7 @@ Pocketing::DrawColoredCrvForFeedTest( ICurve* pCurve, double dFeed)
m_pGeomDB->SetStatus( giallo, ( m_Params.m_nSubType == POCKET_SUB_SPIRALIN ||
m_Params.m_nSubType == POCKET_SUB_SPIRALIN) ? GDB_ST_OFF : GDB_ST_ON) ;
}
#endif
return true ;
}
@@ -14875,13 +14785,16 @@ Pocketing::GetOptCrvIndex( const vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags, int
//----------------------------------------------------------------------------
bool
Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam, ICurveComposite* pCrvTrap,
Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, ICurveComposite* pCrvTrap,
Frame3d& frTrap, double& dPocketSize, int& nBase, int& nSecondBase)
{
// controllo parametri
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return false ;
// diametro reale da tenere in considerazione
double dDiam = m_TParams.m_dDiam + GetOffsR() ;
pCrvTrap->Clear() ; // resterà vuota se il caso non è ottimizzato
nBase = -1 ;
nSecondBase = -1 ;
@@ -14909,7 +14822,7 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam
if ( ! CalcTrapezoidSpiralLocalFrame( pCrvTrap, vtDir, frTrap))
return false ;
bool bBaseOpen = false ;
bBaseOpen = ( pCrvTrap->GetCurve( 0)->GetTempProp( 0) == 1 || pCrvTrap->GetCurve( 2)->GetTempProp( 0) == 1 ) ;
bBaseOpen = ( pCrvTrap->GetCurve( 0)->GetTempProp( 0) == 1 || pCrvTrap->GetCurve( 2)->GetTempProp( 0) == 1) ;
// controllo dimensioni della svuotatura
if ( ! ( bBaseOpen && dPocketSize < dDiam + EPS_SMALL) &&
abs( dPocketSize - dDiam) > EPS_SMALL) {
@@ -14925,7 +14838,7 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam
pCrvTrap->Clear() ;
}
// imposto le basi
// imposto le basi
nBase = 0 ;
nSecondBase = 2 ;
return true ;
@@ -15178,8 +15091,8 @@ Pocketing::CheckTrapezoidClosedEdgePosition( const ICurveComposite* pCrvCompo, c
return true ;
// parametri lavorazione
double dDiam = m_dDiam_Prec > 0 ? m_dDiam_Prec : m_TParams.m_dDiam ;
double dOffsR = m_dDiam_Prec > 0 ? m_dOffsetR_Prec : GetOffsR() ;
double dDiam = m_TParams.m_dDiam ;
double dOffsR = GetOffsR() ;
double dRad = 0.5 * dDiam + dOffsR ;
// -------------- creo il bordo del trapezio estendendo i lati obliqui se possibile ------------------------
@@ -15258,8 +15171,8 @@ Pocketing::CheckSecondBaseTrapezoid( const ICurveComposite* pCrvCompo, const int
return false ;
// parametri lavorazione
double dDiam = m_dDiam_Prec > 0 ? m_dDiam_Prec : m_TParams.m_dDiam ;
double dOffsR = m_dDiam_Prec > 0 ? m_dOffsetR_Prec : GetOffsR() ;
double dDiam = m_TParams.m_dDiam ;
double dOffsR = GetOffsR() ;
double dRad = 0.5 * dDiam + dOffsR ;
nSecondBase = -1 ;
@@ -15327,8 +15240,8 @@ Pocketing::PreparareTrapezoidTwoBases( const ICurveComposite* pCrvCompo, BBox3d
}
// parametri lavorazione
double dDiam = m_dDiam_Prec > 0 ? m_dDiam_Prec : m_TParams.m_dDiam ;
double dOffsR = m_dDiam_Prec > 0 ? m_dOffsetR_Prec : GetOffsR() ;
double dDiam = m_TParams.m_dDiam ;
double dOffsR = GetOffsR() ;
double dRad = 0.5 * dDiam + dOffsR ;
// creo la base principale e secondaria
Pocketing.h
+2 -2
View File
@@ -91,8 +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,
Frame3d& frTrap, double& dPocketSize, int& nBase, int& nSecondBase) ;
bool GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, ICurveComposite* pCrvTrap, Frame3d& frTrap,
double& dPocketSize, int& nBase, int& nSecondBase) ;
bool CheckTrapezoidClosedEdgePosition( const ICurveComposite* pCrvCompo, const int nCrvInd, const double dDimBoxY,
INTVECTOR& vIndClosedSides, bool& bOk,
ICurveComposite* pCrvTrap) ;