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

EgtMachKernel :

Browse Source 
- migliorata la regione di incidenza per lati aperti
- controllo pulizia dei lati aperti con angoli piccoli.
This commit is contained in:
Riccardo Elitropi
2023-08-01 11:35:38 +02:00
parent d7a5f4aa72
commit ff8e875290
2 changed files with 307 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+303 -108
View File
@@ -1227,71 +1227,73 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
pCrvCompo->SetExtrusion( vtN) ;
// --------------------------------- Proiezioni lati adiacenti --------------------------------------
// 1) Creo una regione piana dalla curva esterna
PtrOwner<ISurfFlatRegion> pSrfpCompo( CreateSurfFlatRegion()) ;
if ( IsNull( pSrfpCompo))
return false ;
pSrfpCompo->AddExtLoop( pCrvCompo->Clone()) ;
if ( IsNull( pSrfpCompo) || pSrfpCompo->GetChunkCount() == 0)
return false ;
if ( m_TParams.m_dSideAng == 0) { // controllare se le facce effettivamente sono inclinate come il tool ?
// 1) Creo una regione piana dalla curva esterna
PtrOwner<ISurfFlatRegion> pSrfpCompo( CreateSurfFlatRegion()) ;
if ( IsNull( pSrfpCompo))
return false ;
pSrfpCompo->AddExtLoop( pCrvCompo->Clone()) ;
if ( IsNull( pSrfpCompo) || pSrfpCompo->GetChunkCount() == 0)
return false ;
bool bIspCompoMod = false ;
INTVECTOR vBannedId{ -1, nFacet} ;
bool bIspCompoMod = false ;
INTVECTOR vBannedId{ -1, nFacet} ;
// 2) scorro tutte le curve del bordo esterno
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
if ( pCrvCompo->GetCurveTempProp( j, nProp, 1) && nProp != -1 //-> se la curva j ha una faccia adiacente...
&& find( vBannedId.begin(), vBannedId.end(), nProp) == vBannedId.end() //-> ...non già considerata da altre curve...
&& GetSurfByAdj( pSurf, vBannedId, nProp)) { //-> ...e riesco a ricavare tutte le facce del bordo
// 4) creo una regione piana con tutte le facce proiettate contenute
PtrOwner<ISurfFlatRegion> pSfrProj( CreateSurfFlatRegion()) ;
if ( ! IsNull( pSfrProj) && ProjectEdgesOnSelFace( pSrfpCompo, pSurf, vBannedId, nFacet, pSfrProj)) {
// sto modificando le singole superifici, quindi superificie del bordo esterno e superificie delle isole
if ( i == 0) {
if ( ! pSrfpCompo->Subtract( *pSfrProj))
return false ;
}
else {
if ( ! pSrfpCompo->Add( *pSfrProj))
return false ;
}
bIspCompoMod = true ;
// 2) scorro tutte le curve del bordo esterno
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
if ( pCrvCompo->GetCurveTempProp( j, nProp, 1) && nProp != -1 //-> se la curva j ha una faccia adiacente...
&& find( vBannedId.begin(), vBannedId.end(), nProp) == vBannedId.end() //-> ...non già considerata da altre curve...
&& GetSurfByAdj( pSurf, vBannedId, nProp)) { //-> ...e riesco a ricavare tutte le facce del bordo
// 4) creo una regione piana con tutte le facce proiettate contenute
PtrOwner<ISurfFlatRegion> pSfrProj( CreateSurfFlatRegion()) ;
if ( ! IsNull( pSfrProj) && ProjectEdgesOnSelFace( pSrfpCompo, pSurf, vBannedId, nFacet, pSfrProj)) {
// sto modificando le singole superifici, quindi superificie del bordo esterno e superificie delle isole
if ( i == 0) {
if ( ! pSrfpCompo->Subtract( *pSfrProj))
return false ;
}
else {
if ( ! pSrfpCompo->Add( *pSfrProj))
return false ;
}
bIspCompoMod = true ;
}
}
}
}
// Ho creato una nuova FlatRegion.
// *** Se la curva originale è quella esterna -> tolgo le proiezioni ( non devo passare con il tool in quelle aree )
// *** Se la curva originale è quella di un'isola -> aggiungo le proiezioni ( così estraendo poi la curva mi trovo
// con un'isola più grande, comprendendo quindi le parti proiettare dove il tool non può passare )
// Ho creato una nuova FlatRegion.
// *** Se la curva originale è quella esterna -> tolgo le proiezioni ( non devo passare con il tool in quelle aree )
// *** Se la curva originale è quella di un'isola -> aggiungo le proiezioni ( così estraendo poi la curva mi trovo
// con un'isola più grande, comprendendo quindi le parti proiettare dove il tool non può passare )
// se questa nuova superificie è modificata rispetto a quella selezionata, devo aggiornare le curve, con quelle
// della nuova FlatRegion
// se questa nuova superificie è modificata rispetto a quella selezionata, devo aggiornare le curve, con quelle
// della nuova FlatRegion
if ( bIspCompoMod) {
// scorro ora il bordo della mia superificie
if( pSrfpCompo->GetChunkCount() == 0)
return false ;
PtrOwner<ICurveComposite> pCrvBorder( GetCurveComposite( pSrfpCompo->GetLoop( 0, 0))) ;
if ( IsNull( pCrvBorder) || pCrvBorder->GetCurveCount() == 0)
return false ;
for ( int c = 0 ; c < pCrvBorder->GetCurveCount() ; ++ c) {
int nStat = 0 ;
if ( ! SetTmpPropByOverlap( pCrvBorder, c, pCrvCompo, nStat))
if ( bIspCompoMod) {
// scorro ora il bordo della mia superificie
if( pSrfpCompo->GetChunkCount() == 0)
return false ;
if ( nStat == 0 || nStat == 2) { // se non c'è overlap o geometria complessa
pCrvBorder->SetCurveTempProp( c, 0, 0) ; // lato chiuso
pCrvBorder->SetCurveTempProp( c, -1, 1) ; // lato esterno non definito
PtrOwner<ICurveComposite> pCrvBorder( GetCurveComposite( pSrfpCompo->GetLoop( 0, 0))) ;
if ( IsNull( pCrvBorder) || pCrvBorder->GetCurveCount() == 0)
return false ;
for ( int c = 0 ; c < pCrvBorder->GetCurveCount() ; ++ c) {
int nStat = 0 ;
if ( ! SetTmpPropByOverlap( pCrvBorder, c, pCrvCompo, nStat))
return false ;
if ( nStat == 0 || nStat == 2) { // se non c'è overlap o geometria complessa
pCrvBorder->SetCurveTempProp( c, 0, 0) ; // lato chiuso
pCrvBorder->SetCurveTempProp( c, -1, 1) ; // lato esterno non definito
}
}
// risetto le proprietà iniziali della curva
pCrvCompo->Clear() ;
pCrvCompo->AddCurve( Release( pCrvBorder)) ;
}
// risetto le proprietà iniziali della curva
pCrvCompo->Clear() ;
pCrvCompo->AddCurve( Release( pCrvBorder)) ;
}
// ------------------------------------------------------------------------------------------
// assegno l'estrusione dalla normale alla faccia
@@ -3337,9 +3339,9 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
}
int nClosedSides = vnInfoClosed.size() ;
PtrOwner<ICurveComposite> pCrvDraw1( CloneCurveComposite( pCrvPocket)) ;
pCrvDraw1->ToGlob( frPocket) ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvDraw1->Clone()) ;
//PtrOwner<ICurveComposite> pCrvDraw1( CloneCurveComposite( pCrvPocket)) ;
//pCrvDraw1->ToGlob( frPocket) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvDraw1->Clone()) ;
// modifico pCrvPocket per poterla passare a CalcZigZag
@@ -3363,9 +3365,9 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
break ;
}
PtrOwner<ICurveComposite> pCrvDraw( CloneCurveComposite( pCrvPocket)) ;
pCrvDraw->ToGlob( frPocket) ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvDraw->Clone()) ;
//PtrOwner<ICurveComposite> pCrvDraw( CloneCurveComposite( pCrvPocket)) ;
//pCrvDraw->ToGlob( frPocket) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvDraw->Clone()) ;
if ( ! bOptimizedZigZag)
return true ;
@@ -4618,8 +4620,10 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
// 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
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, pRCrv, ptP1))
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))
@@ -4630,7 +4634,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
bool bUhAboveRaw = ! m_bAboveHead &&
GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
//if ( bAhUnderRaw || bUhAboveRaw )
if ( bAhUnderRaw || bUhAboveRaw )
dStElev = max( dStElev, j * dStep) ;
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
@@ -4645,6 +4649,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) ;
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, pRCrv, !m_Params.m_bInvert, bSplitArcs, bOutStart || bForcedOutStart)) {
@@ -4730,12 +4735,14 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
pCurve->GetEndDir( vtEnd) ;
// aggiungo uscita
Point3d ptP1 ;
double dEndElev = j * dStep ;
double dEndElev = dElev ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, pRCrv, bSplitArcs, false, ptP1, dEndElev, false)) {
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") ;
@@ -5089,7 +5096,6 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
// caso spirale
PtrOwner<ICurveComposite> pCrvBorder( GetCurveComposite( pSrfPock->GetLoop( 0, 0))) ;
Point3d ptCen ; Vector3d vtN ; double dRad ; bool bCCW ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvBorder->Clone()) ;
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) {
@@ -5215,9 +5221,8 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
bool bSmallRad = ( nIter == 0 ? dOffs < dTRad + GetOffsR() + EPS_ZERO : dOffs < dTRad + EPS_ZERO) ;
if ( nChunks > 0) {
if ( nChunks > 0)
dOffs = GetSideStep() ;
}
else if ( ! bSmallRad) {
pSrfAct.Set( pSrfPrec) ;
dOffs = ( nIter == 0 ? dTRad + GetOffsR() : dTRad) ;
@@ -8527,6 +8532,7 @@ Pocketing::GetParamOnOpenSide( const ICurveComposite* pCompo, const ICRVCOMPOPOV
if ( pPrevCrv != nullptr && pPrevCrv->GetTempProp() == 1)
pPrevCrv->GetLength( dLenPrev) ;
const ICurve* pCrv = pCompo->GetFirstCurve() ;
int nPriorityOpenEdge = -1 ;
while ( pCrv != nullptr) {
// analizzo la curva successiva
const ICurve* pNextCrv = pCompo->GetNextCurve() ;
@@ -8536,6 +8542,7 @@ Pocketing::GetParamOnOpenSide( const ICurveComposite* pCompo, const ICRVCOMPOPOV
double dLenNext = 0 ;
if ( pNextCrv != nullptr && pNextCrv->GetTempProp() == 1)
pNextCrv->GetLength( dLenNext) ;
++ nPriorityOpenEdge ;
// verifico la curva corrente
if ( pCrv->GetTempProp() == 1) {
// contributo dalle entità adiacenti (se non tutte aperte)
@@ -8586,6 +8593,8 @@ Pocketing::GetParamOnOpenSide( const ICurveComposite* pCompo, const ICRVCOMPOPOV
pCompoClone->GetStartDir( vtMidOrt) ;
vtMidOrt.Rotate( vtExtr, 0, -1) ;
bFound = true ;
if ( nPriorityOpenEdge == 0)
return true ;
}
}
dLenPrev = dLen ;
@@ -8797,12 +8806,27 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO
// assegno alle sue sottocurve la proprietà di curva aperta
for ( int u = 0 ; u < pJCrv->GetCurveCount() ; ++ u)
pJCrv->SetCurveTempProp( u, 1, 0) ;
// controllo se ci sono degli "overlap"
bool bSucc = false ;
PtrOwner<ICurveComposite> pNewCrv( CreateCurveComposite()) ;
if ( ! CheckOpenEdgeOverlapParts( pJCrv, vpCrvs[i], true, bSucc, pNewCrv))
return false ;
if ( bSucc) { // se "overlap Trovato", modifico la vpCrvs[i]
vpCrvs[i].Set( Release( pNewCrv)) ;
}
// calcolo l'intersezione nel piano della svuotatura dell'amo con la curva aperta
pJCrv->ToLoc( frPocket) ;
vpCrvs[i]->ToLoc( frPocket) ;
IntersCurveCurve intCC( *pJCrv, *vpCrvs[i]) ;
pJCrv->ToGlob( frPocket) ;
vpCrvs[i]->ToGlob( frPocket) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pJCrv->Clone()) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vpCrvs[i]->Clone()) ;
// taglio opportunamente le curve
bool bFound = false ;
IntCrvCrvInfo aInfo ;
@@ -8830,7 +8854,6 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO
}
// se passo da aperto a chiuso
else if ( bOpenPrev && ! bOpenCurr) {
// determino la curva ad amo
Vector3d vtTg ; vpCrvs[i]->GetStartDir( vtTg) ;
Vector3d vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, 1) ;
@@ -8859,15 +8882,37 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO
if ( pCompo->GetCurveCount() >= 2)
pLCrv->AddCurve( pCompo->GetPrevCurve()->Clone(), false) ;
double dUL = pLCrv->GetCurveCount() ;
//const ICurveComposite* PCrvH( CloneCurveComposite( pCompo)) ;
//for ( int u = 0 ; u < PCrvH->GetCurveCount() ; ++ u)
// pLCrv->AddCurve( PCrvH->GetCurve(u)->Clone()) ;
//double dUL = pLCrv->GetCurveCount() ;
//int A = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pLCrv->Clone()) ;
//m_pGeomDB->SetMaterial( A, AQUA) ;
// controllo se ci sono degli "overlap"
bool bSucc = false ;
PtrOwner<ICurveComposite> pNewCrv( CreateCurveComposite()) ;
if ( ! CheckOpenEdgeOverlapParts( pJCrv, pLCrv, false, bSucc, pNewCrv))
return false ;
if ( bSucc) { // se "overlap Trovato", modifico la vpCrvs[i]
pLCrv.Set( pNewCrv->Clone()) ;
double dUS_tmp, dUE_tmp ;
pCompo->GetDomain( dUS_tmp, dUE_tmp) ;
if ( dUE_tmp >= 2) { // sempre ( ho sempre un pezzo di chiuso e il tratto aperto)
pCompo->TrimEndAtParam( dUE_tmp - dUL) ;
pCompo->AddCurve( pLCrv->Clone()) ;
}
}
dUL = pLCrv->GetCurveCount() ;
pJCrv->ToLoc( frPocket) ;
pLCrv->ToLoc( frPocket) ;
IntersCurveCurve intCC( *pJCrv, *pLCrv) ;
pJCrv->ToGlob( frPocket) ;
pLCrv->ToGlob( frPocket) ;
// taglio opportunamente le curve
// taglio opportunamente le curve
IntCrvCrvInfo aInfo ;
if ( intCC.GetIntCrvCrvInfo( 0, aInfo) && !bInVsOut) {
double dUs, dUe ; pCompo->GetDomain( dUs, dUe) ;
@@ -8893,7 +8938,8 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO
}
}
// aggiungo la curva
pCompo->AddCurve( ::Release( vpCrvs[i]), true, 10 * EPS_SMALL) ;
//pCompo->AddCurve( ::Release( vpCrvs[i]), true, 10 * EPS_SMALL) ;
pCompo->AddCurve( vpCrvs[i]->Clone(), true, 10 * EPS_SMALL) ;
//int p = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompo->Clone()) ;
//m_pGeomDB->SetMaterial( p, PURPLE) ;
@@ -8908,6 +8954,110 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO
return true ;
}
bool
Pocketing::CheckOpenEdgeOverlapParts( const ICurve* pCrvJ, const ICurve* pCrvOffBorder, bool bCloseToOpen, bool& bSucc,
ICurveComposite* pCrvFinal)
{
// controllo validità dei parametri
if ( pCrvJ == nullptr || ! pCrvJ->IsValid() ||
pCrvOffBorder == nullptr || ! pCrvOffBorder->IsValid() ||
pCrvFinal == nullptr )
return false ;
bSucc = false ;
pCrvFinal->Clear() ;
//int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvJ->Clone()) ;
//m_pGeomDB->SetMaterial( G, GREEN) ;
//int Gg = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvOffBorder->Clone()) ;
//m_pGeomDB->SetMaterial( Gg, BLACK) ;
// converto la curva ad amo in curva composita
PtrOwner<ICurveComposite> pCrvJ_Cut( ConvertCurveToComposite( pCrvJ->Clone())) ;
if ( IsNull( pCrvJ_Cut) || ! pCrvJ_Cut->IsValid() || pCrvJ_Cut->GetCurveCount() == 0)
return false ;
// parametri per taglio
double dUTrim = EPS_SMALL ;
Point3d ptCut, ptBase ;
// se passo da chiuso ad aperto
if ( bCloseToOpen) {
pCrvOffBorder->GetStartPoint( ptCut) ; // punto di Trim
DistPointCurve DistPC( ptCut, *pCrvJ_Cut, true) ;
double dDist = INFINITO ;
// se distante esco...
if ( ! DistPC.GetDist( dDist) || dDist > 200 * EPS_SMALL)
return true ;
// dato che il punto è molto vicino...
if ( pCrvJ_Cut->GetParamAtPoint( ptCut, dUTrim, 200 * EPS_SMALL)) {
// cerco il parametro sulla curva J e taglio la parte finale
if ( ! pCrvJ_Cut->TrimEndAtParam( dUTrim))
return true ;
// punto finale della curva J ottenuta
pCrvJ_Cut->GetEndPoint( ptBase) ;
// ricavo il nuovo bordo esterno presso il lato aperto corrente
// ( estendendolo all'inizio per trovare l'intersezione)
if ( pCrvFinal->AddPoint( ptBase) &&
pCrvFinal->AddLine( ptCut) &&
pCrvFinal->ExtendStartByLen( 10) &&
pCrvFinal->AddCurve( pCrvOffBorder->Clone())) {
bSucc = true ;
}
}
}
// se passo da aperto a chiuso
else {
pCrvOffBorder->GetEndPoint( ptCut) ; // punto di Trim
DistPointCurve DistPC( ptCut, *pCrvJ_Cut, true) ;
double dDist = INFINITO ;
// se distante esco...
if ( ! DistPC.GetDist( dDist) || dDist > 200 * EPS_SMALL)
return true ;
// dato che il punto è molto vicino...
if ( pCrvJ_Cut->GetParamAtPoint( ptCut, dUTrim, 200 * EPS_SMALL)) {
// cerco il parametro sulla curva J e taglio la parte iniziale
if ( ! pCrvJ_Cut->TrimStartAtParam( dUTrim))
return true ;
// punto iniziale della curva J ottenuta
pCrvJ_Cut->GetStartPoint( ptBase) ;
// ricavo il nuovo bordo esterno presso il lato aperto corrente
// ( estendendolo alla fine per trovare l'intersezione)
if ( pCrvFinal->AddCurve( pCrvOffBorder->Clone()) &&
pCrvFinal->AddLine( ptBase) &&
pCrvFinal->ExtendEndByLen( 10))
bSucc = true ;
}
}
// controllo che tutto sia andato a buon fine, altrimenti esco
if ( bSucc == false)
return true ;
// assegno le proprietà :
// thickness
double dThick = pCrvOffBorder->GetThickness( dThick) ;
pCrvFinal->SetThickness( dThick) ;
// estrusione
Vector3d vtExtr ; pCrvOffBorder->GetExtrusion( vtExtr) ;
pCrvFinal->SetExtrusion( vtExtr) ;
// TmpProp0 + TmpProp1
int nProp0 = pCrvOffBorder->GetTempProp( 0) ;
pCrvFinal->SetTempProp( nProp0, 0) ;
int nProp1 = pCrvOffBorder->GetTempProp( 1) ;
pCrvFinal->SetTempProp( nProp1, 1) ;
// Proprietà di sottocurve aperte
for ( int u = 0 ; u < pCrvFinal->GetCurveCount() ; ++ u)
pCrvFinal->SetCurveTempProp( u, 1, 0) ; // sottocurve tutte aperte
//int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvFinal->Clone()) ;
//m_pGeomDB->SetMaterial( b, BLUE) ;
return true ;
}
//---------------------------------------------------------------------------
bool
Pocketing::AdustTmpPropLinesForProjection( ICurveComposite* pCompo)
@@ -9049,9 +9199,6 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
if ( ! GetHomogeneousParts( pCrvCurrPartIn_, vCrvOpen, vCrvClose))
return false ;
if ( pCompo->GetCurveCount() == 86)
int a = 0 ;
for ( int t_Open = 0 ; t_Open < ( int)vCrvClose.size() ; ++ t_Open) {
PtrOwner<ICurveComposite> pCrvCurrPartIn( CreateCurveComposite()) ;
pCrvCurrPartIn->AddCurve( vCrvClose[t_Open]->Clone()) ;
@@ -9121,7 +9268,37 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
if ( pSfrExpan->IsValid()) {
if ( AreOppositeVectorApprox( pSfrExpan->GetNormVersor(), vtExtr))
pSfrExpan->Invert() ;
// ----------- AGGIORNAMENTO DELLA REGIONE DI INFLUENZA ----------
PtrOwner<ISurfFlatRegion> pSfrInc_c( CloneSurfFlatRegion( pSfrInc)) ;
if ( IsNull( pSfrInc_c))
return false ;
//int OOOOOO = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrInc_c->Clone()) ;
//m_pGeomDB->SetMaterial( OOOOOO, BLACK) ;
//int OOOOOOg = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrExpan->Clone()) ;
//m_pGeomDB->SetMaterial( OOOOOOg, WHITE) ;
if ( pSfrInc_c->Subtract( *pSfrExpan)) {
pSfrInc->Clear() ;
for ( int cc = 0 ; cc < pSfrInc_c->GetChunkCount() ; ++ cc) {
CRVCVECTOR ccClass_cc ;
const ISurfFlatRegion* pSfrChunk_cc = pSfrInc_c->CloneChunk( cc) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrChunk_cc->Clone()) ;
if ( pSfrChunk_cc->GetCurveClassification( *pCrvOpen, EPS_SMALL, ccClass_cc)) {
for ( int jj = 0 ; jj < ( int)ccClass_cc.size() ; ++ jj) {
if ( ccClass_cc[jj].nClass == CRVC_IN) {
if ( IsNull( pSfrInc) || ! pSfrInc->IsValid())
pSfrInc.Set( pSfrChunk_cc->Clone()) ;
else
pSfrInc->Add( *pSfrChunk_cc) ;
break ;
}
}
}
}
}
pSfrInc->Add( *pSfrExpan) ;
//int GRR = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrInc->Clone()) ;
//m_pGeomDB->SetMaterial( GRR, GRAY) ;
}
}
}
@@ -9173,6 +9350,8 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
PtrOwner<ICurveComposite> pCrvNewBorder( GetCurveComposite( pSfrInc->GetLoop( 0, 0))) ;
if ( IsNull( pCrvNewBorder))
return false ;
//int brown = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvNewBorder->Clone()) ; //
//m_pGeomDB->SetMaterial( brown, LIME) ;
double dUSTART ;
if ( ! pCrvNewBorder->GetParamAtPoint( ptSTART, dUSTART, 5000 * EPS_SMALL)) {
@@ -9195,8 +9374,8 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
for ( int u = 0 ; u < pNewCrv->GetCurveCount() ; ++ u)
pNewCrv->SetCurveTempProp( u, 1, 0) ;
//int P = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pNewCrv->Clone()) ; //
//m_pGeomDB->SetMaterial( P, LIME) ;
//int Ptttt = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pNewCrv->Clone()) ; //
//m_pGeomDB->SetMaterial( Ptttt, LIME) ;
return true ;
}
@@ -10222,7 +10401,8 @@ Pocketing::IntersSurfWithRaw( ISurfFlatRegion* pSfrPock, const ISurfTriMesh* pSt
if ( ! frPock.IsValid())
return false ;
pCrv->ToLoc( frPock) ;
pCrv->ApproxWithArcsEx( 5 * EPS_SMALL, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) ; // 500 * EPS_SMALL
//pCrv->ApproxWithArcsEx( 5 * EPS_SMALL, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) ; // 500 * EPS_SMALL
pCrv->ApproxWithArcsEx( 0.5 , ANG_TOL_STD_DEG, LIN_FEA_STD, PA) ;
pCrv->Clear() ;
pCrv->FromPolyArc( PA) ;
pCrv->ToGlob( frPock) ;
@@ -10569,7 +10749,7 @@ Pocketing::GetStmRawPart( int nId, ISurfTriMesh* pSrfTMRaw, Frame3d frPocket)
return false ;
// dall'indice della geometria da svuotare, recupero l'Id del gruppo Processing in cui mi trovo
int nProcessingId = m_pGeomDB->GetParentId( nId) ;
/*int nProcessingId = m_pGeomDB->GetParentId( nId) ;
if ( nProcessingId != GDB_ID_NULL) {
int nPartId = m_pGeomDB->GetParentId( nProcessingId) ;
if ( nPartId != GDB_ID_NULL) {
@@ -10592,37 +10772,37 @@ Pocketing::GetStmRawPart( int nId, ISurfTriMesh* pSrfTMRaw, Frame3d frPocket)
}
}
}
}*/
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
// verifico che il grezzo compaia nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
// recupero l'oggetto dal database con tale Id
int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nRawSolidId) ;
// recupero il frame in cui si trova
Frame3d frRaw ;
m_pGeomDB->GetGlobFrame( nRawSolidId, frRaw) ;
if ( pGObj == nullptr)
return false ;
// controllo che sia una Trimesh
if ( pGObj->GetType() == SRF_TRIMESH) {
// Trimesh della parte p-esima
PtrOwner<ISurfTriMesh> pStmRawPart( CloneSurfTriMesh( GetSurfTriMesh( pGObj))) ;
if ( IsNull( pStmRawPart))
return false ;
// porto la trimesh in globale
pStmRawPart->LocToLoc( frRaw, frPocket) ;
// lo aggiungo alla Trimesh complessiva
pSrfTMRaw->Add( *Release( pStmRawPart)) ;
}
}
// passo al grezzo successivo
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
//int nRawId = m_pMchMgr->GetFirstRawPart() ;
//while ( nRawId != GDB_ID_NULL) {
// // verifico che il grezzo compaia nella fase
// if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
// // recupero l'oggetto dal database con tale Id
// int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
// const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nRawSolidId) ;
// // recupero il frame in cui si trova
// Frame3d frRaw ;
// m_pGeomDB->GetGlobFrame( nRawSolidId, frRaw) ;
// if ( pGObj == nullptr)
// return false ;
// // controllo che sia una Trimesh
// if ( pGObj->GetType() == SRF_TRIMESH) {
// // Trimesh della parte p-esima
// PtrOwner<ISurfTriMesh> pStmRawPart( CloneSurfTriMesh( GetSurfTriMesh( pGObj))) ;
// if ( IsNull( pStmRawPart))
// return false ;
// // porto la trimesh in globale
// pStmRawPart->LocToLoc( frRaw, frPocket) ;
// // lo aggiungo alla Trimesh complessiva
// pSrfTMRaw->Add( *Release( pStmRawPart)) ;
// }
// }
// // passo al grezzo successivo
// nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
//}
return true ;
}
@@ -12014,7 +12194,7 @@ Pocketing::GetCoeffLinArc( const ICurveArc* pArc, double dDiam, double& dSubArc)
//----------------------------------------------------------------------------
bool
Pocketing::SetBetterPtStartForSubChunks( ICurveComposite* pCrvOffsAct, const ISurfFlatRegion* pSrfToWork, Point3d& ptStart,
Pocketing::SetBetterPtStartForSubChunks( ICurveComposite* pCrvOffsAct, const ISurfFlatRegion* pSrfToWork, Point3d& ptStart,
Vector3d& vtMidOut, bool& bMidOut, double dOffs)
{
// ============================= INFO ==============================================================
@@ -12028,7 +12208,7 @@ Pocketing::SetBetterPtStartForSubChunks( ICurveComposite* pCrvOffsAct, const ISu
pSrfToWork == nullptr || ! pSrfToWork->IsValid() || pSrfToWork->GetChunkCount() != 1)
return false ;
// clono le curva su cui devo entrares
// clono le curva su cui devo entrare
PtrOwner<ICurveComposite> pCrv( CloneCurveComposite( pCrvOffsAct)) ;
if ( IsNull( pCrv))
return false ;
@@ -12073,6 +12253,21 @@ Pocketing::SetBetterPtStartForSubChunks( ICurveComposite* pCrvOffsAct, const ISu
pCrv->SetCurveTempProp( i, 1, 0) ; // <- tmp prop = 0
}
// cambio il punto iniziale della curva all'inizio del lato aperto più lungo ( se presente)
double dLenMax = EPS_SMALL ;
int nCrvForMax = 0 ;
if ( bSomeOpen) {
for ( int u = 0 ; u < pCrv->GetCurveCount() ; ++ u) {
int nTmpProp = 0 ;
double dLenAct = EPS_SMALL ;
if ( pCrv->GetCurveTempProp( u, nTmpProp, 0) && nTmpProp == 1 &&
pCrv->GetCurve( u)->GetLength( dLenAct) && dLenAct > dLenMax) {
dLenMax = dLenAct ;
nCrvForMax = u ;
}
}
pCrv->ChangeStartPoint( nCrvForMax) ;
}
// creo un vettore con tutti i Loops della pSwfToWork per i quali, mediante l'Offset, non hanno
// generato alcuna curva presente nella pCrv ( quella da cui devo entrare )
Pocketing.h
+4 -2
View File
@@ -143,6 +143,8 @@ class Pocketing : public Machining
const Point3d& ptCrvOpenE, const double dRad, const double dDiam,
ICurveComposite* pNewCrv, const Vector3d& vtTrasl,
ISurfTriMesh* pStmRaw = nullptr, bool bInVsOut = false) ;
bool CheckOpenEdgeOverlapParts( const ICurve* pCrvJ, const ICurve* pCrvOffBorder, bool bCloseToOpen, bool& bSucc,
ICurveComposite* pCrvFinal) ;
bool AdjustContourStart( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvIsl, bool bOrder = false) ;
bool GetParamForPtStartOnEdge( const ICurve* pCrv, const ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvIsl,
double& dPar) ;
@@ -337,11 +339,11 @@ class Pocketing : public Machining
bool m_bOpenOutRaw ; // flag forzatura lati aperti sempre fuori dal grezzo
double m_dOpenMinSafe ; // minima distanza di sicurezza di attacco su lato aperto
bool m_bIntersRaw = true ; // flag per intersezione con grezzo
bool m_bProjectRaw = true ; // flag di proiezione del grezzo
bool m_bProjectRaw = true ; // flag di proiezione del grezzo
double m_dMaxLenRawProj = 100 ; // lunghezza massima per contatto di proiezione
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
bool m_bAssignFeed = false ; // flag per controllo della Feed
bool m_bAssignFeed = false ; // flag per controllo della Feed
double m_dDiam_Prec = 0.0 ; // diametro utensile per precedente svuotatura
double m_dOffsetR_Prec = 0.0 ; // offset radiale della svuotatura precedente
double m_dSideStep_Prec = 0.0 ; // side Step della svuotatura precedente