diff --git a/Pocketing.cpp b/Pocketing.cpp index cca7167..1c9fb18 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -1833,11 +1833,11 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId) return false ; break ; case POCKET_SUB_SPIRALIN: - if ( ! AddSpiralIn( pSrfPock, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs)) + if ( ! AddSpiralIn( pSrfPock, vtTool, vtExtr, dDepth, dElev, dMaxElev, dOkStep, bSplitArcs)) return false ; break ; case POCKET_SUB_SPIRALOUT: - if ( ! AddSpiralOut( pSrfPock, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs)) + if ( ! AddSpiralOut( pSrfPock, vtTool, vtExtr, dDepth, dElev, dMaxElev, dOkStep, bSplitArcs)) return false ; break ; } @@ -2435,15 +2435,6 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c int nOff_index = int( vCrvInfo.size()) ; for ( int x = 0 ; x < int( vCrvIslMergeBorders.size()) ; ++ x) { - /*CrvInfo myCrvInfo ; - myCrvInfo.pCrvCompo.Set( Release( vCrvIslMergeBorders[x])) ; - myCrvInfo.nCrvType = CRV_BORDER ; - myCrvInfo.ptStart = vPtStart[x] ; - myCrvInfo.bMidOut = vbMidOut[x] ; - myCrvInfo.vtMidOut = vVtMidOut[x] ; - myCrvInfo.nChunk = cc ; - vCrvInfo.emplace_back( myCrvInfo) ; - */ vCrvInfo[nOff_index + x].pCrvCompo.Set( Release( vCrvIslMergeBorders[x])) ; vCrvInfo[nOff_index + x].nCrvType = CRV_BORDER ; vCrvInfo[nOff_index + x].ptStart = vPtStart[x] ; @@ -2488,13 +2479,8 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c int nIndex_offs = int( vCrvInfo.size()) ; vCrvInfo.resize( int( vpCrvs.size()) + nIndex_offs) ; for ( int x = 0 ; x < int( vpCrvs.size()) ; ++ x) { - /*CrvInfo myCrvInfo ; - myCrvInfo.pCrvCompo.Set( Release( vpCrvs[x])) ; - myCrvInfo.nChunk = cc ; - vCrvInfo.emplace_back( myCrvInfo) ;*/ vCrvInfo[ nIndex_offs + x].pCrvCompo.Set( Release( vpCrvs[x])) ; vCrvInfo[ nIndex_offs + x].nChunk = cc ; - } } // se la regione non è dentro alla curva esterna allora la ignoro @@ -2550,14 +2536,6 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c int nIndex_offs = int( vCrvInfo.size()) ; vCrvInfo.resize( int( vAllCrv.size()) + nIndex_offs) ; for ( int x = 0 ; x < int( vAllCrv.size()) ; ++ x) { - /*CrvInfo myCrvInfo ; - myCrvInfo.pCrvCompo.Set( Release( vAllCrv[x])) ; - myCrvInfo.nCrvType = CRV_BORDER ; - myCrvInfo.bMidOut = vbMidOut[x] ; - myCrvInfo.ptStart = vPtStart[x] ; - myCrvInfo.vtMidOut = vVtMidOut[x] ; - vCrvInfo.emplace_back( myCrvInfo) ; - */ vCrvInfo[ nIndex_offs + x].pCrvCompo.Set( Release( vAllCrv[x])) ; vCrvInfo[ nIndex_offs + x].nCrvType = CRV_BORDER ; vCrvInfo[ nIndex_offs + x].bMidOut = vbMidOut[x] ; @@ -4629,7 +4607,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c //---------------------------------------------------------------------------- bool Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, const Vector3d& vtExtr, - double dDepth, double dElev, double dOkStep, bool bSplitArcs) + double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) { // recupero distanze di sicurezza @@ -4871,6 +4849,9 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, int nMaxInd = pMCrv->GetCurveCount() - 1 ; int nMaxRInd = pRCrv->GetCurveCount() - 1 ; + // determino l'affondamento attuale + double dSink = dElev - dDepth + dMaxElev - vVtTrasl[j-1].Len() ; + // ciclo sulle curve elementari for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente @@ -4901,18 +4882,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, 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)) - dStElev = dStep ; - bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), - m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - bool bUhAboveRaw = ! m_bAboveHead && - GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), - m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - //if ( bAhUnderRaw || bUhAboveRaw || m_bTiltingTab) - //dStElev = max( dStElev, dCurrAffondamento) ; - dStElev = max( dStElev, j * dStep) ; + double dStElev = dSink ; dStElev -= ( ptP1 - ptStart) * vtExtr ; // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco if ( GetLeadInType() == POCKET_LI_ZIGZAG || @@ -4926,7 +4896,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) ; + //dStElev = max( dStElev, j * dStep) ; // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, pRCrv, !m_Params.m_bInvert, bSplitArcs, bOutStart || bForcedOutStart)) { @@ -5012,14 +4982,12 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, pCurve->GetEndDir( vtEnd) ; // aggiungo uscita Point3d ptP1 ; - double dEndElev = dElev ; + double dEndElev = dSink ; SetFeed( GetEndFeed()) ; 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") ; @@ -5039,7 +5007,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, //---------------------------------------------------------------------------- bool Pocketing::AddSpiralOut( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, const Vector3d& vtExtr, - double dDepth, double dElev, double dOkStep, bool bSplitArcs) + double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) { // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; @@ -5422,6 +5390,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt if ( ! bHasIsland && pCrvOEWithFlags != nullptr) { // caso spirale PtrOwner pCrvBorder( GetCurveComposite( pSrfPock->GetLoop( 0, 0))) ; + 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 ; @@ -5448,32 +5417,33 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt } bool bSomeOpen = false ; int nTmpProp0 = -1 ; - for ( int u = 0 ; u < pCrvOEWithFlags->GetCurveCount() && !bSomeOpen; ++ u) { - pCrvOEWithFlags->GetCurveTempProp( u, nTmpProp0, 0) ; + for ( int u = 0 ; u < pCrvBorder->GetCurveCount() && !bSomeOpen; ++ u) { + pCrvBorder->GetCurveTempProp( u, nTmpProp0, 0) ; bSomeOpen = ( nTmpProp0 == 1) ; } // caso trapezoide - pCrvOEWithFlags->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ; Point3d pt ; Vector3d vtB1, vtL1, vtB2 ; - if ( pCrvOEWithFlags->IsATrapezoid( 100 * EPS_SMALL, pt, vtB1, vtL1, vtB2)) { - Vector3d vtDir( vtB1), vtOtherDir( vtL1) ; - // se parallelogramma scelgo come base i lati lunghi - Vector3d vtL2( - vtB1 + vtL1 + vtB2) ; - if ( AreSameOrOppositeVectorApprox( vtL1, vtL2)) { - if ( vtL1.Len() > vtB1.Len()) - swap( vtDir, vtOtherDir) ; - } - vtDir.Normalize() ; - Vector3d vtOrtho = OrthoCompo( vtOtherDir, vtDir) ; - double dPocketSize = vtOrtho.Len() ; - double dMaxOptSize ; - FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) ; - if ( ( ( bSomeOpen && dPocketSize < m_TParams.m_dDiam + EPS_SMALL) || - abs( dPocketSize - m_TParams.m_dDiam) < EPS_SMALL) && - ( ! FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) || - dPocketSize < dMaxOptSize)) - { + //if ( pCrvOEWithFlags->IsATrapezoid( 100 * EPS_SMALL, pt, vtB1, vtL1, vtB2)) { + // Vector3d vtDir( vtB1), vtOtherDir( vtL1) ; + // // se parallelogramma scelgo come base i lati lunghi + // Vector3d vtL2( - vtB1 + vtL1 + vtB2) ; + // if ( AreSameOrOppositeVectorApprox( vtL1, vtL2)) { + // if ( vtL1.Len() > vtB1.Len()) + // swap( vtDir, vtOtherDir) ; + // } + // vtDir.Normalize() ; + // Vector3d vtOrtho = OrthoCompo( vtOtherDir, vtDir) ; + // double dPocketSize = vtOrtho.Len() ; + // double dMaxOptSize ; + // FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) ; + // if ( ( ( bSomeOpen && dPocketSize < m_TParams.m_dDiam + EPS_SMALL) || + // abs( dPocketSize - m_TParams.m_dDiam) < EPS_SMALL) && + // ( ! FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) || + // dPocketSize < dMaxOptSize)) + // { + + /* if ( nReg == 0) { CalcTrapezoidSpiral( pCrvOEWithFlags, vtDir, dPocketSize, pMCrv, pRCrv, bOptimizedTrap) ; if ( bOptimizedTrap) { @@ -5483,8 +5453,9 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt } else return true ; - } - } + */ + // } + //} } // porto il Chunk c-esimo nel sistema di riferimento locale (assieme al punto inziale) @@ -14806,4 +14777,332 @@ Pocketing::GetOptCrvIndex( const vector& vCrvOEWithFlags, int } return true ; +} + +//---------------------------------------------------------------------------- +bool +Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam, ICurveComposite* pCrvTrap, + Vector3d& vtDir, double& dPocketSize) +{ + // controllo parametri + if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid()) + return false ; + + // controllo il numero di lati chiusi e salvo i loro indici + int nClosedSide = 0 ; + INTVECTOR vIndClosedSides ; + for ( int u = 0 ; u < pCrvCompo->GetCurveCount() ; ++ u) { + int nTmpProp ; + if ( pCrvCompo->GetCurveTempProp( u, nTmpProp, 0) && nTmpProp == 0) { + ++nClosedSide ; + vIndClosedSides.push_back( u) ; + } + } + + // se tutti lati aperti + if ( nClosedSide == 0) { + // ricavo il box minimo della curva aperta ( passo dalla polyLine) + PolyLine PL ; + if ( ! pCrvCompo->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL)) + return false ; + Point3d ptCen ; double dWidth, dHeight ; + if ( ! PL.GetMinAreaRectangleXY( ptCen, vtDir, dWidth, dPocketSize)) + return false ; + // controllo dimY ( dHeight) + if ( dPocketSize > 2 * dDiam - 50 * EPS_SMALL) + return true ; + // inverto il frame attuale + Frame3d frRect ; frRect.Set( ptCen, Z_AX, vtDir) ; + if ( ! frRect.IsValid()) + return false ; + // creo il rettangolo del Box + pCrvTrap->AddPoint( Point3d( - 0.5 * dWidth, - 0.5 * dPocketSize, 0)) ; + pCrvTrap->AddLine( Point3d( 0.5 * dWidth, - 0.5 * dPocketSize, 0)) ; + pCrvTrap->AddLine( Point3d( 0.5 * dWidth, 0.5 * dPocketSize, 0)) ; + pCrvTrap->AddLine( Point3d( - 0.5 * dWidth, 0.5 * dPocketSize, 0)) ; + pCrvTrap->Close() ; + pCrvTrap->ToGlob( frRect) ; + // imposto tutte le curve come aperte + for ( int u = 0 ; u < pCrvTrap->GetCurveCount() ; ++ u) + pCrvTrap->SetCurveTempProp( u, 1, 0) ; + + } + // se un lato aperto + else if ( nClosedSide == 1) { + // prendo la curva + const ICurve* pCrvCurr = pCrvCompo->GetCurve( vIndClosedSides[0]) ; + if ( pCrvCurr == nullptr) + return false ; + // controllo se lineare + if ( pCrvCurr->GetType() != CRV_LINE) + return true ; + // prendo la direzione del tratto lineare + pCrvCurr->GetStartDir( vtDir) ; + // prendo il punto iniziale + Point3d ptStart ; pCrvCurr->GetStartPoint( ptStart) ; + // creo il riferimento basato su questo tratto + Frame3d frCurr ; + frCurr.Set( ptStart, Z_AX, vtDir) ; + if ( ! frCurr.IsValid()) + return false ; + // porto la curva compo ( clonandola) nel frame + PtrOwner pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ; + if ( IsNull( pCrvCompo_c)) + return false ; + pCrvCompo_c->ToLoc( frCurr) ; + BBox3d BBox ; + pCrvCompo_c->GetLocalBBox( BBox) ; + // controllo dimY + if ( BBox.GetDimY() > 1.5 * dDiam + 50 * EPS_SMALL || + ! ( abs( BBox.GetMin().y) > EPS_SMALL && abs( BBox.GetMax().y) > EPS_SMALL)) + return true ; + // creo il rettangolo del Box + pCrvTrap->AddPoint( BBox.GetMin()) ; + pCrvTrap->AddLine( BBox.GetMin() + BBox.GetDimX() * X_AX) ; + pCrvTrap->AddLine( BBox.GetMax()) ; + pCrvTrap->AddLine( BBox.GetMin() + BBox.GetDimY() * Y_AX) ; + pCrvTrap->Close() ; + // porto in globale + pCrvTrap->ToGlob( frCurr) ; + // imposto tutte le curve come aperte tranne la prima + for ( int u = 0 ; u < pCrvTrap->GetCurveCount() ; ++ u) + pCrvTrap->SetCurveTempProp( u, u == 0 ? 0 : 1, 0) ; + dPocketSize = BBox.GetDimY() ; + } + else { + // riordino gli indici in base alla lunghezza delle curva + sort( vIndClosedSides.begin(), vIndClosedSides.end(), ([pCrvCompo] ( int nInd_a, int nInd_b) { + double dLen_a, dLen_b ; + pCrvCompo->GetCurve( nInd_a)->GetLength( dLen_a) ; + pCrvCompo->GetCurve( nInd_b)->GetLength( dLen_b) ; + return dLen_b > dLen_a ; + })) ; + // cerco la base : + // lato lineare, box nella sua direzione con DimY < 1.5 dDiam, box dei restanti chiusi con dimY < dDiam + // il lato lineare deve essere un lato del box + bool bBaseFound = false ; + int nBase = -1 ; + int nSecondBase = -1 ; + BBox3d BBox ; + Frame3d frCurr ; + for ( int i = 0 ; i < int( vIndClosedSides.size()) && !bBaseFound ; ++ i) { + nBase = i ; + // prendo la curva + const ICurve* pCrvCurr = pCrvCompo->GetCurve( vIndClosedSides[i]) ; + if ( pCrvCurr == nullptr) + return false ; + // controllo se lineare + if ( pCrvCurr->GetType() != CRV_LINE) + continue ; + // prendo la direzione del tratto lineare + pCrvCurr->GetStartDir( vtDir) ; + // prendo il punto iniziale + Point3d ptStart ; pCrvCurr->GetStartPoint( ptStart) ; + // creo il riferimento basato su questo tratto + frCurr.Set( ptStart, Z_AX, vtDir) ; + if ( ! frCurr.IsValid()) + return false ; + // porto la curva compo ( clonandola) nel frame + PtrOwner pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ; + if ( IsNull( pCrvCompo_c)) + return false ; + pCrvCompo_c->ToLoc( frCurr) ; + pCrvCompo_c->GetLocalBBox( BBox) ; + // controllo dimY + if ( BBox.GetDimY() > 1.5 * dDiam + 50 * EPS_SMALL || + ! ( abs( BBox.GetMin().y) > EPS_SMALL && abs( BBox.GetMax().y) > EPS_SMALL)) + continue ; + // Box dei chiusi... + bool bOk = true ; + for ( int j = 0 ; j < int( vIndClosedSides.size()) ; ++ j) { + if ( i == j) + continue ; + // prendo la curva + const ICurve* pCrvOther = pCrvCompo_c->GetCurve( vIndClosedSides[j]) ; + if ( pCrvOther == nullptr) + return false ; + // calcolo il box + BBox3d BBoxOther ; + pCrvOther->GetLocalBBox( BBoxOther) ; + // controllo dimY + if ( BBox.GetDimY() > dDiam + 50 * EPS_SMALL) { + bOk = false ; + break ; + } + } + if ( bOk) { + // cerco se ho una seconda base lineare chiusa parallela alla prima e distante circa il diametro + for ( int u = 0 ; u < int( vIndClosedSides.size()) ; ++ u) { + if ( vIndClosedSides[u] == nBase || pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetType() != CRV_LINE) + continue ; + Vector3d vtCurr_dir ; pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetStartDir( vtCurr_dir) ; + if ( AreOppositeVectorApprox( vtCurr_dir, X_AX)) { + Point3d ptS0, ptS1 ; + pCrvCurr->GetStartPoint( ptS0) ; + pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetStartPoint( ptS1) ; + if ( abs( ptS1.y - ptS0.y - dDiam) > 50 * EPS_SMALL) + bOk = false ; + else + nSecondBase = vIndClosedSides[u] ; + } + } + } + bBaseFound = bOk ; + } // ? + if ( ! bBaseFound || nBase < 0) + return true ; // non è un caso ottimizzato + + dPocketSize = BBox.GetDimY() ; + + // se ho due basi + if ( nSecondBase > -1) { + // le parti tra le due basi devono essere tutte omogenee ( o tutte aperte o tutte chiuse) + Point3d ptSB0, ptSB1 ; + PtrOwner pCrvTest0( CloneCurveComposite( pCrvCompo)) ; + PtrOwner pCrvTest1( CloneCurveComposite( pCrvCompo)) ; + pCrvCompo->GetCurve( nBase)->GetStartPoint( ptSB0) ; + pCrvCompo->GetCurve( nSecondBase)->GetStartPoint( ptSB1) ; + pCrvTest0->ChangeStartPoint( nBase) ; + pCrvTest1->ChangeStartPoint( nSecondBase) ; + double dUTrim0, dUTrim1 ; + pCrvTest0->GetParamAtPoint( ptSB1, dUTrim0) ; + pCrvTest1->GetParamAtPoint( ptSB0, dUTrim1) ; + pCrvTest0->TrimStartEndAtParam( 1, dUTrim0) ; + pCrvTest1->TrimStartEndAtParam( 1, dUTrim1) ; + for ( int u = 0 ; u < pCrvTest0->GetCurveCount() - 1 ; ++ u) { + int nPropAct, nPropSucc ; + if ( pCrvTest0->GetCurveTempProp( u, nPropAct, 0) && + pCrvTest0->GetCurveTempProp( u + 1, nPropSucc, 0) && + nPropAct != nPropSucc) + return true ; + } + for ( int u = 0 ; u < pCrvTest1->GetCurveCount() - 1 ; ++ u) { + int nPropAct, nPropSucc ; + if ( pCrvTest1->GetCurveTempProp( u, nPropAct, 0) && + pCrvTest1->GetCurveTempProp( u + 1, nPropSucc, 0) && + nPropAct != nPropSucc) + return true ; + } + // creo le due curve di base + PtrOwner pCrvBase0( pCrvCompo->GetCurve( nBase)->Clone()) ; + PtrOwner pCrvBase1( pCrvCompo->GetCurve( nSecondBase)->Clone()) ; + pCrvBase0->ToLoc( frCurr) ; + pCrvBase1->ToLoc( frCurr) ; + Point3d ptEB0, ptEB1 ; + pCrvBase0->GetStartPoint( ptSB0) ; + pCrvBase0->GetEndPoint( ptEB0) ; + pCrvBase1->GetStartPoint( ptSB1) ; + pCrvBase1->GetEndPoint( ptEB1) ; + // controllo se lato destro o sinistro sono due semicirconferenze chiuse + bool bIsRightClosedArc = false ; + if ( pCrvTest0->GetCurveCount() == 1 && pCrvTest0->GetCurve( 0)->GetType() == CRV_ARC && + pCrvTest0->GetCurve( 0)->GetTempProp( 0) == 0 && + abs( (( ICurveArc*) pCrvTest0->GetCurve( 0))->GetAngCenter() - 180) < 50 * EPS_SMALL) + bIsRightClosedArc = true ; + bool bIsLeftClosedArc = false ; + if ( pCrvTest1->GetCurveCount() == 1 && pCrvTest1->GetCurve( 0)->GetType() == CRV_ARC && + pCrvTest1->GetCurve( 0)->GetTempProp( 0) == 0 && + abs( (( ICurveArc*) pCrvTest1->GetCurve( 0))->GetAngCenter() - 180) < 50 * EPS_SMALL) + bIsLeftClosedArc = true ; + // creo la linea a metà del box in direzione X_AX + PtrOwner pMidLine( CreateCurveLine()) ; + if ( IsNull( pMidLine) || + ! pMidLine->SetPVL( BBox.GetMin() + Y_AX * dDiam * 0.5, X_AX, 1.) || + ! pMidLine->IsValid()) + return false ; + // se lato destro aperto + bool bCopyRight = false ; + if ( pCrvTest0->GetCurve( 0)->GetTempProp( 0) == 1 || bIsRightClosedArc) { + ptEB0 = BBox.GetMin() + X_AX * BBox.GetDimX() ; + ptSB1 = BBox.GetMax() ; + } + // se lato destro chiuso + else + bCopyRight = true ; + // se lato sinistro aperto + bool bCopyLeft = false ; + if ( pCrvTest1->GetCurve( 0)->GetTempProp( 0) == 1 || bIsLeftClosedArc) { + ptSB0 = BBox.GetMin() ; + ptEB1 = BBox.GetMax() - X_AX * BBox.GetDimX() ; + } + else + bCopyLeft = true ; + // creo la curva da restituire + pCrvTrap->AddPoint( ptSB0) ; + pCrvTrap->AddLine( ptEB0) ; + if ( bCopyRight) + pCrvTrap->AddCurve( Release( pCrvTest0)) ; + else { + pCrvTrap->AddLine( ptSB1) ; + pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, bIsRightClosedArc ? 0 : 1, 0) ; // aperta + } + pCrvTrap->AddLine( ptEB1) ; + if ( bCopyLeft) + pCrvTrap->AddCurve( Release( pCrvTest1)) ; + else { + pCrvTrap->Close() ; + pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, bIsLeftClosedArc ? 0 : 1, 0) ; // aperta + } + } + else { + // devo avere un solo lato chiuso ( la base), oppure tre lati chiusi di cui il box deve avere DimY curva il diam + if ( nClosedSide != 1 && nClosedSide != 3) + return true ; + if ( nClosedSide == 3) { + // prendo i 3 lati chiusi + const ICurve* pCrv0 = pCrvCompo->GetCurve( vIndClosedSides[0]) ; + const ICurve* pCrv1 = pCrvCompo->GetCurve( vIndClosedSides[1]) ; + const ICurve* pCrv2 = pCrvCompo->GetCurve( vIndClosedSides[2]) ; + if ( pCrv0 == nullptr || pCrv1 == nullptr || pCrv2 == nullptr) + return false ; + // prendo i punti iniziali e finali + Point3d ptStart0 ; pCrv0->GetStartPoint( ptStart0) ; + Point3d ptEnd0 ; pCrv0->GetEndPoint( ptEnd0) ; + Point3d ptStart1 ; pCrv1->GetStartPoint( ptStart1) ; + Point3d ptEnd1 ; pCrv1->GetEndPoint( ptEnd1) ; + Point3d ptStart2 ; pCrv2->GetStartPoint( ptStart2) ; + Point3d ptEnd2 ; pCrv2->GetEndPoint( ptEnd2) ; + // controllo che siano consecutivi + if ( AreSamePointApprox( ptEnd0, ptStart1) && AreSamePointApprox( ptEnd1, ptStart2)) + ; + else if ( AreSamePointApprox( ptEnd1, ptStart2) && AreSamePointApprox( ptEnd2, ptStart0)) { + swap( vIndClosedSides[0], vIndClosedSides[1]) ; + swap( vIndClosedSides[1], vIndClosedSides[2]) ; + } + else if ( AreSamePointApprox( ptEnd2, ptStart0) && AreSamePointApprox( ptEnd0, ptStart1)) { + swap( vIndClosedSides[0], vIndClosedSides[2]) ; + swap( vIndClosedSides[2], vIndClosedSides[1]) ; + } + else // se non consecutivi ? ( per ora esco) + return true ; + + // controllo per sicurezza + if ( vIndClosedSides[1] != nBase) + return true ; + + // controllo le distanze che siano effettivamente il dDiam + PtrOwner pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ; + if ( IsNull( pCrvCompo_c)) + return false ; + pCrvCompo_c->ToLoc( frCurr) ; + Point3d ptS0 ; pCrvCompo_c->GetCurve( vIndClosedSides[0])->GetStartPoint( ptS0) ; + Point3d ptS1 ; pCrvCompo_c->GetCurve( vIndClosedSides[1])->GetStartPoint( ptS1) ; // sempre zero (!) + Point3d ptE2 ; pCrvCompo_c->GetCurve( vIndClosedSides[2])->GetEndPoint( ptE2) ; + if ( ptS0.y - ptS1.y > dDiam + 50 * EPS_SMALL || + ptE2.y - ptS1.y > dDiam + 50 * EPS_SMALL) + return true ; + + // creo la curva + pCrvTrap->AddPoint( ptS0) ; + pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[0])->Clone()) ; + pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[1])->Clone()) ; + pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[2])->Clone()) ; + pCrvTrap->Close() ; + pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, 1, 0) ; + } + } + + } + + return true ; } \ No newline at end of file diff --git a/Pocketing.h b/Pocketing.h index c9d34bf..5001c87 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -91,6 +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, Vector3d& vtDir, + double& dPocketSize) ; // =================================================================== // =========================== GREZZO e GEOMETRIE ==================== @@ -205,9 +207,9 @@ class Pocketing : public Machining // ============================ SpiralIn/Out ========================= bool AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, - double dElev, double dOkStep, bool bSplitArcs) ; + double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ; bool AddSpiralOut( const ISurfFlatRegion* pSrfpock, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, - double dElev, double dOkStep, bool bSplitArcs) ; + double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ; bool CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptStart, Vector3d& vtMidOut , bool& bMidOut, bool bSplitArcs,ICurveComposite* pMCrv, ICurveComposite* pRCrv, ICurveComposite* pCrvOEWithFlags, bool vbChangedPrec, bool& bOptimizedTrap) ;