//---------------------------------------------------------------------------- // EgalTech 2019-2019 //---------------------------------------------------------------------------- // File : SurfFinishing.cpp Data : 28.05.19 Versione : 2.1e5 // Contenuto : Implementazione gestione finitura superfici. // // Note : Questa lavorazione è sempre espressa nel riferimento globale. // // Modifiche : 28.05.19 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "MachMgr.h" #include "DllMain.h" #include "SurfFinishing.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/EGkArcSpecial.h" #include "/EgtDev/Include/EGkChainCurves.h" #include "/EgtDev/Include/EGkOffsetCurve.h" #include "/EgtDev/Include/EGkIntersCurves.h" #include "/EgtDev/Include/EGkSfrCreate.h" #include "/EgtDev/Include/EGkSurfLocal.h" #include "/EgtDev/Include/EGkCAvToolSurfTm.h" #include "/EgtDev/Include/EGkCAvSilhouetteSurfTm.h" #include "/EgtDev/Include/EGkCalcPocketing.h" #include "/EgtDev/Include/EGkIntervals.h" #include "/EgtDev/Include/EGkStringUtils3d.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 -------------------------------------- // 3101 = "Error in SurfFinishing : UpdateToolData failed" // 3102 = "Error in SurfFinishing : Tool loading failed" // 3103 = "Error in SurfFinishing : Chaining failed" // 3104 = "Error in SurfFinishing : Open Contour" // 3105 = "Error in SurfFinishing : Contour Not Flat" // 3106 = "Error in SurfFinishing : Tool Dir not perpendicular to Flat Area" // 3107 = "Error in SurfFinishing : Empty RawBox" // 3108 = "Error in SurfFinishing : Depth not computable" // 3109 = "Error in SurfFinishing : Offset not computable" // 3110 = "Error in SurfFinishing : Toolpath not computable" // 3111 = "Error in SurfFinishing : Approach not computable" // 3112 = "Error in SurfFinishing : Link not computable" // 3113 = "Error in SurfFinishing : LeadIn not computable" // 3114 = "Error in SurfFinishing : LeadOut not computable" // 3115 = "Error in SurfFinishing : Retract not computable" // 3116 = "Error in SurfFinishing : axes values not calculable" // 3117 = "Error in SurfFinishing : outstroke xx" // 3118 = "Error in SurfFinishing : link movements not calculable" // 3119 = "Error in SurfFinishing : link outstroke" // 3120 = "Error in SurfFinishing : post apply not calculable" // 3121 = "Error in SurfFinishing : Linear Approx not computable" // 3122 = "Error in SurfFinishing : aggregate from bottom not allowed" // 3123 = "Error in SurfFinishing : missing surfaces" // 3124 = "Error in SurfFinishing : region not computable" // 3125 = "Error in SurfFinishing : CalcPocketing failed" // 3151 = "Warning in SurfFinishing : Skipped entity (xx)" // 3152 = "Warning in SurfFinishing : No machinable path" // 3153 = "Warning in SurfFinishing : Tool name changed (xx)" // 3154 = "Warning in SurfFinishing : Tool data changed (xx)" //---------------------------------------------------------------------------- USEROBJ_REGISTER( GetOperationClass( OPER_SURFFINISHING), SurfFinishing) ; //---------------------------------------------------------------------------- const string& SurfFinishing::GetClassName( void) const { return USEROBJ_GETNAME( SurfFinishing) ; } //---------------------------------------------------------------------------- SurfFinishing* SurfFinishing::Clone( void) const { // alloco oggetto SurfFinishing* pSrF = new(nothrow) SurfFinishing ; // eseguo copia dei dati if ( pSrF != nullptr) { try { pSrF->m_vId = m_vId ; pSrF->m_pMchMgr = m_pMchMgr ; pSrF->m_nPhase = m_nPhase ; pSrF->m_Params = m_Params ; pSrF->m_TParams = m_TParams ; pSrF->m_dTHoldBase = m_dTHoldBase ; pSrF->m_dTHoldLen = m_dTHoldLen ; pSrF->m_dTHoldDiam = m_dTHoldDiam ; pSrF->m_nStatus = m_nStatus ; pSrF->m_nPaths = m_nPaths ; } catch( ...) { delete pSrF ; return nullptr ; } } // ritorno l'oggetto return pSrF ; } //---------------------------------------------------------------------------- bool SurfFinishing::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 ; 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_nPaths) + szNewLine ; sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ; return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::Save( int nBaseId, STRVECTOR& vString) const { try { int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 3 ; 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_nPaths, vString[++k])) return false ; if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k])) return false ; } catch( ...) { return false ; } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::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_nPaths)) return false ; } else if ( sKey == KEY_STAT) { if ( ! FromString( sVal, m_nStatus)) return false ; } } return true ; } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- SurfFinishing::SurfFinishing( void) { m_Params.m_sName = "*" ; m_Params.m_sToolName = "*" ; m_TParams.m_sName = "*" ; m_TParams.m_sHead = "*" ; m_dTHoldBase = 0 ; m_dTHoldLen = 0 ; m_dTHoldDiam = 0 ; m_nStatus = MCH_ST_TO_VERIFY ; m_nPaths = 0 ; } //---------------------------------------------------------------------------- bool SurfFinishing::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 SurfFinishingData* pDdata = GetSurfFinishingData( 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 SurfFinishing::SetParam( int nType, bool bVal) { switch ( nType) { case MPA_INVERT : if ( bVal != m_Params.m_bInvert) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_bInvert = bVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SurfFinishing::SetParam( int nType, int nVal) { switch ( nType) { case MPA_SUBTYPE : if ( ! m_Params.VerifySubType( nVal)) return false ; if ( nVal != m_Params.m_nSubType) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nSubType = nVal ; return true ; case MPA_LEADINTYPE : if ( ! m_Params.VerifyLeadInType( nVal)) return false ; if ( nVal != m_Params.m_nLeadInType) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nLeadInType = nVal ; return true ; case MPA_LEADOUTTYPE : if ( ! m_Params.VerifyLeadOutType( nVal)) return false ; if ( nVal != m_Params.m_nLeadOutType) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nLeadOutType = 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 SurfFinishing::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 ; 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_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_OVERL : if ( ! AreSameLenValue( dVal, m_Params.m_dOverlap)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dOverlap = 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_SIDEANGLE : if ( abs( dVal - m_Params.m_dSideAngle) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dSideAngle = dVal ; return true ; case MPA_LITANG : if ( abs( dVal - m_Params.m_dLiTang) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dLiTang = dVal ; return true ; case MPA_LIPERP : if ( abs( dVal - m_Params.m_dLiPerp) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dLiPerp = dVal ; return true ; case MPA_LOTANG : if ( abs( dVal - m_Params.m_dLoTang) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dLoTang = dVal ; return true ; case MPA_LOPERP : if ( abs( dVal - m_Params.m_dLoPerp) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dLoPerp = dVal ; return true ; case MPA_APPROX : if ( abs( dVal - m_Params.m_dApprox) > EPS_SMALL) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dApprox = dVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SurfFinishing::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 SurfFinishing::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 SurfFinishing : Skipped entity " + ToString( Id) ; m_pMchMgr->SetWarning( 3151, 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 SurfFinishing::Preview( bool bRecalc) { // non esiste preview, si fa apply return Apply( bRecalc, false) ; } //---------------------------------------------------------------------------- bool SurfFinishing::Apply( bool bRecalc, bool bPostApply) { // reset numero tagli nella lavorazione int nCurrPaths = m_nPaths ; m_nPaths = 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( 3101, "Error in SurfFinishing : UpdateToolData failed") ; return false ; } // non è prevista finitura superficie con aggregato da sotto if ( IsAggrBottom( m_TParams.m_sHead)) { m_pMchMgr->SetLastError( 3122, "Error in SurfFinishing : aggregate from bottom not allowed") ; 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_nPaths = nCurrPaths ; LOG_DBG_INFO( GetEMkLogger(), "SurfFinishing 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) ; 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 ; } // rendo corrente l'utensile usato nella lavorazione if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) { m_pMchMgr->SetLastError( 3102, "Error in SurfFinishing : Tool loading failed") ; return false ; } // recupero i dati del portautensile int nToolId = m_pMchMgr->GetCalcTool() ; m_dTHoldBase = 0 ; m_pGeomDB->GetInfo( nToolId, TTH_BASE, m_dTHoldBase) ; m_dTHoldLen = 0 ; m_pGeomDB->GetInfo( nToolId, TTH_LEN, m_dTHoldLen) ; m_dTHoldDiam = 0 ; m_pGeomDB->GetInfo( nToolId, TTH_DIAM, m_dTHoldDiam) ; // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria if ( bChain && ! Chain( nAuxId)) { m_pMchMgr->SetLastError( 3103, "Error in SurfFinishing : Chaining 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) ; // lavoro ogni singola catena bool bOk = true ; int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ; while ( nPathId != GDB_ID_NULL) { if ( ! ProcessPath( nPathId, GDB_ID_NULL, nClId)) bOk = false ; nPathId = m_pGeomDB->GetNextGroup( nPathId) ; } if ( ! bOk) return false ; // 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(), "SurfFinishing apply done") ; return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::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_nPaths == 0) { m_pMchMgr->SetWarning( 3152, "Warning in SurfFinishing : No machinable path") ; return true ; } // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) RemoveClimbRiseHome() ; // 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( 3116, "Error in SurfFinishing : axes values not calculable") ; else m_pMchMgr->SetLastError( 3117, "Error in SurfFinishing : 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( 3118, "Error in SurfFinishing : link movements not calculable") ; else m_pMchMgr->SetLastError( 3119, "Error in SurfFinishing : 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( 3120, sErr) ; else m_pMchMgr->SetLastError( 3120, "Error in SurfFinishing : post apply not calculable") ; return false ; } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::GetParam( int nType, bool& bVal) const { switch ( nType) { case MPA_INVERT : bVal = m_Params.m_bInvert ; return true ; } bVal = false ; return false ; } //---------------------------------------------------------------------------- bool SurfFinishing::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_TYPE : nVal = MT_SURFFINISHING ; return true ; case MPA_SUBTYPE : nVal = m_Params.m_nSubType ; return true ; case MPA_LEADINTYPE : nVal = m_Params.m_nLeadInType ; return true ; case MPA_LEADOUTTYPE : nVal = m_Params.m_nLeadOutType ; return true ; case MPA_SCC : nVal = m_Params.m_nSolCh ; return true ; } nVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SurfFinishing::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_STARTPOS : dVal = m_Params.m_dStartPos ; return true ; case MPA_OVERL : dVal = m_Params.m_dOverlap ; return true ; case MPA_SIDESTEP : dVal = m_Params.m_dSideStep ; return true ; case MPA_SIDEANGLE : dVal = m_Params.m_dSideAngle ; return true ; case MPA_LITANG : dVal = m_Params.m_dLiTang ; return true ; case MPA_LIPERP : dVal = m_Params.m_dLiPerp ; return true ; case MPA_LOTANG : dVal = m_Params.m_dLoTang ; return true ; case MPA_LOPERP : dVal = m_Params.m_dLoPerp ; return true ; case MPA_APPROX : dVal = m_Params.m_dApprox ; return true ; } dVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SurfFinishing::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& SurfFinishing::GetToolData( void) const { return m_TParams ; } //---------------------------------------------------------------------------- bool SurfFinishing::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 ; // salvo posizione TC, testa e uscita originali string sOrigTcPos = m_TParams.m_sTcPos ; string sOrigHead = m_TParams.m_sHead ; int nOrigExit = m_TParams.m_nExit ; // verifico se sono diversi (ad esclusione di nome, posizione TC, testa e uscita) bool bChanged = ( ! SameTool( m_TParams, *pTdata, false)) ; // aggiorno comunque i parametri m_TParams = *pTdata ; // se definito attrezzaggio, aggiorno i parametri che ne possono derivare string sTcPos ; string sHead ; int nExit ; if ( m_pMchMgr->GetCurrSetupMgr().GetToolData( m_TParams.m_sName, sTcPos, sHead, nExit)) { if ( sOrigTcPos != sTcPos || sOrigHead != sHead || nOrigExit != nExit) bChanged = true ; m_TParams.m_sTcPos = sTcPos ; m_TParams.m_sHead = sHead ; m_TParams.m_nExit = nExit ; } else { if ( sOrigTcPos != pTdata->m_sTcPos || sOrigHead != pTdata->m_sHead || nOrigExit != pTdata->m_nExit) bChanged = true ; } // eventuali segnalazioni if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) { string sInfo = "Warning in SurfFinishing : tool name changed (" + m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ; m_pMchMgr->SetWarning( 3153, sInfo) ; m_Params.m_sToolName = m_TParams.m_sName ; } if ( bChanged) { string sInfo = "Warning in SurfFinishing : tool data changed (" + m_Params.m_sToolName + ")" ; m_pMchMgr->SetWarning( 3154, sInfo) ; } // se definito parametro di ritorno, lo assegno if ( pbChanged != nullptr) *pbChanged = bChanged ; return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::GetGeometry( SELVECTOR& vIds) const { // restituisco l'elenco delle entità vIds = m_vId ; return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const { // compenso il raggio dell'utensile ptP += pCamData->GetCorrDir() * ( m_TParams.m_dDiam / 2) ; return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::VerifyGeometry( SelData Id, int& nSubs) { // ammessi : curve o superfici const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ; if ( pGObj == nullptr) return false ; // se curva if ( ( pGObj->GetType() & GEO_CURVE) != 0) { const ICurve* pCurve = nullptr ; // 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) ; } // se altrimenti è superficie trimesh else if ( pGObj->GetType() == SRF_TRIMESH) { const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ; return ( pSurf != nullptr && pSurf->GetFacetCount() >= 1) ; } // altrimenti errore else return false ; } //---------------------------------------------------------------------------- bool SurfFinishing::GetCurves( SelData Id, ICURVEPLIST& lstPC) { // ammessi : curve const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ; if ( pGObj == nullptr) return false ; // ne recupero il riferimento globale Frame3d frGlob ; if ( ! m_pGeomDB->GetGlobFrame( Id.nId, frGlob)) return false ; // se curva if ( ( pGObj->GetType() & GEO_CURVE) != 0) { PtrOwner pCurve ; // se direttamente curva if ( Id.nSub == SEL_SUB_ALL) { // recupero la curva const ICurve* pOriCurve = ::GetCurve( pGObj) ; if ( pOriCurve == nullptr) return false ; // la duplico pCurve.Set( pOriCurve->Clone()) ; // se estrusione mancante, imposto default Vector3d vtExtr ; if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall()) pCurve->SetExtrusion( Z_AX) ; } // altrimenti sottocurva di composita else { // recupero la composita const ICurveComposite* pCompo = GetCurveComposite( pGObj) ; if ( pCompo == nullptr) return false ; // recupero la curva semplice const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ; if ( pOriCurve == nullptr) return false ; // la duplico pCurve.Set( pOriCurve->Clone()) ; // recupero estrusione e spessore Vector3d vtExtr ; if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall()) vtExtr = Z_AX ; pCurve->SetExtrusion( vtExtr) ; double dThick ; if ( pCompo->GetThickness( dThick)) pCurve->SetThickness( dThick) ; } if ( IsNull( pCurve)) return false ; // la porto in globale pCurve->ToGlob( frGlob) ; // la restituisco lstPC.emplace_back( Release( pCurve)) ; return true ; } // se altrimenti superficie else if ( pGObj->GetType() == SRF_TRIMESH) return true ; // altrimenti errore else return false ; } //---------------------------------------------------------------------------- bool SurfFinishing::Chain( int nGrpDestId) { // vettore puntatori alle curve ICURVEPOVECTOR vpCrvs ; vpCrvs.reserve( m_vId.size()) ; // vettore selettori delle curve originali SELVECTOR vInds ; // recupero tutte le curve e le porto in globale for ( const auto& Id : m_vId) { // prendo le curve ICURVEPLIST lstPC ; if ( ! GetCurves( Id, lstPC)) { string sInfo = "Warning in SurfFinishing : Skipped entity " + ToString( Id) ; m_pMchMgr->SetWarning( 3151, sInfo) ; } for ( auto pCrv : lstPC) { vpCrvs.emplace_back( pCrv) ; vInds.emplace_back( Id) ; } } // preparo i dati per il concatenamento bool bFirst = true ; Point3d ptNear = ORIG ; double dToler = 10 * EPS_SMALL ; ChainCurves chainC ; chainC.Init( true, dToler, int( vpCrvs.size())) ; for ( size_t i = 0 ; i < vpCrvs.size() ; ++ i) { // recupero la curva e il suo riferimento ICurve* pCrv = vpCrvs[i] ; if ( pCrv == nullptr) continue ; // recupero i dati della curva necessari al concatenamento e li assegno Point3d ptStart, ptEnd ; Vector3d vtStart, vtEnd ; if ( ! pCrv->GetStartPoint( ptStart) || ! pCrv->GetStartDir( vtStart) || ! pCrv->GetEndPoint( ptEnd) || ! pCrv->GetEndDir( vtEnd)) return false ; if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd)) return false ; // se prima curva, assegno inizio della ricerca if ( bFirst) { ptNear = ptStart + 10 * EPS_SMALL * vtStart ; bFirst = false ; } } // recupero i percorsi concatenati int nCount = 0 ; INTVECTOR vnId2 ; while ( chainC.GetChainFromNear( ptNear, false, vnId2)) { // creo una curva composita PtrOwner pCrvCompo( CreateCurveComposite()) ; if ( IsNull( pCrvCompo)) return false ; // estrusione e spessore Vector3d vtExtr = Z_AX ; double dThick = 0 ; // vettore Id originali SELVECTOR vId2 ; vId2.reserve( vnId2.size()) ; // recupero le curve semplici e le inserisco nella curva composita for ( size_t i = 0 ; i < vnId2.size() ; ++ i) { int nId = abs( vnId2[i]) - 1 ; bool bInvert = ( vnId2[i] < 0) ; vId2.emplace_back( vInds[nId]) ; // recupero la curva ICurve* pCrv = vpCrvs[nId] ; // se necessario, la inverto if ( bInvert) pCrv->Invert() ; // recupero eventuali estrusione e spessore Vector3d vtTemp ; if ( pCrv->GetExtrusion( vtTemp)) { vtExtr = vtTemp ; double dTemp ; if ( pCrv->GetThickness( dTemp) && abs( dTemp) > abs( dThick)) dThick = dTemp ; } // la aggiungo alla curva composta if ( ! pCrvCompo->AddCurve( ::Release( vpCrvs[nId]), true, dToler)) return false ; } // se non sono state inserite curve, vado oltre if ( pCrvCompo->GetCurveCount() == 0) continue ; // imposto estrusione e spessore pCrvCompo->SetExtrusion( vtExtr) ; pCrvCompo->SetThickness( dThick) ; // aggiorno il nuovo punto vicino pCrvCompo->GetEndPoint( ptNear) ; // se utile, approssimo con archi if ( ! ApproxWithArcsIfUseful( pCrvCompo)) return false ; // creo nuovo gruppo int nPathId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpDestId, Frame3d()) ; if ( nPathId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nPathId, MCH_PATH + ToString( ++ nCount)) ; m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( vId2)) ; // inserisco la curva composita nel gruppo destinazione int nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::Release( pCrvCompo)) ; if ( nNewId == GDB_ID_NULL) return false ; } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::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) ; // verifico sia una curva chiusa (deve delimitare l'area da svuotare) int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ; if ( m_pGeomDB->GetGeoType( nCrvId) != CRV_COMPO) return false ; ICurve* pCrv = ::GetCurve( m_pGeomDB->GetGeoObj( nCrvId)) ; if ( pCrv == nullptr || ! pCrv->IsClosed()) { m_pMchMgr->SetLastError( 3104, "Error in SurfFinishing : Open Contour") ; return false ; } // copio la curva composita da elaborare int nCopyId = m_pGeomDB->CopyGlob( nCrvId, GDB_ID_NULL, nTempId) ; if ( nCopyId == GDB_ID_NULL) return false ; ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( nCopyId)) ; // recupero estrusione (vettore fresa) e spessore Vector3d vtTool = Z_AX ; pCompo->GetExtrusion( vtTool) ; double dThick ; pCompo->GetThickness( dThick) ; // verifico sia piana e sistemo senso antiorario visto dalla direzione di estrusione Plane3d plPlane ; double dArea ; if ( ! pCompo->GetArea( plPlane, dArea)) { m_pMchMgr->SetLastError( 3105, "Error in SurfFinishing : Contour Not Flat") ; return false ; } if ( abs( plPlane.GetVersN() * vtTool) < cos( 10 * EPS_ANG_SMALL)) { m_pMchMgr->SetLastError( 3106, "Error in SurfFinishing : Tool Dir not perpendicular to Flat Area") ; return false ; } if ( plPlane.GetVersN() * vtTool * dArea < 0) pCompo->Invert() ; // unisco le parti allineate if ( ! pCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true)) return false ; // recupero il box del grezzo in globale BBox3d b3Raw ; if ( ! GetRawGlobBox( m_nPhase, nPathId, 0.5 * m_TParams.m_dTDiam, b3Raw) || b3Raw.IsEmpty()) { m_pMchMgr->SetLastError( 3107, "Error in SurfFinishing : Empty RawBox") ; return false ; } // valuto l'espressione dell'affondamento ExeLuaSetGlobNumVar( "TH", abs( dThick)) ; double dDepth ; string sMyDepth = m_Params.m_sDepth ; if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) { m_pMchMgr->SetLastError( 3108, "Error in SurfFinishing : Depth not computable") ; return false ; } // recupero flag per saltare parti a massimo affondamento bool bSkipMaxDown = true ; GetValInNotes( m_Params.m_sUserNotes, "SkipMaxDown", bSkipMaxDown) ; // recupero nome del path string sPathName ; m_pGeomDB->GetName( nPathId, sPathName) ; // se richiesta lavorazione if ( nClId != GDB_ID_NULL) { // 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) ; // verifico se archi vanno approssimati con segmenti di retta bool bSplitArcs = GetSplitArcs( vtTool) ; // porto tutte le superfici nel riferimento della prima Frame3d frSurf ; SURFLOCALVECTOR vSrfLoc ; INTVECTOR vSurfId ; GetActiveSurfaces( vSurfId) ; for ( auto nSurfId : vSurfId) { if ( vSrfLoc.empty()) { if ( ! m_pGeomDB->GetGlobFrame( nSurfId, frSurf)) return false ; } vSrfLoc.emplace_back( m_pGeomDB, nSurfId, frSurf) ; } if ( ! frSurf.IsValid()) { m_pMchMgr->SetLastError( 3123, "Error in SurfFinishing : missing surfaces") ; return false ; } // predispongo l'ambiente di correzione dei percorsi utensili con le superfici attive dei pezzi PtrOwner pCAvTlStm( CreateCAvToolSurfTm()) ; if ( IsNull( pCAvTlStm)) return false ; if ( abs( m_TParams.m_dSideAng) < EPS_ANG_SMALL) { pCAvTlStm->SetStdTool( m_TParams.m_dLen + GetOffsR(), m_TParams.m_dDiam / 2 + GetOffsR(), m_TParams.m_dCornRad + GetOffsR()) ; } else { double dDelta ; double dSideAngRad = m_TParams.m_dSideAng * DEGTORAD ; if ( m_TParams.m_dSideAng > 0) { if ( m_TParams.m_dCornRad < EPS_SMALL) dDelta = 2 * m_TParams.m_dMaxMat * tan( dSideAngRad) ; else dDelta = 2 * ( m_TParams.m_dCornRad * cos( dSideAngRad) + ( m_TParams.m_dMaxMat + m_TParams.m_dCornRad * ( sin( dSideAngRad) - 1)) * tan( dSideAngRad)) ; } else { dDelta = 2 * tan( dSideAngRad) * m_TParams.m_dMaxMat ; } double dStemRad = m_TParams.m_dDiam / 2 + dDelta ; double dTipRad = m_TParams.m_dDiam / 2 ; pCAvTlStm->SetAdvTool( m_TParams.m_dLen + GetOffsR(), dStemRad + GetOffsR(), m_TParams.m_dMaxMat, dTipRad + GetOffsR(), m_TParams.m_dCornRad + GetOffsR()) ; } pCAvTlStm->SetSurfTm( *GetSurfTriMesh( vSrfLoc[0].Get())) ; for ( int i = 1 ; i < int( vSrfLoc.size()) ; ++ i) pCAvTlStm->AddSurfTm( *GetSurfTriMesh( vSrfLoc[i].Get())) ; // determino la regione da lavorare PtrOwner pSfrCnt( CreateSurfFlatRegion()) ; if ( IsNull( pSfrCnt) || ! pSfrCnt->AddExtLoop( *pCompo)) { m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ; return false ; } // se richiesto, elimino le parti al massimo affondamento if ( bSkipMaxDown) { // calcolo silhouette dell'insieme di superfici CISURFTMPVECTOR vpStm ; vpStm.reserve( vSurfId.size()) ; for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) vpStm.emplace_back( GetSurfTriMesh( vSrfLoc[i].Get())) ; Frame3d frPocket ; Point3d ptCen ; pCompo->GetCentroid( ptCen) ; frPocket.Set( ptCen, vtTool) ; frPocket.ToLoc( frSurf) ; const double SILH_TOL = 1.0 ; PtrOwner pCavParSilh( CreateCAvParSilhouettesSurfTm()) ; if ( IsNull( pCavParSilh) || ! pCavParSilh->SetData( vpStm, frPocket, SILH_TOL)) return false ; POLYLINEVECTOR vPL ; if ( ! pCavParSilh->GetSilhouette( -dDepth, vPL)) { m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ; return false ; } // creo la regione piana dalle PolyLine ricavate dalla Silhouette SurfFlatRegionByContours SfrMaker ; for ( auto& PL : vPL) { // recupero la curva dalla silhouette PtrOwner pSilCrv( CreateCurveComposite()) ; if ( IsNull( pSilCrv)) return false ; pSilCrv->FromPolyLine( PL) ; // approssimo con archi const double SILH_ARC_TOL = 0.1 * SILH_TOL ; const double SILH_ARC_FEA_MAX = 100. ; PolyArc PA ; if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) { PtrOwner pTempCrv( CreateCurveComposite()) ; if ( ! IsNull( pTempCrv) && pTempCrv->FromPolyArc( PA) && pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG) && pTempCrv->MergeCurves( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG)) pSilCrv.Set( pTempCrv) ; } // aggiungo per regione if ( ! SfrMaker.AddCurve( Release( pSilCrv))) { m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ; return false ; } } PtrOwner pSfrSil( SfrMaker.GetSurf()) ; if ( ! IsNull( pSfrSil)) { pSfrSil->ToGlob( frSurf) ; double dPockRadOffs = m_TParams.m_dDiam - m_Params.m_dSideStep - m_Params.m_dOverlap ; pSfrSil->Offset( dPockRadOffs, ICurve::OFF_CHAMFER) ; // intersezione tra contorno e regione if ( ! pSfrCnt->Intersect( *pSfrSil)) { // ricreo la regione originale pSfrCnt->Clear() ; pSfrCnt->AddExtLoop( *pCompo) ; } // azzero le proprietà delle curve semplici dei contorni delle regioni ( se 1 lato aperto) for ( int nC = 0 ; nC < pSfrCnt->GetChunkCount() ; ++ nC) { for ( int nL = 0 ; nL < pSfrCnt->GetLoopCount( nC) ; ++ nL) { for ( int nCrv = 0 ; ; ++ nCrv) { if ( ! pSfrCnt->SetCurveTempProp( nC, nL, nCrv, 0, 0) || ! pSfrCnt->SetCurveTempProp( nC, nL, nCrv, 0, 1)) break ; } } } } } // se regione risultante vuota, non devo fare altro if ( ! pSfrCnt->IsValid()) return true ; // assegno il vettore estrazione al gruppo del percorso m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ; // Imposto dati comuni SetPathId( nPxId) ; SetToolDir( vtTool) ; // Eseguo la lavorazione a seconda del tipo double dElev = dDepth ; switch ( m_Params.m_nSubType) { case SURFFIN_SUB_ZIGZAG : if ( ! AddZigZag( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs)) return false ; break ; case SURFFIN_SUB_ONEWAY : if ( ! AddOneWay( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs)) return false ; break ; case SURFFIN_SUB_SPIRALIN : if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs, true)) return false ; break ; case SURFFIN_SUB_SPIRALOUT : if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs, false)) return false ; break ; } } // incremento numero di percorsi ++ m_nPaths ; return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::GetActiveSurfaces( INTVECTOR& vSurfId) const { // pulisco vettore superfici vSurfId.clear() ; // verifiche if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) return false ; // cerco tra gli oggetti selezionati for ( const auto& Id : m_vId) { int nEntId = Id.nId ; if ( m_pGeomDB->GetGeoType( nEntId) == SRF_TRIMESH) vSurfId.emplace_back( nEntId) ; } // se trovate superfici, considero solo queste ed esco if ( ! vSurfId.empty()) return true ; // altrimenti considero tutte le superfici dei pezzi nei grezzi attivi della fase int nRawId = m_pMchMgr->GetFirstRawPart() ; while ( nRawId != GDB_ID_NULL) { if ( m_pMchMgr->VerifyRawPartPhase(nRawId, m_nPhase)) { // ciclo sui pezzi del grezzo int nPartId = m_pMchMgr->GetFirstPartInRawPart( nRawId) ; while ( nPartId != GDB_ID_NULL) { // ciclo sui layer dei pezzi int nLayId = m_pGeomDB->GetFirstGroupInGroup( nPartId) ; while ( nLayId != GDB_ID_NULL) { // ciclo sulle entità del layer int nEntId = m_pGeomDB->GetFirstInGroup( nLayId) ; while ( nEntId != GDB_ID_NULL) { // se entità superficie e visibile, la aggiungo int nStat ; if ( m_pGeomDB->GetGeoType( nEntId) == SRF_TRIMESH && m_pGeomDB->GetCalcStatus( nEntId, nStat) && nStat != GDB_ST_OFF) vSurfId.emplace_back( nEntId) ; // passo alla entità successiva nEntId = m_pGeomDB->GetNext( nEntId) ; } nLayId =m_pGeomDB->GetNextGroup( nLayId) ; } nPartId = m_pMchMgr->GetNextPartInRawPart( nPartId) ; } } nRawId = m_pMchMgr->GetNextRawPart( nRawId) ; } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) { // recupero distanze di sicurezza double dSafeZ = GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // calcolo lo zig-zag double dPockRad = m_Params.m_dSideStep ; double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ; ICRVCOMPOPOVECTOR vpCrvs ; if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle, POCKET_ZIGZAG, false, false, true, false, P_INVALID, nullptr, vpCrvs)) { m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ; return false ; } // determino il riferimento di base della svuotatura Frame3d frPocket ; Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ; frPocket.Set( ptCen, vtTool) ; // ciclo sulle curve risultanti bool bStart = true ; double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ; for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) { PtrOwner pMCrv( Release( vpCrvs[k])) ; pMCrv->ToLoc( frPocket) ; // li correggo per non interferire con le superfici if ( pCAvTlStm != nullptr) { // approssimo la curva con una polilinea PolyLine PL ; if ( ! pMCrv->ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)) return false ; // eventuale aggiunta di punti per garantire max distanza const double MIN_DIST = 1. ; const double MAX_DIST = 50. ; double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ; if ( ! PL.AdjustForMaxSegmentLen( dDist)) return false ; // porto nel riferimento delle superfici PL.LocToLoc( frPocket, frSurf) ; // porto i dati geometrici in locale alle superfici Vector3d vtAxL = vtTool ; vtAxL.ToLoc( frSurf) ; Vector3d vtMoveL = vtAxL ; // traslo della lunghezza utensile diminuita dell'affondamento PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ; // eseguo CAv if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( k + 1) * dProgCoeff)) return false ; // contro-traslo della lunghezza utensile PL.Translate( - vtAxL * m_TParams.m_dLen) ; // riporto la polilinea nel riferimento della curva PL.LocToLoc( frSurf, frPocket) ; // elimino i punti allineati PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ; // creo una curva composita a partire dalla polilinea PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo) || ! pCompo->FromPolyLine( PL)) return false ; // sostituisco la vecchia curva con la nuova pMCrv.Set( pCompo) ; } // ciclo sulle curve elementari int nMaxInd = pMCrv->GetCurveCount() - 1 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pMCrv->GetCurve( i) ; // copio la curva PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; pCurve->ToGlob( frPocket) ; // se prima entità if ( i == 0 ) { // dati inizio entità Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto) double dStartOnExtr = vtStart * vtTool ; if ( dStartOnExtr > 0) { vtStart -= dStartOnExtr * vtTool ; vtStart.Normalize() ; } // determino normale della superficie sul punto iniziale Vector3d vtNorm ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) { Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) vtNorm = V_NULL ; } // determino inizio attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1)) return false ; // eventuale correzione inizio attacco per evitare interferenze if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1)) return false ; // determino elevazione su inizio attacco double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; dStElev -= ( ptP1 - ptStart) * vtTool ; // se inizio, approccio globale al punto iniziale if ( bStart) { if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) { m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ; return false ; } bStart = false ; } // altrimenti, approccio di collegamento else { if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) { m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ; return false ; } } // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) { m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ; return false ; } } // elaborazioni sulla curva corrente (sempre un segmento di retta) ICurveLine* pLine = GetCurveLine( pCurve) ; if ( pLine == nullptr) return false ; Point3d ptP3 = pLine->GetEnd() ; Vector3d vtMove ; pLine->GetStartDir( vtMove) ; SetFeed( GetRightFeed( vtMove, vtTool)) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; // se ultima entità if ( i == nMaxInd) { // dati fine entità Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ; // vettore tangente finale non deve scendere rispetto a estrusione double dEndOnExtr = vtEnd * vtTool ; if ( dEndOnExtr < 0) { vtEnd -= dEndOnExtr * vtTool ; vtEnd.Normalize() ; } // determino normale della superficie sul punto finale Vector3d vtNorm ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) { Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) vtNorm = V_NULL ; } // determino fine uscita Point3d ptP1 ; if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1)) return false ; // eventuale correzione fine uscita per evitare interferenze if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1)) return false ; // aggiungo uscita SetFeed( GetEndFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) { m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ; return false ; } // determino elevazione su fine uscita double dEndElev ; if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; dEndElev -= ( ptP1 - ptEnd) * vtTool ; // se non è ultimo tratto, aggiungo retrazione di collegamento if ( k < int( vpCrvs.size()) - 1) { if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ; return false ; } } // altrimenti aggiungo retrazione finale else { if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ; return false ; } } } } } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) { // recupero distanze di sicurezza double dSafeZ = GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // calcolo lo one-way double dPockRad = m_Params.m_dSideStep ; double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ; ICRVCOMPOPOVECTOR vpCrvs ; if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle, POCKET_ONEWAY, false, false, true, false, P_INVALID, nullptr, vpCrvs)) { m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ; return false ; } // determino il riferimento di base della svuotatura Frame3d frPocket ; Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ; frPocket.Set( ptCen, vtTool) ; // ciclo sulle curve risultanti bool bStart = true ; double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ; for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) { PtrOwner pMCrv( Release( vpCrvs[k])) ; pMCrv->ToLoc( frPocket) ; // li correggo per non interferire con le superfici if ( pCAvTlStm != nullptr) { // approssimo la curva con una polilinea PolyLine PL ; if ( ! pMCrv->ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)) return false ; // eventuale aggiunta di punti per garantire max distanza const double MIN_DIST = 1. ; const double MAX_DIST = 50. ; double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ; if ( ! PL.AdjustForMaxSegmentLen( dDist)) return false ; // porto nel riferimento delle superfici PL.LocToLoc( frPocket, frSurf) ; // porto i dati geometrici in locale alle superfici Vector3d vtAxL = vtTool ; vtAxL.ToLoc( frSurf) ; Vector3d vtMoveL = vtAxL ; // traslo della lunghezza utensile diminuita dell'affondamento PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ; // eseguo CAv if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( k + 1) * dProgCoeff)) return false ; // contro-traslo della lunghezza utensile PL.Translate( - vtAxL * m_TParams.m_dLen) ; // riporto la polilinea nel riferimento della curva PL.LocToLoc( frSurf, frPocket) ; // elimino i punti allineati PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ; // creo una curva composita a partire dalla polilinea PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo) || ! pCompo->FromPolyLine( PL)) return false ; // sostituisco la vecchia curva con la nuova pMCrv.Set( pCompo) ; } // ciclo sulle curve elementari int nMaxInd = pMCrv->GetCurveCount() - 1 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pMCrv->GetCurve( i) ; // copio la curva PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; pCurve->ToGlob( frPocket) ; // se prima entità if ( i == 0 ) { // dati inizio entità Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto) double dStartOnExtr = vtStart * vtTool ; if ( dStartOnExtr > 0) { vtStart -= dStartOnExtr * vtTool ; vtStart.Normalize() ; } // determino normale della superficie sul punto iniziale Vector3d vtNorm ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) { Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) vtNorm = V_NULL ; } // determino inizio attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1)) return false ; // eventuale correzione inizio attacco per evitare interferenze if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1)) return false ; // determino elevazione su inizio attacco double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; dStElev -= ( ptP1 - ptStart) * vtTool ; // se inizio, approccio globale al punto iniziale if ( bStart) { if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) { m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ; return false ; } bStart = false ; } // altrimenti, approccio di collegamento else { if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) { m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ; return false ; } } // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) { m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ; return false ; } } // elaborazioni sulla curva corrente (sempre un segmento di retta) ICurveLine* pLine = GetCurveLine( pCurve) ; if ( pLine == nullptr) return false ; Point3d ptP3 = pLine->GetEnd() ; Vector3d vtMove ; pLine->GetStartDir( vtMove) ; SetFeed( GetRightFeed( vtMove, vtTool)) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; // se ultima entità if ( i == nMaxInd) { // dati fine entità Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ; // vettore tangente finale non deve scendere rispetto a estrusione double dEndOnExtr = vtEnd * vtTool ; if ( dEndOnExtr < 0) { vtEnd -= dEndOnExtr * vtTool ; vtEnd.Normalize() ; } // determino normale della superficie sul punto finale Vector3d vtNorm ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) { Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) vtNorm = V_NULL ; } // determino fine uscita Point3d ptP1 ; if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1)) return false ; // eventuale correzione fine uscita per evitare interferenze if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1)) return false ; // aggiungo uscita SetFeed( GetEndFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) { m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ; return false ; } // determino elevazione su fine uscita double dEndElev ; if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; dEndElev -= ( ptP1 - ptEnd) * vtTool ; // se non è ultimo tratto, aggiungo retrazione di collegamento if ( k < int( vpCrvs.size()) - 1) { if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ; return false ; } } // altrimenti aggiungo retrazione finale else { if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ; return false ; } } } } } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut) { // recupero distanze di sicurezza double dSafeZ = GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // calcolo la spirale double dPockRad = m_Params.m_dSideStep ; double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ; int nType = ( bInVsOut ? POCKET_SPIRALIN : POCKET_SPIRALOUT) ; ICRVCOMPOPOVECTOR vpCrvs ; if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle, nType, false, false, true, false, P_INVALID, nullptr, vpCrvs)) { m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ; return false ; } // determino il riferimento di base della svuotatura Frame3d frPocket ; Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ; frPocket.Set( ptCen, vtTool) ; // ciclo sulle curve risultanti bool bStart = true ; for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) { PtrOwner pMCrv( Release( vpCrvs[k])) ; pMCrv->ToLoc( frPocket) ; // li correggo per non interferire con le superfici if ( pCAvTlStm != nullptr) { // approssimo la curva con una polilinea PolyLine PL ; if ( ! pMCrv->ApproxWithLines( m_Params.m_dApprox, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL)) return false ; // eventuale aggiunta di punti per garantire max distanza const double MIN_DIST = 1. ; const double MAX_DIST = 50. ; double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ; if ( ! PL.AdjustForMaxSegmentLen( dDist)) return false ; // porto nel riferimento delle superfici PL.LocToLoc( frPocket, frSurf) ; // porto i dati geometrici in locale alle superfici Vector3d vtAxL = vtTool ; vtAxL.ToLoc( frSurf) ; Vector3d vtMoveL = vtAxL ; // traslo della lunghezza utensile diminuita dell'affondamento PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ; // eseguo CAv if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox)) return false ; // contro-traslo della lunghezza utensile PL.Translate( - vtAxL * m_TParams.m_dLen) ; // riporto la polilinea nel riferimento della curva PL.LocToLoc( frSurf, frPocket) ; // elimino i punti allineati PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ; // creo una curva composita a partire dalla polilinea PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo) || ! pCompo->FromPolyLine( PL)) return false ; // sostituisco la vecchia curva con la nuova pMCrv.Set( pCompo) ; } // ciclo sulle curve elementari int nMaxInd = pMCrv->GetCurveCount() - 1 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pMCrv->GetCurve( i) ; // copio la curva PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; pCurve->ToGlob( frPocket) ; // se prima entità if ( i == 0 ) { // dati inizio entità Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto) double dStartOnExtr = vtStart * vtTool ; if ( dStartOnExtr > 0) { vtStart -= dStartOnExtr * vtTool ; vtStart.Normalize() ; } // determino normale della superficie sul punto iniziale Vector3d vtNorm ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) { Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) vtNorm = V_NULL ; } // determino inizio attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1)) return false ; // eventuale correzione inizio attacco per evitare interferenze if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1)) return false ; // determino elevazione su inizio attacco double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; dStElev -= ( ptP1 - ptStart) * vtTool ; // se inizio, approccio globale al punto iniziale if ( bStart) { if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) { m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ; return false ; } bStart = false ; } // altrimenti, approccio di collegamento else { if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) { m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ; return false ; } } // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) { m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ; return false ; } } // elaborazioni sulla curva corrente (sempre un segmento di retta) ICurveLine* pLine = GetCurveLine( pCurve) ; if ( pLine == nullptr) return false ; Point3d ptP3 = pLine->GetEnd() ; Vector3d vtMove ; pLine->GetStartDir( vtMove) ; SetFeed( GetRightFeed( vtMove, vtTool)) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; // se ultima entità if ( i == nMaxInd) { // dati fine entità Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ; // vettore tangente finale non deve scendere rispetto a estrusione double dEndOnExtr = vtEnd * vtTool ; if ( dEndOnExtr < 0) { vtEnd -= dEndOnExtr * vtTool ; vtEnd.Normalize() ; } // determino normale della superficie sul punto finale Vector3d vtNorm ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) { Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) vtNorm = V_NULL ; } // determino fine uscita Point3d ptP1 ; if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1)) return false ; // eventuale correzione fine uscita per evitare interferenze if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1)) return false ; // aggiungo uscita SetFeed( GetEndFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) { m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ; return false ; } // determino elevazione su fine uscita double dEndElev ; if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; dEndElev -= ( ptP1 - ptEnd) * vtTool ; // se non è ultimo tratto, aggiungo retrazione di collegamento if ( false) { if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ; return false ; } } // altrimenti aggiungo retrazione finale else { if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ; return false ; } } } } } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) { SetFlag( 1) ; // se sopra attacco c'è spazio per sicurezza o approccio double dSafeDist = dSafeZ ; if ( dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { // se distanza di sicurezza minore di distanza di inizio if ( dSafeDist < dAppr + 10 * EPS_SMALL) { // 1 -> punto sopra inizio Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; } else { // 1a -> punto sopra inizio Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ; Point3d ptP1a = ptP1b + vtTool * ( dSafeDist - dAppr) ; if ( ( AddRapidStart( ptP1a) == GDB_ID_NULL)) return false ; // 1b -> punto appena sopra inizio if ( ( dElev + dAppr) > EPS_SMALL) { SetFlag( 0) ; if ( AddRapidMove( ptP1b) == GDB_ID_NULL) return false ; } } // affondo al punto iniziale SetFlag( 0) ; SetFeed( GetTipFeed()) ; if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; } else { // affondo diretto al punto iniziale SetFlag( 0) ; if ( AddRapidStart( ptP) == GDB_ID_NULL) return false ; } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) { // se sopra attacco c'è spazio per approccio if ( ( dElev + dAppr) > 10 * EPS_SMALL) { // 1b -> punto appena sopra inizio Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ; if ( ( dElev + dAppr) > EPS_SMALL) { SetFlag( 0) ; if ( AddRapidMove( ptP1b) == GDB_ID_NULL) return false ; } // affondo al punto iniziale SetFlag( 0) ; SetFeed( GetTipFeed()) ; if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; } else { // affondo diretto al punto iniziale SetFlag( 0) ; if ( AddRapidMove( ptP) == GDB_ID_NULL) return false ; } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) { // se sopra uscita c'è spazio per approccio if ( ( dElev + dAppr) > 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 ; } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) { // se sopra uscita c'è spazio per sicurezza o approccio double dSafeDist = dSafeZ ; if ( dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { if ( dSafeDist < dAppr + 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 Point3d ptP4a = ptP + vtTool * ( dElev + dAppr) ; if ( dElev + dAppr > EPS_SMALL) { SetFeed( GetEndFeed()) ; if ( AddLinearMove( ptP4a) == GDB_ID_NULL) return false ; } // 4b -> movimento di risalita sopra il punto finale Point3d ptP4b = ptP4a + vtTool * ( dSafeDist - dAppr) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } } return true ; } //---------------------------------------------------------------------------- int SurfFinishing::GetLeadInType( void) const { if ( abs( m_Params.m_dLiTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) && abs( m_Params.m_dLiPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1)) return SURFFIN_LI_NONE ; return m_Params.m_nLeadInType ; } //---------------------------------------------------------------------------- bool SurfFinishing::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, const Vector3d& vtNorm, Point3d& ptP1) const { // Assegno tipo e parametri int nType = GetLeadInType() ; double dTang = m_Params.m_dLiTang ; double dPerp = m_Params.m_dLiPerp ; // Calcolo punto iniziale switch ( nType) { case SURFFIN_LI_NONE : ptP1 = ptStart ; return true ; case SURFFIN_LI_LINEAR : case SURFFIN_LI_TANGENT : { Vector3d vtPerp = vtStart ; Vector3d vtRot = OrthoCompo( vtTool, vtStart) ; vtPerp.Rotate( vtRot, 0, -1) ; if ( vtPerp * vtNorm < -EPS_ZERO) vtPerp.Invert() ; ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp ; } return true ; default : return false ; } } //---------------------------------------------------------------------------- bool SurfFinishing::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, bool bSplitArcs) { // Se inizio e fine coincidono, non devo fare alcunché if ( AreSamePointApprox( ptP1, ptStart)) return true ; // Assegno il tipo int nType = GetLeadInType() ; // Eseguo a seconda del tipo switch ( nType) { case SURFFIN_LI_NONE : return true ; case SURFFIN_LI_LINEAR : return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ; case SURFFIN_LI_TANGENT : PtrOwner pCrv( GetArc2PVN( ptStart, ptP1, -vtStart, vtTool)) ; if ( IsNull( pCrv)) return false ; pCrv->Invert() ; return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ; } return true ; } //---------------------------------------------------------------------------- int SurfFinishing::GetLeadOutType( void) const { if ( abs( m_Params.m_dLoTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) && abs( m_Params.m_dLoPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1) && m_Params.m_nLeadOutType != SURFFIN_LO_AS_LI) return SURFFIN_LO_NONE ; return m_Params.m_nLeadOutType ; } //---------------------------------------------------------------------------- bool SurfFinishing::CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtTool, const Vector3d& vtNorm, Point3d& ptP1) const { // Assegno tipo e parametri int nType = GetLeadOutType() ; double dTang = m_Params.m_dLoTang ; double dPerp = m_Params.m_dLoPerp ; // se uscita come ingresso if ( nType == SURFFIN_LO_AS_LI) { int nLiType = GetLeadInType() ; switch ( nLiType) { case SURFFIN_LI_LINEAR : nType = SURFFIN_LO_LINEAR ; break ; case SURFFIN_LI_TANGENT : nType = SURFFIN_LO_TANGENT ; break ; default : nType = SURFFIN_LO_NONE ; break ; } dTang = m_Params.m_dLiTang ; dPerp = m_Params.m_dLiPerp ; } // Calcolo punto finale switch ( nType) { case SURFFIN_LO_NONE : ptP1 = ptEnd ; return true ; case SURFFIN_LO_LINEAR : case SURFFIN_LO_TANGENT : { // calcolo punto finale dell'uscita Vector3d vtPerp = vtEnd ; Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ; vtPerp.Rotate( vtRot, 0, -1) ; if ( vtPerp * vtNorm < -EPS_ZERO) vtPerp.Invert() ; ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ; } return true ; default : return false ; } } //---------------------------------------------------------------------------- bool SurfFinishing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Point3d& ptP1, const Vector3d& vtTool, bool bSplitArcs) { // Se inizio e fine coincidono, non devo fare alcunché if ( AreSamePointApprox( ptEnd, ptP1)) return true ; // Assegno tipo e parametri int nType = GetLeadOutType() ; // se uscita come ingresso if ( nType == SURFFIN_LO_AS_LI) { int nLiType = GetLeadInType() ; switch ( nLiType) { case SURFFIN_LI_LINEAR : nType = SURFFIN_LO_LINEAR ; break ; case SURFFIN_LI_TANGENT : nType = SURFFIN_LO_TANGENT ; break ; default : nType = SURFFIN_LO_NONE ; break ; } } // eseguo a seconda del tipo switch ( nType) { case SURFFIN_LO_NONE : return true ; case SURFFIN_LO_LINEAR : return ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ; case SURFFIN_LO_TANGENT : // inserisco uscita PtrOwner pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtTool)) ; if ( IsNull( pCrv)) return false ; // assegno direzione finale dell'uscita Vector3d vtDirF ; if ( ! pCrv->GetEndDir( vtDirF)) return false ; // emetto movimento return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ; } return true ; } //---------------------------------------------------------------------------- bool SurfFinishing::GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, Point3d& ptP1) const { // porto i punti e il versore nel riferimento superficie Point3d ptStartL = GetToLoc( ptStart, frSurf) ; Point3d ptEndL = GetToLoc( ptEnd, frSurf) ; Vector3d vtToolL = GetToLoc( vtTool, frSurf) ; // porto i punti dal tip al naso mandrino ptStartL += vtToolL * m_TParams.m_dLen ; ptEndL += vtToolL * m_TParams.m_dLen ; // verifico che il movimento non interferisca con la superficie PNTULIST lstPntU{ { ptStartL, 0}, { ptEndL, 1}} ; if ( ! pCAvTlStm->TestPath( lstPntU, vtToolL, vtToolL, m_Params.m_dApprox, 0)) return false ; // cerco l'ultimo punto non spostato per evitare collisione bool bFound = false ; auto currPU = lstPntU.begin() ; while ( ! bFound && currPU != lstPntU.end()) { auto nextPU = next( currPU) ; if ( nextPU == lstPntU.end() || nextPU->second > m_Params.m_dApprox){ bFound = true ; ptP1 = GetToGlob( currPU->first - vtToolL * m_TParams.m_dLen, frSurf) ; } currPU = nextPU ; } return bFound ; } //---------------------------------------------------------------------------- bool SurfFinishing::GetSurfaceNormalAtPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptTool, const Vector3d& vtTool, Vector3d& vtNorm) const { // porto il punto e il versore nel riferimento superficie Point3d ptToolL = GetToLoc( ptTool, frSurf) ; Vector3d vtToolL = GetToLoc( vtTool, frSurf) ; // porto i punti dal tip al naso mandrino ptToolL += vtToolL * m_TParams.m_dLen ; // affondo di poco il punto per ricavare ultima superficie di contatto e sua normale double dMove ; Vector3d vtNormL ; if ( ! pCAvTlStm->TestPosition( ptToolL - vtToolL, vtToolL, vtToolL, dMove, &vtNormL) || dMove < EPS_SMALL) return false ; // porto la normale in globale vtNorm = GetToGlob( vtNormL, frSurf) ; return true ; } //---------------------------------------------------------------------------- double SurfFinishing::GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const { // Determino i versori Vector3d vtM = vtMove ; vtM.Normalize() ; Vector3d vtT = vtTool ; vtT.Normalize() ; // Angolo tra movimento e versore utensile double dCosMove = vtM * vtT ; // Se l'utensile non ha movimento significativo di punta, si restituisce la feed standard if ( dCosMove > - COS_ORTO_ANG_SMALL) return GetFeed() ; // Altrimenti non si deve superare la massima velocità di punta prevista return min( GetFeed(), GetTipFeed() / abs( dCosMove)) ; } //---------------------------------------------------------------------------- double SurfFinishing::GetRadiusForStartEndElevation( void) const { const double DELTA_ELEV_RAD = 4.0 ; double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ; return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; }