//---------------------------------------------------------------------------- // EgalTech 2019-2019 //---------------------------------------------------------------------------- // File : WaterJetting.cpp Data : 08.07.19 Versione : 2.1g2 // Contenuto : Implementazione gestione taglio water jet. // // // // Modifiche : 08.07.19 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "MachMgr.h" #include "DllMain.h" #include "WaterJetting.h" #include "GeoConst.h" #include "OperationConst.h" #include "OperUserNotesConst.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/EGkUserObjFactory.h" #include "/EgtDev/Include/EGkStringUtils3d.h" #include "/EgtDev/Include/EGnStringKeyVal.h" #include "/EgtDev/Include/EgtPointerOwner.h" using namespace std ; //------------------------------ Errors -------------------------------------- // 3201 = "Error in WaterJetting : UpdateToolData failed" // 3202 = "Error in WaterJetting : Offset not computable" // 3203 = "Error in WaterJetting : Empty RawBox" // 3204 = "Error in WaterJetting : entity too small near inside corner" // 3205 = "Error in WaterJetting : machining depth (xx) bigger than MaxMaterial (yy)" // 3207 = "Error in WaterJetting : Approach not computable" // 3208 = "Error in WaterJetting : LeadIn not computable" // 3209 = "Error in WaterJetting : LeadOut not computable" // 3210 = "Error in WaterJetting : Retract not computable" // 3211 = "Error in WaterJetting : Linear Approx not computable" // 3212 = "Error in WaterJetting : Chaining failed" // 3213 = "Error in WaterJetting : Tool MaxMaterial too small (xx)" // 3214 = "Error in WaterJetting : axes values not calculable" // 3215 = "Error in WaterJetting : outstroke xx" // 3216 = "Error in WaterJetting : link movements not calculable" // 3217 = "Error in WaterJetting : link outstroke xx" // 3218 = "Error in WaterJetting : post apply not calculable" // 3219 = "Error in WaterJetting : Tool loading failed" // 3220 = "Error in WaterJetting : Center work not allowed with side angle" // 3221 = "Error in WaterJetting : Path plane different from XY" // 3222 = "Error in WaterJetting : special apply not calculable" // 3251 = "Warning in WaterJetting : Skipped entity (xx)" // 3252 = "Warning in WaterJetting : No machinable path" // 3253 = "Warning in WaterJetting : Tool name changed (xx)" // 3254 = "Warning in WaterJetting : Tool data changed (xx)" // 3255 = "Warning in WaterJetting : skipped Path too short" //---------------------------------------------------------------------------- const double EXTRA_ACC_LEN = 0.5 ; const double INTANG_ROT_LEN = 5.0 ; const double LEN_TOL = 100 * EPS_SMALL ; // valore limite per gestione degli angoli //---------------------------------------------------------------------------- USEROBJ_REGISTER( GetOperationClass( OPER_WATERJETTING), WaterJetting) ; //---------------------------------------------------------------------------- const string& WaterJetting::GetClassName( void) const { return USEROBJ_GETNAME( WaterJetting) ; } //---------------------------------------------------------------------------- WaterJetting* WaterJetting::Clone( void) const { // alloco oggetto WaterJetting* pWJ = new(nothrow) WaterJetting ; // eseguo copia dei dati if ( pWJ != nullptr) { try { pWJ->m_vId = m_vId ; pWJ->m_pMchMgr = m_pMchMgr ; pWJ->m_nPhase = m_nPhase ; pWJ->m_Params = m_Params ; pWJ->m_TParams = m_TParams ; pWJ->m_dTHoldBase = m_dTHoldBase ; pWJ->m_dTHoldLen = m_dTHoldLen ; pWJ->m_dTHoldDiam = m_dTHoldDiam ; pWJ->m_dElev = m_dElev ; pWJ->m_nStatus = m_nStatus ; pWJ->m_nMills = m_nMills ; pWJ->m_nHeadSolCh = m_nHeadSolCh ; pWJ->m_ptLastProbe = m_ptLastProbe ; } catch( ...) { delete pWJ ; return nullptr ; } } // ritorno l'oggetto return pWJ ; } //---------------------------------------------------------------------------- bool WaterJetting::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 WaterJetting::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 WaterJetting::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 ; } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- WaterJetting::WaterJetting( 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_dElev = 0 ; m_nStatus = MCH_ST_TO_VERIFY ; m_nMills = 0 ; m_nHeadSolCh = MCH_SCC_NONE ; } //---------------------------------------------------------------------------- bool WaterJetting::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 WaterJettingData* pDdata = GetWaterJettingData( 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 WaterJetting::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_PROBING : if ( bVal != m_Params.m_bProbing) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_bProbing = bVal ; return true ; case MPA_LIHOLE : if ( bVal != m_Params.m_bLiHole) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_bLiHole = bVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool WaterJetting::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_EXTCORNERTYPE : if ( ! m_Params.VerifyExtCornerType( nVal)) return false ; if ( nVal != m_Params.m_nExtCornerType) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nExtCornerType = nVal ; break ; case MPA_INTCORNERTYPE : if ( ! m_Params.VerifyIntCornerType( nVal)) return false ; if ( nVal != m_Params.m_nIntCornerType) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nIntCornerType = nVal ; break ; case MPA_CORNERSLOWPERC : if ( ! m_Params.VerifyCornerSlowPerc( nVal)) return false ; if ( nVal != m_Params.m_nCornerSlowPerc) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nCornerSlowPerc = nVal ; break ; 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_LPTURNS : if ( nVal != m_Params.m_nLpTurns) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nLpTurns = nVal ; break ; case MPA_HPTURNS : if ( nVal != m_Params.m_nHpTurns) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nHpTurns = nVal ; break ; case MPA_SCC : if ( ! m_Params.VerifySolCh( nVal)) return false ; if ( nVal != m_Params.m_nSolCh) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nSolCh = nVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool WaterJetting::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_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_THICKREF : if ( ! m_Params.VerifyThickRef( dVal)) return false ; if ( abs( dVal - m_Params.m_dThickRef) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dThickRef = 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_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_SIDEANGLE : if ( ! m_Params.VerifySideAngle( dVal)) return false ; if ( ! AreSameAngValue( dVal, m_Params.m_dSideAngle)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dSideAngle = dVal ; return true ; case MPA_FORWARDANGLE : if ( ! m_Params.VerifyForwardAngle( dVal)) return false ; if ( ! AreSameAngValue( dVal, m_Params.m_dForwardAngle)) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dForwardAngle = 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_PROBINGMINDIST : if ( abs( dVal - m_Params.m_dProbingMinDist) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dProbingMinDist = dVal ; return true ; case MPA_PROBINGMAXDIST : if ( abs( dVal - m_Params.m_dProbingMaxDist) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dProbingMaxDist = dVal ; return true ; case MPA_CORNERSLOWLEN : if ( abs( dVal - m_Params.m_dCornerSlowLen) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dCornerSlowLen = 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_LIHOLERAD : if ( abs( dVal - m_Params.m_dLiHoleRad) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dLiHoleRad = 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 ; } return false ; } //---------------------------------------------------------------------------- bool WaterJetting::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_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 WaterJetting::SetGeometry( const SELVECTOR& vIds) { // verifico validità gestore DB geometrico if ( m_pGeomDB == nullptr) return false ; // copia temporanea e reset della geometria corrente SELVECTOR vOldId = m_vId ; 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 WaterJetting : Skipped entity " + ToString( Id) ; m_pMchMgr->SetWarning( 3251, sInfo) ; continue ; } // posso aggiungere alla lista m_vId.emplace_back( Id) ; } // aggiorno lo stato if ( m_vId != vOldId) m_nStatus |= MCH_ST_GEO_MODIF ; // restituisco presenza geometria da lavorare return ( ! m_vId.empty() || vIds.empty()) ; } //---------------------------------------------------------------------------- bool WaterJetting::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( 3201, "Error in WaterJetting : 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( 3219, "Error in WaterJetting : 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( 3212, "Error in WaterJetting : Chaining failed") ; return false ; } // verifiche per angolo di sbandamento if ( ! VerifySideAngle()) 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 WaterJetting::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 if ( ! UpdateToolData()) { m_pMchMgr->SetLastError( 3201, "Error in WaterJetting : UpdateToolData failed") ; return false ; } m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ; // se modificata geometria, necessario ricalcolo if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0) bRecalc = true ; // verifico se necessario continuare nell'aggiornamento if ( ! bRecalc && ( m_nStatus == MCH_ST_OK || m_nStatus == MCH_ST_NO_POSTAPPL)) { // confermo i percorsi di lavorazione m_nMills = nCurrMills ; string sLog = string( "WaterJetting apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ; LOG_DBG_INFO( GetEMkLogger(), sLog.c_str()) ; // eseguo aggiornamento assi macchina e collegamento con operazione precedente if ( ! Update( bPostApply)) return false ; m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ; LOG_DBG_INFO( GetEMkLogger(), "Update done") ; // esco con successo return true ; } m_nStatus = MCH_ST_TO_VERIFY ; // recupero gruppo per geometria ausiliaria int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ; bool bChain = false ; // se non c'è, lo aggiungo if ( nAuxId == GDB_ID_NULL) { nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; if ( nAuxId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nAuxId, MCH_AUX) ; m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ; bChain = true ; } // altrimenti, se chiesto ricalcolo, lo svuoto else if ( bRecalc) { m_pGeomDB->EmptyGroup( nAuxId) ; bChain = true ; } // rendo corrente l'utensile usato nella lavorazione if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) { m_pMchMgr->SetLastError( 3219, "Error in WaterJetting : 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( 3212, "Error in WaterJetting : Chaining failed") ; return false ; } // verifiche per angolo di sbandamento if ( ! VerifySideAngle()) return false ; // recupero gruppo per geometria di lavorazione (Cutter Location) int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ; // se non c'è, lo aggiungo if ( nClId == GDB_ID_NULL) { nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; if ( nClId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nClId, MCH_CL) ; } // altrimenti lo svuoto else m_pGeomDB->EmptyGroup( nClId) ; // lavoro ogni singola catena bool bOk = true ; int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ; while ( nPathId != GDB_ID_NULL) { if ( ! ProcessPath( nPathId, GDB_ID_NULL, nClId)) bOk = false ; nPathId = m_pGeomDB->GetNextGroup( nPathId) ; } if ( ! bOk) return false ; // assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso CalcAndSetBBox( nClId) ; // eseguo aggiornamento assi macchina e collegamento con operazione precedente if ( ! Update( bPostApply)) return false ; // aggiorno stato della lavorazione m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ; // dichiaro successiva da aggiornare UpdateFollowingOperationsStatus( MCH_ST_OTH_MODIF) ; LOG_DBG_INFO( GetEMkLogger(), "WaterJetting apply done") ; return true ; } //---------------------------------------------------------------------------- bool WaterJetting::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( 3252, "Warning in WaterJetting : No machinable path") ; return true ; } // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) RemoveClimbRiseHome() ; // imposto eventuale asse bloccato da lavorazione SetBlockedRotAxis( m_Params.m_sBlockedAxis) ; // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; if ( ! m_Params.m_sInitAngs.empty()) sHint = m_Params.m_sInitAngs ; if ( ! CalculateAxesValues( sHint)) { string sInfo = m_pMchMgr->GetOutstrokeInfo() ; if ( sInfo.empty()) m_pMchMgr->SetLastError( 3214, "Error in WaterJetting : axes values not calculable") ; else m_pMchMgr->SetLastError( 3215, "Error in WaterJetting : outstroke ") ; return false ; } // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso CalcAndSetAxesBBox() ; // esecuzione eventuali personalizzazioni speciali string sSpecErr ; if ( bPostApply && ! SpecialApply( sSpecErr)) { if ( ! IsEmptyOrSpaces( sSpecErr)) m_pMchMgr->SetLastError( 3222, sSpecErr) ; else m_pMchMgr->SetLastError( 3222, "Error in WaterJetting : special apply not calculable") ; 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( 3216, "Error in WaterJetting : link movements not calculable") ; else m_pMchMgr->SetLastError( 3217, "Error in WaterJetting : link outstroke ") ; return false ; } // esecuzione eventuali personalizzazioni finali string sErr ; if ( bPostApply && ! PostApply( sErr)) { if ( ! IsEmptyOrSpaces( sErr)) m_pMchMgr->SetLastError( 3218, sErr) ; else m_pMchMgr->SetLastError( 3218, "Error in WaterJetting : post apply not calculable") ; return false ; } return true ; } //---------------------------------------------------------------------------- bool WaterJetting::GetParam( int nType, bool& bVal) const { switch ( nType) { case MPA_INVERT : bVal = m_Params.m_bInvert ; return true ; case MPA_PROBING : bVal = m_Params.m_bProbing ; return true ; case MPA_LIHOLE : bVal = m_Params.m_bLiHole ; return true ; } bVal = false ; return false ; } //---------------------------------------------------------------------------- bool WaterJetting::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_TYPE : nVal = MT_WATERJETTING ; return true ; case MPA_WORKSIDE : nVal = m_Params.m_nWorkSide ; return true ; case MPA_EXTCORNERTYPE : nVal = m_Params.m_nExtCornerType ; return true ; case MPA_INTCORNERTYPE : nVal = m_Params.m_nIntCornerType ; return true ; case MPA_CORNERSLOWPERC : nVal = m_Params.m_nCornerSlowPerc ; return true ; case MPA_LEADINTYPE : nVal = m_Params.m_nLeadInType ; return true ; case MPA_LEADOUTTYPE : nVal = m_Params.m_nLeadOutType ; return true ; case MPA_LPTURNS : nVal = m_Params.m_nLpTurns ; return true ; case MPA_HPTURNS : nVal = m_Params.m_nHpTurns ; return true ; case MPA_SCC : nVal = m_Params.m_nSolCh ; return true ; } nVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool WaterJetting::GetParam( int nType, double& dVal) const { switch ( nType) { case MPA_SPEED : dVal = GetSpeed() ; return true ; case MPA_FEED : dVal = GetFeed() ; return true ; case MPA_TIPFEED : dVal = GetTipFeed() ; return true ; case MPA_THICKREF : dVal = m_Params.m_dThickRef ; return true ; case MPA_OFFSR : dVal = GetOffsR() ; return true ; case MPA_OVERL : dVal = m_Params.m_dOverlap ; return true ; case MPA_SIDEANGLE : dVal = m_Params.m_dSideAngle ; return true ; case MPA_FORWARDANGLE : dVal = m_Params.m_dForwardAngle ; return true ; case MPA_STARTADDLEN : dVal = m_Params.m_dStartAddLen ; return true ; case MPA_ENDADDLEN : dVal = m_Params.m_dEndAddLen ; return true ; case MPA_PROBINGMINDIST : dVal = m_Params.m_dProbingMinDist ; return true ; case MPA_PROBINGMAXDIST : dVal = m_Params.m_dProbingMaxDist ; return true ; case MPA_CORNERSLOWLEN : dVal = m_Params.m_dCornerSlowLen ; return true ; case MPA_LITANG : dVal = m_Params.m_dLiTang ; return true ; case MPA_LIPERP : dVal = m_Params.m_dLiPerp ; return true ; case MPA_LICOMPLEN : dVal = m_Params.m_dLiCompLen ; return true ; case MPA_LIHOLERAD : dVal = m_Params.m_dLiHoleRad ; return true ; case MPA_LOTANG : dVal = m_Params.m_dLoTang ; return true ; case MPA_LOPERP : dVal = m_Params.m_dLoPerp ; return true ; case MPA_LOCOMPLEN : dVal = m_Params.m_dLoCompLen ; return true ; } dVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool WaterJetting::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_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& WaterJetting::GetToolData( void) const { return m_TParams ; } //---------------------------------------------------------------------------- bool WaterJetting::UpdateToolData( void) { // recupero il gestore DB utensili della macchina corrente ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ; if ( pTMgr == nullptr) return false ; // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome) const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ; if ( pTdata == nullptr) { pTdata = pTMgr->GetTool( m_Params.m_sToolName) ; if ( pTdata == nullptr) return false ; m_Params.m_ToolUuid = m_TParams.m_Uuid ; } // salvo posizione TC, testa e uscita originali string sOrigTcPos = m_TParams.m_sTcPos ; string sOrigHead = m_TParams.m_sHead ; int nOrigExit = m_TParams.m_nExit ; // verifico se sono diversi (ad esclusione di nome, posizione TC, testa e uscita) bool bChanged = ( ! SameTool( m_TParams, *pTdata, false)) ; // aggiorno comunque i parametri m_TParams = *pTdata ; // se definito attrezzaggio, aggiorno i parametri che ne possono derivare string sTcPos ; string sHead ; int nExit ; if ( m_pMchMgr->GetCurrSetupMgr().GetToolData( m_TParams.m_sName, sTcPos, sHead, nExit)) { if ( sOrigTcPos != sTcPos || sOrigHead != sHead || nOrigExit != nExit) bChanged = true ; m_TParams.m_sTcPos = sTcPos ; m_TParams.m_sHead = sHead ; m_TParams.m_nExit = nExit ; } else { if ( sOrigTcPos != pTdata->m_sTcPos || sOrigHead != pTdata->m_sHead || nOrigExit != pTdata->m_nExit) bChanged = true ; } // eventuali segnalazioni if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) { string sInfo = "Warning in WaterJetting : tool name changed (" + m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ; m_pMchMgr->SetWarning( 3253, sInfo) ; m_Params.m_sToolName = m_TParams.m_sName ; } if ( bChanged) { string sInfo = "Warning in WaterJetting : tool data changed (" + m_Params.m_sToolName + ")" ; m_pMchMgr->SetWarning( 3254, sInfo) ; } // se modificato, aggiusto lo stato if ( bChanged) m_nStatus = MCH_ST_TO_VERIFY ; return true ; } //---------------------------------------------------------------------------- bool WaterJetting::GetGeometry( SELVECTOR& vIds) const { // restituisco l'elenco delle entità vIds = m_vId ; return true ; } //---------------------------------------------------------------------------- bool WaterJetting::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 == SRF_TRIMESH) && pGObj->GetType() == SRF_TRIMESH) { nType = SRF_TRIMESH ; 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 == SRF_FLATRGN) && pGObj->GetType() == SRF_FLATRGN) { nType = SRF_FLATRGN ; 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 WaterJetting::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()) ; // se estrusione mancante, imposto default Vector3d vtExtr ; if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall()) pCurve->SetExtrusion( Z_AX) ; } // altrimenti sottocurva di composita else { // recupero la composita const ICurveComposite* pCompo = GetCurveComposite( pGObj) ; if ( pCompo == nullptr) return false ; // recupero la curva semplice const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ; if ( pOriCurve == nullptr) return false ; // la duplico pCurve.Set( pOriCurve->Clone()) ; // recupero estrusione e spessore Vector3d vtExtr ; if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall()) vtExtr = Z_AX ; pCurve->SetExtrusion( vtExtr) ; double dThick ; if ( pCompo->GetThickness( dThick)) pCurve->SetThickness( dThick) ; } if ( IsNull( pCurve)) return false ; // la porto in globale pCurve->ToGlob( frGlob) ; // la restituisco lstPC.emplace_back( Release( pCurve)) ; return true ; } // se altrimenti 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 ; } // altrimenti errore else return false ; } //---------------------------------------------------------------------------- bool WaterJetting::Chain( int nGrpDestId) { // vettore puntatori alle curve ICURVEPOVECTOR vpCrvs ; vpCrvs.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 WaterJetting : Skipped entity " + ToString( Id) ; m_pMchMgr->SetWarning( 3251, sInfo) ; } for ( auto pCrv : lstPC) { // salvo l'id geometrico della curva nelle sue temp prop per i conti successivi pCrv->SetTempProp( Id.nId, 0) ; pCrv->SetTempProp( Id.nSub, 1) ; vpCrvs.emplace_back( pCrv) ; } } // verifico se sono necessarie sistemazioni per collegamenti ( bridges) if ( abs( m_Params.m_dSideAngle) < EPS_ANG_SMALL && m_pGeomDB->GetFirstNameInGroup( m_pMchMgr->GetCurrMachGroup(), MACH_BRIDGES_GROUP) != GDB_ID_NULL) { AdjustCurvesForBridges( vpCrvs) ; } // 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 vnId ; while ( chainC.GetChainFromNear( ptNear, false, vnId)) { // 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 vOrigId ; vOrigId.reserve( vnId.size()) ; // recupero le curve semplici e le inserisco nella curva composita for ( int i = 0 ; i < int( vnId.size()) ; ++ i) { int nId = abs( vnId[i]) - 1 ; bool bInvert = ( vnId[i] < 0) ; // recupero la curva ICurve* pCrv = vpCrvs[nId] ; vOrigId.emplace_back( pCrv->GetTempProp( 0), pCrv->GetTempProp( 1)) ; // 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( vOrigId)) ; // 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 WaterJetting::AdjustCurvesForBridges( ICURVEPOVECTOR& vpCrvs) { // Gruppo dei collegamenti struct Bridge { int nId ; int nEnt1 ; int nEnt2 ; double dWidth ; Point3d ptP1 ; Point3d ptP2 ; Bridge( int nI, int nE1, int nE2, double dW, const Point3d& ptQ1, const Point3d& ptQ2) : nId( nI), nEnt1( nE1), nEnt2( nE2), dWidth( dW), ptP1( ptQ1), ptP2( ptQ2) {} } ; vector vBridges ; int nBridGrpId = m_pGeomDB->GetFirstNameInGroup( m_pMchMgr->GetCurrMachGroup(), MACH_BRIDGES_GROUP) ; int nBridgeId = m_pGeomDB->GetFirstInGroup( nBridGrpId) ; while ( nBridgeId != GDB_ID_NULL) { int nEnt1, nEnt2 ; double dWidth ; Point3d ptP1, ptP2 ; if ( m_pGeomDB->GetInfo( nBridgeId, "EntStart", nEnt1) && m_pGeomDB->GetInfo( nBridgeId, "EntEnd", nEnt2) && m_pGeomDB->GetInfo( nBridgeId, "BridgeW", dWidth) && ExeStartPoint( nBridgeId, GDB_ID_ROOT, ptP1) && ExeEndPoint( nBridgeId, GDB_ID_ROOT, ptP2)) { vBridges.emplace_back( nBridgeId, nEnt1, nEnt2, dWidth, ptP1, ptP2) ; } nBridgeId = m_pGeomDB->GetNext( nBridgeId) ; } // Verifico i collegamenti che interessano le geometrie della lavorazione double const DIST_MAX = 5 ; for ( int i = 0 ; i < int( vBridges.size()) ; ++ i) { // cerco le due curve interessate dal collegamento calcolando e verificando anche la posizione dei punti di collegamento sulle // due curve double dMinLen = vBridges[i].dWidth + m_TParams.m_dDiam ; int nI1 = -1 ; double dDist1, dU1, dLenP1, dLen1 ; int nF1 ; for ( int j = 0 ; j < int( vpCrvs.size()) ; ++ j) { // recupero l'id geometrico della curva dalla sua temp prop int nCrvId = vpCrvs[j]->GetTempProp() ; if ( nCrvId == vBridges[i].nEnt1) { DistPointCurve distPC1( vBridges[i].ptP1, *vpCrvs[j]) ; if ( distPC1.GetDist( dDist1) && dDist1 < DIST_MAX && distPC1.GetParamAtMinDistPoint( 0, dU1, nF1) && vpCrvs[j]->GetLengthAtParam( dU1, dLenP1) && vpCrvs[j]->GetLength( dLen1) && dLenP1 > dMinLen - EPS_SMALL && ( dLen1 - dLenP1) > dMinLen - EPS_SMALL) { nI1 = j ; break ; } } } int nI2 = -1 ; double dDist2, dU2, dLenP2, dLen2 ; int nF2 ; for ( int j = 0 ; j < int( vpCrvs.size()) ; ++ j) { int nCrvId = vpCrvs[j]->GetTempProp() ; if ( nCrvId == vBridges[i].nEnt2) { DistPointCurve distPC2( vBridges[i].ptP2, *vpCrvs[j]) ; if ( distPC2.GetDist( dDist2) && dDist2 < DIST_MAX && distPC2.GetParamAtMinDistPoint( 0, dU2, nF2) && vpCrvs[j]->GetLengthAtParam( dU2, dLenP2) && vpCrvs[j]->GetLength( dLen2) && dLenP2 > dMinLen - EPS_SMALL && ( dLen2 - dLenP2) > dMinLen - EPS_SMALL) { nI2 = j ; break ; } } } if ( nI1 == -1 || nI2 == -1) continue ; // spezzo le curve nei punti del collegamento e creo i segmenti di collegamento PtrOwner pCopy1( vpCrvs[nI1]->Clone()) ; PtrOwner pCopy2( vpCrvs[nI2]->Clone()) ; PtrOwner pLinkA( CreateCurveLine()) ; PtrOwner pLinkB( CreateCurveLine()) ; if ( IsNull( pCopy1) || IsNull( pCopy2) || IsNull( pLinkA) || IsNull( pLinkB)) continue ; vpCrvs[nI1]->TrimEndAtLen( dLenP1 - vBridges[i].dWidth / 2) ; pCopy1->TrimStartAtLen( dLenP1 + vBridges[i].dWidth / 2) ; vpCrvs[nI2]->TrimEndAtLen( dLenP2 - vBridges[i].dWidth / 2) ; pCopy2->TrimStartAtLen( dLenP2 + vBridges[i].dWidth / 2) ; Point3d ptAs ; vpCrvs[nI1]->GetEndPoint( ptAs) ; Point3d ptAe ; pCopy2->GetStartPoint( ptAe) ; pLinkA->Set( ptAs, ptAe) ; Point3d ptBs ; vpCrvs[nI2]->GetEndPoint( ptBs) ; Point3d ptBe ; pCopy1->GetStartPoint( ptBe) ; pLinkB->Set( ptBs, ptBe) ; // inserisco le nuove curve nel vettore delle curve vpCrvs.emplace_back( Release( pCopy1)) ; vpCrvs.emplace_back( Release( pCopy2)) ; vpCrvs.emplace_back( Release( pLinkA)) ; vpCrvs.emplace_back( Release( pLinkB)) ; } return true ; } //---------------------------------------------------------------------------- bool WaterJetting::VerifySideAngle( void) { // verifiche per angolo di sbandamento if ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) { // non ammesso lato di lavoro in centro if ( m_Params.m_nWorkSide == SAW_WS_CENTER) { m_pMchMgr->SetLastError( 3220, "Error in WaterJetting : Center work not allowed with side angle") ; return false ; } } return true ; } //---------------------------------------------------------------------------- bool WaterJetting::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const { // non devo fare alcunché return true ; } //---------------------------------------------------------------------------- bool WaterJetting::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_dTDiam - 10 * EPS_SMALL ; ptCen.Translate( dOffset * pCamData->GetCorrDir()) ; } } // negli altri casi, non devo fare alcunché return true ; } //---------------------------------------------------------------------------- bool WaterJetting::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 Vector3d vtTool ; pCompo->GetExtrusion( vtTool) ; if ( vtTool.IsSmall()) vtTool = Z_AX ; if ( ! AreSameVectorApprox( vtTool, Z_AX)) { m_pMchMgr->SetLastError( 3221, "Error in WaterJetting : Path plane different from XY") ; return false ; } // se percorso chiuso, sposto la partenza come richiesto e lontano da angoli if ( pCompo->IsClosed()) { // recupero indicazione lato di inizio int nStart = 0 ; string sStart ; if ( GetValInNotes( m_Params.m_sUserNotes, UN_START, sStart)) { if ( sStart == "XP") nStart = 1 ; else if ( sStart == "XM") nStart = -1 ; else if ( sStart == "YP") nStart = 2 ; else if ( sStart == "YM") nStart = -2 ; else nStart = 11 ; } // se richiesta sistemazione punto di inizio if ( nStart != 0 && nStart != 11) { const double COS_ANG_PERD_TG = cos( 5 * DEGTORAD) ; const double DIST_SIC_WJ_LIO = 2 ; double dMinLen = m_Params.m_dOverlap + 2 * DIST_SIC_WJ_LIO ; if ( m_Params.m_nLeadInType != WJET_LI_NONE) dMinLen += m_Params.m_dLiTang ; if ( m_Params.m_nLeadOutType != WJET_LO_NONE) dMinLen += ( m_Params.m_nLeadOutType == WJET_LO_AS_LI ? m_Params.m_dLiTang : m_Params.m_dLoTang) ; // ricerca del punto lungo il percorso che risponde alla richiesta int i = 0 ; double dMin = - 1 ; double dValEstr = ( nStart > 0 ? -INFINITO : INFINITO) ; const ICurve* pCrv = pCompo->GetFirstCurve() ; while ( pCrv != nullptr) { double dLen ; if ( pCrv->GetLength( dLen) && dLen > dMinLen) { // se segmento di retta if ( pCrv->GetType() == CRV_LINE) { // verifico il punto medio Point3d ptMid ; if ( pCrv->GetMidPoint( ptMid) && (( nStart == 1 && ptMid.x > dValEstr) || ( nStart == -1 && ptMid.x < dValEstr) || ( nStart == 2 && ptMid.y > dValEstr) || ( nStart == -2 && ptMid.y < dValEstr))) { dValEstr = ( abs( nStart) == 1 ? ptMid.x : ptMid.y) ; dMin = i + 0.5 ; } } // altrimenti arco else { // verifico se estremi sono angoli Point3d ptTmp ; Vector3d vtTgSP ; pCompo->GetPointTang( i, ICurve::FROM_MINUS, ptTmp, vtTgSP) ; Vector3d vtTgSN ; pCompo->GetPointTang( i, ICurve::FROM_PLUS, ptTmp, vtTgSN) ; double dUStart = ( vtTgSP * vtTgSN > COS_ANG_PERD_TG ? 0 : 0.125) ; Vector3d vtTgEP ; pCompo->GetPointTang( i + 1, ICurve::FROM_MINUS, ptTmp, vtTgEP) ; Vector3d vtTgEN ; pCompo->GetPointTang( i + 1, ICurve::FROM_PLUS, ptTmp, vtTgEN) ; double dUEnd = ( vtTgEP * vtTgEN > COS_ANG_PERD_TG ? 1 : 0.875) + 0.01 ; // verifico alcuni punti intermedi for ( double dU = dUStart ; dU <= dUEnd ; dU += 0.0625) { Point3d ptMid ; if ( pCrv->GetPointD1D2( dU, ICurve::FROM_MINUS, ptMid) && (( nStart == 1 && ptMid.x > dValEstr) || ( nStart == -1 && ptMid.x < dValEstr) || ( nStart == 2 && ptMid.y > dValEstr) || ( nStart == -2 && ptMid.y < dValEstr))) { dValEstr = ( abs( nStart) == 1 ? ptMid.x : ptMid.y) ; dMin = i + dU ; } } } } ++ i ; pCrv = pCompo->GetNextCurve() ; } if ( dMin >= 0) pCompo->ChangeStartPoint( dMin) ; } // se altrimenti suggerito punto di inizio else if ( nStart == 11) { TrimLeft( sStart, "(") ; TrimRight( sStart, ")") ; Point3d ptStart ; double dPar ; int nFlag ; if ( FromString( sStart, ptStart) && DistPointCurve( ptStart, *pCompo).GetParamAtMinDistPoint( 0, dPar, nFlag)) { pCompo->ChangeStartPoint( dPar) ; } } } // 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( 3255, "Warning in WaterJetting : 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 dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ; double dOffs = 0.5 * m_TParams.m_dDiam * dSideCoeff + GetOffsR() ; if ( m_Params.m_nWorkSide != WJET_WS_CENTER && abs( dOffs) > EPS_SMALL) { // valore offset double dSignOffs = ( m_Params.m_nWorkSide == WJET_WS_RIGHT) ? dOffs : - dOffs ; // esecuzione offset if ( ! CalcOffset( pCompo, dSignOffs)) { m_pMchMgr->SetLastError( 3202, "Error in WaterJetting : Offset not computable") ; return false ; } } // eventuale sovrapposizione per percorso chiuso double 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)) ; 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 ; // 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( 3203, "Error in WaterJetting : Empty RawBox") ; return false ; } // appiattisco il percorso sulla superficie superiore del grezzo double dZref = b3Raw.GetMax().z ; double dUs, dUe ; pCompo->GetDomain( dUs, dUe) ; for ( int nU = int( dUs) ; nU < dUe + EPS_ZERO ; ++nU) { Point3d ptP ; if ( pCompo->GetPointD1D2( nU, ICurve::FROM_MINUS, ptP)) { ptP.z = dZref ; pCompo->ModifyJoint( nU, ptP) ; } } // recupero nome del path string sPathName ; m_pGeomDB->GetName( nPathId, sPathName) ; // eventuale approssimazione con segmenti di retta bool bSplitArcs = GetSplitArcs( vtTool) ; if ( ! bSplitArcs) { // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi VerifyArcs( pCompo) ; } // se abilitato probing, verifico lunghezza entità ed eventualmente le divido if ( m_Params.m_bProbing) VerifyMaxLenCurves( pCompo, m_Params.m_dProbingMaxDist) ; // calcolo l'elevazione massima m_dElev = ( b3Raw.GetMax().z - b3Raw.GetMin().z) / cos( m_Params.m_dSideAngle * DEGTORAD) ; // verifico che il massimo materiale dell'utensile sia sensato const double MIN_MAXMAT = 1.0 ; if ( m_TParams.m_dMaxMat < m_dElev && m_TParams.m_dMaxMat < MIN_MAXMAT) { string sInfo = "Error in WaterJetting : Tool MaxMaterial too small (" + ToString( m_TParams.m_dMaxMat, 2) + ")" ; m_pMchMgr->SetLastError( 3213, sInfo) ; return false ; } // verifico di non superare il massimo materiale con l'elevazione if ( m_dElev > m_TParams.m_dMaxMat + EPS_SMALL) { string sInfo = "Error in WaterJetting : machining depth (" + ToString( m_dElev, 1) + ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ; m_pMchMgr->SetLastError( 3205, sInfo) ; 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) ; // 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, m_dElev) ; // Sistemazioni per angoli interni AdjustPathForInternalAngles( pCompo) ; // creo l'anteprima del percorso if ( ! GeneratePreView( nPxId, pCompo, vtTool, dAddedOverlap)) 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, m_dElev) ; // Imposto dati comuni SetPathId( nPxId) ; // Sistemazioni per angoli interni AdjustPathForInternalAngles( pCompo) ; // Inserisco la lavorazione if ( ! AddStandardWj( pCompo, vtTool, bSplitArcs, dAddedOverlap)) return false ; } // incremento numero di fresate ++ m_nMills ; return true ; } //---------------------------------------------------------------------------- bool WaterJetting::GeneratePreView( int nPathId, const ICurveComposite* pCompo, const Vector3d& vtTool, double dAddedOverlap) { // colore taglio, dipendente da angolo di inclinazione Color colCut = TEAL ; if ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) colCut = FUCHSIA ; // creo copia della curva composita PtrOwner< ICurve> pCrv( pCompo->Clone()) ; if ( IsNull( pCrv)) return false ; // rimuovo eventuale overlap if ( dAddedOverlap > EPS_SMALL) { pCrv->Invert() ; pCrv->TrimStartAtLen( dAddedOverlap) ; pCrv->Invert() ; } bool bClosed = pCrv->IsClosed() ; // calcolo la regione ridotta PtrOwner pSfr ; double dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ; double dRad = 0.5 * m_TParams.m_dDiam * dSideCoeff ; pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), dRad, false, true)) ; if ( IsNull( pSfr)) return false ; // aggiungo eventuali anelli su angoli esterni if ( ! AddLoopsPreview( pCompo, pSfr)) return false ; // creo la regione completa PtrOwner pSfrTot( CloneSurfFlatRegion( pSfr)) ; if ( IsNull( pSfr)) return false ; // inserisco la regione ridotta nel DB int nRRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfr)) ; if ( nRRId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nRRId, MCH_PV_RRCUT) ; m_pGeomDB->SetMaterial( nRRId, INVISIBLE) ; // regione per attacco PtrOwner pSfrLI( GenerateLeadInPreview( pCompo, vtTool, bClosed)) ; if ( IsNull( pSfrLI)) return false ; if ( pSfrLI->IsValid()) { // se nessun attacco pSrfLI è solo un cerchio segnaposto, aggiungo la sua curva di bordo al DB if ( GetLeadInType() == WJET_LI_NONE) { PtrOwner pCrvLI( pSfrLI->GetLoop( 0, 0)) ; if ( IsNull( pCrvLI)) return false ; int nCLIId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrvLI)) ; if ( nCLIId == GDB_ID_NULL) return false ; // assegno nome e colore m_pGeomDB->SetName( nCLIId, MCH_PV_CUT) ; m_pGeomDB->SetMaterial( nCLIId, colCut) ; } // altrimenti aggiungo la regione else { // aggiungo alla regione completa if ( ! pSfrTot->Add( *pSfrLI)) return false ; // aggiungo nel DB int nRLiId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfrLI)) ; if ( nRLiId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nRLiId, MCH_PV_RLICUT) ; m_pGeomDB->SetMaterial( nRLiId, INVISIBLE) ; } } // regione per uscita PtrOwner pSfrLO( GenerateLeadOutPreview( pCompo, vtTool)) ; if ( IsNull( pSfrLO)) return false ; if ( pSfrLO->IsValid()) { // se regione definita la aggiungo alla regione completa if ( ! pSfrTot->Add( *pSfrLO)) return false ; // aggiungo nel DB int nRLoId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfrLO)) ; if ( nRLoId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nRLoId, MCH_PV_RLOCUT) ; m_pGeomDB->SetMaterial( nRLoId, INVISIBLE) ; } // recupero i contorni della regione completa for ( int i = 0 ; i < pSfrTot->GetLoopCount( 0) ; ++i) { PtrOwner pCrv2( pSfrTot->GetLoop( 0, i)) ; 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, colCut) ; } // aggiungo la regione completa nel DB int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfrTot)) ; if ( nRId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ; m_pGeomDB->SetMaterial( nRId, INVISIBLE) ; // eventuali ripetizioni in basso per tagli inclinati if ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) { // creo copia della curva composita PtrOwner pCrv( pCompo->Clone()) ; if ( IsNull( pCrv)) return false ; // rimuovo eventuale overlap if ( dAddedOverlap > EPS_SMALL) { pCrv->Invert() ; pCrv->TrimStartAtLen( dAddedOverlap) ; pCrv->Invert() ; } ICURVEPOVECTOR vpCrvs ; if ( m_Params.m_dSideAngle < 0) { // se inclinazione negativa devo considerare separatamente ogni sottocurva della composita vpCrvs.reserve( pCrv->GetCurveCount()) ; for ( int i = 0 ; i < pCrv->GetCurveCount() ; i++) vpCrvs.emplace_back( pCrv->GetCurve( i)->Clone()) ; } else { // se inclinazione positiva posso considerare la curva completa vpCrvs.emplace_back( pCrv->Clone()) ; } // offset per raggio utensile double dSignOffs1 = dRad ; if ( ( m_Params.m_nWorkSide == WJET_WS_RIGHT && m_Params.m_dSideAngle > 0) || ( m_Params.m_nWorkSide == WJET_WS_LEFT && m_Params.m_dSideAngle < 0)) dSignOffs1 = - dSignOffs1 ; // offset per inclinazione double dSignOffs2 = dRad + m_dElev * abs( sin( m_Params.m_dSideAngle * DEGTORAD)) ; if ( ( m_Params.m_nWorkSide == WJET_WS_RIGHT && m_Params.m_dSideAngle < 0) || ( m_Params.m_nWorkSide == WJET_WS_LEFT && m_Params.m_dSideAngle > 0)) dSignOffs2 = - dSignOffs2 ; // calcolo la regione PtrOwner pSfr( CreateSurfFlatRegion()) ; if ( IsNull( pSfr)) return false ; for ( int i = 0 ; i < int( vpCrvs.size()) ; i++) { OffsetCurve OffsCrv1 ; OffsCrv1.Make( vpCrvs[i], dSignOffs1, ICurve::OFF_FILLET) ; PtrOwner< ICurve> pOffs1( OffsCrv1.GetLongerCurve()) ; if ( IsNull( pOffs1)) return false ; OffsetCurve OffsCrv2 ; OffsCrv2.Make( vpCrvs[i], dSignOffs2, ICurve::OFF_EXTEND) ; PtrOwner< ICurve> pOffs2( OffsCrv2.GetLongerCurve()) ; if ( IsNull( pOffs2)) return false ; // calcolo la regione corrente PtrOwner pSfrCurr ; // se i due offset sono aperti if ( ! pOffs1->IsClosed() && ! pOffs2->IsClosed()) { // li unisco PtrOwner pBound( CreateCurveComposite()) ; if ( IsNull( pBound)) return false ; pBound->AddCurve( Release( pOffs1)) ; pOffs2->Invert() ; Point3d ptStart ; pOffs2->GetStartPoint( ptStart) ; pBound->AddLine( ptStart) ; pBound->AddCurve( Release( pOffs2)) ; pBound->Close() ; // creo la regione SurfFlatRegionByContours SfrCntr( false, false) ; SfrCntr.AddCurve( Release( pBound)) ; pSfrCurr.Set( SfrCntr.GetSurf()) ; } // altrimenti sono chiusi else { // creo la regione SurfFlatRegionByContours SfrCntr( false, false) ; SfrCntr.AddCurve( Release( pOffs1)) ; SfrCntr.AddCurve( Release( pOffs2)) ; pSfrCurr.Set( SfrCntr.GetSurf()) ; } if ( IsNull( pSfrCurr)) return false ; // aggiungo alla superficie complessiva if ( pSfr->IsValid()) pSfr->Add( *pSfrCurr) ; else pSfr.Set( Release( pSfrCurr)) ; } // la regione deve essere rivolta verso Z+ if ( pSfr->GetNormVersor().z < 0) pSfr->Invert() ; // aggiungo eventuali loops AddLoopsPreview( pCrv, pSfr) ; // ne recupero i contorni for ( int i = 0 ; i < pSfr->GetLoopCount( 0) ; ++i) { PtrOwner pCrv2( pSfr->GetLoop( 0, i)) ; 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_DOWN_CUT) ; m_pGeomDB->SetMaterial( nC2Id, colCut) ; } // 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_DOWN_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_DOWN_RRCUT) ; m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ; } return true ; } //---------------------------------------------------------------------------- ISurfFlatRegion* WaterJetting::GenerateLeadInPreview( const ICurveComposite* pCompo, const Vector3d& vtN, bool bClosed) { // Creo la superficie PtrOwner pSfr( CreateSurfFlatRegion()) ; if ( IsNull( pSfr)) return nullptr ; double dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ; double dRad = 0.49 * m_TParams.m_dDiam * dSideCoeff ; // non 0.5 per evitare problemi di coincidenza // Recupero punto e direzione iniziali del percorso Point3d ptStart ; pCompo->GetStartPoint( ptStart) ; Vector3d vtStart ; pCompo->GetStartDir( vtStart) ; // Verifico il tipo int nType = GetLeadInType() ; if ( nType == WJET_LI_NONE) { // se nessun attacco e curva chiusa creo segnaposto per indicare punto di inizio if ( bClosed) { pSfr.Set( GetSurfFlatRegionDisk( dRad)) ; if ( ! IsNull( pSfr)) pSfr->Translate( ptStart - ORIG) ; } return Release( pSfr) ; } // Calcolo punto iniziale dell'attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtN, pCompo, ptP1)) return nullptr ; // calcolo la curva di attacco PtrOwner pCrv ; switch ( nType) { case WJET_LI_LINEAR : { PtrOwner pLine( CreateCurveLine()) ; if ( IsNull( pLine) || ! pLine->Set( ptP1, ptStart)) return nullptr ; pCrv.Set( pLine) ; } break ; case WJET_LI_TANGENT : pCrv.Set( GetArc2PVN( ptStart, ptP1, - vtStart, vtN)) ; if ( IsNull( pCrv)) return nullptr ; pCrv->Invert() ; break ; default : return nullptr ; } // calcolo la regione pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), dRad, false, false)) ; if ( IsNull( pSfr)) return nullptr ; // se presente foro di attacco, ne calcolo la regione e la unisco alla precedente if ( m_Params.m_bLiHole && m_Params.m_dLiHoleRad > 10 * EPS_SMALL) { PtrOwner pSfr2( GetSurfFlatRegionDisk( m_Params.m_dLiHoleRad + m_TParams.m_dDiam / 2)) ; if ( ! IsNull( pSfr2)) { pSfr2->Translate( ptP1 - ORIG) ; pSfr->Add( *pSfr2) ; } } return Release( pSfr) ; } //---------------------------------------------------------------------------- ISurfFlatRegion* WaterJetting::GenerateLeadOutPreview( const ICurveComposite* pCompo, const Vector3d& vtN) { // Creo la regione PtrOwner pSfr( CreateSurfFlatRegion()) ; if ( IsNull( pSfr)) return nullptr ; // Assegno il tipo int nType = GetLeadOutType() ; // Recupero i parametri double dTang = m_Params.m_dLoTang ; double dPerp = m_Params.m_dLoPerp ; // se uscita come ingresso if ( nType == WJET_LO_AS_LI) { int nLiType = GetLeadInType() ; switch ( nLiType) { case WJET_LI_LINEAR : nType = WJET_LO_LINEAR ; break ; case WJET_LI_TANGENT : nType = WJET_LO_TANGENT ; break ; default : nType = WJET_LO_NONE ; break ; } dTang = m_Params.m_dLiTang ; dPerp = m_Params.m_dLiPerp ; } if ( nType == WJET_LO_NONE) return Release( pSfr) ; // Senso di rotazione da dir tg a dir esterna bool bCcwRot = ( m_Params.m_nWorkSide == WJET_WS_LEFT) ; // Recupero punto e direzione iniziali del percorso Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ; Vector3d vtEnd ; pCompo->GetEndDir( vtEnd) ; // Calcolo la curva di uscita PtrOwner pCrv ; switch ( nType) { case WJET_LO_LINEAR : { PtrOwner pLine( CreateCurveLine()) ; Vector3d vtPerp = vtEnd ; vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ; Point3d ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ; if ( IsNull( pLine) || ! pLine->Set( ptEnd, ptP1)) return nullptr ; pCrv.Set( pLine) ; } break ; case WJET_LO_TANGENT : { // calcolo punto finale dell'uscita Vector3d vtPerp = vtEnd ; vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ; Point3d ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ; // inserisco uscita pCrv.Set( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ; if ( IsNull( pCrv)) return nullptr ; } break ; default : return nullptr ; } // calcolo la regione double dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ; double dRad = 0.49 * m_TParams.m_dDiam * dSideCoeff ; // non 0.5 per evitare problemi di coincidenza pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), dRad, false, false)) ; return Release( pSfr) ; } //---------------------------------------------------------------------------- bool WaterJetting::AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* pSPV) { // ciclo sulle curve elementari int nMaxInd = pCompo->GetCurveCount() - 1 ; for ( int i = 1 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( i) ; // curva precedente const ICurve* pCrvP = pCompo->GetCurve( i - 1) ; // verifico che tratti abbiano lunghezza sufficiente per gestione angolo double dLenC ; pCrvC->GetLength( dLenC) ; double dLenP ; pCrvP->GetLength( dLenP) ; if ( dLenC < LEN_TOL || dLenP < LEN_TOL) continue ; // angolo tra direzione finale precedente e direzione iniziale corrente Vector3d vtEnd ; pCrvP->GetEndDir( vtEnd) ; Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ; double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ; // se previsto e angolo esterno, si aggiunge l'anello if ( m_Params.m_nExtCornerType == WJET_EC_LOOP && IsExternalAngle( dAng)) { // curva dell'anello PtrOwner pLoop( CreateCurveComposite()) ; if ( IsNull( pLoop)) return false ; // lunghezza tratti lineari e loro punti estremi double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * abs( dAng) * DEGTORAD) ; if ( m_Params.m_dSideAngle > EPS_ANG_SMALL) { double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ; double dExtraLen = dW / tan( 0.5 * ( 180 - abs( dAng)) * DEGTORAD) ; dTgLen += dExtraLen ; } Point3d ptP ; pCrvC->GetStartPoint( ptP) ; Point3d ptPe = ptP + vtEnd * dTgLen ; Point3d ptPs = ptP - vtStart * dTgLen ; // tratto prima dell'anello if ( ! pLoop->AddPoint( ptP) || ! pLoop->AddLine( ptPe)) return false ; // anello if ( ! pLoop->AddArcTg( ptPs)) return false ; // verifico che l'anello non interferisca con la curva di lavoro IntersCurveCurve intAC( *pLoop->GetLastCurve(), *pCompo) ; if ( intAC.GetIntersCount() > 0) continue ; // tratto dopo l'anello if ( ! pLoop->AddLine( ptP)) return false ; // lo porto in antiorario double dArea ; if ( ! pLoop->GetAreaXY( dArea)) return false ; if ( dArea < 0) pLoop->Invert() ; // ne eseguo l'offset double dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ; double Rad = 0.49 * m_TParams.m_dDiam * dSideCoeff ; // non 0.5 per evitare problemi di coincidenza if ( ! pLoop->SimpleOffset( Rad, ICurve::OFF_FILLET)) return false ; // calcolo la regione PtrOwner pSfr ; SurfFlatRegionByContours SfrCntr ; SfrCntr.AddCurve( Release( pLoop)) ; pSfr.Set( SfrCntr.GetSurf()) ; // Unisco le due regioni if ( IsNull( pSfr) || ! pSPV->Add( *pSfr)) return false ; } } return true ; } //---------------------------------------------------------------------------- bool WaterJetting::AdjustPathForInternalAngles( ICurveComposite* pCompo) { // necessario aggiustamento solo se angolo di fianco positivo if ( m_Params.m_dSideAngle < EPS_ANG_SMALL) return true ; // larghezza della lavorazione double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ; // ciclo su tutte le entità int nMaxInd = pCompo->GetCurveCount() - 1 ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( i) ; // dati eventuale entità precedente const ICurve* pCrvP = nullptr ; bool bPrevIntAng = false ; double dPrevAng = 0 ; double dPrevLen = 0 ; if ( i > 0) { // direzione finale precedente pCrvP = pCompo->GetCurve( i - 1) ; Vector3d vtEnd ; pCrvP->GetEndDir( vtEnd) ; // direzione iniziale corrente Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ; // angolo tra le direzioni vtEnd.GetAngleXY( vtStart, dPrevAng) ; // verifica di angolo interno bPrevIntAng = IsInternalAngle( dPrevAng) ; // lunghezza pCrvP->GetLength( dPrevLen) ; } // dati eventuale entità successiva const ICurve* pCrvN = nullptr ; bool bNextIntAng = false ; double dNextAng = 0 ; double dNextLen = 0 ; if ( i < nMaxInd) { // direzione finale corrente Vector3d vtEnd ; pCrvC->GetEndDir( vtEnd) ; // direzione iniziale successiva pCrvN = pCompo->GetCurve( i + 1) ; Vector3d vtStart ; pCrvN->GetStartDir( vtStart) ; // angolo tra le direzioni vtEnd.GetAngleXY( vtStart, dNextAng) ; // se angolo interno bNextIntAng = IsInternalAngle( dNextAng) ; // lunghezza pCrvN->GetLength( dNextLen) ; } // se c'è angolo interno con la precedente if ( bPrevIntAng) { // lunghezza entità double dLen ; pCrvC->GetLength( dLen) ; // verifico lunghezza minima double dSlowLen = dW / tan( ( 180 - abs( dPrevAng)) / 2 * DEGTORAD) ; double dExtraLen = dSlowLen + INTANG_ROT_LEN - dLen ; if ( dExtraLen > 0) { // se entità successiva è in tangenza e abbastanza lunga, allungo la corrente a scapito della successiva if ( abs( dNextAng) < EPS_ANG_SMALL && dNextLen > dExtraLen) { double dU ; Point3d ptP ; if ( pCrvN->GetParamAtLength( dExtraLen, dU) && pCrvN->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP)) pCompo->ModifyJoint( i + 1, ptP) ; } } } // se c'è angolo interno con l'entità successiva if ( bNextIntAng) { // lunghezza entità double dLen ; pCrvC->GetLength( dLen) ; // verifico lunghezza minima double dSlowLen = dW / tan( ( 180 - abs( dNextAng)) / 2 * DEGTORAD) ; double dExtraLen = dSlowLen + INTANG_ROT_LEN - dLen ; if ( dExtraLen > 0) { // se entità precedente è in tangenza e abbastanza lunga, allungo la corrente a scapito della precedente if ( abs( dPrevAng) < EPS_ANG_SMALL && dPrevLen > dExtraLen) { double dU ; Point3d ptP ; if ( pCrvP->GetParamAtLength( dPrevLen - dExtraLen, dU) && pCrvP->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP)) pCompo->ModifyJoint( i, ptP) ; } } } } return true ; } //---------------------------------------------------------------------------- bool WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTool, bool bSplitArcs, double dAddedOverlap) { // numero punti di accelerazione/decelerazione const int ACC_PNT_NUM = 7 ; // lunghezza minima per poter suddividere con punti di accelerazione/decelerazione const double MIN_ACC_LEN = 1.0 ; // recupero distanze di sicurezza double dSafeZ = GetSafeZ() ; // verifico se la curva è chiusa a meno di eventuale dAddedOverlap bool bClosed = ( pCompo->IsClosed() || dAddedOverlap > EPS_SMALL) ; // ciclo sulle curve elementari int nIdxSkip = 0 ; int nMaxInd = pCompo->GetCurveCount() - 1 ; bool bStartSlowFull = false ; for ( int i = 0 ; i <= nMaxInd ; ++ i) { // curva corrente const ICurve* pCrvC = pCompo->GetCurve( i) ; // copio la curva ( è già alla giusta quota) PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; double dLen ; pCurve->GetLength( dLen) ; double dUprev = 0 ; bool bSlowFull = false ; // modalità speciale per angoli interni con rallentamento uniforme su tutta l'entità // se prima entità, approccio e affondo if ( i == 0) { // imposto indice dei punti precedenti la partenza SetIndex( -1 - nIdxSkip) ; // dati inizio entità Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; // determino inizio attacco Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, pCompo, ptP1)) return false ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetToolCorrAuxDir( pCompo, i) ; // aggiungo approccio al punto iniziale if ( ! AddApproach( ptP1, vtTool, dSafeZ, bSplitArcs)) { m_pMchMgr->SetLastError( 3207, "Error in WaterJetting : Approach not computable") ; return false ; } // aggiungo attacco SetFeed( GetActualFeed()) ; SetFlag( 0) ; SetIndex( 0 - nIdxSkip) ; if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) { m_pMchMgr->SetLastError( 3208, "Error in WaterJetting : LeadIn not computable") ; return false ; } m_ptLastProbe = ptStart ; } // altrimenti verifico con l'entità precedente else { // direzione finale precedente const ICurve* pCrvP = pCompo->GetCurve( i - 1) ; Vector3d vtEnd ; pCrvP->GetEndDir( vtEnd) ; double dLenP ; pCrvP->GetLength( dLenP) ; // direzione iniziale corrente Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ; // angolo tra le direzioni double dAng = 0 ; vtEnd.GetAngleXY( vtStart, dAng) ; // se tratto sotto la tolleranza, ignoro la gestione dell'angolo if ( dLen < LEN_TOL || dLenP < LEN_TOL) dAng = 0 ; // Se angolo esterno e richiesto anello esterno if ( IsExternalAngle( dAng) && m_Params.m_nExtCornerType == WJET_EC_LOOP) { // lunghezza tratti lineari double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * abs( dAng) * DEGTORAD) ; if ( m_Params.m_dSideAngle > EPS_ANG_SMALL) { // se inclinazione positiva calcolo di quanto deve uscire per non rovinare lo spigolo double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ; double dExtraLen = dW / tan( 0.5 * ( 180 - abs( dAng)) * DEGTORAD) ; dTgLen += dExtraLen ; } // calcolo punti estremi Point3d ptP ; pCrvC->GetStartPoint( ptP) ; Point3d ptPe = ptP + vtEnd * dTgLen ; Point3d ptPs = ptP - vtStart * dTgLen ; // tratto prima dell'anello SetFeed( GetActualFeed()) ; if ( AddLinearMove( ptPe, bSplitArcs) == GDB_ID_NULL) return false ; // anello bool bLoopOk = true ; PtrOwner pCrvA( GetArc2PVN( ptPe, ptPs, vtEnd, vtTool)) ; if ( ! IsNull( pCrvA) && pCrvA->GetType() == CRV_ARC) { // verifico che l'anello non interferisca con la curva di lavoro IntersCurveCurve intAC( *pCrvA, *pCompo) ; if ( intAC.GetIntersCount() == 0) { // suddivido l'anello in due parti per forzare il passaggio dalla posizione vtTool = Z_AX PtrOwner pCompoArc( ConvertCurveToComposite( Release( ( pCrvA)))) ; if ( IsNull( pCompoArc)) return false ; if ( pCompoArc->AddJoint( 0.5)) { // aggiungo il primo tratto Vector3d vtCorr = CalcCorrDir( pCompoArc, 1) ; SetToolCorrAuxDir( Z_AX, vtCorr) ; if ( AddCurveMove( pCompoArc->GetCurve( 0), bSplitArcs) == GDB_ID_NULL) return false ; // aggiungo secondo tratto CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ; if ( AddCurveMove( pCompoArc->GetCurve( 1), bSplitArcs) == GDB_ID_NULL) return false ; } else { // se non è possibile suddividere anello CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ; if ( AddCurveMove( pCompoArc, bSplitArcs) == GDB_ID_NULL) return false ; } } else bLoopOk = false ; } else bLoopOk = false ; // se anello non possibile if ( ! bLoopOk) { CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ; if ( AddLinearMove( ptPs, bSplitArcs) == GDB_ID_NULL) return false ; } // tratto dopo l'anello if ( AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL) return false ; } // se angolo esterno e richiesto rallentamento esterno, eseguo accelerazione else if ( IsExternalAngle( dAng) && m_Params.m_nExtCornerType == WJET_EC_SLOW) { // lunghezza entità double dLen ; pCrvC->GetLength( dLen) ; // lunghezza di accelerazione double dAccLen = min( m_Params.m_dCornerSlowLen, dLen / 2 - EXTRA_ACC_LEN) ; // Feed ridotta double dMinFeed = GetActualReducedFeed() ; // ciclo sui punti di accelerazione int nAccPntNum = dAccLen > MIN_ACC_LEN - EPS_SMALL ? ACC_PNT_NUM : 1 ; for ( int j = 1 ; j <= nAccPntNum ; ++ j) { double dCoeff = j / double( nAccPntNum) ; double dU = dUprev ; pCrvC->GetParamAtLength( dCoeff * dAccLen, dU) ; if ( abs( dU - dUprev) < EPS_SMALL) continue ; PtrOwner pCrvT( pCrvC->Clone()) ; if ( IsNull( pCrvT) || ! pCrvT->TrimStartEndAtParam( dUprev, dU)) return false ; CalcAndSetToolCorrAuxDir( pCompo, i + dU) ; SetFeed( ( 1 - dCoeff) * dMinFeed + dCoeff * GetActualFeed()) ; if ( AddCurveMove( pCrvT, bSplitArcs) == GDB_ID_NULL) return false ; dUprev = dU ; } } // se angolo interno, spezzo per interpolazione direzione utensile e se necessario aggiungo accelerazione else if ( IsInternalAngle( dAng)) { // flag di rallentamento bool bReduceFeed = ( m_Params.m_nIntCornerType == WJET_IC_SLOW || m_Params.m_nIntCornerType == WJET_IC_SLOW_FULL) ; // lunghezza entità double dLen ; pCrvC->GetLength( dLen) ; double dFreeLen = dLen ; // lunghezza di accelerazione double dAccLen = 0 ; if ( m_Params.m_nIntCornerType == WJET_IC_SLOW_FULL) { // se ultima entità if ( i == nMaxInd) { // sfrutto tutta la lunghezza a disposizione dAccLen = dFreeLen - EXTRA_ACC_LEN ; // verifico che la modalità WJET_IC_SLOW_FULL sia fattibile bSlowFull = ( ! bClosed || bStartSlowFull) ; } else { // devo verificare se anche angolo next è interno, altrimenti applico la modalità WJET_IC_SLOW const ICurve* pCrvN = pCompo->GetCurve( i + 1) ; Vector3d vtEndC ; pCurve->GetEndDir( vtEndC) ; Vector3d vtStartN ; pCrvN->GetStartDir( vtStartN) ; double dAngN ; vtEndC.GetAngleXY( vtStartN, dAngN) ; if ( IsInternalAngle( dAngN)) { bSlowFull = true ; dAccLen = dFreeLen / 2 ; } } } if ( ! bSlowFull) { double dMinLen = dFreeLen / 2 - EXTRA_ACC_LEN ; if ( dMinLen < EPS_SMALL && abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) dMinLen = dFreeLen / 2 ; dAccLen = min( dMinLen, ( bReduceFeed ? m_Params.m_dCornerSlowLen : INTANG_ROT_LEN)) ; if ( m_Params.m_dSideAngle > 0) { // verifico sia rispettata la lunghezza minima per non rovinare l'angolo double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ; double dSlowLen = dW / tan( ( 180 - abs( dAng)) / 2 * DEGTORAD) ; if ( dSlowLen > dFreeLen + EPS_SMALL) { m_pMchMgr->SetLastError( 3204, "Error in WaterJetting : entity too small near inside corner") ; return false ; } dAccLen = max( dAccLen, dSlowLen) ; } } // Feed ridotta double dMinFeed = ( bReduceFeed ? GetActualReducedFeed() : GetActualFeed()) ; // Direzioni utensile nell'angolo e finale double dUsta = 0 ; double dUend ; pCrvC->GetParamAtLength( dAccLen, dUend) ; Vector3d vtTp = CalcToolDir( pCompo, i + dUsta) ; Vector3d vtTn = CalcToolDir( pCompo, i + dUend) ; int nAccPntNum = dAccLen > MIN_ACC_LEN - EPS_SMALL ? ACC_PNT_NUM : 1 ; // ciclo sui punti di accelerazione for ( int j = 1 ; j <= nAccPntNum ; ++ j) { double dCoeff = j / double( nAccPntNum) ; double dU = dUprev ; pCrvC->GetParamAtLength( dCoeff * dAccLen, dU) ; if ( abs( dUprev - dU) < EPS_SMALL) continue ; PtrOwner pCrvT( pCrvC->Clone()) ; if ( IsNull( pCrvT) || ! pCrvT->TrimStartEndAtParam( dUprev, dU)) return false ; Vector3d vtTool = ( 1 - dCoeff) * vtTp + dCoeff * vtTn ; vtTool.Normalize() ; Vector3d vtCorr = CalcCorrDir( pCompo, i + dU) ; SetToolCorrAuxDir( vtTool, vtCorr) ; SetFeed( ( 1 - dCoeff) * dMinFeed + dCoeff * GetActualFeed()) ; if ( AddCurveMove( pCrvT, bSplitArcs) == GDB_ID_NULL) return false ; dUprev = dU ; } } } // se non è l'ultima entità, verifico con l'entità successiva double dNextFeed = GetActualFeed() ; if ( i < nMaxInd) { // controlli per indice del punto di arrivo Point3d ptP3 ; pCrvC->GetEndPoint( ptP3) ; if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist) SetIndex( i + 1 - nIdxSkip) ; // direzione finale corrente Vector3d vtEnd ; pCrvC->GetEndDir( vtEnd) ; // direzione iniziale successiva const ICurve* pCrvN = pCompo->GetCurve( i + 1) ; Vector3d vtStart ; pCrvN->GetStartDir( vtStart) ; double dLenN ; pCrvN->GetLength( dLenN) ; // angolo tra le direzioni double dAng = 0 ; vtEnd.GetAngleXY( vtStart, dAng) ; // se tratto sotto la tolleranza, ignoro la gestione dell'angolo if ( dLen < LEN_TOL || dLenN < LEN_TOL) dAng = 0 ; // se angolo esterno e richiesto rallentamento esterno, aggiungo decelerazione if ( IsExternalAngle( dAng) && m_Params.m_nExtCornerType == WJET_EC_SLOW) { // lunghezza entità double dLen ; pCrvC->GetLength( dLen) ; // lunghezza di decelerazione double dAccLen = min( m_Params.m_dCornerSlowLen, dLen / 2 - EXTRA_ACC_LEN) ; // Feed ridotta double dMinFeed = GetActualReducedFeed() ; // ciclo sui punti di decelerazione int nAccPntNum = dAccLen > MIN_ACC_LEN - EPS_SMALL ? ACC_PNT_NUM : 1 ; for ( int j = 0 ; j < nAccPntNum ; ++ j) { double dCoeff = j / double( nAccPntNum) ; double dU = dUprev ; pCrvC->GetParamAtLength( dLen - ( 1 - dCoeff) * dAccLen, dU) ; if ( abs( dUprev - dU) < EPS_SMALL) continue ; PtrOwner pCrvT( pCrvC->Clone()) ; if ( IsNull( pCrvT) || ! pCrvT->TrimStartEndAtParam( dUprev, dU)) return false ; CalcAndSetToolCorrAuxDir( pCompo, i + dU) ; SetFeed( ( 1 - dCoeff) * GetActualFeed() + dCoeff * dMinFeed) ; if ( AddCurveMove( pCrvT, bSplitArcs) == GDB_ID_NULL) return false ; dUprev = dU ; } dNextFeed = dMinFeed ; } // se angolo interno, spezzo per interpolazione direzione utensile e se necessario aggiungo decelerazione else if ( IsInternalAngle( dAng)) { // flag di rallentamento bool bReduceFeed = ( m_Params.m_nIntCornerType == WJET_IC_SLOW || m_Params.m_nIntCornerType == WJET_IC_SLOW_FULL) ; // lunghezza entità double dLen ; pCrvC->GetLength( dLen) ; double dFreeLen = dLen * ( 1 - dUprev) ; // lunghezza di decelerazione double dAccLen = 0 ; // se prima entità e modalità WJET_IC_SLOW_FULL verifico se davvero applicabile controllando angolo con ultima entità if ( i == 0 && m_Params.m_nIntCornerType == WJET_IC_SLOW_FULL) { bSlowFull = true ; if ( bClosed) { // creo una copia della curva senza l'overlap aggiunto PtrOwner pCrvTmp( pCompo->Clone()) ; double dLen ; pCrvTmp->GetLength( dLen) ; if ( IsNull( pCrvTmp) || ! pCrvTmp->TrimEndAtLen( dLen - dAddedOverlap)) return false ; // verifico che anche angolo sullo start della curva sia di tipo prev const ICurve* pCrvLast = pCrvTmp->GetLastCurve() ; Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; Vector3d vtEnd ; pCrvLast->GetEndDir( vtEnd) ; if ( AreSameVectorApprox( vtStart, vtEnd)) { // se curve in tangenza controllo angolo tra l'ultima e la penultima curva int nCrvNbr = pCrvTmp->GetCurveCount() ; const ICurve* pCrvP = pCrvTmp->GetCurve( nCrvNbr - 2) ; pCrvLast->GetStartDir( vtStart) ; pCrvP->GetEndDir( vtEnd) ; } // se angolo precedente non è interno il tratto non va realizzato in modalità full double dAngPrev ; vtEnd.GetAngleXY( vtStart, dAngPrev) ; if ( ! IsInternalAngle( dAngPrev)) bSlowFull = false ; } // salvo il valore per l'ultima entità bStartSlowFull = bSlowFull ; } if ( bSlowFull) // sfrutto tutta la lunghezza a disposizone dAccLen = dFreeLen ; else { double dMinLen = dFreeLen - EXTRA_ACC_LEN ; if ( dMinLen < EPS_SMALL && abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) dMinLen = dFreeLen ; dAccLen = min( dMinLen, ( bReduceFeed ? m_Params.m_dCornerSlowLen : INTANG_ROT_LEN)) ; if ( m_Params.m_dSideAngle > 0) { double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ; double dSlowLen = dW / tan( ( 180 - abs( dAng)) / 2 * DEGTORAD) ; if ( dSlowLen > dFreeLen + EPS_SMALL) { m_pMchMgr->SetLastError( 3204, "Error in WaterJetting : entity too small near inside corner") ; return false ; } dAccLen = max( dAccLen, dSlowLen) ; } } // Feed ridotta double dMinFeed = ( bReduceFeed ? GetActualReducedFeed() : GetActualFeed()) ; // Direzioni utensile iniziale e nell'angolo double dUsta ; pCrvC->GetParamAtLength( dLen - dAccLen, dUsta) ; double dUend = 1 ; Vector3d vtTp = CalcToolDir( pCompo, i + dUsta) ; Vector3d vtTn = CalcToolDir( pCompo, i + dUend) ; int nAccPntNum = dAccLen > MIN_ACC_LEN - EPS_SMALL ? ACC_PNT_NUM : 1 ; // ciclo sui punti di decelerazione for ( int j = 0 ; j < nAccPntNum ; ++ j) { double dCoeff = j / double( nAccPntNum) ; double dU = dUprev ; pCrvC->GetParamAtLength( dLen - ( 1 - dCoeff) * dAccLen, dU) ; if ( abs( dUprev - dU) < EPS_SMALL) continue ; PtrOwner pCrvT( pCrvC->Clone()) ; if ( IsNull( pCrvT) || ! pCrvT->TrimStartEndAtParam( dUprev, dU)) return false ; Vector3d vtTool = ( 1 - dCoeff) * vtTp + dCoeff * vtTn ; vtTool.Normalize() ; Vector3d vtCorr = CalcCorrDir( pCompo, i + dU) ; SetToolCorrAuxDir( vtTool, vtCorr) ; SetFeed( ( 1 - dCoeff) * GetActualFeed() + dCoeff * dMinFeed) ; if ( AddCurveMove( pCrvT, bSplitArcs) == GDB_ID_NULL) return false ; dUprev = dU ; } dNextFeed = dMinFeed ; } // se successivo non è angolo esterno ad anello imposto versore correzione e ausiliario del punto di arrivo if ( ! IsExternalAngle( dAng) || m_Params.m_nExtCornerType != WJET_EC_LOOP) CalcAndSetToolCorrAuxDir( pCompo, i + 1) ; } else { // se ultima entità imposto versore correzione e ausiliario del punto finale CalcAndSetToolCorrAuxDir( pCompo, i + 1) ; } // elaborazioni sulla curva corrente if ( pCurve->GetType() == CRV_LINE) { ICurveLine* pLine = GetCurveLine( pCurve) ; Point3d ptP3 = pLine->GetEnd() ; SetFeed( dNextFeed) ; // controlli per indice del punto di arrivo if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist) { SetIndex( i + 1 - nIdxSkip) ; m_ptLastProbe = ptP3 ; } else ++ nIdxSkip ; if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL) return false ; } else if ( pCurve->GetType() == CRV_ARC) { SetFeed( dNextFeed) ; // controlli per indice del punto di arrivo Point3d ptP3 ; pCurve->GetEndPoint( ptP3) ; if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist) { SetIndex( i + 1 - nIdxSkip) ; m_ptLastProbe = ptP3 ; } else ++ nIdxSkip ; PtrOwner pCrvT( pCrvC->Clone()) ; if ( IsNull( pCrvT) || ! pCrvT->TrimStartAtParam( dUprev)) return false ; if ( AddCurveMove( pCrvT, bSplitArcs) == GDB_ID_NULL) return false ; } // se ultima entità, uscita e retrazione if ( i == nMaxInd) { // dati fine entità Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ; Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ; // aggiungo uscita Point3d ptP1 ; SetFeed( GetActualFeed()) ; if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 3209, "Error in WaterJetting : LeadOut not computable") ; return false ; } // aggiungo retrazione SetFlag( 203) ; if ( ! AddRetract( ptP1, vtTool, dSafeZ, bSplitArcs)) { m_pMchMgr->SetLastError( 3210, "Error in WaterJetting : Retract not computable") ; return false ; } } } return true ; } //---------------------------------------------------------------------------- class LeadIOStatus { public : LeadIOStatus( WaterJetting* pWJ) { m_pWJ = pWJ ; m_dLiPerp = m_pWJ->m_Params.m_dLiPerp ; m_dLoPerp = m_pWJ->m_Params.m_dLoPerp ; } ~LeadIOStatus( void) { Restore() ; } void Restore( void) { m_pWJ->m_Params.m_dLiPerp = m_dLiPerp ; m_pWJ->m_Params.m_dLoPerp = m_dLoPerp ; } private : WaterJetting* m_pWJ ; double m_dLiPerp ; double m_dLoPerp ; } ; //---------------------------------------------------------------------------- bool WaterJetting::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, bool bSplit) { SetFlag( 1) ; // 1 -> punto sopra inizio Point3d ptP1 = ptP + vtTool * dSafeZ ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; // affondo al punto iniziale SetFlag( ( m_Params.m_bLiHole ? 201 : 202)) ; if ( AddRapidMove( ptP, bSplit) == GDB_ID_NULL) return false ; return true ; } //---------------------------------------------------------------------------- bool WaterJetting::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, bool bSplit) { // Risalgo in rapido alla quota di sicurezza Point3d ptP4 = ptP + vtTool * dSafeZ ; if ( AddRapidMove( ptP4, bSplit) == GDB_ID_NULL) return false ; return true ; } //---------------------------------------------------------------------------- int WaterJetting::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 WJET_LI_NONE ; return m_Params.m_nLeadInType ; } //---------------------------------------------------------------------------- bool WaterJetting::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, 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 ; // senso di rotazione da dir tg a dir esterna bool bCcwRot = ( m_Params.m_nWorkSide == WJET_WS_LEFT) ; // Calcolo punto iniziale switch ( nType) { case WJET_LI_NONE : ptP1 = ptStart ; return true ; case WJET_LI_LINEAR : case WJET_LI_TANGENT : { Vector3d vtPerp = vtStart ; vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ; ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp ; return true ; } default : return false ; } } //---------------------------------------------------------------------------- bool WaterJetting::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, bool bSplitArcs) { // Assegno il tipo int nType = GetLeadInType() ; // Eseguo a seconda del tipo switch ( nType) { case WJET_LI_NONE : return true ; case WJET_LI_LINEAR : return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ; case WJET_LI_TANGENT : { PtrOwner pCrv( GetArc2PVN( ptStart, ptP1, - vtStart, vtN)) ; if ( IsNull( pCrv)) return false ; pCrv->Invert() ; return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ; } default : return false ; } } //---------------------------------------------------------------------------- int WaterJetting::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 != WJET_LO_AS_LI) return WJET_LO_NONE ; return m_Params.m_nLeadOutType ; } //---------------------------------------------------------------------------- bool WaterJetting::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, bool bSplitArcs, Point3d& ptP1) { // assegno i parametri int nType = GetLeadOutType() ; double dTang = m_Params.m_dLoTang ; double dPerp = m_Params.m_dLoPerp ; // se uscita come ingresso if ( nType == WJET_LO_AS_LI) { int nLiType = GetLeadInType() ; switch ( nLiType) { case WJET_LI_LINEAR : nType = WJET_LO_LINEAR ; break ; case WJET_LI_TANGENT : nType = WJET_LO_TANGENT ; break ; default : nType = WJET_LO_NONE ; break ; } dTang = m_Params.m_dLiTang ; dPerp = m_Params.m_dLiPerp ; } // senso di rotazione da dir tg a dir esterna bool bCcwRot = ( m_Params.m_nWorkSide == WJET_WS_LEFT) ; // eseguo a seconda del tipo switch ( nType) { case WJET_LO_NONE : ptP1 = ptEnd ; return true ; case WJET_LO_LINEAR : { Vector3d vtPerp = vtEnd ; vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ; ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ; return ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ; } case WJET_LO_TANGENT : { // calcolo punto finale dell'uscita Vector3d vtPerp = vtEnd ; vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ; ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ; // inserisco uscita PtrOwner pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ; if ( IsNull( pCrv)) return false ; return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ; } default : return false ; } } //---------------------------------------------------------------------------- double WaterJetting::GetRadiusForStartEndElevation( void) const { const double DELTA_ELEV_RAD = 20.0 ; double dDeltaRad = DELTA_ELEV_RAD + max( max( m_Params.m_dStartAddLen, m_Params.m_dEndAddLen), 0.0) ; return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; } //---------------------------------------------------------------------------- bool WaterJetting::SetToolCorrAuxDir( const Vector3d& vtTool, const Vector3d& vtCorr) { // imposto il versore fresa SetToolDir( vtTool) ; // imposto versore correzione SetCorrDir( vtCorr) ; // 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 ; } //---------------------------------------------------------------------------- bool WaterJetting::CalcAndSetToolCorrAuxDir( const ICurveComposite* pCompo, double dU) { // verifico curva if ( pCompo == nullptr) return false ; // se utensile centrato, direzione di correzione nulla e direzione utensile sempre Z+ if ( m_Params.m_nWorkSide == WJET_WS_CENTER) { SetToolDir( Z_AX) ; return true ; } // calcolo del versore fresa Vector3d vtTool = CalcToolDir( pCompo, dU) ; // calcolo del versore correzione Vector3d vtCorr = CalcCorrDir( pCompo, dU) ; // imposto versori fresa e correzione return SetToolCorrAuxDir( vtTool, vtCorr) ; } //---------------------------------------------------------------------------- Vector3d WaterJetting::CalcToolDir( const ICurveComposite* pCompo, double dU) { // verifico curva if ( pCompo == nullptr) return V_NULL ; // valore standard della direzione utensile Vector3d vtTool = Z_AX ; // se utensile centrato, direzione utensile sempre Z+ if ( m_Params.m_nWorkSide == WJET_WS_CENTER) return vtTool ; // se angolo di fianco nullo, direzione utensile sempre Z+ if ( abs( m_Params.m_dSideAngle) < EPS_ANG_SMALL) return vtTool ; // angolo di rotazione attorno a tg bool bCcwRot = ( m_Params.m_nWorkSide == WJET_WS_LEFT) ; double dCaRot = m_Params.m_dSideAngle * ( bCcwRot ? 1 : -1) ; // 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 vtT ; pCompo->GetPointTang( dU, ICurve::FROM_PLUS, ptP, vtT) ; vtTool.Rotate( vtT, dCaRot) ; return vtTool ; } // se fine else if ( dU > dUe - EPS_ZERO) { // recupero la tangente prima Point3d ptP ; Vector3d vtT ; pCompo->GetPointTang( dU, ICurve::FROM_MINUS, ptP, vtT) ; vtTool.Rotate( vtT, dCaRot) ; return vtTool ; } // 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)) { vtTool.Rotate( vtT1, dCaRot) ; return vtTool ; } // se sono opposte else if ( AreOppositeVectorApprox( vtT1, vtT2)) { return vtTool ; } // altrimenti else { Vector3d vtTool1 = Z_AX ; vtTool1.Rotate( vtT1, dCaRot) ; Vector3d vtTool2 = Z_AX ; vtTool2.Rotate( vtT2, dCaRot) ; vtTool = ( vtTool1 ^ vtT1) ^ ( vtTool2 ^ vtT2) ; vtTool.Normalize() ; if ( vtTool * vtTool1 < 0) vtTool.Invert() ; return vtTool ; } } } //---------------------------------------------------------------------------- Vector3d WaterJetting::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 == WJET_WS_CENTER) return V_NULL ; // angolo di rotazione da tg a versore corr/aux bool bCcwRot = (m_Params.m_nWorkSide == WJET_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( Z_AX, 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( Z_AX, 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( Z_AX, 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( Z_AX, dCaRot) ; return vtN ; } } } //---------------------------------------------------------------------------- bool WaterJetting::CalcOffset( ICurveComposite* pCompo, double dSignOffs) { // determino opzioni di offset int nFlag = ICurve::OFF_EXTEND ; if ( pCompo->IsClosed()) { Vector3d vtStart ; pCompo->GetStartDir( vtStart) ; Vector3d vtEnd ; pCompo->GetEndDir( vtEnd) ; if ( ! AreSameVectorEpsilon( vtStart, vtEnd, sin( 5 * DEGTORAD))) { // se spigolo forzo apertura solo se è loop esterno double dArea = 0 ; pCompo->GetAreaXY( dArea) ; if ( ( dArea > 0 && m_Params.m_nWorkSide == WJET_WS_RIGHT) || ( dArea < 0 && m_Params.m_nWorkSide == WJET_WS_LEFT)) nFlag |= ICurve::OFF_FORCE_OPEN ; } } // eseguo offset semplice constexpr double MAX_ANG_EXT = 135 ; if ( pCompo->SimpleOffset( dSignOffs, nFlag, MAX_ANG_EXT)) return true ; // se curva piatta, provo con offset avanzato bool bOk = false ; Plane3d plPlane ; if ( pCompo->IsFlat( plPlane, true, 100 * EPS_SMALL)) { OffsetCurve OffsCrv ; if ( OffsCrv.Make( pCompo, dSignOffs, nFlag)) { ICurve* pOffs = OffsCrv.GetLongerCurve() ; if ( pOffs != nullptr) { Point3d ptStart ; pCompo->GetStartPoint( ptStart) ; Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ; pCompo->Clear() ; pCompo->AddCurve( pOffs) ; // ripristino estrusione della curva compo ( rimossa dal Clear) pCompo->SetExtrusion( vtExtr) ; // ripristino punto iniziale double dPar ; int nFlagDist ; if ( DistPointCurve( ptStart, *pCompo).GetParamAtMinDistPoint( 0, dPar, nFlagDist)) pCompo->ChangeStartPoint( dPar) ; bOk = true ; } } } return bOk ; } //---------------------------------------------------------------------------- // Valore limite angolo per corner const double ANG_CORNER = 10 ; //---------------------------------------------------------------------------- bool WaterJetting::IsExternalAngle( double dAng) { return ( ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) || ( dAng < -ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) ; } //---------------------------------------------------------------------------- bool WaterJetting::IsInternalAngle( double dAng) { return ( ( dAng <- ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) || ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) ; } //---------------------------------------------------------------------------- bool WaterJetting::VerifyMaxLenCurves( ICurveComposite* pCompo, double dMaxLen) { // verifiche sulla lunghezza delle curve int nMaxInd = pCompo->GetCurveCount() - 1 ; for ( int i = 0 ; i <= nMaxInd ; ) { // se lunghezza oltre il limite, la divido a metà const ICurve* pCrv = GetCurve( pCompo->GetCurve( i)) ; double dLen ; if ( pCrv != nullptr && pCrv->GetLength( dLen) && dLen > dMaxLen) { int nParts = int( ceil( dLen / dMaxLen)) ; for ( int j = 0 ; j < nParts - 1 ; ++ j) { double dCoeff = 1. / ( nParts - j) ; pCompo->AddJoint( i + j + dCoeff) ; ++ nMaxInd ; } } else ++ i ; } return true ; }