EgtMachKernel/CamData.h

//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : CamData.h           Data : 10.06.15          Versione : 1.6f2
// Contenuto : Dichiarazione della classe CamData.
//
//
//
// Modifiche : 10.06.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

#include "/EgtDev/Include/EGkVector3d.h"
#include "/EgtDev/Include/EGkUserObj.h"
#include "/EgtDev/Include/EGkSelection.h"

//----------------------------------------------------------------------------
class CamData : public IUserObj
{
   public :                           // IUserObj
      virtual CamData* Clone( void) const ;
      virtual const std::string& GetClassName( void) const ;
      virtual bool Dump( std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const ;
      virtual bool SetOwner( int nId, IGeomDB* pGDB) ;
      virtual int  GetOwner( void) const ;
      virtual IGeomDB* GetGeomDB( void) const ;
      virtual bool ToSave( void) const { return true ; }
      virtual bool Save( STRVECTOR& vString) const ;
      virtual bool Load( const STRVECTOR& vString, int nBaseGdbId) ;
      virtual bool GetDrawPolyLines( POLYLINELIST& lstPL) const ;
      virtual bool Translate( const Vector3d& vtMove) ;
      virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg)
                      { double dAngRad = dAngDeg * DEGTORAD ;
                        return Rotate( ptAx, vtAx, cos( dAngRad), sin( dAngRad)) ; }
      virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) ;
      virtual bool Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) ;
      virtual bool Mirror( const Point3d& ptOn, const Vector3d& vtNorm) ;
      virtual bool Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff) ;
      virtual bool ToGlob( const Frame3d& frRef) ;
      virtual bool ToLoc( const Frame3d& frRef) ;
      virtual bool LocToLoc( const Frame3d& frOri, const Frame3d& frDest) ;

   public :
      CamData( void) ;
      bool SetMoveType( int nMove) ;
      bool SetToolDir( const Vector3d& vtDir) ;
      bool SetCorrDir( const Vector3d& vtDir) ;
      bool SetAuxDir( const Vector3d& vtDir) ;
      bool SetEndPoint( const Point3d& ptEnd) ;
      bool SetCenter( const Point3d& ptCen) ;
      bool SetAngCen( double dAngCen) ;
      bool SetNormDir( const Vector3d& vtDir) ;
      bool SetFeed( double dFeed) ;
      bool SetFlag( int nFlag) ;
      bool SetAxes( int nStatus, const DBLVECTOR& vAxVal) ;
      bool ChangeAxesMask( int nMask) ;
      bool ResetAxes( void)
              { m_nAxesStatus = AS_NONE ; return true ; }
      bool SetAxesCen( const Point3d ptAxCen) ;
      bool SetAxesRad( double dRad) ;
      bool SetAxesAngCen( double dAngCen) ;
      bool SetAxesNormDir( const Vector3d& vtDir) ;
      const int GetMoveType( void) const
                         { return m_nMove ; }
      const bool IsArc( void) const
                         { return ( m_nMove == 2  ||  m_nMove == 3) ; }
      const Vector3d& GetToolDir( void) const
                         { return m_vtTool ; }
      const Vector3d& GetCorrDir( void) const
                         { return m_vtCorr ; }
      const Vector3d& GetAuxDir( void) const
                         { return m_vtAux ; }
      const Point3d&  GetEndPoint( void) const
                         { return m_ptEnd ; }
      const Point3d&  GetCenter( void) const
                         { return m_ptCen ; }
      double          GetAngCen( void) const
                         { return m_dAngCen ; }
      const Vector3d& GetNormDir( void) const
                         { return m_vtN ; }
      double          GetFeed( void) const
                         { return m_dFeed ; }
      int             GetFlag( void) const
                         { return m_nFlag ; }
      int             GetAxesStatus( void) const
                         { return m_nAxesStatus ; }
      int             GetAxesMask( void) const
                         { return m_nAxesMask ; }
      const DBLVECTOR& GetAxesVal( void) const
                         { return m_vMachAxes ; }
      const Point3d&  GetAxesCen( void) const
                         { return m_ptMachCen ; }
      const double    GetAxesRad( void) const
                         { return m_dMachRad ; }
      const double    GetAxesAngCen( void) const
                         { return m_dMachAngCen ; }
      const Vector3d& GetAxisNormDir( void) const
                         { return m_vtMachN ; }

   public :
      enum { AS_NONE = 0,
             AS_OK = 1,
             AS_OUTSTROKE = 2,
             AS_DIR_ERR = 3,
             AS_ERR = 4} ;
      enum { MSK_L1 = 1,
             MSK_L2 = 2,
             MSK_L3 = 4,
             MSK_R1 = 8,
             MSK_R2 = 16,
             MSK_R3 = 32,
             MSK_R4 = 64} ;

   private :
      void ResetObjGraphics( void) ;

   private :
      int         m_nOwnerId ;
      IGeomDB*    m_pGeomDB ;
      int         m_nMove ;                // tipo movimento (0=rapido, 1=lineare, 2=arco CW, 3=arco CCW)
      int         m_nCorre ;               // tipo correzione (0, 41, 42, 141, 142, 40)
      Vector3d    m_vtTool ;               // versore fresa
      Vector3d    m_vtCorr ;               // versore correzione
      Vector3d    m_vtAux ;                // versore ausiliario
      Point3d     m_ptEnd ;                // punto finale
      Point3d     m_ptCen ;                // centro per archi
      double      m_dAngCen ;              // angolo al centro per archi
      Vector3d    m_vtN ;                  // vettore normale al piano di giacitura per archi
      double      m_dFeed ;                // velocità di avanzamento in lavorazione
      int         m_nFlag ;                // flag per usi vari
      int         m_nAxesStatus ;          // stato dei valori degli assi
      int         m_nAxesMask ;            // mask di emissione degli assi (bit a bit)
      DBLVECTOR   m_vMachAxes ;            // valori degli assi macchina
      Point3d     m_ptMachCen ;            // centro arco espresso in assi macchina
      double      m_dMachRad ;             // raggio arco espresso in macchina
      double      m_dMachAngCen ;          // angolo al centro per archi espresso in macchina
      Vector3d    m_vtMachN ;              // vettore normale al piano di giacitura per archi espresso in macchina
} ;


//----------------------------------------------------------------------------
inline const CamData* GetCamData( const IUserObj* pUserObj)
               { return dynamic_cast<const CamData*>( pUserObj) ; }
inline CamData* GetCamData( IUserObj* pUserObj)
               { return dynamic_cast< CamData*>( pUserObj) ; }