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 ( ! IsValidFileName( sMachineName))
      return false ;
  // se macchina già caricata, non devo fare alcunchè
   if ( GetMachine( sMachineName) != - 1)
      return true ;
  // verifico esista il file mlde ( o mde) della macchina
   string sMachineMlde = m_sMachinesDir + "\\" + sMachineName + "\\" + sMachineName + ".Mlde" ;
   if ( ! ExistsFile( sMachineMlde))
      sMachineMlde = ChangeFileExtension( sMachineMlde, ".Mde") ;
   if ( ! ExistsFile( sMachineMlde))
      return false ;
  // salvo nel vettore
   m_vMachines.emplace_back( sMachineName, nullptr, nullptr, nullptr) ;
   return true ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetMachine( const string& sMachineName) const
{
  // ciclo sulle macchine
   for ( size_t i = 0 ; i < m_vMachines.size() ; ++ i) {
      if ( EqualNoCase( m_vMachines[i].sName, 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())  &&
        EqualNoCase( m_vMachines[m_nCurrMch].sName, 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 false ;
  // imposto i dati della macchina corrente
   m_nCurrMch = GetMachine( sMachineName) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCurrMachineName( string& sMachineName) const
{
  // verifico validità indice macchina corrente
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
      return false ;
  // assegno il nome
   sMachineName = m_vMachines[m_nCurrMch].sName ;
   return true ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCurrMachineDir( string& sMachineDir) const
{
  // recupero la macchina
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
  // assegno il relativo direttorio
   sMachineDir = pMch->GetMachineDir() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
MachMgr::IsCurrMachineLoaded( void) const
{
  // verifico validità indice macchina corrente
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
      return false ;
  // verifico esistenza gestore macchina
   return ( m_vMachines[m_nCurrMch].pMachine != nullptr) ;
}

//----------------------------------------------------------------------------
Machine*
MachMgr::GetCurrMachine( void) const
{
  // verifico validità indice macchina corrente
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
      return nullptr ;
  // se gestore macchina non esiste, provo a crearlo e caricarlo
   if ( m_vMachines[m_nCurrMch].pMachine == nullptr) {
     // creo gruppo ausiliario di base per le macchine
      if ( ! const_cast<MachMgr*>(this)->CreateMachAux())
         return nullptr ;
     // creo e carico la macchina
      PtrOwner<Machine> pMch( new( nothrow) Machine) ;
      if ( IsNull( pMch)  ||  ! pMch->Init( m_sMachinesDir, m_vMachines[m_nCurrMch].sName, const_cast<MachMgr*>(this)))
         return nullptr ;
     // nascondo la macchina
      if ( m_pGeomDB != nullptr)
         m_pGeomDB->SetStatus( pMch->GetMachineId(), GDB_ST_OFF) ;
     // salvo nel vettore
      const_cast<MachineData&>(  m_vMachines[m_nCurrMch]).pMachine = Release( pMch) ;
   }
  // restituisco il gestore macchina
   return m_vMachines[m_nCurrMch].pMachine ;
}

//----------------------------------------------------------------------------
ToolsMgr*
MachMgr::GetCurrToolsMgr( void) const
{
  // verifico validità indice macchina corrente
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
      return nullptr ;
  // se DB utensili non esiste, provo a crearlo e caricarlo
   if ( m_vMachines[m_nCurrMch].pTsMgr == nullptr) {
      PtrOwner<ToolsMgr> pTsMgr( new( nothrow) ToolsMgr) ;
      string sToolsFile = m_sMachinesDir + "\\" + m_vMachines[m_nCurrMch].sName + "\\" + TOOLS_DIR + "\\" + TOOLS_FILE ;
      if ( IsNull( pTsMgr)  ||  ! pTsMgr->Load( sToolsFile))
         return nullptr ;
     // salvo nel vettore
      const_cast<MachineData&>(  m_vMachines[m_nCurrMch]).pTsMgr = Release( pTsMgr) ;
   }
  // restituisco il gestore DB utensili
   return m_vMachines[m_nCurrMch].pTsMgr ;
}

//----------------------------------------------------------------------------
MachiningsMgr*
MachMgr::GetCurrMachiningsMgr( void) const
{
  // verifico validità indice macchina corrente
   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
      return nullptr ;
  // se DB lavorazioni non esiste, provo a crearlo e caricarlo
   if ( m_vMachines[m_nCurrMch].pMsMgr == nullptr) {
      PtrOwner<MachiningsMgr> pMsMgr( new( nothrow) MachiningsMgr) ;
      string sMachsFile = m_sMachinesDir + "\\" + m_vMachines[m_nCurrMch].sName + "\\" + MACHININGS_DIR + "\\" + MACHININGS_FILE ;
      if ( IsNull( pMsMgr)  ||  ! pMsMgr->Load( sMachsFile, GetCurrToolsMgr()))
         return nullptr ;
     // salvo nel vettore
      const_cast<MachineData&>(  m_vMachines[m_nCurrMch]).pMsMgr = Release( pMsMgr) ;
   }
  // restituisco il gestore DB lavorazioni
   return m_vMachines[m_nCurrMch].pMsMgr ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetCurrMachineId( void) const
{
   Machine* pMch = GetCurrMachine() ;
  // restituisco identificativo della radice della geometria della macchina corrente
   return ( ( pMch != nullptr) ? pMch->GetMachineId() : GDB_ID_NULL) ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetBaseId( const string& sBase) const
{
   Machine* pMch = GetCurrMachine() ;
  // restituisco identificativo della base indicata nella macchina corrente
   return ( ( pMch != nullptr) ? pMch->GetBaseId( sBase) : GDB_ID_NULL) ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetTableId( const string& sTable) const
{
   Machine* pMch = GetCurrMachine() ;
  // restituisco identificativo della tavola indicata nella macchina corrente
   return ( ( pMch != nullptr) ? pMch->GetTableId( sTable) : GDB_ID_NULL) ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetAxisId( const string& sAxis) const
{
   Machine* pMch = GetCurrMachine() ;
  // restituisco identificativo dell'asse indicato nella macchina corrente
   return ( ( pMch != nullptr) ? pMch->GetAxisId( sAxis) : GDB_ID_NULL) ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetHeadId( const string& sHead) const
{
   Machine* pMch = GetCurrMachine() ;
  // restituisco identificativo della testa indicata nella macchina corrente
   return ( ( pMch != nullptr) ? pMch->GetHeadId( sHead) : GDB_ID_NULL) ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetHeadExitCount( const string& sHead) const
{
   Machine* pMch = GetCurrMachine() ;
  // recupero il numero di uscite della testa
   return ( ( pMch != nullptr) ?  pMch->GetHeadExitCount( sHead) : 0) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetHeadAbove( const string& sHead) const
{
   if ( m_pGeomDB == nullptr)
      return false ;
   bool bAbove = true ;
   return ( ! m_pGeomDB->GetInfo( GetHeadId( sHead), "ABOVE", bAbove)  ||  bAbove) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAxisToken( const string& sAxis, string& sToken) const
{
   Machine* pMch = GetCurrMachine() ;
  // restituisco token dell'asse indicato nella macchina corrente
   return ( ( pMch != nullptr) ? pMch->GetAxisToken( sAxis, sToken) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAxisType( const string& sAxis, bool& bLinear) const
{
   Machine* pMch = GetCurrMachine() ;
  // restituisco il tipo dell'asse indicato nella macchina corrente
   return ( ( pMch != nullptr) ? pMch->GetAxisType( sAxis, bLinear) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetAxisPos( const string& sAxis, double dVal)
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->SetAxisPos( sAxis, dVal) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAxisPos( const string& sAxis, double& dVal) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetAxisPos( sAxis, dVal) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAxisHomePos( const string& sAxis, double& dHomeVal) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetAxisHomePos( sAxis, dHomeVal) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::ResetAxisPos( const string& sAxis)
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->ResetAxisPos( sAxis) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::ResetAllAxesPos( void)
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->ResetAllAxesPos() : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::LoadTool( const string& sHead, int nExit, const string& sTool)
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->LoadTool( sHead, nExit, sTool) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetLoadedTool( const string& sHead, int nExit, string& sTool) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetLoadedTool( sHead, nExit, sTool) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::UnloadTool( const string& sHead, int nExit)
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->UnloadTool( sHead, nExit) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::ResetHeadSet( const string& sHead)
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->ResetHeadSet( sHead) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetCalcTable( const string& sTable)
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->SetCurrTable( sTable) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetCalcTool( const string& sTool, const string& sHead, int nExit)
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->SetCurrTool( sTool, sHead, nExit) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetRotAxisBlock( const string& sAxis, double dVal)
{
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
   int nAxId = pMch->GetAxisId( sAxis) ;
   if ( nAxId == GDB_ID_NULL)
      return false ;
   m_vAxisBlock.emplace_back( sAxis, dVal) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetRotAxisBlocked( int nInd, string& sAxis, double& dVal)
{
  // se bloccaggi non ancora impostati
   if ( ! m_vAxisBlock.empty()) {
      if ( nInd < 0  ||  nInd >= int( m_vAxisBlock.size()))
         return false ;
      sAxis = m_vAxisBlock[nInd].sAxis ;
      dVal = m_vAxisBlock[nInd].dVal ;
      return true ;
   }
  // altrimenti cerco negli assi rotanti correnti
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
   int nMyInd = 0 ;
   for ( int i = 0 ; i < pMch->GetCurrRotAxes() ; ++ i) {
      if ( pMch->GetKinematicRotAxisBlocked( i, sAxis, dVal)) {
         if ( nMyInd == nInd)
            return true ;
         else
            ++ nMyInd ;
      }
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MachMgr::ApplyRotAxisBlock( void)
{
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
  // applico blocchi
   bool bOk = true ;
   for ( auto& abVal : m_vAxisBlock) {
      if ( ! pMch->BlockKinematicRotAxis( abVal.sAxis, abVal.dVal))
         bOk = false ;
   }
  // pulisco
   m_vAxisBlock.clear() ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
MachMgr::IsKinematicRotAxisBlocked( int nInd) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->IsKinematicRotAxisBlocked( nInd) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetCalcSolCh( int nScc)
{
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
  // imposto il criterio di scelta della soluzione
   return pMch->SetSolCh( nScc) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcTool( string& sTool) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetCurrTool( sTool) : false) ;
}

//----------------------------------------------------------------------------
double
MachMgr::GetCalcRot1W( void) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetCurrRot1W() : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAllHeadsNames( STRVECTOR& vNames) const
{
  // pulisco il vettore
   vNames.clear() ;
  // recupero la macchina corrente
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
  // richiedo elenco teste alla macchina
   return pMch->GetAllHeadsNames( vNames) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAllTablesNames( STRVECTOR& vNames) const
{
  // pulisco il vettore
   vNames.clear() ;
  // recupero la macchina corrente
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
  // richiedo elenco tavole alla macchina
   return pMch->GetAllTablesNames( vNames) ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetCurrLinAxes( void) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetCurrLinAxes() : false) ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetCurrRotAxes( void) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetCurrRotAxes() : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAllCurrAxesName( STRVECTOR& vAxName) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetAllCurrAxesName( vAxName) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetAllCurrAxesHomePos( DBLVECTOR& vAxHomeVal) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetAllCurrAxesHomePos( vAxHomeVal) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCurrAxisHomePos( int nInd, double& dHome) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetCurrAxisHomePos( nInd, dHome) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                        int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetAngles( vtDirT, vtDirA, nStat, dAngA1, dAngB1, dAngA2, dAngB2) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                        int& nStat, DBLVECTOR& vAng1, DBLVECTOR& vAng2) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetAngles( vtDirT, vtDirA, nStat, vAng1, vAng2) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB,
                           int& nStat, double& dX, double& dY, double& dZ) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetPositions( ptP, dAngA, dAngB, nStat, dX, dY, dZ) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcPositions( const Point3d& ptP, DBLVECTOR& vAng,
                           int& nStat, double& dX, double& dY, double& dZ) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetPositions( ptP, vAng, nStat, dX, dY, dZ) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
                                  bool bOverall, bool bBottom, Point3d& ptTip) const
{
   DBLVECTOR vAng( 2) ; vAng[0] = dAngA ; vAng[1] = dAngB ;
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, ptTip) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
                                  bool bOverall, bool bBottom, Point3d& ptTip) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, ptTip) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcToolDirFromAngles( double dAngA, double dAngB, Vector3d& vtDir) const
{
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
   DBLVECTOR vAng( 2) ; vAng[0] = dAngA ; vAng[1] = dAngB ;
   return pMch->GetToolDirFromAngles( vAng, vtDir) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetCalcAuxDirFromAngles( double dAngA, double dAngB, Vector3d& vtDir) const
{
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
   DBLVECTOR vAng( 2) ; vAng[0] = dAngA ; vAng[1] = dAngB ;
   return pMch->GetAuxDirFromAngles( vAng, vtDir) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::GetNearestAngleInStroke( int nInd, double dAngRef, double& dAng) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->GetNearestAngleInStroke( nInd, dAngRef, dAng) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::LimitAngleToStroke( int nInd, double& dAng) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->LimitAngleToStroke( nInd, dAng) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::VerifyAngleOutstroke( int nInd, double dAng) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->VerifyAngleOutstroke( nInd, dAng) : false) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::VerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) const
{
   DBLVECTOR vAng(2) ;  vAng[0] = dAngA ; vAng[1] = dAngB ;
   return VerifyOutstroke( dX, dY, dZ, vAng, true, nStat) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::VerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, bool bClear, int& nStat) const
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->VerifyOutstroke( dX, dY, dZ, vAng, bClear, nStat) : false) ;
}

//----------------------------------------------------------------------------
std::string
MachMgr::GetOutstrokeInfo( bool bMM) const
{
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return "" ;
   return pMch->GetOutstrokeInfo( bMM) ;
}

//----------------------------------------------------------------------------
bool
MachMgr::SetMachineLook( int nFlag)
{
   Machine* pMch = GetCurrMachine() ;
   return ( ( pMch != nullptr) ? pMch->SetLook( nFlag) : false) ;
}

//----------------------------------------------------------------------------
int
MachMgr::GetMachineLook( void) const
{
   Machine* pMch = GetCurrMachine() ;
   if ( pMch == nullptr)
      return MCH_LOOK_NONE ;
   return pMch->GetLook() ;
}