diff --git a/Pocketing.cpp b/Pocketing.cpp index b258add..2107620 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -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 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 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 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 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 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 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 pCrvDraw1( CloneCurveComposite( pCrvPocket)) ; - pCrvDraw1->ToGlob( frPocket) ; - m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvDraw1->Clone()) ; + //PtrOwner 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 pCrvDraw( CloneCurveComposite( pCrvPocket)) ; - pCrvDraw->ToGlob( frPocket) ; - m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvDraw->Clone()) ; + //PtrOwner 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 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 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 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 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 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 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 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 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 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 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 ) diff --git a/Pocketing.h b/Pocketing.h index 77b487f..cff5187 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -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