Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtMachKernel (Preview) :

Browse Source 
- aggiunta preview per lavorazioni in doppio.
This commit is contained in:
Riccardo Elitropi
2026-02-27 17:08:03 +01:00
parent 0748186661
commit 9005ea481f
2 changed files with 342 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Machining.cpp
+333 -159
View File
@@ -44,8 +44,11 @@ Machining::Machining( void)
{
m_nLookFlag = MCH_LOOK_TAB_HEAD ;
m_nPreviewHeadId = GDB_ID_NULL ;
m_nPreviewHeadIdDBL = GDB_ID_NULL ;
m_nPreviewToolTip = GDB_ID_NULL ;
m_nPreviewToolTipDBL = GDB_ID_NULL ;
m_vPreviewAxisIds = {} ;
m_vPreviewAxisIdsBBL = {} ;
}
//----------------------------------------------------------------------------
@@ -53,8 +56,11 @@ Machining::~Machining( void)
{
m_nLookFlag = MCH_LOOK_NONE ;
m_nPreviewHeadId = GDB_ID_NULL ;
m_nPreviewHeadIdDBL = GDB_ID_NULL ;
m_nPreviewToolTip = GDB_ID_NULL ;
m_nPreviewToolTipDBL = GDB_ID_NULL ;
m_vPreviewAxisIds.clear() ;
m_vPreviewAxisIdsBBL.clear() ;
}
//----------------------------------------------------------------------------
@@ -148,55 +154,53 @@ Machining::GetEndPoint( Point3d& ptEnd) const
//----------------------------------------------------------------------------
bool
Machining::UpdateToolView( int nLookFlag)
Machining::MyChangeToolPreviewShow( int nLookFlag, bool bDouble)
{
// verifico validità del Flag
if ( nLookFlag != MCH_LOOK_NONE && nLookFlag != MCH_LOOK_TAB_TOOL && nLookFlag != MCH_LOOK_TAB_HEAD)
return false ;
// se stesso Flag, non faccio nulla
if ( m_nLookFlag == nLookFlag)
return true ;
// aggiorno il flag
m_nLookFlag = nLookFlag ;
// se non esiste un gruppo di Preview, non faccio nulla
int nStId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
if ( nStId == GDB_ID_NULL)
return true ;
// se non esiste il gruppo di Preview, errore
int nCurrStdId = GDB_ID_NULL ;
int nCurrHeadId = GDB_ID_NULL ;
if ( ! bDouble) {
nCurrStdId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
if ( nCurrStdId == GDB_ID_NULL || m_nPreviewHeadId == GDB_ID_NULL)
return false ;
nCurrHeadId = m_nPreviewHeadId ;
}
else {
nCurrStdId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST_DBL) ;
if ( nCurrStdId == GDB_ID_NULL || m_nPreviewHeadIdDBL == GDB_ID_NULL)
return false ;
nCurrHeadId = m_nPreviewHeadIdDBL ;
}
// recupero la macchina corrente
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch == nullptr)
return false ;
// se non ho una testa corrente in Preview, non faccio nulla
if ( m_nPreviewHeadId == GDB_ID_NULL) {
RemoveToolPreview() ;
return false ;
}
// recupero l'identificativo del gruppo di base della macchina
int nMBaseId = m_pGeomDB->GetFirstInGroup( pMch->GetMachineId()) ;
// se non devo visualizzare nulla, allora spengo il gruppo "ST"
if ( m_nLookFlag == MCH_LOOK_NONE)
m_pGeomDB->SetStatus( nStId, GDB_ST_OFF) ;
if ( nLookFlag == MCH_LOOK_NONE)
m_pGeomDB->SetStatus( nCurrStdId, GDB_ST_OFF) ;
// altrimenti
else {
m_pGeomDB->SetStatus( nStId, GDB_ST_ON) ;
m_pGeomDB->SetStatus( nCurrStdId, GDB_ST_ON) ;
// contatori locali
const int MAX_ITER = 50 ;
bool bStop = false ;
int nIter = 0 ;
// se devo visualizzare solamente il gruppo della testa corrente
if ( m_nLookFlag == MCH_LOOK_TAB_TOOL) {
if ( nLookFlag == MCH_LOOK_TAB_TOOL) {
// la testa diventa visibile
m_pGeomDB->SetStatus( m_nPreviewHeadId, GDB_ST_ON) ;
m_pGeomDB->SetStatus( nCurrHeadId, GDB_ST_ON) ;
// tutti i gruppi che contengono la testa diventano visibili fino a "ST", l'unico loro
// figlio visibile deve essere quello che contiene la testa corrente
int nCurrId = m_nPreviewHeadId ;
int nCurrId = nCurrHeadId ;
while ( ! bStop && nIter < MAX_ITER) {
int nParentId = m_pGeomDB->GetParentId( nCurrId) ;
if ( nParentId == GDB_ID_NULL) {
@@ -212,7 +216,7 @@ Machining::UpdateToolView( int nLookFlag)
m_pGeomDB->SetStatus( nChildId, GDB_ST_OFF) ;
nChildId = m_pGeomDB->GetNextGroup( nChildId) ;
}
bStop = ( nParentId == nStId || nParentId == nMBaseId) ;
bStop = ( nParentId == nCurrStdId || nParentId == nMBaseId) ;
nCurrId = nParentId ;
++ nIter ;
}
@@ -220,7 +224,7 @@ Machining::UpdateToolView( int nLookFlag)
// se devo visualizzare tutta la gerarchia
else {
deque<int> dqHierarchy ;
dqHierarchy.push_front( nStId) ;
dqHierarchy.push_front( nCurrStdId) ;
while ( ! bStop && nIter < MAX_ITER) {
// recupero ed elimino dalla deque il primo Id memorizzato
int nCurrId = dqHierarchy.front() ;
@@ -232,7 +236,7 @@ Machining::UpdateToolView( int nLookFlag)
// rendo visibile tale Layer
m_pGeomDB->SetStatus( nCurrId, GDB_ST_ON) ;
// se il gruppo corrente è la testa, ho finito
bStop = ( nCurrId == m_nPreviewHeadId) ;
bStop = ( nCurrId == nCurrHeadId) ;
if ( ! bStop) {
// tutti i gruppi figli diventano visibili
int nChildId = m_pGeomDB->GetFirstInGroup( nCurrId) ;
@@ -258,35 +262,54 @@ Machining::UpdateToolView( int nLookFlag)
//----------------------------------------------------------------------------
bool
Machining::PrepareToolPreview()
Machining::ChangeToolPreviewShow( int nLookFlag)
{
// verifico validità gestori DB geometrico e CAM
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
// verifico validità del Flag
if ( nLookFlag != MCH_LOOK_NONE && nLookFlag != MCH_LOOK_TAB_TOOL && nLookFlag != MCH_LOOK_TAB_HEAD)
return false ;
// se stesso Flag, non faccio nulla
if ( m_nLookFlag == nLookFlag)
return true ;
// aggiorno il flag
m_nLookFlag = nLookFlag ;
// recupero il gruppo di Preview
int nStdId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
if ( nStdId != GDB_ID_NULL) {
if ( ! MyChangeToolPreviewShow( nLookFlag, false))
return false ;
}
// se lavorazione in doppio aggiorno anche la Preview della
int nStdDBLId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST_DBL) ;
if ( nStdDBLId != GDB_ID_NULL) {
if ( ! MyChangeToolPreviewShow( nLookFlag, true))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Machining::MyPrepareToolPreview( bool bDouble)
{
// recupero la macchina corrente
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch == nullptr)
return false ;
// se non esite il Gruppo di Preview, lo aggiungo
int nStId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
if ( nStId == GDB_ID_NULL) {
nStId = m_pGeomDB->AddGroup( GDB_ID_NULL, GetOwner(), Frame3d()) ;
if ( nStId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nStId, MCH_ST) ;
m_pGeomDB->SetLevel( nStId, GDB_LV_TEMP) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nStId) ;
// se necessario, imposto l'utensile corrente
string sCurrTool ; m_pMchMgr->GetCalcTool( sCurrTool) ;
const_cast<Machining*>( this)->UpdateToolData() ;
if ( ! EqualNoCase( sCurrTool, GetToolName())) {
if ( ! m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()))
string sTool, sHead ;
int nExitDBLId ;
if ( ! bDouble) {
sTool = GetToolName() ;
sHead = GetHeadName() ;
}
else {
if ( ! GetDoubleToolData( sTool, sHead, nExitDBLId))
return false ;
}
@@ -294,7 +317,6 @@ Machining::PrepareToolPreview()
int nMBaseId = m_pGeomDB->GetFirstInGroup( pMch->GetMachineId()) ;
// recupero l'identificativo della testa della lavorazione corrente e il set di teste associato
string sHead = GetHeadName() ;
int nHeadId = m_pMchMgr->GetHeadId( sHead) ;
const STRVECTOR& vSetHead = pMch->GetHSet( sHead) ;
INTVECTOR vSetHeadIds ; vSetHeadIds.reserve( ssize( vSetHead)) ;
@@ -305,7 +327,9 @@ Machining::PrepareToolPreview()
int nCurrTab = pMch->GetCurrTable() ;
// il gruppo iniziale di costruzione della gerarchia è "ST"
int nCurrHierarchyId = nStId ;
int nCurrHierarchyId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), ( ! bDouble ? MCH_ST : MCH_ST_DBL)) ;
if ( nCurrHierarchyId == GDB_ID_NULL)
return false ;
// Per prima cosa verifico se ci sono degli assi rotativi associati alla tavola, questi devono
// essere inseriti in ordine inverso all'interno del gruppo "ST" e il loro versore associato
@@ -334,12 +358,13 @@ Machining::PrepareToolPreview()
double dAxisPos = 0. ;
bOk = bOk && pMch->GetAxisPos( sName, dAxisPos) &&
m_pGeomDB->SetInfo( nNewTabRotAxisId, KEY_ROT_AXIS_VAL, dAxisPos) ;
if ( ! bOk) {
RemoveToolPreview() ;
if ( ! bOk)
return false ;
}
nCurrHierarchyId = nNewTabRotAxisId ;
m_vPreviewAxisIds.push_back( nNewTabRotAxisId) ;
if ( ! bDouble)
m_vPreviewAxisIds.push_back( nNewTabRotAxisId) ;
else
m_vPreviewAxisIdsBBL.push_back( nNewTabRotAxisId) ;
// aggiungo il versore invertito
int nChildId = m_pGeomDB->GetFirstInGroup( nParentId) ;
while ( nChildId != GDB_ID_NULL) {
@@ -350,11 +375,8 @@ Machining::PrepareToolPreview()
pGVInv->Mirror( pGV->GetBase(), pGV->GetVector()) ;
string sName ; m_pGeomDB->GetName( nChildId, sName) ;
int nNewGVId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nNewTabRotAxisId, Release( pGVInv)) ;
if ( nNewGVId == GDB_ID_NULL || ! m_pGeomDB->SetName( nNewGVId, sName) ||
! m_pGeomDB->SetStatus( nNewGVId, GDB_ST_OFF)) {
RemoveToolPreview() ;
if ( nNewGVId == GDB_ID_NULL || ! m_pGeomDB->SetName( nNewGVId, sName) || ! m_pGeomDB->SetStatus( nNewGVId, GDB_ST_OFF))
return false ;
}
break ;
}
}
@@ -411,10 +433,15 @@ Machining::PrepareToolPreview()
// se non c'è alcuna gerarchia, allora inserisco solo la testa corrente
if ( vHierarchyAxis.empty()) {
m_nPreviewHeadId = m_pGeomDB->CopyGlob( nHeadId, GDB_ID_NULL, nCurrHierarchyId) ;
if ( m_nPreviewHeadId == GDB_ID_NULL) {
RemoveToolPreview() ;
return false ;
if ( ! bDouble) {
m_nPreviewHeadId = m_pGeomDB->CopyGlob( nHeadId, GDB_ID_NULL, nCurrHierarchyId) ;
if ( m_nPreviewHeadId == GDB_ID_NULL)
return false ;
}
else {
m_nPreviewHeadIdDBL = m_pGeomDB->CopyGlob( nHeadId, GDB_ID_NULL, nCurrHierarchyId) ;
if ( m_nPreviewHeadIdDBL == GDB_ID_NULL)
return false ;
}
}
// se esiste una gerarchia, allora la ricreo l'albero
@@ -433,7 +460,10 @@ Machining::PrepareToolPreview()
// recupero il tipo di asse
bool bRotary = ( pMch->IsRotaryAxisGroup( nParentId)) ;
if ( bRotary) {
m_vPreviewAxisIds.push_back( nNewParentId) ;
if ( ! bDouble)
m_vPreviewAxisIds.push_back( nNewParentId) ;
else
m_vPreviewAxisIdsBBL.push_back( nNewParentId) ;
// memorizzo la sua posizione iniziale
double dAxisPos = 0. ;
bOk = bOk && pMch->GetAxisPos( sParentName, dAxisPos) &&
@@ -456,8 +486,14 @@ Machining::PrepareToolPreview()
else if ( m_pGeomDB->GetGdbType( nChildId) == GDB_TY_GROUP) {
// se gruppo testa lo inserisco a prescindere
if ( nChildId == nHeadId) {
m_nPreviewHeadId = m_pGeomDB->CopyGlob( nHeadId, GDB_ID_NULL, nNewParentId) ;
bOk = ( m_nPreviewHeadId == GDB_ID_NULL) ;
if ( ! bDouble) {
m_nPreviewHeadId = m_pGeomDB->CopyGlob( nHeadId, GDB_ID_NULL, nNewParentId) ;
bOk = ( m_nPreviewHeadId == GDB_ID_NULL) ;
}
else {
m_nPreviewHeadIdDBL = m_pGeomDB->CopyGlob( nHeadId, GDB_ID_NULL, nNewParentId) ;
bOk = ( m_nPreviewHeadIdDBL == GDB_ID_NULL) ;
}
}
else {
// se asse successivo nella catena cinematica, sarà il nuovo gruppo padre
@@ -489,11 +525,17 @@ Machining::PrepareToolPreview()
}
// recupero il punto Tip dell'utensile e lo inserisco dentro al gruppo testa corrente
int nExitGrpId = pMch->GetCurrExit() ;
int nExitGrpId = ( ! bDouble ? pMch->GetCurrExit() : pMch->GetExitId( sHead, nExitDBLId)) ;
bool bOk = ( nExitGrpId != GDB_ID_NULL) ;
string sExitGrpName ;
bOk = bOk && m_pGeomDB->GetName( nExitGrpId, sExitGrpName) ;
int nFrId = ( bOk ? m_pGeomDB->GetFirstNameInGroup( m_nPreviewHeadId, "_" + sExitGrpName) : GDB_ID_NULL) ;
int nFrId = GDB_ID_NULL ;
if ( bOk) {
if ( ! bDouble)
nFrId = m_pGeomDB->GetFirstNameInGroup( m_nPreviewHeadId, "_" + sExitGrpName) ;
else
nFrId = m_pGeomDB->GetFirstNameInGroup( m_nPreviewHeadIdDBL, "_" + sExitGrpName) ;
}
bOk = bOk && ( nFrId != GDB_ID_NULL) ;
const IGeoFrame3d* frExit = ( bOk ? GetGeoFrame3d( m_pGeomDB->GetGeoObj( nFrId)) : nullptr) ;
bOk = bOk && ( frExit != nullptr) ;
@@ -502,21 +544,92 @@ Machining::PrepareToolPreview()
if ( bOk) {
PtrOwner<IGeoPoint3d> ptGToolTip( CreateGeoPoint3d()) ;
bOk = ( ! IsNull( ptGToolTip) && ptGToolTip->Set( ptToolTip)) ;
m_nPreviewToolTip = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPreviewHeadId, Release( ptGToolTip)) ;
bOk = bOk && ( m_nPreviewToolTip != GDB_ID_NULL) ;
}
if ( ! bOk) {
RemoveToolPreview() ;
return false ;
if ( bOk) {
if ( ! bDouble) {
m_nPreviewToolTip = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPreviewHeadId, Release( ptGToolTip)) ;
bOk = bOk && ( m_nPreviewToolTip != GDB_ID_NULL) ;
}
else {
m_nPreviewToolTipDBL = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPreviewHeadIdDBL, Release( ptGToolTip)) ;
bOk = bOk && ( m_nPreviewToolTipDBL != GDB_ID_NULL) ;
}
}
}
// aggiorno la Preview a seconda della modalità
if ( ! UpdateToolView( MCH_LOOK_TAB_TOOL)) {
RemoveToolPreview() ;
return false ;
}
return bOk ;
}
return true ;
//----------------------------------------------------------------------------
bool
Machining::PrepareToolPreview()
{
// verifico validità gestori DB geometrico e CAM
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
return false ;
// recupero la macchina corrente
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch == nullptr)
return false ;
// se non esite il Gruppo di Preview, lo aggiungo
int nStId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
if ( nStId == GDB_ID_NULL) {
nStId = m_pGeomDB->AddGroup( GDB_ID_NULL, GetOwner(), Frame3d()) ;
if ( nStId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nStId, MCH_ST) ;
m_pGeomDB->SetLevel( nStId, GDB_LV_TEMP) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nStId) ;
// controllo se presente un gruppo di lavorazione in doppio
int nStdIdDBL = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST_DBL) ;
if ( nStdIdDBL == GDB_ID_NULL) {
// verifico se esiste la lavorazione in doppio associata
int nDBLId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_DBL) ;
if ( nDBLId != GDB_ID_NULL) {
nStdIdDBL = m_pGeomDB->AddGroup( GDB_ID_NULL, GetOwner(), Frame3d()) ;
if ( nDBLId == GDB_ID_NULL) {
RemoveToolPreview() ;
return false ;
}
}
m_pGeomDB->SetName( nStdIdDBL, MCH_ST_DBL) ;
m_pGeomDB->SetLevel( nStdIdDBL, GDB_LV_TEMP) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nStdIdDBL) ;
// preparo l'anteprima per il gruppo ST
bool bOk = true ;
if ( nStId != GDB_ID_NULL) {
// imposto l'utensile corrente per impostare il gruppo ST
string sTool ; m_pMchMgr->GetCalcTool( sTool) ;
const_cast<Machining*>( this)->UpdateToolData() ;
if ( ! EqualNoCase( sTool, GetToolName()))
bOk = ( m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr())) ;
// creo la preview
bOk = bOk && MyPrepareToolPreview( false) && MyChangeToolPreviewShow( MCH_LOOK_TAB_TOOL, false) ;
}
if ( bOk && nStdIdDBL != GDB_ID_NULL) {
// imposto l'utensile per la lavorazione in doppio
string sTool, sHead ; int nDblExit ;
bOk = ( GetDoubleToolData( sTool, sHead, nDblExit)) ;
if ( bOk) {
bool bOkToolSet = ( m_pMchMgr->SetCalcTool( sTool, sHead, nDblExit)) ;
bOk = bOkToolSet && MyPrepareToolPreview( true) && MyChangeToolPreviewShow( MCH_LOOK_TAB_TOOL, true) ;
if ( bOkToolSet)
bOk = ( m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr())) && bOk ;
}
}
if ( ! bOk)
RemoveToolPreview() ;
return bOk ;
}
//----------------------------------------------------------------------------
@@ -526,15 +639,20 @@ Machining::RemoveToolPreview( void)
// verifico validità gestore DB geometrico
if ( m_pGeomDB == nullptr)
return false ;
// recupero gruppo per anteprima utensile
// recupero i gruppi per l'anteprima utensile
int nStId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
// lo svuoto
int nStIdDBL = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST_DBL) ;
// li svuoto
m_pGeomDB->EmptyGroup( nStId) ;
m_pGeomDB->EmptyGroup( nStIdDBL) ;
// reset delle variabili membro
m_nPreviewHeadId = GDB_ID_NULL ;
m_nPreviewHeadIdDBL = GDB_ID_NULL ;
m_nPreviewToolTip = GDB_ID_NULL ;
m_nLookFlag = MCH_LOOK_NONE ;
m_nPreviewToolTipDBL = GDB_ID_NULL ;
m_vPreviewAxisIds.clear() ;
m_vPreviewAxisIdsBBL.clear() ;
m_nLookFlag = MCH_LOOK_NONE ;
return true ;
}
@@ -567,7 +685,7 @@ Machining::GetToolPreviewStepCount( void) const
-- nCount ;
nRiseId = m_pGeomDB->GetNextName( nRiseId, MCH_CL_RISE) ;
}
// tolgo le entit� HOME
// tolgo le entità HOME
int nHomeId = m_pGeomDB->GetFirstNameInGroup( nPxId, MCH_CL_HOME) ;
while ( nHomeId != GDB_ID_NULL) {
-- nCount ;
@@ -585,7 +703,7 @@ int
Machining::GetToolPreviewNext( int nEntId, int nParentId, int nStId) const
{
// recupero la successiva
int nNewId = (( nEntId != GDB_ID_NULL) ? m_pGeomDB->GetNext( nEntId) : m_pGeomDB->GetFirstInGroup( nParentId)) ;
int nNewId = ( ( nEntId != GDB_ID_NULL) ? m_pGeomDB->GetNext( nEntId) : m_pGeomDB->GetFirstInGroup( nParentId)) ;
int nNewParentId = nParentId ;
// ciclo nei gruppi successivi
do {
@@ -626,14 +744,14 @@ Machining::GetToolPreviewPrev( int nEntId, int nParentId, int nStId) /*const*/
{
if ( m_nLookFlag == MCH_LOOK_TAB_HEAD)
UpdateToolView( MCH_LOOK_TAB_TOOL) ;
ChangeToolPreviewShow( MCH_LOOK_TAB_TOOL) ;
else if ( m_nLookFlag == MCH_LOOK_TAB_TOOL)
UpdateToolView( MCH_LOOK_NONE) ;
ChangeToolPreviewShow( MCH_LOOK_NONE) ;
else
UpdateToolView( MCH_LOOK_TAB_HEAD) ;
ChangeToolPreviewShow( MCH_LOOK_TAB_HEAD) ;
// recupero la precedente
int nNewId = (( nEntId != GDB_ID_NULL) ? m_pGeomDB->GetPrev( nEntId) : m_pGeomDB->GetLastInGroup( nParentId)) ;
int nNewId = ( ( nEntId != GDB_ID_NULL) ? m_pGeomDB->GetPrev( nEntId) : m_pGeomDB->GetLastInGroup( nParentId)) ;
int nNewParentId = nParentId ;
// ciclo nei gruppi precedenti
do {
@@ -661,6 +779,110 @@ Machining::GetToolPreviewPrev( int nEntId, int nParentId, int nStId) /*const*/
return GDB_ID_NULL ;
}
//----------------------------------------------------------------------------
bool
Machining::MyToolPreview( int nEntId, bool bDouble)
{
// verifico validità gestori DB geometrico e CAM
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
return false ;
// recupero la macchina corrente
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch == nullptr)
return false ;
// verifico l'esistenza del gruppo di Preview
int nCurrStId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), ( ! bDouble ? MCH_ST : MCH_ST_DBL)) ;
if ( nCurrStId == GDB_ID_NULL)
return false ;
// recupero i dati dell'entità CamData corrrente
const CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
if ( pCamData == nullptr)
return false ;
Point3d ptEnd = pCamData->GetEndPoint() ;
AdjustEndPointForAxesCalc( pCamData, ptEnd) ;
// recupero gli assi e i loro valori per la posizione corrente
const DBLVECTOR& vAxVal = pCamData->GetAxesVal() ;
STRVECTOR vAxNames ;
if ( ! bDouble)
m_pMchMgr->GetAllCurrAxesNames( vAxNames) ;
else {
string sDBLTool, sDBLHead ; int nDBLExit ;
bool bOk = ( GetDoubleToolData( sDBLTool, sDBLHead, nDBLExit) && m_pMchMgr->SetCalcTool( sDBLTool, sDBLHead, nDBLExit)) ;
if ( bOk)
m_pMchMgr->GetAllCurrAxesNames( vAxNames) ;
m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()) ;
if ( ! bOk)
return false ;
}
if ( ssize( vAxVal) != ssize( vAxNames))
return GDB_ID_NULL ;
int nAxSize = ssize( vAxVal) ;
VPREVIEWAXISINFO vAxisInfo ; vAxisInfo.reserve( nAxSize) ;
for ( int i = 0 ; i < nAxSize ; ++ i) {
bool bLinear = false ;
pMch->GetAxisType( vAxNames[i], bLinear) ;
vAxisInfo.emplace_back( vAxNames[i], vAxVal[i], bLinear) ;
}
// scorro gli assi dentro al gruppo "ST" ( considero solo quelli rotativi)
INTVECTOR& vCurrPreviewAxisIds = ( ! bDouble ? m_vPreviewAxisIds : m_vPreviewAxisIdsBBL) ;
for ( auto Iter = vCurrPreviewAxisIds.begin() ; Iter != vCurrPreviewAxisIds.end() ; ++ Iter) {
// recupero l'Id dell'asse corrente
int nAxisId = *Iter ;
if ( nAxisId == GDB_ID_NULL)
return false ;
// recupero il nome di tale asse
string sAxisName ;
if ( ! m_pGeomDB->GetName( nAxisId, sAxisName))
return false ;
// recupero il valore corrente dell'asse
double dCurrAxisVal = 0. ;
m_pGeomDB->GetInfo( nAxisId, KEY_ROT_AXIS_VAL, dCurrAxisVal) ;
// recupero il valore dell'asse
bool bFound = false ;
double dAxisVal = 0 ;
for ( int i = 0 ; ! bFound && i < nAxSize ; ++ i) {
if ( ! vAxisInfo[i].bLinear && EqualNoCase( sAxisName, vAxisInfo[i].sName)) {
bFound = true ;
dAxisVal = vAxisInfo[i].dVal ;
}
}
if ( ! bFound)
return GDB_ID_NULL ;
// recupero il vettore dell'asse
int nV = m_pGeomDB->GetFirstNameInGroup( nAxisId, sAxisName) ;
const IGeoVector3d* pGV = GetGeoVector3d( m_pGeomDB->GetGeoObj( nV)) ;
if ( pGV == nullptr)
return GDB_ID_NULL ;
Point3d ptPos = pGV->GetBase() ;
Vector3d vtDir = pGV->GetVector() ;
vtDir.Normalize() ;
m_pGeomDB->RotateGroup( nAxisId, ptPos, vtDir, ( dAxisVal - dCurrAxisVal)) ;
m_pGeomDB->SetInfo( nAxisId, KEY_ROT_AXIS_VAL, dAxisVal) ;
}
// recupero la posizione del tip dell'utensile per movimento assi lineari
int nCurrPreviewToolTipId = ( ( ! bDouble ? m_nPreviewToolTip : m_nPreviewToolTipDBL)) ;
if ( nCurrPreviewToolTipId == GDB_ID_NULL)
return GDB_ID_NULL ;
const IGeoPoint3d* pToolTip = GetGeoPoint3d( m_pGeomDB->GetGeoObj( nCurrPreviewToolTipId)) ;
if ( pToolTip == nullptr)
return GDB_ID_NULL ;
Point3d ptToolTipLoc = pToolTip->GetPoint() ;
Frame3d frGlob ; m_pGeomDB->GetGlobFrame( nCurrPreviewToolTipId, frGlob) ;
Point3d ptToolTipGlob = GetToGlob( ptToolTipLoc, frGlob) ;
Vector3d vtMoveGlob = ptEnd - ptToolTipGlob ;
m_pGeomDB->GetGroupGlobFrame( nCurrStId, frGlob) ;
Vector3d vtMoveLoc = GetToLoc( vtMoveGlob, frGlob) ;
m_pGeomDB->TranslateGroup( nCurrStId, vtMoveLoc) ;
return true ;
}
//----------------------------------------------------------------------------
int
Machining::ToolPreview( int nEntId, int nStep) /*const*/
@@ -668,15 +890,23 @@ Machining::ToolPreview( int nEntId, int nStep) /*const*/
// verifico validità gestori DB geometrico e CAM
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
return GDB_ID_NULL ;
// recupero la testa nel gruppo per anteprima utensile
// recupero il gruppo per anteprima utensile
int nStId = m_pGeomDB->GetFirstGroupInGroup( m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST)) ;
if ( nStId == GDB_ID_NULL)
return GDB_ID_NULL ;
m_pGeomDB->SetStatus( nStId, GDB_ST_OFF) ;
// se esiste il gruppo per la lavorazione in doppio, lo recupero
int nStIdDBL = m_pGeomDB->GetFirstGroupInGroup( m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST_DBL)) ;
if ( nStIdDBL != GDB_ID_NULL)
m_pGeomDB->SetStatus( nStIdDBL, GDB_ST_OFF) ;
// recupero la macchina corrente
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch == nullptr)
return false ;
// recupero il gruppo per geometria di lavorazione (Cutter Location)
int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
if ( nClId == GDB_ID_NULL)
@@ -729,82 +959,26 @@ Machining::ToolPreview( int nEntId, int nStep) /*const*/
else
nEntId = GDB_ID_NULL ;
}
// se esiste il gruppo genitore, visualizzo testa preview
if ( nParentId != GDB_ID_NULL)
// se esiste il gruppo genitore, visualizzo preview
if ( nParentId != GDB_ID_NULL) {
m_pGeomDB->SetStatus( nStId, GDB_ST_ON) ;
// recupero i dati dell'entità CamData corrrente
const CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
if ( pCamData == nullptr)
return GDB_ID_NULL ;
Point3d ptEnd = pCamData->GetEndPoint() ;
AdjustEndPointForAxesCalc( pCamData, ptEnd) ;
Vector3d vtTool = pCamData->GetToolDir() ;
Vector3d vtBAux = pCamData->GetBackAuxDir() ;
// recupero gli assi e i loro valori per la posizione corrente
const DBLVECTOR& vAxVal = pCamData->GetAxesVal() ;
STRVECTOR vAxNames ; m_pMchMgr->GetAllCurrAxesNames( vAxNames) ;
if ( ssize( vAxVal) != ssize( vAxNames))
return GDB_ID_NULL ;
int nAxSize = ssize( vAxVal) ;
VPREVIEWAXISINFO vAxisInfo ; vAxisInfo.reserve( nAxSize) ;
for ( int i = 0 ; i < nAxSize ; ++ i) {
bool bLinear = false ;
pMch->GetAxisType( vAxNames[i], bLinear) ;
vAxisInfo.emplace_back( vAxNames[i], vAxVal[i], bLinear) ;
if ( nStIdDBL != GDB_ID_NULL)
m_pGeomDB->SetStatus( nStIdDBL, GDB_ST_ON) ;
}
// scorro gli assi dentro al gruppo "ST" ( vi sono solo quelli rotativi)
for ( auto Iter = m_vPreviewAxisIds.begin() ; Iter != m_vPreviewAxisIds.end() ; ++ Iter) {
// recupero l'Id dell'asse corrente
int nAxisId = *Iter ;
if ( nAxisId == GDB_ID_NULL)
return GDB_ID_NULL ;
// recupero il nome di tale asse
string sAxisName ;
if ( ! m_pGeomDB->GetName( nAxisId, sAxisName))
return GDB_ID_NULL ;
// recupero il valore corrente dell'asse
double dCurrAxisVal = 0. ;
m_pGeomDB->GetInfo( nAxisId, KEY_ROT_AXIS_VAL, dCurrAxisVal) ;
// recupero il valore dell'asse
bool bFound = false ;
double dAxisVal = 0 ;
for ( int i = 0 ; ! bFound && i < nAxSize ; ++ i) {
if ( ! vAxisInfo[i].bLinear && EqualNoCase( sAxisName, vAxisInfo[i].sName)) {
bFound = true ;
dAxisVal = vAxisInfo[i].dVal ;
}
// aggiorno la preview dell'utensile
if ( ! MyToolPreview( nEntId, false))
return GDB_ID_NULL ;
// se lavorazione in doppio, aggiorno la sua preview
if ( nStIdDBL != GDB_ID_NULL) {
// recupero l'entità associata
int nEntDBLId = GDB_ID_NULL ;
if ( m_pGeomDB->GetInfo( nEntId, KEY_CL_DOUBLE, nEntDBLId) && nEntDBLId != GDB_ID_NULL) {
if ( ! MyToolPreview( nEntDBLId, true))
return GDB_ID_NULL ;
}
if ( ! bFound)
return GDB_ID_NULL ;
// recupero il vettore dell'asse
int nV = m_pGeomDB->GetFirstNameInGroup( nAxisId, sAxisName) ;
const IGeoVector3d* pGV = GetGeoVector3d( m_pGeomDB->GetGeoObj( nV)) ;
if ( pGV == nullptr)
return GDB_ID_NULL ;
Point3d ptPos = pGV->GetBase() ;
Vector3d vtDir = pGV->GetVector() ;
vtDir.Normalize() ;
m_pGeomDB->RotateGroup( nAxisId, ptPos, vtDir, ( dAxisVal - dCurrAxisVal)) ;
m_pGeomDB->SetInfo( nAxisId, KEY_ROT_AXIS_VAL, dAxisVal) ;
}
// recupero la posizione del tip dell'utensile per movimento assi lineari
if ( m_nPreviewToolTip == GDB_ID_NULL)
return GDB_ID_NULL ;
const IGeoPoint3d* pToolTip = GetGeoPoint3d( m_pGeomDB->GetGeoObj( m_nPreviewToolTip)) ;
if ( pToolTip == nullptr)
return GDB_ID_NULL ;
Point3d ptToolTipLoc = pToolTip->GetPoint() ;
Frame3d frGlob ; m_pGeomDB->GetGlobFrame( m_nPreviewToolTip, frGlob) ;
Point3d ptToolTipGlob = GetToGlob( ptToolTipLoc, frGlob) ;
Vector3d vtMoveGlob = ptEnd - ptToolTipGlob ;
m_pGeomDB->GetGroupGlobFrame( nStId, frGlob) ;
Vector3d vtMoveLoc = GetToLoc( vtMoveGlob, frGlob) ;
m_pGeomDB->TranslateGroup( nStId, vtMoveLoc) ;
// ritorno l'Id dell'entità CamData corrente
return nEntId ;
}
@@ -924,7 +1098,7 @@ Machining::CalcMirrorByDouble( int nClId, const string& sUserNotes)
}
// se presente una differenza in Z, eseguo spostamento
double dDeltaZ ;
double dDeltaZ = 0. ;
if ( GetValInNotes( sUserNotes, UN_DELTAZ, dDeltaZ) && abs( dDeltaZ) > EPS_SMALL)
m_pGeomDB->TranslateGlob( nDblId, Vector3d( 0, 0, dDeltaZ)) ;