EgtMachKernel/SurfRoughing.h

//----------------------------------------------------------------------------
//  EgalTech 2024-2024
//----------------------------------------------------------------------------
// File : SurfRoughing.h         Data : 24.05.24          Versione : 2.6e5
// Contenuto : Dichiarazione della classe SurfRoughing.
//
//
//
// Modifiche : 24.05.24 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

#include "Machining.h"
#include "SurfRoughingData.h"
#include "ToolData.h"
#include "MachiningConst.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkIntersPlaneSurfTm.h"

class ICAvToolSurfTm ;

//----------------------------------------------------------------------------
class SurfRoughing : public Machining
{
   public :                           // IUserObj
      SurfRoughing* 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_SURFROUGHING ; }
      bool IsEmpty( void) const override
              { return ( m_nPaths == 0) ; }
      bool UpdateStatus( int nModif) override
              { m_nStatus |= nModif ; return true ; }

   protected :                        // Operation
      int  GetSolCh( void) const override
              { return m_Params.m_nSolCh ; }
      bool AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const override ;

   public :                           // Machining
      bool Prepare( const std::string& sSawName) 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 :
      SurfRoughing( void) ;

   private :
      bool VerifyGeometry( SelData Id, int& nSubs) ;
      bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
      bool Chain( int nGrpDestId) ;
      bool ProcessPath( int nPathId, int nTempId, int nPvId, int nClId) ;
      bool AddPocket( const INTVECTOR& vPocket, const Vector3d& vtTool, const Vector3d& vtExtr,
                      double dDepth, double dElev, bool bSplitArcs) ;
      bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
      bool AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
      bool AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
      bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
      bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, const ICurveComposite* pCrvPath, Point3d& ptP1) const ;
      bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
                      const Vector3d& vtN, const ICurveComposite* pCompo, const ICurveComposite* pRCrv,
                      bool bAtLeft, bool bSplitArcs, bool bNoneForced, bool bSkipControl) ;
      bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
                       const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
                       Point3d& ptP1, double& dElev) ;
      bool GetRaw( ISurfTriMesh* pStmRaw) const ;
      bool GetSfrByRawIntersection( ISurfFlatRegion* pSfrInt, IntersParPlanesSurfTm IPPStm, double dDist) const ;
      bool GetActiveSurfaces( INTVECTOR& vSurfId) const ;
      double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
      double GetRadiusForStartEndElevation( void) const ;
      bool ResetCurveAllTempProp( ICurve* pCurve) const ;
      bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw, bool bOnIsClosed) const ;
      bool CalcRetCrv( const ICurveComposite* pCompo, const Point3d& ptRef, bool bOutStart,
                       ICurveComposite* pRCrv) const ;
      bool VerifyLeadInHelix( const ICurveComposite* pCompo, const Point3d& ptCen, double dRad) const ;
      bool VerifyLeadInZigZag( const ICurveComposite* pCompo, const Point3d& ptPa, const Point3d& ptPb) const ;

   private :
      double GetSpeed() const
         { return ( IsNullAngValue( m_Params.m_dSpeed) ? m_TParams.m_dSpeed : m_Params.m_dSpeed) ; }
      double GetFeed() const
         { return ( IsNullLenValue( m_Params.m_dFeed) ? m_TParams.m_dFeed : m_Params.m_dFeed) ; }
      double GetStartFeed() const
         { return ( IsNullLenValue( m_Params.m_dStartFeed) ? m_TParams.m_dStartFeed : m_Params.m_dStartFeed) ; }
      double GetEndFeed() const
         { return ( IsNullLenValue( m_Params.m_dEndFeed) ? m_TParams.m_dEndFeed : m_Params.m_dEndFeed) ; }
      double GetTipFeed() const
         { return ( IsNullLenValue( m_Params.m_dTipFeed) ? m_TParams.m_dTipFeed : m_Params.m_dTipFeed) ; }
      double GetOffsR() const
         { return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
      double GetOffsL() const
         { return ( IsUnknownValue( m_Params.m_dOffsL) ? m_TParams.m_dOffsL : m_Params.m_dOffsL) ; }
      double GetSideStep( void) const
         { return Clamp( m_Params.m_dSideStep, 0.1, m_TParams.m_dTDiam) ; }
      int GetLeadInType( void) const
         { if ( m_Params.m_dLiTang < std::min( 0.1 * m_TParams.m_dDiam, 1.0))
              return SURFROU_LI_NONE ;
           if ( m_Params.m_nLeadInType != SURFROU_LI_GLIDE  &&  m_Params.m_dLiElev < 10 * EPS_SMALL)
              return SURFROU_LI_NONE ;
           return m_Params.m_nLeadInType ; }
      int GetLeadOutType( void) const
         { if ( m_Params.m_dLoTang < std::min( 0.1 * m_TParams.m_dDiam, 1.0))
              return SURFROU_LO_NONE ;
           return m_Params.m_nLeadOutType ; }

   private :
      SELVECTOR         m_vId ;             // identificativi entità geometriche da lavorare
      SurfRoughingData  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
      int               m_nStatus ;         // stato di aggiornamento della lavorazione
      int               m_nPaths ;          // numero di percorsi di lavoro generati
      double            m_dMaxHelixRad ;    // raggio massimo attacco ad elica nel caso di cerchi
} ;