diff --git a/Machining.cpp b/Machining.cpp index f470837..83bce12 100644 --- a/Machining.cpp +++ b/Machining.cpp @@ -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 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( 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 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( 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)) ; diff --git a/Machining.h b/Machining.h index 18f6acc..8976ec3 100644 --- a/Machining.h +++ b/Machining.h @@ -50,7 +50,7 @@ class Machining : public Operation public : bool GetStartPoint( Point3d& ptStart) const ; bool GetEndPoint( Point3d& ptEnd) const ; - bool UpdateToolView( int nFlag) ; + bool ChangeToolPreviewShow( int nFlag) ; bool PrepareToolPreview( void) ; bool RemoveToolPreview( void) ; int GetToolPreviewStepCount( void) const ; @@ -69,12 +69,20 @@ class Machining : public Operation private : int GetToolPreviewNext( int nEntId, int nParentId, int nStId) const ; int GetToolPreviewPrev( int nEntId, int nParentId, int nStId) /*const*/ ; + bool MyPrepareToolPreview( bool bDouble) ; + bool MyChangeToolPreviewShow( int nLookFlag, bool bDouble) ; + bool MyToolPreview( int nEntId, bool bDouble) ; private : int m_nLookFlag ; // flag di Visualizzazione per Preview + // lavorazione singola int m_nPreviewHeadId ; // Id del gruppo testa di Preview int m_nPreviewToolTip ; // Id del gruppo contenente il punto ToolTip INTVECTOR m_vPreviewAxisIds ; // indici degli assi di Preview + // lavorazione in doppio + int m_nPreviewHeadIdDBL ; // Id della testa di Preview + int m_nPreviewToolTipDBL ; // Id del gruppo contenente il punto di ToolTip + INTVECTOR m_vPreviewAxisIdsBBL ; // indici degli assi di Preview } ; //----------------------------------------------------------------------------