EgtMachKernel/MachMgrMachines.cpp

//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : MachMgrMachines.cpp     Data : 02.05.15          Versione : 1.6e1
// Contenuto : Implementazione gestione macchine della classe MachMgr.
//
//
//
// Modifiche : 02.05.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "MachConst.h"
#include "ToolsMgr.h"
#include "MachiningsMgr.h"
#include "SawingData.h"
#include "/EgtDev/Include/EGkGdbIterator.h"
#include "/EgtDev/Include/EgnStringUtils.h"
#include "/EgtDev/Include/EgnFileUtils.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//----------------------------------------------------------------------------
bool
MachMgr::LoadMachine( const string& sMachineName)
{
  // verifico validità del nome
   if ( ! IsValidName( sMachineName))
      return false ;
  // se macchina già caricata, non devo fare alcunchè
   if ( GetMachine( sMachineName) != - 1)
      return true ;
  // creo gruppo ausiliario di base per le macchine
   if ( ! CreateMachAux())
      return false ;
  // creo e carico la macchina
   PtrOwner<Machine> pMch( new( nothrow) Machine) ;
   if ( IsNull( pMch)  ||  ! pMch->Init( m_sMachinesDir, sMachineName, this))
      return false ;
  // creo e carico il DB utensili
   PtrOwner<ToolsMgr> pTsMgr( new( nothrow) ToolsMgr) ;
   string sToolsFile = m_sMachinesDir + "\\" + sMachineName + "\\" + TOOLS_DIR + "\\" + TOOLS_FILE ;
   if ( IsNull( pTsMgr)  ||  ! pTsMgr->Load( sToolsFile))
      return false ;
  // creo e carico il DB lavorazioni
   PtrOwner<MachiningsMgr> pMsMgr( new( nothrow) MachiningsMgr) ;
   string sMachsFile = m_sMachinesDir + "\\" + sMachineName + "\\" + MACHININGS_DIR + "\\" + MACHININGS_FILE ;
   if ( IsNull( pMsMgr)  ||  ! pMsMgr->Load( sMachsFile, Get( pTsMgr)))
      return false ;
  // salvo nel vettore
   m_vMachines.emplace_back( Release( pMch), Release( pTsMgr), Release( pMsMgr)) ;
   return true ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetMachine( const string& sMachineName) const
{
  // ciclo sulle macchine
   for ( size_t i = 0 ; i < m_vMachines.size() ; ++ i) {
      if ( m_vMachines[i].pMachine != nullptr  &&
           EqualNoCase( m_vMachines[i].pMachine->GetMachineName(), sMachineName))
         return int( i) ;
   }
   return - 1 ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetCurrMachine( const string& sMachineName)
{
  // se è già la macchina corrente, tutto bene
   if ( m_nCurrMch >= 0  &&  m_nCurrMch < int( m_vMachines.size())  &&
        m_vMachines[m_nCurrMch].pMachine != nullptr  &&
        EqualNoCase( m_vMachines[m_nCurrMch].pMachine->GetMachineName(), sMachineName))
      return true ;
  // se c'è macchinata corrente, non posso cambiare la macchina
   if ( m_nCurrMGrpId != GDB_ID_NULL)
      return false ;
  // verifica ed eventuale caricamento della macchina
   if ( ! LoadMachine( sMachineName))
      return GDB_ID_NULL ;
  // imposto i dati della macchina corrente
   m_nCurrMch = GetMachine( sMachineName) ;
   return true ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetCurrMGeoId( void) const
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return GDB_ID_NULL ;
   return m_vMachines[m_nCurrMch].pMachine->GetMGeoId() ;
}

//----------------------------------------------------------------------------
Machine*
MachMgr::GetCurrMachine( void) const
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
      return nullptr ;
   return m_vMachines[m_nCurrMch].pMachine ;
}

//----------------------------------------------------------------------------
ToolsMgr*
MachMgr::GetCurrToolsMgr( void) const
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
      return nullptr ;
   return m_vMachines[m_nCurrMch].pTsMgr ;
}

//----------------------------------------------------------------------------
MachiningsMgr*
MachMgr::GetCurrMachiningsMgr( void) const
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
      return nullptr ;
   return m_vMachines[m_nCurrMch].pMsMgr ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetAxisPos( const string& sAxis, double dVal)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return GDB_ID_NULL ;
   return m_vMachines[m_nCurrMch].pMachine->SetAxisPos( sAxis, dVal) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAxisPos( const string& sAxis, double& dVal)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return GDB_ID_NULL ;
   return m_vMachines[m_nCurrMch].pMachine->GetAxisPos( sAxis, dVal) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAxisHomePos( const string& sAxis, double& dHomeVal)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return GDB_ID_NULL ;
   return m_vMachines[m_nCurrMch].pMachine->GetAxisHomePos( sAxis, dHomeVal) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::ResetAxisPos( const string& sAxis)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return GDB_ID_NULL ;
   return m_vMachines[m_nCurrMch].pMachine->ResetAxisPos( sAxis) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::ResetAllAxesPos( void)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return GDB_ID_NULL ;
   return m_vMachines[m_nCurrMch].pMachine->ResetAllAxesPos() ;
}

//----------------------------------------------------------------------------
bool
MachMgr::LoadTool( const string& sHead, int nExit, const string& sTool)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->LoadTool( sHead, nExit, sTool) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::ResetHeadSet( const string& sHead)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->ResetHeadSet( sHead) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetCalcTable( const string& sTable)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->SetCurrTable( sTable) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetCalcTool( const string& sTool, const string& sHead, int nExit)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->SetCurrTool( sTool, sHead, nExit) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcTool( string& sTool)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->GetCurrTool( sTool) ;
}

//----------------------------------------------------------------------------
double
MachMgr::GetCalcRot1W( void)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return 1 ;
   return m_vMachines[m_nCurrMch].pMachine->GetCurrRot1W() ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetCurrLinAxes( void)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return 0 ;
   return m_vMachines[m_nCurrMch].pMachine->GetCurrLinAxes() ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetCurrRotAxes( void)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return 0 ;
   return m_vMachines[m_nCurrMch].pMachine->GetCurrRotAxes() ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAllCurrAxesName( STRVECTOR& vAxName)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->GetAllCurrAxesName( vAxName) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAllCalcAxesHomePos( DBLVECTOR& vAxHomeVal)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->GetAllCurrAxesHomePos( vAxHomeVal) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                        int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->GetAngles( vtDirT, vtDirA, nStat, dAngA1, dAngB1, dAngA2, dAngB2) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB,
                           int& nStat, double& dX, double& dY, double& dZ)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->GetPositions( ptP, dAngA, dAngB, nStat, dX, dY, dZ) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetNearestAngleInStroke( int nId, double dAngRef, double& dAng)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->GetNearestAngleInStroke( nId, dAngRef, dAng) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat)
{
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size())  ||
        m_vMachines[m_nCurrMch].pMachine == nullptr)
      return false ;
   return m_vMachines[m_nCurrMch].pMachine->VerifyOutOfStroke( dX, dY, dZ, dAngA, dAngB, nStat) ;
}