//---------------------------------------------------------------------------- // EgalTech 2015-2022 //---------------------------------------------------------------------------- // File : Milling.cpp Data : 16.03.22 Versione : 2.4c1 // Contenuto : Implementazione gestione fresature. // // // // Modifiche : 07.06.15 DS Creazione modulo. // 11.08.16 DS Miglioria gestione PV per più loop. // 02.06.20 DS Aggiunta gestione Tabs. // 16.03.22 DS Migliorata sicurezza lame sopra. // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "MachMgr.h" #include "DllMain.h" #include "Milling.h" #include "GeoConst.h" #include "OperationConst.h" #include "/EgtDev/Include/EXeCmdLogOff.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/EGkCurveAux.h" #include "/EgtDev/Include/EGkSfrCreate.h" #include "/EgtDev/Include/EGkSurfTriMesh.h" #include "/EgtDev/Include/EGkExtText.h" #include "/EgtDev/Include/EGkDistPointCurve.h" #include "/EgtDev/Include/EGkIntervals.h" #include "/EgtDev/Include/EGkUserObjFactory.h" #include "/EgtDev/Include/EGnStringKeyVal.h" #include "/EgtDev/Include/EgtNumUtils.h" #include "/EgtDev/Include/EgtPointerOwner.h" using namespace std ; //------------------------------ Constants ------------------------------------ const double OSC_MIN_LEN = 0.1 ; const double ELEV_MAX_OFFS = 25.0 ; const double MIN_SAFEDIST = 5.0 ; //------------------------------ Errors -------------------------------------- // 2301 = "Error in Milling : UpdateToolData failed" // 2302 = "Error in Milling : Offset not computable" // 2303 = "Error in Milling : Empty RawBox" // 2304 = "Error in Milling : Depth not computable" // 2305 = "Error in Milling : machining depth (xx) bigger than MaxMaterial (yy)" // 2306 = "Error in Milling : Entity GetElevation" // 2307 = "Error in Milling : missing aggregate from bottom" // 2308 = "Error in Milling : path too far from part sides" // 2309 = "Error in Milling : Approach not computable" // 2310 = "Error in Milling : LeadIn not computable" // 2311 = "Error in Milling : LeadOut not computable" // 2312 = "Error in Milling : Retract not computable" // 2313 = "Error in Milling : Linear Approx not computable" // 2314 = "Error in Milling : LeadIn must be out of rawpart" // 2315 = "Error in Milling : Chaining failed" // 2316 = "Error in Milling : Tool MaxMaterial too small (xx)" // 2317 = "Error in Milling : axes values not calculable" // 2318 = "Error in Milling : outstroke xx" // 2319 = "Error in Milling : link movements not calculable" // 2320 = "Error in Milling : link outstroke xx" // 2321 = "Error in Milling : post apply not calculable" // 2322 = "Error in Milling : Tool loading failed" // 2323 = "Error in Milling : machining depth (xxx) bigger than MaxDepth (yyy)" // 2324 = "Error in Milling : LeadOut must be out of rawpart" // 2351 = "Warning in Milling : Skipped entity (xx)" // 2352 = "Warning in Milling : No machinable path" // 2353 = "Warning in Milling : Tool name changed (xx)" // 2354 = "Warning in Milling : Tool data changed (xx)" // 2355 = "Warning in Milling : skipped Path too short" // 2356 = "Warning in Milling : machining step too small (xx)" // 2357 = "Warning in Milling : machining step (xxx) bigger than MaxMaterial (yyy)" // 2358 = "Warning in Milling : machining depth (xxx) bigger than MaxMaterial (yyy)" // 2359 = "Warning in Milling : oscillation incompatible with saw blade" // 2360 = "Warning in Milling : oscillation incompatible with depth" // 2361 = "Warning in Milling : oscillation impossible" // 2362 = "Warning in Milling : tabs incompatible with saw blade" // 2363 = "Warning in Milling : tabs impossible" // 2364 = "Warning in Milling : tabs number less than minimum" //---------------------------------------------------------------------------- USEROBJ_REGISTER( GetOperationClass( OPER_MILLING), Milling) ; //---------------------------------------------------------------------------- const string& Milling::GetClassName( void) const { return USEROBJ_GETNAME( Milling) ; } //---------------------------------------------------------------------------- Milling* Milling::Clone( void) const { // alloco oggetto Milling* pMill = new(nothrow) Milling ; // eseguo copia dei dati if ( pMill != nullptr) { try { pMill->m_vId = m_vId ; pMill->m_pMchMgr = m_pMchMgr ; pMill->m_nPhase = m_nPhase ; pMill->m_Params = m_Params ; pMill->m_TParams = m_TParams ; pMill->m_dTHoldBase = m_dTHoldBase ; pMill->m_dTHoldLen = m_dTHoldLen ; pMill->m_dTHoldDiam = m_dTHoldDiam ; pMill->m_nStatus = m_nStatus ; pMill->m_nMills = m_nMills ; pMill->m_bStepOn = m_bStepOn ; pMill->m_dAddedOverlap = m_dAddedOverlap ; pMill->m_nHeadSolCh = m_nHeadSolCh ; pMill->m_bTiltingTab = m_bTiltingTab ; pMill->m_bAboveHead = m_bAboveHead ; pMill->m_bAggrBottom = m_bAggrBottom ; pMill->m_dCurrOscillLen = m_dCurrOscillLen ; pMill->m_dCurrTabsLen = m_dCurrTabsLen ; } catch( ...) { delete pMill ; return nullptr ; } } // ritorno l'oggetto return pMill ; } //---------------------------------------------------------------------------- bool Milling::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_nMills) + szNewLine ; sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ; return true ; } //---------------------------------------------------------------------------- bool Milling::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_nMills, vString[++k])) return false ; if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k])) return false ; } catch( ...) { return false ; } return true ; } //---------------------------------------------------------------------------- bool Milling::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_nMills)) return false ; } else if ( sKey == KEY_STAT) { if ( ! FromString( sVal, m_nStatus)) return false ; } } return true ; } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- Milling::Milling( 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_nMills = 0 ; m_bStepOn = false ; m_dAddedOverlap = 0 ; m_nHeadSolCh = MCH_SCC_NONE ; m_bTiltingTab = false ; m_bAboveHead = true ; m_bAggrBottom = false ; m_dCurrOscillLen = 0 ; m_dCurrTabsLen = 0 ; } //---------------------------------------------------------------------------- bool Milling::Prepare( const string& sMillName) { // 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 MillingData* pDdata = GetMillingData( pMMgr->GetMachining( sMillName)) ; 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 Milling::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 ; case MPA_LEAVETAB : if ( bVal != m_Params.m_bLeaveTab) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_bLeaveTab = bVal ; return true ; case MPA_TOOLINVERT : if ( bVal != m_Params.m_bToolInvert) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_bToolInvert = bVal ; return true ; case MPA_OSCENABLE : if ( bVal != m_Params.m_bOscEnable) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_bOscEnable = bVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool Milling::SetParam( int nType, int nVal) { switch ( nType) { case MPA_WORKSIDE : if ( ! m_Params.VerifyWorkSide( nVal)) return false ; if ( nVal != m_Params.m_nWorkSide) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nWorkSide = 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_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_TABMIN : if ( ! m_Params.VerifyTabMin( nVal)) return false ; if ( nVal != m_Params.m_nTabMin) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nTabMin = nVal ; return true ; case MPA_TABMAX : if ( ! m_Params.VerifyTabMax( nVal)) return false ; if ( nVal != m_Params.m_nTabMax) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nTabMax = 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 ; case MPA_FACEUSE : if ( ! m_Params.VerifyFaceUse( nVal)) return false ; if ( nVal != m_Params.m_nFaceUse) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nFaceUse = nVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool Milling::SetParam( int nType, double dVal) { switch ( nType) { case MPA_SPEED : if ( ! m_TParams.VerifySpeed( dVal)) return false ; if ( abs( m_TParams.m_dSpeed - dVal) < EPS_MACH_ANG_PAR) dVal = 0 ; if ( abs( dVal - m_Params.m_dSpeed) > EPS_MACH_ANG_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dSpeed = dVal ; return true ; case MPA_FEED : if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR) dVal = 0 ; if ( abs( dVal - m_Params.m_dFeed) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dFeed = dVal ; return true ; case MPA_STARTFEED : if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR) dVal = 0 ; if ( abs( dVal - m_Params.m_dStartFeed) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dStartFeed = dVal ; return true ; case MPA_ENDFEED : if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR) dVal = 0 ; if ( abs( dVal - m_Params.m_dEndFeed) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dEndFeed = dVal ; return true ; case MPA_TIPFEED : if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR) dVal = 0 ; if ( abs( dVal - m_Params.m_dTipFeed) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dTipFeed = dVal ; return true ; case MPA_OFFSR : if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR) dVal = UNKNOWN_PAR ; if ( abs( dVal - m_Params.m_dOffsR) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dOffsR = dVal ; return true ; case MPA_OFFSL : if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR) dVal = UNKNOWN_PAR ; if ( abs( dVal - m_Params.m_dOffsL) > EPS_MACH_LEN_PAR) 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 ( abs( dVal - m_Params.m_dStartPos) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dStartPos = dVal ; return true ; case MPA_OVERL : if ( abs( dVal - m_Params.m_dOverlap) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dOverlap = dVal ; return true ; case MPA_STEP : if ( abs( dVal - m_Params.m_dStep) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dStep = dVal ; return true ; case MPA_STARTADDLEN : if ( abs( dVal - m_Params.m_dStartAddLen) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dStartAddLen = dVal ; return true ; case MPA_ENDADDLEN : if ( abs( dVal - m_Params.m_dEndAddLen) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dEndAddLen = dVal ; return true ; case MPA_OSCHEIGHT : if ( abs( dVal - m_Params.m_dOscHeight) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dOscHeight = dVal ; return true ; case MPA_OSCRAMPLEN : if ( abs( dVal - m_Params.m_dOscRampLen) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dOscRampLen = dVal ; return true ; case MPA_OSCFLATLEN : if ( abs( dVal - m_Params.m_dOscFlatLen) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dOscFlatLen = dVal ; return true ; case MPA_TABLEN : if ( abs( dVal - m_Params.m_dTabLen) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dTabLen = dVal ; return true ; case MPA_TABDIST : if ( abs( dVal - m_Params.m_dTabDist) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dTabDist = dVal ; return true ; case MPA_TABHEIGHT : if ( abs( dVal - m_Params.m_dTabHeight) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dTabHeight = dVal ; return true ; case MPA_TABANGLE : if ( abs( dVal - m_Params.m_dTabAngle) > EPS_MACH_ANG_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dTabAngle = 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_LIELEV : if ( abs( dVal - m_Params.m_dLiElev) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dLiElev = dVal ; return true ; case MPA_LICOMPLEN : if ( abs( dVal - m_Params.m_dLiCompLen) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dLiCompLen = 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_LOELEV : if ( abs( dVal - m_Params.m_dLoElev) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dLoElev = dVal ; return true ; case MPA_LOCOMPLEN : if ( abs( dVal - m_Params.m_dLoCompLen) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dLoCompLen = dVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool Milling::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 Milling::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 (tutte curve, tutti testi o tutte facce) int nType = GEO_NONE ; for ( const auto& Id : vIds) { // test sull'entità int nSubs ; if ( ! VerifyGeometry( Id, nSubs, nType)) { string sInfo = "Warning in Milling : Skipped entity " + ToString( Id) ; m_pMchMgr->SetWarning( 2351, 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() || vIds.empty()) ; } //---------------------------------------------------------------------------- bool Milling::Preview( bool bRecalc) { // reset numero percorsi di lavoro generati m_nMills = 0 ; // verifico validità gestore DB geometrico e Id del gruppo if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId)) return false ; // recupero gruppo per geometria ausiliaria int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ; bool bChain = false ; // se non c'è, lo aggiungo if ( nAuxId == GDB_ID_NULL) { nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; if ( nAuxId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nAuxId, MCH_AUX) ; m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ; bChain = true ; } // altrimenti, se chiesto ricalcolo, lo svuoto else if ( bRecalc) { m_pGeomDB->EmptyGroup( nAuxId) ; bChain = true ; } // aggiorno dati geometrici dell'utensile if ( ! UpdateToolData()) { m_pMchMgr->SetLastError( 2301, "Error in Milling : UpdateToolData failed") ; return false ; } m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ; // aggiorno anche se non necessario, comunque operazione veloce // 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( 2322, "Error in Milling : 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( 2315, "Error in Milling : Chaining failed") ; return false ; } // recupero gruppo per geometria di Preview int nPvId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_PV) ; // se non c'è, lo aggiungo if ( nPvId == GDB_ID_NULL) { nPvId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; if ( nPvId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nPvId, MCH_PV) ; } // altrimenti lo svuoto else m_pGeomDB->EmptyGroup( nPvId) ; // lavoro ogni singola catena int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ; while ( nPathId != GDB_ID_NULL) { if ( ! ProcessPath( nPathId, nPvId, GDB_ID_NULL)) return false ; nPathId = m_pGeomDB->GetNextGroup( nPathId) ; } return true ; } //---------------------------------------------------------------------------- bool Milling::Apply( bool bRecalc, bool bPostApply) { // reset numero percorsi di lavoro generati int nCurrMills = m_nMills ; m_nMills = 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( 2301, "Error in Milling : UpdateToolData failed") ; return false ; } m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ; // verifico se necessario continuare nell'aggiornamento if ( ! bRecalc && ! bToolChanged && ( m_nStatus == MCH_ST_OK || ( ! bPostApply && m_nStatus == MCH_ST_NO_POSTAPPL))) { m_nMills = nCurrMills ; LOG_DBG_INFO( GetEMkLogger(), "Milling apply skipped : status already ok") ; 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 ; } // recupero gruppo per vista ausiliaria int nAuxViewId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUXVIEW) ; // se non c'è, lo aggiungo if ( nAuxViewId == GDB_ID_NULL) { nAuxViewId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; if ( nAuxViewId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nAuxViewId, MCH_AUXVIEW) ; m_pGeomDB->SetMaterial( nAuxViewId, Color( 64, 0, 0)) ; m_pGeomDB->SetStatus( nAuxViewId, GDB_ST_OFF) ; } // altrimenti, se necessario chain, lo svuoto else if ( bChain) { m_pGeomDB->EmptyGroup( nAuxViewId) ; } // 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( 2322, "Error in Milling : 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) ; // 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) ; // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria if ( bChain) { if ( ! Chain( nAuxId)) { m_pMchMgr->SetLastError( 2315, "Error in Milling : Chaining failed") ; return false ; } CalcSurfAuxView( nAuxId, nAuxViewId) ; } // 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) ; return true ; } //---------------------------------------------------------------------------- bool Milling::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_nMills == 0) { m_pMchMgr->SetWarning( 2352, "Warning in Milling : 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( 2317, "Error in Milling : axes values not calculable") ; else m_pMchMgr->SetLastError( 2318, "Error in Milling : 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( 2319, "Error in Milling : link movements not calculable") ; else m_pMchMgr->SetLastError( 2320, "Error in Milling : 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( 2321, sErr) ; else m_pMchMgr->SetLastError( 2321, "Error in Milling : post apply not calculable") ; return false ; } return true ; } //---------------------------------------------------------------------------- bool Milling::GetParam( int nType, bool& bVal) const { switch ( nType) { case MPA_INVERT : bVal = m_Params.m_bInvert ; return true ; case MPA_LEAVETAB : bVal = m_Params.m_bLeaveTab ; return true ; case MPA_TOOLINVERT : bVal = m_Params.m_bToolInvert ; return true ; case MPA_OSCENABLE : bVal = m_Params.m_bOscEnable ; return true ; } bVal = false ; return false ; } //---------------------------------------------------------------------------- bool Milling::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_TYPE : nVal = MT_MILLING ; return true ; case MPA_WORKSIDE : nVal = m_Params.m_nWorkSide ; return true ; case MPA_STEPTYPE : nVal = m_Params.m_nStepType ; return true ; case MPA_LEADINTYPE : nVal = m_Params.m_nLeadInType ; return true ; case MPA_LEADOUTTYPE : nVal = m_Params.m_nLeadOutType ; return true ; case MPA_TABMIN : nVal = m_Params.m_nTabMin ; return true ; case MPA_TABMAX : nVal = m_Params.m_nTabMax ; return true ; case MPA_SCC : nVal = m_Params.m_nSolCh ; return true ; case MPA_FACEUSE : nVal = m_Params.m_nFaceUse ; return true ; } nVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool Milling::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_OVERL : dVal = m_Params.m_dOverlap ; return true ; case MPA_STEP : dVal = m_Params.m_dStep ; return true ; case MPA_STARTADDLEN : dVal = m_Params.m_dStartAddLen ; return true ; case MPA_ENDADDLEN : dVal = m_Params.m_dEndAddLen ; return true ; case MPA_OSCHEIGHT : dVal = m_Params.m_dOscHeight ; return true ; case MPA_OSCRAMPLEN : dVal = m_Params.m_dOscRampLen ; return true ; case MPA_OSCFLATLEN : dVal = m_Params.m_dOscFlatLen ; return true ; case MPA_TABLEN : dVal = m_Params.m_dTabLen ; return true ; case MPA_TABDIST : dVal = m_Params.m_dTabDist ; return true ; case MPA_TABHEIGHT : dVal = m_Params.m_dTabHeight ; return true ; case MPA_TABANGLE : dVal = m_Params.m_dTabAngle ; return true ; case MPA_LITANG : dVal = m_Params.m_dLiTang ; return true ; case MPA_LIPERP : dVal = m_Params.m_dLiPerp ; return true ; case MPA_LIELEV : dVal = m_Params.m_dLiElev ; return true ; case MPA_LICOMPLEN : dVal = m_Params.m_dLiCompLen ; return true ; case MPA_LOTANG : dVal = m_Params.m_dLoTang ; return true ; case MPA_LOPERP : dVal = m_Params.m_dLoPerp ; return true ; case MPA_LOELEV : dVal = m_Params.m_dLoElev ; return true ; case MPA_LOCOMPLEN : dVal = m_Params.m_dLoCompLen ; return true ; } dVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool Milling::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& Milling::GetToolData( void) const { return m_TParams ; } //---------------------------------------------------------------------------- bool Milling::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 Milling : tool name changed (" + m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ; m_pMchMgr->SetWarning( 2353, sInfo) ; m_Params.m_sToolName = m_TParams.m_sName ; } if ( bChanged) { string sInfo = "Warning in Milling : tool data changed (" + m_Params.m_sToolName + ")" ; m_pMchMgr->SetWarning( 2354, sInfo) ; } // se definito parametro di ritorno, lo assegno if ( pbChanged != nullptr) *pbChanged = bChanged ; return true ; } //---------------------------------------------------------------------------- bool Milling::GetGeometry( SELVECTOR& vIds) const { // restituisco l'elenco delle entità vIds = m_vId ; return true ; } //---------------------------------------------------------------------------- bool Milling::VerifyGeometry( SelData Id, int& nSubs, int& nType) { // ammessi : curve, testi, facce di trimesh o regioni const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ; if ( pGObj == nullptr) return false ; // se ammesse curve ed è tale if ( ( nType == GEO_NONE || nType == GEO_CURVE) && ( pGObj->GetType() & GEO_CURVE) != 0) { nType = GEO_CURVE ; const ICurve* pCurve = nullptr ; // se direttamente la curva if ( Id.nSub == SEL_SUB_ALL) { pCurve = ::GetCurve( pGObj) ; if ( pCurve == nullptr) return false ; if ( pCurve->GetType() == CRV_COMPO) nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ; else nSubs = 0 ; } // altrimenti sottocurva di composita else { const ICurveComposite* pCompo = GetCurveComposite( pGObj) ; pCurve = ( pCompo != nullptr ? pCompo->GetCurve( Id.nSub) : nullptr) ; if ( pCurve == nullptr) return false ; nSubs = 0 ; } return true ; } // se altrimenti ammessi testi ed è tale else if ( ( nType == GEO_NONE || nType == EXT_TEXT) && pGObj->GetType() == EXT_TEXT) { nType = EXT_TEXT ; const IExtText* pText = ::GetExtText( pGObj) ; if ( pText == nullptr) return false ; // tutto bene nSubs = 0 ; return true ; } // se altrimenti ammesse superfici trimesh ed è tale else if ( ( nType == GEO_NONE || nType == GEO_SURF) && pGObj->GetType() == SRF_TRIMESH) { nType = GEO_SURF ; const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ; if ( pSurf == nullptr) return false ; // se direttamente la superficie if ( Id.nSub == SEL_SUB_ALL) { // deve avere una sola faccia if ( pSurf->GetFacetCount() != 1) return false ; nSubs = 1 ; } // altrimenti faccia di superficie trimesh else { // se faccia non esistente if ( Id.nSub > pSurf->GetFacetCount()) return false ; nSubs = 0 ; } return true ; } // se altrimenti ammesse regioni ed è tale else if ( ( nType == GEO_NONE || nType == GEO_SURF) && pGObj->GetType() == SRF_FLATRGN) { nType = GEO_SURF ; const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ; if ( pReg == nullptr) return false ; // se direttamente la regione if ( Id.nSub == SEL_SUB_ALL) { nSubs = pReg->GetChunkCount() ; } // altrimenti chunk di regione else { // se chunk non esistente if ( Id.nSub >= pReg->GetChunkCount()) return false ; // tutto bene nSubs = 0 ; } return true ; } // altrimenti errore else return false ; } //---------------------------------------------------------------------------- bool Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC) { // ammessi : curve, testi, facce di trimesh o regioni 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()) ; if ( IsNull( pCurve)) return false ; // 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()) ; if ( IsNull( pCurve)) return false ; // 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) ; } // la porto in globale pCurve->ToGlob( frGlob) ; // la restituisco lstPC.emplace_back( Release( pCurve)) ; return true ; } // se altrimenti testo else if ( pGObj->GetType() == EXT_TEXT) { // recupero il testo const IExtText* pText = ::GetExtText( pGObj) ; if ( pText == nullptr) return false ; // recupero l'outline del testo if ( ! pText->GetOutline( lstPC)) return false ; // porto le curve in globale for ( auto pCrv : lstPC) pCrv->ToGlob( frGlob) ; // ritorno return true ; } // se altrimenti superficie trimesh else if ( pGObj->GetType() == SRF_TRIMESH) { // recupero la trimesh const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ; if ( pSurf == nullptr) return false ; // recupero l'indice della faccia int nFacet = ( ( Id.nSub == SEL_SUB_ALL) ? 0 : Id.nSub) ; // recupero i contorni della faccia POLYLINEVECTOR vPL ; pSurf->GetFacetLoops( nFacet, vPL) ; if ( vPL.empty()) return false ; // creo la curva a partire da quello esterno PtrOwner pCrvCompo( CreateCurveComposite()) ; pCrvCompo->FromPolyLine( vPL[0]) ; if ( ! pCrvCompo->IsValid()) return false ; // recupero la normale esterna della faccia Vector3d vtN ; if ( ! pSurf->GetFacetNormal( nFacet, vtN)) return false ; // assegno l'estrusione dalla normale alla faccia pCrvCompo->SetExtrusion( vtN) ; // unisco le eventuali parti allineate pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ; // la porto in globale pCrvCompo->ToGlob( frGlob) ; // sistemazioni varie int nToolDir ; if ( ( m_Params.m_nFaceUse & 64) != 0) nToolDir = TOOL_ORTUP ; else if ( ( m_Params.m_nFaceUse & 32) != 0) nToolDir = TOOL_ORTHO ; else nToolDir = TOOL_PARAL ; int nFaceUse = ( m_Params.m_nFaceUse & 31) ; AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, m_TParams.m_dThick) ; // la restituisco lstPC.emplace_back( Release( pCrvCompo)) ; return true ; } // se altrimenti regione else if ( pGObj->GetType() == SRF_FLATRGN) { // recupero la regione const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ; if ( pReg == nullptr) return false ; // recupero la normale della regione Vector3d vtN = pReg->GetNormVersor() ; if ( vtN.IsSmall()) return false ; // sistemazioni varie int nToolDir ; if ( ( m_Params.m_nFaceUse & 64) != 0) nToolDir = TOOL_ORTUP ; else if ( ( m_Params.m_nFaceUse & 32) != 0) nToolDir = TOOL_ORTHO ; else nToolDir = TOOL_PARAL ; int nFaceUse = ( m_Params.m_nFaceUse & 31) ; // determino intervallo di chunk int nCstart = 0 ; int nCend = pReg->GetChunkCount() ; if ( Id.nSub != SEL_SUB_ALL) { nCstart = Id.nSub ; nCend = nCstart + 1 ; } // ciclo sui chunk for ( int nC = nCstart ; nC < nCend ; ++ nC) { // recupero i contorni del chunk for ( int nL = 0 ; nL < pReg->GetLoopCount( nC) ; ++ nL) { PtrOwner pCrvCompo( CreateCurveComposite()) ; if ( IsNull( pCrvCompo) || ! pCrvCompo->AddCurve( pReg->GetLoop( nC, nL))) return false ; // assegno l'estrusione dalla normale alla regione pCrvCompo->SetExtrusion( vtN) ; // unisco le eventuali parti allineate pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ; // la porto in globale pCrvCompo->ToGlob( frGlob) ; // sistemazioni varie AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, m_TParams.m_dThick) ; // la restituisco lstPC.emplace_back( Release( pCrvCompo)) ; } } return true ; } // altrimenti errore else return false ; } //---------------------------------------------------------------------------- bool Milling::Chain( int nGrpDestId) { // vettore puntatori alle curve ICURVEPOVECTOR vpCrvs ; vpCrvs.reserve( m_vId.size()) ; // vettore selettori delle curve originali SELVECTOR vInds ; vInds.reserve( m_vId.size()) ; // 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 Milling : Skipped entity " + ToString( Id) ; m_pMchMgr->SetWarning( 2351, 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 Milling::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const { // se utensile lama if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) { // traslazione opposta a quanto fatto in AdjustPathDrawForSaw double dOffset = 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ; ptP.Translate( dOffset * pCamData->GetCorrDir()) ; } // negli altri casi, non devo fare alcunché return true ; } //---------------------------------------------------------------------------- bool Milling::AdjustArcCenterForAxesCalc( const CamData* pCamData, Point3d& ptCen) const { // se utensile lama if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) { // recupero il precedente movimento int nPrevId = m_pGeomDB->GetPrev( pCamData->GetOwner()) ; CamData* pPrevCamData = GetCamData( m_pGeomDB->GetUserObj( nPrevId)) ; if ( pPrevCamData == nullptr) return false ; // se versori correzione uguali, correggo il centro if ( AreSameVectorApprox( pCamData->GetCorrDir(), pPrevCamData->GetCorrDir())) { // traslazione opposta a quanto fatto in AdjustPathDrawForSaw double dOffset = 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ; ptCen.Translate( dOffset * pCamData->GetCorrDir()) ; } } // negli altri casi, non devo fare alcunché return true ; } //---------------------------------------------------------------------------- bool Milling::CalcSurfAuxView( int nAuxId, int nAuxViewId) { const double FAT_RAD = 0.5 ; if ( m_Params.m_nFaceUse != MILL_FU_NONE) { int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ; while ( nPathId != GDB_ID_NULL) { int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ; const ICurve* pCrv = ::GetCurve( m_pGeomDB->GetGeoObj( nCrvId)) ; if ( pCrv != nullptr) { ISurfFlatRegion* pSfr = GetSurfFlatRegionFromFatCurve( pCrv->Clone(), FAT_RAD, false, false) ; if ( pSfr != nullptr) { int nSfrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nAuxViewId, pSfr) ; } } nPathId = m_pGeomDB->GetNextGroup( nPathId) ; } } return true ; } //---------------------------------------------------------------------------- bool Milling::ProcessPath( int nPathId, int nPvId, int nClId) { // recupero gruppo per geometria temporanea const string GRP_TEMP = "Temp" ; int nTempId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, GRP_TEMP) ; // se non c'è, lo aggiungo if ( nTempId == GDB_ID_NULL) { nTempId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; if ( nTempId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nTempId, GRP_TEMP) ; } // altrimenti lo svuoto else m_pGeomDB->EmptyGroup( nTempId) ; // in ogni caso lo dichiaro temporaneo e non visibile m_pGeomDB->SetLevel( nTempId, GDB_LV_TEMP) ; m_pGeomDB->SetStatus( nTempId, GDB_ST_OFF) ; // copio la curva composita da elaborare int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ; if ( m_pGeomDB->GetGeoType( nCrvId) != CRV_COMPO) return false ; int nCopyId = m_pGeomDB->CopyGlob( nCrvId, GDB_ID_NULL, nTempId) ; if ( nCopyId == GDB_ID_NULL) return false ; ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( nCopyId)) ; // converto in archi e rette pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ; // eventuale inversione percorso if ( m_Params.m_bInvert) pCompo->Invert() ; // recupero direzione utensile da estrusione e spessore Vector3d vtTool ; pCompo->GetExtrusion( vtTool) ; if ( vtTool.IsSmall()) vtTool = Z_AX ; double dThick ; pCompo->GetThickness( dThick) ; // eventuale inversione direzione utensile if ( m_Params.m_bToolInvert) { vtTool.Invert() ; pCompo->SetExtrusion( vtTool) ; dThick = - dThick ; pCompo->SetThickness( dThick) ; } // se percorso chiuso con inizio/fine su angolo interno, porto la partenza a metà del primo lato if ( pCompo->IsClosed()) { Vector3d vtStart, vtEnd ; pCompo->GetStartDir( vtStart) ; pCompo->GetEndDir( vtEnd) ; if ( ! AreSameOrOppositeVectorApprox( vtStart, vtEnd)) { bool bAngCCW = ( ( vtEnd ^ vtStart) * vtTool > 0.0) ; if ( m_Params.m_dOverlap > EPS_SMALL || m_Params.m_nWorkSide == MILL_WS_CENTER || ( m_Params.m_nWorkSide == MILL_WS_RIGHT && ! bAngCCW) || ( m_Params.m_nWorkSide == MILL_WS_LEFT && bAngCCW)) pCompo->ChangeStartPoint( 0.5) ; } } // eventuali allungamenti/accorciamenti per percorso aperto o chiuso senza sovrapposizione if ( ! pCompo->IsClosed() || m_Params.m_dOverlap < EPS_SMALL) { // verifico che il percorso sia abbastanza lungo double dLen ; pCompo->GetLength( dLen) ; if ( dLen + m_Params.m_dStartAddLen + m_Params.m_dEndAddLen < 10 * EPS_SMALL) { m_pMchMgr->SetWarning( 2355, "Warning in Milling : skipped Path too short") ; return true ; } // se una sola entità circonferenza completa, la divido in due per poterla allungare if ( pCompo->GetCurveCount() == 1 && pCompo->IsClosed()) pCompo->AddJoint( 0.5) ; // eventuali allungamenti if ( m_Params.m_dStartAddLen > EPS_SMALL) { if ( ! pCompo->ExtendStartByLen( m_Params.m_dStartAddLen)) return false ; dLen += m_Params.m_dStartAddLen ; } if ( m_Params.m_dEndAddLen > EPS_SMALL) { if ( ! pCompo->ExtendEndByLen( m_Params.m_dEndAddLen)) return false ; dLen += m_Params.m_dEndAddLen ; } // eventuale accorciamenti (da fare dopo tutti gli allungamenti) if ( m_Params.m_dStartAddLen < - EPS_SMALL) { if ( ! pCompo->TrimStartAtLen( - m_Params.m_dStartAddLen)) return false ; dLen += m_Params.m_dStartAddLen ; } if ( m_Params.m_dEndAddLen < - EPS_SMALL) { if ( ! pCompo->TrimEndAtLen( dLen + m_Params.m_dEndAddLen)) return false ; dLen += m_Params.m_dEndAddLen ; } } // se utensile non centrato, eseguo correzione raggio utensile ed eventuale offset double dOffs = 0.5 * m_TParams.m_dDiam + GetOffsR() ; if ( m_Params.m_nWorkSide != MILL_WS_CENTER && abs( dOffs) > EPS_SMALL) { // valore offset double dSignOffs = ( m_Params.m_nWorkSide == MILL_WS_RIGHT) ? dOffs : - dOffs ; // esecuzione offset if ( ! CalcOffset( pCompo, dSignOffs)) { m_pMchMgr->SetLastError( 2302, "Error in Milling : Offset not computable") ; return false ; } } // eventuale sovrapposizione per percorso chiuso m_dAddedOverlap = 0 ; if ( pCompo->IsClosed()) { if ( m_Params.m_dOverlap > EPS_SMALL) { double dParS, dParE ; if ( pCompo->GetParamAtLength( 0.0, dParS) && pCompo->GetParamAtLength( m_Params.m_dOverlap, dParE)) { PtrOwner pCrv( pCompo->CopyParamRange( dParS, dParE)) ; if ( ! IsNull( pCrv)) { pCompo->AddCurve( Release( pCrv)) ; m_dAddedOverlap = m_Params.m_dOverlap ; } } } } // unisco le parti allineate (tranne inizio-fine se chiusa) if ( ! pCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false)) return false ; // flags per tabs e oscillazione del percorso corrente (se entrambi, solo tabs) bool bPathTabsEnable = m_Params.m_bLeaveTab ; bool bPathOscEnable = ( ! bPathTabsEnable && m_Params.m_bOscEnable) ; // se utensile lama, disabilito eventuali tabs o oscillazione if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) { if ( bPathTabsEnable) { bPathTabsEnable = false ; m_pMchMgr->SetWarning( 2362, "Warning in Milling : tabs incompatible with saw blade") ; } if ( bPathOscEnable) { bPathOscEnable = false ; m_pMchMgr->SetWarning( 2359, "Warning in Milling : oscillation incompatible with saw blade") ; } } // recupero i punti di inizio e fine (per poi salvarli nelle info di CL path) Point3d ptStart ; pCompo->GetStartPoint( ptStart) ; Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ; // 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( 2303, "Error in Milling : Empty RawBox") ; return false ; } // recupero distanza da fondo dei grezzi interessati dal percorso double dRbDist = 0 ; if ( AreSameVectorApprox( vtTool, Z_AX)) { if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, m_TParams.m_dTDiam, dRbDist)) return false ; } // valuto l'espressione dell'affondamento ExeLuaSetGlobNumVar( "TH", abs( dThick)) ; ExeLuaSetGlobNumVar( "RB", dRbDist) ; double dDepth ; string sMyDepth = m_Params.m_sDepth ; if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) { m_pMchMgr->SetLastError( 2304, "Error in Milling : Depth not computable") ; return false ; } // se spessore positivo, lo sottraggo dal risultato if ( dThick > 0) dDepth -= dThick ; // sottraggo eventuale offset longitudinale dDepth -= GetOffsL() ; // recupero nome del path string sPathName ; m_pGeomDB->GetName( nPathId, sPathName) ; // eventuale approssimazione con segmenti di retta int nSplitArcs = m_pMchMgr->GetCurrMachiningsMgr()->GetSplitArcs() ; bool bSplitArcs = ( nSplitArcs == SPLAR_ALWAYS || ( nSplitArcs == SPLAR_NO_XY_PLANE && ! vtTool.IsZplus()) || ( nSplitArcs == SPLAR_GEN_PLANE && vtTool.IsGeneric())) ; if ( bSplitArcs && ! ApproxWithLines( pCompo)) { m_pMchMgr->SetLastError( 2313, "Error in Milling : Linear Approx not computable") ; return false ; } // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi VerifyArcs( pCompo) ; // calcolo l'elevazione massima double dElev ; if ( CalcPathElevation( pCompo, vtTool, dDepth, 0.5 * m_TParams.m_dDiam, dElev)) { if ( dElev < EPS_SMALL && AreSameVectorApprox( vtTool, Z_AX)) { BBox3d b3Crv ; pCompo->GetLocalBBox( b3Crv) ; dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z + min( 0., dThick) + dDepth) ; } } else return false ; // eventuale imposizione massima elevazione da note utente double dMaxElev ; if ( FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxElev="), dMaxElev) && dElev > dMaxElev) dElev = dMaxElev ; // eventuale aggiuntivo all'elevazione per l'oscillazione double dAddElev = ( bPathOscEnable ? abs( m_Params.m_dOscHeight) : 0) ; // eventuale elevazione di fianco (solo per lama) double dSideElev = 0 ; FromString( ExtractInfo( m_Params.m_sUserNotes, "SideElev="), dSideElev) ; // verifico che lo step dell'utensile sia sensato double dOkStep = ( m_Params.m_dStep > EPS_SMALL ? m_Params.m_dStep + EPS_ZERO : 0) ; const double MIN_ZSTEP = ( m_TParams.m_nType != TT_MILL_POLISHING ? 0.1 : EPS_SMALL) ; if ( dOkStep >= EPS_SMALL && dOkStep < MIN_ZSTEP) { dOkStep = MIN_ZSTEP + EPS_ZERO ; string sInfo = "Warning in Milling : machining step too small (" + ToString( m_Params.m_dStep, 2) + ")" ; m_pMchMgr->SetWarning( 2356, sInfo) ; } // verifico che il massimo materiale dell'utensile sia sensato const double MIN_MAXMAT = 1.0 ; if ( m_TParams.m_dMaxMat < dElev && m_TParams.m_dMaxMat < MIN_MAXMAT) { string sInfo = "Error in Milling : Tool MaxMaterial too small (" + ToString( m_TParams.m_dMaxMat, 2) + ")" ; m_pMchMgr->SetLastError( 2316, sInfo) ; return false ; } // per frese normali, verifico di non superare il massimo materiale con possibilità di aggiustare if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // se lo step supera la capacità dell'utensile if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) { dOkStep = m_TParams.m_dMaxMat + EPS_SMALL ; string sInfo = "Warning in Milling : machining step (" + ToString( m_Params.m_dStep, 1) + ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ; m_pMchMgr->SetWarning( 2357, sInfo) ; } // se lavorazione singola if ( dOkStep < EPS_SMALL || dOkStep > dElev + dAddElev) { // se c'è oscillazione e l'elevazione complessiva supera la capacità dell'utensile, annullo l'oscillazione if ( bPathOscEnable && dElev + dAddElev > m_TParams.m_dMaxMat + EPS_SMALL) { bPathOscEnable = false ; dAddElev = 0 ; m_pMchMgr->SetWarning( 2360, "Warning in Milling : oscillation incompatible with depth") ; } // se l'elevazione supera la capacità dell'utensile if ( dElev > m_TParams.m_dMaxMat + EPS_SMALL) { // segnalo, riduco e continuo string sInfo = "Warning in Milling : machining depth (" + ToString( dElev, 1) + ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ; m_pMchMgr->SetWarning( 2358, sInfo) ; dDepth -= dElev - m_TParams.m_dMaxMat ; dElev = m_TParams.m_dMaxMat ; } } // altrimenti lavorazione a step else { // massimo affondamento dell'utensile double dSafe = m_pMchMgr->GetCurrMachiningsMgr()->GetMaxDepthSafe() ; double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? m_dTHoldBase : m_dTHoldLen) - dSafe ; // se c'è oscillazione e l'elevazione complessiva supera la capacità dell'utensile, annullo l'oscillazione if ( bPathOscEnable && dElev + dAddElev > dMaxDepth + EPS_SMALL) { bPathOscEnable = false ; dAddElev = 0 ; m_pMchMgr->SetWarning( 2360, "Warning in Milling : oscillation incompatible with depth") ; } // se l'elevazione supera il massimo affondamento dell'utensile if ( dElev > dMaxDepth + EPS_SMALL) { // segnalo, riduco e continuo string sInfo = "Warning in Milling : machining depth (" + ToString( dElev, 1) + ") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ; m_pMchMgr->SetWarning( 2358, sInfo) ; dDepth -= dElev - dMaxDepth ; dElev = dMaxDepth ; } } } // per lame e con elevazione di lato definita else if ( dSideElev > EPS_SMALL) { if ( dSideElev > m_TParams.m_dMaxMat) { string sInfo = "Error in Milling : machining depth (" + ToString( dSideElev, 1) + ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ; m_pMchMgr->SetLastError( 2305, sInfo) ; return false ; } } // verifico se tavola basculante bool bTiltTab = false ; m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab) && bTiltTab) ; // verifico se testa da sopra (Z+) m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ; // verifiche per fresatura dal basso m_bAggrBottom = false ; if ( ! VerifyPathFromBottom( pCompo, vtTool)) return false ; // se richiesta anteprima if ( nPvId != GDB_ID_NULL) { // creo gruppo per geometria di anteprima del percorso int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nPvId, Frame3d()) ; if ( nPxId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nPxId, sPathName) ; m_pGeomDB->SetMaterial( nPxId, GREEN) ; // creo l'anteprima del percorso if ( ! GenerateMillingPv( nPxId, pCompo)) return false ; } // 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) ; // assegno il vettore estrazione al gruppo del percorso m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ; // assegno i punti di inizio e fine al gruppo del percorso m_pGeomDB->SetInfo( nPxId, KEY_START, ptStart) ; m_pGeomDB->SetInfo( nPxId, KEY_END, ptEnd) ; // assegno l'elevazione massima m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ; // Imposto dati comuni SetPathId( nPxId) ; SetToolDir( vtTool) ; // Controlli per lama (non deve fare movimenti assiali nel pezzo) if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) { // Non ammesse passate a spirale if ( m_Params.m_nStepType == MILL_ST_SPIRAL) m_Params.m_nStepType = MILL_ST_ZIGZAG ; // Non ammessa elevazione in attacco e uscita m_Params.m_dLiElev = 0 ; m_Params.m_dLoElev = 0 ; } bool bOk = false ; // Se lama con elevazione e step di fianco if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 && dSideElev > 10 * EPS_SMALL && dOkStep > EPS_SMALL) { m_bStepOn = true ; bOk = AddSawZigZagMilling( pCompo, vtTool, dDepth, dSideElev, dOkStep, bSplitArcs) ; } // se altrimenti una sola passata else if ( dOkStep < EPS_SMALL || dOkStep > dElev) { m_bStepOn = false ; bOk = AddStandardMilling( pCompo, vtTool, dDepth, dElev, bSplitArcs, bPathTabsEnable, bPathOscEnable) ; } // se altrimenti passate a zig-zag else if ( m_Params.m_nStepType == MILL_ST_ZIGZAG) { m_bStepOn = true ; bOk = AddZigZagMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathTabsEnable, bPathOscEnable) ; } // se altrimenti passate a one-way else if ( m_Params.m_nStepType == MILL_ST_ONEWAY) { m_bStepOn = true ; bOk = AddOneWayMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathTabsEnable, bPathOscEnable) ; } // se altrimenti passate a spirale else if ( m_Params.m_nStepType == MILL_ST_SPIRAL) { m_bStepOn = true ; // rimuovo eventuale sovrapposizione aggiunta if ( m_dAddedOverlap > EPS_SMALL) { pCompo->Invert() ; pCompo->TrimStartAtLen( m_dAddedOverlap) ; pCompo->Invert() ; m_dAddedOverlap = 0 ; } bOk = AddSpiralMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathTabsEnable, bPathOscEnable) ; } // se utensile lama, porto il percorso sull'estremo della stessa AdjustPathDrawForSaw( nPxId) ; if ( ! bOk) return false ; } // incremento numero di fresate ++ m_nMills ; return true ; } //---------------------------------------------------------------------------- bool Milling::AdjustPathDrawForSaw( int nClPathId) { // se non è lama, non devo fare alcunché if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) return true ; // porto il percorso praticamente sull'estremo della lama ( appena meno per evitare di trasformare archi in punti) double dOffset = 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ; Vector3d vtPrevCorr ; for ( int nId = m_pGeomDB->GetFirstInGroup( nClPathId) ; nId != GDB_ID_NULL ; nId = m_pGeomDB->GetNext( nId)) { // recupero l'oggetto geometrico IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nId) ; if ( pGObj == nullptr) continue ; // recupero i dati Cam dell'entità e verifico sia definito il versore correzione CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nId)) ; if ( pCamData == nullptr || pCamData->GetCorrDir().IsSmall()) continue ; Vector3d vtCorr = pCamData->GetCorrDir() ; // eseguo traslazione generale Vector3d vtMove = - dOffset * vtCorr ; pGObj->Translate( vtMove) ; pCamData->Translate( vtMove) ; // se il vettore correzione attuale è diverso dal precedente if ( ! AreSameVectorApprox( vtCorr, vtPrevCorr)) { // se curva if ( ( pGObj->GetType() & GEO_CURVE) != 0) { // compenso differenza su punto iniziale Vector3d vtDiff = - dOffset * ( vtPrevCorr - vtCorr) ; ICurve* pCrv = ::GetCurve( pGObj) ; Point3d ptStart ; pCrv->GetStartPoint( ptStart) ; pCrv->ModifyStart( ptStart + vtDiff) ; // se arco, aggiorno il centro if ( pGObj->GetType() == CRV_ARC) { ICurveArc* pArc = GetCurveArc( pCrv) ; pCamData->SetCenter( pArc->GetCenter()) ; } } } // aggiorno precedente versore correzione vtPrevCorr = vtCorr ; } return true ; } //---------------------------------------------------------------------------- bool Milling::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) const { dElev = 0 ; int nMaxInd = pCompo->GetCurveCount() - 1 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( i) ; // calcolo elevazione double dCurrElev ; Point3d ptStart, ptMid, ptEnd ; pCrvC->GetStartPoint( ptStart) ; pCrvC->GetMidPoint( ptMid) ; pCrvC->GetEndPoint( ptEnd) ; Vector3d vtStartPerp, vtMidPerp, vtEndPerp, vtTg ; pCrvC->GetStartDir( vtTg) ; vtStartPerp = vtTg ^ vtTool ; vtStartPerp.Normalize() ; vtStartPerp *= dRad ; pCrvC->GetMidDir( vtTg) ; vtMidPerp = vtTg ^ vtTool ; vtMidPerp.Normalize() ; vtMidPerp *= dRad ; pCrvC->GetEndDir( vtTg) ; vtEndPerp = vtTg ^ vtTool ; vtEndPerp.Normalize() ; vtEndPerp *= dRad ; Vector3d vtDepth = vtTool * dDepth ; // linea centro utensile if ( GetElevation( m_nPhase, ptStart - vtDepth, ptMid - vtDepth, ptEnd - vtDepth, vtTool, dCurrElev)) { if ( dCurrElev > dElev) dElev = dCurrElev ; } else { m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ; return false ; } // da una parte if ( GetElevation( m_nPhase, ptStart + vtStartPerp - vtDepth, ptMid + vtMidPerp - vtDepth, ptEnd + vtEndPerp - vtDepth, vtTool, dCurrElev)) { if ( dCurrElev > dElev) dElev = dCurrElev ; } else { m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ; return false ; } if ( dRad > ELEV_MAX_OFFS) { if ( GetElevation( m_nPhase, ptStart + vtStartPerp / 2 - vtDepth, ptMid + vtMidPerp / 2 - vtDepth, ptEnd + vtEndPerp / 2 - vtDepth, vtTool, dCurrElev)) { if ( dCurrElev > dElev) dElev = dCurrElev ; } else { m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ; return false ; } } // dall'altra parte if ( GetElevation( m_nPhase, ptStart - vtStartPerp - vtDepth, ptMid - vtMidPerp - vtDepth, ptEnd - vtEndPerp - vtDepth, vtTool, dCurrElev)) { if ( dCurrElev > dElev) dElev = dCurrElev ; } else { m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ; return false ; } if ( dRad > ELEV_MAX_OFFS) { if ( GetElevation( m_nPhase, ptStart - vtStartPerp / 2 - vtDepth, ptMid - vtMidPerp / 2 - vtDepth, ptEnd - vtEndPerp / 2 - vtDepth, vtTool, dCurrElev)) { if ( dCurrElev > dElev) dElev = dCurrElev ; } else { m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ; return false ; } } } return true ; } //---------------------------------------------------------------------------- bool Milling::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) { // se non è fresatura dal basso in alto, esco if ( vtTool.z > MIN_ZDIR_TOP_TOOL) return true ; // se c'è testa non dall'alto o tavola basculante, esco if ( ! m_bAboveHead || m_bTiltingTab) return true ; // recupero dati di eventuale rinvio da sotto if ( ! GetAggrBottomData( m_TParams.m_sHead, m_AggrBottom) || m_AggrBottom.nType == 0) { m_pMchMgr->SetLastError( 2307, "Error in Milling : missing aggregate from bottom") ; return false ; } // calcolo la massima distanza minima del percorso dal contorno del grezzo double dExpand = 0.5 * m_TParams.m_dTDiam ; double dDist = - INFINITO ; Vector3d vtDir ; int nMaxInd = pCompo->GetCurveCount() - 1 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( i) ; // considero inizio della prima curva, punto medio e fine di tutte Point3d ptP ; double dCurrDist = 0 ; Vector3d vtCurrDir ; if ( i == 0) { pCrvC->GetStartPoint( ptP) ; GetMinDistanceFromRawSide( m_nPhase, ptP, dExpand, dCurrDist, vtCurrDir) ; if ( dCurrDist > dDist) { dDist = dCurrDist ; vtDir = vtCurrDir ; } } pCrvC->GetMidPoint( ptP) ; GetMinDistanceFromRawSide( m_nPhase, ptP, dExpand, dCurrDist, vtCurrDir) ; if ( dCurrDist > dDist) { dDist = dCurrDist ; vtDir = vtCurrDir ; } pCrvC->GetEndPoint( ptP) ; GetMinDistanceFromRawSide( m_nPhase, ptP, dExpand, dCurrDist, vtCurrDir) ; if ( dCurrDist > dDist) { dDist = dCurrDist ; vtDir = vtCurrDir ; } } // se supera il limite, errore if ( dDist > m_AggrBottom.dDMax) { m_pMchMgr->SetLastError( 2308, "Error in Milling : path too far from part sides") ; return false ; } // assegno direzione di accesso e segnalo utilizzo aggregato da sotto m_vtAggrBottom = vtDir ; m_bAggrBottom = true ; return true ; } //---------------------------------------------------------------------------- bool Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo) { // creo copia della curva composita PtrOwner< ICurve> pCrv( pCompo->Clone()) ; if ( IsNull( pCrv)) return false ; // calcolo la regione PtrOwner pSfr ; pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), 0.5 * m_TParams.m_dDiam, false, false)) ; if ( IsNull( pSfr)) return false ; // ne recupero il contorno PtrOwner< ICurve> pCrv2 ; pCrv2.Set( pSfr->GetLoop( 0, 0)) ; if ( IsNull( pCrv2)) return false ; // inserisco la curva nel DB int nC2Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv2)) ; if ( nC2Id == GDB_ID_NULL) return false ; // assegno nome e colore m_pGeomDB->SetName( nC2Id, MCH_PV_CUT) ; m_pGeomDB->SetMaterial( nC2Id, LIME) ; // eventuali altri contorni ( interni di contornatura chiusa) const int MAX_INT_LOOP = 1000 ; for ( int i = 1 ; i <= MAX_INT_LOOP ; ++i) { PtrOwner< ICurve> pCrv3 ; pCrv3.Set( pSfr->GetLoop( 0, i)) ; if ( IsNull( pCrv3)) break ; // inserisco la curva nel DB int nC3Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv3)) ; if ( nC3Id == GDB_ID_NULL) return false ; // assegno nome e colore m_pGeomDB->SetName( nC3Id, MCH_PV_CUT) ; m_pGeomDB->SetMaterial( nC3Id, LIME) ; } // inserisco la regione nel DB int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfr)) ; if ( nRId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ; m_pGeomDB->SetMaterial( nRId, INVISIBLE) ; // la copio anche come regione ridotta int nRrId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ; if ( nRrId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ; m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ; return true ; } //---------------------------------------------------------------------------- static bool VerifyEscapeDir( const Vector3d& vtCorr, const Vector3d& vtTool, bool bAboveHead) { if ( bAboveHead && AreSameVectorApprox( vtCorr, -Z_AX)) return false ; if ( ! bAboveHead && AreSameVectorApprox( vtCorr, Z_AX)) return false ; Vector3d vtEsc( vtCorr.x, vtCorr.y, 0) ; return ( vtEsc.Normalize() && vtEsc * vtTool > -0.5) ; } //---------------------------------------------------------------------------- bool Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) { // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // in caso di tabs ne aggiusto i parametri secondo il percorso TabData tdTabs ; AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ; DBLVECTOR vdTabs ; CalcTabsPositions( pCompo, dDepth, bPathTabsEnable, tdTabs, vdTabs) ; // in caso di oscillazione ne aggiusto i parametri secondo il percorso double dOscRampLen, dOscFlatLen ; AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ; // ciclo sulle curve elementari bool bOk = true ; bool bClosed = pCompo->IsClosed() ; m_dCurrTabsLen = 0 ; m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ; int nMaxInd = pCompo->GetCurveCount() - 1 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( i) ; // copio la curva PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; // aggiungo affondamento pCurve->Translate( - vtTool * dDepth) ; // se prima entità, approccio e affondo if ( i == 0) { // dati inizio entità Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; // determino elevazione su inizio percorso di lavoro double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; // determino inizio attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo Vector3d vtAppr( vtTool.x, vtTool.y, 0) ; if ( ! vtAppr.Normalize()) vtAppr = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ; bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ; bool bAboveStart = ( m_bAboveHead && bGeomAboveStart) ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, i) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; dStElev = - LIO_ELEV_TOL ; } // approccio al punto iniziale if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } } // altrimenti, approccio per lame else { // verifico di entrare in aria if ( ! bOutStart) { // verifico se sono sotto double dSawStartElev = 0 ; bool bUnderStart = false ; bool bSideStart = false ; if ( ! bGeomAboveStart) { bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ; } // se non sono sotto, verifico se posso allontanarmi nel piano lama (meglio se in orizzontale) if ( ! bUnderStart) { Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ; Vector3d vtAppr2 = ptP1 - ptStart ; if ( ! vtAppr2.Normalize()) vtAppr2 = CalcCorrDir( pCompo, i) ; double dSawStartElev1, dSawStartElev2 ; GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtAppr1, dSawStartElev1) ; GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtAppr2, dSawStartElev2) ; if ( dSawStartElev1 > EPS_SMALL && dSawStartElev2 > EPS_SMALL) { bool bFirst = ( dSawStartElev1 < dSawStartElev2) ; vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ; dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ; bSideStart = true ; } else if ( dSawStartElev1 > EPS_SMALL) { vtAppr = vtAppr1 ; dSawStartElev = dSawStartElev1 ; bSideStart = true ; } else if ( dSawStartElev2 > EPS_SMALL) { vtAppr = vtAppr2 ; dSawStartElev = dSawStartElev2 ; bSideStart = true ; } } if ( ! bGeomAboveStart && ! bUnderStart && ! bSideStart && bOk) { m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ; bOk = false ; } // aggiungo opportuno approccio if ( ! AddSawBladeSideApproach( ptP1, vtAppr, dSafeZ, dSawStartElev, dAppr)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } } else { // affondo al punto iniziale SetFlag( 0) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; } } // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } } // imposto versore correzione e ausiliario sul punto di arrivo CalcAndSetCorrAuxDir( pCompo, i + 1) ; // elaborazioni sulla curva corrente if ( pCurve->GetType() == CRV_LINE) { ICurveLine* pLine = GetCurveLine( pCurve) ; SetFeed( GetFeed()) ; if ( bPathTabsEnable) { if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs)) return false ; } else if ( bPathOscEnable) { if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptP3 = pLine->GetEnd() ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } else if ( pCurve->GetType() == CRV_ARC) { ICurveArc* pArc = GetCurveArc( pCurve) ; SetFeed( GetFeed()) ; if ( bPathTabsEnable) { if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs)) return false ; } else if ( bPathOscEnable) { if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } } // se ultima entità, uscita e retrazione if ( i == nMaxInd) { // dati fine entità Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ; // elevazione sul punto finale double dEndElev ; if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // aggiungo retrazione per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // determino se la fine dell'uscita è sopra il grezzo bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } } // per lame quando è necessario else { // verifico di uscire in aria Vector3d vtRetr( vtTool.x, vtTool.y, 0) ; if ( ! vtRetr.Normalize()) vtRetr = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ; bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dElev, dSafeZ) ; if ( ! bOutEnd) { // verifico se sono sopra bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ; // verifico se sono sotto double dSawEndElev = 0 ; bool bUnderEnd = false ; bool bSideEnd = false ; if ( ! bGeomAboveEnd) { bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ; } if ( ! bUnderEnd) { Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ; Vector3d vtRetr2 = ptP1 - ptEnd ; if ( ! vtRetr2.Normalize()) vtRetr2 = CalcCorrDir( pCompo, i + 1) ; double dSawEndElev1, dSawEndElev2 ; GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtRetr1, dSawEndElev1) ; GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtRetr2, dSawEndElev2) ; if ( dSawEndElev1 > EPS_SMALL && dSawEndElev2 > EPS_SMALL) { bool bFirst = ( dSawEndElev1 < dSawEndElev2) ; vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ; dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ; bSideEnd = true ; } else if ( dSawEndElev1 > EPS_SMALL) { vtRetr = vtRetr1 ; dSawEndElev = dSawEndElev1 ; bSideEnd = true ; } else if ( dSawEndElev2 > EPS_SMALL) { vtRetr = vtRetr2 ; dSawEndElev = dSawEndElev2 ; bSideEnd = true ; } } if ( ! bGeomAboveEnd && ! bUnderEnd && ! bSideEnd && bOk) { m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ; bOk = false ; } // aggiungo opportuna retrazione if ( ! AddSawBladeSideRetract( ptP1, vtRetr, dSafeZ, dSawEndElev, dAppr)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } } } } } return bOk ; } //---------------------------------------------------------------------------- bool Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) { // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // determino numero e affondamento degli step int nStep = max( 1, static_cast( ceil( dElev / dOkStep))) ; double dStep = dElev / nStep ; // in caso di tabs ne aggiusto i parametri secondo il percorso TabData tdTabs ; AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ; DBLVECTOR vdTabs ; // se ultima passata al contrario if ( bPathTabsEnable && ( nStep % 2) == 0) { PtrOwner pCopy( pCompo->Clone()) ; if ( ! IsNull( pCopy) && pCopy->Invert()) CalcTabsPositions( pCopy, dDepth, bPathTabsEnable, tdTabs, vdTabs) ; else bPathTabsEnable = false ; } else CalcTabsPositions( pCompo, dDepth, bPathTabsEnable, tdTabs, vdTabs) ; // in caso di oscillazione ne aggiusto i parametri secondo il percorso double dOscRampLen, dOscFlatLen ; AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ; // altri dati del percorso bool bClosed = pCompo->IsClosed() ; int nMaxInd = pCompo->GetCurveCount() - 1 ; // ciclo sugli step for ( int j = 1 ; j <= nStep ; ++ j) { // flag direzione (prima passata indice 1) bool bInvert = ( ( j % 2) == 0) ; m_dCurrTabsLen = 0 ; m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ; // ciclo sulle curve elementari for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ; // copio la curva PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; if ( bInvert) pCurve->Invert() ; // aggiungo affondamento pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ; // se prima entità, se primo step approccio e sempre affondo if ( i == 0) { // dati inizio entità Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; // determino elevazione su inizio attacco double dStElev ; if ( j == 1) { if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dStep ; } else dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ; // determino inizio attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; // se primo step aggiungo approccio per frese normali if ( j == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; dStElev = - LIO_ELEV_TOL ; } // approccio al punto iniziale if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } } // altrimenti, affondo al punto iniziale else { // se lama if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) { SetFlag( 0) ; if ( j == 1) { // verifico di entrare in aria if ( ! bOutStart) { m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ; return false ; } // eseguo affondo if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; } else { if ( AddRapidMove( ptP1) == GDB_ID_NULL) return false ; } } // se attacco a zigzag o a spirale, non affondo else if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; dStElev = - LIO_ELEV_TOL ; } // altrimenti, affondo in feed opportuna else { bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP || m_TParams.m_nType == TT_MILL_POLISHING) ; SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ; if ( AddLinearMove( ptP1) == GDB_ID_NULL) return false ; } } // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bInvert, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } } // imposto versore correzione e ausiliario sul punto di arrivo CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1)) ; // elaborazioni sulla curva corrente if ( pCurve->GetType() == CRV_LINE) { ICurveLine* pLine = GetCurveLine( pCurve) ; SetFeed( GetFeed()) ; if ( j == nStep && bPathTabsEnable) { if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs)) return false ; } else if ( j == nStep && bPathOscEnable) { if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptP3 = pLine->GetEnd() ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } else if ( pCurve->GetType() == CRV_ARC) { ICurveArc* pArc = GetCurveArc( pCurve) ; SetFeed( GetFeed()) ; if ( j == nStep && bPathTabsEnable) { if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs)) return false ; } else if ( j == nStep && bPathOscEnable) { if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } } // se ultima entità, uscita e se ultimo step retrazione if ( i == nMaxInd) { // dati fine entità Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ; // elevazione sul punto finale double dEndElev ; if ( j == nStep) { if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; } else dEndElev = - LIO_ELEV_TOL ; // se non c'è attacco a zigzag o a spirale oppure ultimo step, aggiungo uscita Point3d ptP1 = ptEnd ; if ( ! IsLeadInHelixOrZigzag() || j == nStep) { SetFeed( GetEndFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } } // se ultimo step aggiungo retrazione per frese normali if ( j == nStep && ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // determino se la fine dell'uscita è sopra il grezzo bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } } // per lame non è necessario } } } return true ; } //---------------------------------------------------------------------------- bool Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) { // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // in caso di tabs ne aggiusto i parametri secondo il percorso TabData tdTabs ; AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ; DBLVECTOR vdTabs ; CalcTabsPositions( pCompo, dDepth, bPathTabsEnable, tdTabs, vdTabs) ; // in caso di oscillazione ne aggiusto i parametri secondo il percorso double dOscRampLen, dOscFlatLen ; AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ; // percorso speciale : chiuso e con attacco a spirale o zigzag bool bSpecial = pCompo->IsClosed() && IsLeadInHelixOrZigzag() ; // percorso senza retrazioni intermedie : chiuso e con attacco e uscita con punti esterni coincidenti bool bMidRetract = true ; if ( pCompo->IsClosed()) { int nLiType = GetLeadInType() ; int nLoType = GetLeadOutType() ; if ( nLiType == MILL_LI_NONE && ( nLoType == MILL_LO_NONE || nLoType == MILL_LO_AS_LI)) bMidRetract = false ; if ( ( nLiType == MILL_LI_TANGENT || nLiType == MILL_LI_LINEAR || nLiType == MILL_LI_TG_PERP) && nLoType == MILL_LO_AS_LI && abs( m_Params.m_dLiTang) < EPS_SMALL) bMidRetract = false ; if ( ( nLiType == MILL_LI_TANGENT || nLiType == MILL_LI_LINEAR || nLiType == MILL_LI_TG_PERP) && ( nLoType == MILL_LO_TANGENT || nLoType == MILL_LO_LINEAR || nLoType == MILL_LO_PERP_TG) && abs( m_Params.m_dLiTang) < EPS_SMALL && abs( m_Params.m_dLoTang) < EPS_SMALL && abs( m_Params.m_dLiPerp - m_Params.m_dLoPerp) < EPS_SMALL) bMidRetract = false ; } // verifico se attacco e uscita sopra il grezzo Point3d ptStart ; pCompo->GetStartPoint( ptStart) ; ptStart -= vtTool * dDepth ; Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ; ptEnd -= vtTool * dDepth ; bool bAboveStartEnd = m_bAboveHead && GetPointAboveRaw( ptStart, vtTool) && GetPointAboveRaw( ptEnd, vtTool) ; // determino numero e affondamento degli step int nStep = max( 1, static_cast( ceil( dElev / dOkStep))) ; double dStep = dElev / nStep ; // ciclo sugli step int nMaxInd = pCompo->GetCurveCount() - 1 ; for ( int j = 1 ; j <= nStep ; ++ j) { m_dCurrTabsLen = 0 ; m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ; // ciclo sulle curve elementari for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( i) ; // copio la curva PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; // aggiungo affondamento pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ; // se prima entità, approccio e affondo if ( i == 0) { // dati inizio entità Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, i) ; // punto inizio attacco Point3d ptP1 ; // se speciale e step intermedio if ( bSpecial && j > 1) { ptP1 = ptStart + dStep * vtTool ; } // altrimenti else { // determino elevazione su inizio attacco double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; if ( ! bAboveStartEnd) dStElev = max( dStElev, j * dStep) ; // determino inizio attacco if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo Vector3d vtCorr = CalcCorrDir( pCompo, i) ; bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) Point3d ptP1m = ptP1 - 10 * EPS_SMALL * vtTool ; Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) { if ( bAboveStartEnd) dStElev = min( dStElev, dNewStElev) ; else dStElev = max( dStElev, dNewStElev) ; } // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev - ( j - 1) * dStep) ; dStElev = ( j - 1) * dStep ; } // approccio standard al punto iniziale if ( j == 1 || bMidRetract) { if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStartEnd)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } } // altrimenti approccio diretto al punto iniziale else { if ( ! AddDirectApproach( ptP1)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } } } // altrimenti, approccio per lame else { // verifico di entrare in aria if ( ! bOutStart) { m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ; return false ; } // affondo al punto iniziale SetFlag( 0) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; } } // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } } // imposto versore correzione e ausiliario sul punto di arrivo CalcAndSetCorrAuxDir( pCompo, i+1) ; // elaborazioni sulla curva corrente if ( pCurve->GetType() == CRV_LINE) { ICurveLine* pLine = GetCurveLine( pCurve) ; SetFeed( GetFeed()) ; if ( j == nStep && bPathTabsEnable) { if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs)) return false ; } else if ( j == nStep && bPathOscEnable) { if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptP3 = pLine->GetEnd() ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } else if ( pCurve->GetType() == CRV_ARC) { ICurveArc* pArc = GetCurveArc( pCurve) ; SetFeed( GetFeed()) ; if ( j == nStep && bPathTabsEnable) { if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs)) return false ; } else if ( j == nStep && bPathOscEnable) { if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } } // se ultima entità, uscita e retrazione if ( i == nMaxInd) { // se speciale e step intermedio salto uscita e retrazione if ( bSpecial && j != nStep) continue ; // dati fine entità Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ; // elevazione sul punto finale double dEndElev ; if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; if ( ! bAboveStartEnd) dEndElev = max( dEndElev, j * dStep) ; // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // aggiungo retrazione per frese normali (esclusi step intermedi senza retrazione) if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0 && ( j == nStep || bMidRetract)) { // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Point3d ptP1m = ptP1 - 10 * EPS_SMALL * vtTool ; Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) { if ( bAboveStartEnd) dEndElev = min( dEndElev, dNewEndElev) ; else dEndElev = max( dEndElev, dNewEndElev) ; } // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveStartEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } } // per lame non è necessario } } } return true ; } //---------------------------------------------------------------------------- bool Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) { // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // se attacco ad inseguimento (per ora nullo), parto sopra di elevazione in attacco double dStart = 0 ; if ( m_Params.m_nLeadInType == MILL_LI_NONE) dStart = m_Params.m_dLiElev ; // in caso di oscillazione ne aggiusto i parametri secondo il percorso double dOscRampLen, dOscFlatLen ; AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ; // imposto flag di percorso chiuso bool bClosed = pCompo->IsClosed() ; // determino numero e affondamento degli step int nStep = max( 1, static_cast( ceil( ( dElev + dStart) / ( bClosed ? dOkStep : dOkStep / 2)))) ; if ( m_TParams.m_nType == TT_MILL_POLISHING) nStep = max( 1, nStep - 1) ; double dStep = ( dElev + dStart) / nStep ; // determino dati del percorso double dTotLen ; pCompo->GetLength( dTotLen) ; int nMaxInd = pCompo->GetCurveCount() - 1 ; // se chiuso -> sempre in avanti if ( bClosed) { // ciclo sugli step for ( int j = 0 ; j <= nStep ; ++ j) { // ciclo sulle curve elementari m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ; double dCurrLen = 0 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( i) ; // affondamento a inizio curva Vector3d vtStaDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ; // affondamento a fine curva double dCrvLen ; pCrvC->GetLength( dCrvLen) ; dCurrLen += dCrvLen ; Vector3d vtEndDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ; // se prima entità di primo step, approccio e affondo if ( i == 0 && j == 0) { // dati inizio entità Point3d ptStart ; pCrvC->GetStartPoint( ptStart) ; ptStart -= vtStaDepth ; Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ; // determino elevazione su inizio attacco double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = 0 ; dStElev -= dStart ; // determino inizio attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo Vector3d vtCorr = CalcCorrDir( pCompo, i) ; bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, i) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // approccio al punto iniziale if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } } // altrimenti, affondo al punto iniziale per lame else { // verifico di entrare in aria if ( ! bOutStart) { m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ; return false ; } // eseguo affondamento SetFlag( 0) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; } // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } } // imposto versore correzione e ausiliario sul punto di arrivo CalcAndSetCorrAuxDir( pCompo, i+1) ; // elaborazioni sulla curva corrente if ( pCrvC->GetType() == CRV_LINE) { const ICurveLine* pLine = GetCurveLine( pCrvC) ; SetFeed( GetFeed()) ; if ( j == nStep && bPathOscEnable) { PtrOwner pTmpLine( pLine->Clone()) ; if ( IsNull( pTmpLine)) return false ; pTmpLine->Translate( -vtStaDepth) ; if ( ! AddOscillLine( pTmpLine, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptP3 = pLine->GetEnd() ; ptP3 -= vtEndDepth ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } else if ( pCrvC->GetType() == CRV_ARC) { const ICurveArc* pArc = GetCurveArc( pCrvC) ; SetFeed( GetFeed()) ; if ( j == nStep && bPathOscEnable) { PtrOwner pTmpArc( pArc->Clone()) ; if ( IsNull( pTmpArc)) return false ; pTmpArc->Translate( -vtStaDepth) ; if ( ! AddOscillArc( pTmpArc, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptCen = pArc->GetCenter() ; ptCen -= vtStaDepth ; double dAngCen = pArc->GetAngCenter() ; Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 -= vtEndDepth ; if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } } // se ultima entità di ultimo step, uscita e retrazione if ( i == nMaxInd && j == nStep) { // dati fine entità Point3d ptEnd ; pCrvC->GetEndPoint( ptEnd) ; ptEnd -= vtEndDepth ; Vector3d vtEnd ; pCrvC->GetEndDir( vtEnd) ; // elevazione sul punto finale double dEndElev ; if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // aggiungo retrazione per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // determino se la fine dell'uscita è sopra il grezzo bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } } // per lame non è necessario } } } } // altrimenti aperto -> avanti e indietro else { // ciclo sugli step for ( int j = 0 ; j <= nStep ; ++ j) { // flag direzione (prima passata indice 0) bool bInvert = ( ( j % 2) == 1) ; // ciclo sulle curve elementari m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ; double dCurrLen = 0 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ; // copio la curva PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; if ( bInvert) pCurve->Invert() ; // affondamento a inizio curva Vector3d vtStaDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ; // affondamento a fine curva double dCrvLen ; pCrvC->GetLength( dCrvLen) ; dCurrLen += dCrvLen ; Vector3d vtEndDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ; // se prima entità di primo step, approccio e affondo if ( i == 0 && j == 0) { // dati inizio entità Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; ptStart -= vtStaDepth ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; // determino elevazione su inizio attacco double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; dStElev -= dStart ; // determino inizio attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1)) return false ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è fuori dal grezzo Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // approccio al punto iniziale if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } } // altrimenti, affondo per lame else { SetFlag( 0) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; } // aggiungo attacco SetFeed( GetStartFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bInvert, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } } // imposto versore correzione e ausiliario sul punto di arrivo CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1)) ; // elaborazioni sulla curva corrente if ( pCurve->GetType() == CRV_LINE) { ICurveLine* pLine = GetCurveLine( pCurve) ; SetFeed( GetFeed()) ; if ( j == nStep && bPathOscEnable) { PtrOwner pTmpLine( pLine->Clone()) ; if ( IsNull( pTmpLine)) return false ; pTmpLine->Translate( -vtStaDepth) ; if ( ! AddOscillLine( pTmpLine, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptP3 = pLine->GetEnd() ; ptP3 -= vtEndDepth ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } else if ( pCurve->GetType() == CRV_ARC) { ICurveArc* pArc = GetCurveArc( pCurve) ; SetFeed( GetFeed()) ; if ( j == nStep && bPathOscEnable) { PtrOwner pTmpArc( pArc->Clone()) ; if ( IsNull( pTmpArc)) return false ; pTmpArc->Translate( -vtStaDepth) ; if ( ! AddOscillArc( pTmpArc, vtTool, dOscRampLen, dOscFlatLen)) return false ; } else { Point3d ptCen = pArc->GetCenter() ; ptCen -= vtStaDepth ; double dAngCen = pArc->GetAngCenter() ; Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 -= vtEndDepth ; if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } } // se ultima entità di ultimo step, uscita e retrazione if ( i == nMaxInd && j == nStep) { // dati fine entità Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; ptEnd -= vtEndDepth ; Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ; // elevazione sul punto finale double dEndElev ; if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // aggiungo retrazione per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // determino se la fine dell'uscita è sopra il grezzo bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } } // per lame non è necessario } } } } return true ; } //---------------------------------------------------------------------------- class LeadIOStatus { public : LeadIOStatus( Milling* pMill) { m_pMill = pMill ; m_dLiPerp = m_pMill->m_Params.m_dLiPerp ; m_dLoPerp = m_pMill->m_Params.m_dLoPerp ; } ~LeadIOStatus( void) { Restore() ; } void Restore( void) { m_pMill->m_Params.m_dLiPerp = m_dLiPerp ; m_pMill->m_Params.m_dLoPerp = m_dLoPerp ; } private : Milling* m_pMill ; double m_dLiPerp ; double m_dLoPerp ; } ; //---------------------------------------------------------------------------- bool Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // flag di percorso chiuso bool bClosed = pCompo->IsClosed() ; // determino numero e affondamento degli step int nStep = max( 1, static_cast( ceil( dElev / dOkStep))) ; double dStep = dElev / nStep ; // gestione parametri di attacco/uscita (con backup per ripristino all'uscita) LeadIOStatus LioStatus( this) ; bool bAdjustLiPerp = ( m_Params.m_dLiPerp > EPS_SMALL) ; if ( bAdjustLiPerp) m_Params.m_dLiPerp = max( 0., m_Params.m_dLiPerp - ( nStep - 1) * dStep) ; bool bAdjustLoPerp = ( m_Params.m_dLoPerp > EPS_SMALL) ; m_Params.m_dLoPerp = 0. ; // ciclo sugli step for ( int j = 1 ; j <= nStep ; ++ j) { // flag direzione (prima passata indice 1) bool bInvert = ( ( j % 2) == 0) ; // copio la curva PtrOwner pMyCompo( pCompo->Clone()) ; if ( IsNull( pMyCompo)) return false ; // eseguo offset double dSignOffs = ( dElev - j * dStep) * ( m_Params.m_nWorkSide == MILL_WS_LEFT ? - 1 : 1) ; if ( ! CalcOffset( pMyCompo, dSignOffs)) return false ; // dopo primo step annullo parametro di attacco if ( j > 1) m_Params.m_dLiPerp = 0. ; // ciclo sulle curve elementari int nMaxInd = pCompo->GetCurveCount() - 1 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pMyCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ; // copio la curva PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; if ( bInvert) pCurve->Invert() ; // se prima entità, se primo step approccio e sempre affondo if ( i == 0) { // dati inizio entità Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; // determino elevazione su inizio attacco double dStElev ; if ( j == 1) { if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; } else dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ; // determino inizio attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; // se primo step if ( j == 1) { // verifico di entrare in aria if ( ! bOutStart) { m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ; return false ; } // eseguo affondo SetFlag( 0) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; } // altrimenti, affondo in feed opportuna else { bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP || m_TParams.m_nType == TT_MILL_POLISHING) ; SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ; if ( AddLinearMove( ptP1) == GDB_ID_NULL) return false ; } // aggiungo attacco bool bTang = (( ! bInvert && m_Params.m_dLiTang > EPS_SMALL) || ( bInvert && m_Params.m_dLoTang > EPS_SMALL)) ; SetFeed( bTang ? GetStartFeed() : GetTipFeed()) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bInvert, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } } // imposto versore correzione e ausiliario sul punto di arrivo CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1)) ; // elaborazioni sulla curva corrente if ( pCurve->GetType() == CRV_LINE) { ICurveLine* pLine = GetCurveLine( pCurve) ; Point3d ptP3 = pLine->GetEnd() ; SetFeed( GetFeed()) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } else if ( pCurve->GetType() == CRV_ARC) { ICurveArc* pArc = GetCurveArc( pCurve) ; Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; Vector3d vtN = pArc->GetNormVersor() ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; SetFeed( GetFeed()) ; if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } // se ultima entità, uscita e se ultimo step retrazione if ( i == nMaxInd) { // se ultima passata, ripristino parametri originali di attacco/uscita if ( j == nStep) LioStatus.Restore() ; // dati fine entità Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ; // elevazione sul punto finale double dEndElev ; if ( j == nStep) { if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; } else dEndElev = - LIO_ELEV_TOL ; // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // per lame retrazione non è necessaria } } } return true ; } //---------------------------------------------------------------------------- bool Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, double dElev, double dAppr, bool bOutStart, bool bAboveStart) { SetFlag( 1) ; // se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi) bool bBottomStart = false ; if ( m_bAggrBottom) { // distanza dal bordo del pezzo (se negativa il punto è fuori dal grezzo) double dDistBottom ; if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, dDistBottom)) dDistBottom = 0 ; bBottomStart = ( dDistBottom < - 10 * EPS_SMALL) ; // aggiuntivo in Z double dAggZ = ( bBottomStart ? 0. : max( dElev + max( dSafeAggrBottZ, dAppr), 0.)) ; // pre-approccio Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ; Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ; // se rinvio da sotto che richiede speciale rotazione if ( m_AggrBottom.nType == 1) { Vector3d vtAux = m_vtAggrBottom ; vtAux.Rotate( Z_AX, 0, 1) ; SetAuxDir( vtAux) ; if ( AddRapidStart( ptP00, MCH_CL_AGB_DWN) == GDB_ID_NULL) return false ; SetAuxDir( m_vtAggrBottom) ; SetFlag( 0) ; if ( AddRapidMove( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL) return false ; } // altrimenti rinvio normale else { SetAuxDir( m_vtAggrBottom) ; if ( AddRapidStart( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL) return false ; SetFlag( 0) ; } } // se testa da sopra senza aggregato da sotto, approccio mai da Z negativo Vector3d vtAppr = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtAppr.z = 0 ; vtAppr.Normalize() ; } // se non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; double dElevZ = vtAppr.z * dElev ; if ( ! bAboveStart && ! bBottomStart && 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 + vtAppr * ( dElev + dAppr) ; if ( ( ! m_bAggrBottom && AddRapidStart( ptP1) == GDB_ID_NULL) || ( m_bAggrBottom && AddRapidMove( ptP1) == GDB_ID_NULL)) return false ; } else { // 1a -> punto sopra inizio Point3d ptP1b = ptP + vtAppr * ( dElev + dAppr) ; Point3d ptP1a = ptP1b + vtAppr * ( dSafeDist - dAppr) ; if ( ( ! m_bAggrBottom && AddRapidStart( ptP1a) == GDB_ID_NULL) || ( m_bAggrBottom && AddRapidMove( 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) ; bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP || m_TParams.m_nType == TT_MILL_POLISHING) ; SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ; if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; } // sono sopra il pezzo ma non abbastanza else if ( bAboveStart && ( min( dElevZ, 0.) + dAppr) > 10 * EPS_SMALL) { // 1b -> punto appena sopra inizio (in Z globale) Point3d ptP1b = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ; if ( AddRapidStart( ptP1b) == GDB_ID_NULL) return false ; // affondo al punto iniziale SetFlag( 0) ; bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP || m_TParams.m_nType == TT_MILL_POLISHING) ; SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ; if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; } // altrimenti else { // affondo diretto al punto iniziale if ( ( ! m_bAggrBottom && AddRapidStart( ptP) == GDB_ID_NULL) || ( m_bAggrBottom && AddRapidMove( ptP) == GDB_ID_NULL)) return false ; SetFlag( 0) ; } return true ; } //---------------------------------------------------------------------------- bool Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, double dSafeZ, double dStElev, double dAppr) { SetFlag( 1) ; // per approccio orizzontale vtAppr deve essere già stato sistemato dal chiamante // 1 -> punto fuori inizio Point3d ptP1 = ptP + vtAppr * ( dStElev + max( dAppr, dSafeZ)) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; // affondo al punto iniziale in feed SetFlag( 0) ; SetFeed( GetStartFeed()) ; if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; return true ; } //---------------------------------------------------------------------------- bool Milling::AddDirectApproach( const Point3d& ptP) { SetFlag( 1) ; // affondo diretto al punto iniziale if ( AddRapidMove( ptP) == GDB_ID_NULL) return false ; SetFlag( 0) ; return true ; } //---------------------------------------------------------------------------- bool Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, double dElev, double dAppr, bool bAboveEnd) { // se testa da sopra senza aggregato da sotto, retrazione mai da Z negativo Vector3d vtAppr = vtTool ; if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { vtAppr.z = 0 ; vtAppr.Normalize() ; } // se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi) bool bBottomOutStart = false ; double dDistBottom ; if ( m_bAggrBottom) { // distanza dal bordo del pezzo (se negativa il punto è fuori dal grezzo) if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, dDistBottom)) dDistBottom = 0 ; bBottomOutStart = ( dDistBottom < - 10 * EPS_SMALL) ; } // se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; double dElevZ = vtAppr.z * dElev ; if ( ! bAboveEnd && ! bBottomOutStart && 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 + vtAppr * ( dElev + dAppr) ; if ( AddLinearMove( ptP4) == GDB_ID_NULL) return false ; } else { // 4a -> movimento di risalita appena sopra il punto finale Point3d ptP4a = ptP + vtAppr * ( 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 + vtAppr * ( dSafeDist - dAppr) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } } // sono sopra il pezzo ma non abbastanza else if ( bAboveEnd && ( min( dElevZ, 0.) + dAppr) > 10 * EPS_SMALL) { if ( dSafeDist < dAppr + 10 * EPS_SMALL) { // 4 -> movimento di risalita sopra il punto finale SetFeed( GetEndFeed()) ; Point3d ptP4 = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ; if ( AddLinearMove( ptP4) == GDB_ID_NULL) return false ; } else { // 4a -> movimento di risalita appena sopra il punto finale Point3d ptP4a = ptP + Z_AX * ( min( dElevZ, 0.) + 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 + Z_AX * ( dSafeDist - dAppr) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } } // se con aggregato da sotto if ( m_bAggrBottom) { // aggiuntivo in Z double dAggZ = ( bBottomOutStart ? 0. : max( dElev + max( dSafeAggrBottZ, dAppr), 0.)) ; // post-retract Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ; Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ; if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL) return false ; // se rinvio da sotto che richiede speciale rotazione if ( m_AggrBottom.nType == 1) { Vector3d vtAux = m_vtAggrBottom ; vtAux.Rotate( Z_AX, 0, 1) ; SetAuxDir( vtAux) ; if ( AddRapidMove( ptP00, MCH_CL_AGB_UP) == GDB_ID_NULL) return false ; } } return true ; } //---------------------------------------------------------------------------- bool Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, double dSafeZ, double dEndElev, double dAppr) { // per retrazione orizzontale vtAppr deve essere già stato sistemato dal chiamante // se sopra uscita c'è spazio per sicurezza o approccio if ( dEndElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) { if ( dSafeZ < dAppr + 10 * EPS_SMALL) { // 4 -> movimento di risalita sopra il punto finale SetFeed( GetEndFeed()) ; Point3d ptP4 = ptP + vtRetr * ( dEndElev + dAppr) ; if ( AddLinearMove( ptP4) == GDB_ID_NULL) return false ; } else { // 4a -> movimento di risalita appena sopra il punto finale Point3d ptP4a = ptP + vtRetr * ( dEndElev + dAppr) ; if ( dEndElev + dAppr > EPS_SMALL) { SetFeed( GetEndFeed()) ; if ( AddLinearMove( ptP4a) == GDB_ID_NULL) return false ; } // 4b -> movimento di risalita sopra il punto finale Point3d ptP4b = ptP4a + vtRetr * ( dSafeZ - dAppr) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } } return true ; } //---------------------------------------------------------------------------- int Milling::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 MILL_LI_NONE ; if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) && ( m_Params.m_dLiTang < min( 0.1 * m_TParams.m_dDiam, 1.0) || m_Params.m_dLiElev < 10 * EPS_SMALL)) return MILL_LI_NONE ; //if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) && // m_bStepOn && m_Params.m_nStepType == MILL_ST_ZIGZAG) // return MILL_LI_NONE ; if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) && m_bStepOn && m_Params.m_nStepType == MILL_ST_SPIRAL) return MILL_LI_NONE ; if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) && ( m_TParams.m_nType & TF_SAWBLADE) != 0) return MILL_LI_LINEAR ; return m_Params.m_nLeadInType ; } //---------------------------------------------------------------------------- bool Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const { // Assegno tipo e parametri int nType = GetLeadInType() ; double dTang = m_Params.m_dLiTang ; double dPerp = m_Params.m_dLiPerp ; double dElev = min( m_Params.m_dLiElev, dStElev + LIO_ELEV_TOL) ; // se step invertito if ( bInvert) { // va aggiustato se non zigzag o spirale if ( nType != MILL_LI_ZIGZAG && nType != MILL_LI_HELIX) { switch ( m_Params.m_nLeadOutType) { case MILL_LO_LINEAR : nType = MILL_LI_LINEAR ; break ; case MILL_LO_PERP_TG : nType = MILL_LI_TG_PERP ; break ; case MILL_LO_TANGENT : nType = MILL_LI_TANGENT ; break ; case MILL_LO_GLIDE : nType = MILL_LI_GLIDE ; break ; case MILL_LO_AS_LI : /* resta inalterato */ ; break ; default : nType = MILL_LI_NONE ; break ; } if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) { dTang = m_Params.m_dLoTang ; dPerp = m_Params.m_dLoPerp ; dElev = min( m_Params.m_dLoElev, dStElev + LIO_ELEV_TOL) ; } } } // senso di rotazione da dir tg a dir esterna bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) || ( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ; // verifico di poter fare l'ingresso a inseguimento if ( nType == MILL_LI_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL) nType = MILL_LI_NONE ; // Calcolo punto iniziale switch ( nType) { case MILL_LI_NONE : ptP1 = ptStart ; return true ; case MILL_LI_LINEAR : case MILL_LI_TG_PERP : case MILL_LI_TANGENT : { Vector3d vtPerp = vtStart ; Vector3d vtRot = vtN - vtN * vtStart * vtStart ; vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ; ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtN * dElev ; return true ; } case MILL_LI_GLIDE : { if ( ! bInvert) { double dLen, dU ; if ( ! pCompo->GetLength( dLen) || ! pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU) || ! pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) { if ( ! pCompo->GetStartPoint( ptP1)) return false ; } } else { double dU ; if ( ! pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU) || ! pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) { if ( ! pCompo->GetEndPoint( ptP1)) return false ; } } ptP1 += vtN * ( vtN * ( ptStart - ptP1)) + vtN * dElev ; return true ; } case MILL_LI_ZIGZAG : ptP1 = ptStart ; return true ; case MILL_LI_HELIX : ptP1 = ptStart ; return true ; default : return false ; } } //---------------------------------------------------------------------------- bool Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs) { // Assegno il tipo int nType = GetLeadInType() ; double dTang = m_Params.m_dLiTang ; double dPerp = m_Params.m_dLiPerp ; // se step invertito if ( bInvert) { // va aggiustato se non zigzag o spirale if ( nType != MILL_LI_ZIGZAG && nType != MILL_LI_HELIX) { switch ( GetLeadOutType()) { case MILL_LO_LINEAR : nType = MILL_LI_LINEAR ; break ; case MILL_LO_PERP_TG : nType = MILL_LI_TG_PERP ; break ; case MILL_LO_TANGENT : nType = MILL_LI_TANGENT ; break ; case MILL_LO_GLIDE : nType = MILL_LI_GLIDE ; break ; case MILL_LO_AS_LI : /* resta inalterato */ ; break ; default : nType = MILL_LI_NONE ; break ; } if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) { dTang = m_Params.m_dLoTang ; dPerp = m_Params.m_dLoPerp ; } } } // senso di rotazione da dir tg a dir esterna bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) || ( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ; // verifico di poter fare l'ingresso a inseguimento if ( nType == MILL_LI_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL) nType = MILL_LI_NONE ; // Eseguo a seconda del tipo switch ( nType) { case MILL_LI_NONE : return true ; case MILL_LI_LINEAR : return ( AddLinearMove( ptStart, MCH_CL_LEADIN) != GDB_ID_NULL) ; case MILL_LI_TG_PERP : { // direzione perpendicolare Vector3d vtPerp = vtStart ; Vector3d vtRot = vtN - vtN * vtStart * vtStart ; vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ; Point3d ptMid = ptStart + vtPerp * dPerp ; return ( AddLinearMove( ptMid, MCH_CL_LEADIN) != GDB_ID_NULL && AddLinearMove( ptStart, MCH_CL_LEADIN) != GDB_ID_NULL) ; } case MILL_LI_TANGENT : { PtrOwner pCrv( GetArc2PVN( ptStart, ptP1, - vtStart, vtN)) ; if ( IsNull( pCrv)) return false ; pCrv->Invert() ; // eventuale spezzatura if ( bSplitArcs) { PtrOwner pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo) || ! pCompo->AddCurve( Release( pCrv)) || ! ApproxWithLines( pCompo)) return false ; return ( AddCurveMove( pCompo, MCH_CL_LEADIN) != GDB_ID_NULL) ; } else { return ( AddCurveMove( pCrv, MCH_CL_LEADIN) != GDB_ID_NULL) ; } } case MILL_LI_GLIDE : { // recupero la parte richiesta della curva PtrOwner pCrv ; if ( ! bInvert) { double dLen, dU ; if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)) { double dParS, dParE ; pCompo->GetDomain( dParS, dParE) ; if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dU, dParE))) return false ; } else { if ( ! pCrv.Set( pCompo->Clone())) return false ; } if ( m_dAddedOverlap > EPS_SMALL) { pCrv->Invert() ; pCrv->TrimStartAtLen( m_dAddedOverlap) ; pCrv->Invert() ; } } else { double dU ; if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) { if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( 0, dU))) return false ; } else { if ( ! pCrv.Set( pCompo->Clone())) return false ; } if ( m_dAddedOverlap > EPS_SMALL) pCrv->TrimStartAtLen( m_dAddedOverlap) ; pCrv->Invert() ; } pCrv->SetExtrusion( vtN) ; // la porto alla giusta quota Point3d ptFin ; pCrv->GetEndPoint( ptFin) ; Vector3d vtMove = ptStart - ptFin ; pCrv->Translate( vtMove) ; // assegno la corretta pendenza double dNini = ( ptP1 - ORIG) * vtN ; double dNfin = ( ptStart - ORIG) * vtN ; AdjustCurveSlope( pCrv, dNini, dNfin) ; // eventuale spezzatura if ( bSplitArcs && ! ApproxWithLines( pCrv)) return false ; // emetto return ( AddCurveMove( pCrv) != GDB_ID_NULL) ; } case MILL_LI_ZIGZAG : { // recupero la parte richiesta della curva PtrOwner pCrv ; if ( ! bInvert) { double dU ; if ( pCompo->GetParamAtLength( dTang, dU)) { double dParS, dParE ; pCompo->GetDomain( dParS, dParE) ; if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dParS, dU))) return false ; } else { if ( ! pCrv.Set( pCompo->Clone())) return false ; } } else { double dLen, dU ; if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - dTang, dU)) { double dParS, dParE ; pCompo->GetDomain( dParS, dParE) ; if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dU, dParE))) return false ; } else { if ( ! pCrv.Set( pCompo->Clone())) return false ; } pCrv->Invert() ; } pCrv->SetExtrusion( vtN) ; // la porto alla giusta quota Point3d ptIni ; pCrv->GetStartPoint( ptIni) ; Vector3d vtMove = ptStart - ptIni ; pCrv->Translate( vtMove) ; // eventuale spezzatura if ( bSplitArcs && ! ApproxWithLines( pCrv)) return false ; // la ripeto a zigzag double dDeltaN = ( ptStart - ptP1) * vtN ; int nStep = int( ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL))) ; double dStep = - dDeltaN / nStep ; for ( int i = 1 ; i <= nStep ; ++ i) { // calcolo quote per pendenza double dNini = ( ptP1 - ORIG) * vtN - ( i - 1) * dStep ; double dNmid = dNini - 0.5 * dStep ; double dNfin = dNmid - 0.5 * dStep ; // copio per zig PtrOwner pCopy1( pCrv->Clone()) ; // assegno la corretta pendenza AdjustCurveSlope( pCopy1, dNini, dNmid) ; // emetto if ( AddCurveMove( pCopy1) == GDB_ID_NULL) return false ; // copio per zag PtrOwner pCopy2( pCrv->Clone()) ; pCopy2->Invert() ; // assegno la corretta pendenza AdjustCurveSlope( pCopy2, dNmid, dNfin) ; // emetto if ( AddCurveMove( pCopy2) == GDB_ID_NULL) return false ; } return true ; } case MILL_LI_HELIX : { bool bAtLeft = ( bInvert != ( m_Params.m_nWorkSide != MILL_WS_RIGHT)) ; // vettore dal punto al centro elica Vector3d vtCen = vtStart ; vtCen.Rotate( vtN, 0, ( bAtLeft ? 1 : - 1)) ; // dati dell'elica double dRad = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ; Point3d ptCen = ptP1 + vtCen * dRad ; double dDeltaN = ( ptStart - ptP1) * vtN ; double dAngCen = ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL)) * ( bAtLeft ? ANG_FULL : - ANG_FULL) ; // creo l'elica PtrOwner pArc( CreateCurveArc()) ; if ( IsNull( pArc) || ! pArc->Set( ptCen, vtN, dRad, - vtCen, dAngCen, dDeltaN)) return false ; // eventuale spezzatura if ( bSplitArcs) { PtrOwner pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo) || ! pCompo->AddCurve( Release( pArc)) || ! ApproxWithLines( pCompo)) return false ; return ( AddCurveMove( pCompo, MCH_CL_LEADIN) != GDB_ID_NULL) ; } else { // emetto l'elica return ( AddCurveMove( pArc, MCH_CL_LEADIN) != GDB_ID_NULL) ; } } default : return false ; } } //---------------------------------------------------------------------------- int Milling::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 != MILL_LO_AS_LI) return MILL_LO_NONE ; return m_Params.m_nLeadOutType ; } //---------------------------------------------------------------------------- bool Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, double dEndElev, bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs, Point3d& ptP1) { // assegno i parametri int nType = GetLeadOutType() ; double dTang = m_Params.m_dLoTang ; double dPerp = m_Params.m_dLoPerp ; double dElev = min( m_Params.m_dLoElev, dEndElev + LIO_ELEV_TOL) ; // se uscita come ingresso o step invertito if ( nType == MILL_LO_AS_LI || bInvert) { int nLiType = GetLeadInType() ; switch ( nLiType) { case MILL_LI_LINEAR : nType = MILL_LO_LINEAR ; break ; case MILL_LI_TG_PERP : nType = MILL_LO_PERP_TG ; break ; case MILL_LI_TANGENT : nType = MILL_LO_TANGENT ; break ; case MILL_LI_GLIDE : nType = MILL_LO_GLIDE ; break ; case MILL_LI_ZIGZAG : nType = MILL_LO_NONE ; break ; case MILL_LI_HELIX : nType = MILL_LO_NONE ; break ; default : nType = MILL_LO_NONE ; break ; } dTang = m_Params.m_dLiTang ; dPerp = m_Params.m_dLiPerp ; if ( nLiType == MILL_LI_HELIX) { dTang = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ; dPerp = dTang ; } dElev = min( m_Params.m_dLiElev, dEndElev + LIO_ELEV_TOL) ; } // senso di rotazione da dir tg a dir esterna bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) || ( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ; // verifico di poter fare l'uscita a inseguimento if ( nType == MILL_LO_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL) nType = MILL_LO_NONE ; // eseguo a seconda del tipo switch ( nType) { case MILL_LO_NONE : ptP1 = ptEnd ; return true ; case MILL_LO_LINEAR : { Vector3d vtPerp = vtEnd ; Vector3d vtRot = vtN - vtN * vtEnd * vtEnd ; vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ; ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ; return ( AddLinearMove( ptP1, MCH_CL_LEADOUT) != GDB_ID_NULL) ; } case MILL_LO_PERP_TG : { Vector3d vtPerp = vtEnd ; Vector3d vtRot = vtN - vtN * vtEnd * vtEnd ; vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ; Point3d ptMid = ptEnd + vtPerp * dPerp ; ptP1 = ptMid + vtEnd * dTang + vtN * dElev ; return ( AddLinearMove( ptMid, MCH_CL_LEADOUT) != GDB_ID_NULL && AddLinearMove( ptP1, MCH_CL_LEADOUT) != GDB_ID_NULL) ; } case MILL_LO_TANGENT : { // calcolo punto finale dell'uscita Vector3d vtPerp = vtEnd ; Vector3d vtRot = vtN - vtN * vtEnd * vtEnd ; vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ; ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ; // inserisco uscita PtrOwner pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ; if ( IsNull( pCrv)) return false ; // eventuale spezzatura if ( bSplitArcs) { PtrOwner pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo) || ! pCompo->AddCurve( Release( pCrv)) || ! ApproxWithLines( pCompo)) return false ; return ( AddCurveMove( pCompo, MCH_CL_LEADOUT) != GDB_ID_NULL) ; } else { return ( AddCurveMove( pCrv, MCH_CL_LEADOUT) != GDB_ID_NULL) ; } } case MILL_LO_GLIDE : { // recupero la parte richiesta della curva di ritorno PtrOwner pCrv ; if ( ! bInvert) { double dU ; if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) { if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( 0, dU))) return false ; } else { if ( ! pCrv.Set( pCompo->Clone())) return false ; } if ( m_dAddedOverlap > EPS_SMALL) pCrv->TrimStartAtLen( m_dAddedOverlap) ; } else { double dLen, dU ; if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)) { double dParS, dParE ; pCompo->GetDomain( dParS, dParE) ; if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dU, dParE))) return false ; } else { if ( ! pCrv.Set( pCompo->Clone())) return false ; } pCrv->Invert() ; if ( m_dAddedOverlap > EPS_SMALL) pCrv->TrimStartAtLen( m_dAddedOverlap) ; } pCrv->SetExtrusion( vtN) ; // la porto alla giusta quota Point3d ptIni ; pCrv->GetStartPoint( ptIni) ; Vector3d vtMove = ptEnd - ptIni ; pCrv->Translate( vtMove) ; // assegno la corretta pendenza double dNini = ( ptEnd - ORIG) * vtN ; AdjustCurveSlope( pCrv, dNini, dNini + dElev) ; // eventuale spezzatura if ( bSplitArcs && ! ApproxWithLines( pCrv)) return false ; // emetto AddCurveMove( pCrv) ; // assegno punto finale dell'uscita pCrv->GetEndPoint( ptP1) ; return true ; } default : return false ; } } //---------------------------------------------------------------------------- bool Milling::AdjustOscillParams( const ICurve* pCrv, bool& bPathOscEnable, double& dRampLen, double& dFlatLen) { // se c'è oscillazione cerco di aggiustare le lunghezze dei Flat per finire con la stessa quota di partenza dRampLen = abs( m_Params.m_dOscRampLen) ; dFlatLen = abs( m_Params.m_dOscFlatLen) ; if ( bPathOscEnable) { // lunghezza del percorso double dLen ; pCrv->GetLength( dLen) ; // se percorso più corto di mezza oscillazione, la disabilito if ( dLen < 2 * dRampLen + 2 * OSC_MIN_LEN) { bPathOscEnable = false ; m_pMchMgr->SetWarning( 2361, "Warning in Milling : oscillation impossible") ; } else { int nOsc = max( static_cast( dLen / ( 2 * dRampLen + 2 * dFlatLen)), 1) ; dFlatLen = ( dLen - nOsc * 2 * dRampLen) / ( 2 * nOsc) ; } } return true ; } //---------------------------------------------------------------------------- bool Milling::AddOscillLine( const ICurveLine* pLine, const Vector3d& vtTool, double dRampLen, double dFlatLen) { // lunghezze dei tratti di oscillazione dRampLen = max( dRampLen, OSC_MIN_LEN) ; dFlatLen = max( dFlatLen, OSC_MIN_LEN) ; double vLenRef[4] = { dRampLen, dRampLen + dFlatLen, 2 * dRampLen + dFlatLen, 2 * dRampLen + 2 * dFlatLen} ; // lunghezza della linea double dLen ; pLine->GetLength( dLen) ; // lunghezza corrente sulla linea double dCurrLen = 0 ; // emissione oscillazioni while ( dCurrLen < dLen - EPS_ZERO) { // lunghezza rimanente double dNextLen = dLen - dCurrLen ; // se inizio è sul primo tratto (rampa discendente) if ( m_dCurrOscillLen < vLenRef[0] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrOscillLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen += dNextLen ; Point3d ptP3 = pLine->GetEnd() ; ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * m_dCurrOscillLen / vLenRef[0]) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrOscillLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen = vLenRef[0] ; Point3d ptP3 = pLine->GetEnd() ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[0] - m_dCurrOscillLen ; m_dCurrOscillLen = vLenRef[0] ; double dU ; pLine->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } // se inizio è sul secondo tratto (parte piatta in basso) else if ( m_dCurrOscillLen < vLenRef[1] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrOscillLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen += dNextLen ; Point3d ptP3 = pLine->GetEnd() ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrOscillLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen = vLenRef[1] ; Point3d ptP3 = pLine->GetEnd() ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[1] - m_dCurrOscillLen ; m_dCurrOscillLen = vLenRef[1] ; double dU ; pLine->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } // se inizio è sul terzo tratto (rampa ascendente) else if ( m_dCurrOscillLen < vLenRef[2] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrOscillLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen += dNextLen ; Point3d ptP3 = pLine->GetEnd() ; ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * ( vLenRef[2] - m_dCurrOscillLen) / ( vLenRef[2] - vLenRef[1])) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrOscillLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen = vLenRef[2] ; Point3d ptP3 = pLine->GetEnd() ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[2] - m_dCurrOscillLen ; m_dCurrOscillLen = vLenRef[2] ; double dU ; pLine->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } // altrimenti è sul quarto tratto (parte piatta in alto) else { // se fine linea è entro il tratto if ( m_dCurrOscillLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen += dNextLen ; Point3d ptP3 = pLine->GetEnd() ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrOscillLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen = 0 ; Point3d ptP3 = pLine->GetEnd() ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[3] - m_dCurrOscillLen ; m_dCurrOscillLen = 0 ; double dU ; pLine->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } } return true ; } //---------------------------------------------------------------------------- bool Milling::AddOscillArc( const ICurveArc* pArc, const Vector3d& vtTool, double dRampLen, double dFlatLen) { // lunghezze dei tratti di oscillazione dRampLen = max( dRampLen, OSC_MIN_LEN) ; dFlatLen = max( dFlatLen, OSC_MIN_LEN) ; double vLenRef[4] = { dRampLen, dRampLen + dFlatLen, 2 * dRampLen + dFlatLen, 2 * dRampLen + 2 * dFlatLen} ; // parametria dell'arco Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; Vector3d vtN = pArc->GetNormVersor() ; double dLen ; pArc->GetLength( dLen) ; // lunghezza corrente sull'arco double dCurrLen = 0 ; // emissione oscillazioni while ( dCurrLen < dLen - EPS_ZERO) { // lunghezza rimanente double dNextLen = dLen - dCurrLen ; // se inizio è sul primo tratto (rampa discendente) if ( m_dCurrOscillLen < vLenRef[0] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrOscillLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen += dNextLen ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * m_dCurrOscillLen / vLenRef[0]) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrOscillLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen = vLenRef[0] ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[0] - m_dCurrOscillLen ; m_dCurrOscillLen = vLenRef[0] ; double dU ; pArc->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } // se inizio è sul secondo tratto (parte piatta in basso) else if ( m_dCurrOscillLen < vLenRef[1] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrOscillLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen += dNextLen ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrOscillLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen = vLenRef[1] ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[1] - m_dCurrOscillLen ; m_dCurrOscillLen = vLenRef[1] ; double dU ; pArc->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ; double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } // se inizio è sul terzo tratto (rampa ascendente) else if ( m_dCurrOscillLen < vLenRef[2] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrOscillLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen += dNextLen ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * ( vLenRef[2] - m_dCurrOscillLen) / ( vLenRef[2] - vLenRef[1])) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrOscillLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen = vLenRef[2] ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[2] - m_dCurrOscillLen ; m_dCurrOscillLen = vLenRef[2] ; double dU ; pArc->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } // altrimenti è sul quarto tratto (parte piatta in alto) else { // se fine linea è entro il tratto if ( m_dCurrOscillLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen += dNextLen ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrOscillLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrOscillLen = 0 ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[3] - m_dCurrOscillLen ; m_dCurrOscillLen = 0 ; double dU ; pArc->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } } return true ; } //---------------------------------------------------------------------------- bool Milling::AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, TabData& tdTabs) { // se ci sono i tab cerco di aggiustare le lunghezze dei Bottom per finire con la stessa quota di partenza double dTabLen = m_Params.m_dTabLen + m_TParams.m_dDiam ; double dTabAngle = Clamp( abs( m_Params.m_dTabAngle), 15., 75.) ; tdTabs.m_dRampLen = min( abs( m_Params.m_dTabHeight) / tan( dTabAngle * DEGTORAD), abs( dTabLen) / 2 - OSC_MIN_LEN) ; tdTabs.m_dTopLen = abs( dTabLen) - 2 * tdTabs.m_dRampLen ; tdTabs.m_dBottomLen = abs( m_Params.m_dTabDist) - abs( dTabLen) ; if ( bPathTabsEnable) { // lunghezza del percorso double dLen ; pCrv->GetLength( dLen) ; dLen -= m_dAddedOverlap ; // se percorso non permette nemmeno un tab disabilito if ( dLen < ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen)) { bPathTabsEnable = false ; m_pMchMgr->SetWarning( 2363, "Warning in Milling : tabs impossible") ; } else { // calcolo numero di tabs e distanza int nTabs = max( static_cast( dLen / ( 2 * tdTabs.m_dRampLen + tdTabs.m_dBottomLen + tdTabs.m_dTopLen)), 0) ; nTabs = min( nTabs, m_Params.m_nTabMax) ; if ( nTabs < m_Params.m_nTabMin) { if ( dLen > ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen) * m_Params.m_nTabMin) nTabs = m_Params.m_nTabMin ; else m_pMchMgr->SetWarning( 2364, "Warning in Milling : tabs number less than minimum") ; } if ( nTabs > 0) tdTabs.m_dBottomLen = ( dLen - nTabs * ( 2 * tdTabs.m_dRampLen + tdTabs.m_dTopLen)) / nTabs ; } } // verifico che le lughezze non siano inferiori al minimo tdTabs.m_dRampLen = max( tdTabs.m_dRampLen, OSC_MIN_LEN) ; tdTabs.m_dBottomLen = max( tdTabs.m_dBottomLen, OSC_MIN_LEN) ; tdTabs.m_dTopLen = max( tdTabs.m_dTopLen, OSC_MIN_LEN) ; return true ; } //---------------------------------------------------------------------------- static void PeriodicIntervalsSubract( Intervals& ivItv, double dPeriod, double dMin, double dMax) { if ( dMin < - EPS_SMALL) { ivItv.Subtract( dPeriod + dMin, dPeriod) ; dMin = 0 ; } if ( dMax > dPeriod + EPS_SMALL) { ivItv.Subtract( dMin, dPeriod) ; dMax -= dPeriod ; } if ( dMin < dMax) ivItv.Subtract( dMin, dMax) ; } //---------------------------------------------------------------------------- bool Milling::CalcTabsPositions( const ICurveComposite* pCompo, double dDepth, bool bPathTabsEnable, const TabData& tdTabs, DBLVECTOR& vdTabs) { // reset posizioni Tabs vdTabs.clear() ; // recupero gruppo ausiliario per Tabs int nTabsId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_TABS) ; // se Tabs non abilitati, cancello gruppo ausiliario relativo ed esco if ( ! bPathTabsEnable) { m_pGeomDB->Erase( nTabsId) ; return true ; } // disabilito eventuale registrazione comandi EXE (riabilitazione automatica) CmdLogOff cmdLogOff ; // creo o svuoto gruppo ausiliario tabs if ( nTabsId == GDB_ID_NULL) { nTabsId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; if ( nTabsId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nTabsId, MCH_TABS) ; } // altrimenti, lo svuoto else m_pGeomDB->EmptyGroup( nTabsId) ; // lunghezza di un Tab double dTabLen = tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen ; // lunghezza del percorso double dLen ; pCompo->GetLength( dLen) ; dLen -= m_dAddedOverlap ; // vettore estrusione del percorso Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ; if ( vtExtr.IsSmall()) vtExtr = Z_AX ; // determinazione intervalli validi Intervals ivTabs ; // inizializzo intervallo valido (non sono ammessi tab a cavallo di inizio/fine) ivTabs.Set( 0, dLen - dTabLen) ; // elimino le zone con piccolo raggio e quelle vicine agli angoli const double RAD_MIN = 100 ; const double CORNER_RAG = 2 ; const double CORNER_ANG = 5 ; const double CORNER_DIST = 2 ; bool bContinue = true ; double dJointLen = 0 ; const ICurve* pCurrCrv = pCompo->GetFirstCurve() ; const ICurve* pNextCrv = pCompo->GetNextCurve() ; while ( pNextCrv != nullptr) { // calcolo lunghezza entità double dEntLen = 0 ; pCurrCrv->GetLength( dEntLen) ; // se arco, verifico se spigolo o inferiore a raggio minimo const ICurveArc* pArc = GetCurveArc( pCurrCrv) ; if ( pArc != nullptr) { // determino il raggio sul profilo bool bCCW = ( pArc->GetAngCenter() > 0) ; double dRad = pArc->GetRadius() ; if ( m_Params.m_nWorkSide == MILL_WS_LEFT) dRad += m_TParams.m_dDiam / 2 * ( bCCW ? 1 : -1) ; else if ( m_Params.m_nWorkSide == MILL_WS_RIGHT) dRad += m_TParams.m_dDiam / 2 * ( bCCW ? -1 : 1) ; // se raggio molto piccolo è uno spigolo if ( dRad < CORNER_RAG) { double dMin = dJointLen - CORNER_DIST - dTabLen ; double dMax = dJointLen + dEntLen + CORNER_DIST ; PeriodicIntervalsSubract( ivTabs, dLen, dMin, dMax) ; } // se raggio è piccolo else if ( dRad < RAD_MIN) { double dMin = dJointLen - dTabLen ; double dMax = dJointLen + dEntLen ; PeriodicIntervalsSubract( ivTabs, dLen, dMin, dMax) ; } } // aggiorno lunghezza alla giunzione con la successiva dJointLen += dEntLen ; // verifico se angolo tra le entità Vector3d vtTg1 ; pCurrCrv->GetEndDir( vtTg1) ; Vector3d vtTg2 ; pNextCrv->GetStartDir( vtTg2) ; if ( abs( ( vtTg1 ^ vtTg2) * vtExtr) > sin( CORNER_ANG * DEGTORAD)) { double dMin = dJointLen - CORNER_DIST - dTabLen ; double dMax = dJointLen + CORNER_DIST ; PeriodicIntervalsSubract( ivTabs, dLen, dMin, dMax) ; } // passo al successivo pCurrCrv = pNextCrv ; if ( bContinue) { pNextCrv = pCompo->GetNextCurve() ; if ( pNextCrv == nullptr && pCompo->IsClosed()) { pNextCrv = pCompo->GetFirstCurve() ; bContinue = false ; } } else pNextCrv = nullptr ; } // determino posizioni di inizio dei Tabs double dLastIns = -1 - 2 * dTabLen ; double dNextTab = 0.5 * tdTabs.m_dBottomLen ; double dCurrLen = 0 ; while ( dCurrLen + dNextTab < dLen) { double dPos = dCurrLen + dNextTab ; double dPrev, dNext ; if ( ivTabs.IsInside( dPos)) { vdTabs.emplace_back( dPos) ; dLastIns = dPos ; } else if ( ivTabs.GetPrevNearest( dPos, dPrev) && dPrev > dLastIns + 1.5 * dTabLen) { vdTabs.emplace_back( dPrev) ; dLastIns = dPrev ; } else if ( ivTabs.GetNextNearest( dPos, dNext) && dNext > dLastIns + dTabLen) { vdTabs.emplace_back( dNext) ; dLastIns = dNext ; } dCurrLen += dNextTab + dTabLen ; dNextTab = tdTabs.m_dBottomLen ; } // recupero posizioni tabs adiacenti di precedenti lavorazioni, se accettabili DBLVECTOR vdAdj ; double dMaxDist = m_TParams.m_dDiam + 10. ; BBox3d b3Mill ; m_pGeomDB->GetGlobalBBox( m_nOwnerId, b3Mill) ; b3Mill.Expand( dMaxDist) ; int nOpeId = m_pMchMgr->GetNextActiveOperation( m_pMchMgr->GetPhaseDisposition( m_nPhase)) ; while ( nOpeId != GDB_ID_NULL && m_pMchMgr->GetOperationPhase( nOpeId) == m_nPhase) { if ( nOpeId != m_nOwnerId) { int nTabId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetFirstNameInGroup( nOpeId, MCH_TABS)) ; while ( nTabId != GDB_ID_NULL) { Point3d ptCen ; if ( ExeCenterPoint( nTabId, GDB_ID_ROOT, ptCen) && b3Mill.EnclosesXY( ptCen)) { // porto il centro alla quota del percorso ptCen += vtExtr * ( dDepth - m_Params.m_dTabHeight) ; // calcolo la distanza del centro dal percorso double dDist ; double dPar, dAdjLen ; int nFlag ; DistPointCurve distPC( ptCen, *pCompo) ; if ( distPC.GetDist( dDist) && dDist < dMaxDist && distPC.GetParamAtMinDistPoint( 0, dPar, nFlag) && pCompo->GetLengthAtParam( dPar, dAdjLen)) { double dPos = dAdjLen - dTabLen / 2 ; if ( dPos < 0) dPos += dLen ; double dPrev, dNext ; if ( ivTabs.IsInside( dPos)) vdAdj.emplace_back( dPos) ; else if ( ivTabs.GetPrevNearest( dPos, dPrev) && abs( dPos - dPrev) <= dTabLen / 2) vdAdj.emplace_back( dPrev) ; else if ( ivTabs.GetNextNearest( dPos, dNext) && abs( dNext - dPos) <= dTabLen / 2) vdAdj.emplace_back( dNext) ; } } nTabId = m_pGeomDB->GetNext( nTabId) ; } } nOpeId = m_pMchMgr->GetNextActiveOperation( nOpeId) ; } // correggo posizione tabs per eventuali adiacenti if ( ! vdAdj.empty()) { // ordino le posizioni adiacenti in senso crescente lungo la lavorazione sort( vdAdj.begin(), vdAdj.end()) ; // se non sono presenti tabs if ( vdTabs.empty()) { for ( int i = 0 ; i < int( vdAdj.size()) && i < m_Params.m_nTabMax ; ++ i) { vdTabs.emplace_back( vdAdj[i]) ; } } // altrimenti else { // per ogni posizione adiacente for ( int i = 0 ; i < int( vdAdj.size()) ; ++ i) { double dPos = vdAdj[i] ; // cerco quale posizione già definita sostituire for ( int j = 0 ; j < int( vdTabs.size()) ; ++ j) { if ( abs( dPos - vdTabs[j]) < EPS_SMALL) ; else if ( dPos < vdTabs[j]) { if ( j == 0) vdTabs[j] = dPos ; else { if ( abs( dPos - vdTabs[j-1]) < abs( vdTabs[j] - dPos)) vdTabs[j-1] = dPos ; else vdTabs[j] = dPos ; } break ; } else if ( j == int( vdTabs.size()) - 1) { vdTabs[j] = dPos ; break ; } } } } } // inserisco geometria ausiliaria per i tabs for ( auto& dPos : vdTabs) { // recupero la posizione double dU ; Point3d ptCen ; if ( pCompo->GetParamAtLength( dPos + dTabLen / 2, dU) && pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptCen)) { // porto il centro alla quota del tab ptCen -= vtExtr * ( dDepth - m_Params.m_dTabHeight) ; // creo il cerchio PtrOwner pCircle( CreateCurveArc()) ; if ( ! IsNull( pCircle) && pCircle->Set( ptCen, vtExtr, m_TParams.m_dDiam / 2)) { int nCircId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nTabsId, Release( pCircle)) ; m_pGeomDB->SetMaterial( nCircId, AQUA) ; } } } // aggiungo la posizione tappo vdTabs.emplace_back( dLen + m_dAddedOverlap + 100.) ; return true ; } //---------------------------------------------------------------------------- bool Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) { // lunghezze dei tratti di oscillazione double vLen[4] = { 0, tdTabs.m_dRampLen, tdTabs.m_dRampLen + tdTabs.m_dTopLen, tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ; // lunghezza della linea double dLen ; pLine->GetLength( dLen) ; // lunghezza corrente sulla linea double dCurrLen = 0 ; // indice corrente di posizione int nI = 0 ; // emissione oscillazioni while ( dCurrLen < dLen - EPS_ZERO && nI < int( vdTabs.size())) { // lunghezze di riferimento dei tratti di oscillazione double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ; // lunghezza rimanente double dNextLen = dLen - dCurrLen ; // se inizio è sul primo tratto (parte piatta in basso) if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen += dNextLen ; Point3d ptP3 = pLine->GetEnd() ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen = vLenRef[0] ; Point3d ptP3 = pLine->GetEnd() ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[0] - m_dCurrTabsLen ; m_dCurrTabsLen = vLenRef[0] ; double dU ; pLine->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } // se inizio è sul secondo tratto (rampa ascendente) else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen += dNextLen ; Point3d ptP3 = pLine->GetEnd() ; ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrTabsLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen = vLenRef[1] ; Point3d ptP3 = pLine->GetEnd() ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[1] - m_dCurrTabsLen ; m_dCurrTabsLen = vLenRef[1] ; double dU ; pLine->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } // se inizio è sul terzo tratto (parte piatta in alto) else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen += dNextLen ; Point3d ptP3 = pLine->GetEnd() ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen = vLenRef[2] ; Point3d ptP3 = pLine->GetEnd() ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[2] - m_dCurrTabsLen ; m_dCurrTabsLen = vLenRef[2] ; double dU ; pLine->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } // altrimenti è sul quarto tratto (rampa discendente) else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) { // se fine linea è entro il tratto if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen += dNextLen ; Point3d ptP3 = pLine->GetEnd() ; ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // se fine linea è alla fine del tratto else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen = vLenRef[3] ; Point3d ptP3 = pLine->GetEnd() ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } // altrimenti fine linea è oltre else { dCurrLen += vLenRef[3] - m_dCurrTabsLen ; m_dCurrTabsLen = vLenRef[3] ; double dU ; pLine->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; if ( AddLinearMove( ptP3) == GDB_ID_NULL) return false ; } } // altrimenti passo all'intervallo successivo else ++ nI ; } return true ; } //---------------------------------------------------------------------------- bool Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) { // lunghezze dei tratti di oscillazione double vLen[4] = { 0, tdTabs.m_dRampLen, tdTabs.m_dRampLen + tdTabs.m_dTopLen, tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ; // parametri dell'arco Point3d ptCen = pArc->GetCenter() ; double dAngCen = pArc->GetAngCenter() ; Vector3d vtN = pArc->GetNormVersor() ; double dLen ; pArc->GetLength( dLen) ; // lunghezza corrente sull'arco double dCurrLen = 0 ; // indice corrente di posizione int nI = 0 ; // emissione oscillazioni while ( dCurrLen < dLen - EPS_ZERO && nI < int( vdTabs.size())) { // lunghezze di riferimento dei tratti di oscillazione double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ; // lunghezza rimanente double dNextLen = dLen - dCurrLen ; // se inizio è sul primo tratto (parte piatta in basso) if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) { // se fine arco è entro il tratto if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen += dNextLen ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // se fine arco è alla fine del tratto else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen = vLenRef[0] ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti fine arco è oltre else { dCurrLen += vLenRef[0] - m_dCurrTabsLen ; m_dCurrTabsLen = vLenRef[0] ; double dU ; pArc->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } // se inizio è sul secondo tratto (rampa ascendente) else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) { // se fine arco è entro il tratto if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen += dNextLen ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // se fine arco è alla fine del tratto else if ( m_dCurrTabsLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen = vLenRef[1] ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti fine arco è oltre else { dCurrLen += vLenRef[1] - m_dCurrTabsLen ; m_dCurrTabsLen = vLenRef[1] ; double dU ; pArc->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } // se inizio è sul terzo tratto (parte piatta in alto) else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) { // se fine arco è entro il tratto if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen += dNextLen ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // se fine arco è alla fine del tratto else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen = vLenRef[2] ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti fine arco è oltre else { dCurrLen += vLenRef[2] - m_dCurrTabsLen ; m_dCurrTabsLen = vLenRef[2] ; double dU ; pArc->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; ptP3 += vtTool * abs( m_Params.m_dTabHeight) ; double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } // altrimenti è sul quarto tratto (rampa discendente) else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) { // se fine arco è entro il tratto if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen += dNextLen ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // se fine arco è alla fine del tratto else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) { dCurrLen = dLen ; m_dCurrTabsLen = vLenRef[3] ; Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; double dCurrAngCen = dAngCen * dNextLen / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } // altrimenti fine arco è oltre else { dCurrLen += vLenRef[3] - m_dCurrTabsLen ; m_dCurrTabsLen = vLenRef[3] ; double dU ; pArc->GetParamAtLength( dCurrLen, dU) ; Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ; double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ; if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL) return false ; } } // altrimenti passo all'intervallo successivo else ++ nI ; } return true ; } //---------------------------------------------------------------------------- double Milling::GetRadiusForStartEndElevation( bool bExtra) const { // se da non estendere if ( ! bExtra) return ( 0.5 * m_TParams.m_dTDiam) ; // aumentato const double DELTA_ELEV_RAD = 2.0 ; double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ; return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; } //---------------------------------------------------------------------------- bool Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, double dSafeZ) const { // per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento fresa lungo il suo asse) double dTemp ; if ( ! GetElevation( m_nPhase, ptP, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTemp)) return false ; return ( dTemp < 10 * EPS_SMALL || dTemp > dElev + 10 * EPS_SMALL) ; } // per lame else { // determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento lama in +/- Z) double dTemp ; Vector3d vtMove = ( m_bAboveHead ? Z_AX : -Z_AX) ; Vector3d vtSafe = vtCorr ; vtSafe.z = 0 ; vtSafe.Normalize() ; Point3d ptQ = ptP - ( vtSafe + vtMove) * max( 0.2 * dSafeZ, MIN_SAFEDIST) ; if ( ! GetElevation( m_nPhase, ptQ, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) return false ; Point3d ptR = ptP + vtTool * m_TParams.m_dThick ; if ( ! GetElevation( m_nPhase, ptR, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) return false ; return true ; } } //---------------------------------------------------------------------------- bool Milling::GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const { // derivo punti più bassi dell'utensile Vector3d vtDown = - FromUprightOrtho( vtTool) ; Point3d ptP1 = ptP + vtDown * 0.5 * m_TParams.m_dTDiam ; Point3d ptP2 = ptP1 + vtTool * ((( m_TParams.m_nType & TF_SAWBLADE) == 0) ? m_TParams.m_dLen : m_TParams.m_dThick) ; // determino la posizione dei punti rispetto al grezzo // ciclo sui grezzi int nRawId = m_pMchMgr->GetFirstRawPart() ; while ( nRawId != GDB_ID_NULL) { // se il grezzo compare nella fase if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) { int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; BBox3d b3Raw ; m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ; if ( ! b3Raw.IsEmpty()) { if ( ptP1.z < b3Raw.GetMax().z + 10 * EPS_SMALL || ptP2.z < b3Raw.GetMax().z + 10 * EPS_SMALL) return false ; } } nRawId = m_pMchMgr->GetNextRawPart( nRawId) ; } return true ; } //---------------------------------------------------------------------------- bool Milling::CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU) { // verifico curva if ( pCompo == nullptr) return false ; // se utensile centrato, direzione di correzione nulla if ( m_Params.m_nWorkSide == MILL_WS_CENTER) return true ; // calcolo del versore correzione Vector3d vtCorr = CalcCorrDir( pCompo, dU) ; // imposto versore correzione SetCorrDir( vtCorr) ; // se rinvio da sotto in uso, non devo impostare direzione aux da correzione if ( m_bAggrBottom) return true ; // se impostato uso direttamente da lavorazione, imposto anche come versore aux if ( m_Params.m_nSolCh == MCH_SCC_ADIR_NEAR || m_Params.m_nSolCh == MCH_SCC_ADIR_FAR) SetAuxDir( vtCorr) ; // se standard o nullo o suo opposto if ( m_Params.m_nSolCh == MCH_SCC_STD || m_Params.m_nSolCh == MCH_SCC_NONE || m_Params.m_nSolCh == MCH_SCC_OPPOSITE) { // verifico se richiesto dalla testa if ( m_nHeadSolCh == MCH_SCC_ADIR_NEAR || m_nHeadSolCh == MCH_SCC_ADIR_FAR) SetAuxDir( vtCorr) ; } return true ; } //---------------------------------------------------------------------------- Vector3d Milling::CalcCorrDir( const ICurveComposite* pCompo, double dU) { // verifico curva if ( pCompo == nullptr) return V_NULL ; // se utensile centrato, direzione di correzione nulla if ( m_Params.m_nWorkSide == MILL_WS_CENTER) return V_NULL ; // angolo di rotazione da tg a versore corr/aux bool bCcwRot = (m_Params.m_nWorkSide == MILL_WS_LEFT) ; double dCaRot = ( bCcwRot ? ANG_RIGHT : -ANG_RIGHT) ; // dominio parametrico della curva double dUs, dUe ; pCompo->GetDomain( dUs, dUe) ; // se inizio if ( dU < dUs + EPS_ZERO) { // recupero la tangente dopo Point3d ptP ; Vector3d vtN ; pCompo->GetPointTang( dU, ICurve::FROM_PLUS, ptP, vtN) ; vtN.Rotate( m_vtTool, dCaRot) ; return vtN ; } // se fine else if ( dU > dUe - EPS_ZERO) { // recupero la tangente prima Point3d ptP ; Vector3d vtN ; pCompo->GetPointTang( dU, ICurve::FROM_MINUS, ptP, vtN) ; vtN.Rotate( m_vtTool, dCaRot) ; return vtN ; } // altrimenti else { // recupero la tangente prima e dopo il punto Point3d ptP1, ptP2 ; Vector3d vtT1, vtT2 ; pCompo->GetPointTang( dU, ICurve::FROM_MINUS, ptP1, vtT1) ; pCompo->GetPointTang( dU, ICurve::FROM_PLUS, ptP2, vtT2) ; // se coincidono if ( AreSameVectorApprox( vtT1, vtT2)) { Vector3d vtN = vtT1 ; vtN.Rotate( m_vtTool, dCaRot) ; return vtN ; } // se sono opposte else if ( AreOppositeVectorApprox( vtT1, vtT2)) { Vector3d vtN = ( bCcwRot ? vtT2 : vtT1) ; return vtN ; } // altrimenti else { Vector3d vtN = ( vtT1 + vtT2) / 2 ; vtN.Rotate( m_vtTool, dCaRot) ; return vtN ; } } } //---------------------------------------------------------------------------- bool Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs) { // determino opzioni di offset int nFlag = ICurve::OFF_FILLET ; if ( pCompo->IsClosed()) { Vector3d vtStart ; pCompo->GetStartDir( vtStart) ; Vector3d vtEnd ; pCompo->GetEndDir( vtEnd) ; if ( ! AreSameVectorEpsilon( vtStart, vtEnd, sin( 5 * DEGTORAD))) nFlag |= ICurve::OFF_FORCE_OPEN ; } if ( m_Params.m_bLeaveTab || m_Params.m_bOscEnable) nFlag |= ICurve::OFF_MEDIA_INTDZ ; // determino se curva piatta e recupero suo vettore estrusione Plane3d plPlane ; bool bIsFlat = pCompo->IsFlat( plPlane, false, 10 * EPS_SMALL) ; Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ; // se curva piatta con estrusione non perpendicolare forzo offset avanzato bool bAdvOffs = ( bIsFlat && abs( vtExtr * plPlane.GetVersN()) < cos( 0.1 * DEGTORAD)) ; // eseguo offset semplice if ( ! bAdvOffs && pCompo->SimpleOffset( dSignOffs, nFlag)) return true ; // eseguo offset avanzato if ( bIsFlat) { OffsetCurve OffsCrv ; if ( OffsCrv.Make( pCompo, dSignOffs, nFlag)) { ICurve* pOffs = OffsCrv.GetLongerCurve() ; if ( pOffs != nullptr) { pCompo->Clear() ; pCompo->AddCurve( pOffs) ; pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ; return true ; } } } return false ; }