//---------------------------------------------------------------------------- // EgalTech 2015-2019 //---------------------------------------------------------------------------- // File : SawRoughing.cpp Data : 23.04.19 Versione : 2.1d3 // Contenuto : Implementazione gestione sgrossatura superficie con lama. // // Note : Questa lavorazione è sempre espressa nel riferimento globale. // // Modifiche : 30.03.16 DS Creazione modulo. // 23.04.19 DS Aggiunte cornici curve. // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "MachMgr.h" #include "DllMain.h" #include "SawRoughing.h" #include "OperationConst.h" #include "GeoConst.h" #include "/EgtDev/Include/EXeCmdLogOff.h" #include "/EgtDev/Include/EXeConst.h" #include "/EgtDev/Include/EGkCurveLine.h" #include "/EgtDev/Include/EGkCurveArc.h" #include "/EgtDev/Include/EGkCurveComposite.h" #include "/EgtDev/Include/EGkOffsetCurve.h" #include "/EgtDev/Include/EGkOffsetCurveOnX.h" #include "/EgtDev/Include/EGkSfrCreate.h" #include "/EgtDev/Include/EGkIntervals.h" #include "/EgtDev/Include/EGkUserObjFactory.h" #include "/EgtDev/Include/EGnStringKeyVal.h" #include "/EgtDev/Include/EgtPointerOwner.h" // per far dimenticare macro di WinUser.h #undef GetClassName using namespace std ; //------------------------------ Errors -------------------------------------- // 2601 = "Error in SawRoughing : UpdateToolData failed" // 2602 = "Error in SawRoughing : AdjustGeometry failed" // 2603 = "Error in SawRoughing : Guide Line not along X or Y" // 2604 = "Error in SawRoughing : Empty RawBox" // 2605 = "Error in SawRoughing : OffsetCurve" // 2606 = "Error in SawRoughing : OffsetCurveOnX" // 2607 = "Error in SawRoughing : Depth not computable" // 2608 = "Error in SawRoughing : CalculateToolAndCorrVersors" // 2609 = "Error in SawRoughing : GetElevation" // 2610 = "Error in SawRoughing : TrimSection failed" // 2611 = "Error in SawRoughing : axes values not calculable" // 2612 = "Error in SawRoughing : outstroke xxx" // 2613 = "Error in SawRoughing : link movements not calculable" // 2614 = "Error in SawRoughing : link outstroke xxx" // 2615 = "Error in SawRoughing : post apply not calculable" // 2651 = "Warning in SawRoughing : Skipped entity (xx)" // 2652 = "Warning in SawRoughing : No machinable path" // 2653 = "Warning in SawRoughing : Tool name changed (xx)" // 2654 = "Warning in SawRoughing : Tool data changed (xx)" //---------------------------------------------------------------------------- const string MCH_SECTION = "Sect" ; const string MCH_GUIDE = "Guide" ; //---------------------------------------------------------------------------- USEROBJ_REGISTER( GetOperationClass( OPER_SAWROUGHING), SawRoughing) ; //---------------------------------------------------------------------------- const string& SawRoughing::GetClassName( void) const { return USEROBJ_GETNAME( SawRoughing) ; } //---------------------------------------------------------------------------- SawRoughing* SawRoughing::Clone( void) const { // alloco oggetto SawRoughing* pSaw = new(nothrow) SawRoughing ; // eseguo copia dei dati if ( pSaw != nullptr) { try { pSaw->m_vId = m_vId ; pSaw->m_bStraight = m_bStraight ; pSaw->m_pMchMgr = m_pMchMgr ; pSaw->m_nPhase = m_nPhase ; pSaw->m_Params = m_Params ; pSaw->m_TParams = m_TParams ; pSaw->m_nStatus = m_nStatus ; pSaw->m_nCuts = m_nCuts ; } catch( ...) { delete pSaw ; return nullptr ; } } // ritorno l'oggetto return pSaw ; } //---------------------------------------------------------------------------- bool SawRoughing::Dump( string& sOut, bool bMM, const char* szNewLine) const { sOut += GetClassName() + "[mm]" + szNewLine ; sOut += KEY_PHASE + EQUAL + ToString( m_nPhase) + szNewLine ; sOut += KEY_IDS + EQUAL + ToString( m_vId) + szNewLine ; sOut += KEY_STRAIGHT + EQUAL + ToString( m_bStraight) + szNewLine ; for ( int i = 0 ; i < m_Params.GetSize() ; ++ i) sOut += m_Params.ToString( i) + szNewLine ; for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) sOut += m_TParams.ToString( i) + szNewLine ; sOut += KEY_NUM + EQUAL + ToString( m_nCuts) + szNewLine ; sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::Save( int nBaseId, STRVECTOR& vString) const { try { int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 4 ; vString.insert( vString.begin(), nSize, "") ; int k = - 1 ; if ( ! SetVal( KEY_IDS, m_vId, vString[++k])) return false ; for ( int i = 0 ; i < m_Params.GetSize() ; ++ i) vString[++k] = m_Params.ToString( i) ; for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) vString[++k] = m_TParams.ToString( i) ; if ( ! SetVal( KEY_PHASE, m_nPhase, vString[++k])) return false ; if ( ! SetVal( KEY_NUM, m_nCuts, vString[++k])) return false ; if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k])) return false ; if ( ! SetVal( KEY_STRAIGHT, m_bStraight, vString[++k])) return false ; } catch( ...) { return false ; } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::Load( const STRVECTOR& vString, int nBaseGdbId) { int nSize = int( vString.size()) ; // lista identificativi geometrie da lavorare int k = - 1 ; if ( k >= nSize - 1 || ! GetVal( vString[++k], KEY_IDS, m_vId)) return false ; for ( auto& Sel : m_vId) Sel.nId += nBaseGdbId ; // parametri lavorazione for ( int i = 0 ; i < m_Params.GetSize() ; ++ i) { int nKey ; if ( k >= nSize - 1 || ! m_Params.FromString( vString[++k], nKey) || nKey != i) { if ( m_Params.IsOptional( i)) -- k ; else return false ; } } // parametri utensile for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) { int nKey ; if ( k >= nSize - 1 || ! m_TParams.FromString( vString[++k], nKey) || nKey != i) return false ; } // parametri di stato while ( k < nSize - 1) { // separo chiave da valore string sKey, sVal ; SplitFirst( vString[++k], "=", sKey, sVal) ; // leggo if ( sKey == KEY_PHASE) { if ( ! FromString( sVal, m_nPhase)) return false ; } else if ( sKey == KEY_NUM) { if ( ! FromString( sVal, m_nCuts)) return false ; } else if ( sKey == KEY_STAT) { if ( ! FromString( sVal, m_nStatus)) return false ; } else if ( sKey == KEY_STRAIGHT) { if ( ! FromString( sVal, m_bStraight)) return false ; } } return true ; } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- SawRoughing::SawRoughing( void) { m_Params.m_sName = "*" ; m_Params.m_sToolName = "*" ; m_TParams.m_sName = "*" ; m_TParams.m_sHead = "*" ; m_nStatus = MCH_ST_TO_VERIFY ; m_nCuts = 0 ; m_bStraight = true ; } //---------------------------------------------------------------------------- bool SawRoughing::Prepare( const string& sSawName) { // verifico il gestore lavorazioni if ( m_pMchMgr == nullptr) return false ; // recupero il gestore DB utensili della macchina corrente ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ; if ( pTMgr == nullptr) return false ; // recupero il gestore DB lavorazioni della macchina corrente MachiningsMgr* pMMgr = m_pMchMgr->GetCurrMachiningsMgr() ; if ( pMMgr == nullptr) return false ; // ricerca della lavorazione di libreria con il nome indicato const SawRoughingData* pDdata = GetSawRoughingData( pMMgr->GetMachining( sSawName)) ; if ( pDdata == nullptr) return false ; m_Params = *pDdata ; // ricerca dell'utensile usato dalla lavorazione const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ; if ( pTdata == nullptr) return false ; m_TParams = *pTdata ; m_Params.m_sToolName = m_TParams.m_sName ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::SetParam( int nType, bool bVal) { //switch ( nType) { //} return false ; } //---------------------------------------------------------------------------- bool SawRoughing::SetParam( int nType, int nVal) { switch ( nType) { case MPA_HEADSIDE : if ( ! m_Params.VerifyHeadSide( nVal)) return false ; if ( nVal != m_Params.m_nHeadSide) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nHeadSide = nVal ; return true ; case MPA_STEPTYPE : if ( ! m_Params.VerifyStepType( nVal)) return false ; if ( nVal != m_Params.m_nStepType) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nStepType = nVal ; return true ; case MPA_LEADLINKTYPE : if ( ! m_Params.VerifyLeadLinkType( nVal)) return false ; if ( nVal != m_Params.m_nLeadLinkType) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nLeadLinkType = nVal ; return true ; case MPA_SCC : if ( ! m_Params.VerifySolCh( nVal)) return false ; if ( nVal != m_Params.m_nSolCh) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nSolCh = nVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawRoughing::SetParam( int nType, double dVal) { switch ( nType) { case MPA_SPEED : if ( ! m_TParams.VerifySpeed( dVal)) return false ; if ( AreSameAngValue( dVal, m_TParams.m_dSpeed)) dVal = 0 ; if ( ! AreSameAngValue( dVal, m_Params.m_dSpeed)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dSpeed = dVal ; return true ; case MPA_FEED : if ( AreSameLenValue( dVal, m_TParams.m_dFeed)) dVal = 0 ; if ( ! AreSameLenValue( dVal, m_Params.m_dFeed)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dFeed = dVal ; return true ; case MPA_STARTFEED : if ( AreSameLenValue( dVal, m_TParams.m_dStartFeed)) dVal = 0 ; if ( ! AreSameLenValue( dVal, m_Params.m_dStartFeed)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dStartFeed = dVal ; return true ; case MPA_ENDFEED : if ( AreSameLenValue( dVal, m_TParams.m_dEndFeed)) dVal = 0 ; if ( ! AreSameLenValue( dVal, m_Params.m_dEndFeed)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dEndFeed = dVal ; return true ; case MPA_TIPFEED : if ( AreSameLenValue( dVal, m_TParams.m_dTipFeed)) dVal = 0 ; if ( ! AreSameLenValue( dVal, m_Params.m_dTipFeed)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dTipFeed = dVal ; return true ; case MPA_OFFSR : if ( AreSameLenValue( dVal, m_TParams.m_dOffsR)) dVal = UNKNOWN_PAR ; if ( ! AreSameLenValue( dVal, m_Params.m_dOffsR)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dOffsR = dVal ; return true ; case MPA_OFFSL : if ( AreSameLenValue( dVal, m_TParams.m_dOffsL)) dVal = UNKNOWN_PAR ; if ( ! AreSameLenValue( dVal, m_Params.m_dOffsL)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dOffsL = dVal ; return true ; case MPA_DEPTH: { string sVal = ToString( dVal) ; if ( sVal != m_Params.m_sDepth) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_sDepth = sVal ; } return true ; case MPA_STARTPOS : if ( ! AreSameLenValue( dVal, m_Params.m_dStartPos)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dStartPos = dVal ; return true ; case MPA_SIDESTEP : if ( ! AreSameLenValue( dVal, m_Params.m_dSideStep)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dSideStep = dVal ; return true ; case MPA_STEP : if ( ! AreSameLenValue( dVal, m_Params.m_dStep)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dStep = dVal ; return true ; case MPA_APPROX : if ( ! AreSameLenValue( dVal, m_Params.m_dApprox)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dApprox = dVal ; return true ; case MPA_STARTADDLEN : if ( ! AreSameLenValue( dVal, m_Params.m_dStartAddLen)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dStartAddLen = dVal ; return true ; case MPA_ENDADDLEN : if ( ! AreSameLenValue( dVal, m_Params.m_dEndAddLen)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dEndAddLen = dVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawRoughing::SetParam( int nType, const string& sVal) { switch ( nType) { case MPA_TOOL : { const ToolData* pTdata ; if ( ! m_Params.VerifyTool( m_pMchMgr->GetCurrToolsMgr(), sVal, pTdata)) return false ; if ( ! SameTool( m_TParams, *pTdata)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_sToolName = sVal ; m_Params.m_ToolUuid = pTdata->m_Uuid ; m_TParams = *pTdata ; } return true ; case MPA_DEPTH_STR : if ( sVal != m_Params.m_sDepth) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_sDepth = sVal ; return true ; case MPA_SYSNOTES : if ( sVal != m_Params.m_sSysNotes) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_sSysNotes = sVal ; return true ; case MPA_USERNOTES : if ( sVal != m_Params.m_sUserNotes) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_sUserNotes = sVal ; return true ; case MPA_INITANGS : if ( sVal != m_Params.m_sInitAngs) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_sInitAngs = sVal ; return true ; case MPA_BLOCKEDAXIS : if ( sVal != m_Params.m_sBlockedAxis) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_sBlockedAxis = sVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawRoughing::SetGeometry( const SELVECTOR& vIds) { // 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 sInfo = "Warning in SawRoughing : Skipped entity " + ToString( Id) ; m_pMchMgr->SetWarning( 2651, sInfo) ; continue ; } // posso aggiungere alla lista m_vId.emplace_back( Id) ; } // aggiorno lo stato m_nStatus |= MCH_ST_GEO_MODIF ; // restituisco presenza geometria da lavorare return ( ! m_vId.empty()) ; } //---------------------------------------------------------------------------- bool SawRoughing::Preview( bool bRecalc) { // non esiste preview, si fa apply return Apply( bRecalc, false) ; } //---------------------------------------------------------------------------- bool SawRoughing::Apply( bool bRecalc, bool bPostApply) { // reset numero tagli nella lavorazione int nCurrCuts = m_nCuts ; m_nCuts = 0 ; // verifico validità gestore DB geometrico e Id del gruppo if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId)) return false ; // aggiorno dati geometrici dell'utensile bool bToolChanged = true ; if ( ! UpdateToolData( &bToolChanged)) { m_pMchMgr->SetLastError( 2601, "Error in SawRoughing : UpdateToolData failed") ; return false ; } // verifico se necessario continuare nell'aggiornamento if ( ! bRecalc && ! bToolChanged && ( m_nStatus == MCH_ST_OK || ( ! bPostApply && m_nStatus == MCH_ST_NO_POSTAPPL))) { // confermo i percorsi di lavorazione m_nCuts = nCurrCuts ; LOG_DBG_INFO( GetEMkLogger(), "SawRoughing apply skipped : status already ok") ; // eseguo aggiornamento assi macchina e collegamento con operazione precedente if ( ! Update( bPostApply)) return false ; LOG_DBG_INFO( GetEMkLogger(), "Update done") ; // esco con successo return true ; } m_nStatus = MCH_ST_TO_VERIFY ; // recupero gruppo per geometria ausiliaria int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ; // 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) ; bRecalc = true ; } // altrimenti, se chiesto ricalcolo, lo svuoto else if ( bRecalc) { m_pGeomDB->EmptyGroup( nAuxId) ; } // se necessario, preparo geometria e la inserisco sotto la geometria ausiliaria if ( bRecalc && ! AdjustGeometry( nAuxId)) { m_pMchMgr->SetLastError( 2602, "Error in SawRoughing : AdjustGeometry failed") ; 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) ; // calcolo le passate if ( m_bStraight) { if ( ! CalculateToolPath( nAuxId, nClId)) return false ; } else { if ( ! CalculateCurvedToolPath( nAuxId, nClId)) return false ; } m_nCuts = 1 ; // assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso CalcAndSetBBox( nClId) ; // eseguo aggiornamento assi macchina e collegamento con operazione precedente if ( ! Update( bPostApply)) return false ; // aggiorno stato della lavorazione m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ; // dichiaro successiva da aggiornare UpdateFollowingOperationsStatus( MCH_ST_OTH_MODIF) ; LOG_DBG_INFO( GetEMkLogger(), "SawRoughing apply done") ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::Update( bool bPostApply) { // verifico validità gestore DB geometrico e Id del gruppo if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId)) return false ; // se lavorazione vuota, esco if ( m_nCuts == 0) { m_pMchMgr->SetWarning( 2652, "Warning in SawRoughing : No machinable path") ; return true ; } // imposto eventuale asse bloccato da lavorazione SetBlockedRotAxis( m_Params.m_sBlockedAxis) ; // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; if ( ! m_Params.m_sInitAngs.empty()) sHint = m_Params.m_sInitAngs ; if ( ! CalculateAxesValues( sHint)) { string sInfo = m_pMchMgr->GetOutstrokeInfo() ; if ( sInfo.empty()) m_pMchMgr->SetLastError( 2611, "Error in SawRoughing : axes values not calculable") ; else m_pMchMgr->SetLastError( 2612, "Error in SawRoughing : outstroke ") ; return false ; } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione if ( ! AdjustStartEndMovements()) { string sInfo = m_pMchMgr->GetOutstrokeInfo() ; if ( sInfo.empty()) m_pMchMgr->SetLastError( 2613, "Error in SawRoughing : link movements not calculable") ; else m_pMchMgr->SetLastError( 2614, "Error in SawRoughing : link outstroke ") ; return false ; } // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso CalcAndSetAxesBBox() ; // esecuzione eventuali personalizzazioni string sErr ; if ( bPostApply && ! PostApply( sErr)) { if ( ! IsEmptyOrSpaces( sErr)) m_pMchMgr->SetLastError( 2615, sErr) ; else m_pMchMgr->SetLastError( 2615, "Error in SawRoughing : post apply not calculable") ; return false ; } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::GetParam( int nType, bool& bVal) const { //switch ( nType) { //} bVal = false ; return false ; } //---------------------------------------------------------------------------- bool SawRoughing::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_TYPE : nVal = MT_SAWROUGHING ; return true ; case MPA_HEADSIDE : nVal = m_Params.m_nHeadSide ; return true ; case MPA_STEPTYPE : nVal = m_Params.m_nStepType ; return true ; case MPA_LEADLINKTYPE : nVal = m_Params.m_nLeadLinkType ; return true ; case MPA_SCC : nVal = m_Params.m_nSolCh ; return true ; } nVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SawRoughing::GetParam( int nType, double& dVal) const { switch ( nType) { case MPA_SPEED : dVal = GetSpeed() ; return true ; case MPA_FEED : dVal = GetFeed() ; return true ; case MPA_STARTFEED : dVal = GetStartFeed() ; return true ; case MPA_ENDFEED : dVal = GetEndFeed() ; return true ; case MPA_TIPFEED : dVal = GetTipFeed() ; return true ; case MPA_OFFSR : dVal =GetOffsR() ; return true ; case MPA_OFFSL : dVal = GetOffsL() ; return true ; case MPA_STARTPOS : dVal = m_Params.m_dStartPos ; return true ; case MPA_SIDESTEP : dVal = m_Params.m_dSideStep ; return true ; case MPA_STEP : dVal = m_Params.m_dStep ; return true ; case MPA_APPROX : dVal = m_Params.m_dApprox ; return true ; case MPA_STARTADDLEN : dVal = m_Params.m_dStartAddLen ; return true ; case MPA_ENDADDLEN : dVal = m_Params.m_dEndAddLen ; return true ; } dVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SawRoughing::GetParam( int nType, string& sVal) const { switch ( nType) { case MPA_NAME : sVal = m_Params.m_sName ; return true ; case MPA_TOOL : sVal = m_Params.m_sToolName ; return true ; case MPA_DEPTH_STR : sVal = m_Params.m_sDepth ; return true ; case MPA_TUUID : sVal = ToString( m_Params.m_ToolUuid) ; return true ; case MPA_UUID : sVal = ToString( m_Params.m_Uuid) ; return true ; case MPA_SYSNOTES : sVal = m_Params.m_sSysNotes ; return true ; case MPA_USERNOTES : sVal = m_Params.m_sUserNotes ; return true ; case MPA_INITANGS : sVal = m_Params.m_sInitAngs ; return true ; case MPA_BLOCKEDAXIS : sVal = m_Params.m_sBlockedAxis ; return true ; } sVal = "" ; return false ; } //---------------------------------------------------------------------------- const ToolData& SawRoughing::GetToolData( void) const { return m_TParams ; } //---------------------------------------------------------------------------- bool SawRoughing::UpdateToolData( bool* pbChanged) { // recupero il gestore DB utensili della macchina corrente ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ; if ( pTMgr == nullptr) return false ; // recupero l'utensile nel DB utensili const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ; if ( pTdata == nullptr) return false ; // verifico se sono diversi (ad esclusione del nome) m_TParams.m_sName = pTdata->m_sName ; bool bChanged = ! SameTool( m_TParams, *pTdata) ; // aggiorno comunque i parametri m_TParams = *pTdata ; // eventuali segnalazioni if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) { string sInfo = "Warning in SawRoughing : tool name changed (" + m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ; m_pMchMgr->SetWarning( 2653, sInfo) ; m_Params.m_sToolName = m_TParams.m_sName ; } if ( bChanged) { string sInfo = "Warning in SawRoughing : tool data changed (" + m_Params.m_sToolName + ")" ; m_pMchMgr->SetWarning( 2654, sInfo) ; } // se definito parametro di ritorno, lo assegno if ( pbChanged != nullptr) *pbChanged = bChanged ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::GetGeometry( SELVECTOR& vIds) const { // restituisco l'elenco delle entità vIds = m_vId ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const { // compenso il raggio dell'utensile ptP += pCamData->GetCorrDir() * ( m_TParams.m_dDiam / 2) ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::VerifyGeometry( SelData Id, int& nSubs) { // ammessi : curve o superfici // per ora accetto solo curve const ICurve* pCurve = nullptr ; const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ; // se direttamente la curva if ( Id.nSub == SEL_SUB_ALL) { pCurve = ::GetCurve( pGObj) ; if ( pCurve != nullptr) { if ( pCurve->GetType() == CRV_COMPO) nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ; else nSubs = 0 ; } } // altrimenti sottocurva di composita else { const ICurveComposite* pCompo = GetCurveComposite( pGObj) ; if ( pCompo != nullptr) pCurve = pCompo->GetCurve( Id.nSub) ; nSubs = 0 ; } return ( pCurve != nullptr) ; } //---------------------------------------------------------------------------- ICurve* SawRoughing::GetCurve( SelData Id) { // ammessi : curve o facce di polymesh // nel caso di facce si deve recuperare la linea di base // per ora accetto solo curve PtrOwner pCurve ; // se direttamente curva if ( Id.nSub == SEL_SUB_ALL) { // recupero e duplico la curva const ICurve* pOriCurve = ::GetCurve( m_pGeomDB->GetGeoObj( Id.nId)) ; if ( pOriCurve != nullptr) pCurve.Set( pOriCurve->Clone()) ; } // altrimenti sottocurva di composita else { // recupero la composita const ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( Id.nId)) ; if ( pCompo != nullptr) { // duplico la curva semplice const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ; if ( pOriCurve != nullptr) { pCurve.Set( pOriCurve->Clone()) ; // recupero estrusione e spessore Vector3d vtExtr ; if ( pCompo->GetExtrusion( vtExtr)) pCurve->SetExtrusion( vtExtr) ; double dThick ; if ( pCompo->GetThickness( dThick)) pCurve->SetThickness( dThick) ; } } } if ( IsNull( pCurve)) return nullptr ; // ne recupero il riferimento globale Frame3d frGlob ; if ( ! m_pGeomDB->GetGlobFrame( Id.nId, frGlob)) return nullptr ; // la porto in globale pCurve->ToGlob( frGlob) ; // la restituisco return Release( pCurve) ; } //---------------------------------------------------------------------------- bool SawRoughing::AdjustGeometry( int nAuxId) { // sgrossatura di cornici diritte : due o più curve (sezioni e guida rettilinea) // sgrossatura di cornici curve : due curve (sezione e guida curva) size_t nCrvCount = m_vId.size() ; if ( nCrvCount >= 2) { // le sezioni devono essere chiuse, piane e giacere in uno stesso piano verticale ICURVEPOVECTOR vpSects ; vpSects.reserve( nCrvCount - 1) ; Vector3d vtN ; for ( size_t i = 0 ; i < nCrvCount - 1 ; ++ i) { vpSects.emplace_back( GetCurve( m_vId[i])) ; if ( IsNull( vpSects.back())) return false ; if ( ! vpSects.back()->IsClosed()) return false ; Plane3d plPlane ; if ( ! vpSects.back()->IsFlat( plPlane, false, 10 * EPS_SMALL) || abs( plPlane.GetVersN().z) > EPS_SMALL) return false ; if ( i == 0) vtN = plPlane.GetVersN() ; else { if ( ! AreSameOrOppositeVectorApprox( plPlane.GetVersN(), vtN)) return false ; } } // l'ultima curva è la guida PtrOwner pGuide( GetCurve( m_vId[nCrvCount-1])) ; if ( IsNull( pGuide)) return false ; // se linea -> cornici diritte (lama verticale) if ( pGuide->GetType() == CRV_LINE) m_bStraight = true ; // altrimenti curva -> cornici curve (lama orizzontale) else { m_bStraight = false ; // ammessa una sola sezione if ( nCrvCount > 2) return false ; // la guida deve giacere nel piano XY Plane3d plPlane ; if ( ! pGuide->IsFlat( plPlane, false, 10 * EPS_SMALL) || ! AreSameOrOppositeVectorApprox( plPlane.GetVersN(), Z_AX)) return false ; // verifiche sulla curva (che trasformo in composita) PtrOwner pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo) || ! pCompo->AddCurve( Release( pGuide))) return false ; // converto in archi e rette pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ; // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi VerifyArcs( pCompo) ; // reinserisco nella curva originale pGuide.Set( Release( pCompo)) ; } // deve iniziare in comune con la prima sezione ed essere ivi perpendicolare Vector3d vtGdDir ; if ( ! pGuide->GetStartDir( vtGdDir) || ! AreSameOrOppositeVectorApprox( vtN, vtGdDir)) return false ; Point3d ptStStart, ptGdStart ; if ( ! vpSects[0]->GetStartPoint( ptStStart) || ! pGuide->GetStartPoint( ptGdStart) || ( ptGdStart - ptStStart) * vtGdDir > 10 * EPS_SMALL) return false ; // creo sottogruppo per le sezioni con riferimento avente // l'origine nel punto di inizio della guida e la Z opposta alla direzione della guida Frame3d frSect ; if ( ! frSect.Set( ptGdStart, - vtGdDir)) return false ; int nGrpSectId = m_pGeomDB->AddGroup( GDB_ID_NULL, nAuxId, frSect) ; if ( nGrpSectId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nGrpSectId, MCH_SECTION) ; // inserisco le sezioni e ne sistemo il senso di rotazione come CCW for ( auto& pSect : vpSects) { pSect->ToLoc( frSect) ; double dArea ; pSect->GetAreaXY( dArea) ; if ( dArea < 0) pSect->Invert() ; if ( m_pGeomDB->AddGeoObj( GDB_ID_NULL, nGrpSectId, ::Release( pSect)) == GDB_ID_NULL) return false ; } // creo sottogruppo per la guida // inserisco la guida nel gruppo ausiliario int nGrpGuideId = m_pGeomDB->AddGroup( GDB_ID_NULL, nAuxId, Frame3d()) ; if ( nGrpGuideId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nGrpGuideId, MCH_GUIDE) ; if ( m_pGeomDB->AddGeoObj( GDB_ID_NULL, nGrpGuideId, ::Release( pGuide)) == GDB_ID_NULL) return false ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawRoughing::CalculateToolPath( int nAuxId, int nClId) { // Recupero ed elaboro le sezioni ICurve* pSect ; int nSectGrpId = m_pGeomDB->GetFirstNameInGroup( nAuxId, MCH_SECTION) ; if ( ! CalculateSection( nSectGrpId, pSect)) return false ; PtrOwner pCrv( pSect) ; // recupero il riferimento globale delle sezioni Frame3d frSect ; m_pGeomDB->GetGroupGlobFrame( nSectGrpId, frSect) ; // recupero il box globale delle sezioni BBox3d b3Sect ; m_pGeomDB->GetGlobalBBox( nSectGrpId, b3Sect) ; // Recupero ed elaboro la linea guida Point3d ptGdStart, ptGdEnd ; Vector3d vtGdDir ; int nGuideId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetFirstNameInGroup( nAuxId, MCH_GUIDE)) ; if ( ! CalculateGuideLine( nGuideId, b3Sect, ptGdStart, ptGdEnd, vtGdDir)) return false ; // recupero il box globale della linea guida BBox3d b3Guide ; m_pGeomDB->GetGlobalBBox( nGuideId, b3Guide) ; // determino l'ingombro della curva risultante in locale BBox3d b3Crv ; pCrv->GetLocalBBox( b3Crv) ; // recupero il box del grezzo in globale e lo porto in locale alla sezione BBox3d b3Test ; b3Test.Add( b3Sect) ; b3Test.Add( b3Guide) ; BBox3d b3Raw ; if ( ! GetRawGlobBox( m_nPhase, b3Test, 10 * EPS_SMALL, b3Raw) || b3Raw.IsEmpty()) { m_pMchMgr->SetLastError( 2703, "Error in SawFinishing : Empty RawBox") ; return false ; } BBox3d b3RawLoc = b3Raw ; b3RawLoc.ToLoc( frSect) ; // valuto l'espressione dell'affondamento ExeLuaSetGlobNumVar( "TH", 0) ; ExeLuaSetGlobNumVar( "RB", b3Raw.GetMax().z - b3Raw.GetMin().z) ; double dDepth ; if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) { m_pMchMgr->SetLastError( 2607, "Error in SawRoughing : Depth not computable") ; return false ; } // creo gruppo per geometria di lavorazione int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ; if ( nPxId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nPxId, MCH_PATH + "1_1") ; m_pGeomDB->SetMaterial( nPxId, BLUE) ; // Determino versori fresa e correzione Vector3d vtTool, vtCorr ; if ( ! CalculateToolAndCorrVersors( vtGdDir, m_Params.m_nHeadSide, vtTool, vtCorr)) { m_pMchMgr->SetLastError( 2608, "Error in SawRoughing : CalculateToolAndCorrVersors") ; return false ; } // Imposto dati comuni SetPathId( nPxId) ; SetToolDir( vtTool) ; SetCorrAuxDir( vtCorr) ; // Determino eventuali pareti verticali (sono in senso decrescente di X) DBLVECTOR vdVr ; double dPrevX = INFINITO ; const ICurveComposite* pCompo = GetCurveComposite( pCrv) ; if ( pCompo != nullptr) { const ICurve* pSimpCrv = pCompo->GetFirstCurve() ; while ( pSimpCrv != nullptr) { Point3d ptStart, ptEnd ; pSimpCrv->GetStartPoint( ptStart) ; pSimpCrv->GetEndPoint( ptEnd) ; if ( abs( ptEnd.x - ptStart.x) < EPS_SMALL) { double dX = ( ptEnd.x + ptStart.x) / 2 ; if ( dX < dPrevX - EPS_SMALL) { vdVr.push_back( dX) ; dPrevX = dX ; } } pSimpCrv = pCompo->GetNextCurve() ; } } else { Point3d ptStart, ptEnd ; pCrv->GetStartPoint( ptStart) ; pCrv->GetEndPoint( ptEnd) ; if ( abs( ptEnd.x - ptStart.x) < EPS_SMALL) vdVr.push_back( ( ptEnd.x + ptStart.x) / 2) ; } // Determino le posizioni particolari DBLVECTOR vdPp ; size_t nVr = vdVr.size() ; double dSawOffs = 0.5 * m_TParams.m_dThick ; double dFinOffs = m_Params.m_dSideStep - dSawOffs ; // calcolo dell'inizio (Xmin) double dRawMin = b3RawLoc.GetMin().x ; // inizio grezzo double dStart = max( dRawMin + dFinOffs, b3Crv.GetMin().x) ; // inizio con aletta prima if ( nVr > 0 && vdVr[nVr-1] < dStart - EPS_SMALL && vdVr[nVr-1] + dSawOffs > dRawMin + EPS_SMALL) dStart = vdVr[nVr-1] ; // correzione per parete verticale // calcolo della fine (Xmax) double dRawMax = b3RawLoc.GetMax().x ; // fine grezzo double dEnd = min( dRawMax - dFinOffs, b3Crv.GetMax().x) ; // fine con aletta dopo if ( nVr > 0 && vdVr[0] > dEnd + EPS_SMALL && vdVr[0] - dSawOffs < dRawMax - EPS_SMALL) dEnd = vdVr[0] ; // correzione per parete verticale // assegno le posizioni particolari (ordinate in senso decrescente) vdPp.push_back( dEnd) ; for ( size_t i = 0 ; i < nVr ; ++ i) { if ( vdVr[i] > dStart + EPS_SMALL && vdVr[i] < dEnd - EPS_SMALL) vdPp.push_back( vdVr[i]) ; } vdPp.push_back( dStart) ; // Ciclo sugli intervalli tra le posizioni particolari per generare le passate int nCount = 0 ; for ( size_t j = 0 ; j < vdPp.size() ; ++ j) { double dXmax = ( j > 0 ? vdPp[j-1] : vdPp[0]) ; double dXmin = vdPp[j] ; double dLargh = dXmax - dXmin ; double dStep = max( m_Params.m_dSideStep, 10 * EPS_SMALL) ; int nStep = max( 1, static_cast( ceil( dLargh / dStep))) ; dStep = dLargh / nStep ; double dSectYMin = b3Crv.GetMin().y ; double dSectYMax = b3Crv.GetMax().y ; for ( int i = 1 ; i <= nStep ; ++ i) { // flag per primo e ultimo taglio bool bFirst = ( j == 0 && i == 1) ; bool bLast = ( j == vdPp.size() -1 && i == nStep) ; // determino l'ascissa della prima intersezione double dX = dXmax - i * dStep ; // determino l'ordinata della prima intersezione double dY ; if ( ! GetHeightOnSection( pCrv, dX, dSectYMin, dSectYMax, dY)) return false ; // estremi del taglio Vector3d vtMove = dX * frSect.VersX() + dY * frSect.VersY() - 0.5 * m_TParams.m_dThick * vtTool ; Point3d ptStart = ptGdStart + vtMove ; Point3d ptEnd = ptGdEnd + vtMove ; // determino l'elevazione del taglio Vector3d vtThick = vtTool * m_TParams.m_dThick ; double dElev, dElev2 ; if ( ! GetElevation( m_nPhase, ptStart, ptEnd, vtCorr, dElev) || ! GetElevation( m_nPhase, ptStart + vtThick, ptEnd + vtThick, vtCorr, dElev2) ) { m_pMchMgr->SetLastError( 2609, "Error in SawRoughing : GetElevation") ; return false ; } dElev = max( dElev, dElev2) ; // se elevazione nulla, verifico col massimo del grezzo if ( dElev < EPS_SMALL) dElev = max( 0., b3Raw.GetMax().z - ptStart.z) ; // la confronto con il massimo affondamento e con la massima lavorazione della lama double dMaxDepth = min( dDepth, m_TParams.m_dMaxMat) ; if ( dElev > dMaxDepth) { ptStart += Vector3d( 0, 0, dElev - dMaxDepth) ; ptEnd += Vector3d( 0, 0, dElev - dMaxDepth) ; dElev = dMaxDepth ; } // esecuzione del taglio if ( m_Params.m_nStepType != SAWROU_ST_ZIGZAG) { if ( ! CalculateOneWayCut( ptStart, ptEnd, vtGdDir, vtTool, vtCorr, dElev, bFirst, bLast)) return false ; } else { if ( ! CalculateZigZagCut( ptStart, ptEnd, vtGdDir, vtTool, vtCorr, dElev, bFirst, bLast, nCount)) return false ; } } } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::CalculateCurvedToolPath( int nAuxId, int nClId) { // Ruoto di 90 deg la curva sezione nel suo piano int nSectGrpId = m_pGeomDB->GetFirstNameInGroup( nAuxId, MCH_SECTION) ; int nCrvId = ExeGetFirstInGroup( nSectGrpId) ; m_pGeomDB->Rotate( nCrvId, ORIG, Z_AX, 90.0) ; // Recupero ed elaboro la sezione ICurve* pSect ; if ( ! CalculateSection( nSectGrpId, pSect)) return false ; // Contro rotazione della curva m_pGeomDB->Rotate( nCrvId, ORIG, Z_AX, -90.0) ; PtrOwner pCrv( pSect) ; // recupero il riferimento globale della sezione Frame3d frSect ; m_pGeomDB->GetGroupGlobFrame( nSectGrpId, frSect) ; // recupero il box globale della sezione BBox3d b3Sect ; m_pGeomDB->GetGlobalBBox( nSectGrpId, b3Sect) ; // Recupero ed elaboro la linea guida int nGuideId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetFirstNameInGroup( nAuxId, MCH_GUIDE)) ; // recupero la linea guida ICurve* pGuide = ::GetCurve( m_pGeomDB->GetGeoObj( nGuideId)) ; if ( pGuide == nullptr) return false ; // recupero il box globale della linea guida BBox3d b3Guide ; m_pGeomDB->GetGlobalBBox( nGuideId, b3Guide) ; // recupero il box del grezzo in globale e lo porto in locale alla sezione BBox3d b3Test ; b3Test.Add( b3Sect) ; b3Test.Add( b3Guide) ; BBox3d b3Raw ; if ( ! GetRawGlobBox( m_nPhase, b3Test, 10 * EPS_SMALL, b3Raw) || b3Raw.IsEmpty()) { m_pMchMgr->SetLastError( 2703, "Error in SawFinishing : Empty RawBox") ; return false ; } BBox3d b3RawLoc = b3Raw ; b3RawLoc.ToLoc( frSect) ; // valuto l'espressione dell'affondamento ExeLuaSetGlobNumVar( "TH", 0) ; ExeLuaSetGlobNumVar( "RB", b3Raw.GetMax().z - b3Raw.GetMin().z) ; double dDepth ; if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) { m_pMchMgr->SetLastError( 2607, "Error in SawRoughing : Depth not computable") ; return false ; } // creo gruppo per geometria di lavorazione int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ; if ( nPxId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nPxId, MCH_PATH + "1_1") ; m_pGeomDB->SetMaterial( nPxId, BLUE) ; // Ripristino orientamento sezione con controrotazione pCrv->Rotate( ORIG, Z_AX, -90.0) ; // determino l'ingombro della curva risultante in locale BBox3d b3Crv ; pCrv->GetLocalBBox( b3Crv) ; // Determino eventuali pareti orizzontali (in senso decrescente di Y) DBLVECTOR vdVr ; double dPrevY = INFINITO ; const ICurveComposite* pCompo = GetCurveComposite( pCrv) ; if ( pCompo != nullptr) { const ICurve* pSimpCrv = pCompo->GetLastCurve() ; while ( pSimpCrv != nullptr) { Point3d ptStart, ptEnd ; pSimpCrv->GetStartPoint( ptStart) ; pSimpCrv->GetEndPoint( ptEnd) ; if ( abs( ptEnd.y - ptStart.y) < EPS_SMALL) { double dY = ( ptEnd.y + ptStart.y) / 2 ; if ( dY < dPrevY - EPS_SMALL) { vdVr.push_back( dY) ; dPrevY = dY ; } } pSimpCrv = pCompo->GetPrevCurve() ; } } else { Point3d ptStart, ptEnd ; pCrv->GetStartPoint( ptStart) ; pCrv->GetEndPoint( ptEnd) ; if ( abs( ptEnd.y - ptStart.y) < EPS_SMALL) vdVr.push_back( ( ptEnd.y + ptStart.y) / 2) ; } // Determino le posizioni particolari DBLVECTOR vdPp ; size_t nVr = vdVr.size() ; double dSawOffs = 0.5 * m_TParams.m_dThick ; double dFinOffs = m_Params.m_dSideStep - dSawOffs ; // calcolo dell'inizio (Ymax) double dRawMax = b3RawLoc.GetMax().y ; // inizio grezzo double dStart = min( dRawMax - dFinOffs, b3Crv.GetMax().y) ; // inizio con aletta prima if ( nVr > 0 && vdVr[0] > dStart + EPS_SMALL && vdVr[0] - dSawOffs < dRawMax - EPS_SMALL) dStart = vdVr[0] ; // correzione per parete verticale // calcolo della fine (Ymin) double dRawMin = b3RawLoc.GetMin().y ; // fine grezzo double dEnd = max( dRawMin + dFinOffs, b3Crv.GetMin().y) ; // fine con aletta dopo if ( nVr > 0 && vdVr[nVr-1] < dEnd - EPS_SMALL && vdVr[nVr-1] + dSawOffs > dRawMax + EPS_SMALL) dEnd = vdVr[nVr-1] ; // correzione per parete verticale // assegno le posizioni particolari (ordinate in senso decrescente) vdPp.push_back( dStart) ; for ( size_t i = 0 ; i < nVr ; ++ i) { if ( vdVr[i] < dStart - EPS_SMALL && vdVr[i] > dEnd + EPS_SMALL) vdPp.push_back( vdVr[i]) ; } vdPp.push_back( dEnd) ; // Determino versori fresa e correzione Vector3d vtTool = Z_AX ; // Imposto dati comuni SetPathId( nPxId) ; SetToolDir( vtTool) ; // Ciclo sugli intervalli tra le posizioni particolari per generare le passate int nCount = 0 ; for ( size_t j = 0 ; j < vdPp.size() ; ++ j) { double dYmax = ( j > 0 ? vdPp[j-1] : vdPp[0]) ; double dYmin = vdPp[j] ; double dLargh = dYmax - dYmin ; double dStep = max( m_Params.m_dSideStep, 10 * EPS_SMALL) ; int nStep = max( 1, static_cast( ceil( dLargh / dStep))) ; dStep = dLargh / nStep ; double dSectXMin = b3Crv.GetMin().x ; double dSectXMax = b3Crv.GetMax().x ; for ( int i = 1 ; i <= nStep ; ++ i) { // flag per primo e ultimo taglio bool bFirst = ( j == 0 && i == 1) ; bool bLast = ( j == vdPp.size() -1 && i == nStep) ; // determino l'ordinata della prima intersezione double dY = dYmax - i * dStep ; // determino l'ascissa della prima intersezione double dX ; if ( ! GetWidthOnSection( pCrv, dY, dSectXMin, dSectXMax, dX)) return false ; // creo la curva di taglio OffsetCurve OffsCrv ; OffsCrv.Make( pGuide, dX, ICurve::OFF_FILLET) ; PtrOwner pCut( CreateCurveComposite()) ; if ( IsNull( pCut) || ! pCut->AddCurve( OffsCrv.GetLongerCurve())) return false ; VerifyArcs( pCut) ; Vector3d vtMove = ( dY - m_TParams.m_dThick / 2) * Z_AX ; pCut->Translate( vtMove) ; // ne determino la massima elevazione double dElev = 0 ; CalculateSideElevation( pCut, dElev) ; // la confronto con il massimo affondamento e con la massima lavorazione della lama double dMaxDepth = min( dDepth, m_TParams.m_dMaxMat) ; if ( dElev > dMaxDepth) { double dOffs = dElev - dMaxDepth ; pCut->SimpleOffset( dOffs) ; dElev = dMaxDepth ; } else pCut->SimpleOffset( SAWRF_OFFS, ICurve::OFF_FORCE_OPEN) ; // esecuzione del taglio if ( m_Params.m_nStepType != SAWROU_ST_ZIGZAG) { //if ( ! CalculateOneWayCut( ptStart, ptEnd, vtGdDir, vtTool, vtCorr, dElev, bFirst, bLast)) // return false ; } else { if ( ! CalculateCurvedZigZagCut( pCut, vtTool, dElev, bFirst, bLast, nCount)) return false ; } } } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::CalculateSection( int nSectGrpId, ICurve*& pSect) { // recupero le sezioni ICURVEPVECTOR vpSects ; int nSectId = m_pGeomDB->GetFirstInGroup( nSectGrpId) ; while ( nSectId != GDB_ID_NULL) { // recupero il puntatore alla curva vpSects.emplace_back( ::GetCurve( m_pGeomDB->GetGeoObj( nSectId))) ; if ( vpSects.back() == nullptr) return false ; // passo alla successiva nSectId = m_pGeomDB->GetNext( nSectId) ; } // elimino eventuali sottosquadra ICURVEPOVECTOR vpNucCrvs ; vpNucCrvs.reserve( vpSects.size()) ; for ( const auto& pSect : vpSects) { PtrOwner pCrvCompo( CreateCurveComposite()) ; if ( IsNull( pCrvCompo) || ! pCrvCompo->AddCurve( *pSect) || ! pCrvCompo->RemoveUndercutOnY( LIN_TOL_STD, ANG_TOL_STD_DEG)) return false ; vpNucCrvs.emplace_back( Release( pCrvCompo)) ; } // calcolo ordinamento delle curve secondo la X decrescente typedef pair INDASC ; // coppia indice, ascissa typedef vector INDASCVECTOR ; // vettore di coppie indice, ascissa INDASCVECTOR vIAsc ; vIAsc.reserve( vpNucCrvs.size()) ; for ( int i = 0 ; i < int( vpNucCrvs.size()) ; ++ i) { Point3d ptStart ; if ( ! vpNucCrvs[i]->GetStartPoint( ptStart)) return false ; vIAsc.emplace_back( i, ptStart.x) ; } sort( vIAsc.begin(), vIAsc.end(), []( const INDASC& a, const INDASC& b) { return a.second > b.second ; }) ; // unisco le diverse curve (ora aperte) in un unico profilo PtrOwner pCurve( CreateCurveComposite()) ; if ( IsNull( pCurve)) return false ; bool bFirst = true ; for ( int i = 0 ; i < int( vpNucCrvs.size()) ; ++ i) { if ( ! bFirst) { Point3d ptStart ; if ( ! vpNucCrvs[vIAsc[i].first]->GetStartPoint( ptStart) || ! pCurve->AddLine( ptStart)) return false ; } if ( ! pCurve->AddCurve( Release( vpNucCrvs[vIAsc[i].first]))) return false ; bFirst = false ; } // offset radiale delle sezioni per il sovramateriale double dOffsR = GetOffsR() ; PtrOwner pOvrCrv ; OffsetCurve OffsCrv ; OffsCrv.Make( pCurve, dOffsR, ICurve::OFF_FILLET) ; pOvrCrv.Set( OffsCrv.GetLongerCurve()) ; if ( IsNull( pOvrCrv)) { m_pMchMgr->SetLastError( 2605, "Error in SawRoughing : OffsetCurve") ; return false ; } // ricavo dalla sezione la curva per centro in basso della lama double dOffsX = 0.5 * m_TParams.m_dThick + GetOffsL() - GetOffsR() ; PtrOwner pCrv ; OffsetCurveOnX OffsCrvX ; OffsCrvX.Make( pOvrCrv, dOffsX) ; pCrv.Set( OffsCrvX.GetLongerCurve()) ; if ( IsNull( pCrv)) { m_pMchMgr->SetLastError( 2606, "Error in SawRoughing : OffsetCurveOnX") ; return false ; } // determino l'intervallo di curva da conservare if ( ! TrimSection( pCrv)) { m_pMchMgr->SetLastError( 2610, "Error in SawRoughing : TrimSection failed") ; return false ; } pSect = Release( pCrv) ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::TrimSection( ICurve* pCrv) { // se parametri di accorciamento iniziale e finale sono nulli, non faccio alcunché if ( m_Params.m_dStartAddLen > - EPS_SMALL && m_Params.m_dEndAddLen > -EPS_SMALL) return true ; // box della sezione in locale BBox3d b3Crv ; pCrv->GetBBox( Frame3d(), b3Crv) ; // riduco gli estremi in X Point3d ptMin = b3Crv.GetMin() ; Point3d ptMax = b3Crv.GetMax() ; ptMin.x -= m_Params.m_dStartAddLen ; ptMax.x += m_Params.m_dEndAddLen ; double dDimX = ptMax.x - ptMin.x ; double dDimY = ptMax.y - ptMin.y + 100 * EPS_SMALL ; // regione del box nel piano XY PtrOwner pSfr( GetSurfFlatRegionRectangle( dDimX, dDimY)) ; if ( IsNull( pSfr)) return false ; pSfr->Translate( Vector3d( ptMin.x, ptMin.y - 50 * EPS_SMALL, ptMin.z)) ; // calcolo la classificazione della curva rispetto alla regione CRVCVECTOR ccClass ; if ( ! pSfr->GetCurveClassification( *pCrv, EPS_SMALL, ccClass)) return false ; // determino l'intervallo di curva da conservare Intervals inOk ; for ( auto& ccOne : ccClass) { if ( ccOne.nClass == CRVC_IN || ccOne.nClass == CRVC_ON_P || ccOne.nClass == CRVC_ON_M) inOk.Add( ccOne.dParS, ccOne.dParE) ; } // eseguo trim double dUmin, dUmax ; if ( ! inOk.GetMinMax( dUmin, dUmax)) return false ; return ( pCrv->TrimEndAtParam( dUmax) && pCrv->TrimStartAtParam( dUmin)) ; } //---------------------------------------------------------------------------- bool SawRoughing::CalculateGuideLine( int nGuideId, const BBox3d& b3Sect, Point3d& ptGdStart, Point3d& ptGdEnd, Vector3d& vtGdDir) { // recupero la linea guida ICurve* pGuide = ::GetCurve( m_pGeomDB->GetGeoObj( nGuideId)) ; if ( pGuide == nullptr) return false ; // recupero gli estremi della linea guida pGuide->GetStartPoint( ptGdStart) ; pGuide->GetEndPoint( ptGdEnd) ; // recupero la direzione della linea guida pGuide->GetStartDir( vtGdDir) ; // per ora ammesse solo linee guida rettilinee dirette lungo X o Y if ( ! AreSameOrOppositeVectorApprox( vtGdDir, X_AX) && ! AreSameOrOppositeVectorApprox( vtGdDir, Y_AX)) { m_pMchMgr->SetLastError( 2603, "Error in SawRoughing : Guide Line not along X or Y") ; return false ; } // recupero il box globale della linea guida BBox3d b3Guide ; m_pGeomDB->GetGlobalBBox( nGuideId, b3Guide) ; // recupero il box del grezzo in globale BBox3d b3Test ; b3Test.Add( b3Sect) ; b3Test.Add( b3Guide) ; BBox3d b3Raw ; if ( ! GetRawGlobBox( m_nPhase, b3Test, 10 * EPS_SMALL, b3Raw) || b3Raw.IsEmpty()) { m_pMchMgr->SetLastError( 2604, "Error in SawRoughing : Empty RawBox") ; return false ; } // aggiusto la linea guida al bordo del box if ( AreSameVectorApprox( vtGdDir, X_AX)) { ptGdStart.x = b3Raw.GetMin().x ; ptGdEnd.x = b3Raw.GetMax().x ; } else if ( AreOppositeVectorApprox( vtGdDir, X_AX)) { ptGdStart.x = b3Raw.GetMax().x ; ptGdEnd.x = b3Raw.GetMin().x ; } else if ( AreSameVectorApprox( vtGdDir, Y_AX)) { ptGdStart.y = b3Raw.GetMin().y ; ptGdEnd.y = b3Raw.GetMax().y ; } else { ptGdStart.y = b3Raw.GetMax().y ; ptGdEnd.y = b3Raw.GetMin().y ; } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::CalculateOneWayCut( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDir, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bFirst, bool bLast) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // se attacco/uscita/collegamento esterno allungo inizio Point3d ptNewStart = ptStart ; if ( m_Params.m_nLeadLinkType == SAWROU_LL_OUT) { // distanza XY tra centro e bordo taglio double dDeltaT = 0 ; if ( dElev > 0.0 && dElev < 0.5 * m_TParams.m_dDiam) dDeltaT = sqrt( dElev * m_TParams.m_dDiam - dElev * dElev) ; // modifico inizio ptNewStart = ptStart - vtDir * ( dDeltaT + dAppr) ; } // Se una sola passata if ( m_Params.m_dStep < EPS_SMALL || dElev <= m_Params.m_dStep) { // 1 -> approccio if ( ! AddApproach( ptNewStart, vtCorr, bFirst, dSafeZ, dElev, dAppr)) return false ; // 2 -> movimento in affondo al punto iniziale SetFlag( 0) ; if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) SetFeed( GetTipFeed()) ; else SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; // 3 -> movimento di lato al punto finale SetFeed( GetFeed()) ; if ( AddLinearMove( ptEnd) == GDB_ID_NULL) return false ; // 4 -> retrazione if ( ! AddRetract( ptEnd, vtCorr, dSafeZ, dElev, dAppr)) return false ; } // altrimenti più passate ad una via else { // 1 -> approccio if ( ! AddApproach( ptNewStart, vtCorr, bFirst, dSafeZ, dElev, dAppr)) return false ; // 2-3 -> lavorazione // calcolo numero e valore degli step double dCutH = dElev ; int nStep = static_cast( ceil( dCutH / m_Params.m_dStep)) ; double dStep = dCutH / nStep ; // esecuzione degli step for ( int i = nStep - 1 ; i >= 0 ; -- i) { // distanza dal fondo double dDelta = ( ( i != 0) ? i * dStep : 0) ; // movimento in affondo al punto iniziale SetFlag( 0) ; if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) SetFeed( GetTipFeed()) ; else SetFeed( GetFeed()) ; Point3d ptP2 = ptNewStart + vtCorr * dDelta ; if ( AddLinearMove( ptP2) == GDB_ID_NULL) return false ; // movimento di lato al punto finale SetFeed( GetFeed()) ; Point3d ptP3 = ptEnd + vtCorr * dDelta ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; // se non è ultimo passo if ( i != 0) { // movimento di risalita sopra il punto finale SetFeed( GetEndFeed()) ; Point3d ptP4 = ptEnd + vtCorr * ( dElev + dAppr) ; if ( AddLinearMove( ptP4) == GDB_ID_NULL) return false ; // movimento di ritorno spora il punto iniziale SetFeed( GetEndFeed()) ; Point3d ptP5 = ptNewStart + vtCorr * ( dElev + dAppr) ; if ( AddLinearMove( ptP5) == GDB_ID_NULL) return false ; } } // 4 -> retrazione if ( ! AddRetract( ptEnd, vtCorr, dSafeZ, dElev, dAppr)) return false ; } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::CalculateZigZagCut( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDir, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bFirst, bool bLast, int& nCount) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // aggiorno inizio, fine e direzione movimento Point3d ptOriStart = ptStart ; Point3d ptOriEnd = ptEnd ; Point3d ptNewStart = ptStart ; Point3d ptNewEnd = ptEnd ; Vector3d vtNewDir = vtDir ; // se attacco/uscita/collegamento esterno allungo inizio e fine if ( m_Params.m_nLeadLinkType == SAWROU_LL_OUT) { // distanza XY tra centro e bordo taglio double dDeltaT = 0 ; if ( dElev > 0.0 && dElev < 0.5 * m_TParams.m_dDiam) dDeltaT = sqrt( dElev * m_TParams.m_dDiam - dElev * dElev) ; // modifico inizio ptNewStart = ptStart - vtDir * ( dDeltaT + dAppr) ; // modifico fine ptNewEnd = ptEnd + vtDir * ( dDeltaT + dAppr) ; } // le passate dispari sono al contrario if ( ( nCount % 2) != 0) { swap( ptOriStart, ptOriEnd) ; swap( ptNewStart, ptNewEnd) ; vtNewDir.Invert() ; } // Se una sola passata if ( m_Params.m_dStep < EPS_SMALL || dElev <= m_Params.m_dStep) { // 1 -> approccio if ( bFirst || m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { if ( ! AddApproach( ptNewStart, vtCorr, bFirst, dSafeZ, dElev, dAppr)) return false ; } // 2 -> movimento in affondo al punto iniziale SetFlag( 0) ; // con attacco centrato sono sul materiale e devo usare feed di testa if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { SetFeed( GetTipFeed()) ; Point3d ptCurr ; GetCurrPos( ptCurr) ; if ( ! AreSamePointEpsilon( ptCurr, ptNewStart, 10 * EPS_SMALL)) { if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } } // con attacco fuori sono in aria else { if ( bFirst) { SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } else { Point3d ptLast ; GetCurrPos( ptLast) ; double dDiff = ( ptNewStart - ptLast) * vtNewDir ; // se precedente e corrente sono fuori allo stesso modo if ( abs( dDiff) < 10 * EPS_SMALL) { // inizio nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } // se il precedente è più fuori else if ( dDiff > 0) { // allungo nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart - dDiff * vtNewDir) == GDB_ID_NULL) return false ; } // se il corrente è più fuori else { // allungo passata precedente if ( AddLinearMove( ptLast + dDiff * vtNewDir) == GDB_ID_NULL) return false ; // inizio nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } } } // 3 -> movimento di lato al punto finale if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewEnd) == GDB_ID_NULL) return false ; } else { SetFeed( GetFeed()) ; if ( AddLinearMove( ptOriEnd) == GDB_ID_NULL) return false ; SetFeed( GetEndFeed()) ; if ( AddLinearMove( ptNewEnd) == GDB_ID_NULL) return false ; } // 4 -> retrazione if ( bLast || m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { if ( ! AddRetract( ptNewEnd, vtCorr, dSafeZ, dElev, dAppr)) return false ; } // incremento contatore passate ++ nCount ; } // altrimenti più passate a zig-zag else { // 1 -> approccio if ( bFirst || m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { if ( ! AddApproach( ptNewStart, vtCorr, bFirst, dSafeZ, dElev, dAppr)) return false ; } // 2-3 -> lavorazione // calcolo numero e valore degli step double dCutH = dElev ; int nStep = static_cast( ceil( dCutH / m_Params.m_dStep)) ; double dStep = dCutH / nStep ; // esecuzione degli step for ( int i = nStep - 1 ; i >= 0 ; -- i) { // distanza dal fondo double dDelta = ( ( i != 0) ? i * dStep : 0) ; // movimento in affondo al punto iniziale // con attacco centrato sono sul materiale e devo usare feed di testa if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { SetFlag( 0) ; if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) SetFeed( GetTipFeed()) ; else SetFeed( GetFeed()) ; Point3d ptP2 = ptNewStart + vtCorr * dDelta ; if ( AddLinearMove( ptP2) == GDB_ID_NULL) return false ; } // con attacco fuori sono in aria else { if ( bFirst || i < nStep - 1) { SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart + vtCorr * dDelta) == GDB_ID_NULL) return false ; } else { Point3d ptLast ; GetCurrPos( ptLast) ; double dDiff = ( ptNewStart - ptLast) * vtNewDir ; // se precedente e corrente sono fuori allo stesso modo if ( abs( dDiff) < 10 * EPS_SMALL) { // inizio nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart + vtCorr * dDelta) == GDB_ID_NULL) return false ; } // se il precedente è più fuori else if ( dDiff > 0) { // allungo nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart + vtCorr * dDelta - dDiff * vtNewDir) == GDB_ID_NULL) return false ; } // se il corrente è più fuori else { // allungo passata precedente if ( AddLinearMove( ptLast + dDiff * vtNewDir) == GDB_ID_NULL) return false ; // inizio nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart + vtCorr * dDelta) == GDB_ID_NULL) return false ; } } } // movimento di lato al punto finale if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { SetFeed( GetFeed()) ; Point3d ptP3 = ptNewEnd + vtCorr * dDelta ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } else { SetFeed( GetFeed()) ; if ( AddLinearMove( ptOriEnd + vtCorr * dDelta) == GDB_ID_NULL) return false ; SetFeed( GetEndFeed()) ; if ( AddLinearMove( ptNewEnd + vtCorr * dDelta) == GDB_ID_NULL) return false ; } // incremento contatore passate ++ nCount ; // scambio inizio e fine if ( i > 0) { swap( ptNewStart, ptNewEnd) ; swap( ptOriStart, ptOriEnd) ; vtNewDir.Invert() ; } } // 4 -> retrazione if ( bLast || m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { if ( ! AddRetract( ptNewEnd, vtCorr, dSafeZ, dElev, dAppr)) return false ; } } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::CalculateCurvedZigZagCut( const ICurve* pCut, const Vector3d& vtTool, double dElev, bool bFirst, bool bLast, int& nCount) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // verifico se passata da invertire (indice dispari) bool bInvert = ( ( nCount % 2) != 0) ; // recupero la passata PtrOwner pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo) || ! pCompo->AddCurve( *pCut)) return false ; // eseguo eventuale inversione if ( bInvert) pCompo->Invert() ; // aggiorno inizio, fine e direzione movimento Point3d ptStart ; pCompo->GetStartPoint( ptStart) ; Vector3d vtDirStart ; pCompo->GetStartDir( vtDirStart) ; Vector3d vtOrtStart = vtDirStart ; vtOrtStart.Rotate( Z_AX, ( bInvert ? 90 : -90)) ; Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ; Vector3d vtDirEnd ; pCompo->GetEndDir( vtDirEnd) ; Vector3d vtOrtEnd = vtDirEnd ; vtOrtEnd.Rotate( Z_AX, ( bInvert ? 90 : -90)) ; Point3d ptNewStart = ptStart ; Point3d ptNewEnd = ptEnd ; // calcolo elevazioni double dTgElevStart = 0 ; GetElevation( m_nPhase, ptStart, - vtDirStart, dTgElevStart) ; double dOrtElevStart = 0 ; GetElevation( m_nPhase, ptStart, vtOrtStart, dOrtElevStart) ; dOrtElevStart = max( dOrtElevStart, dElev) ; double dTgElevEnd = 0 ; GetElevation( m_nPhase, ptEnd, vtDirEnd, dTgElevEnd) ; double dOrtElevEnd = 0 ; GetElevation( m_nPhase, ptEnd, vtOrtEnd, dOrtElevEnd) ; dOrtElevEnd = max( dOrtElevEnd, dElev) ; // se attacco/uscita/collegamento esterno allungo inizio e fine if ( m_Params.m_nLeadLinkType == SAWROU_LL_OUT) { // distanza XY tra centro e bordo taglio double dDeltaTStart = 0 ; if ( dOrtElevStart > 0.0 && dOrtElevStart < 0.5 * m_TParams.m_dDiam) dDeltaTStart = sqrt( dOrtElevStart * m_TParams.m_dDiam - dOrtElevStart * dOrtElevStart) ; double dDeltaTEnd = 0 ; if ( dOrtElevEnd > 0.0 && dOrtElevEnd < 0.5 * m_TParams.m_dDiam) dDeltaTEnd = sqrt( dOrtElevEnd * m_TParams.m_dDiam - dOrtElevEnd * dOrtElevEnd) ; // modifico inizio ptNewStart = ptStart - vtDirStart * ( dTgElevStart + dDeltaTStart + dAppr) ; // modifico fine ptNewEnd = ptEnd + vtDirEnd * ( dTgElevEnd + dDeltaTEnd + dAppr) ; } // Se una sola passata if ( m_Params.m_dStep < EPS_SMALL || dElev <= m_Params.m_dStep) { SetCorrAuxDir( vtOrtStart) ; // 1 -> approccio if ( bFirst || m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { if ( ! AddApproach( ptNewStart, vtOrtStart, bFirst, dSafeZ, dOrtElevStart, dAppr)) return false ; } // 2 -> movimento in affondo al punto iniziale SetFlag( 0) ; // con attacco centrato sono sul materiale e devo usare feed di testa if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { SetFeed( GetTipFeed()) ; Point3d ptCurr ; GetCurrPos( ptCurr) ; if ( ! AreSamePointEpsilon( ptCurr, ptNewStart, 10 * EPS_SMALL)) { if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } } // con attacco fuori sono in aria else { if ( bFirst) { SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } else { Point3d ptLast ; GetCurrPos( ptLast) ; double dDiff = ( ptNewStart - ptLast) * vtDirStart ; // se precedente e corrente sono fuori allo stesso modo if ( abs( dDiff) < 10 * EPS_SMALL) { // inizio nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } // se il precedente è più fuori else if ( dDiff > 0) { // allungo nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart - dDiff * vtDirStart) == GDB_ID_NULL) return false ; } // se il corrente è più fuori else { // allungo passata precedente if ( AddLinearMove( ptLast + dDiff * vtDirStart) == GDB_ID_NULL) return false ; // inizio nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } } } // se non ci sono già, vado all'inizio dell'arco if ( ! SameAsCurrPos( ptStart) && AddLinearMove( ptStart) == GDB_ID_NULL) return false ; // 3 -> movimento di lato al punto finale const ICurve* pCrv = pCompo->GetFirstCurve() ; while ( pCrv != nullptr) { Point3d ptEnd ; pCrv->GetEndPoint( ptEnd) ; Vector3d vtDirEnd ; pCrv->GetEndDir( vtDirEnd) ; Vector3d vtOrtEnd = vtDirEnd ; vtOrtEnd.Rotate( Z_AX, ( bInvert ? 90 : -90)) ; SetCorrAuxDir( vtOrtEnd) ; SetFeed( GetFeed()) ; if ( pCrv->GetType() == CRV_LINE) { if ( AddLinearMove( ptEnd) == GDB_ID_NULL) return false ; } else { Point3d ptCen ; pCrv->GetCenterPoint( ptCen) ; double dAngCen = GetCurveArc( pCrv)->GetAngCenter() ; if ( AddArcMove( ptEnd, ptCen, dAngCen, vtTool) == GDB_ID_NULL) return false ; } pCrv = pCompo->GetNextCurve() ; } if ( m_Params.m_nLeadLinkType == SAWROU_LL_OUT) { SetFeed( GetEndFeed()) ; if ( AddLinearMove( ptNewEnd) == GDB_ID_NULL) return false ; } // 4 -> retrazione if ( bLast || m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { if ( ! AddRetract( ptNewEnd, vtOrtEnd, dSafeZ, dOrtElevEnd, dAppr)) return false ; } // incremento contatore passate ++ nCount ; } // altrimenti più passate a zig-zag else { SetCorrAuxDir( vtOrtStart) ; // 1 -> approccio if ( bFirst || m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { if ( ! AddApproach( ptNewStart, vtOrtStart, bFirst, dSafeZ, dOrtElevStart, dAppr)) return false ; } // 2-3 -> lavorazione // calcolo numero e valore degli step double dCutH = dElev ; int nStep = static_cast( ceil( dCutH / m_Params.m_dStep)) ; double dStep = dCutH / nStep ; // offset iniziale della curva pCompo->SimpleOffset( bInvert ? - nStep * dStep : nStep * dStep, ICurve::OFF_FORCE_OPEN) ; // esecuzione degli step for ( int i = nStep - 1 ; i >= 0 ; -- i) { // distanza dal fondo double dDelta = ( ( i != 0) ? i * dStep : 0) ; pCompo->SimpleOffset( bInvert ? dStep : -dStep, ICurve::OFF_FORCE_OPEN) ; // movimento in affondo al punto iniziale // con attacco centrato sono sul materiale e devo usare feed di testa if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { SetFlag( 0) ; if ( m_Params.m_nLeadLinkType != SAWROU_LL_OUT) SetFeed( GetTipFeed()) ; else SetFeed( GetFeed()) ; Point3d ptP2 = ptNewStart + vtOrtStart * dDelta ; if ( AddLinearMove( ptP2) == GDB_ID_NULL) return false ; } // con attacco fuori sono in aria else { if ( bFirst || i < nStep - 1) { SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart + vtOrtStart * dDelta) == GDB_ID_NULL) return false ; } else { Point3d ptLast ; GetCurrPos( ptLast) ; double dDiff = ( ptNewStart - ptLast) * vtDirStart ; // se precedente e corrente sono fuori allo stesso modo if ( abs( dDiff) < 10 * EPS_SMALL) { // inizio nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart + vtOrtStart * dDelta) == GDB_ID_NULL) return false ; } // se il precedente è più fuori else if ( dDiff > 0) { // allungo nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart + vtOrtStart * dDelta - dDiff * vtDirStart) == GDB_ID_NULL) return false ; } // se il corrente è più fuori else { // allungo passata precedente if ( AddLinearMove( ptLast + dDiff * vtDirStart) == GDB_ID_NULL) return false ; // inizio nuova passata SetFeed( GetFeed()) ; if ( AddLinearMove( ptNewStart + vtOrtStart * dDelta) == GDB_ID_NULL) return false ; } } } // se non ci sono già, vado all'inizio dell'arco if ( ! SameAsCurrPos( ptStart + vtOrtStart * dDelta) && AddLinearMove( ptStart + vtOrtStart * dDelta) == GDB_ID_NULL) return false ; // movimento di lato al punto finale const ICurve* pCrv = pCompo->GetFirstCurve() ; while ( pCrv != nullptr) { Point3d ptEnd ; pCrv->GetEndPoint( ptEnd) ; Vector3d vtDirEnd ; pCrv->GetEndDir( vtDirEnd) ; Vector3d vtOrtEnd = vtDirEnd ; vtOrtEnd.Rotate( Z_AX, ( bInvert ? 90 : -90)) ; SetCorrAuxDir( vtOrtEnd) ; SetFeed( GetFeed()) ; if ( pCrv->GetType() == CRV_LINE) { if ( AddLinearMove( ptEnd) == GDB_ID_NULL) return false ; } else { Point3d ptCen ; pCrv->GetCenterPoint( ptCen) ; double dAngCen = GetCurveArc( pCrv)->GetAngCenter() ; if ( AddArcMove( ptEnd, ptCen, dAngCen, vtTool) == GDB_ID_NULL) return false ; } pCrv = pCompo->GetNextCurve() ; } if ( m_Params.m_nLeadLinkType == SAWROU_LL_OUT) { SetFeed( GetEndFeed()) ; if ( AddLinearMove( ptNewEnd + vtOrtEnd * dDelta) == GDB_ID_NULL) return false ; } // incremento contatore passate ++ nCount ; // scambio inizio e fine if ( i > 0) { swap( ptStart, ptEnd) ; swap( ptNewStart, ptNewEnd) ; swap( vtOrtStart, vtOrtEnd) ; swap( dOrtElevStart, dOrtElevEnd) ; bInvert = ! bInvert ; pCompo->Invert() ; } } // 4 -> retrazione if ( bLast || m_Params.m_nLeadLinkType != SAWROU_LL_OUT) { if ( ! AddRetract( ptNewEnd, vtOrtEnd, dSafeZ, dOrtElevEnd, dAppr)) return false ; } } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::AddApproach( const Point3d& ptP, const Vector3d& vtCorr, bool bFirst, 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 Point3d ptP1 = ptP + vtCorr * ( dElev + dAppr) ; if ( bFirst) { SetFlag( 1) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; } else { SetFlag( 0) ; if ( AddRapidMove( ptP1) == GDB_ID_NULL) return false ; } } else { // 1a -> punto sopra inizio Point3d ptP1b = ptP + vtCorr * ( dElev + dAppr) ; Point3d ptP1a = ptP1b + vtCorr * ( dSafeZ - m_Params.m_dStartPos) ; if ( bFirst) { SetFlag( 1) ; if ( AddRapidStart( ptP1a) == GDB_ID_NULL) return false ; } else { SetFlag( 0) ; if ( AddRapidMove( ptP1a) == GDB_ID_NULL) return false ; } // 1b -> punto appena sopra inizio SetFlag( 0) ; if ( AddRapidMove( ptP1b) == GDB_ID_NULL) return false ; } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::AddRetract( const Point3d& ptP, const Vector3d& vtCorr, 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 + vtCorr * ( 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 + vtCorr * ( dElev + dAppr) ; Point3d ptCurr ; GetCurrPos( ptCurr) ; if ( ! AreSamePointEpsilon( ptCurr, ptP4a, 10 * EPS_SMALL)) { if ( AddLinearMove( ptP4a) == GDB_ID_NULL) return false ; } // 4b -> movimento di risalita sopra il punto finale Point3d ptP4b = ptP4a + vtCorr * ( dSafeZ - m_Params.m_dStartPos) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } return true ; } //---------------------------------------------------------------------------- bool SawRoughing::CalculateToolAndCorrVersors( const Vector3d& vtTang, int nHeadSide, Vector3d& vtTool, Vector3d& vtCorr) { // Versore fresa : annullo la componente in Z e normalizzo vtTool = vtTang ; vtTool.z = 0 ; if ( ! vtTool.Normalize()) return false ; // ruoto attorno a Zglob+ a seconda del lato mandrino if ( nHeadSide == SAW_HS_LEFT) vtTool.Rotate( Z_AX, 0, 1) ; else vtTool.Rotate( Z_AX, 0, -1) ; // Versore correzione vtCorr = Z_AX ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::GetHeightOnSection( const ICurve* pSect, double dX, double dYmin, double dYmax, double& dY) { // creo raggio per intersezione con direzione Y+ PtrOwnerpRay( CreateCurveLine()) ; if ( IsNull( pRay) || ! pRay->Set( Point3d( dX, dYmin - EPS_SMALL, 0), Point3d( dX, dYmax + EPS_SMALL, 0))) return false ; // eseguo intersezione (considero la prima perchè non ci sono sottosquadra) IntersCurveCurve intCC( *pRay, *pSect) ; IntCrvCrvInfo aInfo ; if ( intCC.GetIntCrvCrvInfo( 0, aInfo)) { // nel caso di sovrapposizione devo prendere la Y in basso del tratto dY = aInfo.IciA[0].ptI.y ; return true ; } // se non c'è intersezione assegno il minimo dY = dYmin ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::GetWidthOnSection( const ICurve* pSect, double dY, double dXmin, double dXmax, double& dX) { // creo raggio per intersezione con direzione X- PtrOwnerpRay( CreateCurveLine()) ; if ( IsNull( pRay) || ! pRay->Set( Point3d( dXmax + EPS_SMALL, dY, 0), Point3d( dXmin - EPS_SMALL, dY, 0))) return false ; // eseguo intersezione (considero la prima perchè non ci sono sottosquadra) IntersCurveCurve intCC( *pRay, *pSect) ; IntCrvCrvInfo aInfo ; if ( intCC.GetIntCrvCrvInfo( 0, aInfo)) { // nel caso di sovrapposizione devo prendere la X massima del tratto dX = aInfo.IciA[0].ptI.x ; return true ; } // se non c'è intersezione assegno il massimo dX = dXmax ; return true ; } //---------------------------------------------------------------------------- bool SawRoughing::CalculateSideElevation( const ICurve* pCut, double& dElev) { // Inizializzo elevazione dElev = 0 ; // Lunghezza della curva double dTotLen ; pCut->GetLength( dTotLen) ; // Ciclo sulla curva double dLen = 0 ; while ( dLen <= dTotLen) { double dU ; if ( pCut->GetParamAtLength( dLen, dU)) { Point3d ptP ; Vector3d vtDir ; pCut->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP, &vtDir) ; vtDir.Normalize() ; vtDir.Rotate( Z_AX, -90) ; double dCurrElev ; if ( GetElevation(m_nPhase, ptP, vtDir, dCurrElev) && dCurrElev > dElev) dElev = dCurrElev ; } dLen += 20 ; } return true ; }