Riccardo Elitropi
373 lines
29 KiB
C++
373 lines
29 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2017-2017
|
|
//----------------------------------------------------------------------------
|
|
// File :Pocketing.h Data : 04.02.17 Versione : 1.8b1
|
|
// Contenuto : Dichiarazione della classe Pocketing.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 04.02.17 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include "Machining.h"
|
|
#include "PocketingData.h"
|
|
#include "ToolData.h"
|
|
#include "/EgtDev/Include/EGkCurveComposite.h"
|
|
#include "/EgtDev/Include/EGkCurveLine.h"
|
|
#include "/EgtDev/Include/EgtNumUtils.h"
|
|
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
|
|
#include "/EgtDev/Include/EGkSurfTriMesh.h"
|
|
#include "/EgtDev/Include/EGkCurveArc.h"
|
|
|
|
//----------------------------------------------------------------------------
|
|
class Pocketing : public Machining
|
|
{
|
|
public : // IUserObj
|
|
Pocketing* Clone( void) const override ;
|
|
const std::string& GetClassName( void) const override ;
|
|
bool Dump( std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const override ;
|
|
bool ToSave( void) const override
|
|
{ return true ; }
|
|
bool Save( int nBaseId, STRVECTOR& vString) const override ;
|
|
bool Load( const STRVECTOR& vString, int nBaseGdbId) override ;
|
|
|
|
public : // Operation
|
|
int GetType( void) const override
|
|
{ return OPER_POCKETING ; }
|
|
bool IsEmpty( void) const override
|
|
{ return ( m_nPockets == 0) ; }
|
|
bool UpdateStatus( int nModif) override
|
|
{ m_nStatus |= nModif ; return true ; }
|
|
|
|
protected : // Operation
|
|
int GetSolCh( void) const override
|
|
{ return m_Params.m_nSolCh ; }
|
|
|
|
public : // Machining
|
|
bool Prepare( const std::string& sMillName) override ;
|
|
bool SetParam( int nType, bool bVal) override ;
|
|
bool SetParam( int nType, int nVal) override ;
|
|
bool SetParam( int nType, double dVal) override ;
|
|
bool SetParam( int nType, const std::string& sVal) override ;
|
|
bool SetGeometry( const SELVECTOR& vIds) override ;
|
|
bool Preview( bool bRecalc) override ;
|
|
bool Apply( bool bRecalc, bool bPostApply) override ;
|
|
bool Update( bool bPostApply) override ;
|
|
bool GetParam( int nType, bool& bVal) const override ;
|
|
bool GetParam( int nType, int& nVal) const override ;
|
|
bool GetParam( int nType, double& dVal) const override ;
|
|
bool GetParam( int nType, std::string& sVal) const override ;
|
|
bool UpdateToolData( bool* pbChanged = nullptr) override ;
|
|
const ToolData& GetToolData( void) const override ;
|
|
bool GetGeometry( SELVECTOR& vIds) const override ;
|
|
|
|
public :
|
|
Pocketing( void) ;
|
|
|
|
private :
|
|
bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
|
|
bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
|
|
bool GetForcedClosed( void) ;
|
|
bool SetCurveAllTempProp( int nCrvId, bool bForcedClose, ICurve* pCurve, bool* pbSomeOpen = nullptr) ;
|
|
bool ResetCurveAllTempProp( ICurve* pCurve) ;
|
|
bool Chain( int nGrpDestId) ;
|
|
bool ProcessPath( int nPathId, int nPvId, int nClId) ;
|
|
bool CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) const ;
|
|
bool VerifyPathFromBottom( const ISurfFlatRegion* pSrf, const Vector3d& vtTool) ;
|
|
bool GeneratePocketingPv( int nPathId, const ISurfFlatRegion* pSrfPock) ;
|
|
bool CheckSelectedId( void) ;
|
|
bool DetectShape( int nId, Frame3d frPocket) ;
|
|
bool DetectOpenEdgeInsideRaw ( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw ) ;
|
|
|
|
// =========================== MIGLIORIE GENERALI ====================
|
|
bool ModifyCurveToSmoothed( ICurveComposite* pCrvOffset, double dRightPer, double dleftPer) ;
|
|
bool OrderCurvesByLastPntOfPath( ICRVCOMPOPOVECTOR& vCrv, Point3d ptEnd, PNTVECTOR& vPtStart,
|
|
VCT3DVECTOR& vVtOut, BOOLVECTOR& vbMidOut, BOOLVECTOR& vbForcedOutStart) ;
|
|
bool SetBetterPtStartForSubChunks( ICurveComposite* pCrv0, const ISurfFlatRegion* pSrfToWork, Point3d& ptStart,
|
|
Vector3d& vtMidOut, bool& bMidOut, double dOffs) ;
|
|
// ===================================================================
|
|
|
|
// =========================== GREZZO e GEOMETRIE ====================
|
|
bool GetHomogeneousParts( ICurveComposite* pCrvCompo, ICURVEPOVECTOR& vCrvOpen, ICURVEPOVECTOR& vCrvClose,
|
|
bool bCallAdjust = false) ;
|
|
bool GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const Plane3d plPock, const Vector3d& vtExtr,
|
|
const double dThick, double dToll = 5 * EPS_SMALL) ;
|
|
bool ProjectEdgesOnSelFace( const ISurfFlatRegion* pSfrFacet, const ISurfTriMesh* pStmEdge, INTVECTOR& vBannedId ,
|
|
int nFacet, ISurfFlatRegion* pSfrProj, bool bIsIsland, ISurfFlatRegion* pSrfProjDanger) ;
|
|
bool GetSurfByAdj( const ISurfTriMesh* pSrfOri, INTVECTOR& vBannedId, int idCurrFace) ;
|
|
bool GetNewBorderByProjectionOfFaces( ISurfFlatRegion* pSrfpCompo, ICurveComposite* pCrvProj, const Point3d ptStart) ;
|
|
bool GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, std::vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags,
|
|
BOOLVECTOR& vbChangedPrec, VCT3DVECTOR& vVtTrasl, const ISurfFlatRegion* pSrfChunk,
|
|
int& nStep, const Vector3d vtTool, const double& dElev,
|
|
const double& dDepth, const double& dStep) ;
|
|
bool GetAdaptedSfrByTrimesh( const ISurfFlatRegion* pSfrExtended, const ISurfFlatRegion* pSfrORIG,
|
|
const ISurfTriMesh* pStmORIG, const Vector3d& vtTrasl, ISurfFlatRegion* pNewSrfPock) ;
|
|
bool ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPock, ISurfFlatRegion* pSfrProj) ;
|
|
bool CalcExtraSteps( const ISurfFlatRegion* pSfrAct, const ISurfTriMesh* pStmORIG,
|
|
const Vector3d vtTool, const double& dElev, const double& dDepth, const int& nStep,
|
|
const double& dStep, VCT3DVECTOR& vtVtTrasl) ;
|
|
bool AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, ISurfTriMesh* pStmRaw,
|
|
ICRVCOMPOPOVECTOR& vCrvOEFlags, bool& bChanged, int nStep, double dStep,
|
|
double dAreaToll = 500 * EPS_SMALL, ISurfTriMesh* pStmShape = nullptr) ;
|
|
bool AdjustFakeOpenEdges( ICurveComposite* pCrvCompo, const ISurfFlatRegion* pSrfOrig, const ISurfTriMesh* pStmRaw,
|
|
const Vector3d vtTrasl, bool bFromProj = false) ;
|
|
bool GetStmRawPart( int nId, ISurfTriMesh* pSrfTMRaw, Frame3d frPocket = GLOB_FRM) ;
|
|
bool GetSelectedStm( const ICurveComposite* pCvrBorder, Frame3d frPocket, bool& bIsStm, ISurfTriMesh* pStmOrig) ;
|
|
bool ProjectEdgesOfSelectedStm( const ISurfFlatRegion* pSrfToPock, const ISurfTriMesh* pStmORIG,
|
|
ISurfFlatRegion* pSfrNew) ;
|
|
bool CloseCurvesOnProjectionSurface( ICurveComposite* pCrvCompo, const ISurfFlatRegion* pSrfProjDanger) ;
|
|
bool CheckSmallPartsForOpenEdge( ICurveComposite* pCrvCompo, double dToll = 1500 * EPS_SMALL) ;
|
|
bool SetTmpPropWithRawProjectedFaces( ICurveComposite* pCrvCompo_NewExt, ICRVCOMPOPOVECTOR& vCrvExtProj,
|
|
const Vector3d& vtN, double dToll = 150 * EPS_SMALL) ;
|
|
bool IntersSurfWithRaw( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm, const Vector3d& vtTrasl,
|
|
bool& bIsChanged, double dAreaToll = 500 * EPS_SMALL, bool bInVsOut = true,
|
|
bool bRemoveSmallRawParts = false, bool bComputeOpenEdge = true) ;
|
|
bool ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrals, const ISurfTriMesh* pSrfProjRaw, int nId,
|
|
const ISurfFlatRegion* pSrfOrig, int nStep, double dStep,
|
|
double dAreaToll = 500 * EPS_SMALL) ;
|
|
bool CloseOpenSidesInsideRawForProjection( const ISurfFlatRegion* pSfrAct, const ISurfTriMesh* pStmRaw,
|
|
ISurfFlatRegion* pSfrMod) ;
|
|
bool ManageTmpPropForAdaptingStm( const ISurfTriMesh* pStmORIG, const ISurfFlatRegion* pSfrORIG,
|
|
const ISurfFlatRegion* pSfrProjUP, const ISurfFlatRegion* pSrfExtended,
|
|
const Vector3d& vtTrasl, ICRVCOMPOPOVECTOR& vCrvWithTmpProps) ;
|
|
bool SubtractFinalShape( ISurfFlatRegion* pSfrCurr, const Vector3d& vtTrasl, const ISurfTriMesh* pStmShape) ;
|
|
bool AdjustAngleForProjectedFace( const ISurfFlatRegion* pSrfFaceT, ICurveComposite* pCrvEdgeBorder, double dAngle) ;
|
|
bool SetOpenOrCloseEdge( ISurfFlatRegion* pSrfTP, const ISurfFlatRegion* pSrfForCrvs, const ISurfFlatRegion* pSrfOrig,
|
|
bool bFromProj = false, ISurfTriMesh* pStmRaw = nullptr, Vector3d vtTrasl = V_NULL,
|
|
bool bCheckFakeOpenEdge = true) ;
|
|
bool GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSrfOrig,
|
|
const int nStep, double dStep, const Vector3d& vtTrasl, ISurfFlatRegion* pSfrRawBoxProj) ;
|
|
bool CutProjectionToFitShape( ISurfFlatRegion* pSrfProjected, const ISurfFlatRegion* pSrfOrig) ;
|
|
bool AjustCurveForProjRawOnFace( const ICurveLine* pL1, ICurveLine* pL2, const ICurveComposite* pCrvBorder,
|
|
ICurveComposite* pCompo, int nStat, PNTVECTOR vPtTan, ISurfFlatRegion* pSrfProjRaw) ;
|
|
bool GetCurveByOverlap( const ICurve* pCrv, const ICurveComposite* pCrvCompo, int& nInd,
|
|
double dToll = 1500 * EPS_SMALL) ;
|
|
bool CheckSimpleOverlap( const ICurve* pCrv, const ICurveComposite* pCrvOri, int& nStat,
|
|
double dToll = 1500 * EPS_SMALL) ;
|
|
bool SetTmpPropByOverlap( ICurveComposite* pCrv, int nInd, const ICurveComposite* pCrvOri, int& nStat,
|
|
double dToll = 1500 * EPS_SMALL) ;
|
|
bool CheckBoundingPointForIslands( ICurveComposite* pCrv, int nInd, const ICRVCOMPOPOVECTOR& vCrvAll, int nIndFI,
|
|
bool bFlag) ;
|
|
bool GetCoeffLinArc( const ICurveArc* pArc, double dDiam, double& dSubArc) ;
|
|
bool GetParamOnOpenSide( const ICurveComposite* pCompo,const ICRVCOMPOPOVECTOR& vCrvIsl, Point3d& ptMid, Vector3d& vtMidOut) ;
|
|
bool AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTOR& vCrvIsl,
|
|
double dDiam, double dOffR, double dStepPrec, const Vector3d& vtTrasl,
|
|
ISurfTriMesh* pStmRaw = nullptr, bool bInVsOut = false) ;
|
|
bool AdustTmpPropLinesForProjection( ICurveComposite* pCompo) ;
|
|
bool AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvIsland,
|
|
ICurveComposite* pCrvOpenOffs, const Point3d& ptCrvOpenS,
|
|
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) ;
|
|
bool ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvOEFlags, const Vector3d& vtTrasl, ISurfTriMesh* pStmRaw = nullptr) ;
|
|
bool GetNewSrfByAnotherPocketing( ISurfFlatRegion* pSrf, ISurfFlatRegion* pSrf_noOpenEdge, const Vector3d& vtTrasl) ;
|
|
bool CheckForRemovingIsland( ICurveComposite* pCrvIslandBorder, double dOffs, bool bRemove) ;
|
|
// ===================================================================
|
|
|
|
// ============================ ZigZag ===============================
|
|
bool AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev,
|
|
double dOkStep, bool bSplitArcs) ;
|
|
bool CalcZigZag( const ISurfFlatRegion* pSrfZigZag, ICRVCOMPOPOVECTOR& vpCrvs) ;
|
|
bool CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurveComposite* pCrvLink) ;
|
|
bool OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d & vtTool, double dDepth, double dSafeZ,
|
|
Frame3d& frPocket, ICurveComposite* pCrvOrig, bool& bOptimizedZigZag,
|
|
ICRVCOMPOPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvIslMergeBorders, double& dOffs) ;
|
|
bool ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ;
|
|
bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag,
|
|
Vector3d& vtDir, double& dOffs) ;
|
|
bool ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds,
|
|
bool& bOptimizedZigZag, bool& bOpposite, Vector3d& vtDir, double& dOffs) ;
|
|
bool ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag,
|
|
bool& bOpposite, Vector3d& vtDir, double& dOffs) ;
|
|
bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY,
|
|
const INTVECTOR& vnClosedIds, double& dOffs) ;
|
|
bool AssignContourToPath( const ICRVCOMPOPOVECTOR& vpCrvs, const Frame3d frPocket, const ISurfFlatRegion* pSrfOffs, ICRVCOMPOPOVECTOR& vAllCrv) ;
|
|
bool CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) ;
|
|
// ===================================================================
|
|
|
|
// ============================ OneWay ===============================
|
|
bool AddOneWay( const ISurfFlatRegion* pSrfPock , const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth,
|
|
double dElev, double dOkStep, bool bSplitArcs) ;
|
|
bool OptimizeChunkOneWay( ISurfFlatRegion* pSrfOrig, ISURFFRPOVECTOR& vSrfIdeal, INTVECTOR& vIndChunk,
|
|
PNTVECTOR& vPtCheck) ;
|
|
// ===================================================================
|
|
|
|
// ============================ SpiralIn/Out =========================
|
|
bool AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth,
|
|
double dElev, double dOkStep, bool bSplitArcs) ;
|
|
bool AddSpiralOut( const ISurfFlatRegion* pSrfpock, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth,
|
|
double dElev, 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& bOptimizedTrap) ;
|
|
bool CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const double dOffs, const int nIter,
|
|
const int nOffsCount, const Vector3d& vtN, bool& bInsert) ;
|
|
bool GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR& vCrvs, ICURVEPOVECTOR& vLinks,
|
|
const ICurveComposite* pCrv_orig, ISurfFlatRegion* pSrfToCut) ;
|
|
bool GetDynamicClearedRegion( ISurfFlatRegion* pSrfPrec, const ICurveComposite* pCrv) ;
|
|
bool RemoveFirstLoopFromSfr( ISurfFlatRegion* pSrfOrig ) ;
|
|
bool RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOffs, ICRVCOMPOPOVECTOR& vOffsClosedCurves,
|
|
ICRVCOMPOPOVECTOR& vOffsFirstCurve, ICURVEPOVECTOR& vLinks) ;
|
|
bool RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECTOR& vOffsFirstCurve,
|
|
int& nOptFlag, Point3d& ptCentroid, ICurveComposite* pCrvPath) ;
|
|
bool CutOffsetToClosestPoint( ICRVCOMPOPOVECTOR& vCurves, const Point3d& ptFocus, ICurveComposite* pCrv1,
|
|
ICurveComposite* pCrv2, int& nIndex) ;
|
|
bool CutLinkToClosestPoint( ICURVEPOVECTOR& vCurves, ICRVCOMPOPOVECTOR& vOffs, const Point3d& ptFocus,
|
|
ICurveComposite* pCrv1, ICurveComposite* pCrv2, bool& bFound, int& nIndex) ;
|
|
bool GetNewCurvetWithCentroid( const ICurveComposite* pCrvH1, const ICurveComposite* pCrvH2, Point3d& ptC, bool bCir,
|
|
ICRVCOMPOPOVECTOR& VFirstOff, ICurveComposite* pCrvNewCurve) ;
|
|
bool GetNewCurvetWithPath( const ICurveComposite* pCrvH1, const ICurveComposite* pCrvH2, ICurveComposite* pCrvPath,
|
|
ICRVCOMPOPOVECTOR& VFirstOff, ICRVCOMPOPOVECTOR& VoffsCl, ICurveComposite* pCrvNewCurve) ;
|
|
bool ManageSmoothAndAutoInters( ICurveComposite* pCrv, ICurveComposite* pCrvPath, ICurveComposite* pPath1,
|
|
ICurveComposite* pPath2, ICRVCOMPOPOVECTOR& vOffsCL) ;
|
|
bool GetCurveWeightInfo( const ICurveComposite* pCrvCompo, double dMaxLen, double& dToTRot, int& nSmallArcs, int& nSmallLines) ;
|
|
bool ChoosePath( const ICurveComposite* pCrv1, const ICurveComposite* pCrv2, int nP, double dPerP, double dMaxLen, int& nC) ;
|
|
bool CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCOMPOPOVECTOR& vOffIslands,
|
|
ICurveComposite* pCrvLink) ;
|
|
bool CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd, const Vector3d& vtEnd, double dParMeet,
|
|
ICRVCOMPOPOVECTOR& vOffIslands, ICurveComposite* pCrvLink) ;
|
|
bool ModifyBiArc( ICurve* pCrvBiArc, double dCutToll, ICurveComposite* pNewCrv) ;
|
|
bool CutCurveByOffsets( ICurveComposite* pCurve, ICRVCOMPOPOVECTOR& vOffs) ;
|
|
bool CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, ICRVCOMPOPOVECTOR& vOffs, ICRVCOMPOPOVECTOR& vOffIslands,
|
|
ICurveComposite* pCrvLink, double dLenPercS = 0.01, double dLenPercE = 0.01, int nMaxIter = 2) ;
|
|
bool CalcBoundedLinkWithBiArcs( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd, const Vector3d& vtEnd,
|
|
const ICurve* pCrvBound, ICurveComposite* pCrvLink) ;
|
|
bool CalcCircleSpiral( const Point3d& ptCen, const Vector3d& vtN, double dOutRad, double dIntRad,
|
|
bool bSplitArcs, ICurveComposite* pMCrv, ICurveComposite* pRCrv) ;
|
|
bool CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtDir, double dPocketSize,
|
|
ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool& bOptimizedTrap) ;
|
|
bool CalcTrapezoidSpiralLocalFrame( ICurveComposite * pCrvPocket, const Vector3d& vtDir, Frame3d& frLoc) ;
|
|
bool CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord, double dPocketSize) ;
|
|
bool AdjustTrapezoidSpiralForAngles( ICurveComposite * pMCrv, const ICurveComposite * pCrvPocket, bool bStart) ;
|
|
bool SpecialAdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveComposite* pCrvPocket) ;
|
|
bool AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICurveComposite * pRCrv, const Vector3d& vtTool,
|
|
double dDepth, int& nOutsideRaw) ;
|
|
bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth,
|
|
bool& bIsOutsideRaw) ;
|
|
bool GetSignedDistFromRealDirection( const Point3d ptP, const Vector3d vtDir, double& dDist, Vector3d& vtNorm) ;
|
|
// =========================================================================
|
|
|
|
// ============================ FEED =======================================
|
|
double GetMinFeed( void ) const { return GetFeed() * GetSideStep() / m_TParams.m_dDiam ; }
|
|
double GetMaxFeed( void ) const { return GetFeed() ; }
|
|
bool GetFeedForParam( double& dPar, double& dFeed) ;
|
|
bool AssignDefaultFeed( ICurveComposite* pCrv) ;
|
|
bool DrawColoredCrvForFeedTest( ICurve* pCurve, double dFeed) ;
|
|
bool AssignFeedForOpenEdge( ICurveComposite* pCrv, const ICurveComposite* pCrvOF_ori) ;
|
|
bool AssignFeedForLineInOut( ICurveComposite* pCrv, const bool bIsIn) ;
|
|
bool AssignFeedOnCorners( ICurveComposite* pCrv, const ICurveComposite* pCrv_orig, const double dLenToll) ;
|
|
bool AssignFeedForEdgeCleaning( ICurveComposite *pCrv, const ICRVCOMPOPOVECTOR& vCrvOF_orig, int nInd = -1) ;
|
|
|
|
// --- ZigZag/OneWay ---
|
|
bool AssignFeedZigZagOneWay( ICurveComposite* pCompoLine, const bool bIsLink, const ICURVEPOVECTOR& vLAbove,
|
|
const ICURVEPOVECTOR& vLUnder, const ICRVCOMPOPOVECTOR& vAddedLinks) ;
|
|
|
|
// --- SpiralIn/SpiralOut ---
|
|
bool AssignFeedSpiral( ICurveComposite* pCrv, const ISurfFlatRegion* pSrfRemoved_offs, const bool bIsLink,
|
|
const ICRVCOMPOPOVECTOR& vLinks_done, const ICurveComposite* pCrv_orig, double dToll) ;
|
|
bool AssignFeedSpiralOpt( const int nOptType, ICurveComposite* pCrv) ;
|
|
bool AssignFeedCrvOnUnclearedRegions( ICurveComposite* pCrv) ;
|
|
bool AssignFeedForReturnPath( ICurveComposite* pCrv) ;
|
|
|
|
// =========================================================================
|
|
|
|
// ============================ IN/OUT =====================================
|
|
bool VerifyLeadInHelix( ISurfFlatRegion* pSrfChunk, const Point3d& ptCen, double dRad) const ;
|
|
bool VerifyLeadInZigZag( ISurfFlatRegion* pSrfChunk, const Point3d& ptPa, const Point3d& ptPb) const ;
|
|
bool ComputePolishingPath( ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool bSplitArcs) ;
|
|
bool AddEpicycles( ICurveComposite * pCompo, ICurveComposite * pCrv, ICurveComposite * pCrvBound = nullptr) ;
|
|
bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
|
|
double dElev, double dAppr, bool bOutStart) ;
|
|
bool AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
|
|
double dElev, double dAppr, bool bOutStart = false) ;
|
|
bool AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
|
|
double dElev, double dAppr) ;
|
|
bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
|
|
double dElev, double dAppr) ;
|
|
bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
|
|
const ICurveComposite* pRCrv, Point3d& ptP1) const ;
|
|
bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
|
|
ISurfFlatRegion* pSrfChunk, const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs,
|
|
bool bNoneForced = false, bool bSkipControl = false) ;
|
|
bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
|
|
const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, Point3d& ptP1,
|
|
double& dElev, bool bRecalcElev = true) ;
|
|
bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
|
|
const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
|
|
Point3d& ptP1, double& dElev, bool& bOppositeHome, bool bRecalcElev = true) ;
|
|
double GetRadiusForStartEndElevation( void) const ;
|
|
// ===================================================================
|
|
|
|
private :
|
|
double GetSpeed( void) const
|
|
{ return ( IsNullAngValue( m_Params.m_dSpeed) ? m_TParams.m_dSpeed : m_Params.m_dSpeed) ; }
|
|
double GetFeed( void) const
|
|
{ return ( IsNullLenValue( m_Params.m_dFeed) ? m_TParams.m_dFeed : m_Params.m_dFeed) ; }
|
|
double GetStartFeed( void) const
|
|
{ return ( IsNullLenValue( m_Params.m_dStartFeed) ? m_TParams.m_dStartFeed : m_Params.m_dStartFeed) ; }
|
|
double GetEndFeed( void) const
|
|
{ return ( IsNullLenValue( m_Params.m_dEndFeed) ? m_TParams.m_dEndFeed : m_Params.m_dEndFeed) ; }
|
|
double GetTipFeed( void) const
|
|
{ return ( IsNullLenValue( m_Params.m_dTipFeed) ? m_TParams.m_dTipFeed : m_Params.m_dTipFeed) ; }
|
|
double GetOffsL( void) const
|
|
{ return ( IsUnknownValue( m_Params.m_dOffsL) ? m_TParams.m_dOffsL : m_Params.m_dOffsL) ; }
|
|
double GetOffsR( void) const
|
|
{ return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
|
|
double GetSideStep( void) const
|
|
{ return Clamp( m_Params.m_dSideStep, std::min( 0.1 * m_TParams.m_dDiam, 1.0), m_TParams.m_dDiam) ; }
|
|
int GetLeadInType( void) const
|
|
{ if ( m_Params.m_dLiTang < std::min( 0.1 * m_TParams.m_dDiam, 1.0))
|
|
return POCKET_LI_NONE ;
|
|
if ( m_Params.m_nLeadInType != POCKET_LI_GLIDE && m_Params.m_dLiElev < 10 * EPS_SMALL)
|
|
return POCKET_LI_NONE ;
|
|
return m_Params.m_nLeadInType ; }
|
|
bool LeadInRawIsOk( void) const
|
|
{ if ( m_TParams.m_nType != TT_MILL_NOTIP)
|
|
return true ;
|
|
return (( GetLeadInType() == POCKET_LI_ZIGZAG || GetLeadInType() == POCKET_LI_HELIX) &&
|
|
m_Params.m_dLiTang >= 0.9 * m_TParams.m_dDiam && m_Params.m_dLiElev <= 2) ; }
|
|
int GetLeadOutType( void) const
|
|
{ if ( m_Params.m_dLoTang < std::min( 0.1 * m_TParams.m_dDiam, 1.0))
|
|
return POCKET_LO_NONE ;
|
|
return m_Params.m_nLeadOutType ; }
|
|
|
|
private :
|
|
SELVECTOR m_vId ; // identificativi entit� geometriche da lavorare
|
|
PocketingData m_Params ; // parametri lavorazione
|
|
ToolData m_TParams ; // parametri utensile
|
|
double m_dTHoldBase ; // posizione base del porta-utensile
|
|
double m_dTHoldLen ; // lunghezza del porta-utensile
|
|
double m_dTHoldDiam ; // diametro del porta-utensile
|
|
double m_dMaxHelixRad ; // raggio massimo attacco ad elica nel caso di cerchi
|
|
int m_nStatus ; // stato di aggiornamento della lavorazione
|
|
int m_nPockets ; // numero di percorsi di svuotatura generati
|
|
bool m_bTiltingTab ; // flag utilizzo tavola basculante
|
|
Vector3d m_vtTiltingAx ; // versore direzione eventuale asse basculante
|
|
bool m_bAboveHead ; // flag utilizzo testa da sopra
|
|
bool m_bAggrBottom ; // flag di utilizzo dell'aggregato da sotto
|
|
Vector3d m_vtAggrBottom ; // vettore direzione ausiliaria aggregato da sotto
|
|
AggrBottom m_AggrBottom ; // dati eventuale aggregato da sotto
|
|
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_bHasShape = true ; // flag per presenza di geometria voluta
|
|
PtrOwner<ISurfTriMesh> m_pStmShape ; // puntatore alla superficie TriMesh da seguire
|
|
double m_dMaxLenRawProj = 200 ; // 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
|
|
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
|
|
|
|
} ; |