From 3cd21182d3cddc4a4f89f98d79e9ae4bedbc3b80 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Mon, 30 May 2016 08:55:15 +0000 Subject: [PATCH] EgtMachKernel : - aggiunta gestione archi su piani diversi da XY - disposizione rimette sempre anche i sottopezzi al loro posto - aggiunti attacchi e uscite a fresature - aggiunta prima versione calcolo collegamenti tra lavorazioni evitando collisioni - modifiche a simulazione per tavole mobili con sottopezzi e pezzi. --- CamData.cpp | 43 ++- CamData.h | 12 +- Disposition.cpp | 46 ++- Disposition.h | 1 + EgtMachKernel.vcxproj | 1 + EgtMachKernel.vcxproj.filters | 3 + Machine.h | 2 + MachineCalc.cpp | 22 ++ MachiningsMgr.cpp | 1 + Milling.cpp | 640 +++++++++++++++++++++++++++++++++- Milling.h | 6 + Operation.cpp | 352 +++++-------------- Operation.h | 5 +- OperationCL.cpp | 294 ++++++++++++++++ Sawing.cpp | 42 ++- Simulator.cpp | 8 +- 16 files changed, 1189 insertions(+), 289 deletions(-) create mode 100644 OperationCL.cpp diff --git a/CamData.cpp b/CamData.cpp index 152be76..650e059 100644 --- a/CamData.cpp +++ b/CamData.cpp @@ -40,7 +40,10 @@ static std::string CAM_ACEN = "ACen" ; static std::string CAM_AXMC = "AxMC" ; static std::string CAM_AXMR = "AxMR" ; static std::string CAM_AXAC = "AxAC" ; -static int CAM_TOTPARAM =CAM_PARAM_V2 ; +static int CAM_PARAM_V3 = 18 ; +static std::string CAM_NDIR = "NDir" ; +static std::string CAM_AXND = "AxND" ; +static int CAM_TOTPARAM =CAM_PARAM_V3 ; //---------------------------------------------------------------------------- USEROBJ_REGISTER( "EMkCamData", CamData) ; @@ -71,6 +74,7 @@ CamData::Clone( void) const pCam->m_ptEnd = m_ptEnd ; pCam->m_ptCen = m_ptCen ; pCam->m_dAngCen = m_dAngCen ; + pCam->m_vtN = m_vtN ; pCam->m_dFeed = m_dFeed ; pCam->m_nFlag = m_nFlag ; pCam->m_nAxesStatus = m_nAxesStatus ; @@ -79,6 +83,7 @@ CamData::Clone( void) const pCam->m_ptMachCen = m_ptMachCen ; pCam->m_dMachRad = m_dMachRad ; pCam->m_dMachAngCen = m_dMachAngCen ; + pCam->m_vtMachN = m_vtMachN ; } catch( ...) { delete pCam ; @@ -102,6 +107,7 @@ CamData::Dump( string& sOut, bool bMM, const char* szNewLine) const sOut += CAM_PBAS + "=" + ToString( m_ptEnd) + szNewLine ; sOut += CAM_PCEN + "=" + ToString( m_ptCen) + szNewLine ; sOut += CAM_ACEN + "=" + ToString( m_dAngCen) + szNewLine ; + sOut += CAM_NDIR + "=" + ToString( m_vtN) + szNewLine ; sOut += CAM_FEED + "=" + ToString( m_dFeed) + szNewLine ; sOut += CAM_FLAG + "=" + ToString( m_nFlag) + szNewLine ; sOut += CAM_AXSTS + "=" + ToString( m_nAxesStatus) + szNewLine ; @@ -110,6 +116,7 @@ CamData::Dump( string& sOut, bool bMM, const char* szNewLine) const sOut += CAM_AXMC + "=" + ToString( m_ptMachCen) + szNewLine ; sOut += CAM_AXMR + "=" + ToString( m_dMachRad) + szNewLine ; sOut += CAM_AXAC + "=" + ToString( m_dMachAngCen) + szNewLine ; + sOut += CAM_AXND + "=" + ToString( m_vtMachN) + szNewLine ; return true ; } @@ -161,6 +168,9 @@ CamData::Save( STRVECTOR& vString) const vString[++k] = CAM_AXMC + "=" + ToString( m_ptMachCen) ; vString[++k] = CAM_AXMR + "=" + ToString( m_dMachRad) ; vString[++k] = CAM_AXAC + "=" + ToString( m_dMachAngCen) ; + // parametri aggiunti V3 + vString[++k] = CAM_NDIR + "=" + ToString( m_vtN) ; + vString[++k] = CAM_AXND + "=" + ToString( m_vtMachN) ; } catch( ...) { return false ; @@ -203,7 +213,16 @@ CamData::Load( const STRVECTOR& vString, int nBaseGdbId) m_ptMachCen = ORIG ; m_dMachRad = 0 ; } - + // parametri aggiunti V3 + if ( int( vString.size()) >= CAM_PARAM_V3) { + if ( ! GetVal( vString[++k], CAM_NDIR, m_vtN) || + ! GetVal( vString[++k], CAM_AXND, m_vtMachN)) + return false ; + } + else { + m_vtN = Z_AX ; + m_vtMachN = Z_AX ; + } return true ; } @@ -527,6 +546,16 @@ CamData::SetAngCen( double dAngCen) ResetObjGraphics() ; return true ; } + +//---------------------------------------------------------------------------- +bool +CamData::SetNormDir( const Vector3d& vtDir) +{ + m_vtN = vtDir ; + ResetObjGraphics() ; + return true ; +} + //---------------------------------------------------------------------------- bool CamData::SetFeed( double dFeed) @@ -593,6 +622,16 @@ CamData::SetAxesAngCen( double dAngCen) return true ; } +//---------------------------------------------------------------------------- +bool +CamData::SetAxesNormDir( const Vector3d& vtDir) +{ + if ( ! IsArc()) + return false ; + m_vtMachN = vtDir ; + return true ; +} + //---------------------------------------------------------------------------- void CamData::ResetObjGraphics( void) diff --git a/CamData.h b/CamData.h index 77145eb..ad1b0bf 100644 --- a/CamData.h +++ b/CamData.h @@ -52,6 +52,7 @@ class CamData : public IUserObj bool SetEndPoint( const Point3d& ptEnd) ; bool SetCenter( const Point3d& ptCen) ; bool SetAngCen( double dAngCen) ; + bool SetNormDir( const Vector3d& vtDir) ; bool SetFeed( double dFeed) ; bool SetFlag( int nFlag) ; bool SetAxes( int nStatus, const DBLVECTOR& vAxVal) ; @@ -61,6 +62,7 @@ class CamData : public IUserObj bool SetAxesCen( const Point3d ptAxCen) ; bool SetAxesRad( double dRad) ; bool SetAxesAngCen( double dAngCen) ; + bool SetAxesNormDir( const Vector3d& vtDir) ; const int GetMoveType( void) const { return m_nMove ; } const bool IsArc( void) const @@ -77,6 +79,8 @@ class CamData : public IUserObj { return m_ptCen ; } double GetAngCen( void) const { return m_dAngCen ; } + const Vector3d& GetNormDir( void) const + { return m_vtN ; } double GetFeed( void) const { return m_dFeed ; } int GetFlag( void) const @@ -93,6 +97,8 @@ class CamData : public IUserObj { return m_dMachRad ; } const double GetAxesAngCen( void) const { return m_dMachAngCen ; } + const Vector3d& GetAxisNormDir( void) const + { return m_vtMachN ; } public : enum { AS_NONE = 0, @@ -104,7 +110,9 @@ class CamData : public IUserObj MSK_L2 = 2, MSK_L3 = 4, MSK_R1 = 8, - MSK_R2 = 16} ; + MSK_R2 = 16, + MSK_R3 = 32, + MSK_R4 = 64} ; private : void ResetObjGraphics( void) ; @@ -120,6 +128,7 @@ class CamData : public IUserObj Point3d m_ptEnd ; // punto finale Point3d m_ptCen ; // centro per archi double m_dAngCen ; // angolo al centro per archi + Vector3d m_vtN ; // vettore normale al piano di giacitura per archi double m_dFeed ; // velocità di avanzamento in lavorazione int m_nFlag ; // flag per usi vari int m_nAxesStatus ; // stato dei valori degli assi @@ -128,6 +137,7 @@ class CamData : public IUserObj Point3d m_ptMachCen ; // centro arco espresso in assi macchina double m_dMachRad ; // raggio arco espresso in macchina double m_dMachAngCen ; // angolo al centro per archi espresso in macchina + Vector3d m_vtMachN ; // vettore normale al piano di giacitura per archi espresso in macchina } ; diff --git a/Disposition.cpp b/Disposition.cpp index 3b45351..cda17fc 100644 --- a/Disposition.cpp +++ b/Disposition.cpp @@ -343,6 +343,13 @@ Disposition::Apply(void) else FixData.nId = nId ; } + // altrimenti sottopezzo da rimettere in posizione + else { + if ( ! PlaceFixture( FixData.nId, FixData.ptPos, FixData.dAng)) { + string sOut = "Error placing fixture " + ToString( FixData.nId) ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; + } + } } // annullo movimento grezzi int nRawId = m_pMchMgr->GetFirstRawPart() ; @@ -441,9 +448,9 @@ Disposition::MoveFixture( int nId, const Vector3d& vtMove) // muovo l'oggetto m_pGeomDB->TranslateGlob( nId, vtMove) ; // aggiorno la posizione dell'oggetto nel vettore dei comandi - for ( auto iIter = m_vFixData.begin() ; iIter != m_vFixData.end() ; ++ iIter) { - if ( iIter->nId == nId) { - iIter->ptPos += vtMove ; + for ( auto& FixData : m_vFixData) { + if ( FixData.nId == nId) { + FixData.ptPos += vtMove ; break ; } } @@ -472,6 +479,39 @@ Disposition::RotateFixture( int nId, double dAngDeg) return true ; } +//---------------------------------------------------------------------------- +bool +Disposition::PlaceFixture( int nId, const Point3d& ptPos, double dAngDeg) +{ + // verifica validità sottopezzo + if ( ! VerifyFixture( nId)) + return false ; + // verifico aggiornamento tavola + if ( ! m_bTabOk && ! SetTable( m_sTabName)) + return false ; + // verifico che la posizione sia nell'area della tavola + if ( ! m_b3Area1.EnclosesXY( m_ptRef1 + ptPos)) + return false ; + // resetto il riferimento del gruppo + Frame3d* pfrFixt = m_pGeomDB->GetGroupFrame( nId) ; + pfrFixt->Reset() ; + // lo muovo nella posizione voluta + Vector3d vtMove = ( m_ptRef1 + ptPos) - ORIG ; + m_pGeomDB->TranslateGlob( nId, vtMove) ; + // lo ruoto + if ( fabs( dAngDeg) > EPS_ANG_SMALL) + m_pGeomDB->RotateGroup( nId, ORIG, Z_AX, dAngDeg) ; + // aggiorno la posizione dell'oggetto nel vettore dei comandi + for ( auto& FixData : m_vFixData) { + if ( FixData.nId == nId) { + FixData.ptPos = ptPos ; + FixData.dAng = dAngDeg ; + break ; + } + } + return true ; +} + //---------------------------------------------------------------------------- bool Disposition::RemoveFixture( int nId) diff --git a/Disposition.h b/Disposition.h index c8255db..f3a4260 100644 --- a/Disposition.h +++ b/Disposition.h @@ -82,6 +82,7 @@ class Disposition : public Operation int AddFixture( const std::string& sName, const Point3d& ptPos, double dAngDeg = 0, bool bAddToList = true) ; bool MoveFixture( int nId, const Vector3d& vtMove) ; bool RotateFixture( int nId, double dAngDeg) ; + bool PlaceFixture( int nId, const Point3d& ptPos, double dAngDeg) ; bool RemoveFixture( int nId) ; bool MoveToCornerRawPart( int nRawId, const Point3d& ptP, int nFlag, bool bAddToList = true) ; bool MoveToCenterRawPart( int nRawId, const Point3d& ptP, int nFlag, bool bAddToList = true) ; diff --git a/EgtMachKernel.vcxproj b/EgtMachKernel.vcxproj index 3dc7f23..e57605c 100644 --- a/EgtMachKernel.vcxproj +++ b/EgtMachKernel.vcxproj @@ -246,6 +246,7 @@ copy $(TargetPath) \EgtProg\Dll64 + diff --git a/EgtMachKernel.vcxproj.filters b/EgtMachKernel.vcxproj.filters index 49aa9cf..6778b75 100644 --- a/EgtMachKernel.vcxproj.filters +++ b/EgtMachKernel.vcxproj.filters @@ -174,6 +174,9 @@ Source Files\Operations + + Source Files\Operations + diff --git a/Machine.h b/Machine.h index 3da2aef..ec36b5a 100644 --- a/Machine.h +++ b/Machine.h @@ -68,6 +68,8 @@ class Machine bool SetCurrTool( const std::string& sTool, const std::string& sHead, int nExit) ; int GetCurrTool( void) const ; bool GetCurrTool( std::string& sTool) const ; + int GetCurrHead( void) const ; + bool GetCurrHead( std::string& sHead) const ; double GetCurrRot1W( void) const ; std::string GetKinematicAxis( int nInd) const ; bool BlockKinematicRotAxis( const std::string& sName, double dVal) ; diff --git a/MachineCalc.cpp b/MachineCalc.cpp index c2d9472..c808774 100644 --- a/MachineCalc.cpp +++ b/MachineCalc.cpp @@ -214,6 +214,28 @@ Machine::GetCurrTool( string& sTool) const return m_pGeomDB->GetName( m_nCalcToolId, sTool) ; } +//---------------------------------------------------------------------------- +int +Machine::GetCurrHead( void) const +{ + // controllo GeomDB + if ( m_pGeomDB == nullptr) + return GDB_ID_NULL ; + // recupero identificativo dell'utensile + return m_nCalcHeadId ; +} + +//---------------------------------------------------------------------------- +bool +Machine::GetCurrHead( std::string& sHead) const +{ + // controllo GeomDB + if ( m_pGeomDB == nullptr) + return false ; + // recupero nome gruppo della testa + return m_pGeomDB->GetName( m_nCalcHeadId, sHead) ; +} + //---------------------------------------------------------------------------- double Machine::GetCurrRot1W( void) const diff --git a/MachiningsMgr.cpp b/MachiningsMgr.cpp index 4d6666b..5d84f83 100644 --- a/MachiningsMgr.cpp +++ b/MachiningsMgr.cpp @@ -65,6 +65,7 @@ MachiningsMgr::MachiningsMgr( void) m_b5AxComp = MF_CURR_5AXCOMP ; m_dExtraLOnCutRegion = MF_CURR_EXTRALCR ; m_dExtraROnDrillRegion = MF_CURR_EXTRARDR ; + m_dHoleDiamToler = MF_CURR_HOLEDTOL ; m_dExtSawArcMinRad = MF_CURR_EXTSAWARCMINRAD ; } diff --git a/Milling.cpp b/Milling.cpp index 198ce57..4bb22ca 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -18,7 +18,9 @@ #include "Milling.h" #include "MachiningConst.h" #include "/EgtDev/Include/EGkCurveLine.h" +#include "/EgtDev/Include/EGkCurveArc.h" #include "/EgtDev/Include/EGkCurveComposite.h" +#include "/EgtDev/Include/EgkArcSpecial.h" #include "/EgtDev/Include/EgkChainCurves.h" #include "/EgtDev/Include/EGkUserObjFactory.h" #include "/EgtDev/Include/EGnStringKeyVal.h" @@ -187,6 +189,11 @@ Milling::Prepare( const string& sMillName) bool Milling::SetParam( int nType, bool bVal) { + switch ( nType) { + case MPA_INVERT : + m_Params.m_bInvert = bVal ; + return true ; + } return false ; } @@ -194,6 +201,28 @@ Milling::SetParam( int nType, bool bVal) bool Milling::SetParam( int nType, int nVal) { + switch ( nType) { + case MPA_WORKSIDE : + if ( ! m_Params.VerifyWorkSide( nVal)) + return false ; + m_Params.m_nWorkSide = nVal ; + return true ; + case MPA_STEPTYPE : + if ( ! m_Params.VerifyStepType( nVal)) + return false ; + m_Params.m_nStepType = nVal ; + return true ; + case MPA_LEADINTYPE : + if ( ! m_Params.VerifyLeadInType( nVal)) + return false ; + m_Params.m_nLeadInType = nVal ; + return true ; + case MPA_LEADOUTTYPE : + if ( ! m_Params.VerifyLeadOutType( nVal)) + return false ; + m_Params.m_nLeadOutType = nVal ; + return true ; + } return false ; } @@ -246,6 +275,30 @@ Milling::SetParam( int nType, double dVal) else m_Params.m_dOffsL = dVal ; return true ; + case MPA_DEPTH : + m_Params.m_sDepth = ToString( dVal) ; + return true ; + case MPA_STARTPOS : + m_Params.m_dStartPos = dVal ; + return true ; + case MPA_OVERLAP : + m_Params.m_dOverlap = dVal ; + return true ; + case MPA_STEP : + m_Params.m_dStep = dVal ; + return true ; + case MPA_LITANG : + m_Params.m_dLiTang = dVal ; + return true ; + case MPA_LIPERP : + m_Params.m_dLiPerp = dVal ; + return true ; + case MPA_LIELEV : + m_Params.m_dLiElev = dVal ; + return true ; + case MPA_LICOMPLEN : + m_Params.m_dLoCompLen = dVal ; + return true ; } return false ; } @@ -263,6 +316,9 @@ Milling::SetParam( int nType, const string& sVal) m_Params.m_ToolUuid = pTdata->m_Uuid ; m_TParams = *pTdata ; } break ; + case MPA_DEPTH_STR : + m_Params.m_sDepth = sVal ; + return true ; case MPA_SYSNOTES : m_Params.m_sSysNotes = sVal ; break ; @@ -279,7 +335,29 @@ Milling::SetParam( int nType, const string& sVal) bool Milling::SetGeometry( const SELVECTOR& vIds) { - return false ; + // verifico validità gestore DB geometrico + if ( m_pGeomDB == nullptr) + return false ; + // reset della geometria corrente + m_vId.clear() ; + // verifico che gli identificativi rappresentino delle entità ammissibili + for ( const auto& Id : vIds) { + // test sull'entità + int nSubs ; + if ( ! VerifyGeometry( Id, nSubs)) { + string sOut = "Entity " + ToString( Id) + " skipped by Milling" ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) ; + continue ; + } + // posso aggiungere alla lista + if ( nSubs == 0) + m_vId.emplace_back( Id) ; + else { + for ( int i = 0 ; i < nSubs ; ++ i) + m_vId.emplace_back( Id.nId, i) ; + } + } + return ( ! m_vId.empty()) ; } //---------------------------------------------------------------------------- @@ -299,7 +377,72 @@ Milling::Apply( bool bRecalc) // reset numero percorsi di lavoro generati m_nMills = 0 ; - return false ; + // verifico validità gestore DB geometrico e Id del gruppo + if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId)) + return false ; + + // recupero gruppo per geometria ausiliaria + int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ; + bool bChain = false ; + // se non c'è, lo aggiungo + if ( nAuxId == GDB_ID_NULL) { + nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; + if ( nAuxId == GDB_ID_NULL) + return false ; + m_pGeomDB->SetName( nAuxId, MCH_AUX) ; + m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ; + bChain = true ; + } + // altrimenti, se chiesto ricalcolo, lo svuoto + else if ( bRecalc) { + m_pGeomDB->EmptyGroup( nAuxId) ; + bChain = true ; + } + + // aggiorno dati geometrici dell'utensile + if ( ! UpdateToolData()) { + LOG_INFO( GetEMkLogger(), "Error in Sawing : UpdateToolData failed") ; + return false ; + } + + // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria + if ( bChain && ! Chain( nAuxId)) + return false ; + + // recupero gruppo per geometria di lavorazione (Cutter Location) + int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ; + // se non c'è, lo aggiungo + if ( nClId == GDB_ID_NULL) { + nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; + if ( nClId == GDB_ID_NULL) + return false ; + m_pGeomDB->SetName( nClId, MCH_CL) ; + } + // altrimenti lo svuoto + else + m_pGeomDB->EmptyGroup( nClId) ; + + // lavoro ogni singola catena + int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ; + while ( nPathId != GDB_ID_NULL) { + if ( ! ProcessPath( nPathId, GDB_ID_NULL, nClId)) + return false ; + nPathId = m_pGeomDB->GetNextGroup( nPathId) ; + } + + // se lavorazione vuota, esco + if ( m_nMills == 0) + return true ; + + // calcolo gli assi macchina + if ( ! CalculateAxesValues()) + return false ; + + // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione + if ( ! AdjustStartEndMovements()) + return false ; + + return true ; } //---------------------------------------------------------------------------- @@ -317,6 +460,18 @@ Milling::GetParam( int nType, int& nVal) const case MPA_TYPE : nVal = MT_MILLING ; return true ; + case MPA_WORKSIDE : + nVal = m_Params.m_nWorkSide ; + return true ; + case MPA_STEPTYPE : + nVal = m_Params.m_nStepType ; + return true ; + case MPA_LEADINTYPE : + nVal = m_Params.m_nLeadInType ; + return true ; + case MPA_LEADOUTTYPE : + nVal = m_Params.m_nLeadOutType ; + return true ; } return false ; } @@ -350,9 +505,25 @@ Milling::GetParam( int nType, double& dVal) const case MPA_STARTPOS : dVal = m_Params.m_dStartPos ; return true ; - case MPA_SIDEANGLE : - dVal = m_Params.m_dSideAngle ; + case MPA_OVERLAP : + dVal = m_Params.m_dOverlap ; return true ; + case MPA_STEP : + dVal = m_Params.m_dStep ; + return true ; + case MPA_LITANG : + dVal = m_Params.m_dLiTang ; + return true ; + case MPA_LIPERP : + dVal = m_Params.m_dLiPerp ; + return true ; + case MPA_LIELEV : + dVal = m_Params.m_dLiElev ; + return true ; + case MPA_LICOMPLEN : + dVal = m_Params.m_dLoCompLen ; + return true ; + } return false ; } @@ -607,3 +778,464 @@ Milling::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) // non devo fare alcunché return true ; } + +//---------------------------------------------------------------------------- +bool +Milling::ProcessPath( int nPathId, int nPvId, int nClId) +{ + // recupero gruppo per geometria temporanea + const string GRP_TEMP = "Temp" ; + int nTempId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, GRP_TEMP) ; + // se non c'è, lo aggiungo + if ( nTempId == GDB_ID_NULL) { + nTempId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; + if ( nTempId == GDB_ID_NULL) + return false ; + m_pGeomDB->SetName( nTempId, GRP_TEMP) ; + } + // altrimenti lo svuoto + else + m_pGeomDB->EmptyGroup( nTempId) ; + // in ogni caso lo dichiaro temporaneo e non visibile + m_pGeomDB->SetLevel( nTempId, GDB_LV_TEMP) ; + m_pGeomDB->SetStatus( nTempId, GDB_ST_OFF) ; + + // copio la curva composita da elaborare + int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ; + if ( m_pGeomDB->GetGeoType( nCrvId) != CRV_COMPO) + return false ; + int nCopyId = m_pGeomDB->CopyGlob( nCrvId, GDB_ID_NULL, nTempId) ; + if ( nCopyId == GDB_ID_NULL) + return false ; + ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( nCopyId)) ; + + // unisco le parti allineate + //if ( ! pCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL)) + // return false ; + + // eventuale inversione percorso + if ( m_Params.m_bInvert) + pCompo->Invert() ; + + // se utensile non centrato, eseguo correzione raggio utensile ed eventuale offset + double dOffs = 0.5 * m_TParams.m_dTDiam + GetOffsR() ; + if ( m_Params.m_nWorkSide != MILL_WS_CENTER && abs( dOffs) > EPS_SMALL) { + double dSignOffs = ( m_Params.m_nWorkSide == MILL_WS_RIGHT) ? dOffs : - dOffs ; + if ( ! pCompo->SimpleOffset( dSignOffs, ICurve::OFF_EXTEND)){ + LOG_INFO( GetEMkLogger(), "Error in Milling : SimpleOffset not computable") ; + return false ; + } + } + + // recupero estrusione e spessore + Vector3d vtExtr ; + pCompo->GetExtrusion( vtExtr) ; + double dThick ; + pCompo->GetThickness( dThick) ; + + // recupero il box del grezzo in globale + BBox3d b3Raw ; + if ( ! GetRawGlobBox( m_nPhase, nPathId, b3Raw) || b3Raw.IsEmpty()) { + LOG_INFO( GetEMkLogger(), "Error in SawFinishing : Empty RawBox") ; + return false ; + } + + // recupero distanza da fondo dei grezzi interessati dal percorso + double dRbDist ; + if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, 2 * m_TParams.m_dThick, dRbDist)) + return false ; + + // valuto l'espressione dell'affondamento + ExeLuaSetGlobNumVar( "TH", (( dThick * vtExtr.z < 0) ? fabs( dThick) : 0)) ; + ExeLuaSetGlobNumVar( "RB", dRbDist) ; + double dDepth ; + if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) { + LOG_INFO( GetEMkLogger(), "Error in Milling : Depth not computable") ; + return false ; + } + // verifico di non superare il massimo materiale + if ( dDepth > m_TParams.m_dMaxMat) { + LOG_INFO( GetEMkLogger(), "Error in Milling : Depth bigger than MaxMaterial") ; + return false ; + } + + // recupero nome del path + string sPathName ; + m_pGeomDB->GetName( nPathId, sPathName) ; + + // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi + const double MAX_ANG_CEN = 150 + EPS_ANG_SMALL ; + int nMaxInd = pCompo->GetCurveCount() - 1 ; + for ( int i = 0 ; i <= nMaxInd ; ++ i) { + // se arco con angolo al centro oltre il limite, lo divido a metà + const ICurveArc* pArc = GetCurveArc( pCompo->GetCurve( i)) ; + if ( pArc != nullptr && abs( pArc->GetAngCenter()) > MAX_ANG_CEN) { + pCompo->AddJoint( i + 0.5) ; + ++ i ; + ++ nMaxInd ; + } + } + + // creo gruppo per geometria di lavorazione del percorso + int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ; + if ( nPxId == GDB_ID_NULL) + return false ; + m_pGeomDB->SetName( nPxId, sPathName) ; + m_pGeomDB->SetMaterial( nPxId, BLUE) ; + + // calcolo il versore fresa + Vector3d vtTool = Z_AX ; + if ( ! vtExtr.IsSmall()) + vtTool = vtExtr ; + + // Imposto dati comuni + SetPathId( nPxId) ; + SetToolDir( vtTool) ; + // recupero distanza di sicurezza + double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + // lunghezza di approccio/retrazione + double dAppr = m_Params.m_dStartPos ; + + // ciclo sulle curve elementari + bool bClosed = pCompo->IsClosed() ; + nMaxInd = pCompo->GetCurveCount() - 1 ; + for ( int i = 0 ; i <= nMaxInd ; ++ i) { + // curva corrente + const ICurve* pCrvC = pCompo->GetCurve( i) ; + // copio la curva + PtrOwner pCurve( ::GetCurve( pCrvC->Clone())) ; + if ( IsNull( pCurve)) + return false ; + // aggiungo affondamento + pCurve->Translate( - vtTool * dDepth) ; + // calcolo elevazione + double dElev ; + Point3d ptStart, ptMid, ptEnd ; + pCurve->GetStartPoint( ptStart) ; + pCurve->GetMidPoint( ptMid) ; + pCurve->GetEndPoint( ptEnd) ; + if ( ! GetElevation( m_nPhase, ptStart, ptMid, ptEnd, vtTool, dElev)) { + LOG_INFO( GetEMkLogger(), "Error in Milling : Entity GetElevation") ; + return false ; + } + if ( dElev < EPS_SMALL) { + BBox3d b3Crv ; + pCurve->GetLocalBBox( b3Crv) ; + dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z) ; + } + // se prima entità, approccio e affondo + if ( i == 0) { + // dati inizio entità + Point3d ptStart ; + pCurve->GetStartPoint( ptStart) ; + Vector3d vtStart ; + pCurve->GetStartDir( vtStart) ; + // determino inizio attacco + Point3d ptP1 ; + if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, ptP1)) + return false ; + // aggiungo approccio + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dElev, dAppr)) + return false ; + // affondo al punto iniziale + SetFlag( 0) ; + SetFeed( GetTipFeed()) ; + if ( AddLinearMove( ptP1) == GDB_ID_NULL) + return false ; + // aggiungo attacco + SetFeed( GetStartFeed()) ; + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr)) { + LOG_INFO( GetEMkLogger(), "Error in Milling : LeadIn not computable") ; + return false ; + } + } + // elaborazioni sulla curva corrente + if ( pCurve->GetType() == CRV_LINE) { + ICurveLine* pLine = GetCurveLine( pCurve) ; + Point3d ptP3 = pLine->GetEnd() ; + SetFeed( GetFeed()) ; + if ( AddLinearMove( ptP3) == GDB_ID_NULL) + return false ; + } + else if ( pCurve->GetType() == CRV_ARC) { + ICurveArc* pArc = GetCurveArc( pCurve) ; + Point3d ptCen = pArc->GetCenter() ; + double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; + Point3d ptP3 ; + pArc->GetEndPoint( ptP3) ; + SetFeed( GetFeed()) ; + if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) + return false ; + } + // se ultima entità, uscita e retrazione + if ( i == nMaxInd) { + // dati fine entità + Point3d ptEnd ; + pCurve->GetEndPoint( ptEnd) ; + Vector3d vtEnd ; + pCurve->GetEndDir( vtEnd) ; + // aggiungo uscita + Point3d ptP1 ; + SetFeed( GetStartFeed()) ; + if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, ptP1)) { + LOG_INFO( GetEMkLogger(), "Error in Milling : LeadOut not computable") ; + return false ; + } + // aggiungo retrazione + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dElev, dAppr)) + return false ; + } + } + + // incremento numero di fresate + ++ m_nMills ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) +{ + // se distanza di sicurezza minore di distanza di inizio + if ( dSafeZ < m_Params.m_dStartPos + 10 * EPS_SMALL) { + // 1 -> punto sopra inizio + SetFlag( 1) ; + Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ; + if ( AddRapidStart( ptP1) == GDB_ID_NULL) + return false ; + } + else { + // 1a -> punto sopra inizio + SetFlag( 1) ; + Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ; + Point3d ptP1a = ptP1b + vtTool * ( dSafeZ - m_Params.m_dStartPos) ; + if ( AddRapidStart( ptP1a) == GDB_ID_NULL) + return false ; + // 1b -> punto appena sopra inizio + SetFlag( 0) ; + if ( AddRapidMove( ptP1b) == GDB_ID_NULL) + return false ; + } + return true ; +} + +//---------------------------------------------------------------------------- +bool +Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) +{ + if ( dSafeZ < m_Params.m_dStartPos + 10 * EPS_SMALL) { + // 4 -> movimento di risalita sopra il punto finale + SetFeed( GetEndFeed()) ; + Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ; + if ( AddLinearMove( ptP4) == GDB_ID_NULL) + return false ; + } + else { + // 4a -> movimento di risalita appena sopra il punto finale + SetFeed( GetEndFeed()) ; + Point3d ptP4a = ptP + vtTool * ( dElev + dAppr) ; + if ( AddLinearMove( ptP4a) == GDB_ID_NULL) + return false ; + // 4b -> movimento di risalita sopra il punto finale + Point3d ptP4b = ptP4a + vtTool * ( dSafeZ - m_Params.m_dStartPos) ; + if ( AddRapidMove( ptP4b) == GDB_ID_NULL) + return false ; + } + return true ; +} + +//---------------------------------------------------------------------------- +bool +Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, Point3d& ptP1) +{ + switch ( m_Params.m_nLeadInType) { + case MILL_LI_NONE : + ptP1 = ptStart ; + return true ; + case MILL_LI_LINEAR : + case MILL_LI_TANGENT : { + if ( m_Params.m_dLiTang < 10 * EPS_SMALL && abs( m_Params.m_dLiPerp) < EPS_SMALL) + return false ; + Vector3d vtPerp = vtStart ; + vtPerp.Rotate( vtN, ( ( m_Params.m_nWorkSide == MILL_WS_LEFT) ? 90 : - 90)) ; + ptP1 = ptStart - vtStart * m_Params.m_dLiTang + vtPerp * m_Params.m_dLiPerp ; + return true ; + } + case MILL_LI_GLIDE : + // !!! DA FARE !!! + return false ; + default : + return false ; + } +} + +//---------------------------------------------------------------------------- +bool +Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN) +{ + switch ( m_Params.m_nLeadInType) { + case MILL_LI_NONE : + return true ; + case MILL_LI_LINEAR : + return ( AddLinearMove( ptStart, MCH_CL_LEADIN) != GDB_ID_NULL) ; + case MILL_LI_TANGENT : + { + PtrOwner pCrv( GetArc2PVN( ptStart, ptP1, - vtStart, vtN)) ; + if ( IsNull( pCrv)) + return false ; + pCrv->Invert() ; + if ( pCrv->GetType() == CRV_LINE) { + ICurveLine* pLine = GetCurveLine( pCrv) ; + Point3d ptP3 = pLine->GetEnd() ; + return ( AddLinearMove( ptP3, MCH_CL_LEADIN) != GDB_ID_NULL) ; + } + else if ( pCrv->GetType() == CRV_ARC) { + ICurveArc* pArc = GetCurveArc( pCrv) ; + Point3d ptCen = pArc->GetCenter() ; + double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; + Point3d ptP3 ; + pArc->GetEndPoint( ptP3) ; + // se angolo al centro minore del limite, un solo arco + const double MAX_ANG_CEN = 150 + EPS_ANG_SMALL ; + if ( abs( dAngCen) < MAX_ANG_CEN) { + if ( AddArcMove( ptP3, ptCen, dAngCen, vtN, MCH_CL_LEADIN) == GDB_ID_NULL) + return false ; + } + // altrimenti due archi + else if ( abs( dAngCen) < 2 * MAX_ANG_CEN){ + Point3d ptMid ; + pArc->GetMidPoint( ptMid) ; + // prima metà arco + if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN, MCH_CL_LEADIN) == GDB_ID_NULL) + return false ; + // seconda metà arco + if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN, MCH_CL_LEADIN) == GDB_ID_NULL) + return false ; + } + // oppure tre archi + else { + Point3d ptTmp ; + // primo terzo + pArc->GetPointD1D2( 1. / 3, ICurve::FROM_MINUS, ptTmp) ; + if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADIN) == GDB_ID_NULL) + return false ; + // secondo terzo + ptCen.z = ptTmp.z ; + pArc->GetPointD1D2( 2. / 3, ICurve::FROM_MINUS, ptTmp) ; + if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADIN) == GDB_ID_NULL) + return false ; + // ultimo terzo + ptCen.z = ptTmp.z ; + if ( AddArcMove( ptP3, ptCen, dAngCen / 3, vtN, MCH_CL_LEADIN) == GDB_ID_NULL) + return false ; + } + return true ; + } + } + case MILL_LI_GLIDE : + // !!! DA FARE !!! + return false ; + default : + return false ; + } +} + +//---------------------------------------------------------------------------- +bool +Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, Point3d& ptP1) +{ + // assegno i parametri + int nType = m_Params.m_nLeadOutType ; + double dTang = m_Params.m_dLoTang ; + double dPerp = m_Params.m_dLoPerp ; + if ( nType == MILL_LO_AS_LI) { + nType = m_Params.m_nLeadInType ; + dTang = m_Params.m_dLiTang ; + dPerp = m_Params.m_dLiPerp ; + } + // eseguo a seconda del tipo + switch ( nType) { + case MILL_LO_NONE : + ptP1 = ptEnd ; + return true ; + case MILL_LO_LINEAR : + { + if ( dTang < 10 * EPS_SMALL && abs( dPerp) < EPS_SMALL) + return false ; + Vector3d vtPerp = vtEnd ; + vtPerp.Rotate( vtN, ( ( m_Params.m_nWorkSide == MILL_WS_LEFT) ? 90 : - 90)) ; + ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ; + return ( AddLinearMove( ptP1, MCH_CL_LEADOUT) != GDB_ID_NULL) ; + } + case MILL_LO_TANGENT : + { + // calcolo punto finale dell'uscita + if ( dTang < 10 * EPS_SMALL && abs( dPerp) < EPS_SMALL) + return false ; + Vector3d vtPerp = vtEnd ; + vtPerp.Rotate( vtN, ( ( m_Params.m_nWorkSide == MILL_WS_LEFT) ? 90 : - 90)) ; + ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ; + // inserisco uscita + PtrOwner pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ; + if ( IsNull( pCrv)) + return false ; + if ( pCrv->GetType() == CRV_LINE) { + ICurveLine* pLine = GetCurveLine( pCrv) ; + Point3d ptP3 = pLine->GetEnd() ; + return ( AddLinearMove( ptP3, MCH_CL_LEADOUT) != GDB_ID_NULL) ; + } + else if ( pCrv->GetType() == CRV_ARC) { + ICurveArc* pArc = GetCurveArc( pCrv) ; + Point3d ptCen = pArc->GetCenter() ; + double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; + Point3d ptP3 ; + pArc->GetEndPoint( ptP3) ; + // se angolo al centro minore del limite, un solo arco + const double MAX_ANG_CEN = 150 + EPS_ANG_SMALL ; + if ( abs( dAngCen) < MAX_ANG_CEN) { + if ( AddArcMove( ptP3, ptCen, dAngCen, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL) + return false ; + } + // altrimenti due archi + else if ( abs( dAngCen) < 2 * MAX_ANG_CEN){ + Point3d ptMid ; + pArc->GetMidPoint( ptMid) ; + // prima metà arco + if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL) + return false ; + // seconda metà arco + ptCen.z = ptMid.z ; + if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL) + return false ; + } + // oppure tre archi + else { + Point3d ptTmp ; + // primo terzo + pArc->GetPointD1D2( 1. / 3, ICurve::FROM_MINUS, ptTmp) ; + if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL) + return false ; + // secondo terzo + ptCen.z = ptTmp.z ; + pArc->GetPointD1D2( 2. / 3, ICurve::FROM_MINUS, ptTmp) ; + if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL) + return false ; + // ultimo terzo + ptCen.z = ptTmp.z ; + if ( AddArcMove( ptP3, ptCen, dAngCen / 3, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL) + return false ; + } + return true ; + } + } + case MILL_LO_GLIDE : + // !!! DA FARE !!! + return false ; + default : + return false ; + } +} diff --git a/Milling.h b/Milling.h index 4c63a87..28af8d9 100644 --- a/Milling.h +++ b/Milling.h @@ -62,6 +62,12 @@ class Milling : public Machining bool VerifyGeometry( SelData Id, int& nSubs) ; ICurve* GetCurve( SelData Id) ; bool Chain( int nGrpDestId) ; + bool ProcessPath( int nPathId, int nPvId, int nClId) ; + bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ; + bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ; + bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, Point3d& ptP1) ; + bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN) ; + bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, Point3d& ptP1) ; private : double GetSpeed() const diff --git a/Operation.cpp b/Operation.cpp index b593040..121d717 100644 --- a/Operation.cpp +++ b/Operation.cpp @@ -24,6 +24,7 @@ #include "/EgtDev/Include/EgkIntersCurves.h" #include "/EgtDev/Include/EGkIntersLineSurfTm.h" #include "/EgtDev/Include/EGkGeomDB.h" +#include "/EgtDev/Include/EXeConst.h" #include "/EgtDev/Include/EgtPointerOwner.h" using namespace std ; @@ -608,9 +609,7 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, vAxVal.emplace_back( dAng) ; // verifico i limiti di corsa degli assi int nStat ; - double dAngA = ( vAng1.size() >= 1 ? vAng1[0] : 0) ; - double dAngB = ( vAng1.size() >= 2 ? vAng1[1] : 0) ; - bool bOsOk = m_pMchMgr->VerifyOutstroke( dX, dY, dZ, dAngA, dAngB, nStat) ; + bool bOsOk = m_pMchMgr->VerifyOutstroke( dX, dY, dZ, vAng1, nStat) ; if ( ! bOsOk || nStat != 0) { bOk = false ; pCamData->SetAxes( CamData::AS_OUTSTROKE, vAxVal) ; @@ -631,8 +630,9 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, // ricavo punto medio Point3d ptCen = pCamData->GetCenter() ; double dAngCen = pCamData->GetAngCen() ; + Vector3d vtN = pCamData->GetNormDir() ; Point3d ptMid = ptP ; - ptMid.Rotate( ptCen, Z_AX, - dAngCen / 2) ; + ptMid.Rotate( ptCen, vtN, - dAngCen / 2) ; // determino i valori degli assi al punto medio DBLVECTOR vAngMid( vAng1.size()) ; for ( size_t i = 0 ; i < vAng1.size() ; ++ i) @@ -655,6 +655,7 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, pCamData->SetAxesCen( ptP2M) ; pCamData->SetAxesRad( 0) ; pCamData->SetAxesAngCen( 0) ; + pCamData->SetAxesNormDir( V_NULL) ; // il movimento diventa lineare pCamData->SetMoveType( 1) ; // non è necessario verificare i limiti di corsa degli assi @@ -668,28 +669,30 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, continue ; } // verifico il piano - if ( pArc->GetNormVersor().z < 0) + if ( pArc->GetNormVersor() * pCamData->GetToolDir() < 0) pArc->InvertN() ; // assegno il centro e il raggio di questo arco ai dati cam pCamData->SetAxesCen( pArc->GetCenter()) ; pCamData->SetAxesRad( pArc->GetRadius()) ; pCamData->SetAxesAngCen( pArc->GetAngCenter()) ; + pCamData->SetAxesNormDir( pArc->GetNormVersor()) ; // aggiorno il tipo di arco pCamData->SetMoveType( pArc->GetAngCenter() > 0 ? 3 : 2) ; // verifico i limiti di corsa dei punti lungo l'arco const int NUM_VERIF_STEP = 16 ; Point3d ptCen = pCamData->GetAxesCen() ; double dAngCenStep = pCamData->GetAxesAngCen() / NUM_VERIF_STEP ; + Vector3d vtN = pCamData->GetAxisNormDir() ; Vector3d vtCurr = Point3d( dXprec, dYprec, dZprec) - ptCen ; for ( int i = 1 ; i < NUM_VERIF_STEP ; ++ i) { - vtCurr.Rotate( Z_AX, dAngCenStep) ; + vtCurr.Rotate( vtN, dAngCenStep) ; Point3d ptCurr = ptCen + vtCurr ; double dCoeff = i / NUM_VERIF_STEP ; DBLVECTOR vAng( vAng1.size()) ; for ( size_t i = 0 ; i < vAng1.size() ; ++ i) vAng[i] = vAxRotPrec[i] * ( 1 - dCoeff) + vAng1[i] * dCoeff ; int nStat ; - bool bOsOk = m_pMchMgr->VerifyOutstroke( ptCurr.x, ptCurr.y, ptCurr.z, vAng[0], vAng[1], nStat) ; + bool bOsOk = m_pMchMgr->VerifyOutstroke( ptCurr.x, ptCurr.y, ptCurr.z, vAng, nStat) ; if ( ! bOsOk || nStat != 0) { bOk = false ; pCamData->SetAxes( CamData::AS_OUTSTROKE, vAxVal) ; @@ -761,6 +764,11 @@ Operation::AdjustStartEndMovements(void) DBLVECTOR vAxIni ; if ( ! pPrevOp->GetFinalAxesValues( vAxVal) || ! GetInitialAxesValues( vAxIni)) return false ; + // verifico se la testa interferisce con i pezzi o i bloccaggi sulla tavola + if ( ! TestCollisionAvoid( vAxVal, vAxIni)) { + if ( ! pPrevOp->AddRise( vAxVal)) + return false ; + } // determino delta Z rispetto a posizione finale if ( vAxVal.size() >= 4 && vAxIni.size() >= 4) { double dDelta = 0 ; @@ -902,7 +910,7 @@ Operation::AddRise( DBLVECTOR& vAxVal, double dDelta) int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLastPxClId, Release( pGP)) ; if ( nId == GDB_ID_NULL) return false ; - m_pGeomDB->SetName( nId, MCH_RISE) ; + m_pGeomDB->SetName( nId, MCH_CL_RISE) ; // creo oggetto dati Cam PtrOwner pCam( pCamData->Clone()) ; if ( IsNull( pCam)) @@ -958,16 +966,16 @@ Operation::RemoveRise( void) // recupero l'ultimo percorso CL int nClPathId = m_pGeomDB->GetLastGroupInGroup( nClId) ; // elimino tutte le entità RISE alla fine del percorso - int nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_RISE) ; + int nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_CL_RISE) ; while ( nId != GDB_ID_NULL) { m_pGeomDB->Erase( nId) ; - nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_RISE) ; + nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_CL_RISE) ; } // elimino a maggior ragione le entità HOME - nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_HOME) ; + nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_CL_HOME) ; while ( nId != GDB_ID_NULL) { m_pGeomDB->Erase( nId) ; - nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_HOME) ; + nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_CL_HOME) ; } return true ; @@ -986,7 +994,7 @@ Operation::AddHome( void) // recupero l'ultimo percorso int nLastPxClId = m_pGeomDB->GetLastGroupInGroup( nClId) ; // recupero l'ultima entità del percorso di nome RISE - int nEntId = m_pGeomDB->GetLastNameInGroup( nLastPxClId, MCH_RISE) ; + int nEntId = m_pGeomDB->GetLastNameInGroup( nLastPxClId, MCH_CL_RISE) ; if ( nEntId == GDB_ID_NULL) return false ; // ne recupero i dati Cam @@ -1003,7 +1011,7 @@ Operation::AddHome( void) int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLastPxClId, Release( pGP)) ; if ( nId == GDB_ID_NULL) return false ; - m_pGeomDB->SetName( nId, MCH_HOME) ; + m_pGeomDB->SetName( nId, MCH_CL_HOME) ; // creo oggetto dati Cam PtrOwner pCam( pCamData->Clone()) ; if ( IsNull( pCam)) @@ -1037,10 +1045,10 @@ Operation::RemoveHome( void) // recupero l'ultimo percorso CL int nClPathId = m_pGeomDB->GetLastGroupInGroup( nClId) ; // elimino tutte le entità HOME alla fine del percorso - int nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_HOME) ; + int nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_CL_HOME) ; while ( nId != GDB_ID_NULL) { m_pGeomDB->Erase( nId) ; - nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_HOME) ; + nId = m_pGeomDB->GetFirstNameInGroup( nClPathId, MCH_CL_HOME) ; } return true ; @@ -1092,250 +1100,82 @@ Operation::CalcDeltaZForHeadRotation( const DBLVECTOR& vAxStart, const DBLVECTOR return true ; } -//---------------------------------------------------------------------------- //---------------------------------------------------------------------------- bool -Operation::SetPathId( int nPathId) +Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd) { - m_nPathId = nPathId ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -Operation::SetToolDir( const Vector3d& vtDir) -{ - m_vtTool = vtDir ; - return ( m_vtTool.Normalize()) ; -} - -//---------------------------------------------------------------------------- -bool -Operation::SetCorrDir( const Vector3d& vtDir) -{ - m_vtCorr = vtDir ; - return ( ! m_vtCorr.IsSmall()) ; -} - -//---------------------------------------------------------------------------- -bool -Operation::SetAuxDir( const Vector3d& vtDir) -{ - m_vtAux = vtDir ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -Operation::SetCorrAuxDir( const Vector3d& vtDir) -{ - m_vtCorr = vtDir ; - m_vtAux = vtDir ; - return ( ! m_vtCorr.IsSmall()) ; -} - -//---------------------------------------------------------------------------- -bool -Operation::SetFeed( double dFeed) -{ - m_dFeed = dFeed ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -Operation::SetFlag( int nFlag) -{ - m_nFlag = nFlag ; - return true ; -} - -//---------------------------------------------------------------------------- -int -Operation::AddRapidStart( const Point3d& ptP) -{ - if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) - return GDB_ID_NULL ; - // verifico di essere in uno stato valido per inizio - if ( m_vtTool.IsSmall()) - return GDB_ID_NULL ; - // creo oggetto punto per DB geometrico - PtrOwner pGP( CreateGeoPoint3d()) ; - if ( IsNull( pGP)) - return GDB_ID_NULL ; - // assegno le coordinate del punto - pGP->Set( ptP) ; - // inserisco l'oggetto nel DB geometrico - int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pGP)) ; - if ( nId == GDB_ID_NULL) - return GDB_ID_NULL ; - // creo oggetto dati Cam - PtrOwner pCam( new( nothrow) CamData) ; - if ( IsNull( pCam)) - return GDB_ID_NULL ; - // assegno valori - pCam->SetMoveType( 0) ; - pCam->SetToolDir( m_vtTool) ; - pCam->SetCorrDir( m_vtCorr) ; - pCam->SetAuxDir( m_vtAux) ; - pCam->SetEndPoint( ptP) ; - pCam->SetFeed( 0) ; - pCam->SetFlag( m_nFlag) ; - // associo questo oggetto a quello geometrico - m_pGeomDB->SetUserObj( nId, Release( pCam)) ; - // salvo la posizione corrente - m_bCurr = true ; - m_ptCurr = ptP ; - return nId ; -} - -//---------------------------------------------------------------------------- -int -Operation::AddRapidMove( const Point3d& ptP) -{ - if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) - return GDB_ID_NULL ; - // verifico di essere in uno stato valido per un movimento in rapido - if ( ! m_bCurr || m_vtTool.IsSmall()) - return GDB_ID_NULL ; - // creo oggetto linea per DB geometrico - PtrOwner pLine( CreateCurveLine()) ; - if ( IsNull( pLine)) - return GDB_ID_NULL ; - // assegno le coordinate degli estremi - if ( ! pLine->Set( m_ptCurr, ptP)) - return GDB_ID_NULL ; - // inserisco l'oggetto nel DB geometrico - int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pLine)) ; - if ( nId == GDB_ID_NULL) - return GDB_ID_NULL ; - // creo oggetto dati Cam - PtrOwner pCam( new( nothrow) CamData) ; - if ( IsNull( pCam)) - return GDB_ID_NULL ; - // assegno valori - pCam->SetMoveType( 0) ; - pCam->SetToolDir( m_vtTool) ; - pCam->SetCorrDir( m_vtCorr) ; - pCam->SetAuxDir( m_vtAux) ; - pCam->SetEndPoint( ptP) ; - pCam->SetFeed( 0) ; - pCam->SetFlag( m_nFlag) ; - // associo questo oggetto a quello geometrico - m_pGeomDB->SetUserObj( nId, Release( pCam)) ; - // salvo la posizione corrente - m_ptCurr = ptP ; - return nId ; -} - -//---------------------------------------------------------------------------- -int -Operation::AddLinearMove( const Point3d& ptP) -{ - if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) - return GDB_ID_NULL ; - // verifico di essere in uno stato valido per un movimento lineare - if ( ! m_bCurr || m_vtTool.IsSmall()) { - LOG_INFO( GetEMkLogger(), "Error on LinearMove : Curr or ToolDir") - return GDB_ID_NULL ; + // Recupero macchina corrente + Machine* pMch = ( m_pMchMgr != nullptr ? m_pMchMgr->GetCurrMachine() : nullptr) ; + if ( pMch == nullptr) + return false ; + // Recupero tavola corrente + string sTable ; + if ( ! pMch->GetCurrTable( sTable)) + return false ; + // Recupero assi correnti + STRVECTOR vAxName ; + pMch->GetAllCurrAxesName( vAxName) ; + // il numero di assi deve essere costante + if ( vAxName.size() != vAxStart.size() || vAxName.size() != vAxEnd.size()) + return false ; + // Porto la macchina in home + pMch->ResetAllAxesPos() ; + // Elenco grezzi attivi + INTVECTOR vRawId ; + int nRawId = m_pMchMgr->GetFirstRawPart() ; + while ( nRawId != GDB_ID_NULL) { + if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) + vRawId.emplace_back( nRawId) ; + nRawId = m_pMchMgr->GetNextRawPart( nRawId) ; } - // se feed nulla, assegno il minimo e lo segnalo - if ( m_dFeed < FEED_MIN) { - m_dFeed = FEED_MIN ; - LOG_INFO( GetEMkLogger(), "Error on LinearMove : Min Feed") + // Aggancio pezzi attivi alla tavola corrente + for ( const auto nRawId : vRawId) + pMch->LinkRawPartToGroup( nRawId, sTable) ; + // Elenco bloccaggi attivi + INTVECTOR vFxtId ; + int nFxtId = m_pMchMgr->GetFirstFixture() ; + while ( nFxtId != GDB_ID_NULL) { + vFxtId.emplace_back( nFxtId) ; + nFxtId = m_pMchMgr->GetNextFixture( nFxtId) ; } - // creo oggetto linea per DB geometrico - PtrOwner pLine( CreateCurveLine()) ; - if ( IsNull( pLine)) - return GDB_ID_NULL ; - // assegno le coordinate degli estremi - if ( ! pLine->Set( m_ptCurr, ptP)) - return GDB_ID_NULL ; - // inserisco l'oggetto nel DB geometrico - int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pLine)) ; - if ( nId == GDB_ID_NULL) - return GDB_ID_NULL ; - // creo oggetto dati Cam - PtrOwner pCam( new( nothrow) CamData) ; - if ( IsNull( pCam)) - return GDB_ID_NULL ; - // assegno valori - pCam->SetMoveType( 1) ; - pCam->SetToolDir( m_vtTool) ; - pCam->SetCorrDir( m_vtCorr) ; - pCam->SetAuxDir( m_vtAux) ; - pCam->SetEndPoint( ptP) ; - pCam->SetFeed( m_dFeed) ; - pCam->SetFlag( m_nFlag) ; - // associo questo oggetto a quello geometrico - m_pGeomDB->SetUserObj( nId, Release( pCam)) ; - // salvo la posizione corrente - m_ptCurr = ptP ; - return nId ; -} + // Aggancio bloccaggi alla tavola corrente + for ( const auto nFxtId : vFxtId) + pMch->LinkFixtureToGroup( nFxtId, sTable) ; + // Vado nelle posizioni da controllare + bool bCollide = false ; + for ( int i = 1 ; i <= 3 && ! bCollide ; ++ i) { + double dCoeff = double( i) / 4 ; + for ( size_t j = 0 ; j < vAxStart.size() ; ++ j) { + double dPos = ( 1 - dCoeff) * vAxStart[j] + dCoeff * vAxEnd[j] ; + pMch->SetAxisPos( vAxName[j], dPos) ; + } + // Eseguo controllo + BBox3d b3Head ; + m_pGeomDB->GetGlobalBBox( pMch->GetCurrHead(), b3Head) ; + for ( const auto nRawId : vRawId) { + BBox3d b3Raw ; + int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; + if ( m_pGeomDB->GetGlobalBBox( nRawSolidId, b3Raw) && b3Head.Overlaps( b3Raw)) { + bCollide = true ; + break ; + } + } + for ( const auto nFxtId : vFxtId) { + BBox3d b3Fxt ; + if ( m_pGeomDB->GetGlobalBBox( nFxtId, b3Fxt) && b3Head.Overlaps( b3Fxt)) { + bCollide = true ; + break ; + } + } + //int nRes = 1 ; + //while ( nRes != 0) + // nRes = ExeProcessEvents( 0, 5) ; + } + // Riporto la macchina in home + pMch->ResetAllAxesPos() ; + // Sgancio grezzi e sottopezzi dalla tavola corrente + pMch->UnlinkAllRawPartsFromGroups() ; + pMch->UnlinkAllFixturesFromGroups() ; -//---------------------------------------------------------------------------- -int -Operation::AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, double dDeltaZ) -{ - if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) - return GDB_ID_NULL ; - // verifico di essere in uno stato valido per un movimento arco - if ( ! m_bCurr || m_vtTool.IsSmall()) { - LOG_INFO( GetEMkLogger(), "Error on ArcMove : Curr or ToolDir") - return GDB_ID_NULL ; - } - // se feed nulla, assegno il minimo e lo segnalo - if ( m_dFeed < FEED_MIN) { - m_dFeed = FEED_MIN ; - LOG_INFO( GetEMkLogger(), "Error on ArcMove : Min Feed") - } - // creo oggetto arco per DB geometrico - PtrOwner pArc( CreateCurveArc()) ; - if ( IsNull( pArc)) - return GDB_ID_NULL ; - // assegno i dati dell'arco - if ( ! pArc->SetCPA( ptCen, m_ptCurr, dAngCen, dDeltaZ)) - return GDB_ID_NULL ; - Point3d ptFin ; - if ( ! pArc->GetEndPoint( ptFin) || ! AreSamePointApprox( ptFin, ptP)) - return GDB_ID_NULL ; - int nMove = ( dAngCen > 0 ? 3 : 2) ; - // inserisco l'oggetto nel DB geometrico - int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pArc)) ; - if ( nId == GDB_ID_NULL) - return GDB_ID_NULL ; - // creo oggetto dati Cam - PtrOwner pCam( new( nothrow) CamData) ; - if ( IsNull( pCam)) - return GDB_ID_NULL ; - // assegno valori - pCam->SetMoveType( nMove) ; - pCam->SetToolDir( m_vtTool) ; - pCam->SetCorrDir( m_vtCorr) ; - pCam->SetAuxDir( m_vtAux) ; - pCam->SetEndPoint( ptP) ; - pCam->SetCenter( ptCen) ; - pCam->SetAngCen( dAngCen) ; - pCam->SetFeed( m_dFeed) ; - pCam->SetFlag( m_nFlag) ; - // associo questo oggetto a quello geometrico - m_pGeomDB->SetUserObj( nId, Release( pCam)) ; - // salvo la posizione corrente - m_ptCurr = ptP ; - return nId ; -} - -//---------------------------------------------------------------------------- -bool -Operation::ResetMoveData( void) -{ - m_bCurr = false ; - m_ptCurr = ORIG ; - m_vtTool = V_NULL ; - m_vtCorr = V_NULL ; - m_vtAux = V_NULL ; - m_dFeed = 0 ; - m_nFlag = 0 ; - return true ; + return ( ! bCollide) ; } diff --git a/Operation.h b/Operation.h index f07bf56..704c183 100644 --- a/Operation.h +++ b/Operation.h @@ -76,6 +76,7 @@ class Operation : public IUserObj bool AddHome( void) ; bool RemoveHome( void) ; bool CalcDeltaZForHeadRotation( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, double& dDeltaZ) ; + bool TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd) ; protected : int m_nOwnerId ; // identificativo dell'oggetto geometrico possessore @@ -96,7 +97,9 @@ class Operation : public IUserObj int AddRapidStart( const Point3d& ptP) ; int AddRapidMove( const Point3d& ptP) ; int AddLinearMove( const Point3d& ptP) ; - int AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, double dDeltaZ = 0) ; + int AddLinearMove( const Point3d& ptP, const std::string& sName) ; + int AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, const Vector3d& vtN) ; + int AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, const Vector3d& vtN, const std::string& sName) ; bool ResetMoveData( void) ; protected : diff --git a/OperationCL.cpp b/OperationCL.cpp new file mode 100644 index 0000000..f4eac2d --- /dev/null +++ b/OperationCL.cpp @@ -0,0 +1,294 @@ +//---------------------------------------------------------------------------- +// EgalTech 2016-2016 +//---------------------------------------------------------------------------- +// File : Operation.cpp Data : 29.05.16 Versione : 1.6r7 +// Contenuto : Implementazione gestione operazioni per CL. +// +// +// +// Modifiche : 29.05.16 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "DllMain.h" +#include "Operation.h" +#include "MachMgr.h" +#include "/EgtDev/Include/EGkGeoPoint3d.h" +#include "/EgtDev/Include/EGkCurveLine.h" +#include "/EgtDev/Include/EGkCurveArc.h" +#include "/EgtDev/Include/EGkGeomDB.h" +#include "/EgtDev/Include/EgtPointerOwner.h" + +using namespace std ; + +//---------------------------------------------------------------------------- +bool +Operation::SetPathId( int nPathId) +{ + m_nPathId = nPathId ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +Operation::SetToolDir( const Vector3d& vtDir) +{ + m_vtTool = vtDir ; + return ( m_vtTool.Normalize()) ; +} + +//---------------------------------------------------------------------------- +bool +Operation::SetCorrDir( const Vector3d& vtDir) +{ + m_vtCorr = vtDir ; + return ( ! m_vtCorr.IsSmall()) ; +} + +//---------------------------------------------------------------------------- +bool +Operation::SetAuxDir( const Vector3d& vtDir) +{ + m_vtAux = vtDir ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +Operation::SetCorrAuxDir( const Vector3d& vtDir) +{ + m_vtCorr = vtDir ; + m_vtAux = vtDir ; + return ( ! m_vtCorr.IsSmall()) ; +} + +//---------------------------------------------------------------------------- +bool +Operation::SetFeed( double dFeed) +{ + m_dFeed = dFeed ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +Operation::SetFlag( int nFlag) +{ + m_nFlag = nFlag ; + return true ; +} + +//---------------------------------------------------------------------------- +int +Operation::AddRapidStart( const Point3d& ptP) +{ + if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) + return GDB_ID_NULL ; + // verifico di essere in uno stato valido per inizio + if ( m_vtTool.IsSmall()) + return GDB_ID_NULL ; + // creo oggetto punto per DB geometrico + PtrOwner pGP( CreateGeoPoint3d()) ; + if ( IsNull( pGP)) + return GDB_ID_NULL ; + // assegno le coordinate del punto + pGP->Set( ptP) ; + // inserisco l'oggetto nel DB geometrico + int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pGP)) ; + if ( nId == GDB_ID_NULL) + return GDB_ID_NULL ; + // creo oggetto dati Cam + PtrOwner pCam( new( nothrow) CamData) ; + if ( IsNull( pCam)) + return GDB_ID_NULL ; + // assegno valori + pCam->SetMoveType( 0) ; + pCam->SetToolDir( m_vtTool) ; + pCam->SetCorrDir( m_vtCorr) ; + pCam->SetAuxDir( m_vtAux) ; + pCam->SetEndPoint( ptP) ; + pCam->SetFeed( 0) ; + pCam->SetFlag( m_nFlag) ; + // associo questo oggetto a quello geometrico + m_pGeomDB->SetUserObj( nId, Release( pCam)) ; + // salvo la posizione corrente + m_bCurr = true ; + m_ptCurr = ptP ; + return nId ; +} + +//---------------------------------------------------------------------------- +int +Operation::AddRapidMove( const Point3d& ptP) +{ + if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) + return GDB_ID_NULL ; + // verifico di essere in uno stato valido per un movimento in rapido + if ( ! m_bCurr || m_vtTool.IsSmall()) + return GDB_ID_NULL ; + // creo oggetto linea per DB geometrico + PtrOwner pLine( CreateCurveLine()) ; + if ( IsNull( pLine)) + return GDB_ID_NULL ; + // assegno le coordinate degli estremi + if ( ! pLine->Set( m_ptCurr, ptP)) + return GDB_ID_NULL ; + // inserisco l'oggetto nel DB geometrico + int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pLine)) ; + if ( nId == GDB_ID_NULL) + return GDB_ID_NULL ; + // creo oggetto dati Cam + PtrOwner pCam( new( nothrow) CamData) ; + if ( IsNull( pCam)) + return GDB_ID_NULL ; + // assegno valori + pCam->SetMoveType( 0) ; + pCam->SetToolDir( m_vtTool) ; + pCam->SetCorrDir( m_vtCorr) ; + pCam->SetAuxDir( m_vtAux) ; + pCam->SetEndPoint( ptP) ; + pCam->SetFeed( 0) ; + pCam->SetFlag( m_nFlag) ; + // associo questo oggetto a quello geometrico + m_pGeomDB->SetUserObj( nId, Release( pCam)) ; + // salvo la posizione corrente + m_ptCurr = ptP ; + return nId ; +} + +//---------------------------------------------------------------------------- +int +Operation::AddLinearMove( const Point3d& ptP) +{ + if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) + return GDB_ID_NULL ; + // verifico di essere in uno stato valido per un movimento lineare + if ( ! m_bCurr || m_vtTool.IsSmall()) { + LOG_INFO( GetEMkLogger(), "Error on LinearMove : Curr or ToolDir") + return GDB_ID_NULL ; + } + // se feed nulla, assegno il minimo e lo segnalo + if ( m_dFeed < FEED_MIN) { + m_dFeed = FEED_MIN ; + LOG_INFO( GetEMkLogger(), "Error on LinearMove : Min Feed") + } + // creo oggetto linea per DB geometrico + PtrOwner pLine( CreateCurveLine()) ; + if ( IsNull( pLine)) + return GDB_ID_NULL ; + // assegno le coordinate degli estremi + if ( ! pLine->Set( m_ptCurr, ptP)) + return GDB_ID_NULL ; + // inserisco l'oggetto nel DB geometrico + int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pLine)) ; + if ( nId == GDB_ID_NULL) + return GDB_ID_NULL ; + // creo oggetto dati Cam + PtrOwner pCam( new( nothrow) CamData) ; + if ( IsNull( pCam)) + return GDB_ID_NULL ; + // assegno valori + pCam->SetMoveType( 1) ; + pCam->SetToolDir( m_vtTool) ; + pCam->SetCorrDir( m_vtCorr) ; + pCam->SetAuxDir( m_vtAux) ; + pCam->SetEndPoint( ptP) ; + pCam->SetFeed( m_dFeed) ; + pCam->SetFlag( m_nFlag) ; + // associo questo oggetto a quello geometrico + m_pGeomDB->SetUserObj( nId, Release( pCam)) ; + // salvo la posizione corrente + m_ptCurr = ptP ; + return nId ; +} + +//---------------------------------------------------------------------------- +int +Operation::AddLinearMove( const Point3d& ptP, const string& sName) +{ + int nId = AddLinearMove( ptP) ; + if ( nId != GDB_ID_NULL) + m_pGeomDB->SetName( nId, sName) ; + return nId ; +} + +//---------------------------------------------------------------------------- +int +Operation::AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, const Vector3d& vtN) +{ + if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) + return GDB_ID_NULL ; + // verifico di essere in uno stato valido per un movimento arco + if ( ! m_bCurr || m_vtTool.IsSmall()) { + LOG_INFO( GetEMkLogger(), "Error on ArcMove : Curr or ToolDir") + return GDB_ID_NULL ; + } + // se feed nulla, assegno il minimo e lo segnalo + if ( m_dFeed < FEED_MIN) { + m_dFeed = FEED_MIN ; + LOG_INFO( GetEMkLogger(), "Error on ArcMove : Min Feed") + } + // creo oggetto arco per DB geometrico + PtrOwner pArc( CreateCurveArc()) ; + if ( IsNull( pArc)) + return GDB_ID_NULL ; + // assegno i dati dell'arco + double dDeltaZ = ( ptP - ptCen) * vtN ; + if ( ! pArc->SetCPAN( ptCen, m_ptCurr, dAngCen, dDeltaZ, vtN)) + return GDB_ID_NULL ; + Point3d ptFin ; + if ( ! pArc->GetEndPoint( ptFin) || ! AreSamePointApprox( ptFin, ptP)) + return GDB_ID_NULL ; + int nMove = ( dAngCen > 0 ? 3 : 2) ; + // inserisco l'oggetto nel DB geometrico + int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pArc)) ; + if ( nId == GDB_ID_NULL) + return GDB_ID_NULL ; + // creo oggetto dati Cam + PtrOwner pCam( new( nothrow) CamData) ; + if ( IsNull( pCam)) + return GDB_ID_NULL ; + // assegno valori + pCam->SetMoveType( nMove) ; + pCam->SetToolDir( m_vtTool) ; + pCam->SetCorrDir( m_vtCorr) ; + pCam->SetAuxDir( m_vtAux) ; + pCam->SetEndPoint( ptP) ; + pCam->SetCenter( ptCen) ; + pCam->SetAngCen( dAngCen) ; + pCam->SetNormDir( vtN) ; + pCam->SetFeed( m_dFeed) ; + pCam->SetFlag( m_nFlag) ; + // associo questo oggetto a quello geometrico + m_pGeomDB->SetUserObj( nId, Release( pCam)) ; + // salvo la posizione corrente + m_ptCurr = ptP ; + return nId ; +} + +//---------------------------------------------------------------------------- +int +Operation::AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, const Vector3d& vtN, const string& sName) +{ + int nId = AddArcMove( ptP, ptCen, dAngCen, vtN) ; + if ( nId != GDB_ID_NULL) + m_pGeomDB->SetName( nId, sName) ; + return nId ; +} + +//---------------------------------------------------------------------------- +bool +Operation::ResetMoveData( void) +{ + m_bCurr = false ; + m_ptCurr = ORIG ; + m_vtTool = V_NULL ; + m_vtCorr = V_NULL ; + m_vtAux = V_NULL ; + m_dFeed = 0 ; + m_nFlag = 0 ; + return true ; +} diff --git a/Sawing.cpp b/Sawing.cpp index fbc5564..0019fa9 100644 --- a/Sawing.cpp +++ b/Sawing.cpp @@ -1916,12 +1916,13 @@ Sawing::GenerateExtArcCl( const ICurveArc* pArc, const Vector3d& vtStaTool, cons SetFeed( GetFeed()) ; Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; // se angolo al centro minore del limite, un solo arco if ( abs( dAngCen) < MAX_ANG_CEN) { SetToolDir( vtEndTool) ; - if ( AddArcMove( ptP3, ptCen, dAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti due archi @@ -1930,11 +1931,11 @@ Sawing::GenerateExtArcCl( const ICurveArc* pArc, const Vector3d& vtStaTool, cons pArc->GetMidPoint( ptMid) ; // prima metà arco SetToolDir( vtMidTool) ; - if ( AddArcMove( ptMid, ptCen, dAngCen / 2) == GDB_ID_NULL) + if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL) return false ; // seconda metà arco SetToolDir( vtEndTool) ; - if ( AddArcMove( ptP3, ptCen, dAngCen / 2) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL) return false ; } // 4 -> retrazione @@ -1985,11 +1986,12 @@ Sawing::GenerateExtArcCl( const ICurveArc* pArc, const Vector3d& vtStaTool, cons SetFeed( GetFeed()) ; Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; // se angolo al centro minore del limite, un solo arco if ( abs( dAngCen) < MAX_ANG_CEN) { double dCurrAngCen = dAngCen * ((( i % 2) == 0) ? -1 : 1) ; SetToolDir( ( ( i % 2) == 0) ? vtStaTool : vtEndTool) ; - if ( AddArcMove( ptP3, ptCen, dCurrAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti due archi @@ -2000,11 +2002,11 @@ Sawing::GenerateExtArcCl( const ICurveArc* pArc, const Vector3d& vtStaTool, cons double dCurrAngCen = dAngCen / 2 * ((( i % 2) == 0) ? -1 : 1) ; // prima metà arco SetToolDir( vtMidTool) ; - if ( AddArcMove( ptMid, ptCen, dCurrAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptMid, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; // seconda metà arco SetToolDir( ( ( i % 2) == 0) ? vtStaTool : vtEndTool) ; - if ( AddArcMove( ptP3, ptCen, dCurrAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } @@ -2046,13 +2048,14 @@ Sawing::GenerateExtArcCl( const ICurveArc* pArc, const Vector3d& vtStaTool, cons SetFeed( GetFeed()) ; Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 += vtCorr * dDelta ; // se angolo al centro minore del limite, un solo arco if ( abs( dAngCen) < MAX_ANG_CEN) { SetToolDir( vtEndTool) ; - if ( AddArcMove( ptP3, ptCen, dAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti due archi @@ -2062,11 +2065,11 @@ Sawing::GenerateExtArcCl( const ICurveArc* pArc, const Vector3d& vtStaTool, cons ptMid += vtCorr * dDelta ; // prima metà arco SetToolDir( vtMidTool) ; - if ( AddArcMove( ptMid, ptCen, dAngCen / 2) == GDB_ID_NULL) + if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL) return false ; // seconda metà arco SetToolDir( vtEndTool) ; - if ( AddArcMove( ptP3, ptCen, dAngCen / 2) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL) return false ; } // se non è ultimo passo @@ -2544,13 +2547,14 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc, SetFeed( GetFeed()) ; Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; // se angolo al centro minore del limite, un solo arco if ( abs( pArc->GetAngCenter()) < MAX_ANG_CEN) { SetToolDir( vtEndTool) ; SetCorrAuxDir( vtEndCorr) ; - if ( AddArcMove( ptP3, ptCen, dAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti due archi @@ -2560,12 +2564,12 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc, // prima metà arco SetToolDir( vtMidTool) ; SetCorrAuxDir( vtMidCorr) ; - if ( AddArcMove( ptMid, ptCen, dAngCen / 2) == GDB_ID_NULL) + if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL) return false ; // seconda metà arco SetToolDir( vtEndTool) ; SetCorrAuxDir( vtEndCorr) ; - if ( AddArcMove( ptP3, ptCen, dAngCen / 2) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL) return false ; } // 4 -> retrazione @@ -2618,12 +2622,13 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc, SetFeed( GetFeed()) ; Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; // se angolo al centro minore del limite, un solo arco if ( abs( dAngCen) < MAX_ANG_CEN) { double dCurrAngCen = dAngCen * ((( i % 2) == 0) ? -1 : 1) ; SetToolDir( ( ( i % 2) == 0) ? vtStaTool : vtEndTool) ; SetCorrAuxDir( ( ( i % 2) == 0) ? vtStaCorr : vtEndCorr) ; - if ( AddArcMove( ptP3, ptCen, dCurrAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti due archi @@ -2635,12 +2640,12 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc, // prima metà arco SetToolDir( vtMidTool) ; SetCorrAuxDir( vtMidCorr) ; - if ( AddArcMove( ptMid, ptCen, dCurrAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptMid, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; // seconda metà arco SetToolDir( ( ( i % 2) == 0) ? vtStaTool : vtEndTool) ; SetCorrAuxDir( ( ( i % 2) == 0) ? vtStaCorr : vtEndCorr) ; - if ( AddArcMove( ptP3, ptCen, dCurrAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } @@ -2685,6 +2690,7 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc, SetFeed( GetFeed()) ; Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; + Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 += Z_AX * dDelta ; @@ -2692,7 +2698,7 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc, if ( abs( dAngCen) < MAX_ANG_CEN) { SetToolDir( vtEndTool) ; SetCorrAuxDir( vtEndCorr) ; - if ( AddArcMove( ptP3, ptCen, dAngCen) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti due archi @@ -2703,12 +2709,12 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc, // prima metà arco SetToolDir( vtMidTool) ; SetCorrAuxDir( vtMidCorr) ; - if ( AddArcMove( ptMid, ptCen, dAngCen / 2) == GDB_ID_NULL) + if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL) return false ; // seconda metà arco SetToolDir( vtEndTool) ; SetCorrAuxDir( vtEndCorr) ; - if ( AddArcMove( ptP3, ptCen, dAngCen / 2) == GDB_ID_NULL) + if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL) return false ; } // se non è ultimo passo diff --git a/Simulator.cpp b/Simulator.cpp index 2e810b3..d1fdf98 100644 --- a/Simulator.cpp +++ b/Simulator.cpp @@ -434,10 +434,10 @@ Simulator::GoHome( void) // controllo validità stato if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr || m_pMachine == nullptr) return false ; - // reset stato macchina - OnResetMachine() ; // porto la macchina in home m_pMchMgr->ResetAllAxesPos() ; + // reset stato macchina + OnResetMachine() ; // assegno valori home degli assi macchina attivi return m_pMchMgr->GetAllCalcAxesHomePos( m_AxesVal) ; } @@ -449,10 +449,10 @@ Simulator::Stop( void) // controllo validità stato if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr || m_pMachine == nullptr) return false ; - // reset stato macchina - OnResetMachine() ; // porto la macchina in home m_pMchMgr->ResetAllAxesPos() ; + // reset stato macchina + OnResetMachine() ; // rimuovo tavola variabili globali m_pMachine->LuaResetGlobVar( GLOB_VAR) ; // reset dello stato