Dario Sassi
fe0cbd0191
- aggiunta gestione SCC (Solution Choice Criterion) nelle lavorazioni - possibilità di calcolo Tip con dimensioni massime anzichè quelle di lavoro - migliorato controllo pezzi prima di inserimento nei grezzi - migliorato caricamento tavola al cambio di gruppo di lavoro - aggiunta prima versione di risalita tra i percorsi di lavorazione in base a controllo collisioni (ora solo box) - in simulazione imposto variabile nome tavola prima di OnDispositionStart.
1009 lines
38 KiB
C++
1009 lines
38 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : Machine.cpp Data : 06.05.15 Versione : 1.6e3
|
|
// Contenuto : Implementazione gestione macchina.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 06.05.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "MachMgr.h"
|
|
#include "DllMain.h"
|
|
#include "Table.h"
|
|
#include "Axis.h"
|
|
#include "Head.h"
|
|
#include "Exit.h"
|
|
#include "/EgtDev/Include/EGkGeomDB.h"
|
|
#include "/EgtDev/Include/EGkGeoVector3d.h"
|
|
#include "/EgtDev/Include/EGkStringUtils3d.h"
|
|
#include "/EgtDev/Include/EGnFileUtils.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
#include <algorithm>
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
Machine::Machine( void)
|
|
{
|
|
m_pMchMgr = nullptr ;
|
|
m_pGeomDB = nullptr ;
|
|
m_nGroupId = GDB_ID_NULL ;
|
|
m_nTempGroupId = GDB_ID_NULL ;
|
|
m_dAxisMaxAdjust = EPS_SMALL ;
|
|
m_dExitMaxAdjust = EPS_SMALL ;
|
|
m_nCalcTabId = GDB_ID_NULL ;
|
|
m_nCalcHeadId = GDB_ID_NULL ;
|
|
m_nCalcExitId = GDB_ID_NULL ;
|
|
m_nCalcToolId = GDB_ID_NULL ;
|
|
m_dCalcRot1W = 1 ;
|
|
m_nCalcSolCh = MCH_SCC_NONE ;
|
|
m_dCalcTLen = 0 ;
|
|
m_dCalcTRad = 0 ;
|
|
m_dCalcTOvLen = 0 ;
|
|
m_dCalcTOvRad = 0 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Machine::~Machine( void)
|
|
{
|
|
Clear() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
Machine::Clear( void)
|
|
{
|
|
// cancellazione eventuali gruppi geometrici associati
|
|
if ( m_pGeomDB != nullptr) {
|
|
if ( m_nGroupId != GDB_ID_NULL)
|
|
m_pGeomDB->Erase( m_nGroupId) ;
|
|
if ( m_nTempGroupId != GDB_ID_NULL)
|
|
m_pGeomDB->Erase( m_nTempGroupId) ;
|
|
}
|
|
// pulizia interprete lua di macchina
|
|
LuaExit() ;
|
|
// reset membri
|
|
m_pMchMgr = nullptr ;
|
|
m_pGeomDB = nullptr ;
|
|
m_sName.clear() ;
|
|
m_sMachineDir.clear() ;
|
|
m_nGroupId = GDB_ID_NULL ;
|
|
m_nTempGroupId = GDB_ID_NULL ;
|
|
m_mapGroups.clear() ;
|
|
m_mapGroups.rehash( 20) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::Init( const string& sMachinesDir, const string& sMachineName, MachMgr* pMchMgr)
|
|
{
|
|
// pulisco
|
|
Clear() ;
|
|
// verifico ambiente
|
|
if ( pMchMgr == nullptr || pMchMgr->GetContextId() == 0 || pMchMgr->GetGeomDB() == nullptr)
|
|
return false ;
|
|
m_pMchMgr = pMchMgr ;
|
|
m_pGeomDB = m_pMchMgr->GetGeomDB() ;
|
|
// verifico direttorio dati macchina
|
|
m_sMachineDir = sMachinesDir + "\\" + sMachineName ;
|
|
if ( ! ExistsDirectory( m_sMachineDir))
|
|
return false ;
|
|
// creo il gruppo per la macchina
|
|
int nId = m_pGeomDB->InsertGroup( GDB_ID_NULL, pMchMgr->GetMachAuxId(), GDB_LAST_SON, GLOB_FRM) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return false ;
|
|
// imposto nome del gruppo
|
|
m_pGeomDB->SetName( nId, sMachineName) ;
|
|
// carico l'interprete lua dedicato alla macchina
|
|
if ( ! LuaInit( sMachineName)) {
|
|
m_pGeomDB->Erase( nId) ;
|
|
return false ;
|
|
}
|
|
// salvo i dati
|
|
m_nGroupId = nId ;
|
|
m_sName = sMachineName ;
|
|
// carico la macchina {
|
|
string sMachineMde = m_sMachineDir + "\\" + sMachineName + ".Mde" ;
|
|
bool bOk = LuaLoadMachine( sMachineMde) ;
|
|
// cancello il gruppo temporaneo
|
|
m_pGeomDB->Erase( m_nTempGroupId) ;
|
|
m_nTempGroupId = GDB_ID_NULL ;
|
|
// in caso di errore, cancello tutta la geometria
|
|
if ( ! bOk) {
|
|
m_pGeomDB->Erase( m_nGroupId) ;
|
|
m_pGeomDB->Erase( m_nTempGroupId) ;
|
|
m_nGroupId = GDB_ID_NULL ;
|
|
m_nTempGroupId = GDB_ID_NULL ;
|
|
m_sName.clear() ;
|
|
m_sMachineDir.clear() ;
|
|
}
|
|
// metto tutti gli assi in posizione home
|
|
bOk = bOk && ResetAllAxesPos() ;
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadMachineGeometry( const string& sMGeoName, const Vector3d& vtOffset)
|
|
{
|
|
// creo un sotto gruppo temporaneo in cui caricare la macchina
|
|
m_nTempGroupId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_pMchMgr->GetMachAuxId(), GLOB_FRM) ;
|
|
if ( m_nTempGroupId == GDB_ID_NULL)
|
|
return false ;
|
|
// carico la macchina
|
|
string sMachineNge = m_sMachineDir + "\\" + sMGeoName ;
|
|
if ( ! m_pGeomDB->Load( sMachineNge, m_nTempGroupId))
|
|
return false ;
|
|
// applico offset
|
|
return m_pGeomDB->TranslateGlob( m_nTempGroupId, vtOffset) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadMachineBase( const string& sName, const string& sGeo, const STRVECTOR& vsAux)
|
|
{
|
|
// recupero pezzo e layer della geometria originale della base
|
|
string sPart, sLay ;
|
|
Split( sGeo, "/", true, sPart, sLay) ;
|
|
// cerco il gruppo nella geometria originale
|
|
int nPart = m_pGeomDB->GetFirstNameInGroup( m_nTempGroupId, sPart) ;
|
|
int nLay = m_pGeomDB->GetFirstNameInGroup( nPart, sLay) ;
|
|
if ( nLay == GDB_ID_NULL)
|
|
return false ;
|
|
// lo sposto nella radice della macchina
|
|
if ( ! m_pGeomDB->RelocateGlob( nLay, m_nGroupId, GDB_LAST_SON))
|
|
return false ;
|
|
// gli assegno il nome
|
|
m_pGeomDB->SetName( nLay, sName) ;
|
|
// sistemo la geometria ausiliaria
|
|
if ( ! AdjustAuxGeometry( vsAux, nLay))
|
|
return false ;
|
|
// lo inserisco nel dizionario dei gruppi della macchina
|
|
return m_mapGroups.emplace( sName, nLay).second ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::AdjustAuxGeometry( const STRVECTOR& vsAux, int nLay)
|
|
{
|
|
// sistemo la geometria ausiliaria
|
|
for ( const auto& sAux : vsAux) {
|
|
// recupero pezzo e layer della geometria ausiliaria
|
|
string sAuxPart, sAuxLay ;
|
|
Split( sAux, "/", true, sAuxPart, sAuxLay) ;
|
|
// cerco il gruppo nella geometria originale
|
|
int nAuxPart = m_pGeomDB->GetFirstNameInGroup( m_nTempGroupId, sAuxPart) ;
|
|
int nAuxLay = m_pGeomDB->GetFirstNameInGroup( nAuxPart, sAuxLay) ;
|
|
if ( nAuxLay == GDB_ID_NULL)
|
|
return false ;
|
|
// lo sposto nel gruppo
|
|
if ( ! m_pGeomDB->RelocateGlob( nAuxLay, nLay, GDB_LAST_SON))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadMachineTable( const string& sName, const string& sParent, int nType,
|
|
const Point3d& ptRef1, const string& sGeo, const STRVECTOR& vsAux)
|
|
{
|
|
// recupero pezzo e layer della geometria originale della tavola
|
|
string sPart, sLay ;
|
|
Split( sGeo, "/", true, sPart, sLay) ;
|
|
// cerco il gruppo nella geometria originale
|
|
int nPart = m_pGeomDB->GetFirstNameInGroup( m_nTempGroupId, sPart) ;
|
|
int nLay = m_pGeomDB->GetFirstNameInGroup( nPart, sLay) ;
|
|
if ( nLay == GDB_ID_NULL)
|
|
return false ;
|
|
// cerco il gruppo padre per spostarvelo
|
|
int nParentId = GetGroup( sParent) ;
|
|
if ( nParentId == GDB_ID_NULL ||
|
|
! m_pGeomDB->RelocateGlob( nLay, nParentId, GDB_LAST_SON))
|
|
return false ;
|
|
// gli assegno il nome
|
|
m_pGeomDB->SetName( nLay, sName) ;
|
|
// sistemo la geometria ausiliaria
|
|
if ( ! AdjustAuxGeometry( vsAux, nLay))
|
|
return false ;
|
|
// aggiusto la posizione della tavola
|
|
if ( ! AdjustTable( nLay, ptRef1))
|
|
return false ;
|
|
// recupero l'area valida
|
|
int nAreaId = m_pGeomDB->GetFirstNameInGroup( nLay, MCH_TAREA + "1") ;
|
|
BBox3d b3Area1 ;
|
|
if ( ! m_pGeomDB->GetGlobalBBox( nAreaId, b3Area1))
|
|
return false ;
|
|
// installo e inizializzo il gestore della tavola
|
|
Table* pTab = new(nothrow) Table ;
|
|
if ( pTab == nullptr)
|
|
return false ;
|
|
pTab->Set( sName, nType, ptRef1, b3Area1) ;
|
|
m_pGeomDB->SetUserObj( nLay, pTab) ;
|
|
// lo inserisco nel dizionario dei gruppi della macchina
|
|
return m_mapGroups.emplace( sName, nLay).second ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::AdjustTable( int nLay, const Point3d& ptRef1)
|
|
{
|
|
// riferimento globale del gruppo tavola
|
|
Frame3d frTable ;
|
|
m_pGeomDB->GetGroupGlobFrame( nLay, frTable) ;
|
|
// recupero il primo riferimento della tavola
|
|
int nRef1 = m_pGeomDB->GetFirstNameInGroup( nLay, MCH_TREF + "1") ;
|
|
if ( nRef1 == GDB_ID_NULL || m_pGeomDB->GetGeoType( nRef1) != GEO_FRAME3D) {
|
|
string sOut = " Missing " + MCH_TREF + "1" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
// recupero frame
|
|
const Frame3d& frFrame = GetGeoFrame3d( m_pGeomDB->GetGeoObj( nRef1))->GetFrame() ;
|
|
// ne calcolo l'origine in globale
|
|
Point3d ptPos = frFrame.Orig() ;
|
|
ptPos.ToGlob( frTable) ;
|
|
// verifico eventuale aggiustamento di posizione
|
|
Vector3d vtMove = ptRef1 - ptPos ;
|
|
if ( ! vtMove.IsSmall()) {
|
|
string sOut = " Move = (" + ToString( vtMove) + ")" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return m_pGeomDB->TranslateGlob( nLay, vtMove) ;
|
|
}
|
|
else
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadMachineAxis( const string& sName, const string& sParent, int nType,
|
|
const Point3d& ptPos, const Vector3d& vtDir, const STROKE& Stroke, double dHome,
|
|
bool bAdjustAux, const string& sGeo, const STRVECTOR& vsAux)
|
|
{
|
|
// verifico sia di tipo ammesso
|
|
if ( nType != MCH_AT_LINEAR && nType != MCH_AT_ROTARY) {
|
|
LOG_ERROR( GetEMkLogger(), " Wrong Axis Type") ;
|
|
return false ;
|
|
}
|
|
// recupero pezzo e layer della geometria originale dell'asse
|
|
string sPart, sLay ;
|
|
Split( sGeo, "/", true, sPart, sLay) ;
|
|
// cerco il gruppo nella geometria originale
|
|
int nPart = m_pGeomDB->GetFirstNameInGroup( m_nTempGroupId, sPart) ;
|
|
int nLay = m_pGeomDB->GetFirstNameInGroup( nPart, sLay) ;
|
|
if ( nLay == GDB_ID_NULL) {
|
|
string sOut = " Missing Axis Part " + sPart ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
// cerco il gruppo padre per spostarvelo
|
|
int nParentId = GetGroup( sParent) ;
|
|
if ( nParentId == GDB_ID_NULL ||
|
|
! m_pGeomDB->RelocateGlob( nLay, nParentId, GDB_LAST_SON)) {
|
|
string sOut = " Missing Parent Group " + sParent ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
// verifico che il valore di home sia nei limiti di corsa
|
|
if ( dHome < Stroke.Min || dHome > Stroke.Max) {
|
|
LOG_ERROR( GetEMkLogger(), " Home Position Out of stroke") ;
|
|
return false ;
|
|
}
|
|
// gli assegno il nome
|
|
m_pGeomDB->SetName( nLay, sName) ;
|
|
// sistemo la geometria ausiliaria
|
|
if ( ! AdjustAuxGeometry( vsAux, nLay))
|
|
return false ;
|
|
// installo e inizializzo il gestore dell'asse
|
|
Axis* pAxis = new(nothrow) Axis ;
|
|
if ( pAxis == nullptr)
|
|
return false ;
|
|
pAxis->Set( sName, nType, ptPos, vtDir, Stroke, dHome) ;
|
|
m_pGeomDB->SetUserObj( nLay, pAxis) ;
|
|
// verifico il vettore rappresentativo dell'asse
|
|
if ( ! AdjustAxis( nLay, sPart, sName, nType, ptPos, vtDir, bAdjustAux))
|
|
return false ;
|
|
// lo inserisco nel dizionario dei gruppi della macchina
|
|
return m_mapGroups.emplace( sName, nLay).second ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::AdjustAxis( int nLay, const string& sPart, const string& sName,
|
|
int nType, const Point3d& ptPos, const Vector3d& vtDir, bool bAdjustAux)
|
|
{
|
|
// verifico presenza vettore asse
|
|
int nId = m_pGeomDB->GetFirstNameInGroup( nLay, sPart) ;
|
|
if ( nId == GDB_ID_NULL || m_pGeomDB->GetGeoType( nId) != GEO_VECT3D) {
|
|
string sOut = " Missing Axis Vector " + sPart ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
// lo sposto all'inizio del suo gruppo
|
|
if ( ! m_pGeomDB->Relocate( nId, nLay, GDB_FIRST_SON))
|
|
return false ;
|
|
// lo rinomino come l'asse
|
|
if ( ! m_pGeomDB->SetName( nId, sName))
|
|
return false ;
|
|
// lo nascondo
|
|
if ( ! m_pGeomDB->SetStatus( nId, GDB_ST_OFF))
|
|
return false ;
|
|
|
|
// riferimento globale del gruppo asse
|
|
Frame3d frFrame ;
|
|
m_pGeomDB->GetGroupGlobFrame( nLay, frFrame) ;
|
|
// recupero punto base e vettore direzione
|
|
IGeoVector3d* pGeoVct = GetGeoVector3d( m_pGeomDB->GetGeoObj( nId)) ;
|
|
Point3d ptBase = pGeoVct->GetBase() ;
|
|
Vector3d vtAxis = pGeoVct->GetVector() ;
|
|
vtAxis.Normalize() ;
|
|
// riassegno il vettore normalizzato
|
|
pGeoVct->ChangeVector( vtAxis) ;
|
|
// li porto in globale
|
|
ptBase.ToGlob( frFrame) ;
|
|
vtAxis.ToGlob( frFrame) ;
|
|
|
|
// se asse lineare devo verificarne solo la direzione
|
|
if ( nType == MCH_AT_LINEAR) {
|
|
Vector3d vtDirN = vtDir ;
|
|
if ( ! vtDirN.Normalize() || ! AreSameVectorApprox( vtAxis, vtDirN)) {
|
|
string sOut = " Wrong Axis Vector or Dir " + sPart ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
}
|
|
|
|
// altrimenti asse rotante, devo verificarne direzione e coassialità (questa solo se non abilitato movimento)
|
|
else {
|
|
Vector3d vtDirN = vtDir ;
|
|
if ( ! vtDirN.Normalize() || ! AreSameVectorApprox( vtAxis, vtDirN)) {
|
|
string sOut = " Wrong Axis Vector or Dir " + sPart ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
Vector3d vtDelta = ptPos - ptBase ;
|
|
Vector3d vtDeltaPerp = vtDelta - ( vtDelta * vtDirN) * vtDirN ;
|
|
if ( ! vtDeltaPerp.IsSmall()) {
|
|
if ( vtDeltaPerp.Len() > m_dAxisMaxAdjust && ! bAdjustAux) {
|
|
string sOut = " Wrong Axis Base move = (" + ToString( vtDeltaPerp) + ")" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
else {
|
|
string sOut = " Move = (" + ToString( vtDelta) + ")" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
m_pGeomDB->TranslateGlob( nId, vtDelta) ;
|
|
}
|
|
}
|
|
}
|
|
// se richiesto, muovo la geometria ausiliaria
|
|
if ( bAdjustAux) {
|
|
Vector3d vtDelta = ptPos - ptBase ;
|
|
int nIdAux = m_pGeomDB->GetFirstInGroup( nLay) ;
|
|
while ( nIdAux != GDB_ID_NULL) {
|
|
if ( nIdAux != nId)
|
|
m_pGeomDB->TranslateGlob( nIdAux, vtDelta) ;
|
|
nIdAux = m_pGeomDB->GetNext( nIdAux) ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::ModifyMachineAxisStroke( const string& sName, const STROKE& Stroke)
|
|
{
|
|
// controllo GeomDB
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// recupero il gruppo dell'asse
|
|
int nAxGrp = GetGroup( sName) ;
|
|
// recupero il relativo gestore
|
|
Axis* pAx = GetAxis( nAxGrp) ;
|
|
if ( pAx == nullptr)
|
|
return false ;
|
|
// eseguo la modifica
|
|
return pAx->Modify( Stroke) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::ModifyMachineAxisHome( const string& sName, double dHome)
|
|
{
|
|
// controllo GeomDB
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// recupero il gruppo dell'asse
|
|
int nAxGrp = GetGroup( sName) ;
|
|
// recupero il relativo gestore
|
|
Axis* pAx = GetAxis( nAxGrp) ;
|
|
if ( pAx == nullptr)
|
|
return false ;
|
|
// eseguo la modifica
|
|
return pAx->Modify( dHome) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadMachineStdHead( const string& sName, const string& sParent, const std::string& sHSet,
|
|
const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
|
|
double dRot1W, const STROKE& Rot2Stroke, int nSolCh,
|
|
const string& sGeo, const STRVECTOR& vsAux)
|
|
{
|
|
// recupero pezzo e layer della geometria originale dell'asse
|
|
string sPart, sLay ;
|
|
Split( sGeo, "/", true, sPart, sLay) ;
|
|
// cerco il gruppo nella geometria originale
|
|
int nPart = m_pGeomDB->GetFirstNameInGroup( m_nTempGroupId, sPart) ;
|
|
int nLay = m_pGeomDB->GetFirstNameInGroup( nPart, sLay) ;
|
|
if ( nLay == GDB_ID_NULL)
|
|
return false ;
|
|
// cerco il gruppo padre per spostarvelo
|
|
int nParentId = GetGroup( sParent) ;
|
|
if ( nParentId == GDB_ID_NULL ||
|
|
! m_pGeomDB->RelocateGlob( nLay, nParentId, GDB_LAST_SON))
|
|
return false ;
|
|
// sistemo lo stato di visualizzazione
|
|
bool bShow = ( sHSet == sName) ;
|
|
m_pGeomDB->SetStatus( nLay, ( bShow ? GDB_ST_ON : GDB_ST_OFF)) ;
|
|
// gli assegno il nome
|
|
m_pGeomDB->SetName( nLay, sName) ;
|
|
// sistemo la geometria ausiliaria
|
|
if ( ! AdjustAuxGeometry( vsAux, nLay))
|
|
return false ;
|
|
// installo e inizializzo il gestore della testa
|
|
Head* pHead = new(nothrow) Head ;
|
|
if ( pHead == nullptr)
|
|
return false ;
|
|
pHead->Set( sName, MCH_HT_STD, sHSet, vtADir, dRot1W, Rot2Stroke, nSolCh) ;
|
|
m_pGeomDB->SetUserObj( nLay, pHead) ;
|
|
// aggiorno la testa capostipite
|
|
if ( ! AddHeadToSet( sHSet, sName))
|
|
return false ;
|
|
// sistemo il riferimento dell'uscita rispetto alla direzione ausiliaria
|
|
MUEXITVECTOR vMuExit ;
|
|
vMuExit.emplace_back( ptPos, vtTDir) ;
|
|
if ( ! AdjustExitFrames( nLay, vMuExit, vtADir))
|
|
return false ;
|
|
// trasformazione del riferimento di uscita in gruppo di uscita
|
|
if ( ! CreateExitGroups( nLay, vMuExit))
|
|
return false ;
|
|
// lo inserisco nel dizionario dei gruppi della macchina
|
|
return m_mapGroups.emplace( sName, nLay).second ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadMachineMultiHead( const string& sName, const string& sParent, const std::string& sHSet,
|
|
const MUEXITVECTOR& vMuExit, const Vector3d& vtADir,
|
|
double dRot1W, const STROKE& Rot2Stroke, int nSolCh,
|
|
const string& sGeo, const STRVECTOR& vsAux)
|
|
{
|
|
// recupero pezzo e layer della geometria originale dell'asse
|
|
string sPart, sLay ;
|
|
Split( sGeo, "/", true, sPart, sLay) ;
|
|
// cerco il gruppo nella geometria originale
|
|
int nPart = m_pGeomDB->GetFirstNameInGroup( m_nTempGroupId, sPart) ;
|
|
int nLay = m_pGeomDB->GetFirstNameInGroup( nPart, sLay) ;
|
|
if ( nLay == GDB_ID_NULL)
|
|
return false ;
|
|
// cerco il gruppo padre per spostarvelo
|
|
int nParentId = GetGroup( sParent) ;
|
|
if ( nParentId == GDB_ID_NULL ||
|
|
! m_pGeomDB->RelocateGlob( nLay, nParentId, GDB_LAST_SON))
|
|
return false ;
|
|
// sistemo lo stato di visualizzazione
|
|
bool bShow = ( sHSet == sName) ;
|
|
m_pGeomDB->SetStatus( nLay, ( bShow ? GDB_ST_ON : GDB_ST_OFF)) ;
|
|
// gli assegno il nome
|
|
m_pGeomDB->SetName( nLay, sName) ;
|
|
// sistemo la geometria ausiliaria
|
|
if ( ! AdjustAuxGeometry( vsAux, nLay))
|
|
return false ;
|
|
// installo e inizializzo il gestore della testa
|
|
Head* pHead = new(nothrow) Head ;
|
|
if ( pHead == nullptr)
|
|
return false ;
|
|
pHead->Set( sName, MCH_HT_MULTI, sHSet, vtADir, dRot1W, Rot2Stroke, nSolCh) ;
|
|
m_pGeomDB->SetUserObj( nLay, pHead) ;
|
|
// aggiorno la testa capostipite
|
|
if ( ! AddHeadToSet( sHSet, sName))
|
|
return false ;
|
|
// sistemo i riferimenti delle uscite rispetto alla direzione ausiliaria
|
|
if ( ! AdjustExitFrames( nLay, vMuExit, vtADir))
|
|
return false ;
|
|
// trasformazione dei riferimenti di uscita in gruppi di uscita
|
|
if ( ! CreateExitGroups( nLay, vMuExit))
|
|
return false ;
|
|
// lo inserisco nel dizionario dei gruppi della macchina
|
|
return m_mapGroups.emplace( sName, nLay).second ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadMachineSpecialHead( const string& sName, const string& sParent, const std::string& sHSet,
|
|
const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
|
|
double dRot1W, const STROKE& Rot2Stroke, int nSolCh,
|
|
const string& sGeo, const STRVECTOR& vsAux)
|
|
{
|
|
// recupero pezzo e layer della geometria originale della testa
|
|
string sPart, sLay ;
|
|
Split( sGeo, "/", true, sPart, sLay) ;
|
|
// cerco il gruppo nella geometria originale
|
|
int nPart = m_pGeomDB->GetFirstNameInGroup( m_nTempGroupId, sPart) ;
|
|
int nLay = m_pGeomDB->GetFirstNameInGroup( nPart, sLay) ;
|
|
if ( nLay == GDB_ID_NULL)
|
|
return false ;
|
|
// cerco il gruppo padre per spostarvelo
|
|
int nParentId = GetGroup( sParent) ;
|
|
if ( nParentId == GDB_ID_NULL ||
|
|
! m_pGeomDB->RelocateGlob( nLay, nParentId, GDB_LAST_SON))
|
|
return false ;
|
|
// sistemo lo stato di visualizzazione
|
|
bool bShow = ( sHSet == sName) ;
|
|
m_pGeomDB->SetStatus( nLay, ( bShow ? GDB_ST_ON : GDB_ST_OFF)) ;
|
|
// gli assegno il nome
|
|
m_pGeomDB->SetName( nLay, sName) ;
|
|
// sistemo la geometria ausiliaria
|
|
if ( ! AdjustAuxGeometry( vsAux, nLay))
|
|
return false ;
|
|
// installo e inizializzo il gestore della testa
|
|
Head* pHead = new(nothrow) Head ;
|
|
if ( pHead == nullptr)
|
|
return false ;
|
|
pHead->Set( sName, MCH_HT_SPECIAL, sHSet, vtADir, dRot1W, Rot2Stroke, nSolCh) ;
|
|
m_pGeomDB->SetUserObj( nLay, pHead) ;
|
|
// aggiorno la testa capostipite
|
|
if ( ! AddHeadToSet( sHSet, sName))
|
|
return false ;
|
|
// sistemo il riferimento dell'uscita rispetto alla direzione ausiliaria
|
|
MUEXITVECTOR vMuExit ;
|
|
vMuExit.emplace_back( ptPos, vtTDir) ;
|
|
if ( ! AdjustExitFrames( nLay, vMuExit, vtADir))
|
|
return false ;
|
|
// trasformazione del riferimento di uscita in gruppo di uscita
|
|
if ( ! CreateExitGroups( nLay, vMuExit))
|
|
return false ;
|
|
// lo inserisco nel dizionario dei gruppi della macchina
|
|
return m_mapGroups.emplace( sName, nLay).second ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Machine::GetGroup( const string& sGroup) const
|
|
{
|
|
STRINT_UMAP::const_iterator Iter = m_mapGroups.find( sGroup) ;
|
|
return (( Iter != m_mapGroups.end()) ? Iter->second : GDB_ID_NULL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::IsBaseGroup( int nGroup) const
|
|
{
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// deve essere nel primo gruppo della macchina
|
|
return ( m_pGeomDB->GetParentId( nGroup) == m_nGroupId) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Table*
|
|
Machine::GetTable( int nGroup) const
|
|
{
|
|
return ( dynamic_cast<Table*>( m_pGeomDB->GetUserObj( nGroup))) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Axis*
|
|
Machine::GetAxis( int nGroup) const
|
|
{
|
|
return ( dynamic_cast<Axis*>( m_pGeomDB->GetUserObj( nGroup))) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::IsLinearAxisGroup( int nGroup) const
|
|
{
|
|
Axis* pAx = GetAxis( nGroup) ;
|
|
return ( pAx != nullptr && pAx->GetType() == MCH_AT_LINEAR) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::IsRotaryAxisGroup( int nGroup) const
|
|
{
|
|
Axis* pAx = GetAxis( nGroup) ;
|
|
return ( pAx != nullptr && pAx->GetType() == MCH_AT_ROTARY) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Head*
|
|
Machine::GetHead( int nGroup) const
|
|
{
|
|
return ( dynamic_cast<Head*>( m_pGeomDB->GetUserObj( nGroup))) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Exit*
|
|
Machine::GetExit( int nGroup) const
|
|
{
|
|
return ( dynamic_cast<Exit*>( m_pGeomDB->GetUserObj( nGroup))) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::AddHeadToSet( const string& sHSet, const string& sName)
|
|
{
|
|
// se il capo-insieme coincide con la testa, non devo fare alcunchè
|
|
if ( sHSet == sName)
|
|
return true ;
|
|
// recupero la testa capo-insieme
|
|
Head* pHead = GetHead( GetGroup( sHSet)) ;
|
|
if ( pHead == nullptr)
|
|
return false ;
|
|
// aggiungo questa testa all'insieme
|
|
return pHead->AddHeadToHSet( sName) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const STRVECTOR&
|
|
Machine::GetHSet( const string& sHead) const
|
|
{
|
|
// vettore di stringhe vuoto, da restituire in caso di errore
|
|
static const STRVECTOR vsNull ;
|
|
// recupero la testa
|
|
Head* pHead = GetHead( GetGroup( sHead)) ;
|
|
if ( pHead == nullptr)
|
|
return vsNull ;
|
|
// recupero l'insieme di teste a cui appartiene
|
|
const STRVECTOR& vsTmp = pHead->GetHSet() ;
|
|
if ( vsTmp.empty())
|
|
return vsNull ;
|
|
// se il primo membro coincide con la testa, allora è già l'insieme di teste
|
|
if ( vsTmp[0] == sHead)
|
|
return vsTmp ;
|
|
// altrimenti cerco l'insieme della prima testa
|
|
return GetHSet( vsTmp[0]) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::EnableHeadInSet( const string& sHead)
|
|
{
|
|
// recupero l'insieme di teste
|
|
const STRVECTOR& vsHSet = GetHSet( sHead) ;
|
|
if ( vsHSet.empty())
|
|
return false ;
|
|
// spengo tutte le teste tranne questa
|
|
for ( size_t i = 0 ; i < vsHSet.size() ; ++ i) {
|
|
int nH = GetGroup( vsHSet[i]) ;
|
|
bool bShow = ( vsHSet[i] == sHead) ;
|
|
m_pGeomDB->SetStatus( nH, ( bShow ? GDB_ST_ON : GDB_ST_OFF)) ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::AdjustExitFrames( int nLay, const MUEXITVECTOR& vMuExit, const Vector3d& vtADir)
|
|
{
|
|
// se il versore ausiliario non è definito, non sono necessari controlli
|
|
if ( vtADir.IsSmall())
|
|
return true ;
|
|
// riferimento globale del gruppo testa
|
|
Frame3d frHead ;
|
|
m_pGeomDB->GetGroupGlobFrame( nLay, frHead) ;
|
|
// porto il vettore ausiliario nel riferimento testa
|
|
Vector3d vtAuxL = vtADir ;
|
|
vtAuxL.ToLoc( frHead) ;
|
|
// ciclo sulle uscite
|
|
for ( int i = 0 ; i < int( vMuExit.size()) ; ++ i) {
|
|
string sName = MCH_EXIT + ToString( i + 1) ;
|
|
// se trovo riferimento per uscita, lo verifico
|
|
int nT = m_pGeomDB->GetFirstNameInGroup( nLay, sName) ;
|
|
if ( nT != GDB_ID_NULL && m_pGeomDB->GetGeoType( nT) == GEO_FRAME3D) {
|
|
// recupero frame
|
|
IGeoFrame3d* pGF = GetGeoFrame3d( m_pGeomDB->GetGeoObj( nT)) ;
|
|
Frame3d frFrame = pGF->GetFrame() ;
|
|
// determino rotazione attorno a RifAxZ per massimo allineamento RifAxX con direzione ausiliaria
|
|
bool bDet ;
|
|
double dAngRotDeg ;
|
|
if ( frFrame.VersX().GetRotation( vtAuxL, frFrame.VersZ(), dAngRotDeg, bDet) && bDet) {
|
|
if ( abs( dAngRotDeg) > EPS_ANG_SMALL) {
|
|
frFrame.Rotate( frFrame.Orig(), frFrame.VersZ(), dAngRotDeg) ;
|
|
pGF->Set( frFrame) ;
|
|
}
|
|
}
|
|
else {
|
|
string sOut = " Exit " + sName + " with frame not adjustable for AuxDir" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
}
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::CreateExitGroups( int nLay, const MUEXITVECTOR& vMuExit)
|
|
{
|
|
// riferimento globale del gruppo testa
|
|
Frame3d frHead ;
|
|
m_pGeomDB->GetGroupGlobFrame( nLay, frHead) ;
|
|
// ciclo sulle uscite
|
|
for ( int i = 0 ; i < int( vMuExit.size()) ; ++ i) {
|
|
string sName = MCH_EXIT + ToString( i + 1) ;
|
|
// se trovo riferimento per uscita, lo sostituisco con gruppo equivalente
|
|
int nT = m_pGeomDB->GetFirstNameInGroup( nLay, sName) ;
|
|
if ( nT != GDB_ID_NULL && m_pGeomDB->GetGeoType( nT) == GEO_FRAME3D) {
|
|
// recupero frame
|
|
Frame3d frFrame = GetGeoFrame3d( m_pGeomDB->GetGeoObj( nT))->GetFrame() ;
|
|
// verifico dati frame rispetto ad uscita (in globale)
|
|
Point3d ptPos = frFrame.Orig() ;
|
|
ptPos.ToGlob( frHead) ;
|
|
Vector3d vtTDir = frFrame.VersZ() ;
|
|
vtTDir.ToGlob( frHead) ;
|
|
vtTDir.Normalize() ;
|
|
Vector3d vtDelta = vMuExit[i].ptPos - ptPos ;
|
|
if ( ! vtDelta.IsSmall()) {
|
|
if ( vtDelta.Len() > m_dExitMaxAdjust) {
|
|
string sOut = " Wrong Exit Position " + sName + " move = (" + ToString( vtDelta) +")" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
else {
|
|
string sOut = " Exit " + sName + " move = (" + ToString( vtDelta) +")" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
vtDelta.ToLoc( frHead) ;
|
|
frFrame.Translate( vtDelta) ;
|
|
GetGeoFrame3d( m_pGeomDB->GetGeoObj( nT))->Set( frFrame) ;
|
|
}
|
|
}
|
|
Vector3d vtDirN = vMuExit[i].vtTDir ;
|
|
if ( ! vtDirN.Normalize() || ! AreSameVectorApprox( vtTDir, vtDirN)) {
|
|
string sOut = " Wrong Exit Vector " + sName ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
// inserisco gruppo con riferimento del frame
|
|
int nGT = m_pGeomDB->InsertGroup( GDB_ID_NULL, nT, GDB_BEFORE, frFrame) ;
|
|
if ( nGT == GDB_ID_NULL) {
|
|
string sOut = " Error inserting group " + sName ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
// cambio nome al riferimento e lo nascondo
|
|
m_pGeomDB->SetName( nT, "_" + sName) ;
|
|
m_pGeomDB->SetStatus( nT, GDB_ST_OFF) ;
|
|
// assegno nome al gruppo
|
|
m_pGeomDB->SetName( nGT, sName) ;
|
|
// installo e inizializzo il gestore dell'uscita
|
|
Exit* pExit = new(nothrow) Exit ;
|
|
if ( pExit == nullptr)
|
|
return false ;
|
|
pExit->Set( sName, vMuExit[i].ptPos, vMuExit[i].vtTDir) ;
|
|
m_pGeomDB->SetUserObj( nGT, pExit) ;
|
|
}
|
|
else {
|
|
string sOut = " Error finding frame " + sName ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::SetLook( int nFlag)
|
|
{
|
|
// verifico DB geometrico
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
|
|
// recupero l'identificativo del gruppo di base della macchina
|
|
int nMBaseId = m_pGeomDB->GetFirstInGroup( GetMachineId()) ;
|
|
|
|
// recupero la tavola corrente
|
|
int nTabId = GetCurrTable() ;
|
|
if ( nTabId == GDB_ID_NULL)
|
|
return false ;
|
|
// nascondo o visualizzo i fratelli e tutti i fratelli degli ascendenti della tavola
|
|
bool bTabOnly = ( nFlag != MCH_LOOK_ALL) ;
|
|
int nTabCurrId = nTabId ;
|
|
int nParentId = m_pGeomDB->GetParentId( nTabCurrId) ;
|
|
while ( nParentId != GDB_ID_NULL && nParentId != nMBaseId) {
|
|
int nId = m_pGeomDB->GetFirstInGroup( nParentId) ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
if ( nId != nTabCurrId)
|
|
m_pGeomDB->SetStatus( nId, ( bTabOnly ? GDB_ST_OFF : GDB_ST_ON)) ;
|
|
nId = m_pGeomDB->GetNext( nId) ;
|
|
}
|
|
nTabCurrId = nParentId ;
|
|
nParentId = m_pGeomDB->GetParentId( nParentId) ;
|
|
}
|
|
|
|
// recupero l'utensile e l'uscita correnti (per gestire casi senza utensile)
|
|
int nToolId = GetCurrTool() ;
|
|
int nExitId = m_nCalcExitId ;
|
|
// nascondo o visualizzo i fratelli e tutti i fratelli degli ascendenti
|
|
bool bToolOnly = ( nFlag > MCH_LOOK_TAB && nFlag < MCH_LOOK_ALL) ;
|
|
int nToolCurrId = ( nToolId != GDB_ID_NULL ? nToolId : nExitId) ;
|
|
nParentId = m_pGeomDB->GetParentId( nToolCurrId) ;
|
|
while ( nParentId != GDB_ID_NULL && nParentId != nMBaseId) {
|
|
bool bHide = bToolOnly ;
|
|
if ( nFlag == MCH_LOOK_TAB_HEAD ||
|
|
( nFlag == MCH_LOOK_TAB_TOOL && nToolId == GDB_ID_NULL)) {
|
|
if ( IsHeadGroup( nParentId) || IsRotaryAxisGroup( nParentId))
|
|
bHide = false ;
|
|
}
|
|
int nId = m_pGeomDB->GetFirstInGroup( nParentId) ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
if ( nId != nToolCurrId)
|
|
m_pGeomDB->SetStatus( nId, ( bHide ? GDB_ST_OFF : GDB_ST_ON)) ;
|
|
else
|
|
m_pGeomDB->SetStatus( nId, GDB_ST_ON) ;
|
|
nId = m_pGeomDB->GetNext( nId) ;
|
|
}
|
|
nToolCurrId = nParentId ;
|
|
nParentId = m_pGeomDB->GetParentId( nParentId) ;
|
|
}
|
|
|
|
// sistemo gli oggetti del gruppo di base
|
|
int nId = m_pGeomDB->GetFirstInGroup( nMBaseId) ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
if ( nId != nTabCurrId && nId != nToolCurrId)
|
|
m_pGeomDB->SetStatus( nId, ( nFlag != MCH_LOOK_ALL ? GDB_ST_OFF : GDB_ST_ON)) ;
|
|
else if ( nId == nTabCurrId)
|
|
m_pGeomDB->SetStatus( nId, GDB_ST_ON) ;
|
|
else
|
|
m_pGeomDB->SetStatus( nId, ( nFlag == MCH_LOOK_TAB ? GDB_ST_OFF : GDB_ST_ON)) ;
|
|
nId = m_pGeomDB->GetNext( nId) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LinkRawPartToGroup( int nRawPartId, const std::string& sGroupName)
|
|
{
|
|
// verifico DB geometrico e gestore lavorazioni
|
|
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
|
|
return false ;
|
|
// recupero l'identificativo del gruppo di base dei grezzi
|
|
int nRawGrpId = m_pMchMgr->GetCurrRawGroupId() ;
|
|
if ( nRawGrpId == GDB_ID_NULL)
|
|
return false ;
|
|
// verifico che il grezzo appartenga a questo gruppo
|
|
if ( m_pGeomDB->GetParentId( nRawPartId) != nRawGrpId)
|
|
return false ;
|
|
// recupero il gruppo di macchina indicato
|
|
int nGrpId = GetGroup( sGroupName) ;
|
|
if ( nGrpId == GDB_ID_NULL)
|
|
return false ;
|
|
// aggancio il grezzo al gruppo
|
|
if ( ! m_pGeomDB->RelocateGlob( nRawPartId, nGrpId))
|
|
return false ;
|
|
// inserisco il grezzo nell'elenco dei linkati
|
|
m_vLinkedRawParts.push_back( nRawPartId) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::IsLinkedRawPart( int nRawId) const
|
|
{
|
|
return ( find( m_vLinkedRawParts.begin(), m_vLinkedRawParts.end(), nRawId) != m_vLinkedRawParts.end()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::UnlinkRawPartFromGroup( int nRawPartId)
|
|
{
|
|
// verifico DB geometrico e gestore lavorazioni
|
|
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
|
|
return false ;
|
|
// recupero il gruppo dei grezzi dalla macchina
|
|
int nRawGrpId = m_pMchMgr->GetCurrRawGroupId() ;
|
|
if ( nRawGrpId == GDB_ID_NULL)
|
|
return false ;
|
|
// verifico che il grezzo indicato sia nell'elenco dei linkati
|
|
auto iIter = find( m_vLinkedRawParts.begin(), m_vLinkedRawParts.end(), nRawPartId) ;
|
|
if ( iIter == m_vLinkedRawParts.end())
|
|
return false ;
|
|
// riporto il grezzo nel gruppo dei grezzi (se appartiene alla prima fase in testa)
|
|
int nInsPos = ( m_pMchMgr->VerifyRawPartPhase( nRawPartId, 1) ? GDB_FIRST_SON : GDB_LAST_SON) ;
|
|
if ( ! m_pGeomDB->RelocateGlob( nRawPartId, nRawGrpId, nInsPos))
|
|
return false ;
|
|
// tolgo il grezzo dall'elenco dei linkati
|
|
m_vLinkedRawParts.erase( iIter) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::UnlinkAllRawPartsFromGroups( void)
|
|
{
|
|
while ( m_vLinkedRawParts.size() > 0) {
|
|
int nRawId = m_vLinkedRawParts.back() ;
|
|
if ( ! UnlinkRawPartFromGroup( nRawId))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LinkFixtureToGroup( int nFxtId, const std::string& sGroupName)
|
|
{
|
|
// verifico DB geometrico e gestore lavorazioni
|
|
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
|
|
return false ;
|
|
// recupero il gruppo delle fixtures nella macchinata corrente
|
|
int nFixtGrpId = m_pMchMgr->GetCurrFixtGroupId() ;
|
|
if ( nFixtGrpId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
// verifico che il bloccaggio appartenga a questo gruppo
|
|
if ( m_pGeomDB->GetParentId( nFxtId) != nFixtGrpId)
|
|
return false ;
|
|
// recupero il gruppo di macchina indicato
|
|
int nGrpId = GetGroup( sGroupName) ;
|
|
if ( nGrpId == GDB_ID_NULL)
|
|
return false ;
|
|
// aggancio il bloccaggio al gruppo
|
|
if ( ! m_pGeomDB->RelocateGlob( nFxtId, nGrpId))
|
|
return false ;
|
|
// inserisco il bloccaggio nell'elenco dei linkati
|
|
m_vLinkedFixtures.push_back( nFxtId) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::IsLinkedFixture( int nFxtId) const
|
|
{
|
|
return ( find( m_vLinkedFixtures.begin(), m_vLinkedFixtures.end(), nFxtId) != m_vLinkedFixtures.end()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::UnlinkFixtureFromGroup( int nFxtId)
|
|
{
|
|
// verifico DB geometrico e gestore lavorazioni
|
|
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
|
|
return false ;
|
|
// recupero il gruppo delle fixtures nella macchinata corrente
|
|
int nFixtGrpId = m_pMchMgr->GetCurrFixtGroupId() ;
|
|
if ( nFixtGrpId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
// verifico che il bloccaggio indicato sia nell'elenco dei linkati
|
|
auto iIter = find( m_vLinkedFixtures.begin(), m_vLinkedFixtures.end(), nFxtId) ;
|
|
if ( iIter == m_vLinkedFixtures.end())
|
|
return false ;
|
|
// riporto il bloccaggio nel gruppo delle fixtures
|
|
if ( ! m_pGeomDB->RelocateGlob( nFxtId, nFixtGrpId))
|
|
return false ;
|
|
// tolgo il bloccaggio dall'elenco dei linkati
|
|
m_vLinkedFixtures.erase( iIter) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::UnlinkAllFixturesFromGroups( void)
|
|
{
|
|
while ( m_vLinkedFixtures.size() > 0) {
|
|
int nFxtId = m_vLinkedFixtures.back() ;
|
|
if ( ! UnlinkFixtureFromGroup( nFxtId))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|