diff --git a/Pocketing.cpp b/Pocketing.cpp index 859a78b..eb458a0 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -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 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 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 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 pCrvForId( GetCurveComposite( pSrfPocket->GetLoop( 0, 0))) ; - int nCrvId = pCrvForId->GetTempProp( 0) ; - PtrOwner 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 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 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 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 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 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 pCrvBorder( GetCurveComposite( pSrfPock->GetLoop( 0, 0))) ; + PtrOwner 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 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, vectorAdjustTopology() ; if ( ! GetStmRawPart( nProp0 , pStmRaw, GLOB_FRM)) return false ; + // ====================================================================================== // ====================================================================================== @@ -10075,26 +10003,6 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector 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 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, vectorGetArea( 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 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 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 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& 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 diff --git a/Pocketing.h b/Pocketing.h index 2d0cfa5..17b538e 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -91,8 +91,8 @@ class Pocketing : public Machining Vector3d& vtMidOut, bool& bMidOut) ; bool GetOptCrvIndex( const std::vector& 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) ;