//---------------------------------------------------------------------------- // EgalTech 2015-2016 //---------------------------------------------------------------------------- // File : SawFinishing.cpp Data : 05.04.16 Versione : 1.6o4 // Contenuto : Implementazione gestione finitura superficie con lama. // // Note : Questa lavorazione è sempre espressa nel riferimento globale. // // Modifiche : 05.04.16 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "MachMgr.h" #include "DllMain.h" #include "SawFinishing.h" #include "OperationConst.h" #include "/EgtDev/Include/EXeCmdLogOff.h" #include "/EgtDev/Include/EXeConst.h" #include "/EgtDev/Include/EGkCurveLine.h" #include "/EgtDev/Include/EGkCurveArc.h" #include "/EgtDev/Include/EGkCurveComposite.h" #include "/EgtDev/Include/EgkOffsetCurve.h" #include "/EgtDev/Include/EgkOffsetCurveOnX.h" #include "/EgtDev/Include/EGkSfrCreate.h" #include "/EgtDev/Include/EGkIntervals.h" #include "/EgtDev/Include/EGkUserObjFactory.h" #include "/EgtDev/Include/EGnStringKeyVal.h" #include "/EgtDev/Include/EgtPointerOwner.h" // per far dimenticare macro di WinUser.h #undef GetClassName using namespace std ; //------------------------------ Errors -------------------------------------- // 2701 = "Error in SawFinishing : UpdateToolData failed" // 2702 = "Error in SawFinishing : Empty RawBox" // 2703 = "Error in SawFinishing : Depth not computable" // 2704 = "Error in SawFinishing : CalculateToolAndCorrVersors" // 2705 = "Error in SawFinishing : ApproxWithLines" // 2706 = "Error in SawFinishing : Guide Line not along X or Y" // 2707 = "Error in SawFinishing : GetElevation" // 2708 = "Error in SawFinishing : CalculateAlongToolPath failed" // 2709 = "Error in SawFinishing : CalculateAcrossToolPath failed" // 2710 = "Error in SawFinishing : axes values not calculable" // 2711 = "Error in SawFinishing : outstroke xx" // 2712 = "Error in SawFinishing : link movements not calculable" // 2713 = "Error in SawFinishing : link outstroke xx" // 2714 = "Error in SawFinishing : post apply not calculable" //---------------------------------------------------------------------------- const std::string MCH_SECTION = "Sect" ; const std::string MCH_GUIDE = "Guide" ; enum nCrvClass { CCL_SMALL = 0, CCL_VERT = 1, CCL_FLAT = 2, CCL_FALL = 3, CCL_RISE = 4 }; //---------------------------------------------------------------------------- USEROBJ_REGISTER( GetOperationClass( OPER_SAWFINISHING), SawFinishing) ; //---------------------------------------------------------------------------- const string& SawFinishing::GetClassName( void) const { return USEROBJ_GETNAME( SawFinishing) ; } //---------------------------------------------------------------------------- SawFinishing* SawFinishing::Clone( void) const { // alloco oggetto SawFinishing* pSaw = new(nothrow) SawFinishing ; // eseguo copia dei dati if ( pSaw != nullptr) { try { pSaw->m_Params = m_Params ; pSaw->m_TParams = m_TParams ; } catch( ...) { delete pSaw ; return nullptr ; } } // ritorno l'oggetto return pSaw ; } //---------------------------------------------------------------------------- bool SawFinishing::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_nCuts) + szNewLine ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::Save( int nBaseId, STRVECTOR& vString) const { try { int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 2 ; vString.insert( vString.begin(), nSize, "") ; int k = - 1 ; if ( ! SetVal( KEY_IDS, m_vId, vString[++k])) return false ; for ( int i = 0 ; i < m_Params.GetSize() ; ++ i) vString[++k] = m_Params.ToString( i) ; for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) vString[++k] = m_TParams.ToString( i) ; if ( ! SetVal( KEY_PHASE, m_nPhase, vString[++k])) return false ; if ( ! SetVal( KEY_NUM, m_nCuts, vString[++k])) return false ; } catch( ...) { return false ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::Load( const STRVECTOR& vString, int nBaseGdbId) { int nSize = int( vString.size()) ; // lista identificativi geometrie da lavorare int k = - 1 ; if ( k >= nSize - 1 || ! GetVal( vString[++k], KEY_IDS, m_vId)) return false ; for ( auto& Sel : m_vId) Sel.nId += nBaseGdbId ; // parametri lavorazione for ( int i = 0 ; i < m_Params.GetSize() ; ++ i) { int nKey ; if ( k >= nSize - 1 || ! m_Params.FromString( vString[++k], nKey) || nKey != i) { if ( m_Params.IsOptional( i)) -- k ; else return false ; } } // parametri utensile for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) { int nKey ; if ( k >= nSize - 1 || ! m_TParams.FromString( vString[++k], nKey) || nKey != i) return false ; } // parametri di stato while ( k < nSize - 1) { // separo chiave da valore string sKey, sVal ; SplitFirst( vString[++k], "=", sKey, sVal) ; // leggo if ( sKey == KEY_PHASE){ if ( ! FromString( sVal, m_nPhase)) return false ; } else if ( sKey == KEY_NUM) { if ( ! FromString( sVal, m_nCuts)) return false ; } } return true ; } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- SawFinishing::SawFinishing( void) { m_Params.m_sName = "*" ; m_Params.m_sToolName = "*" ; m_TParams.m_sName = "*" ; m_TParams.m_sHead = "*" ; m_nCuts = 0 ; } //---------------------------------------------------------------------------- bool SawFinishing::Prepare( const string& sSawName) { // verifico il gestore lavorazioni if ( m_pMchMgr == nullptr) return false ; // recupero il gestore DB utensili della macchina corrente ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ; if ( pTMgr == nullptr) return false ; // recupero il gestore DB lavorazioni della macchina corrente MachiningsMgr* pMMgr = m_pMchMgr->GetCurrMachiningsMgr() ; if ( pMMgr == nullptr) return false ; // ricerca della lavorazione di libreria con il nome indicato const SawFinishingData* pDdata = GetSawFinishingData( pMMgr->GetMachining( sSawName)) ; if ( pDdata == nullptr) return false ; m_Params = *pDdata ; // ricerca dell'utensile usato dalla lavorazione const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ; if ( pTdata == nullptr) return false ; m_TParams = *pTdata ; m_Params.m_sToolName = m_TParams.m_sName ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::SetParam( int nType, bool bVal) { switch ( nType) { case MPA_INVERT : m_Params.m_bInvert = bVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawFinishing::SetParam( int nType, int nVal) { switch ( nType) { case MPA_HEADSIDE : if ( ! m_Params.VerifyHeadSide( nVal)) return false ; m_Params.m_nHeadSide = nVal ; return true ; case MPA_STEPTYPE : if ( ! m_Params.VerifyStepType( nVal)) return false ; m_Params.m_nStepType = nVal ; return true ; case MPA_SUBTYPE : if ( ! m_Params.VerifySubType( nVal)) return false ; m_Params.m_nSubType = nVal ; return true ; case MPA_LEADLINKTYPE : if ( ! m_Params.VerifyLeadLinkType( nVal)) return false ; m_Params.m_nLeadLinkType = nVal ; return true ; case MPA_SCC : if ( ! m_Params.VerifySolCh( nVal)) return false ; m_Params.m_nSolCh = nVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawFinishing::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) m_Params.m_dSpeed = 0 ; else m_Params.m_dSpeed = dVal ; return true ; case MPA_FEED : if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR) m_Params.m_dFeed = 0 ; else m_Params.m_dFeed = dVal ; return true ; case MPA_STARTFEED : if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR) m_Params.m_dStartFeed = 0 ; else m_Params.m_dStartFeed = dVal ; return true ; case MPA_ENDFEED : if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR) m_Params.m_dEndFeed = 0 ; else m_Params.m_dEndFeed = dVal ; return true ; case MPA_TIPFEED : if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR) m_Params.m_dTipFeed = 0 ; else m_Params.m_dTipFeed = dVal ; return true ; case MPA_VERTFEED : if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR) m_Params.m_dVertFeed = 0 ; else m_Params.m_dVertFeed = dVal ; return true ; case MPA_OFFSR : if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR) m_Params.m_dOffsR = UNKNOWN_PAR ; else m_Params.m_dOffsR = dVal ; return true ; case MPA_DEPTH : m_Params.m_sDepth = ToString( dVal) ; return true ; case MPA_STARTPOS : m_Params.m_dStartPos = dVal ; return true ; case MPA_SIDESTEP : m_Params.m_dSideStep = dVal ; return true ; case MPA_STEP : m_Params.m_dStep = dVal ; return true ; case MPA_APPROX : m_Params.m_dApprox = dVal ; return true ; case MPA_STARTADDLEN : m_Params.m_dStartAddLen = dVal ; return true ; case MPA_ENDADDLEN : m_Params.m_dEndAddLen = dVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawFinishing::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 ; m_Params.m_sToolName = sVal ; m_Params.m_ToolUuid = pTdata->m_Uuid ; m_TParams = *pTdata ; } return true ; case MPA_DEPTH_STR : m_Params.m_sDepth = sVal ; return true ; case MPA_SYSNOTES : m_Params.m_sSysNotes = sVal ; break ; case MPA_USERNOTES : m_Params.m_sUserNotes = sVal ; break ; case MPA_INITANGS : m_Params.m_sInitAngs = sVal ; break ; case MPA_BLOCKEDAXIS : m_Params.m_sBlockedAxis = sVal ; break ; } return false ; } //---------------------------------------------------------------------------- bool SawFinishing::SetGeometry( const SELVECTOR& vIds) { // verifico validità gestore DB geometrico if ( m_pGeomDB == nullptr) return false ; // reset della geometria corrente m_vId.clear() ; // verifico che gli identificativi rappresentino delle entità ammissibili for ( const auto& Id : vIds) { // test sull'entità int nSubs ; if ( ! VerifyGeometry( Id, nSubs)) { string sOut = "Entity " + ToString( Id) + " skipped by Sawing" ; LOG_INFO( GetEMkLogger(), sOut.c_str()) ; continue ; } // posso aggiungere alla lista m_vId.emplace_back( Id) ; } return ( ! m_vId.empty()) ; } //---------------------------------------------------------------------------- bool SawFinishing::Preview( bool bRecalc) { // non esiste preview, si fa apply return Apply( bRecalc, false) ; } //---------------------------------------------------------------------------- bool SawFinishing::Apply( bool bRecalc, bool bPostApply) { // reset numero tagli nella lavorazione m_nCuts = 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) ; // se non c'è, lo aggiungo if ( nAuxId == GDB_ID_NULL) { nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; if ( nAuxId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nAuxId, MCH_AUX) ; m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ; bRecalc = true ; } // altrimenti, se chiesto ricalcolo, lo svuoto else if ( bRecalc) { m_pGeomDB->EmptyGroup( nAuxId) ; } // aggiorno dati geometrici dell'utensile if ( ! UpdateToolData()) { m_pMchMgr->SetLastError( 2701, "Error in SawFinishing : UpdateToolData failed") ; return false ; } // se necessario, preparo geometria e la inserisco sotto la geometria ausiliaria if ( bRecalc && ! AdjustGeometry( nAuxId)) return false ; // recupero gruppo per geometria di lavorazione (Cutter Location) int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ; // se non c'è, lo aggiungo if ( nClId == GDB_ID_NULL) { nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ; if ( nClId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nClId, MCH_CL) ; } // altrimenti lo svuoto else m_pGeomDB->EmptyGroup( nClId) ; // calcolo le passate if ( m_Params.m_nSubType == SAWFIN_SUB_ALONG) { if ( ! CalculateAlongToolPath( nAuxId, nClId)) { m_pMchMgr->SetLastError( 2708, "Error in SawFinishing : CalculateAlongToolPath failed") ; return false ; } } else if ( m_Params.m_nSubType == SAWFIN_SUB_ACROSS) { if ( ! CalculateAcrossToolPath( nAuxId, nClId)) { m_pMchMgr->SetLastError( 2709, "Error in SawFinishing : CalculateAcrossToolPath failed") ; 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 return Update( bPostApply) ; } //---------------------------------------------------------------------------- bool SawFinishing::Update( bool bPostApply) { // verifico validità gestore DB geometrico e Id del gruppo if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId)) return false ; // se lavorazione vuota, esco if ( m_nCuts == 0) { LOG_INFO( GetEMkLogger(), "Warning in SawFinishing : No machinable path") return true ; } // imposto eventuale asse bloccato da lavorazione if ( ! m_Params.m_sBlockedAxis.empty()) { string sAxis, sVal ; Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ; double dVal = 0 ; FromString( sVal, dVal) ; m_pMchMgr->ClearRotAxisBlock() ; m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; } // 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( 2710, "Error in SawFinishing : axes values not calculable") ; else m_pMchMgr->SetLastError( 2711, "Error in SawFinishing : outstroke ") ; return false ; } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione if ( ! AdjustStartEndMovements()) { string sInfo = m_pMchMgr->GetOutstrokeInfo() ; if ( sInfo.empty()) m_pMchMgr->SetLastError( 2712, "Error in SawFinishing : link movements not calculable") ; else m_pMchMgr->SetLastError( 2713, "Error in SawFinishing : link outstroke ") ; return false ; } // esecuzione eventuali personalizzazioni if ( bPostApply && ! PostApply()) { m_pMchMgr->SetLastError( 2714, "Error in SawFinishing : post apply not calculable") ; return false ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::GetParam( int nType, bool& bVal) const { switch ( nType) { case MPA_INVERT : bVal = m_Params.m_bInvert ; return true ; } bVal = false ; return false ; } //---------------------------------------------------------------------------- bool SawFinishing::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_TYPE : nVal = MT_SAWFINISHING ; return true ; case MPA_HEADSIDE : nVal = m_Params.m_nHeadSide ; return true ; case MPA_STEPTYPE : nVal = m_Params.m_nStepType ; return true ; case MPA_SUBTYPE : nVal = m_Params.m_nSubType ; return true ; case MPA_LEADLINKTYPE : nVal = m_Params.m_nLeadLinkType ; return true ; case MPA_SCC : nVal = m_Params.m_nSolCh ; return true ; } nVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SawFinishing::GetParam( int nType, double& dVal) const { switch ( nType) { case MPA_SPEED : dVal = GetSpeed() ; return true ; case MPA_FEED : dVal = GetFeed() ; return true ; case MPA_STARTFEED : dVal = GetStartFeed() ; return true ; case MPA_ENDFEED : dVal = GetEndFeed() ; return true ; case MPA_TIPFEED : dVal = GetTipFeed() ; return true ; case MPA_VERTFEED : dVal = GetVertFeed() ; return true ; case MPA_OFFSR : dVal =GetOffsR() ; return true ; case MPA_STARTPOS : dVal = m_Params.m_dStartPos ; return true ; case MPA_SIDESTEP : dVal = m_Params.m_dSideStep ; return true ; case MPA_STEP : dVal = m_Params.m_dStep ; return true ; case MPA_APPROX : dVal = m_Params.m_dApprox ; return true ; case MPA_STARTADDLEN : dVal = m_Params.m_dStartAddLen ; return true ; case MPA_ENDADDLEN : dVal = m_Params.m_dEndAddLen ; return true ; } dVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SawFinishing::GetParam( int nType, string& sVal) const { switch ( nType) { case MPA_NAME : sVal = m_Params.m_sName ; return true ; case MPA_TOOL : sVal = m_Params.m_sToolName ; return true ; case MPA_DEPTH_STR : sVal = m_Params.m_sDepth ; return true ; case MPA_TUUID : sVal = ToString( m_Params.m_ToolUuid) ; return true ; case MPA_UUID : sVal = ToString( m_Params.m_Uuid) ; return true ; case MPA_SYSNOTES : sVal = m_Params.m_sSysNotes ; return true ; case MPA_USERNOTES : sVal = m_Params.m_sUserNotes ; return true ; case MPA_INITANGS : sVal = m_Params.m_sInitAngs ; return true ; case MPA_BLOCKEDAXIS : sVal = m_Params.m_sBlockedAxis ; return true ; } sVal = "" ; return false ; } //---------------------------------------------------------------------------- const ToolData& SawFinishing::GetToolData( void) const { return m_TParams ; } //---------------------------------------------------------------------------- bool SawFinishing::UpdateToolData( bool* pbChanged) { // recupero il gestore DB utensili della macchina corrente ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ; if ( pTMgr == nullptr) return false ; // recupero l'utensile nel DB utensili const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ; if ( pTdata == nullptr) return false ; // verifico se sono diversi (ad esclusione del nome) m_TParams.m_sName = pTdata->m_sName ; bool bChanged = ! SameTool( m_TParams, *pTdata) ; // aggiorno comunque i parametri m_TParams = *pTdata ; // eventuali segnalazioni if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) { string sLog = "Warning in SawFinishing : tool name changed (" + m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ; LOG_INFO( GetEMkLogger(), sLog.c_str()) ; m_Params.m_sToolName = m_TParams.m_sName ; } if ( bChanged) { string sLog = "Warning in SawFinishing : tool data changed (" + m_Params.m_sToolName + ")" ; LOG_INFO( GetEMkLogger(), sLog.c_str()) ; } // se definito parametro di ritorno, lo assegno if ( pbChanged != nullptr) *pbChanged = bChanged ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::GetGeometry( SELVECTOR& vIds) const { // restituisco l'elenco delle entità vIds = m_vId ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const { // compenso il raggio dell'utensile ptP += pCamData->GetCorrDir() * ( m_TParams.m_dDiam / 2) ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::VerifyGeometry( SelData Id, int& nSubs) { // ammessi : curve o superfici // per ora accetto solo curve const ICurve* pCurve = nullptr ; const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ; // se direttamente la curva if ( Id.nSub == SEL_SUB_ALL) { pCurve = ::GetCurve( m_pGeomDB->GetGeoObj( Id.nId)) ; if ( pCurve != nullptr) { if ( pCurve->GetType() == CRV_COMPO) nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ; else nSubs = 0 ; } } // altrimenti sottocurva di composita else { const ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( Id.nId)) ; if ( pCompo != nullptr) pCurve = pCompo->GetCurve( Id.nSub) ; nSubs = 0 ; } return ( pCurve != nullptr) ; } //---------------------------------------------------------------------------- ICurve* SawFinishing::GetCurve( SelData Id) { // ammessi : curve o facce di polymesh // nel caso di facce si deve recuperare la linea di base // per ora accetto solo curve PtrOwner pCurve ; // se direttamente curva if ( Id.nSub == SEL_SUB_ALL) { // recupero e duplico la curva const ICurve* pOriCurve = ::GetCurve( m_pGeomDB->GetGeoObj( Id.nId)) ; if ( pOriCurve != nullptr) pCurve.Set( pOriCurve->Clone()) ; } // altrimenti sottocurva di composita else { // recupero la composita const ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( Id.nId)) ; if ( pCompo != nullptr) { // duplico la curva semplice const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ; if ( pOriCurve != nullptr) { pCurve.Set( pOriCurve->Clone()) ; // recupero estrusione e spessore Vector3d vtExtr ; if ( pCompo->GetExtrusion( vtExtr)) pCurve->SetExtrusion( vtExtr) ; double dThick ; if ( pCompo->GetThickness( dThick)) pCurve->SetThickness( dThick) ; } } } if ( IsNull( pCurve)) return nullptr ; // ne recupero il riferimento globale Frame3d frGlob ; if ( ! m_pGeomDB->GetGlobFrame( Id.nId, frGlob)) return nullptr ; // la porto in globale pCurve->ToGlob( frGlob) ; // la restituisco return Release( pCurve) ; } //---------------------------------------------------------------------------- bool SawFinishing::AdjustGeometry( int nAuxId) { // sgrossatura di cornici diritte : due o più curve (sezioni e guida rettilinea) size_t nCrvCount = m_vId.size() ; if ( nCrvCount >= 2) { // le sezioni devono essere chiuse, piane e giacere in uno stesso piano verticale ICURVEPOVECTOR vpSects ; vpSects.reserve( nCrvCount - 1) ; Vector3d vtN ; for ( size_t i = 0 ; i < nCrvCount - 1 ; ++ i) { vpSects.emplace_back( GetCurve( m_vId[i])) ; if ( IsNull( vpSects.back())) return false ; if ( ! vpSects.back()->IsClosed()) return false ; Plane3d plPlane ; if ( ! vpSects.back()->IsFlat( plPlane, 10 * EPS_SMALL) || abs( plPlane.GetVersN().z) > EPS_SMALL) return false ; if ( i == 0) vtN = plPlane.GetVersN() ; else { if ( ! AreSameOrOppositeVectorApprox( plPlane.GetVersN(), vtN)) return false ; } } // l'ultima curva deve essere una linea, iniziare in comune con la prima sezione ed essere perp. al piano PtrOwner pGuide( GetCurve( m_vId[nCrvCount-1])) ; if ( IsNull( pGuide) || pGuide->GetType() != CRV_LINE) return false ; Point3d ptStStart, ptGdStart ; if ( ! vpSects[0]->GetStartPoint( ptStStart) || ! pGuide->GetStartPoint( ptGdStart) || ! AreSamePointApprox( ptStStart, ptGdStart)) return false ; Vector3d vtGdDir ; if ( ! pGuide->GetStartDir( vtGdDir) || ! AreSameOrOppositeVectorApprox( vtN, vtGdDir)) return false ; // creo sottogruppo di ausiliario per le sezioni con riferimento avente // l'origine nel punto di inizio della prima sezione e la Z opposta alla direzione della guida Frame3d frSect ; if ( ! frSect.Set( ptStStart, - vtGdDir)) return false ; int nGrpSectId = m_pGeomDB->AddGroup( GDB_ID_NULL, nAuxId, frSect) ; if ( nGrpSectId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nGrpSectId, MCH_SECTION) ; // inserisco le sezioni e ne sistemo il senso di rotazione come CCW for ( auto& pSect : vpSects) { pSect->ToLoc( frSect) ; double dArea ; pSect->GetAreaXY( dArea) ; if ( dArea < 0) pSect->Invert() ; if ( m_pGeomDB->AddGeoObj( GDB_ID_NULL, nGrpSectId, ::Release( pSect)) == GDB_ID_NULL) return false ; } // creo sottogruppo per la guida // inserisco la guida nel gruppo ausiliario int nGrpGuideId = m_pGeomDB->AddGroup( GDB_ID_NULL, nAuxId, Frame3d()) ; if ( nGrpGuideId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nGrpGuideId, MCH_GUIDE) ; if ( m_pGeomDB->AddGeoObj( GDB_ID_NULL, nGrpGuideId, ::Release( pGuide)) == GDB_ID_NULL) return false ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawFinishing::CalculateAlongToolPath( int nAuxId, int nClId) { // Recupero ed elaboro le sezioni per portarle ad essere la curva del centro in basso della lama ICurve* pSect ; int nSectGrpId = m_pGeomDB->GetFirstNameInGroup( nAuxId, MCH_SECTION) ; if ( ! CalculateSection( nSectGrpId, pSect)) return false ; PtrOwner pCrv( pSect) ; // recupero il riferimento globale delle sezioni Frame3d frSect ; m_pGeomDB->GetGroupGlobFrame( nSectGrpId, frSect) ; // recupero il box globale delle sezioni BBox3d b3Sect ; m_pGeomDB->GetGlobalBBox( nSectGrpId, b3Sect) ; // Recupero ed elaboro la linea guida Point3d ptGdStart, ptGdEnd ; Vector3d vtGdDir ; int nGuideId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetFirstNameInGroup( nAuxId, MCH_GUIDE)) ; if ( ! CalculateGuideLine( nGuideId, b3Sect, ptGdStart, ptGdEnd, vtGdDir)) return false ; if ( m_Params.m_bInvert) { swap( ptGdStart, ptGdEnd) ; vtGdDir.Invert() ; } // recupero il box globale della linea guida BBox3d b3Guide ; m_pGeomDB->GetGlobalBBox( nGuideId, b3Guide) ; // recupero il box del grezzo in globale BBox3d b3Test ; b3Test.Add( b3Sect) ; b3Test.Add( b3Guide) ; BBox3d b3Raw ; if ( ! GetRawGlobBox( m_nPhase, b3Test, 10 * EPS_SMALL, b3Raw) || b3Raw.IsEmpty()) { m_pMchMgr->SetLastError( 2702, "Error in SawFinishing : Empty RawBox") ; return false ; } // valuto l'espressione dell'affondamento ExeLuaSetGlobNumVar( "TH", 0) ; ExeLuaSetGlobNumVar( "RB", b3Raw.GetMax().z - b3Raw.GetMin().z) ; double dDepth ; if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) { m_pMchMgr->SetLastError( 2703, "Error in SawFinishing : Depth not computable") ; return false ; } // creo gruppo per geometria di lavorazione int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ; if ( nPxId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nPxId, MCH_PATH + "1_1") ; m_pGeomDB->SetMaterial( nPxId, GREEN) ; // Determino versori fresa e correzione Vector3d vtTool, vtCorr ; if ( ! CalculateToolAndCorrVersors( vtGdDir, m_Params.m_nHeadSide, vtTool, vtCorr)) { m_pMchMgr->SetLastError( 2704, "Error in SawFinishing : CalculateToolAndCorrVersors") ; return false ; } // Imposto dati comuni SetPathId( nPxId) ; SetToolDir( vtTool) ; SetCorrAuxDir( vtCorr) ; // Classifico i tratti a seconda della pendenza (salita, discesa, verticale, orizzontale) INTVECTOR vnClass ; ClassifySection( pCrv, vnClass) ; // Inizializzo contatore tagli m_nCuts = 0 ; // Passate sui lati verticali int nUmin = -1, nUmax = -1 ; for ( size_t i = 0 ; i < vnClass.size() ; ++ i) { // se lato verticale if ( vnClass[i] == CCL_VERT) { if ( nUmin < 0) nUmin = int( i) ; nUmax = int( i + 1) ; } // se lato non verticale e non piccolo o ultimo if ( ( vnClass[i] != CCL_VERT && vnClass[i] != CCL_SMALL) || i == vnClass.size() - 1) { if ( nUmin >= 0) { // eseguo la passata if ( ! CalcAlongVerticalCuts( pCrv, nUmin, nUmax, frSect, ptGdStart, ptGdEnd, vtGdDir, dDepth, b3Raw.GetMax().z, vtTool, vtCorr)) return false ; nUmin = - 1 ; } } } // Altre passate int nStatus = CCL_VERT ; nUmin = -1 ; nUmax = -1 ; bool bSkipMin = false, bSkipMax = false ; for ( size_t i = 0 ; i < vnClass.size() ; ++ i) { // se stato nullo (verticale) if ( nStatus == CCL_VERT) { if ( vnClass[i] == CCL_VERT || vnClass[i] == CCL_SMALL) continue ; else { nStatus = vnClass[i] ; nUmin = int( i) ; nUmax = int( i + 1) ; bSkipMin = true ; } } // altrimenti else { // se classe piatto e trovo salita o discesa, converto a questo if ( nStatus == CCL_FLAT && ( vnClass[i] == CCL_RISE || vnClass[i] == CCL_FALL)) nStatus = vnClass[i] ; // se si conserva la classe, aggiorno fine if ( vnClass[i] == nStatus || vnClass[i] == CCL_FLAT || vnClass[i] == CCL_SMALL) nUmax = int( i + 1) ; // altrimenti calcolo il tratto precedente else { // calcolo il tratto bSkipMax = ( vnClass[i] == CCL_VERT) ; bool bInvert = ( nStatus == CCL_RISE) ; if ( ! CalcAlongStdCuts( pCrv, nUmin, nUmax, bSkipMin, bSkipMax, bInvert, frSect, ptGdStart, ptGdEnd, vtGdDir, dDepth, b3Raw.GetMax().z, vtTool, vtCorr)) return false ; // aggiorno stato if ( vnClass[i] == CCL_VERT) nStatus = CCL_VERT ; else { nStatus = vnClass[i] ; nUmin = int( i) ; nUmax = int( i + 1) ; } bSkipMin = true ; } } } // se c'è qualcosa in sospeso if ( nStatus != CCL_VERT) { bSkipMax = false ; bool bInvert = ( nStatus == CCL_RISE) ; if ( ! CalcAlongStdCuts( pCrv, nUmin, nUmax, bSkipMin, bSkipMax, bInvert, frSect, ptGdStart, ptGdEnd, vtGdDir, dDepth, b3Raw.GetMax().z, vtTool, vtCorr)) return false ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::CalculateAcrossToolPath( int nAuxId, int nClId) { // Recupero ed elaboro le sezioni per portarle ad essere la curva del centro in basso della lama ICurve* pSect ; int nSectGrpId = m_pGeomDB->GetFirstNameInGroup( nAuxId, MCH_SECTION) ; if ( ! CalculateSection( nSectGrpId, pSect)) return false ; PtrOwner pCrv( pSect) ; // recupero il riferimento globale delle sezioni Frame3d frSect ; m_pGeomDB->GetGroupGlobFrame( nSectGrpId, frSect) ; // recupero il box globale delle sezioni BBox3d b3Sect ; m_pGeomDB->GetGlobalBBox( nSectGrpId, b3Sect) ; // Recupero ed elaboro la linea guida Point3d ptGdStart, ptGdEnd ; Vector3d vtGdDir ; int nGuideId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetFirstNameInGroup( nAuxId, MCH_GUIDE)) ; if ( ! CalculateGuideLine( nGuideId, b3Sect, ptGdStart, ptGdEnd, vtGdDir)) return false ; Vector3d vtDeltaSect = vtGdDir * ( vtGdDir * ( ptGdStart - frSect.Orig())) ; if ( m_Params.m_bInvert) { swap( ptGdStart, ptGdEnd) ; vtGdDir.Invert() ; } // recupero il box globale della linea guida BBox3d b3Guide ; m_pGeomDB->GetGlobalBBox( nGuideId, b3Guide) ; // recupero il box del grezzo in globale BBox3d b3Test ; b3Test.Add( b3Sect) ; b3Test.Add( b3Guide) ; BBox3d b3Raw ; if ( ! GetRawGlobBox( m_nPhase, b3Test, 10 * EPS_SMALL, b3Raw) || b3Raw.IsEmpty()) { m_pMchMgr->SetLastError( 2702, "Error in SawFinishing : Empty RawBox") ; return false ; } // valuto l'espressione dell'affondamento ExeLuaSetGlobNumVar( "TH", 0) ; ExeLuaSetGlobNumVar( "RB", b3Raw.GetMax().z - b3Raw.GetMin().z) ; double dDepth ; if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) { m_pMchMgr->SetLastError( 2703, "Error in SawFinishing : Depth not computable") ; return false ; } // creo gruppo per geometria di lavorazione int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ; if ( nPxId == GDB_ID_NULL) return false ; m_pGeomDB->SetName( nPxId, MCH_PATH + "1_1") ; m_pGeomDB->SetMaterial( nPxId, GREEN) ; // Determino versori fresa e correzione Vector3d vtTool, vtCorr ; if ( ! CalculateToolAndCorrVersors( vtGdDir, m_Params.m_nHeadSide, vtTool, vtCorr)) { m_pMchMgr->SetLastError( 2704, "Error in SawFinishing : CalculateToolAndCorrVersors") ; return false ; } // Approssimo la curva con una spezzata const double LIN_TOL_STD = 0.05 ; const double ANG_TOL_STD_DEG = 15 ; PolyLine PL ; if ( ! pCrv->ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_RIGHT, PL)) { m_pMchMgr->SetLastError( 2705, "Error in SawFinishing : ApproxWithLines") ; return false ; } // Se standard, allungo inizio e fine della sezione dello spessore lama if ( m_Params.m_nLeadLinkType == SAWFIN_LL_STD) { // inizio PL.Invert() ; double dU ; Point3d ptP ; PL.GetLastUPoint( &dU, &ptP) ; PL.AddUPoint( dU, ptP + Vector3d( m_TParams.m_dThick, 0, 0)) ; PL.Invert() ; // fine PL.GetLastUPoint( &dU, &ptP) ; PL.AddUPoint( dU, ptP - Vector3d( m_TParams.m_dThick, 0, 0)) ; } // La porto in globale PL.ToGlob( frSect) ; PL.Translate( vtDeltaSect) ; if ( m_Params.m_bInvert) PL.Translate( ptGdStart - ptGdEnd) ; // Calcolo eventuale anticipo dell'inizio double dAddStart = 0 ; if ( m_Params.m_nLeadLinkType == SAWFIN_LL_OUT) { BBox3d b3PL ; PL.GetLocalBBox( b3PL) ; double dMaxElev = min( dDepth, b3Raw.GetMax().z - b3PL.GetMin().z) ; if ( dMaxElev > 0.0 && dMaxElev < 0.5 * m_TParams.m_dDiam) dAddStart = sqrt( dMaxElev * m_TParams.m_dDiam - dMaxElev * dMaxElev) ; else dAddStart = 0.5 * m_TParams.m_dDiam ; } // Imposto dati comuni SetPathId( nPxId) ; SetToolDir( vtTool) ; SetCorrAuxDir( vtCorr) ; // Inizializzo contatore tagli m_nCuts = 0 ; // Calcolo le passate double dStep = max( m_Params.m_dSideStep, 10 * EPS_SMALL) ; double dL = Dist( ptGdStart, ptGdEnd) + dAddStart ; int nStep = static_cast( ceil( dL / dStep)) ; dStep = dL / nStep ; Point3d ptP ; bool bFirst = true ; for ( int i = 0 ; i <= nStep ; ++ i) { // vettore di spostamento Vector3d vtMove = vtGdDir * ( - dAddStart + i * dStep) ; // lavoro la sezione if ( m_Params.m_nStepType != SAWFIN_ST_ZIGZAG) { if ( ! CalcAcrossOneWayCut( PL, vtMove, vtTool, vtCorr, b3Raw.GetMax().z, dDepth)) return false ; } else { bool bFirst = ( i == 0) ; if ( ! CalcAcrossZigZagCut( PL, vtMove, vtTool, vtCorr, b3Raw.GetMax().z, dDepth, bFirst)) return false ; } } // se ZigZag aggiungo risalita if ( m_Params.m_nStepType == SAWFIN_ST_ZIGZAG) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // aggiungo retrazione Point3d ptEnd ; if ( ! GetCurrPos( ptEnd)) return false ; double dElev = b3Raw.GetMax().z - ptEnd.z ; if ( ! AddRetract( ptEnd, vtCorr, dSafeZ, dElev, dAppr)) return false ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::CalculateSection( int nSectGrpId, ICurve*& pSect) { // recupero le sezioni ICURVEPVECTOR vpSects ; int nSectId = m_pGeomDB->GetFirstInGroup( nSectGrpId) ; while ( nSectId != GDB_ID_NULL) { // recupero il puntatore alla curva vpSects.emplace_back( ::GetCurve( m_pGeomDB->GetGeoObj( nSectId))) ; if ( vpSects.back() == nullptr) return false ; // passo alla successiva nSectId = m_pGeomDB->GetNext( nSectId) ; } // elimino eventuali sottosquadra const double LIN_TOL_STD = 0.1 ; const double ANG_TOL_STD_DEG = 15 ; ICURVEPOVECTOR vpNucCrvs ; vpNucCrvs.reserve( vpSects.size()) ; for ( const auto& pSect : vpSects) { PtrOwner pCrvCompo( CreateCurveComposite()) ; if ( IsNull( pCrvCompo) || ! pCrvCompo->AddCurve( *pSect) || ! pCrvCompo->RemoveUndercutOnY( LIN_TOL_STD, ANG_TOL_STD_DEG)) return false ; vpNucCrvs.emplace_back( Release( pCrvCompo)) ; } // calcolo ordinamento delle curve secondo la X decrescente typedef pair INDASC ; // coppia indice, ascissa typedef vector INDASCVECTOR ; // vettore di coppie indice, ascissa INDASCVECTOR vIAsc ; vIAsc.reserve( vpNucCrvs.size()) ; for ( int i = 0 ; i < int( vpNucCrvs.size()) ; ++ i) { Point3d ptStart ; if ( ! vpNucCrvs[i]->GetStartPoint( ptStart)) return false ; vIAsc.emplace_back( i, ptStart.x) ; } std::sort( vIAsc.begin(), vIAsc.end(), []( const INDASC& a, const INDASC& b) { return a.second > b.second ; }) ; // unisco le diverse curve (ora aperte) in un unico profilo PtrOwner pCurve( CreateCurveComposite()) ; if ( IsNull( pCurve)) return false ; bool bFirst = true ; for ( int i = 0 ; i < int( vpNucCrvs.size()) ; ++ i) { if ( ! bFirst) { Point3d ptStart ; if ( ! vpNucCrvs[vIAsc[i].first]->GetStartPoint( ptStart) || ! pCurve->AddLine( ptStart)) return false ; } if ( ! pCurve->AddCurve( Release( vpNucCrvs[vIAsc[i].first]))) return false ; bFirst = false ; } // offset radiale delle sezioni per il sovramateriale double dOffsR = GetOffsR() ; PtrOwner pOvrCrv ; OffsetCurve OffsCrv ; OffsCrv.Make( pCurve, dOffsR, ICurve::OFF_FILLET) ; pOvrCrv.Set( OffsCrv.GetLongerCurve()) ; // ricavo dalla sezione la curva per centro in basso della lama double dOffsX = 0.5 * m_TParams.m_dThick ; PtrOwner pCrv ; OffsetCurveOnX OffsCrvX ; OffsCrvX.Make( pOvrCrv, dOffsX) ; pCrv.Set( OffsCrvX.GetLongerCurve()) ; // eseguo trim (se richiesto) if ( ! TrimSection( pCrv)) return false ; pSect = Release( pCrv) ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::TrimSection( ICurve* pCrv) { // se parametri di accorciamento iniziale e finale sono nulli, non faccio alcunché if ( m_Params.m_dStartAddLen > - EPS_SMALL && m_Params.m_dEndAddLen > -EPS_SMALL) return true ; // box della sezione in locale BBox3d b3Crv ; pCrv->GetBBox( Frame3d(), b3Crv) ; // riduco gli estremi in X Point3d ptMin = b3Crv.GetMin() ; Point3d ptMax = b3Crv.GetMax() ; ptMin.x -= m_Params.m_dStartAddLen ; ptMax.x += m_Params.m_dEndAddLen ; double dDimX = ptMax.x - ptMin.x ; double dDimY = ptMax.y - ptMin.y + 100 * EPS_SMALL ; // regione del box nel piano XY PtrOwner pSfr( GetSurfFlatRegionRectangle( dDimX, dDimY)) ; if ( IsNull( pSfr)) return false ; pSfr->Translate( Vector3d( ptMin.x, ptMin.y - 50 * EPS_SMALL, ptMin.z)) ; // calcolo la classificazione della curva rispetto alla regione CRVCVECTOR ccClass ; if ( ! pSfr->GetCurveClassification( *pCrv, ccClass)) return false ; // determino l'intervallo di curva da conservare Intervals inOk ; for ( auto& ccOne : ccClass) { if ( ccOne.nClass == CRVC_IN || ccOne.nClass == CRVC_ON_P || ccOne.nClass == CRVC_ON_M) inOk.Add( ccOne.dParS, ccOne.dParE) ; } // eseguo trim double dUmin, dUmax ; if ( ! inOk.GetMinMax( dUmin, dUmax)) return false ; return ( pCrv->TrimEndAtParam( dUmax) && pCrv->TrimStartAtParam( dUmin)) ; } //---------------------------------------------------------------------------- bool SawFinishing::CalculateGuideLine( int nGuideId, const BBox3d& b3Sect, Point3d& ptGdStart, Point3d& ptGdEnd, Vector3d& vtGdDir) { // recupero la linea guida ICurve* pGuide = ::GetCurve( m_pGeomDB->GetGeoObj( nGuideId)) ; if ( pGuide == nullptr) return false ; // recupero il suo riferimento Frame3d frGdL ; m_pGeomDB->GetGlobFrame( nGuideId, frGdL) ; // porto la curva in globale (dovrebbe già avere riferimento globale) pGuide->ToGlob( frGdL) ; // recupero gli estremi della linea guida pGuide->GetStartPoint( ptGdStart) ; pGuide->GetEndPoint( ptGdEnd) ; // recupero la direzione della linea guida pGuide->GetStartDir( vtGdDir) ; // per ora ammesse solo linee guida rettilinee dirette lungo X o Y if ( ! AreSameOrOppositeVectorApprox( vtGdDir, X_AX) && ! AreSameOrOppositeVectorApprox( vtGdDir, Y_AX)) { m_pMchMgr->SetLastError( 2706, "Error in SawFinishing : Guide Line not along X or Y") ; return false ; } // recupero il box globale della linea guida BBox3d b3Guide ; m_pGeomDB->GetGlobalBBox( nGuideId, b3Guide) ; // recupero il box del grezzo in globale BBox3d b3Test ; b3Test.Add( b3Sect) ; b3Test.Add( b3Guide) ; BBox3d b3Raw ; if ( ! GetRawGlobBox( m_nPhase, b3Test, 10 * EPS_SMALL, b3Raw) || b3Raw.IsEmpty()) { m_pMchMgr->SetLastError( 2702, "Error in SawFinishing : Empty RawBox") ; return false ; } // aggiusto la linea guida al bordo del box if ( AreSameVectorApprox( vtGdDir, X_AX)) { ptGdStart.x = b3Raw.GetMin().x ; ptGdEnd.x = b3Raw.GetMax().x ; } else if ( AreOppositeVectorApprox( vtGdDir, X_AX)) { ptGdStart.x = b3Raw.GetMax().x ; ptGdEnd.x = b3Raw.GetMin().x ; } else if ( AreSameVectorApprox( vtGdDir, Y_AX)) { ptGdStart.y = b3Raw.GetMin().y ; ptGdEnd.y = b3Raw.GetMax().y ; } else { ptGdStart.y = b3Raw.GetMax().y ; ptGdEnd.y = b3Raw.GetMin().y ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::ClassifySection( ICurve* pCrv, INTVECTOR& vnClass) { const ICurveComposite* pCompo = GetCurveComposite( pCrv) ; if ( pCompo != nullptr) { int Ind = 0 ; const ICurve* pSimpCrv = pCompo->GetFirstCurve() ; while ( pSimpCrv != nullptr) { // analizzo la curva Point3d ptStart, ptEnd ; pSimpCrv->GetStartPoint( ptStart) ; pSimpCrv->GetEndPoint( ptEnd) ; if ( AreSamePointXYEpsilon( ptEnd, ptStart, 10 * EPS_SMALL)) vnClass.push_back( CCL_SMALL) ; else if ( abs( ptEnd.x - ptStart.x) < EPS_SMALL) vnClass.push_back( CCL_VERT) ; else if ( abs( ptEnd.y - ptStart.y) < EPS_SMALL) vnClass.push_back( CCL_FLAT) ; else if ( ptEnd.y > ptStart.y) vnClass.push_back( CCL_RISE) ; else vnClass.push_back( CCL_FALL) ; // passo alla curva successiva ++ Ind ; pSimpCrv = pCompo->GetNextCurve() ; } } else { Point3d ptStart, ptEnd ; pCrv->GetStartPoint( ptStart) ; pCrv->GetEndPoint( ptEnd) ; if ( AreSamePointXYEpsilon( ptEnd, ptStart, 10 * EPS_SMALL)) vnClass.push_back( CCL_SMALL) ; else if ( abs( ptEnd.x - ptStart.x) < EPS_SMALL) vnClass.push_back( CCL_VERT) ; else if ( abs( ptEnd.y - ptStart.y) < EPS_SMALL) vnClass.push_back( CCL_FLAT) ; else if ( ptEnd.y > ptStart.y) vnClass.push_back( CCL_RISE) ; else vnClass.push_back( CCL_FALL) ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::CalcAlongVerticalCuts( ICurve* pSect, int nUmin, int nUmax, const Frame3d& frSect, const Point3d& ptGdStart, const Point3d& ptGdEnd, const Vector3d& vtGdDir, double dDepth, double dRawMaxZ, const Vector3d& vtTool, const Vector3d& vtCorr) { // Ingombro del taglio BBox3d b3Cut ; for ( int i = nUmin ; i <= nUmax ; ++ i) { Point3d ptP ; if ( pSect->GetPointD1D2( i, ICurve::FROM_MINUS, ptP)) b3Cut.Add( ptP) ; } if ( b3Cut.IsEmpty()) return false ; // ascissa double dX = ( b3Cut.GetMin().x + b3Cut.GetMax().x) / 2 ; // Calcolo dello step tra le passate double dL = b3Cut.GetMax().y - b3Cut.GetMin().y ; if ( dL < 10 * EPS_SMALL) return true ; double dStep = max( m_Params.m_dStep, 10 * EPS_SMALL) ; int nStep = static_cast( ceil( dL / dStep)) ; dStep = dL / nStep ; // Ciclo sulle passate double dLastElev ; Point3d ptStartPrev ; for ( int i = 0 ; i <= nStep ; ++ i) { // ordinata double dY = b3Cut.GetMax().y - i * dStep ; // estremi del taglio Vector3d vtMove = dX * frSect.VersX() + dY * frSect.VersY() - 0.5 * m_TParams.m_dThick * vtTool ; Point3d ptStart = ptGdStart + vtMove ; Point3d ptEnd = ptGdEnd + vtMove ; // determino l'elevazione del taglio Vector3d vtThick = vtTool * m_TParams.m_dThick ; double dElev, dElev2 ; if ( ! GetElevation( m_nPhase, ptStart, ptEnd, vtCorr, dElev) || ! GetElevation( m_nPhase, ptStart + vtThick, ptEnd + vtThick, vtCorr, dElev2) ) { m_pMchMgr->SetLastError( 2707, "Error in SawFinishinging : GetElevation") ; return false ; } dElev = max( dElev, dElev2) ; if ( dElev < EPS_SMALL) dElev = max( max( dRawMaxZ - ptStart.z, dRawMaxZ - ptEnd.z), 0.) ; // la confronto con il massimo affondamento e con la massima lavorazione della lama double dMaxDepth = min( dDepth, m_TParams.m_dMaxMat) ; if ( dElev > dMaxDepth) { ptStart += Vector3d( 0, 0, dElev - dMaxDepth) ; ptEnd += Vector3d( 0, 0, dElev - dMaxDepth) ; dElev = dMaxDepth ; } // se diverso da precedente, eseguo il taglio bool bFirst = ( i == 0) ; if ( bFirst || ! AreSamePointEpsilon( ptStart, ptStartPrev, 10 * EPS_SMALL)) { if ( m_Params.m_nStepType != SAWFIN_ST_ZIGZAG) { if ( ! CalcAlongOneWayCut( ptStart, ptEnd, vtGdDir, vtTool, vtCorr, dElev, true)) return false ; } else { if ( ! CalcAlongZigZagCut( ptStart, ptEnd, vtGdDir, vtTool, vtCorr, dElev, true, bFirst)) return false ; } // salvo dati correnti dLastElev = dElev ; ptStartPrev = ptStart ; } } // se ZigZag e non centrato aggiungo risalita if ( m_Params.m_nStepType == SAWFIN_ST_ZIGZAG && m_Params.m_nLeadLinkType != SAWFIN_LL_CENT) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // aggiungo retrazione Point3d ptNewEnd ; if ( ! GetCurrPos( ptNewEnd) || ! AddRetract( ptNewEnd, vtCorr, dSafeZ, dLastElev, dAppr)) return false ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::CalcAlongStdCuts( ICurve* pSect, double dUmin, double dUmax, bool bSkipMin, bool bSkipMax, bool bInvert, const Frame3d& frSect, const Point3d& ptGdStart, const Point3d& ptGdEnd, const Vector3d& vtGdDir, double dDepth, double dRawMaxZ, const Vector3d& vtTool, const Vector3d& vtCorr) { // Calcolo dello step tra le passate double dStep = max( m_Params.m_dSideStep, 10 * EPS_SMALL) ; double dLmin, dLmax ; if ( ! pSect->GetLengthAtParam( dUmin, dLmin) || ! pSect->GetLengthAtParam( dUmax, dLmax)) return false ; double dL = dLmax - dLmin ; if ( dL < 10 * EPS_SMALL) return true ; int nStep = static_cast( ceil( dL / dStep)) ; dStep = dL / nStep ; // Ciclo sulle passate double dLastElev ; Point3d ptStartPrev ; bool bSkipIni = ( bInvert ? bSkipMax : bSkipMin) ; bool bSkipFin = ( bInvert ? bSkipMin : bSkipMax) ; int nIni = ( bSkipIni ? 1 : 0) ; int nFin = ( bSkipFin ? nStep - 1 : nStep) ; if ( nFin < nIni) return true ; for ( int i = nIni ; i <= nFin ; ++ i) { // calcolo del parametro double dLcurr = ( bInvert ? dLmax - i * dStep : dLmin + i * dStep) ; double dU ; pSect->GetParamAtLength( dLcurr, dU) ; // coordinate nel punto Point3d ptP ; pSect->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP) ; // estremi del taglio Vector3d vtMove = ptP.x * frSect.VersX() + ptP.y * frSect.VersY() - 0.5 * m_TParams.m_dThick * vtTool ; Point3d ptStart = ptGdStart + vtMove ; Point3d ptEnd = ptGdEnd + vtMove ; // determino l'elevazione del taglio Vector3d vtThick = vtTool * m_TParams.m_dThick ; double dElev, dElev2 ; if ( ! GetElevation( m_nPhase, ptStart, ptEnd, vtCorr, dElev) || ! GetElevation( m_nPhase, ptStart + vtThick, ptEnd + vtThick, vtCorr, dElev2) ) { m_pMchMgr->SetLastError( 2707, "Error in SawFinishing : GetElevation") ; return false ; } dElev = max( dElev, dElev2) ; if ( dElev < EPS_SMALL) dElev = max( max( dRawMaxZ - ptStart.z, dRawMaxZ - ptEnd.z), 0.) ; // la confronto con il massimo affondamento e con la massima lavorazione della lama double dMaxDepth = min( dDepth, m_TParams.m_dMaxMat) ; if ( dElev > dMaxDepth) { ptStart += Vector3d( 0, 0, dElev - dMaxDepth) ; ptEnd += Vector3d( 0, 0, dElev - dMaxDepth) ; dElev = dMaxDepth ; } // se diverso da precedente, eseguo il taglio bool bFirst = ( i == nIni) ; if ( bFirst || ! AreSamePointEpsilon( ptStart, ptStartPrev, 10 * EPS_SMALL)) { if ( m_Params.m_nStepType != SAWFIN_ST_ZIGZAG) { if ( ! CalcAlongOneWayCut( ptStart, ptEnd, vtGdDir, vtTool, vtCorr, dElev, false)) return false ; } else { if ( ! CalcAlongZigZagCut( ptStart, ptEnd, vtGdDir, vtTool, vtCorr, dElev, false, bFirst)) return false ; } // salvo dati correnti dLastElev = dElev ; ptStartPrev = ptStart ; } } // se ZigZag e non centrato aggiungo risalita if ( m_Params.m_nStepType == SAWFIN_ST_ZIGZAG && m_Params.m_nLeadLinkType != SAWFIN_LL_CENT) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // aggiungo retrazione Point3d ptNewEnd ; if ( ! GetCurrPos( ptNewEnd) || ! AddRetract( ptNewEnd, vtCorr, dSafeZ, dLastElev, dAppr)) return false ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::CalcAlongOneWayCut( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDir, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bVert) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // se attacco/uscita/collegamento esterno allungo inizio Point3d ptNewStart = ptStart ; if ( m_Params.m_nLeadLinkType == SAWFIN_LL_STD) { ptNewStart = ptStart - vtDir * dAppr ; } else if ( m_Params.m_nLeadLinkType == SAWFIN_LL_OUT) { // distanza XY tra centro e bordo taglio double dDeltaT = 0 ; if ( dElev > 0.0 && dElev < 0.5 * m_TParams.m_dDiam) dDeltaT = sqrt( dElev * m_TParams.m_dDiam - dElev * dElev) ; // modifico inizio ptNewStart = ptStart - vtDir * ( dDeltaT + dAppr) ; } // Sempre una sola passata // 1 -> approccio if ( ! AddApproach( ptNewStart, vtCorr, dSafeZ, dElev, dAppr)) return false ; // 2 -> movimento in affondo al punto iniziale SetFlag( 0) ; if ( m_Params.m_nLeadLinkType != SAWFIN_LL_OUT) SetFeed( GetTipFeed()) ; else SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; // 3 -> movimento di lato al punto finale SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ; if ( AddLinearMove( ptEnd) == GDB_ID_NULL) return false ; // 4 -> retrazione if ( ! AddRetract( ptEnd, vtCorr, dSafeZ, dElev, dAppr)) return false ; // incremento contatore passate ++ m_nCuts ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::CalcAlongZigZagCut( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDir, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bVert, bool bFirst) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // aggiorno inizio, fine e direzione movimento Point3d ptOriStart = ptStart ; Point3d ptOriEnd = ptEnd ; Point3d ptNewStart = ptStart ; Point3d ptNewEnd = ptEnd ; Vector3d vtNewDir = vtDir ; // se attacco/uscita/collegamento standard allungo inizio e fine dell'approccio if ( m_Params.m_nLeadLinkType == SAWFIN_LL_STD) { // modifico inizio ptNewStart = ptStart - vtDir * dAppr ; // modifico fine ptNewEnd = ptEnd + vtDir * dAppr ; } // se attacco/uscita/collegamento esterno allungo inizio e fine a fuori grezzo else if ( m_Params.m_nLeadLinkType == SAWFIN_LL_OUT) { // distanza XY tra centro e bordo taglio double dDeltaT = 0 ; if ( dElev > 0.0 && dElev < 0.5 * m_TParams.m_dDiam) dDeltaT = sqrt( dElev * m_TParams.m_dDiam - dElev * dElev) ; // modifico inizio ptNewStart = ptStart - vtDir * ( dDeltaT + dAppr) ; // modifico fine ptNewEnd = ptEnd + vtDir * ( dDeltaT + dAppr) ; } // le passate dispari sono al contrario if ( ( m_nCuts % 2) != 0) { swap( ptOriStart, ptOriEnd) ; swap( ptNewStart, ptNewEnd) ; vtNewDir.Invert() ; } // Sempre una sola passata // 1 -> approccio if ( bFirst || m_Params.m_nLeadLinkType == SAWFIN_LL_CENT) { if ( ! AddApproach( ptNewStart, vtCorr, dSafeZ, dElev, dAppr)) return false ; } // 2 -> movimento in affondo al punto iniziale SetFlag( 0) ; // con attacco centrato sono sul materiale e devo usare feed di testa if ( m_Params.m_nLeadLinkType == SAWFIN_LL_CENT) { SetFeed( GetTipFeed()) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } // con attacco fuori sono in aria else { if ( bFirst) { SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } else { Point3d ptLast ; GetCurrPos( ptLast) ; double dDiff = ( ptNewStart - ptLast) * vtNewDir ; // se precedente e corrente sono fuori allo stesso modo if ( abs( dDiff) < 10 * EPS_SMALL) { // inizio nuova passata SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } // se il precedente è più fuori else if ( dDiff > 0) { // allungo nuova passata SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ; if ( AddLinearMove( ptNewStart - dDiff * vtNewDir) == GDB_ID_NULL) return false ; } // se il corrente è più fuori else { // allungo passata precedente if ( AddLinearMove( ptLast + dDiff * vtNewDir) == GDB_ID_NULL) return false ; // inizio nuova passata SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ; if ( AddLinearMove( ptNewStart) == GDB_ID_NULL) return false ; } } } // 3 -> movimento di lato al punto finale if ( m_Params.m_nLeadLinkType == SAWFIN_LL_CENT) { SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ; if ( AddLinearMove( ptNewEnd) == GDB_ID_NULL) return false ; } else { SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ; if ( AddLinearMove( ptOriEnd) == GDB_ID_NULL) return false ; SetFeed( GetEndFeed()) ; if ( AddLinearMove( ptNewEnd) == GDB_ID_NULL) return false ; } // 4 -> retrazione if ( m_Params.m_nLeadLinkType == SAWFIN_LL_CENT) { if ( ! AddRetract( ptNewEnd, vtCorr, dSafeZ, dElev, dAppr)) return false ; } // incremento contatore passate ++ m_nCuts ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::CalcAcrossOneWayCut( const PolyLine& PL, const Vector3d& vtMove, const Vector3d& vtTool, const Vector3d& vtCorr, double dRawZ, double dDepth) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; Point3d ptP ; // 1 -> approccio bool bFound = PL.GetFirstPoint( ptP) ; if ( bFound) { ptP += vtMove - 0.5 * m_TParams.m_dThick * vtTool ; ptP.z = max( ptP.z, dRawZ - dDepth) ; double dElev = dRawZ - ptP.z ; if ( ! AddApproach( ptP, vtCorr, dSafeZ, dElev, dAppr)) return false ; } // 2 -> movimento lungo la sezione Point3d ptPrev ; GetCurrPos( ptPrev) ; while ( bFound) { // se diverso da precedente, movimento al punto if ( ! AreSamePointEpsilon( ptP, ptPrev, 10 * EPS_SMALL)) { Vector3d vtDelta = ptP - ptPrev ; if ( vtDelta.z > - EPS_SMALL) SetFeed( GetFeed()) ; else { double dC = sqrt( 1 + ( vtDelta.x * vtDelta.x + vtDelta.y * vtDelta.y) / ( vtDelta.z * vtDelta.z)) ; double dF = min( GetFeed(), dC * GetTipFeed()) ; SetFeed( dF) ; } if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; ptPrev = ptP ; } // recupero punto successivo bFound = PL.GetNextPoint( ptP) ; if ( bFound) { ptP += vtMove - 0.5 * m_TParams.m_dThick * vtTool ; ptP.z = max( ptP.z, dRawZ - dDepth) ; } } // 3-> retrazione { double dElev = dRawZ - ptP.z ; if ( ! AddRetract( ptP, vtCorr, dSafeZ, dElev, dAppr)) return false ; } // incremento contatore passate ++ m_nCuts ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::CalcAcrossZigZagCut( const PolyLine& PL, const Vector3d& vtMove, const Vector3d& vtTool, const Vector3d& vtCorr, double dRawZ, double dDepth, bool bFirst) { // recupero distanza di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // sezione da invertire bool bInvert = (( m_nCuts % 2) != 0) ; Point3d ptP ; bool bFound = ( bInvert ? PL.GetLastPoint( ptP) : PL.GetFirstPoint( ptP)) ; // 1 -> approccio if ( bFound) { ptP += vtMove - 0.5 * m_TParams.m_dThick * vtTool ; ptP.z = max( ptP.z, dRawZ - dDepth) ; if ( bFirst) { double dElev = dRawZ - ptP.z ; if ( ! AddApproach( ptP, vtCorr, dSafeZ, dElev, dAppr)) return false ; } } // 2 -> movimento lungo la sezione Point3d ptPrev ; GetCurrPos( ptPrev) ; while ( bFound) { // se diverso da precedente, movimento al punto if ( ! AreSamePointEpsilon( ptP, ptPrev, 10 * EPS_SMALL)) { Vector3d vtDelta = ptP - ptPrev ; if ( vtDelta.z > - EPS_SMALL) SetFeed( GetFeed()) ; else { double dC = sqrt( 1 + ( vtDelta.x * vtDelta.x + vtDelta.y * vtDelta.y) / ( vtDelta.z * vtDelta.z)) ; double dF = min( GetFeed(), dC * GetTipFeed()) ; SetFeed( dF) ; } if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; ptPrev = ptP ; } // recupero punto successivo bFound = ( bInvert ? PL.GetPrevPoint( ptP) : PL.GetNextPoint( ptP)) ; if ( bFound) { ptP += vtMove - 0.5 * m_TParams.m_dThick * vtTool ; ptP.z = max( ptP.z, dRawZ - dDepth) ; } } // incremento contatore passate ++ m_nCuts ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::AddApproach( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dElev, double dAppr) { // se distanza di sicurezza minore di distanza di inizio if ( dSafeZ < m_Params.m_dStartPos + 10 * EPS_SMALL) { // 1 -> punto sopra inizio Point3d ptP1 = ptP + vtCorr * ( dElev + dAppr) ; if ( m_nCuts == 0) { SetFlag( 1) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; } else { SetFlag( 0) ; if ( AddRapidMove( ptP1) == GDB_ID_NULL) return false ; } } else { // 1a -> punto sopra inizio Point3d ptP1b = ptP + vtCorr * ( dElev + dAppr) ; Point3d ptP1a = ptP1b + Z_AX * ( dSafeZ - m_Params.m_dStartPos) ; if ( m_nCuts == 0) { SetFlag( 1) ; if ( AddRapidStart( ptP1a) == GDB_ID_NULL) return false ; } else { SetFlag( 0) ; Point3d ptCurr ; GetCurrPos( ptCurr) ; if ( ! AreSamePointEpsilon( ptCurr, ptP1a, 10 * EPS_SMALL)) { if ( AddRapidMove( ptP1a) == GDB_ID_NULL) return false ; } } // 1b -> punto appena sopra inizio SetFlag( 0) ; if ( AddRapidMove( ptP1b) == GDB_ID_NULL) return false ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::AddRetract( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dElev, double dAppr) { Point3d ptCurr ; GetCurrPos( ptCurr) ; if ( dSafeZ < m_Params.m_dStartPos + 10 * EPS_SMALL) { // 4 -> movimento di risalita sopra il punto finale SetFeed( GetEndFeed()) ; Point3d ptP4 = ptP + vtCorr * ( dElev + dAppr) ; if ( ! AreSamePointEpsilon( ptP4, ptCurr, 10 * EPS_SMALL)) { if ( AddLinearMove( ptP4) == GDB_ID_NULL) return false ; } } else { // 4a -> movimento di risalita appena sopra il punto finale Point3d ptP4a = ptP + vtCorr * ( dElev + dAppr) ; if ( ! AreSamePointEpsilon( ptP4a, ptCurr, 10 * EPS_SMALL)) { SetFeed( GetEndFeed()) ; if ( AddLinearMove( ptP4a) == GDB_ID_NULL) return false ; } // 4b -> movimento di risalita sopra il punto finale Point3d ptP4b = ptP4a + Z_AX * ( dSafeZ - m_Params.m_dStartPos) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } return true ; } //---------------------------------------------------------------------------- bool SawFinishing::CalculateToolAndCorrVersors( const Vector3d& vtTang, int nHeadSide, Vector3d& vtTool, Vector3d& vtCorr) { // Versore fresa : annullo la componente in Z e normalizzo vtTool = vtTang ; vtTool.z = 0 ; if ( ! vtTool.Normalize()) return false ; // ruoto attorno a Zglob+ a seconda del lato mandrino if ( nHeadSide == SAW_HS_LEFT) vtTool.Rotate( Z_AX, 90) ; else vtTool.Rotate( Z_AX, -90) ; // Versore correzione vtCorr = Z_AX ; return true ; } //---------------------------------------------------------------------------- bool SawFinishing::GetHeightOnSection( const ICurve* pSect, double dX, double dYmin, double dYmax, double& dY) { // creo raggio per intersezione con direzione Y+ PtrOwnerpRay( CreateCurveLine()) ; if ( IsNull( pRay) || ! pRay->Set( Point3d( dX, dYmin - EPS_SMALL, 0), Point3d( dX, dYmax + EPS_SMALL, 0))) return false ; // eseguo intersezione (considero l'ultima, ovvero quella con Y maggiore) IntersCurveCurve intCC( *pRay, *pSect) ; IntCrvCrvInfo aInfo ; if ( intCC.GetIntCrvCrvInfo( intCC.GetIntersCount() - 1, aInfo)) { // nel caso di sovrapposizione devo prendere la Y in basso del tratto dY = aInfo.IciA[0].ptI.y ; return true ; } // se non c'è intersezione assegno il minimo dY = dYmin ; return true ; }