Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
EgtMachKernel/Milling.cpp
T
Dario Sassi 054dc530fb EgtMachKernel : 
- modifica in fresatura per asse Aux da UserNotes anche con fresa centrata.
2026-04-28 13:21:16 +02:00

6760 lines
293 KiB
C++
Raw Permalink Blame History

//----------------------------------------------------------------------------
// EgalTech 2015-2023
//----------------------------------------------------------------------------
// File : Milling.cpp Data : 19.12.23 Versione : 2.5l3
// Contenuto : Implementazione gestione fresature.
//
//
//
// Modifiche : 07.06.15 DS Creazione modulo.
// 11.08.16 DS Miglioria gestione PV per più loop.
// 02.06.20 DS Aggiunta gestione Tabs.
// 16.03.22 DS Migliorata sicurezza lame sopra.
// 24.02.22 DS Corretta ed estesa VerifyPathFromBottom.
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "Milling.h"
#include "GeoConst.h"
#include "OperationConst.h"
#include "OperUserNotesConst.h"
#include "/EgtDev/Include/EXeCmdLogOff.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkArcSpecial.h"
#include "/EgtDev/Include/EGkChainCurves.h"
#include "/EgtDev/Include/EGkOffsetCurve.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkIntersCurveSurfTm.h"
#include "/EgtDev/Include/EGkIntervals.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EgtIniFile.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//------------------------------ Constants ------------------------------------
const double OSC_MIN_LEN = 0.1 ;
const double LIM_DOWN_APPRZ = -0.5 ;
const double DELTA_ELEV_RAD = 4.0 ;
const double LIM_SIN_DIFF_DIR = 0.175 ;
//------------------------------ Errors --------------------------------------
// 2301 = "Error in Milling : UpdateToolData failed"
// 2302 = "Error in Milling : Offset not computable"
// 2303 = "Error in Milling : Empty RawBox"
// 2304 = "Error in Milling : Depth not computable"
// 2305 = "Error in Milling : machining depth (xx) bigger than MaxMaterial (yy)"
// 2306 = "Error in Milling : machining step (xx) bigger than MaxMaterial (yy)"
// 2307 = "Error in Milling : missing aggregate from bottom"
// 2308 = "Error in Milling : path too far from part sides"
// 2309 = "Error in Milling : Approach not computable"
// 2310 = "Error in Milling : LeadIn not computable"
// 2311 = "Error in Milling : LeadOut not computable"
// 2312 = "Error in Milling : Retract not computable"
// 2313 = "Error in Milling : Linear Approx not computable"
// 2314 = "Error in Milling : LeadIn must be out of rawpart"
// 2315 = "Error in Milling : Chaining failed"
// 2316 = "Error in Milling : Tool MaxMaterial too small (xx)"
// 2317 = "Error in Milling : axes values not calculable"
// 2318 = "Error in Milling : outstroke xx"
// 2319 = "Error in Milling : link movements not calculable"
// 2320 = "Error in Milling : link outstroke xx"
// 2321 = "Error in Milling : post apply not calculable"
// 2322 = "Error in Milling : Tool loading failed"
// 2323 = "Error in Milling : machining depth (xxx) bigger than MaxDepth (yyy)"
// 2324 = "Error in Milling : LeadOut must be out of rawpart"
// 2325 = "Error in Milling : Mirror for Double calculation failed"
// 2326 = "Error in Milling : special apply not calculable"
// 2351 = "Warning in Milling : Skipped entity (xx)"
// 2352 = "Warning in Milling : No machinable path"
// 2353 = "Warning in Milling : Tool name changed (xx)"
// 2354 = "Warning in Milling : Tool data changed (xx)"
// 2355 = "Warning in Milling : skipped Path too short"
// 2356 = "Warning in Milling : machining step too small (xx)"
// 2357 = "Warning in Milling : machining step (xxx) bigger than MaxMaterial (yyy)"
// 2358 = "Warning in Milling : machining depth (xxx) bigger than MaxMaterial (yyy)"
// 2359 = "Warning in Milling : oscillation incompatible with saw blade"
// 2360 = "Warning in Milling : oscillation incompatible with depth"
// 2361 = "Warning in Milling : oscillation impossible"
// 2362 = "Warning in Milling : tabs incompatible with saw blade"
// 2363 = "Warning in Milling : tabs impossible"
// 2364 = "Warning in Milling : tabs number less than minimum"
//----------------------------------------------------------------------------
USEROBJ_REGISTER( GetOperationClass( OPER_MILLING), Milling) ;
//----------------------------------------------------------------------------
const string&
Milling::GetClassName( void) const
{
return USEROBJ_GETNAME( Milling) ;
}
//----------------------------------------------------------------------------
Milling*
Milling::Clone( void) const
{
// alloco oggetto
Milling* pMill = new( nothrow) Milling ;
// eseguo copia dei dati
if ( pMill != nullptr) {
try {
pMill->m_vId = m_vId ;
pMill->m_pMchMgr = m_pMchMgr ;
pMill->m_nPhase = m_nPhase ;
pMill->m_Params = m_Params ;
pMill->m_TParams = m_TParams ;
pMill->m_dTHoldBase = m_dTHoldBase ;
pMill->m_dTHoldLen = m_dTHoldLen ;
pMill->m_dTHoldDiam = m_dTHoldDiam ;
pMill->m_bTHoldFloating = m_bTHoldFloating ;
pMill->m_nStatus = m_nStatus ;
pMill->m_nMills = m_nMills ;
pMill->m_bStepOn = m_bStepOn ;
pMill->m_dAddedOverlap = m_dAddedOverlap ;
pMill->m_nHeadSolCh = m_nHeadSolCh ;
pMill->m_bTiltingTab = m_bTiltingTab ;
pMill->m_vtTiltingAx = m_vtTiltingAx ;
pMill->m_bAboveHead = m_bAboveHead ;
pMill->m_bAggrBottom = m_bAggrBottom ;
pMill->m_dCurrOscillLen = m_dCurrOscillLen ;
pMill->m_dCurrTabsLen = m_dCurrTabsLen ;
pMill->m_bStartOutRaw = m_bStartOutRaw ;
pMill->m_bEndOutRaw = m_bEndOutRaw ;
}
catch( ...) {
delete pMill ;
return nullptr ;
}
}
// ritorno l'oggetto
return pMill ;
}
//----------------------------------------------------------------------------
bool
Milling::Dump( string& sOut, bool bMM, const char* szNewLine) const
{
sOut += GetClassName() + "[mm]" + szNewLine ;
sOut += KEY_PHASE + EQUAL + ToString( m_nPhase) + szNewLine ;
sOut += KEY_IDS + EQUAL + ToString( m_vId) + szNewLine ;
for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
sOut += m_Params.ToString( i) + szNewLine ;
for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
sOut += m_TParams.ToString( i) + szNewLine ;
sOut += KEY_NUM + EQUAL + ToString( m_nMills) + szNewLine ;
sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::Save( int nBaseId, STRVECTOR& vString) const
{
try {
int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 3 ;
vString.insert( vString.begin(), nSize, "") ;
int k = - 1 ;
if ( ! SetVal( KEY_IDS, m_vId, vString[++k]))
return false ;
for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
vString[++k] = m_Params.ToString( i) ;
for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
vString[++k] = m_TParams.ToString( i) ;
if ( ! SetVal( KEY_PHASE, m_nPhase, vString[++k]))
return false ;
if ( ! SetVal( KEY_NUM, m_nMills, vString[++k]))
return false ;
if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k]))
return false ;
}
catch( ...) {
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::Load( const STRVECTOR& vString, int nBaseGdbId)
{
int nSize = int( vString.size()) ;
// lista identificativi geometrie da lavorare
int k = - 1 ;
if ( k >= nSize - 1 || ! GetVal( vString[++k], KEY_IDS, m_vId))
return false ;
for ( auto& Sel : m_vId)
Sel.nId += nBaseGdbId ;
// parametri lavorazione
for ( int i = 0 ; i < m_Params.GetSize() ; ++ i) {
int nKey ;
if ( k >= nSize - 1 || ! m_Params.FromString( vString[++k], nKey) || nKey != i) {
if ( m_Params.IsOptional( i))
-- k ;
else
return false ;
}
}
// parametri utensile
for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) {
int nKey ;
if ( k >= nSize - 1 || ! m_TParams.FromString( vString[++k], nKey) || nKey != i)
return false ;
}
// parametri di stato
while ( k < nSize - 1) {
// separo chiave da valore
string sKey, sVal ;
SplitFirst( vString[++k], "=", sKey, sVal) ;
// leggo
if ( sKey == KEY_PHASE) {
if ( ! FromString( sVal, m_nPhase))
return false ;
}
else if ( sKey == KEY_NUM) {
if ( ! FromString( sVal, m_nMills))
return false ;
}
else if ( sKey == KEY_STAT) {
if ( ! FromString( sVal, m_nStatus))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
Milling::Milling( void)
{
m_Params.m_sName = "*" ;
m_Params.m_sToolName = "*" ;
m_TParams.m_sName = "*" ;
m_TParams.m_sHead = "*" ;
m_dTHoldBase = 0 ;
m_dTHoldLen = 0 ;
m_dTHoldDiam = 0 ;
m_bTHoldFloating = false ;
m_nStatus = MCH_ST_TO_VERIFY ;
m_nMills = 0 ;
m_bStepOn = false ;
m_dAddedOverlap = 0 ;
m_nHeadSolCh = MCH_SCC_NONE ;
m_bTiltingTab = false ;
m_bAboveHead = true ;
m_bAggrBottom = false ;
m_dCurrOscillLen = 0 ;
m_dCurrTabsLen = 0 ;
m_bStartOutRaw = false ;
m_bEndOutRaw = false ;
}
//----------------------------------------------------------------------------
bool
Milling::Prepare( const string& sMillName)
{
// verifico il gestore lavorazioni
if ( m_pMchMgr == nullptr)
return false ;
// recupero il gestore DB utensili della macchina corrente
ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
if ( pTMgr == nullptr)
return false ;
// recupero il gestore DB lavorazioni della macchina corrente
MachiningsMgr* pMMgr = m_pMchMgr->GetCurrMachiningsMgr() ;
if ( pMMgr == nullptr)
return false ;
// ricerca della lavorazione di libreria con il nome indicato
const MillingData* pDdata = GetMillingData( pMMgr->GetMachining( sMillName)) ;
if ( pDdata == nullptr)
return false ;
m_Params = *pDdata ;
// ricerca dell'utensile usato dalla lavorazione
const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
if ( pTdata == nullptr)
return false ;
m_TParams = *pTdata ;
m_Params.m_sToolName = m_TParams.m_sName ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::SetParam( int nType, bool bVal)
{
switch ( nType) {
case MPA_INVERT :
if ( bVal != m_Params.m_bInvert)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_bInvert = bVal ;
return true ;
case MPA_LEAVETAB :
if ( bVal != m_Params.m_bLeaveTab)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_bLeaveTab = bVal ;
return true ;
case MPA_TOOLINVERT :
if ( bVal != m_Params.m_bToolInvert)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_bToolInvert = bVal ;
return true ;
case MPA_OSCENABLE :
if ( bVal != m_Params.m_bOscEnable)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_bOscEnable = bVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::SetParam( int nType, int nVal)
{
switch ( nType) {
case MPA_WORKSIDE :
if ( ! m_Params.VerifyWorkSide( nVal))
return false ;
if ( nVal != m_Params.m_nWorkSide)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nWorkSide = nVal ;
return true ;
case MPA_STEPTYPE :
if ( ! m_Params.VerifyStepType( nVal))
return false ;
if ( nVal != m_Params.m_nStepType)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nStepType = nVal ;
return true ;
case MPA_LEADINTYPE :
if ( ! m_Params.VerifyLeadInType( nVal))
return false ;
if ( nVal != m_Params.m_nLeadInType)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nLeadInType = nVal ;
return true ;
case MPA_LEADOUTTYPE :
if ( ! m_Params.VerifyLeadOutType( nVal))
return false ;
if ( nVal != m_Params.m_nLeadOutType)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nLeadOutType = nVal ;
return true ;
case MPA_TABMIN :
if ( ! m_Params.VerifyTabMin( nVal))
return false ;
if ( nVal != m_Params.m_nTabMin)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nTabMin = nVal ;
return true ;
case MPA_TABMAX :
if ( ! m_Params.VerifyTabMax( nVal))
return false ;
if ( nVal != m_Params.m_nTabMax)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nTabMax = nVal ;
return true ;
case MPA_SCC :
if ( ! m_Params.VerifySolCh( nVal))
return false ;
if ( nVal != m_Params.m_nSolCh)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nSolCh = nVal ;
return true ;
case MPA_FACEUSE :
if ( ! m_Params.VerifyFaceUse( nVal))
return false ;
if ( nVal != m_Params.m_nFaceUse)
m_nStatus |= ( MCH_ST_PARAM_MODIF | MCH_ST_GEO_MODIF) ;
m_Params.m_nFaceUse = nVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::SetParam( int nType, double dVal)
{
switch ( nType) {
case MPA_SPEED :
if ( ! m_TParams.VerifySpeed( dVal))
return false ;
if ( abs( m_TParams.m_dSpeed - dVal) < EPS_MACH_ANG_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dSpeed) > EPS_MACH_ANG_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dSpeed = dVal ;
return true ;
case MPA_FEED :
if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dFeed = dVal ;
return true ;
case MPA_STARTFEED :
if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dStartFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartFeed = dVal ;
return true ;
case MPA_ENDFEED :
if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dEndFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dEndFeed = dVal ;
return true ;
case MPA_TIPFEED :
if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dTipFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dTipFeed = dVal ;
return true ;
case MPA_OFFSR :
if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR)
dVal = UNKNOWN_PAR ;
if ( abs( dVal - m_Params.m_dOffsR) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOffsR = dVal ;
return true ;
case MPA_OFFSL :
if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
dVal = UNKNOWN_PAR ;
if ( abs( dVal - m_Params.m_dOffsL) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOffsL = dVal ;
return true ;
case MPA_DEPTH : {
string sVal = ToString( dVal) ;
if ( sVal != m_Params.m_sDepth)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sDepth = sVal ;
} return true ;
case MPA_STARTPOS :
if ( abs( dVal - m_Params.m_dStartPos) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartPos = dVal ;
return true ;
case MPA_OVERL :
if ( abs( dVal - m_Params.m_dOverlap) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOverlap = dVal ;
return true ;
case MPA_STEP :
if ( abs( dVal - m_Params.m_dStep) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStep = dVal ;
return true ;
case MPA_STARTADDLEN :
if ( abs( dVal - m_Params.m_dStartAddLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartAddLen = dVal ;
return true ;
case MPA_ENDADDLEN :
if ( abs( dVal - m_Params.m_dEndAddLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dEndAddLen = dVal ;
return true ;
case MPA_OSCHEIGHT :
if ( abs( dVal - m_Params.m_dOscHeight) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOscHeight = dVal ;
return true ;
case MPA_OSCRAMPLEN :
if ( abs( dVal - m_Params.m_dOscRampLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOscRampLen = dVal ;
return true ;
case MPA_OSCFLATLEN :
if ( abs( dVal - m_Params.m_dOscFlatLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOscFlatLen = dVal ;
return true ;
case MPA_TABLEN :
if ( abs( dVal - m_Params.m_dTabLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dTabLen = dVal ;
return true ;
case MPA_TABDIST :
if ( abs( dVal - m_Params.m_dTabDist) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dTabDist = dVal ;
return true ;
case MPA_TABHEIGHT :
if ( abs( dVal - m_Params.m_dTabHeight) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dTabHeight = dVal ;
return true ;
case MPA_TABANGLE :
if ( abs( dVal - m_Params.m_dTabAngle) > EPS_MACH_ANG_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dTabAngle = dVal ;
return true ;
case MPA_LITANG :
if ( abs( dVal - m_Params.m_dLiTang) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiTang = dVal ;
return true ;
case MPA_LIPERP :
if ( abs( dVal - m_Params.m_dLiPerp) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiPerp = dVal ;
return true ;
case MPA_LIELEV :
if ( abs( dVal - m_Params.m_dLiElev) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiElev = dVal ;
return true ;
case MPA_LICOMPLEN :
if ( abs( dVal - m_Params.m_dLiCompLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiCompLen = dVal ;
return true ;
case MPA_LOTANG :
if ( abs( dVal - m_Params.m_dLoTang) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoTang = dVal ;
return true ;
case MPA_LOPERP :
if ( abs( dVal - m_Params.m_dLoPerp) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoPerp = dVal ;
return true ;
case MPA_LOELEV :
if ( abs( dVal - m_Params.m_dLoElev) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoElev = dVal ;
return true ;
case MPA_LOCOMPLEN :
if ( abs( dVal - m_Params.m_dLoCompLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoCompLen = dVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::SetParam( int nType, const string& sVal)
{
switch ( nType) {
case MPA_TOOL : {
const ToolData* pTdata ;
if ( ! m_Params.VerifyTool( m_pMchMgr->GetCurrToolsMgr(), sVal, pTdata))
return false ;
if ( ! SameTool( m_TParams, *pTdata))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sToolName = sVal ;
m_Params.m_ToolUuid = pTdata->m_Uuid ;
m_TParams = *pTdata ;
} return true ;
case MPA_DEPTH_STR :
if ( sVal != m_Params.m_sDepth)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sDepth = sVal ;
return true ;
case MPA_SYSNOTES :
if ( sVal != m_Params.m_sSysNotes)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sSysNotes = sVal ;
return true ;
case MPA_USERNOTES :
if ( sVal != m_Params.m_sUserNotes) {
m_nStatus |= MCH_ST_PARAM_MODIF ;
Vector3d vtNew ; GetValInNotes( sVal, UN_VTFACEUSE, vtNew) ;
Vector3d vtOri ; GetValInNotes( m_Params.m_sUserNotes, UN_VTFACEUSE, vtOri) ;
if ( ! AreSameVectorApprox( vtNew, vtOri))
m_nStatus |= MCH_ST_GEO_MODIF ;
INTVECTOR vnNew ; GetValInNotes( sVal, UN_EDGESFACEUSE, vnNew) ;
INTVECTOR vnOri ; GetValInNotes( m_Params.m_sUserNotes, UN_EDGESFACEUSE, vnOri) ;
if ( vnNew != vnOri)
m_nStatus |= MCH_ST_GEO_MODIF ;
}
m_Params.m_sUserNotes = sVal ;
return true ;
case MPA_INITANGS :
if ( sVal != m_Params.m_sInitAngs)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sInitAngs = sVal ;
return true ;
case MPA_BLOCKEDAXIS :
if ( sVal != m_Params.m_sBlockedAxis)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sBlockedAxis = sVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::SetGeometry( const SELVECTOR& vIds)
{
// verifico validità gestore DB geometrico
if ( m_pGeomDB == nullptr)
return false ;
// 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 Milling : Skipped entity " + ToString( Id) ;
m_pMchMgr->SetWarning( 2351, 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
Milling::Preview( bool bRecalc)
{
// reset numero percorsi di lavoro generati
m_nMills = 0 ;
// verifico validità gestore DB geometrico e Id del gruppo
if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
return false ;
// recupero gruppo per geometria ausiliaria
int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ;
bool bChain = false ;
// se non c'è, lo aggiungo
if ( nAuxId == GDB_ID_NULL) {
nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nAuxId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nAuxId, MCH_AUX) ;
m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ;
bChain = true ;
}
// altrimenti, se chiesto ricalcolo, lo svuoto
else if ( bRecalc) {
m_pGeomDB->EmptyGroup( nAuxId) ;
bChain = true ;
}
// aggiorno dati geometrici dell'utensile
if ( ! UpdateToolData()) {
m_pMchMgr->SetLastError( 2301, "Error in Milling : UpdateToolData failed") ;
return false ;
}
m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ;
// aggiorno anche se non necessario, comunque operazione veloce
// rendo corrente l'utensile usato nella lavorazione
if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) {
m_pMchMgr->SetLastError( 2322, "Error in Milling : Tool loading failed") ;
return false ;
}
// recupero i dati del portautensile
int nToolId = m_pMchMgr->GetCalcTool() ;
m_dTHoldBase = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_BASE, m_dTHoldBase) ;
m_dTHoldLen = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_LEN, m_dTHoldLen) ;
m_dTHoldDiam = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_DIAM, m_dTHoldDiam) ;
m_bTHoldFloating = m_pMchMgr->GetCurrMachine()->IsCurrToolFloating() ;
// se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
if ( bChain && ! Chain( nAuxId)) {
m_pMchMgr->SetLastError( 2315, "Error in Milling : Chaining failed") ;
return false ;
}
// recupero gruppo per geometria di Preview
int nPvId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_PV) ;
// se non c'è, lo aggiungo
if ( nPvId == GDB_ID_NULL) {
nPvId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nPvId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nPvId, MCH_PV) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nPvId) ;
// lavoro ogni singola catena
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL) {
if ( ! ProcessPath( nPathId, nPvId, GDB_ID_NULL))
return false ;
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::Apply( bool bRecalc, bool bPostApply)
{
// reset numero percorsi di lavoro generati
int nCurrMills = m_nMills ;
m_nMills = 0 ;
// verifico validità gestore DB geometrico e Id del gruppo
if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
return false ;
// aggiorno dati geometrici dell'utensile
if ( ! UpdateToolData()) {
m_pMchMgr->SetLastError( 2301, "Error in Milling : 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( "Milling 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 ;
}
// recupero gruppo per vista ausiliaria
int nAuxViewId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUXVIEW) ;
// se non c'è, lo aggiungo
if ( nAuxViewId == GDB_ID_NULL) {
nAuxViewId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nAuxViewId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nAuxViewId, MCH_AUXVIEW) ;
m_pGeomDB->SetMaterial( nAuxViewId, Color( 64, 0, 0)) ;
m_pGeomDB->SetStatus( nAuxViewId, GDB_ST_OFF) ;
}
// altrimenti, se necessario chain, lo svuoto
else if ( bChain) {
m_pGeomDB->EmptyGroup( nAuxViewId) ;
}
// rendo corrente l'utensile usato nella lavorazione
if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) {
m_pMchMgr->SetLastError( 2322, "Error in Milling : Tool loading failed") ;
return false ;
}
// recupero i dati del portautensile
int nToolId = m_pMchMgr->GetCalcTool() ;
m_dTHoldBase = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_BASE, m_dTHoldBase) ;
m_dTHoldLen = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_LEN, m_dTHoldLen) ;
m_dTHoldDiam = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_DIAM, m_dTHoldDiam) ;
m_bTHoldFloating = m_pMchMgr->GetCurrMachine()->IsCurrToolFloating() ;
// 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) ;
// elimino eventuale gruppo geometria simmetrica per lavorazione in doppio
int nDblId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_DBL) ;
if ( nDblId != GDB_ID_NULL) {
m_pGeomDB->Erase( nDblId) ;
nDblId = GDB_ID_NULL ;
}
// se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
if ( bChain) {
if ( ! Chain( nAuxId)) {
m_pMchMgr->SetLastError( 2315, "Error in Milling : Chaining failed") ;
return false ;
}
CalcSurfAuxView( nAuxId, nAuxViewId) ;
}
// lavoro ogni singola catena
bool bOk = true ;
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL) {
if ( ! ProcessPath( nPathId, GDB_ID_NULL, nClId))
bOk = false ;
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
if ( ! bOk)
return false ;
// assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
CalcAndSetBBox( nClId) ;
// se lavorazione in doppio, aggiungo geometria della parte simmetrica
if ( ! CalcMirrorByDouble( nClId, m_Params.m_sUserNotes)) {
m_pMchMgr->SetLastError( 2325, "Error in Milling : Mirror for Double calculation failed") ;
return false ;
}
// 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(), "Milling apply done") ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::Update( bool bPostApply)
{
// verifico validità gestore DB geometrico e Id del gruppo
if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
return false ;
// se lavorazione vuota, esco
if ( m_nMills == 0) {
m_pMchMgr->SetWarning( 2352, "Warning in Milling : No machinable path") ;
return true ;
}
// 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( 2317, "Error in Milling : axes values not calculable") ;
else
m_pMchMgr->SetLastError( 2318, "Error in Milling : outstroke ") ;
return false ;
}
// assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
CalcAndSetAxesBBox() ;
// se lavorazione in doppio, calcolo assi e movimenti di approccio e retrazione relativi
if ( GetDoubleType( m_Params.m_sUserNotes) != 0) {
// elimino le entità CLIMB, RISE e HOME della lavorazione in doppio
RemoveClimbRiseHome( false) ;
// recupero i dati della testa in doppio e la imposto
string sDblTool ; string sTcPos; string sDblHead ; int nDblExit ;
bool bOk = GetDoubleToolData( sDblTool, sTcPos, sDblHead, nDblExit) &&
m_pMchMgr->SetCalcTool( sDblTool, sDblHead, nDblExit) ;
// imposto eventuale asse bloccato da lavorazione
SetBlockedRotAxis( m_Params.m_sBlockedAxis, true) ;
// eseguo il calcolo
if ( bOk) {
if ( ! CalculateDoubleAxesValues( sHint)) {
string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
if ( sInfo.empty())
m_pMchMgr->SetLastError( 2317, "Error in Milling : axes values not calculable for double") ;
else
m_pMchMgr->SetLastError( 2318, "Error in Milling : double outstroke ") ;
bOk = false ;
}
}
// ripristino testa principale
m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()) ;
// in caso di errore, esco
if ( ! bOk)
return false ;
}
// esecuzione eventuali personalizzazioni speciali
string sSpecErr ;
if ( bPostApply && ! SpecialApply( sSpecErr)) {
if ( ! IsEmptyOrSpaces( sSpecErr))
m_pMchMgr->SetLastError( 2326, sSpecErr) ;
else
m_pMchMgr->SetLastError( 2326, "Error in Milling : special apply not calculable") ;
return false ;
}
// gestione movimenti all'inizio e fine di ogni singolo percorso di lavorazione
if ( ! AdjustStartEndMovements()) {
string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
if ( sInfo.empty())
m_pMchMgr->SetLastError( 2319, "Error in Milling : link movements not calculable") ;
else
m_pMchMgr->SetLastError( 2320, "Error in Milling : link outstroke ") ;
return false ;
}
// esecuzione eventuali personalizzazioni finali
string sPostErr ;
if ( bPostApply && ! PostApply( sPostErr)) {
if ( ! IsEmptyOrSpaces( sPostErr))
m_pMchMgr->SetLastError( 2321, sPostErr) ;
else
m_pMchMgr->SetLastError( 2321, "Error in Milling : post apply not calculable") ;
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::GetParam( int nType, bool& bVal) const
{
switch ( nType) {
case MPA_INVERT :
bVal = m_Params.m_bInvert ;
return true ;
case MPA_LEAVETAB :
bVal = m_Params.m_bLeaveTab ;
return true ;
case MPA_TOOLINVERT :
bVal = m_Params.m_bToolInvert ;
return true ;
case MPA_OSCENABLE :
bVal = m_Params.m_bOscEnable ;
return true ;
}
bVal = false ;
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::GetParam( int nType, int& nVal) const
{
switch ( nType) {
case MPA_TYPE :
nVal = MT_MILLING ;
return true ;
case MPA_WORKSIDE :
nVal = m_Params.m_nWorkSide ;
return true ;
case MPA_STEPTYPE :
nVal = m_Params.m_nStepType ;
return true ;
case MPA_LEADINTYPE :
nVal = m_Params.m_nLeadInType ;
return true ;
case MPA_LEADOUTTYPE :
nVal = m_Params.m_nLeadOutType ;
return true ;
case MPA_TABMIN :
nVal = m_Params.m_nTabMin ;
return true ;
case MPA_TABMAX :
nVal = m_Params.m_nTabMax ;
return true ;
case MPA_SCC :
nVal = m_Params.m_nSolCh ;
return true ;
case MPA_FACEUSE :
nVal = m_Params.m_nFaceUse ;
return true ;
}
nVal = 0 ;
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::GetParam( int nType, double& dVal) const
{
switch ( nType) {
case MPA_SPEED :
dVal = GetSpeed() ;
return true ;
case MPA_FEED :
dVal = GetFeed() ;
return true ;
case MPA_STARTFEED :
dVal = GetStartFeed() ;
return true ;
case MPA_ENDFEED :
dVal = GetEndFeed() ;
return true ;
case MPA_TIPFEED :
dVal = GetTipFeed() ;
return true ;
case MPA_OFFSR :
dVal = GetOffsR() ;
return true ;
case MPA_OFFSL :
dVal = GetOffsL() ;
return true ;
case MPA_STARTPOS :
dVal = m_Params.m_dStartPos ;
return true ;
case MPA_OVERL :
dVal = m_Params.m_dOverlap ;
return true ;
case MPA_STEP :
dVal = m_Params.m_dStep ;
return true ;
case MPA_STARTADDLEN :
dVal = m_Params.m_dStartAddLen ;
return true ;
case MPA_ENDADDLEN :
dVal = m_Params.m_dEndAddLen ;
return true ;
case MPA_OSCHEIGHT :
dVal = m_Params.m_dOscHeight ;
return true ;
case MPA_OSCRAMPLEN :
dVal = m_Params.m_dOscRampLen ;
return true ;
case MPA_OSCFLATLEN :
dVal = m_Params.m_dOscFlatLen ;
return true ;
case MPA_TABLEN :
dVal = m_Params.m_dTabLen ;
return true ;
case MPA_TABDIST :
dVal = m_Params.m_dTabDist ;
return true ;
case MPA_TABHEIGHT :
dVal = m_Params.m_dTabHeight ;
return true ;
case MPA_TABANGLE :
dVal = m_Params.m_dTabAngle ;
return true ;
case MPA_LITANG :
dVal = m_Params.m_dLiTang ;
return true ;
case MPA_LIPERP :
dVal = m_Params.m_dLiPerp ;
return true ;
case MPA_LIELEV :
dVal = m_Params.m_dLiElev ;
return true ;
case MPA_LICOMPLEN :
dVal = m_Params.m_dLiCompLen ;
return true ;
case MPA_LOTANG :
dVal = m_Params.m_dLoTang ;
return true ;
case MPA_LOPERP :
dVal = m_Params.m_dLoPerp ;
return true ;
case MPA_LOELEV :
dVal = m_Params.m_dLoElev ;
return true ;
case MPA_LOCOMPLEN :
dVal = m_Params.m_dLoCompLen ;
return true ;
}
dVal = 0 ;
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::GetParam( int nType, string& sVal) const
{
switch ( nType) {
case MPA_NAME :
sVal = m_Params.m_sName ;
return true ;
case MPA_TOOL :
sVal = m_Params.m_sToolName ;
return true ;
case MPA_DEPTH_STR :
sVal = m_Params.m_sDepth ;
return true ;
case MPA_TUUID :
sVal = ToString( m_Params.m_ToolUuid) ;
return true ;
case MPA_UUID :
sVal = ToString( m_Params.m_Uuid) ;
return true ;
case MPA_SYSNOTES :
sVal = m_Params.m_sSysNotes ;
return true ;
case MPA_USERNOTES :
sVal = m_Params.m_sUserNotes ;
return true ;
case MPA_INITANGS :
sVal = m_Params.m_sInitAngs ;
return true ;
case MPA_BLOCKEDAXIS :
sVal = m_Params.m_sBlockedAxis ;
return true ;
}
sVal = "" ;
return false ;
}
//----------------------------------------------------------------------------
const ToolData&
Milling::GetToolData( void) const
{
return m_TParams ;
}
//----------------------------------------------------------------------------
bool
Milling::UpdateToolData( 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 Milling : tool name changed (" +
m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
m_pMchMgr->SetWarning( 2353, sInfo) ;
m_Params.m_sToolName = m_TParams.m_sName ;
}
if ( bChanged) {
string sInfo = "Warning in Milling : tool data changed (" +
m_Params.m_sToolName + ")" ;
m_pMchMgr->SetWarning( 2354, sInfo) ;
}
// se modificato, aggiusto lo stato
if ( bChanged)
m_nStatus = MCH_ST_TO_VERIFY ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::GetGeometry( SELVECTOR& vIds) const
{
// restituisco l'elenco delle entità
vIds = m_vId ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::VerifyGeometry( SelData Id, int& nSubs, int& nType)
{
// ammessi : curve, testi, facce di trimesh o regioni
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
if ( pGObj == nullptr)
return false ;
// se ammesse curve ed è tale
if ( ( nType == GEO_NONE || nType == GEO_CURVE) && ( pGObj->GetType() & GEO_CURVE) != 0) {
nType = GEO_CURVE ;
const ICurve* pCurve = nullptr ;
// se direttamente la curva
if ( Id.nSub == SEL_SUB_ALL) {
pCurve = ::GetCurve( pGObj) ;
if ( pCurve == nullptr)
return false ;
if ( pCurve->GetType() == CRV_COMPO)
nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
else
nSubs = 0 ;
}
// altrimenti sottocurva di composita
else {
const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
pCurve = ( pCompo != nullptr ? pCompo->GetCurve( Id.nSub) : nullptr) ;
if ( pCurve == nullptr)
return false ;
nSubs = 0 ;
}
return true ;
}
// se altrimenti ammessi testi ed è tale
else if ( ( nType == GEO_NONE || nType == EXT_TEXT) && pGObj->GetType() == EXT_TEXT) {
nType = EXT_TEXT ;
const IExtText* pText = ::GetExtText( pGObj) ;
if ( pText == nullptr)
return false ;
// tutto bene
nSubs = 0 ;
return true ;
}
// se altrimenti ammesse superfici trimesh ed è tale
else if ( ( nType == GEO_NONE || nType == GEO_SURF) && pGObj->GetType() == SRF_TRIMESH) {
nType = GEO_SURF ;
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
if ( pSurf == nullptr)
return false ;
// se direttamente la superficie
if ( Id.nSub == SEL_SUB_ALL) {
// deve avere una sola faccia
if ( pSurf->GetFacetCount() != 1)
return false ;
nSubs = 1 ;
}
// altrimenti faccia di superficie trimesh
else {
// se faccia non esistente
if ( Id.nSub > pSurf->GetFacetCount())
return false ;
nSubs = 0 ;
}
return true ;
}
// se altrimenti ammesse regioni ed è tale
else if ( ( nType == GEO_NONE || nType == GEO_SURF) && pGObj->GetType() == SRF_FLATRGN) {
nType = GEO_SURF ;
const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
if ( pReg == nullptr)
return false ;
// se direttamente la regione
if ( Id.nSub == SEL_SUB_ALL) {
nSubs = pReg->GetChunkCount() ;
}
// altrimenti chunk di regione
else {
// se chunk non esistente
if ( Id.nSub >= pReg->GetChunkCount())
return false ;
// tutto bene
nSubs = 0 ;
}
return true ;
}
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC)
{
// ammessi : curve, testi, facce di trimesh o regioni
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
if ( pGObj == nullptr)
return false ;
// ne recupero il riferimento globale
Frame3d frGlob ;
if ( ! m_pGeomDB->GetGlobFrame( Id.nId, frGlob))
return false ;
// se curva
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
PtrOwner<ICurve> pCurve ;
// se direttamente curva
if ( Id.nSub == SEL_SUB_ALL) {
// recupero la curva
const ICurve* pOriCurve = ::GetCurve( pGObj) ;
if ( pOriCurve == nullptr)
return false ;
// la duplico
pCurve.Set( pOriCurve->Clone()) ;
if ( IsNull( pCurve))
return false ;
// se estrusione mancante, imposto default
Vector3d vtExtr ;
if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall())
pCurve->SetExtrusion( Z_AX) ;
}
// altrimenti sottocurva di composita
else {
// recupero la composita
const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
if ( pCompo == nullptr)
return false ;
// recupero la curva semplice
const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ;
if ( pOriCurve == nullptr)
return false ;
// la duplico
pCurve.Set( pOriCurve->Clone()) ;
if ( IsNull( pCurve))
return false ;
// recupero estrusione e spessore
Vector3d vtExtr ;
if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall())
vtExtr = Z_AX ;
pCurve->SetExtrusion( vtExtr) ;
double dThick ;
if ( pCompo->GetThickness( dThick))
pCurve->SetThickness( dThick) ;
}
// la porto in globale
pCurve->ToGlob( frGlob) ;
// la restituisco
lstPC.emplace_back( Release( pCurve)) ;
return true ;
}
// se altrimenti testo
else if ( pGObj->GetType() == EXT_TEXT) {
// recupero il testo
const IExtText* pText = ::GetExtText( pGObj) ;
if ( pText == nullptr)
return false ;
// recupero l'outline del testo
if ( ! pText->GetOutline( lstPC))
return false ;
// porto le curve in globale
for ( auto pCrv : lstPC)
pCrv->ToGlob( frGlob) ;
// ritorno
return true ;
}
// se altrimenti superficie trimesh
else if ( pGObj->GetType() == SRF_TRIMESH) {
// recupero la trimesh
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
if ( pSurf == nullptr)
return false ;
// recupero l'indice della faccia
int nFacet = ( ( Id.nSub == SEL_SUB_ALL) ? 0 : Id.nSub) ;
// recupero i contorni della faccia
POLYLINEVECTOR vPL ;
pSurf->GetFacetLoops( nFacet, vPL) ;
if ( vPL.empty())
return false ;
// creo la curva a partire da quello esterno
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
pCrvCompo->FromPolyLine( vPL[0]) ;
if ( ! pCrvCompo->IsValid())
return false ;
// recupero la normale esterna della faccia
Vector3d vtN ;
if ( ! pSurf->GetFacetNormal( nFacet, vtN))
return false ;
// assegno l'estrusione dalla normale alla faccia
pCrvCompo->SetExtrusion( vtN) ;
// unisco le eventuali parti allineate
pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
// la porto in globale
pCrvCompo->ToGlob( frGlob) ;
// sistemazioni varie
int nToolDir ;
if ( ( m_Params.m_nFaceUse & 64) != 0)
nToolDir = TOOL_ORTUP ;
else if ( ( m_Params.m_nFaceUse & 32) != 0)
nToolDir = TOOL_ORTHO ;
else
nToolDir = TOOL_PARAL ;
int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
Vector3d vtFaceUse ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTFACEUSE, vtFaceUse) && ! vtFaceUse.IsSmall())
nFaceUse = FACE_VERSOR ;
INTVECTOR vnEdgesFaceUse ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_EDGESFACEUSE, vnEdgesFaceUse) && ! vnEdgesFaceUse.empty())
nFaceUse = FACE_EDGES ;
double dSawThick = ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ? m_TParams.m_dThick : 0) ;
if ( ! AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, vtFaceUse, vnEdgesFaceUse, dSawThick))
return false ;
// la restituisco
lstPC.emplace_back( Release( pCrvCompo)) ;
return true ;
}
// se altrimenti regione
else if ( pGObj->GetType() == SRF_FLATRGN) {
// recupero la regione
const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
if ( pReg == nullptr)
return false ;
// recupero la normale della regione
Vector3d vtN = pReg->GetNormVersor() ;
if ( vtN.IsSmall())
return false ;
// sistemazioni varie
int nToolDir ;
if ( ( m_Params.m_nFaceUse & 64) != 0)
nToolDir = TOOL_ORTUP ;
else if ( ( m_Params.m_nFaceUse & 32) != 0)
nToolDir = TOOL_ORTHO ;
else
nToolDir = TOOL_PARAL ;
int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
Vector3d vtFaceUse ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTFACEUSE, vtFaceUse) && ! vtFaceUse.IsSmall())
nFaceUse = FACE_VERSOR ;
INTVECTOR vnEdgesFaceUse ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_EDGESFACEUSE, vnEdgesFaceUse) && ! vnEdgesFaceUse.empty())
nFaceUse = FACE_EDGES ;
double dSawThick = ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ? m_TParams.m_dThick : 0) ;
// determino intervallo di chunk
int nCstart = 0 ;
int nCend = pReg->GetChunkCount() ;
if ( Id.nSub != SEL_SUB_ALL) {
nCstart = Id.nSub ;
nCend = nCstart + 1 ;
}
else if ( nFaceUse == FACE_EDGES) {
nCstart = 0 ;
nCend = nCstart + 1 ;
}
// ciclo sui chunk
for ( int nC = nCstart ; nC < nCend ; ++ nC) {
// recupero i contorni del chunk
for ( int nL = 0 ; nL < pReg->GetLoopCount( nC) ; ++ nL) {
PtrOwner<ICurveComposite> pCrvCompo ;
if ( ! pCrvCompo.Set( ConvertCurveToComposite( pReg->GetLoop( nC, nL))))
return false ;
// assegno l'estrusione dalla normale alla regione
pCrvCompo->SetExtrusion( vtN) ;
// unisco le eventuali parti allineate
pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
// la porto in globale
pCrvCompo->ToGlob( frGlob) ;
// sistemazioni varie
if ( ! AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, vtFaceUse, vnEdgesFaceUse, dSawThick))
return false ;
// la restituisco
lstPC.emplace_back( Release( pCrvCompo)) ;
}
}
return true ;
}
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::Chain( int nGrpDestId)
{
// vettore puntatori alle curve
ICURVEPOVECTOR vpCrvs ;
vpCrvs.reserve( m_vId.size()) ;
// vettore selettori delle curve originali
SELVECTOR vInds ;
vInds.reserve( m_vId.size()) ;
// recupero tutte le curve e le porto in globale
for ( const auto& Id : m_vId) {
// prendo le curve
ICURVEPLIST lstPC ;
if ( ! GetCurves( Id, lstPC)) {
string sInfo = "Warning in Milling : Skipped entity " + ToString( Id) ;
m_pMchMgr->SetWarning( 2351, sInfo) ;
}
for ( auto pCrv : lstPC) {
vpCrvs.emplace_back( pCrv) ;
vInds.emplace_back( Id) ;
}
}
// preparo i dati per il concatenamento
bool bFirst = true ;
Point3d ptNear = ORIG ;
double dToler = 10 * EPS_SMALL ;
ChainCurves chainC ;
chainC.Init( true, dToler, int( vpCrvs.size())) ;
for ( size_t i = 0 ; i < vpCrvs.size() ; ++ i) {
// recupero la curva e il suo riferimento
ICurve* pCrv = vpCrvs[i] ;
if ( pCrv == nullptr)
continue ;
// recupero i dati della curva necessari al concatenamento e li assegno
Point3d ptStart, ptEnd ;
Vector3d vtStart, vtEnd ;
if ( ! pCrv->GetStartPoint( ptStart) || ! pCrv->GetStartDir( vtStart) ||
! pCrv->GetEndPoint( ptEnd) || ! pCrv->GetEndDir( vtEnd))
return false ;
if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd))
return false ;
// se prima curva, assegno inizio della ricerca
if ( bFirst) {
ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
bFirst = false ;
}
}
// recupero i percorsi concatenati
int nCount = 0 ;
INTVECTOR vnId2 ;
while ( chainC.GetChainFromNear( ptNear, false, vnId2)) {
// creo una curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// estrusione e spessore
Vector3d vtExtr = Z_AX ;
double dThick = 0 ;
// vettore Id originali
SELVECTOR vId2 ;
vId2.reserve( vnId2.size()) ;
// recupero le curve semplici e le inserisco nella curva composita
for ( size_t i = 0 ; i < vnId2.size() ; ++ i) {
int nId = abs( vnId2[i]) - 1 ;
bool bInvert = ( vnId2[i] < 0) ;
vId2.emplace_back( vInds[nId]) ;
// recupero la curva
ICurve* pCrv = vpCrvs[nId] ;
// se necessario, la inverto
if ( bInvert)
pCrv->Invert() ;
// recupero eventuali estrusione e spessore
Vector3d vtTemp ;
if ( pCrv->GetExtrusion( vtTemp)) {
vtExtr = vtTemp ;
double dTemp ;
if ( pCrv->GetThickness( dTemp) && abs( dTemp) > abs( dThick))
dThick = dTemp ;
}
// la aggiungo alla curva composta
if ( ! pCrvCompo->AddCurve( ::Release( vpCrvs[nId]), true, dToler))
return false ;
}
// se non sono state inserite curve, vado oltre
if ( pCrvCompo->GetCurveCount() == 0)
continue ;
// imposto estrusione e spessore
pCrvCompo->SetExtrusion( vtExtr) ;
pCrvCompo->SetThickness( dThick) ;
// aggiorno il nuovo punto vicino
pCrvCompo->GetEndPoint( ptNear) ;
// se utile, approssimo con archi
if ( ! ApproxWithArcsIfUseful( pCrvCompo))
return false ;
// creo nuovo gruppo
int nPathId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpDestId, Frame3d()) ;
if ( nPathId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nPathId, MCH_PATH + ToString( ++ nCount)) ;
m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( vId2)) ;
// inserisco la curva composita nel gruppo destinazione
int nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::Release( pCrvCompo)) ;
if ( nNewId == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const
{
// se utensile lama
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
// traslazione opposta a quanto fatto in AdjustPathDrawForSaw
double dOffset = 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ;
ptP.Translate( dOffset * pCamData->GetCorrDir()) ;
}
// negli altri casi, non devo fare alcunché
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AdjustArcCenterForAxesCalc( const CamData* pCamData, Point3d& ptCen) const
{
// se utensile lama
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
// recupero il precedente movimento
int nPrevId = m_pGeomDB->GetPrev( pCamData->GetOwner()) ;
CamData* pPrevCamData = GetCamData( m_pGeomDB->GetUserObj( nPrevId)) ;
if ( pPrevCamData == nullptr)
return false ;
// se versori correzione uguali, correggo il centro
if ( AreSameVectorApprox( pCamData->GetCorrDir(), pPrevCamData->GetCorrDir())) {
// traslazione opposta a quanto fatto in AdjustPathDrawForSaw
double dOffset = 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ;
ptCen.Translate( dOffset * pCamData->GetCorrDir()) ;
}
}
// negli altri casi, non devo fare alcunché
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcSurfAuxView( int nAuxId, int nAuxViewId)
{
const double FAT_RAD = 0.5 ;
if ( m_Params.m_nFaceUse != MILL_FU_NONE) {
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL) {
int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
const ICurve* pCrv = ::GetCurve( m_pGeomDB->GetGeoObj( nCrvId)) ;
if ( pCrv != nullptr) {
ISurfFlatRegion* pSfr = GetSurfFlatRegionFromFatCurve( pCrv->Clone(), FAT_RAD, false, false) ;
if ( pSfr != nullptr) {
int nSfrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nAuxViewId, pSfr) ;
}
}
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::ProcessPath( int nPathId, int nPvId, int nClId)
{
// recupero gruppo per geometria temporanea
const string GRP_TEMP = "Temp" ;
int nTempId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, GRP_TEMP) ;
// se non c'è, lo aggiungo
if ( nTempId == GDB_ID_NULL) {
nTempId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nTempId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nTempId, GRP_TEMP) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nTempId) ;
// in ogni caso lo dichiaro temporaneo e non visibile
m_pGeomDB->SetLevel( nTempId, GDB_LV_TEMP) ;
m_pGeomDB->SetStatus( nTempId, GDB_ST_OFF) ;
// copio la curva composita da elaborare
int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
if ( m_pGeomDB->GetGeoType( nCrvId) != CRV_COMPO)
return false ;
int nCopyId = m_pGeomDB->CopyGlob( nCrvId, GDB_ID_NULL, nTempId) ;
if ( nCopyId == GDB_ID_NULL)
return false ;
ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( nCopyId)) ;
// converto in archi e rette
pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ;
// eventuale inversione percorso
if ( m_Params.m_bInvert)
pCompo->Invert() ;
// recupero direzione utensile da estrusione e spessore
Vector3d vtTool ;
pCompo->GetExtrusion( vtTool) ;
if ( vtTool.IsSmall())
vtTool = Z_AX ;
double dThick ;
pCompo->GetThickness( dThick) ;
// eventuale inversione direzione utensile
if ( m_Params.m_bToolInvert) {
vtTool.Invert() ;
pCompo->SetExtrusion( vtTool) ;
dThick = - dThick ;
pCompo->SetThickness( dThick) ;
}
// se percorso chiuso con inizio/fine su angolo interno, porto la partenza a metà del primo lato
if ( pCompo->IsClosed()) {
Vector3d vtStart, vtEnd ;
pCompo->GetStartDir( vtStart) ;
pCompo->GetEndDir( vtEnd) ;
if ( ! AreSameOrOppositeVectorApprox( vtStart, vtEnd)) {
bool bAngCCW = ( ( vtEnd ^ vtStart) * vtTool > 0.0) ;
if ( m_Params.m_dOverlap > EPS_SMALL ||
m_Params.m_nWorkSide == MILL_WS_CENTER ||
( m_Params.m_nWorkSide == MILL_WS_RIGHT && ! bAngCCW) ||
( m_Params.m_nWorkSide == MILL_WS_LEFT && bAngCCW))
pCompo->ChangeStartPoint( 0.5) ;
}
}
// eventuali allungamenti/accorciamenti per percorso aperto o chiuso senza sovrapposizione
if ( ! pCompo->IsClosed() || m_Params.m_dOverlap < EPS_SMALL) {
// verifico che il percorso sia abbastanza lungo
double dLen ; pCompo->GetLength( dLen) ;
if ( dLen + m_Params.m_dStartAddLen + m_Params.m_dEndAddLen < 10 * EPS_SMALL) {
m_pMchMgr->SetWarning( 2355, "Warning in Milling : skipped Path too short") ;
return true ;
}
// se una sola entità circonferenza completa, la divido in due per poterla allungare
if ( pCompo->GetCurveCount() == 1 && pCompo->IsClosed())
pCompo->AddJoint( 0.5) ;
// eventuali allungamenti
if ( m_Params.m_dStartAddLen > EPS_SMALL) {
if ( ! pCompo->ExtendStartByLen( m_Params.m_dStartAddLen))
return false ;
dLen += m_Params.m_dStartAddLen ;
}
if ( m_Params.m_dEndAddLen > EPS_SMALL) {
if ( ! pCompo->ExtendEndByLen( m_Params.m_dEndAddLen))
return false ;
dLen += m_Params.m_dEndAddLen ;
}
// eventuale accorciamenti (da fare dopo tutti gli allungamenti)
if ( m_Params.m_dStartAddLen < - EPS_SMALL) {
if ( ! pCompo->TrimStartAtLen( - m_Params.m_dStartAddLen))
return false ;
dLen += m_Params.m_dStartAddLen ;
}
if ( m_Params.m_dEndAddLen < - EPS_SMALL) {
if ( ! pCompo->TrimEndAtLen( dLen + m_Params.m_dEndAddLen))
return false ;
dLen += m_Params.m_dEndAddLen ;
}
}
// eventuale spostamento inizio per percorso chiuso con sovrapposizione
if ( pCompo->IsClosed() && m_Params.m_dOverlap > EPS_SMALL && abs( m_Params.m_dStartAddLen) > EPS_SMALL) {
double dPos = -m_Params.m_dStartAddLen ;
if ( dPos < 0) {
double dLen ;
pCompo->GetLength( dLen) ;
dPos += dLen ;
}
double dPar ;
if ( pCompo->GetParamAtLength( dPos, dPar))
pCompo->ChangeStartPoint( dPar) ;
}
// salvo direzioni iniziale e finale del percorso prima di eventuale offset
pCompo->GetStartDir( m_vtStartDir) ;
pCompo->GetEndDir( m_vtEndDir) ;
// se utensile non centrato, eseguo correzione raggio utensile ed eventuale offset
double dOffs = 0.5 * m_TParams.m_dDiam + GetOffsR() ;
if ( m_Params.m_nWorkSide != MILL_WS_CENTER && abs( dOffs) > EPS_SMALL) {
// valore offset
double dSignOffs = ( m_Params.m_nWorkSide == MILL_WS_RIGHT) ? dOffs : - dOffs ;
// esecuzione offset
if ( ! CalcOffset( pCompo, dSignOffs)) {
m_pMchMgr->SetLastError( 2302, "Error in Milling : Offset not computable") ;
return false ;
}
}
// eventuale sovrapposizione per percorso chiuso
m_dAddedOverlap = 0 ;
if ( pCompo->IsClosed() && m_Params.m_dOverlap > EPS_SMALL) {
double dParS, dParE ;
if ( pCompo->GetParamAtLength( 0.0, dParS) &&
pCompo->GetParamAtLength( m_Params.m_dOverlap, dParE)) {
PtrOwner<ICurve> pCrv( pCompo->CopyParamRange( dParS, dParE)) ;
if ( ! IsNull( pCrv)) {
pCompo->AddCurve( Release( pCrv)) ;
m_dAddedOverlap = m_Params.m_dOverlap ;
}
}
}
// unisco le parti allineate (tranne inizio-fine se chiusa)
if ( ! pCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false))
return false ;
// flags per tabs e oscillazione del percorso corrente (se entrambi, solo tabs)
bool bPathTabsEnable = m_Params.m_bLeaveTab ;
bool bPathOscEnable = ( ! bPathTabsEnable && m_Params.m_bOscEnable) ;
// se utensile lama, disabilito eventuali tabs o oscillazione
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
if ( bPathTabsEnable) {
bPathTabsEnable = false ;
m_pMchMgr->SetWarning( 2362, "Warning in Milling : tabs incompatible with saw blade") ;
}
if ( bPathOscEnable) {
bPathOscEnable = false ;
m_pMchMgr->SetWarning( 2359, "Warning in Milling : oscillation incompatible with saw blade") ;
}
}
// recupero i punti di inizio e fine (per poi salvarli nelle info di CL path)
Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ;
// recupero il box del grezzo in globale
BBox3d b3Raw ;
if ( ! GetRawGlobBox( m_nPhase, nPathId, 0.5 * m_TParams.m_dTDiam, b3Raw) || b3Raw.IsEmpty()) {
m_pMchMgr->SetLastError( 2303, "Error in Milling : Empty RawBox") ;
return false ;
}
// recupero distanza da fondo dei grezzi interessati dal percorso
double dRbDist = 0 ;
if ( AreSameVectorApprox( vtTool, Z_AX)) {
if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, m_TParams.m_dTDiam, dRbDist))
return false ;
}
// valuto l'espressione dell'affondamento
ExeLuaSetGlobNumVar( "TH", abs( dThick)) ;
ExeLuaSetGlobNumVar( "RB", dRbDist) ;
double dDepth ;
string sMyDepth = m_Params.m_sDepth ;
if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) {
m_pMchMgr->SetLastError( 2304, "Error in Milling : Depth not computable") ;
return false ;
}
// se spessore positivo, lo sottraggo dal risultato
if ( dThick > 0)
dDepth -= dThick ;
// sottraggo eventuale offset longitudinale
dDepth -= GetOffsL() ;
// recupero nome del path
string sPathName ;
m_pGeomDB->GetName( nPathId, sPathName) ;
// eventuale approssimazione con segmenti di retta
bool bSplitArcs = GetSplitArcs( vtTool) ;
if ( bSplitArcs) {
if ( ! ApproxWithLines( pCompo)) {
m_pMchMgr->SetLastError( 2313, "Error in Milling : Linear Approx not computable") ;
return false ;
}
}
// verifiche sull'ampiezza dell'angolo al centro degli eventuali archi
VerifyArcs( pCompo) ;
// calcolo l'elevazione massima
double dElev ;
if ( CalcPathElevation( pCompo, vtTool, dDepth, 0.5 * m_TParams.m_dDiam, dElev)) {
if ( dElev < EPS_SMALL && AreSameVectorApprox( vtTool, Z_AX)) {
BBox3d b3Crv ;
pCompo->GetLocalBBox( b3Crv) ;
dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z + min( 0., dThick) + dDepth) ;
}
}
else
return false ;
// eventuale imposizione massima elevazione da note utente
double dMaxElev ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev) && dElev > dMaxElev)
dElev = dMaxElev ;
// eventuale aggiuntivo all'elevazione per l'oscillazione
double dAddElev = ( bPathOscEnable ? abs( m_Params.m_dOscHeight) : 0) ;
// eventuale elevazione di fianco (solo per lama)
double dSideElev = 0 ;
GetValInNotes( m_Params.m_sUserNotes, UN_SIDEELEV, dSideElev) ;
// verifico che lo step dell'utensile sia sensato
double dOkStep = 0 ;
bool bStepUp = false ;
if ( m_bTHoldFloating)
dOkStep = 0 ;
else if ( m_Params.m_dStep > EPS_SMALL)
dOkStep = m_Params.m_dStep + EPS_ZERO ;
else if ( m_Params.m_dStep < -EPS_SMALL &&
( m_TParams.m_nType == TT_MILL_NOTIP ||
( ( m_TParams.m_nType & TF_SAWBLADE) != 0 && abs( dSideElev) < 10 * EPS_SMALL))) {
dOkStep = abs( m_Params.m_dStep) + EPS_ZERO ;
bStepUp = true ;
}
const double MIN_ZSTEP = ( m_TParams.m_nType != TT_MILL_POLISHING ? 0.1 : EPS_SMALL) ;
if ( dOkStep >= EPS_SMALL && dOkStep < MIN_ZSTEP) {
dOkStep = MIN_ZSTEP + EPS_ZERO ;
string sInfo = "Warning in Milling : machining step too small (" +
ToString( m_Params.m_dStep, 2) + ")" ;
m_pMchMgr->SetWarning( 2356, sInfo) ;
}
// verifico che il massimo materiale dell'utensile sia sensato
const double MIN_MAXMAT = 1.0 ;
if ( m_TParams.m_dMaxMat < dElev && m_TParams.m_dMaxMat < MIN_MAXMAT) {
string sInfo = "Error in Milling : Tool MaxMaterial too small (" +
ToString( m_TParams.m_dMaxMat, 2) + ")" ;
m_pMchMgr->SetLastError( 2316, sInfo) ;
return false ;
}
// per frese normali, verifico di non superare il massimo materiale con possibilità di aggiustare
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// se lo step supera la capacità dell'utensile
if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) {
dOkStep = m_TParams.m_dMaxMat + EPS_SMALL ;
string sInfo = "Warning in Milling : machining step (" + ToString( m_Params.m_dStep, 1) +
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetWarning( 2357, sInfo) ;
}
// se lavorazione singola
if ( dOkStep < EPS_SMALL || dOkStep > dElev + dAddElev) {
// se c'è oscillazione e l'elevazione complessiva supera la capacità dell'utensile, annullo l'oscillazione
if ( bPathOscEnable && dElev + dAddElev > m_TParams.m_dMaxMat + EPS_SMALL) {
bPathOscEnable = false ;
dAddElev = 0 ;
m_pMchMgr->SetWarning( 2360, "Warning in Milling : oscillation incompatible with depth") ;
}
// se l'elevazione supera la capacità dell'utensile
if ( dElev > m_TParams.m_dMaxMat + EPS_SMALL) {
// segnalo, riduco e continuo
string sInfo = "Warning in Milling : machining depth (" + ToString( dElev, 1) +
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetWarning( 2358, sInfo) ;
dDepth -= dElev - m_TParams.m_dMaxMat ;
dElev = m_TParams.m_dMaxMat ;
}
}
// altrimenti lavorazione a step
else {
// massimo affondamento dell'utensile
double dSafe = GetMaxDepthSafe() ;
double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? m_dTHoldBase : m_dTHoldLen) - dSafe ;
// se c'è oscillazione e l'elevazione complessiva supera la capacità dell'utensile, annullo l'oscillazione
if ( bPathOscEnable && dElev + dAddElev > dMaxDepth + EPS_SMALL) {
bPathOscEnable = false ;
dAddElev = 0 ;
m_pMchMgr->SetWarning( 2360, "Warning in Milling : oscillation incompatible with depth") ;
}
// se l'elevazione supera il massimo affondamento dell'utensile
if ( dElev > dMaxDepth + EPS_SMALL) {
// segnalo, riduco e continuo
string sInfo = "Warning in Milling : machining depth (" + ToString( dElev, 1) +
") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
m_pMchMgr->SetWarning( 2358, sInfo) ;
dDepth -= dElev - dMaxDepth ;
dElev = dMaxDepth ;
}
}
}
// per lame e con elevazione di lato definita
else if ( abs( dSideElev) > EPS_SMALL) {
// caso standard
if ( dSideElev > 0) {
// se l'elevazione di lato supera la capacità dell'utensile
if ( dSideElev > m_TParams.m_dMaxMat + EPS_SMALL) {
string sInfo = "Error in Milling : machining depth (" + ToString( dSideElev, 1) +
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetLastError( 2305, sInfo) ;
return false ;
}
}
// per tagli a cubetti (ciascuno step di taglio cade)
else {
// se lo step supera la capacità dell'utensile
if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) {
string sInfo = "Error in Milling : machining step (" + ToString( m_Params.m_dStep, 1) +
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetLastError( 2306, sInfo) ;
return false ;
}
dSideElev = abs( dSideElev) ;
}
}
// verifico se tavola basculante
bool bTiltTab = false ;
m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab, m_vtTiltingAx) && bTiltTab) ;
// verifico se testa da sopra (Z+)
m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ;
// verifiche per fresatura dal basso
m_bAggrBottom = false ;
if ( ! VerifyPathFromBottom( pCompo, vtTool))
return false ;
// recupero eventuale flag di inizio forzato fuori dal grezzo
int nStartOutRaw = 0 ;
GetValInNotes( m_Params.m_sUserNotes, UN_OUTRAW, nStartOutRaw) ;
m_bStartOutRaw = (( nStartOutRaw & 1) != 0) ;
m_bEndOutRaw = (( nStartOutRaw & 2) != 0) ;
// 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, dElev) ;
// creo l'anteprima del percorso
if ( ! GenerateMillingPv( nPxId, pCompo, dRbDist, dDepth))
return false ;
}
// se richiesta lavorazione
if ( nClId != GDB_ID_NULL) {
// creo gruppo per geometria di lavorazione del percorso
int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ;
if ( nPxId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nPxId, sPathName) ;
m_pGeomDB->SetMaterial( nPxId, BLUE) ;
// assegno il vettore estrazione al gruppo del percorso
m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ;
// assegno i punti di inizio e fine al gruppo del percorso
m_pGeomDB->SetInfo( nPxId, KEY_START, ptStart) ;
m_pGeomDB->SetInfo( nPxId, KEY_END, ptEnd) ;
// assegno l'elevazione massima
m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;
// Imposto dati comuni
SetPathId( nPxId) ;
SetToolDir( vtTool) ;
// Controlli per lama (non deve fare movimenti assiali nel pezzo)
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
// Non ammesse passate a spirale
if ( m_Params.m_nStepType == MILL_ST_SPIRAL)
m_Params.m_nStepType = MILL_ST_ZIGZAG ;
// Non ammessa elevazione in attacco e uscita
m_Params.m_dLiElev = 0 ;
m_Params.m_dLoElev = 0 ;
}
// Controlli per fresa che non lavora di punta (non deve fare movimenti assiali nel pezzo)
if ( m_TParams.m_nType == TT_MILL_NOTIP) {
// Non ammesse passate a spirale
if ( m_Params.m_nStepType == MILL_ST_SPIRAL)
m_Params.m_nStepType = MILL_ST_ZIGZAG ;
// Ammessa elevazione in attacco e uscita
}
bool bOk = false ;
// Se lama con elevazione e step di fianco
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 && dSideElev > 10 * EPS_SMALL && dOkStep > EPS_SMALL) {
m_bStepOn = true ;
if ( m_Params.m_nStepType != MILL_ST_ONEWAY)
bOk = AddSawZigZagMilling( pCompo, vtTool, dDepth, dSideElev, dOkStep, bSplitArcs) ;
else
bOk = AddSawOneWayMilling( pCompo, vtTool, dDepth, dSideElev, dOkStep, bSplitArcs) ;
}
// se altrimenti una sola passata
else if ( dOkStep < EPS_SMALL || dOkStep > dElev) {
m_bStepOn = false ;
bOk = AddStandardMilling( pCompo, vtTool, dDepth, dElev, bSplitArcs, bPathTabsEnable, bPathOscEnable) ;
}
// se altrimenti passate a zig-zag
else if ( m_Params.m_nStepType == MILL_ST_ZIGZAG) {
m_bStepOn = true ;
bOk = AddZigZagMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bStepUp, bSplitArcs, bPathTabsEnable, bPathOscEnable) ;
}
// se altrimenti passate a one-way
else if ( m_Params.m_nStepType == MILL_ST_ONEWAY) {
m_bStepOn = true ;
bOk = AddOneWayMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bStepUp, bSplitArcs, bPathTabsEnable, bPathOscEnable) ;
}
// se altrimenti passate a spirale
else if ( m_Params.m_nStepType == MILL_ST_SPIRAL) {
m_bStepOn = true ;
// rimuovo eventuale sovrapposizione aggiunta
if ( m_dAddedOverlap > EPS_SMALL) {
pCompo->Invert() ;
pCompo->TrimStartAtLen( m_dAddedOverlap) ;
pCompo->Invert() ;
m_dAddedOverlap = 0 ;
}
bOk = AddSpiralMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathTabsEnable, bPathOscEnable) ;
}
// se utensile lama, porto il percorso sull'estremo della stessa
AdjustPathDrawForSaw( nPxId) ;
if ( ! bOk)
return false ;
}
// incremento numero di fresate
++ m_nMills ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AdjustPathDrawForSaw( int nClPathId)
{
// se non è lama, non devo fare alcunché
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0)
return true ;
// porto il percorso praticamente sull'estremo della lama ( appena meno per evitare di trasformare archi in punti)
double dOffset = 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ;
Vector3d vtPrevCorr ;
for ( int nId = m_pGeomDB->GetFirstInGroup( nClPathId) ;
nId != GDB_ID_NULL ;
nId = m_pGeomDB->GetNext( nId)) {
// recupero l'oggetto geometrico
IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nId) ;
if ( pGObj == nullptr)
continue ;
// recupero i dati Cam dell'entità e verifico sia definito il versore correzione
CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nId)) ;
if ( pCamData == nullptr || pCamData->GetCorrDir().IsSmall())
continue ;
Vector3d vtCorr = pCamData->GetCorrDir() ;
// eseguo traslazione generale
Vector3d vtMove = - dOffset * vtCorr ;
pGObj->Translate( vtMove) ;
pCamData->Translate( vtMove) ;
// se il vettore correzione attuale è diverso dal precedente
if ( ! AreSameVectorApprox( vtCorr, vtPrevCorr)) {
// se curva
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
// compenso differenza su punto iniziale
Vector3d vtDiff = - dOffset * ( vtPrevCorr - vtCorr) ;
ICurve* pCrv = ::GetCurve( pGObj) ;
Point3d ptStart ;
pCrv->GetStartPoint( ptStart) ;
pCrv->ModifyStart( ptStart + vtDiff) ;
// se arco, aggiorno il centro
if ( pGObj->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCrv) ;
pCamData->SetCenter( pArc->GetCenter()) ;
}
}
}
// aggiorno precedente versore correzione
vtPrevCorr = vtCorr ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad,
double& dElev) const
{
// default
dElev = 0 ;
// controllo il raggio utensile
double const MIN_RAD = 5 ;
dRad = max( dRad, MIN_RAD) ;
// approssimo la curva con una polilinea
PolyLine PL ;
if ( ! pCompo->ApproxWithLines( LIN_TOL_RAW, ANG_TOL_MAX_DEG, ICurve::APL_SPECIAL, PL))
return false ;
double const MIN_STEP = 5 ;
double const MAX_STEP = 500 ;
double dStep = Clamp( dRad, MIN_STEP, MAX_STEP) ;
PL.AdjustForMaxSegmentLen( dStep) ;
// calcolo l'elevazione
Point3d ptP ;
bool bFound = PL.GetFirstPoint( ptP) ;
while ( bFound) {
double dPtElev ;
if ( ! GetElevation( m_nPhase, ptP - vtTool * dDepth, vtTool, dRad, vtTool, dPtElev))
return false ;
dElev = max( dElev, dPtElev) ;
bFound = PL.GetNextPoint( ptP) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool)
{
// se non è fresatura dal basso in alto, esco
if ( vtTool.z > MIN_ZDIR_TOP_TOOL)
return true ;
// se c'è testa non dall'alto o tavola basculante, esco
if ( ! m_bAboveHead || m_bTiltingTab)
return true ;
// recupero dati di eventuale rinvio da sotto
if ( ! GetAggrBottomData( m_TParams.m_sHead, m_AggrBottom) || m_AggrBottom.nType == 0) {
m_pMchMgr->SetLastError( 2307, "Error in Milling : missing aggregate from bottom") ;
return false ;
}
// calcolo il minimo della massima distanza del percorso dal contorno del grezzo
double dExpand = 0.5 * m_TParams.m_dTDiam ;
double dMinDist = INFINITO ;
Vector3d vtMinDir ;
VCT3DVECTOR vDir ;
double dParS, dParE ; pCompo->GetDomain( dParS, dParE) ;
for ( double dPar = dParS ; dPar < dParE + EPS_PARAM ; dPar += 0.5) {
// distanza minima del punto e relativa direzione dal contorno del grezzo
Point3d ptP ; double dCurrDist = INFINITO ; Vector3d vtCurrDir ;
if ( pCompo->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptP) &&
GetMinDistanceFromRawSide( m_nPhase, ptP, dExpand, m_AggrBottom.vtMDir, MCH_AGB_DELTAMAX_MDIR, dCurrDist, vtCurrDir) &&
! vtCurrDir.IsSmallXY()) {
if ( dCurrDist < dMinDist - 10 * EPS_SMALL &&
find_if( vDir.begin(), vDir.end(), [&](const Vector3d& vtV){ return vtCurrDir * vtV > cos( 15 * DEGTORAD) ; }) == vDir.end()) {
// inserisco la direzione tra quelle già esplorate
vDir.emplace_back( vtCurrDir) ;
// determino la distanza di tutti gli altri punti dal contorno del grezzo lungo questa direzione
for ( double dPar2 = dParS ; dPar2 < dParE + EPS_PARAM ; dPar2 += 0.5) {
if ( abs( dPar2 - dPar) > EPS_PARAM) {
Point3d ptQ ;
double dQDist ;
if ( pCompo->GetPointD1D2( dPar2, ICurve::FROM_MINUS, ptQ) &&
GetDistanceFromRawSide( m_nPhase, ptQ, vtCurrDir, dQDist) && dQDist + dExpand > dCurrDist)
dCurrDist = dQDist + dExpand ;
}
}
// se la massima distanza trovata è inferiore al minimo, lo aggiorno
if ( dCurrDist < dMinDist) {
dMinDist = dCurrDist ;
vtMinDir = vtCurrDir ;
}
}
}
}
// se supera il limite, errore
if ( dMinDist > m_AggrBottom.dDMax) {
m_pMchMgr->SetLastError( 2308, "Error in Milling : path too far from part sides") ;
return false ;
}
// assegno direzione di accesso e segnalo utilizzo aggregato da sotto
m_vtAggrBottom = vtMinDir ;
m_bAggrBottom = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo, double dRbDist, double dDepth)
{
// creo copia della curva composita
PtrOwner< ICurve> pCrv( pCompo->Clone()) ;
if ( IsNull( pCrv))
return false ;
// calcolo la regione
PtrOwner<ISurfFlatRegion> pSfr ;
pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), 0.5 * m_TParams.m_dDiam, false, false)) ;
if ( IsNull( pSfr))
return false ;
// ne recupero i contorni
for ( int i = 0 ; i < pSfr->GetLoopCount( 0) ; i++) {
PtrOwner<ICurve> 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_CUT) ;
m_pGeomDB->SetMaterial( nC2Id, LIME) ;
}
// inserisco la regione nel DB
int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfr)) ;
if ( nRId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ;
m_pGeomDB->SetMaterial( nRId, INVISIBLE) ;
// la copio anche come regione ridotta
int nRrId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
if ( nRrId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ;
m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
// creo regioni di lavorazione che interessano le superfici superiore e inferiore del grezzo
// casi inclinati da gestire !
int nUpId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
m_pGeomDB->SetName( nUpId, MCH_PV_UP_RAWCUT) ;
if ( dRbDist > EPS_SMALL && dRbDist - dDepth < EPS_SMALL) {
int nDwnId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
m_pGeomDB->SetName( nDwnId, MCH_PV_DOWN_RAWCUT) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = GetSafeZ() ;
double dSafeAggrBottZ = GetSafeAggrBottZ() ;
// extra lunghezza utensile
double dExtraLen = max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
double dExtrAppr = dAppr + dExtraLen ;
// delta da punto lavoro a punto tip
Vector3d vtWkTip = -vtTool * dExtraLen ;
// Recupero flag per rapidi su inizio/fine se fuori
string sMachIni = m_pMchMgr->GetCurrMachine()->GetMachineDir() + "\\" + m_pMchMgr->GetCurrMachine()->GetMachineName() + ".ini" ;
bool bRapidOnOut = ( GetPrivateProfileInt( MACHININGS_SEC.c_str(), RAPIDONOUT_KEY.c_str(), 0, sMachIni.c_str()) == 1) ;
// Recupero necessità indicizzazione per variazioni di lavorazione ("MVar" da porte)
bool bIndex = false ;
string sInfo ;
if ( m_Params.m_nWorkSide == MILL_WS_CENTER && m_vId.size() == 1 && m_pGeomDB->GetInfo( m_vId[0].nId, "MVar", sInfo))
bIndex = true ;
// in caso di tabs ne aggiusto i parametri secondo il percorso
TabData tdTabs ;
AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ;
DBLVECTOR vdTabs ;
CalcTabsPositions( pCompo, dDepth, bPathTabsEnable, tdTabs, vdTabs) ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// ciclo sulle curve elementari
bool bOk = true ;
m_dCurrTabsLen = 0 ;
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// copio la curva
PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
if ( IsNull( pCurve))
return false ;
// aggiungo affondamento
pCurve->Translate( - vtTool * dDepth) ;
// se prima entità, approccio e affondo
if ( i == 0) {
// reset index
SetIndex( 0) ;
// dati inizio entità
Point3d ptStart ;
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart = m_vtStartDir ;
// determino elevazione su inizio percorso di lavoro
double dStElev ;
if ( GetElevation( m_nPhase, ptStart + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = max( dStElev - dExtraLen, 0.) ;
else
dStElev = dElev ;
// determino inizio attacco
Point3d ptP1 ;
Vector3d vtDir1 ;
double dCalcStElev = dStElev ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, ptP1, vtDir1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
if ( ! vtAppr.Normalize())
vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
bool bOutStart = GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtAppr, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bGeomAboveStart = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
bool bAboveStart = false ;
if ( m_bAboveHead) {
if ( ! m_bTiltingTab)
bAboveStart = bGeomAboveStart ;
else {
if ( bOutStart)
dStElev = min( dStElev, dElev) ;
}
}
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pCompo, i, false, true) ;
// se richiesto rapido quando fuori e sono già in aria
if ( bRapidOnOut && bOutStart) {
// affondo al punto iniziale
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// aggiungo approccio per frese normali e frese che non lavorano di testa con attacco opportuno oppure fuori
else if ( ( m_TParams.m_nType & TF_MILL) != 0 &&
( m_TParams.m_nType != TT_MILL_NOTIP || LeadInRawIsOk() || m_bStartOutRaw)) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1 + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
dStElev = min( dStElev, max( dNewStElev - dExtraLen, 0.)) ;
// se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
if ( bAhUnderStart)
dStElev = max( dStElev - dExtraLen, 0.) ;
// se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
if ( bUhAboveStart)
dStElev = max( dStElev - dExtraLen, 0.) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev + GetLeadInOutToler()) ;
dStElev = - GetLeadInOutToler() ;
}
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAboveStart, true, bSplitArcs)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti, approccio per lame e frese che non lavorano di testa
else {
// verifico di entrare in aria
if ( ! ( bOutStart || m_bStartOutRaw)) {
// verifico se sono sotto
double dSawStartElev = 0 ;
bool bAhUnderStart = false ;
bool bUhAboveStart = false ;
bool bSideStart = false ;
if ( ! bGeomAboveStart) {
bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
}
else {
bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
}
// se non sono sotto, verifico se posso allontanarmi nel piano lama (meglio se in orizzontale)
if ( ! bAhUnderStart && ! bUhAboveStart) {
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) - DELTA_ELEV_RAD * vtTool ;
Point3d ptTestU = ptTest + m_TParams.m_dDiam * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
Vector3d vtAppr2 = vtDir1 ;
if ( ! vtAppr2.Normalize())
vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i, false, true)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) + 2 * DELTA_ELEV_RAD ;
double dSawStartElev1, dSawStartElev2 ;
bool bOk1 = GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtAppr1, dSawStartElev1) ;
bool bOk2 = ! AreSameVectorApprox( vtAppr2, vtAppr1) &&
GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtAppr2, dSawStartElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawStartElev1 < 1.3 * dSawStartElev2) ;
vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
bSideStart = true ;
}
else if ( bOk1) {
vtAppr = vtAppr1 ;
dSawStartElev = dSawStartElev1 ;
bSideStart = true ;
}
else if ( bOk2) {
vtAppr = vtAppr2 ;
dSawStartElev = dSawStartElev2 ;
bSideStart = true ;
}
}
if ( ! bGeomAboveStart && ! bAhUnderStart && ! bUhAboveStart && ! bSideStart && bOk) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
bOk = false ;
}
// aggiungo opportuno approccio
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr, true, bSplitArcs)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
else {
// affondo al punto iniziale
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, i + 1, false, true) ;
// se richiesto, imposto indice entità
if ( bIndex)
SetIndex( i + 1) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( bPathTabsEnable) {
if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs))
return false ;
}
else if ( bPathOscEnable) {
if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
SetFeed( GetFeed()) ;
if ( bPathTabsEnable) {
if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs))
return false ;
}
else if ( bPathOscEnable) {
if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se ultima entità, uscita e retrazione
if ( i == nMaxInd) {
// reset index
SetIndex( 0) ;
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd = m_vtEndDir ;
// elevazione sul punto finale
double dEndElev ;
if ( GetElevation( m_nPhase, ptEnd + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = max( dEndElev - dExtraLen, 0.) ;
else
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
Vector3d vtDir1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1, vtDir1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// determino se la fine dell'uscita è fuori dal grezzo
Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
if ( ! vtRetr.Normalize())
vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
bool bOutEnd = GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtRetr, dSafeZ) ;
// se richiesto rapido quando fuori e sono già in aria
if ( bRapidOnOut && bOutEnd) {
// non devo fare alcunché
}
// aggiungo retrazione per frese normali e frese che non lavorano di testa già fuori
else if ( ( m_TParams.m_nType & TF_MILL) != 0 &&
( m_TParams.m_nType != TT_MILL_NOTIP || m_bEndOutRaw)) {
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = false ;
if ( m_bAboveHead) {
if ( ! m_bTiltingTab)
bAboveEnd = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
else {
Vector3d vtCorr = CalcCorrDir( pCompo, nMaxInd + 1, false, true) ;
if ( GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtCorr, dSafeZ))
dEndElev = min( dEndElev, dElev) ;
}
}
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1 + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
dEndElev = min( dEndElev, max( dNewEndElev - dExtraLen, 0.)) ;
// se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
if ( bAhUnderEnd)
dEndElev = max( dEndElev - dExtraLen, 0.) ;
// se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
if ( bUhAboveEnd)
dEndElev = max( dEndElev - dExtraLen, 0.) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd, bSplitArcs)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// per lame e frese che non lavorano di testa quando è necessario
else {
if ( ! ( bOutEnd || m_bEndOutRaw)) {
// verifico se sono sopra
bool bGeomAboveEnd = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
// verifico se sono sotto
double dSawEndElev = 0 ;
bool bAhUnderEnd = false ;
bool bUhAboveEnd = false ;
bool bSideEnd = false ;
if ( ! bGeomAboveEnd) {
bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
}
else {
bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
}
if ( ! bAhUnderEnd && ! bUhAboveEnd) {
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) - DELTA_ELEV_RAD * vtTool ;
Point3d ptTestU = ptTest + m_TParams.m_dDiam * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
Vector3d vtRetr2 = vtDir1 ;
if ( ! vtRetr2.Normalize())
vtRetr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? vtEnd : CalcCorrDir( pCompo, i + 1, false, true)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) + 2 * DELTA_ELEV_RAD ;
double dSawEndElev1, dSawEndElev2 ;
bool bOk1 = GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtRetr1, dSawEndElev1) ;
bool bOk2 = ! AreSameVectorApprox( vtRetr2, vtRetr1) &&
GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtRetr2, dSawEndElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawEndElev1 < 1.3 * dSawEndElev2) ;
vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
bSideEnd = true ;
}
else if ( bOk1) {
vtRetr = vtRetr1 ;
dSawEndElev = dSawEndElev1 ;
bSideEnd = true ;
}
else if ( bOk2) {
vtRetr = vtRetr2 ;
dSawEndElev = dSawEndElev2 ;
bSideEnd = true ;
}
}
if ( ! bGeomAboveEnd && ! bAhUnderEnd && ! bUhAboveEnd && ! bSideEnd && bOk) {
m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ;
bOk = false ;
}
// aggiungo opportuna retrazione
if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
}
}
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev,
double dOkStep, bool bStepUp, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = GetSafeZ() ;
double dSafeAggrBottZ = GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
double dExtrAppr = dAppr + max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<int>( ceil( dElev / dOkStep))) ;
double dStep = dElev / nStep ;
// in caso di tabs ne aggiusto i parametri secondo il percorso
TabData tdTabs ;
AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ;
DBLVECTOR vdTabs ;
// se ultima passata al contrario
if ( bPathTabsEnable && ( nStep % 2) == 0) {
PtrOwner<ICurveComposite> pCopy( pCompo->Clone()) ;
if ( ! IsNull( pCopy) && pCopy->Invert())
CalcTabsPositions( pCopy, dDepth, bPathTabsEnable, tdTabs, vdTabs) ;
else
bPathTabsEnable = false ;
}
else
CalcTabsPositions( pCompo, dDepth, bPathTabsEnable, tdTabs, vdTabs) ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// altri dati del percorso
int nMaxInd = pCompo->GetCurveCount() - 1 ;
// ciclo sugli step
bool bOk = true ;
for ( int k = 1 ; k <= nStep ; ++ k) {
// flag direzione (prima passata indice 1)
bool bInvert = ( ( k % 2) == 0) ;
int j = ( bStepUp ? nStep - k + 1 : k) ;
m_dCurrTabsLen = 0 ;
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
// ciclo sulle curve elementari
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ;
// copio la curva
PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
if ( IsNull( pCurve))
return false ;
if ( bInvert)
pCurve->Invert() ;
// aggiungo affondamento
pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
// se prima entità, se primo step approccio e sempre affondo
if ( i == 0) {
// dati inizio entità
Point3d ptStart ;
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart = ( ! bInvert ? m_vtStartDir : -m_vtEndDir) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dStep ;
// determino inizio attacco
Point3d ptP1 ;
Vector3d vtDir1 ;
double dCalcStElev = dStElev ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, bInvert, pCompo, ptP1, vtDir1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
if ( ! vtAppr.Normalize())
vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ;
bool bAboveStart = false ;
if ( m_bAboveHead) {
if ( ! m_bTiltingTab)
bAboveStart = bGeomAboveStart ;
else {
if ( bOutStart)
dStElev = min( dStElev, dStep) ;
}
}
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i), false, true) ;
// se primo step
if ( k == 1) {
// aggiungo approccio per frese normali e frese che non lavorano di testa con attacco opportuno oppure fuori
if ( ( m_TParams.m_nType & TF_MILL) != 0 &&
( m_TParams.m_nType != TT_MILL_NOTIP || LeadInRawIsOk() || m_bStartOutRaw || bOutStart)) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
dStElev = min( dStElev, dNewStElev) ;
// se testa sopra determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// se testa sotto determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev + GetLeadInOutToler()) ;
dStElev = - GetLeadInOutToler() ;
}
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAboveStart, true, bSplitArcs)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti, approccio per lame e frese che non lavorano di testa
else {
// verifico di entrare in aria
if ( ! bOutStart) {
// verifico se sono sotto
double dSawStartElev = 0 ;
bool bUnderStart = false ;
bool bSideStart = false ;
if ( ! bGeomAboveStart) {
bUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
}
// se non sono sotto, verifico se posso allontanarmi nel piano lama (meglio se in orizzontale)
if ( ! bUnderStart) {
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
Vector3d vtAppr2 = vtDir1 ;
if ( ! vtAppr2.Normalize())
vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i, false, true)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawStartElev1, dSawStartElev2 ;
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
bSideStart = true ;
}
else if ( bOk1) {
vtAppr = vtAppr1 ;
dSawStartElev = dSawStartElev1 ;
bSideStart = true ;
}
else if ( bOk2) {
vtAppr = vtAppr2 ;
dSawStartElev = dSawStartElev2 ;
bSideStart = true ;
}
}
if ( ! bGeomAboveStart && ! bUnderStart && ! bSideStart && bOk) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
bOk = false ;
}
// aggiungo opportuno approccio
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr, true, bSplitArcs)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
else {
// affondo al punto iniziale
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
}
}
// altrimenti, affondo al punto iniziale
else {
// considero come elevazione lo step dalla passata precedente
dStElev = dStep ;
// se lama o fresa che non lavora di testa
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 || m_TParams.m_nType == TT_MILL_NOTIP) {
SetFeed( GetStartFeed()) ;
// eventuale movimento parallelo all'asse utensile fatto fuori
Point3d ptCurr ;
if ( ! GetCurrPos( ptCurr))
return false ;
Vector3d vtToolOrt = OrthoCompo( ptP1 - ptCurr, vtTool) ;
if ( vtToolOrt.Len() > 100 * EPS_SMALL) {
if ( AddLinearMove( ptP1 - vtToolOrt, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
return false ;
}
// movimento standard
if ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
return false ;
}
// se attacco a zigzag o a spirale, non affondo
else if ( IsLeadInHelixOrZigzagOrGlide()) {
ptP1 += vtTool * ( dStElev + GetLeadInOutToler()) ;
dStElev = - GetLeadInOutToler() ;
}
// altrimenti, affondo in feed opportuna
else {
bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_POLISHING) ;
SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
if ( ! SameAsCurrPos( ptP1) && AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
return false ;
}
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, bInvert, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1), false, true) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathTabsEnable) {
if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs))
return false ;
}
else if ( j == nStep && bPathOscEnable) {
if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathTabsEnable) {
if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs))
return false ;
}
else if ( j == nStep && bPathOscEnable) {
if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se ultima entità, uscita e se ultimo step retrazione
if ( i == nMaxInd) {
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd = ( ! bInvert ? m_vtEndDir : -m_vtStartDir) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// se non c'è attacco a zigzag o a spirale oppure ultimo step, aggiungo uscita
Point3d ptP1 = ptEnd ;
Vector3d vtDir1 ;
if ( ! IsLeadInHelixOrZigzag() || k == nStep) {
if ( k != nStep && GetLeadInType() == MILL_LI_GLIDE)
dEndElev = - GetLeadInOutToler() ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1, vtDir1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
}
// determino se la fine dell'uscita è fuori dal grezzo
Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
if ( ! vtRetr.Normalize())
vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dSafeZ) ;
// per lame e frese che non lavorano di testa quando ancora dentro aggiungo retrazione se necessaria
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ||
( m_TParams.m_nType == TT_MILL_NOTIP && ! m_bEndOutRaw && ! bOutEnd)) {
if ( ! bOutEnd) {
// verifico se sono sopra
bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
// verifico se sono sotto
double dSawEndElev = 0 ;
bool bUnderEnd = false ;
bool bSideEnd = false ;
if ( ! bGeomAboveEnd) {
bUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
}
if ( ! bUnderEnd) {
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
Vector3d vtRetr2 = vtDir1 ;
if ( ! vtRetr2.Normalize())
vtRetr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? vtEnd : CalcCorrDir( pCompo, i + 1, false, true)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawEndElev1, dSawEndElev2 ;
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
bSideEnd = true ;
}
else if ( bOk1) {
vtRetr = vtRetr1 ;
dSawEndElev = dSawEndElev1 ;
bSideEnd = true ;
}
else if ( bOk2) {
vtRetr = vtRetr2 ;
dSawEndElev = dSawEndElev2 ;
bSideEnd = true ;
}
}
if ( ! bGeomAboveEnd && ! bUnderEnd && ! bSideEnd && bOk) {
m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ;
bOk = false ;
}
// se finale oppure dentro il materiale, aggiungo opportuna retrazione
if ( ( k == nStep || ! bUnderEnd) &&
! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
}
// altrimenti frese e se ultimo step aggiungo retrazione
else if ( k == nStep) {
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = false ;
if ( m_bAboveHead) {
if ( ! m_bTiltingTab)
bAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
else {
Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? 0 : nMaxInd + 1), false, true) ;
if ( GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ))
dEndElev = min( dEndElev, dElev) ;
}
}
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
dEndElev = min( dEndElev, dNewEndElev) ;
// se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd, bSplitArcs)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
}
}
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev,
double dOkStep, bool bStepUp, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = GetSafeZ() ;
double dSafeAggrBottZ = GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
double dExtrAppr = dAppr + max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
// in caso di tabs ne aggiusto i parametri secondo il percorso
TabData tdTabs ;
AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ;
DBLVECTOR vdTabs ;
CalcTabsPositions( pCompo, dDepth, bPathTabsEnable, tdTabs, vdTabs) ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// percorso speciale : chiuso e con attacco a spirale o zigzag
bool bSpecial = ( pCompo->IsClosed() && IsLeadInHelixOrZigzagOrGlide()) ;
// percorso senza retrazioni intermedie : chiuso e con attacco e uscita con punti esterni coincidenti
bool bMidRetract = true ;
if ( pCompo->IsClosed()) {
int nLiType = GetLeadInType() ;
int nLoType = GetLeadOutType() ;
if ( nLiType == MILL_LI_NONE && ( nLoType == MILL_LO_NONE || nLoType == MILL_LO_AS_LI))
bMidRetract = false ;
if ( nLiType == MILL_LI_GLIDE)
bMidRetract = false ;
if ( ( nLiType == MILL_LI_TANGENT || nLiType == MILL_LI_LINEAR || nLiType == MILL_LI_TG_PERP) &&
nLoType == MILL_LO_AS_LI &&
abs( m_Params.m_dLiTang) < EPS_SMALL)
bMidRetract = false ;
if ( ( nLiType == MILL_LI_TANGENT || nLiType == MILL_LI_LINEAR || nLiType == MILL_LI_TG_PERP) &&
( nLoType == MILL_LO_TANGENT || nLoType == MILL_LO_LINEAR || nLoType == MILL_LO_PERP_TG) &&
abs( m_Params.m_dLiTang) < EPS_SMALL &&
abs( m_Params.m_dLoTang) < EPS_SMALL &&
abs( m_Params.m_dLiPerp - m_Params.m_dLoPerp) < EPS_SMALL)
bMidRetract = false ;
}
// determino punti di inizio e fine
Point3d ptStart ;
pCompo->GetStartPoint( ptStart) ;
ptStart -= vtTool * dDepth ;
Vector3d vtStart = m_vtStartDir ;
Point3d ptPs ;
Vector3d vtDirs ;
CalcLeadInStart( ptStart, vtStart, vtTool, dElev, false, pCompo, ptPs, vtDirs) ;
Vector3d vtCs = CalcCorrDir( pCompo, 0, false, true) ;
Point3d ptEnd ;
pCompo->GetEndPoint( ptEnd) ;
ptEnd -= vtTool * dDepth ;
Vector3d vtEnd = m_vtEndDir ;
Point3d ptPe ;
CalcLeadOutEnd( ptEnd, vtEnd, vtTool, dElev, false, pCompo, ptPe) ;
Vector3d vtCe = CalcCorrDir( pCompo, pCompo->GetCurveCount(), false, true) ;
// verifico se attacco e uscita entrambi sopra o sotto il grezzo
bool bAhAboveStartEnd = false ;
bool bUhBelowStartEnd = false ;
if ( m_bAboveHead)
bAhAboveStartEnd = GetPointAboveRaw( ptPs, vtTool) && GetPointAboveRaw( ptPe, vtTool) ;
else
bUhBelowStartEnd = GetPointBelowRaw( ptPs, vtTool) && GetPointBelowRaw( ptPe, vtTool) ;
// verifico se collegamento diretto tra ingresso e uscita è fuori dal grezzo
bool bSafeDirLinkStartEnd = ( bAhAboveStartEnd || bUhBelowStartEnd ||
( ! bMidRetract && m_bStartOutRaw && m_bEndOutRaw)) ;
if ( ! bSafeDirLinkStartEnd) {
// verifica dei punti intermedi
bool bIsOut = true ;
int nStep = Clamp( int( Dist( ptPs, ptPe) / m_TParams.m_dDiam), 4, 16) ;
for ( int i = 1 ; i < nStep ; ++ i) {
double dCoeff = double( i) / nStep ;
Point3d ptPm = Media( ptPs, ptPe, dCoeff) ;
Vector3d vtCm = Media( vtCs, vtCe, dCoeff) ;
if ( ! vtCm.Normalize())
vtCm = vtCs ;
if ( ! GetSimplePointOutOfRaw( ptPm, vtTool, vtCm) &&
( m_TParams.m_nType == TT_MILL_STD || ! GetSimplePointOutOfRaw( ptPm, vtTool, vtTool))) {
bIsOut = false ;
break ;
}
}
if ( bIsOut)
bSafeDirLinkStartEnd = true ;
}
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<int>( ceil( dElev / dOkStep))) ;
double dStep = dElev / nStep ;
// ciclo sugli step
bool bOk = true ;
for ( int k = 1 ; k <= nStep ; ++ k) {
int j = ( bStepUp ? nStep - k + 1 : k) ;
m_dCurrTabsLen = 0 ;
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
// se percorso chiuso e attacco ad inseguimento sposto inizio
if ( k > 1 && pCompo->IsClosed() && GetLeadInType() == MILL_LI_GLIDE) {
double dU ;
if ( pCompo->GetParamAtLength( m_Params.m_dLiTang, dU)) {
const_cast<ICurveComposite*>( pCompo)->ChangeStartPoint( dU) ;
const_cast<ICurveComposite*>( pCompo)->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false) ;
VerifyArcs( const_cast<ICurveComposite*>( pCompo)) ;
}
}
// ciclo sulle curve elementari
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// copio la curva
PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
if ( IsNull( pCurve))
return false ;
// aggiungo affondamento
pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
// se prima entità, approccio e affondo
if ( i == 0) {
// dati inizio entità
Point3d ptStart ;
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart = m_vtStartDir ;
// pCurve->GetStartDir( vtStart) ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pCompo, i, false, true) ;
// punto inizio attacco
Point3d ptP1 ;
Vector3d vtDir1 ;
double dCalcStElev = 0 ;
// se speciale e step intermedio
if ( bSpecial && k > 1) {
ptP1 = ptStart + dStep * vtTool ;
}
// altrimenti
else {
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
if ( ! bSafeDirLinkStartEnd)
dStElev = max( dStElev, j * dStep) ;
// determino inizio attacco
dCalcStElev = dStElev ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, ptP1, vtDir1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
if ( ! vtAppr.Normalize())
vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dSafeZ) ;
// aggiungo approccio per frese normali e frese che non lavorano di testa con attacco opportuno oppure fuori
if ( ( m_TParams.m_nType & TF_MILL) != 0 &&
( m_TParams.m_nType != TT_MILL_NOTIP || LeadInRawIsOk() || m_bStartOutRaw)) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
if ( bAhAboveStartEnd || bUhBelowStartEnd)
dStElev = min( dStElev, dNewStElev) ;
else
dStElev = max( dStElev, dNewStElev) ;
}
if ( bSafeDirLinkStartEnd && m_bTiltingTab)
dStElev = min( dStElev, j * dStep) ;
// se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev - ( j - 1) * dStep) ;
dStElev = ( j - 1) * dStep ;
}
// approccio standard al punto iniziale
if ( k == 1 || bMidRetract) {
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart,
bAhAboveStartEnd || bUhBelowStartEnd, k == 1, bSplitArcs)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti approccio diretto al punto iniziale
else {
if ( ! AddDirectApproach( ptP1, bSplitArcs)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
}
// altrimenti, approccio per lame e frese che non lavorano di testa
else {
// flag necessità movimento preliminare di inserzione in direzione utensile
bool bAddInsert = ( k > 1 && ! bSafeDirLinkStartEnd) ;
// verifico di entrare in aria
if ( ! bOutStart) {
// verifico se sono sopra
bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ;
// verifico se sono sotto
double dSawStartElev = 0 ;
bool bAhUnderStart = false ;
bool bUhAboveStart = false ;
bool bSideStart = false ;
if ( ! bGeomAboveStart) {
bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
}
else {
bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
}
// se non sono sotto, verifico se posso allontanarmi nel piano lama (meglio se in orizzontale)
if ( ! bAhUnderStart && ! bUhAboveStart) {
Point3d ptTest = ptP1 - MIN_SAFEDIST * vtTool ;
Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
Vector3d vtAppr2 = vtDir1 ;
if ( ! vtAppr2.Normalize())
vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i, false, true)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawStartElev1 = 0, dSawStartElev2 = 0 ;
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
bSideStart = true ;
}
else if ( bOk1) {
vtAppr = vtAppr1 ;
dSawStartElev = dSawStartElev1 ;
bSideStart = true ;
}
else if ( bOk2) {
vtAppr = vtAppr2 ;
dSawStartElev = dSawStartElev2 ;
bSideStart = true ;
}
}
if ( bSideStart)
bMidRetract = true ;
if ( ! bGeomAboveStart && ! bAhUnderStart && ! bUhAboveStart && ! bSideStart && bOk) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
bOk = false ;
}
// aggiungo opportuno approccio
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr,
k == 1, bSplitArcs, bAddInsert && bMidRetract)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
else {
SetFlag( 0) ;
bool bFirst = ( k == 1) ;
// se necessario inserimento
if ( bAddInsert) {
Point3d ptInsert = ptP1 + ( dStElev + dSafeZ) * vtTool ;
if ( AddRapidStartOrMove( ptInsert, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
if ( AddRapidMove( ptP1, bSplitArcs) == GDB_ID_NULL)
return false ;
}
// altrimenti direttamente al punto iniziale
else {
if ( AddRapidStartOrMove( ptP1, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
}
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, i + 1, false, true) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathTabsEnable) {
if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs))
return false ;
}
else if ( j == nStep && bPathOscEnable) {
if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathTabsEnable) {
if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs))
return false ;
}
else if ( j == nStep && bPathOscEnable) {
if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se ultima entità, uscita e retrazione
if ( i == nMaxInd) {
// se speciale e step intermedio salto uscita e retrazione
if ( bSpecial && k != nStep)
continue ;
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd = m_vtEndDir ;
// pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
if ( ! bSafeDirLinkStartEnd)
dEndElev = max( dEndElev, j * dStep) ;
// aggiungo uscita
Point3d ptP1 ;
Vector3d vtDir1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1, vtDir1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// se step finale o intermedi con retrazione
if ( k == nStep || bMidRetract || ! bSafeDirLinkStartEnd) {
// determino se la fine dell'uscita è fuori dal grezzo
Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
if ( ! vtRetr.Normalize())
vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dSafeZ) ;
// aggiungo retrazione per frese normali e frese che non lavorano di testa già fuori
if ( ( m_TParams.m_nType & TF_MILL) != 0 &&
( m_TParams.m_nType != TT_MILL_NOTIP || m_bEndOutRaw)) {
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
if ( bAhAboveStartEnd || bUhBelowStartEnd)
dEndElev = min( dEndElev, dNewEndElev) ;
else if ( dNewEndElev > EPS_SMALL)
dEndElev = max( dEndElev, dNewEndElev) ;
}
if ( bSafeDirLinkStartEnd && m_bTiltingTab)
dEndElev = min( dEndElev, j * dStep) ;
// se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAhAboveStartEnd || bUhBelowStartEnd, bSplitArcs)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// per lame e frese che non lavorano di testa quando è necessario
else {
// flag necessità movimento successivo di estrazione in direzione utensile
bool bAddExtract = ( k < nStep && ! bSafeDirLinkStartEnd) ;
// se non è già fuori dal pezzo...
if ( ! bOutEnd) {
// verifico se sono sopra
bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
// verifico se sono sotto
double dSawEndElev = 0 ;
bool bAhUnderEnd = false ;
bool bUhAboveEnd = false ;
bool bSideEnd = false ;
if ( ! bGeomAboveEnd) {
bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
}
else {
bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation(),
m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
}
if ( ! bAhUnderEnd && ! bUhAboveEnd) {
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
Vector3d vtRetr2 = vtDir1 ;
if ( ! vtRetr2.Normalize())
vtRetr2 = CalcCorrDir( pCompo, i + 1, false, true) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawEndElev1, dSawEndElev2 ;
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
bSideEnd = true ;
}
else if ( bOk1) {
vtRetr = vtRetr1 ;
dSawEndElev = dSawEndElev1 ;
bSideEnd = true ;
}
else if ( bOk2) {
vtRetr = vtRetr2 ;
dSawEndElev = dSawEndElev2 ;
bSideEnd = true ;
}
}
if ( bSideEnd)
bMidRetract = true ;
if ( ! bGeomAboveEnd && ! bAhUnderEnd && ! bUhAboveEnd && ! bSideEnd && bOk) {
m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ;
bOk = false ;
}
// aggiungo opportuna retrazione
if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr, bAddExtract && bMidRetract)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// se richiesta estrazione in direzione utensile
else if ( bAddExtract) {
Point3d ptExtract = ptP1 + ( dEndElev + dSafeZ) * vtTool ;
if ( AddRapidMove( ptExtract, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
}
}
}
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = GetSafeZ() ;
double dSafeAggrBottZ = GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
double dExtrAppr = dAppr + max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
// se attacco ad inseguimento (per ora nullo), parto sopra di elevazione in attacco
double dStart = 0 ;
if ( m_Params.m_nLeadInType == MILL_LI_NONE)
dStart = m_Params.m_dLiElev ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// imposto flag di percorso chiuso
bool bClosed = pCompo->IsClosed() ;
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<int>( ceil( ( dElev + dStart) / ( bClosed ? dOkStep : dOkStep / 2)))) ;
if ( m_TParams.m_nType == TT_MILL_POLISHING)
nStep = max( 1, nStep - 1) ;
double dStep = ( dElev + dStart) / nStep ;
// determino dati del percorso
double dTotLen ; pCompo->GetLength( dTotLen) ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
// se chiuso -> sempre in avanti
if ( bClosed) {
// ciclo sugli step
for ( int j = 0 ; j <= nStep ; ++ j) {
// ciclo sulle curve elementari
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
double dCurrLen = 0 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// affondamento a inizio curva
Vector3d vtStaDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
// affondamento a fine curva
double dCrvLen ; pCrvC->GetLength( dCrvLen) ;
dCurrLen += dCrvLen ;
Vector3d vtEndDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
// se prima entità di primo step, approccio e affondo
if ( i == 0 && j == 0) {
// dati inizio entità
Point3d ptStart ;
pCrvC->GetStartPoint( ptStart) ;
ptStart -= vtStaDepth ;
Vector3d vtStart = m_vtStartDir ;
// pCrvC->GetStartDir( vtStart) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = 0 ;
dStElev -= dStart ;
// determino inizio attacco
Point3d ptP1 ;
Vector3d vtDir1 ;
double dCalcStElev = dStElev ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, ptP1, vtDir1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
Vector3d vtCorr = CalcCorrDir( pCompo, i) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pCompo, i) ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
dStElev = min( dStElev, dNewStElev) ;
// se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAboveStart, true, bSplitArcs)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti, affondo al punto iniziale per lame
else {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
return false ;
}
// eseguo affondamento
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, i + 1) ;
// elaborazioni sulla curva corrente
if ( pCrvC->GetType() == CRV_LINE) {
const ICurveLine* pLine = GetCurveLine( pCrvC) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
PtrOwner<ICurveLine> pTmpLine( pLine->Clone()) ;
if ( IsNull( pTmpLine))
return false ;
pTmpLine->Translate( -vtStaDepth) ;
if ( ! AddOscillLine( pTmpLine, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptP3 = pLine->GetEnd() ;
ptP3 -= vtEndDepth ;
if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
else if ( pCrvC->GetType() == CRV_ARC) {
const ICurveArc* pArc = GetCurveArc( pCrvC) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
PtrOwner<ICurveArc> pTmpArc( pArc->Clone()) ;
if ( IsNull( pTmpArc))
return false ;
pTmpArc->Translate( -vtStaDepth) ;
if ( ! AddOscillArc( pTmpArc, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptCen = pArc->GetCenter() ;
ptCen -= vtStaDepth ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 -= vtEndDepth ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se ultima entità di ultimo step, uscita e retrazione
if ( i == nMaxInd && j == nStep) {
// dati fine entità
Point3d ptEnd ;
pCrvC->GetEndPoint( ptEnd) ;
ptEnd -= vtEndDepth ;
Vector3d vtEnd = m_vtEndDir ;
// pCrvC->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
Vector3d vtDir1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1, vtDir1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
dEndElev = min( dEndElev, dNewEndElev) ;
// se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd, bSplitArcs)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// per lame non è necessario
}
}
}
}
// altrimenti aperto -> avanti e indietro
else {
// ciclo sugli step
for ( int j = 0 ; j <= nStep ; ++ j) {
// flag direzione (prima passata indice 0)
bool bInvert = ( ( j % 2) == 1) ;
// ciclo sulle curve elementari
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
double dCurrLen = 0 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ;
// copio la curva
PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
if ( IsNull( pCurve))
return false ;
if ( bInvert)
pCurve->Invert() ;
// affondamento a inizio curva
Vector3d vtStaDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
// affondamento a fine curva
double dCrvLen ; pCrvC->GetLength( dCrvLen) ;
dCurrLen += dCrvLen ;
Vector3d vtEndDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
// se prima entità di primo step, approccio e affondo
if ( i == 0 && j == 0) {
// dati inizio entità
Point3d ptStart ;
pCurve->GetStartPoint( ptStart) ;
ptStart -= vtStaDepth ;
Vector3d vtStart = m_vtStartDir ;
// pCurve->GetStartDir( vtStart) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
dStElev -= dStart ;
// determino inizio attacco
Point3d ptP1 ;
Vector3d vtDir1 ;
double dCalcStElev = dStElev ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, bInvert, pCompo, ptP1, vtDir1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
dStElev = min( dStElev, dNewStElev) ;
// se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAboveStart, true, bSplitArcs)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti, affondo per lame
else {
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, bInvert, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1)) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
PtrOwner<ICurveLine> pTmpLine( pLine->Clone()) ;
if ( IsNull( pTmpLine))
return false ;
pTmpLine->Translate( -vtStaDepth) ;
if ( ! AddOscillLine( pTmpLine, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptP3 = pLine->GetEnd() ;
ptP3 -= vtEndDepth ;
if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
PtrOwner<ICurveArc> pTmpArc( pArc->Clone()) ;
if ( IsNull( pTmpArc))
return false ;
pTmpArc->Translate( -vtStaDepth) ;
if ( ! AddOscillArc( pTmpArc, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptCen = pArc->GetCenter() ;
ptCen -= vtStaDepth ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ;
pArc->GetEndPoint( ptP3) ;
ptP3 -= vtEndDepth ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se ultima entità di ultimo step, uscita e retrazione
if ( i == nMaxInd && j == nStep) {
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
ptEnd -= vtEndDepth ;
Vector3d vtEnd = m_vtEndDir ;
// pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
Vector3d vtDir1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1, vtDir1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
Vector3d vtEscape = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtEscape.z = 0 ;
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
dEndElev = min( dEndElev, dNewEndElev) ;
// se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd, bSplitArcs)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// per lame non è necessario
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
class LeadIOStatus
{
public :
LeadIOStatus( Milling* pMill)
{ m_pMill = pMill ;
m_dLiPerp = m_pMill->m_Params.m_dLiPerp ;
m_dLiTang = m_pMill->m_Params.m_dLiTang ;
m_dLoPerp = m_pMill->m_Params.m_dLoPerp ;
m_dLoTang = m_pMill->m_Params.m_dLoTang ;
}
~LeadIOStatus( void)
{ Restore() ;
}
void Restore( void)
{ m_pMill->m_Params.m_dLiPerp = m_dLiPerp ;
m_pMill->m_Params.m_dLiTang = m_dLiTang ;
m_pMill->m_Params.m_dLoPerp = m_dLoPerp ;
m_pMill->m_Params.m_dLoTang = m_dLoTang ;
}
private :
Milling* m_pMill ;
double m_dLiPerp ;
double m_dLiTang ;
double m_dLoPerp ;
double m_dLoTang ;
} ;
//----------------------------------------------------------------------------
bool
Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs)
{
// recupero distanze di sicurezza
double dSafeZ = GetSafeZ() ;
// recupero eventuale superficie trimesh chiusa per trim/extend
int nTriExtCstm = GDB_ID_NULL ;
int nTesId ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_TRIMEXT, nTesId)) {
const ISurfTriMesh* pTes = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nTesId)) ;
if ( pTes != nullptr && pTes->IsClosed())
nTriExtCstm = nTesId ;
}
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<int>( ceil( dElev / dOkStep))) ;
double dStep = dElev / nStep ;
// gestione parametri di attacco/uscita (con backup per ripristino all'uscita)
LeadIOStatus LioStatus( this) ;
bool bAdjustLiPerp = ( m_Params.m_dLiPerp > 10 * EPS_SMALL) ;
if ( bAdjustLiPerp) {
double dNewLiPerp = max( 0., m_Params.m_dLiPerp - ( nStep - 1) * dStep) ;
m_Params.m_dLiTang *= dNewLiPerp / m_Params.m_dLiPerp ;
m_Params.m_dLiPerp = dNewLiPerp ;
}
bool bAdjustLoPerp = ( m_Params.m_dLoPerp > 10 * EPS_SMALL) ;
if ( bAdjustLoPerp) {
double dNewLoPerp = max( 0., m_Params.m_dLoPerp - ( nStep - 1) * dStep) ;
m_Params.m_dLoTang *= dNewLoPerp / m_Params.m_dLoPerp ;
m_Params.m_dLoPerp = dNewLoPerp ;
}
// ciclo sugli step
for ( int j = 1 ; j <= nStep ; ++ j) {
// flag direzione
bool bInvert = ( (( nStep - j) % 2) == 1) ;
// copio la curva
PtrOwner<ICurveComposite> pMyCompo( pCompo->Clone()) ;
if ( IsNull( pMyCompo))
return false ;
// eseguo offset ed eventuale inversione
double dSignOffs = ( dElev - j * dStep) * ( m_Params.m_nWorkSide == MILL_WS_LEFT ? - 1 : 1) ;
if ( ! CalcOffset( pMyCompo, dSignOffs))
return false ;
if ( bInvert)
pMyCompo->Invert() ;
// eventuale trim/extend con la superficie indicata
if ( nTriExtCstm != GDB_ID_NULL) {
// trim con ripristino dell'originale in caso di errore
PtrOwner<ICurveComposite> pMyCopy( pMyCompo->Clone()) ;
if ( ! TrimExtendCurveToClosedStm( pMyCompo, nTriExtCstm, bInvert))
pMyCompo.Set( pMyCopy) ;
}
// se necessario e invertito oppure step successivo annullo parametri di attacco
if ( bAdjustLiPerp && ( bInvert || j == 2)) {
m_Params.m_dLiPerp = 0. ;
m_Params.m_dLiTang = 0. ;
}
// se necessario e non invertito oppure step successivo annullo parametri di uscita
if ( bAdjustLoPerp && ( ! bInvert || j == 2)) {
m_Params.m_dLoPerp = 0. ;
m_Params.m_dLoTang = 0. ;
}
// ciclo sulle curve elementari
int nMaxInd = pMyCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCurve = pMyCompo->GetCurve( i) ;
// se prima entità, se primo step approccio e sempre affondo
if ( i == 0) {
// dati inizio entità
Point3d ptStart ;
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart = ( ! bInvert ? m_vtStartDir : -m_vtEndDir) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( j == 1) {
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
}
else
dStElev = dStep - GetLeadInOutToler() - 10 * EPS_SMALL ;
// determino inizio attacco
Point3d ptP1 ;
Vector3d vtDir1 ;
double dCalcStElev = dStElev ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, bInvert, pMyCompo, ptP1, vtDir1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
Vector3d vtCorr = CalcCorrDir( pMyCompo, i, bInvert, true) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pMyCompo, i, bInvert, true) ;
// se primo step
if ( j == 1) {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
return false ;
}
// eseguo affondo
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// altrimenti, affondo in feed opportuna
else {
bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP || m_TParams.m_nType == TT_MILL_POLISHING) ;
SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
if ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
return false ;
}
// aggiungo attacco
bool bTang = (( ! bInvert && m_Params.m_dLiTang > EPS_SMALL) || ( bInvert && m_Params.m_dLoTang > EPS_SMALL)) ;
SetFeed( bTang ? GetStartFeed() : GetTipFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, bInvert, pMyCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pMyCompo, i + 1, bInvert, true) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
const ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptP3 = pLine->GetEnd() ;
SetFeed( GetFeed()) ;
if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else if ( pCurve->GetType() == CRV_ARC) {
const ICurveArc* pArc = GetCurveArc( pCurve) ;
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ;
pArc->GetEndPoint( ptP3) ;
SetFeed( GetFeed()) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se ultima entità, uscita e se ultimo step retrazione
if ( i == nMaxInd) {
// se ultima passata, ripristino parametri originali di attacco/uscita
if ( j == nStep)
LioStatus.Restore() ;
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd = ( ! bInvert ? m_vtEndDir : -m_vtStartDir) ;
// elevazione sul punto finale
double dEndElev ;
if ( j == nStep) {
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
}
else
dEndElev = - GetLeadInOutToler() ;
// aggiungo uscita
Point3d ptP1 ;
Vector3d vtDir1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pMyCompo, bSplitArcs, ptP1, vtDir1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// imposto flag fine passata sull'ultima entità emessa
if ( ! SetFlagOnLastMove( 301))
return false ;
// per lame retrazione non è necessaria
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddSawOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs)
{
// recupero distanze di sicurezza
double dSafeZ = GetSafeZ() ;
// recupero eventuale superficie trimesh chiusa per trim/extend
int nTriExtCstm = GDB_ID_NULL ;
int nTesId ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_TRIMEXT, nTesId)) {
const ISurfTriMesh* pTes = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nTesId)) ;
if ( pTes != nullptr && pTes->IsClosed())
nTriExtCstm = nTesId ;
}
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<int>( ceil( dElev / dOkStep))) ;
double dStep = dElev / nStep ;
// gestione parametri di attacco/uscita (con backup per ripristino all'uscita)
LeadIOStatus LioStatus( this) ;
bool bAdjustLiPerp = ( m_Params.m_dLiPerp > 10 * EPS_SMALL) ;
if ( bAdjustLiPerp) {
double dNewLiPerp = max( 0., m_Params.m_dLiPerp - ( nStep - 1) * dStep) ;
m_Params.m_dLiTang *= dNewLiPerp / m_Params.m_dLiPerp ;
m_Params.m_dLiPerp = dNewLiPerp ;
}
bool bAdjustLoPerp = ( m_Params.m_dLoPerp > 10 * EPS_SMALL) ;
if ( bAdjustLoPerp) {
m_Params.m_dLoTang = 0 ;
m_Params.m_dLoPerp = 0. ;
}
// ciclo su step più ritorni (quelli pari sono i ritorni)
for ( int k = 1 ; k <= 2 * nStep - 1 ; ++ k) {
// indice step
int j = ( k + 1) / 2 ;
// flag ritorno
bool bReturn = ( ( k % 2) == 0) ;
// copio la curva
PtrOwner<ICurveComposite> pMyCompo( pCompo->Clone()) ;
if ( IsNull( pMyCompo))
return false ;
// eseguo offset ed eventuale inversione per ritorno
double dDelta = ( bReturn ? min( dStep, 5.) : 0) ;
double dSignOffs = ( dElev - j * dStep + dDelta) * ( m_Params.m_nWorkSide == MILL_WS_LEFT ? - 1 : 1) ;
if ( ! CalcOffset( pMyCompo, dSignOffs))
return false ;
if ( bReturn)
pMyCompo->Invert() ;
// eventuale trim/extend con la superficie indicata
if ( nTriExtCstm != GDB_ID_NULL) {
// trim con ripristino dell'originale in caso di errore
PtrOwner<ICurveComposite> pMyCopy( pMyCompo->Clone()) ;
if ( ! TrimExtendCurveToClosedStm( pMyCompo, nTriExtCstm, bReturn))
pMyCompo.Set( pMyCopy) ;
}
// dopo primo step annullo parametro di attacco
if ( k > 1 && bAdjustLiPerp) {
m_Params.m_dLiPerp = 0. ;
m_Params.m_dLiTang = 0. ;
}
// ciclo sulle curve elementari
int nMaxInd = pMyCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCurve = pMyCompo->GetCurve( i) ;
// se prima entità, se primo step approccio e sempre affondo
if ( i == 0) {
// dati inizio entità
Point3d ptStart ;
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart = ( ! bReturn ? m_vtStartDir : -m_vtEndDir) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( k == 1) {
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
}
else
dStElev = dStep - GetLeadInOutToler() - 10 * EPS_SMALL ;
// determino inizio attacco
Point3d ptP1 ;
Vector3d vtDir1 ;
double dCalcStElev = dStElev ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, bReturn, pMyCompo, ptP1, vtDir1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
Vector3d vtCorr = CalcCorrDir( pMyCompo, i, bReturn, true) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pMyCompo, i, bReturn, true) ;
// se primo step
if ( k == 1) {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
return false ;
}
// eseguo affondo
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// altrimenti, affondo ( o retrazione se Return) in feed opportuna
else {
bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP || m_TParams.m_nType == TT_MILL_POLISHING) ;
SetFeed( bReturn ? GetEndFeed() : ( bStartFeed ? GetStartFeed() : GetTipFeed())) ;
if ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
return false ;
}
// aggiungo attacco
bool bTang = (( ! bReturn && m_Params.m_dLiTang > EPS_SMALL) || ( bReturn && m_Params.m_dLoTang > EPS_SMALL)) ;
SetFeed( bReturn ? GetEndFeed() : ( bTang ? GetStartFeed() : GetTipFeed())) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, bReturn, pMyCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pMyCompo, i + 1, bReturn, true) ;
// se Retrazione e ultima entità, dichiaro fine passata
if ( bReturn && i == nMaxInd)
SetFlag( 301) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
const ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptP3 = pLine->GetEnd() ;
SetFeed( bReturn ? GetEndFeed() : GetFeed()) ;
if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL) {
SetFlag( 0) ;
return false ;
}
}
else if ( pCurve->GetType() == CRV_ARC) {
const ICurveArc* pArc = GetCurveArc( pCurve) ;
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ;
pArc->GetEndPoint( ptP3) ;
SetFeed( bReturn ? GetEndFeed() : GetFeed()) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) {
SetFlag( 0) ;
return false ;
}
}
SetFlag( 0) ;
// se ultima entità, uscita e se ultimo step retrazione
if ( i == nMaxInd) {
// se ultima passata, ripristino parametri originali di attacco/uscita
if ( j == nStep)
LioStatus.Restore() ;
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd = ( ! bReturn ? m_vtEndDir : -m_vtStartDir) ;
// elevazione sul punto finale
double dEndElev ;
if ( j == nStep) {
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
}
else
dEndElev = - GetLeadInOutToler() ;
// aggiungo uscita
Point3d ptP1 ;
Vector3d vtDir1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bReturn, pMyCompo, bSplitArcs, ptP1, vtDir1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// se non è return, imposto flag fine passata sull'ultima entità emessa
if ( ! bReturn) {
if ( ! SetFlagOnLastMove( 301))
return false ;
}
// per lame retrazione non è necessaria
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bOutStart, bool bAboveStart, bool bFirst, bool bSplitArcs)
{
SetFlag( 1) ;
// se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi)
bool bBottomStart = false ;
if ( m_bAggrBottom) {
// distanza dal bordo del pezzo (se negativa il punto è fuori dal grezzo)
double dDistBottom ;
if ( ! GetAggrBottDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, ( m_AggrBottom.dEncH + dSafeZ), dDistBottom))
dDistBottom = 0 ;
bBottomStart = ( dDistBottom < - 10 * EPS_SMALL) ;
// aggiuntivo in Z
double dAggZ = ( bBottomStart ? 0. : max( dElev + max( dSafeAggrBottZ, dAppr), 0.)) ;
// pre-approccio
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
// se richiede speciale rotazione
if ( m_AggrBottom.nType == 1) {
// punto ruotato
Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ;
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
if ( AddRapidStartOrMove( ptP00, bFirst, bSplitArcs, MCH_CL_AGB_DWN) == GDB_ID_NULL)
return false ;
// vado al punto standard
SetAuxDir( m_vtAggrBottom) ;
SetFlag( 0) ;
if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
}
// se altrimenti con rotazione per minimizzare la sporgenza
else if ( m_AggrBottom.nType == 3) {
// punto standard ruotato
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
if ( AddRapidStartOrMove( ptP0, bFirst, bSplitArcs, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
// la rotazione viene eseguita nel movimento successivo al punto sopra l'inizio lavorazione
SetAuxDir( m_vtAggrBottom) ;
SetFlag( 0) ;
}
// altrimenti rinvio normale
else {
SetAuxDir( m_vtAggrBottom) ;
if ( AddRapidStartOrMove( ptP0, bFirst, bSplitArcs, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
}
bFirst = false ;
}
// se testa da sopra senza aggregato da sotto e non con tavola basculante, approccio mai da Z negativo
// oppure testa da sotto, approccio mai da Z positivo
Vector3d vtAppr = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtAppr.z = 0 ;
vtAppr.Normalize() ;
}
// se non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
double dElevZ = vtAppr.z * dElev ;
if ( ! bAboveStart && ! bBottomStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
Point3d ptP1 = ptP + vtAppr * ( dElev + dAppr) ;
// se distanza di sicurezza minore di distanza di inizio
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 1 -> punto sopra inizio
if ( AddRapidStartOrMove( ptP1, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else {
// 1a -> punto molto sopra inizio
Point3d ptP1a = ptP1 + vtAppr * ( dSafeDist - dAppr) ;
if ( AddRapidStartOrMove( ptP1a, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
// 1 -> punto sopra inizio
if ( ( dElev + dAppr) > 10 * EPS_SMALL || (( dElev + dAppr) > -EPS_ZERO && dAppr > EPS_SMALL)) {
SetFlag( 0) ;
if ( AddRapidMove( ptP1, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else
ptP1 = ptP1a ;
}
// affondo al punto iniziale
SetFlag( 0) ;
bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP || m_TParams.m_nType == TT_MILL_POLISHING) ;
SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
if ( ! AreSamePointApprox( ptP1, ptP) && AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
return false ;
}
// sono sopra il pezzo ma non abbastanza
else if ( bAboveStart && ! m_bTiltingTab && ( min( dElevZ, 0.) + dAppr) > 10 * EPS_SMALL) {
// 1b -> punto appena sopra inizio (in Z globale)
Point3d ptP1b = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ;
if ( AddRapidStartOrMove( ptP1b, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
// affondo al punto iniziale
SetFlag( 0) ;
bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP || m_TParams.m_nType == TT_MILL_POLISHING) ;
SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
if ( AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
return false ;
}
// altrimenti
else {
// affondo diretto al punto iniziale
if ( AddRapidStartOrMove( ptP, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, const Vector3d& vtTool,
double dSafeZ, double dSawStElev, double dStElev, double dAppr,
bool bFirst, bool bSplitArcs, bool bAddInsert)
{
// per approccio orizzontale vtAppr deve essere già stato sistemato dal chiamante
SetFlag( 1) ;
// 1a -> punto fuori inizio
Point3d ptP1a = ptP + vtAppr * ( dSawStElev + max( dAppr, dSafeZ)) ;
bool bOutStart = true ;
// se necessario ulteriore approccio
if ( ! m_bTiltingTab) {
Vector3d vtMove = Vector3d( vtTool.x, vtTool.y, 0) ;
if ( vtMove.Normalize()) {
if ( m_bAboveHead && vtAppr.z < LIM_DOWN_APPRZ) {
// deve essere inizializzata a zero
double dExtraElev = 0 ;
if ( GetAhPointUnderRaw( ptP1a, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( false),
m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) {
Point3d ptP1e = ptP1a + vtMove * ( dExtraElev + dSafeZ) ;
if ( bAddInsert && ! AreSameVectorEpsilon( vtMove, vtTool, LIM_SIN_DIFF_DIR)) {
Point3d ptInsert = ptP1e + ( dStElev + dSafeZ) * vtTool ;
if ( AddRapidStartOrMove( ptInsert, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
if ( AddRapidMove( ptP1e, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else {
if ( AddRapidStartOrMove( ptP1e, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
}
bOutStart = false ;
}
}
else if ( ! m_bAboveHead && vtAppr.z > -LIM_DOWN_APPRZ) {
// deve essere inizializzata a zero
double dExtraElev = 0 ;
if ( GetUhPointAboveRaw( ptP1a, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( false),
m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) {
Point3d ptP1e = ptP1a + vtMove * ( dExtraElev + dSafeZ) ;
if ( bAddInsert && ! AreSameVectorEpsilon( vtMove, vtTool, LIM_SIN_DIFF_DIR)) {
Point3d ptInsert = ptP1e + ( dStElev + dSafeZ) * vtTool ;
if ( AddRapidStartOrMove( ptInsert, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
if ( AddRapidMove( ptP1e, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else {
if ( AddRapidStartOrMove( ptP1e, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
}
bOutStart = false ;
}
}
}
}
// punto fuori inizio
if ( bOutStart) {
if ( bAddInsert && ! AreSameVectorEpsilon( vtAppr, vtTool, LIM_SIN_DIFF_DIR)) {
Point3d ptInsert = ptP1a + ( dStElev + dSafeZ) * vtTool ;
if ( AddRapidStartOrMove( ptInsert, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
if ( AddRapidMove( ptP1a, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else {
if ( AddRapidStartOrMove( ptP1a, bFirst, bSplitArcs) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
}
}
else {
if ( AddRapidMove( ptP1a, bSplitArcs) == GDB_ID_NULL)
return false ;
}
// 1b -> punto appena sopra inizio (se necessario)
if ( dSafeZ > dAppr + 10 * EPS_SMALL && dSawStElev + dAppr > 10 * EPS_SMALL) {
Point3d ptP1b = ptP + vtAppr * ( dSawStElev + dAppr) ;
if ( AddRapidMove( ptP1b, bSplitArcs) == GDB_ID_NULL)
return false ;
}
// affondo al punto iniziale in feed
SetFeed( GetStartFeed()) ;
if ( AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddDirectApproach( const Point3d& ptP, bool bSplitArcs)
{
// affondo diretto al punto iniziale
SetFlag( 0) ;
SetFeed( GetStartFeed()) ;
if ( AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bAboveEnd, bool bSplitArcs)
{
// se testa da sopra senza aggregato da sotto, retrazione mai da Z negativo
Vector3d vtAppr = vtTool ;
if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
vtAppr.z = 0 ;
vtAppr.Normalize() ;
}
// se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi)
bool bBottomOutStart = false ;
double dDistBottom ;
if ( m_bAggrBottom) {
// distanza dal bordo del pezzo (se negativa il punto è fuori dal grezzo)
if ( ! GetAggrBottDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, ( m_AggrBottom.dEncH + dSafeZ), dDistBottom))
dDistBottom = 0 ;
bBottomOutStart = ( dDistBottom < - 10 * EPS_SMALL) ;
}
// se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
double dElevZ = vtAppr.z * dElev ;
if ( ! bAboveEnd && ! bBottomOutStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + vtAppr * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + vtAppr * ( dElev + dAppr) ;
if ( dElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + vtAppr * ( dSafeDist - dAppr) ;
if ( AddRapidMove( ptP4b, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
// sono sopra il pezzo ma non abbastanza
else if ( bAboveEnd && ! m_bTiltingTab && ( min( dElevZ, 0.) + dAppr) > 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ;
if ( AddLinearMove( ptP4, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ;
if ( dElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + Z_AX * ( dSafeDist - dAppr) ;
if ( AddRapidMove( ptP4b, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
// se con aggregato da sotto
if ( m_bAggrBottom) {
// se con rotazione per minimizzare la sporgenza
if ( m_AggrBottom.nType == 3) {
// imposto rotazione su punto standard
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
}
// aggiuntivo in Z
double dAggZ = ( bBottomOutStart ? 0. : max( dElev + max( dSafeAggrBottZ, dAppr), 0.)) ;
// post-retract
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_OUT) == GDB_ID_NULL)
return false ;
// se rinvio da sotto che richiede speciale rotazione
if ( m_AggrBottom.nType == 1) {
Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ;
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
if ( AddRapidMove( ptP00, bSplitArcs, MCH_CL_AGB_UP) == GDB_ID_NULL)
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, const Vector3d& vtTool,
double dSafeZ, double dSawEndElev, double dEndElev, double dAppr, bool bAddExtract)
{
// per retrazione orizzontale vtAppr deve essere già stato sistemato dal chiamante
Point3d ptP4 = ptP ;
// se sopra uscita c'è spazio per approccio
if ( dSawEndElev + dAppr > 10 * EPS_SMALL) {
SetFeed( GetEndFeed()) ;
ptP4 = ptP + vtRetr * ( dSawEndElev + dAppr) ;
if ( AddLinearMove( ptP4, MCH_CL_SAFEOUT) == GDB_ID_NULL)
return false ;
}
// se sopra uscita c'è spazio per sicurezza
if ( dSafeZ - dAppr > 10 * EPS_SMALL) {
ptP4 += vtRetr * ( dSafeZ - dAppr) ;
if ( AddRapidMove( ptP4) == GDB_ID_NULL)
return false ;
}
// se necessaria ulteriore uscita
Vector3d vtMove ;
double dMove = 0 ;
if ( ! m_bTiltingTab) {
vtMove = Vector3d( vtTool.x, vtTool.y, 0) ;
if ( vtMove.Normalize()) {
if ( m_bAboveHead && vtRetr.z < LIM_DOWN_APPRZ) {
// deve essere inizializzata a zero
double dExtraElev = 0 ;
if ( GetAhPointUnderRaw( ptP4, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( false),
m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) {
dMove = dExtraElev + dSafeZ ;
Point3d ptP4b = ptP4 + vtMove * dMove ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
}
else if ( ! m_bAboveHead && vtRetr.z > -LIM_DOWN_APPRZ) {
// deve essere inizializzata a zero
double dExtraElev = 0 ;
if ( GetUhPointAboveRaw( ptP4, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( false),
m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) {
dMove = dExtraElev + dSafeZ ;
Point3d ptP4b = ptP4 + vtMove * dMove ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
}
}
}
if ( bAddExtract && ! AreSameVectorEpsilon( vtRetr, vtTool, LIM_SIN_DIFF_DIR) &&
( ! AreSameVectorEpsilon( vtMove, vtTool, LIM_SIN_DIFF_DIR) || dEndElev + dSafeZ > dMove + 10 * EPS_SMALL)) {
Point3d ptCurr ;
if ( ! GetCurrPos( ptCurr))
return false ;
Point3d ptExtract = ptCurr + ( dEndElev + dSafeZ - dMove) * vtTool ;
if ( AddRapidMove( ptExtract) == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
int
Milling::GetLeadInType( void) const
{
if ( abs( m_Params.m_dLiTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
abs( m_Params.m_dLiPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1))
return MILL_LI_NONE ;
if ( m_Params.m_nLeadInType == MILL_LI_GLIDE && m_Params.m_dLiElev < 10 * EPS_SMALL)
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) &&
( m_Params.m_dLiTang < min( 0.1 * m_TParams.m_dDiam, 1.0) || m_Params.m_dLiElev < 10 * EPS_SMALL))
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) &&
m_bStepOn && m_Params.m_nStepType == MILL_ST_SPIRAL)
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) &&
( m_TParams.m_nType & TF_SAWBLADE) != 0)
return MILL_LI_LINEAR ;
return m_Params.m_nLeadInType ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool,
double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1, Vector3d& vtDir1) const
{
// Assegno tipo e parametri
int nType = GetLeadInType() ;
double dTang = m_Params.m_dLiTang ;
double dPerp = m_Params.m_dLiPerp ;
double dElev = m_Params.m_dLiElev ;
if ( m_TParams.m_nType != TT_MILL_POLISHING)
dElev = min( m_Params.m_dLiElev, dStElev + GetLeadInOutToler()) ;
// se step invertito
if ( bInvert) {
// va aggiustato se non zigzag o spirale
if ( nType != MILL_LI_ZIGZAG && nType != MILL_LI_HELIX) {
switch ( GetLeadOutType()) {
case MILL_LO_LINEAR : nType = MILL_LI_LINEAR ; break ;
case MILL_LO_PERP_TG : nType = MILL_LI_TG_PERP ; break ;
case MILL_LO_TANGENT : nType = MILL_LI_TANGENT ; break ;
case MILL_LO_GLIDE : nType = MILL_LI_GLIDE ; break ;
case MILL_LO_AS_LI : /* resta inalterato */ ; break ;
default : nType = MILL_LI_NONE ; break ;
}
if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
dTang = m_Params.m_dLoTang ;
dPerp = m_Params.m_dLoPerp ;
dElev = m_Params.m_dLoElev ;
if ( m_TParams.m_nType != TT_MILL_POLISHING)
dElev = min( m_Params.m_dLoElev, dStElev + GetLeadInOutToler()) ;
}
}
}
// senso di rotazione da dir tg a dir esterna
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
// verifico di poter fare l'ingresso a inseguimento
if ( nType == MILL_LI_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL)
nType = MILL_LI_NONE ;
// Calcolo punto iniziale
switch ( nType) {
case MILL_LI_NONE :
ptP1 = ptStart ;
vtDir1 = -vtStart ;
return true ;
case MILL_LI_LINEAR : {
Vector3d vtPerp = vtStart ;
Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : -1)) ;
ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
vtDir1 = ptP1 - ptStart ;
if ( ! vtDir1.Normalize())
return false ;
bool bOk = true ;
// eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
if ( m_Params.m_dLiCompLen > 10 * EPS_SMALL) {
vtDir1 = OrthoCompo( vtDir1, vtTool) ;
bOk = bOk && vtDir1.Normalize() ;
vtDir1.Rotate( vtRot, 0, ( bCcwRot ? -1 : 1)) ;
ptP1 += vtDir1 * m_Params.m_dLiCompLen ;
}
return bOk ;
}
case MILL_LI_TG_PERP : {
Vector3d vtPerp = vtStart ;
Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : -1)) ;
ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
vtDir1 = ptP1 - ptStart ;
return vtDir1.Normalize() ;
}
case MILL_LI_TANGENT : {
Vector3d vtPerp = vtStart ;
Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : -1)) ;
ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
vtDir1 = ptP1 - ptStart ;
if ( ! vtDir1.Normalize())
return false ;
bool bOk = true ;
// eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
if ( m_Params.m_dLiCompLen > 10 * EPS_SMALL) {
PtrOwner<ICurve> pCrv( GetArc2PVN( ptStart, ptP1, - vtStart, vtTool)) ;
bOk = bOk && ! IsNull( pCrv) && pCrv->GetEndDir( vtDir1) ;
vtDir1 = OrthoCompo( vtDir1, vtTool) ;
bOk = bOk && vtDir1.Normalize() ;
vtDir1.Rotate( vtRot, 0, ( bCcwRot ? -1 : 1)) ;
ptP1 += vtDir1 * m_Params.m_dLiCompLen ;
}
return bOk ;
}
case MILL_LI_GLIDE :
{
if ( ! bInvert) {
double dLen, dU ;
if ( ! pCompo->GetLength( dLen) || ! pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU) ||
! pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) {
if ( ! pCompo->GetStartPoint( ptP1))
return false ;
}
}
else {
double dU ;
if ( ! pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU) ||
! pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) {
if ( ! pCompo->GetEndPoint( ptP1))
return false ;
}
}
ptP1 += vtTool * ( vtTool * ( ptStart - ptP1)) + vtTool * dElev ;
vtDir1 = ptP1 - ptStart ;
return vtDir1.Normalize() ;
}
case MILL_LI_ZIGZAG :
ptP1 = ptStart ;
vtDir1 = -vtStart ;
return true ;
case MILL_LI_HELIX :
ptP1 = ptStart ;
vtDir1 = -vtStart ;
return true ;
default :
return false ;
}
}
//----------------------------------------------------------------------------
bool
Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
const Vector3d& vtTool, double dStElev, bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs)
{
// Assegno il tipo
int nType = GetLeadInType() ;
double dTang = m_Params.m_dLiTang ;
double dPerp = m_Params.m_dLiPerp ;
double dElev = m_Params.m_dLiElev ;
if ( m_TParams.m_nType != TT_MILL_POLISHING)
dElev = min( m_Params.m_dLiElev, dStElev + GetLeadInOutToler()) ;
// se step invertito
if ( bInvert) {
// va aggiustato se non zigzag o spirale
if ( nType != MILL_LI_ZIGZAG && nType != MILL_LI_HELIX) {
switch ( GetLeadOutType()) {
case MILL_LO_LINEAR : nType = MILL_LI_LINEAR ; break ;
case MILL_LO_PERP_TG : nType = MILL_LI_TG_PERP ; break ;
case MILL_LO_TANGENT : nType = MILL_LI_TANGENT ; break ;
case MILL_LO_GLIDE : nType = MILL_LI_GLIDE ; break ;
case MILL_LO_AS_LI : /* resta inalterato */ ; break ;
default : nType = MILL_LI_NONE ; break ;
}
if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
dTang = m_Params.m_dLoTang ;
dPerp = m_Params.m_dLoPerp ;
dElev = m_Params.m_dLoElev ;
if ( m_TParams.m_nType != TT_MILL_POLISHING)
dElev = min( m_Params.m_dLoElev, dStElev + GetLeadInOutToler()) ;
}
}
}
// senso di rotazione da dir tg a dir esterna
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
// verifico di poter fare l'ingresso a inseguimento
if ( nType == MILL_LI_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL)
nType = MILL_LI_NONE ;
// Eseguo a seconda del tipo
switch ( nType) {
case MILL_LI_NONE :
return true ;
case MILL_LI_LINEAR :
// se c'è elevazione di attacco e utensile flottante faccio precedere solo movimento in elevazione
if ( m_bTHoldFloating && dElev > 10 * EPS_SMALL) {
Point3d ptMid = ptP1 - dElev * vtTool ;
if ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
dElev = 0 ;
}
// eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
if ( m_Params.m_dLiCompLen > 10 * EPS_SMALL) {
Vector3d vtPerp = vtStart ;
Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
Point3d ptMid = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
if ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
case MILL_LI_TG_PERP :
{
Vector3d vtPerp = vtStart ;
Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
Point3d ptMid = ptStart + vtPerp * dPerp ;
return ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL &&
AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
case MILL_LI_TANGENT :
{
Point3d ptMid = ptP1 ;
// se c'è elevazione di attacco e utensile flottante faccio precedere solo movimento in elevazione
if ( m_bTHoldFloating && dElev > 10 * EPS_SMALL) {
ptMid += - dElev * vtTool ;
if ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
dElev = 0 ;
}
// eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
if ( m_Params.m_dLiCompLen > 10 * EPS_SMALL) {
Vector3d vtPerp = vtStart ;
Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptMid = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
if ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
PtrOwner<ICurve> pCrv( GetArc2PVN( ptStart, ptMid, - vtStart, vtTool)) ;
if ( IsNull( pCrv))
return false ;
pCrv->Invert() ;
return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
case MILL_LI_GLIDE :
{
// recupero la parte richiesta della curva
PtrOwner<ICurveComposite> pCrv ;
if ( ! bInvert) {
double dLen, dU ;
if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)) {
double dParS, dParE ;
pCompo->GetDomain( dParS, dParE) ;
if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dU, dParE))))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
if ( m_dAddedOverlap > EPS_SMALL) {
pCrv->Invert() ;
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
pCrv->Invert() ;
}
}
else {
double dU ;
if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) {
if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( 0, dU))))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
if ( m_dAddedOverlap > EPS_SMALL)
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
pCrv->Invert() ;
}
pCrv->SetExtrusion( vtTool) ;
// la porto alla giusta quota
Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
Vector3d vtMove = ptStart - ptFin ;
pCrv->Translate( vtMove) ;
// assegno la corretta pendenza
double dNini = ( ptP1 - ORIG) * vtTool ;
double dNfin = ( ptStart - ORIG) * vtTool ;
AdjustCurveSlope( pCrv, dNini, dNfin) ;
// emetto (con eventuale spezzatura)
return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
case MILL_LI_ZIGZAG :
{
// recupero la parte richiesta della curva
PtrOwner<ICurveComposite> pCrv ;
if ( ! bInvert) {
double dU ;
if ( pCompo->GetParamAtLength( dTang, dU)) {
double dParS, dParE ;
pCompo->GetDomain( dParS, dParE) ;
if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dParS, dU))))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
}
else {
double dLen, dU ;
if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - dTang, dU)) {
double dParS, dParE ;
pCompo->GetDomain( dParS, dParE) ;
if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dU, dParE))))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
pCrv->Invert() ;
}
pCrv->SetExtrusion( vtTool) ;
// la porto alla giusta quota
Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
Vector3d vtMove = ptStart - ptIni ;
pCrv->Translate( vtMove) ;
// la ripeto a zigzag
double dDeltaN = ( ptStart - ptP1) * vtTool ;
int nStep = int( ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL))) ;
double dStep = - dDeltaN / nStep ;
for ( int i = 1 ; i <= nStep ; ++ i) {
// calcolo quote per pendenza
double dNini = ( ptP1 - ORIG) * vtTool - ( i - 1) * dStep ;
double dNmid = dNini - 0.5 * dStep ;
double dNfin = dNmid - 0.5 * dStep ;
// copio per zig
PtrOwner<ICurveComposite> pCopy1( pCrv->Clone()) ;
// assegno la corretta pendenza
AdjustCurveSlope( pCopy1, dNini, dNmid) ;
// emetto
if ( AddCurveMove( pCopy1, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
// copio per zag
PtrOwner<ICurveComposite> pCopy2( pCrv->Clone()) ;
pCopy2->Invert() ;
// assegno la corretta pendenza
AdjustCurveSlope( pCopy2, dNmid, dNfin) ;
// emetto
if ( AddCurveMove( pCopy2, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
return true ;
}
case MILL_LI_HELIX :
{
bool bAtLeft = ( bInvert != ( m_Params.m_nWorkSide != MILL_WS_RIGHT)) ;
// vettore dal punto al centro elica
Vector3d vtCen = vtStart ;
vtCen.Rotate( vtTool, 0, ( bAtLeft ? 1 : - 1)) ;
// dati dell'elica
double dRad = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
Point3d ptCen = ptP1 + vtCen * dRad ;
double dDeltaN = ( ptStart - ptP1) * vtTool ;
double dAngCen = ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL)) * ( bAtLeft ? ANG_FULL : - ANG_FULL) ;
// creo l'elica
PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
if ( IsNull( pArc) || ! pArc->Set( ptCen, vtTool, dRad, - vtCen, dAngCen, dDeltaN))
return false ;
// emetto l'elica (con eventuale spezzatura)
return ( AddCurveMove( pArc, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
default :
return false ;
}
}
//----------------------------------------------------------------------------
int
Milling::GetLeadOutType( void) const
{
if ( abs( m_Params.m_dLoTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
abs( m_Params.m_dLoPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
m_Params.m_nLeadOutType != MILL_LO_AS_LI)
return MILL_LO_NONE ;
if ( m_Params.m_nLeadOutType == MILL_LO_GLIDE && m_Params.m_dLoElev < 10 * EPS_SMALL)
return MILL_LO_NONE ;
return m_Params.m_nLeadOutType ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtTool,
double dEndElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const
{
// assegno i parametri
int nType = GetLeadOutType() ;
double dTang = m_Params.m_dLoTang ;
double dPerp = m_Params.m_dLoPerp ;
double dElev = m_Params.m_dLoElev ;
if ( m_TParams.m_nType != TT_MILL_POLISHING)
dElev = min( m_Params.m_dLoElev, dEndElev + GetLeadInOutToler()) ;
// se uscita come ingresso o step invertito
if ( nType == MILL_LO_AS_LI || bInvert) {
int nLiType = GetLeadInType() ;
switch ( nLiType) {
case MILL_LI_LINEAR : nType = MILL_LO_LINEAR ; break ;
case MILL_LI_TG_PERP : nType = MILL_LO_PERP_TG ; break ;
case MILL_LI_TANGENT : nType = MILL_LO_TANGENT ; break ;
case MILL_LI_GLIDE : nType = MILL_LO_GLIDE ; break ;
case MILL_LI_ZIGZAG : nType = MILL_LO_NONE ; break ;
case MILL_LI_HELIX : nType = MILL_LO_NONE ; break ;
default : nType = MILL_LO_NONE ; break ;
}
dTang = m_Params.m_dLiTang ;
dPerp = m_Params.m_dLiPerp ;
if ( nLiType == MILL_LI_HELIX) {
dTang = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
dPerp = dTang ;
}
dElev = m_Params.m_dLiElev ;
if ( m_TParams.m_nType != TT_MILL_POLISHING)
dElev = min( m_Params.m_dLiElev, dEndElev + GetLeadInOutToler()) ;
}
// senso di rotazione da dir tg a dir esterna
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
// verifico di poter fare l'uscita a inseguimento
if ( nType == MILL_LO_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL)
nType = MILL_LO_NONE ;
// eseguo a seconda del tipo
switch ( nType) {
case MILL_LO_NONE :
ptP1 = ptEnd ;
return true ;
case MILL_LO_LINEAR :
{
Vector3d vtPerp = vtEnd ;
Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtTool * dElev ;
if ( m_Params.m_dLoCompLen > 10 * EPS_SMALL) {
Vector3d vtPerp2 = vtEnd * dTang + vtPerp * dPerp ;
if ( vtPerp2.Normalize()) {
vtPerp2.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 += vtPerp2 * m_Params.m_dLoCompLen ;
}
}
return true ;
}
case MILL_LO_PERP_TG :
{
Vector3d vtPerp = vtEnd ;
Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
Point3d ptMid = ptEnd + vtPerp * dPerp ;
ptP1 = ptMid + vtEnd * dTang + vtTool * dElev ;
return true ;
}
case MILL_LO_TANGENT :
{
// calcolo punto finale dell'uscita
Vector3d vtPerp = vtEnd ;
Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtTool * dElev ;
if ( m_Params.m_dLoCompLen > 10 * EPS_SMALL) {
Vector3d vtPerp2 = vtEnd * dTang + vtPerp * dPerp ;
if ( vtPerp2.Normalize()) {
vtPerp2.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 += vtPerp2 * m_Params.m_dLoCompLen ;
}
}
return true ;
}
case MILL_LO_GLIDE :
{
// recupero la parte richiesta della curva di ritorno
PtrOwner<ICurveComposite> pCrv ;
if ( ! bInvert) {
double dU ;
if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) {
if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( 0, dU))))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
if ( m_dAddedOverlap > EPS_SMALL)
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
}
else {
double dLen, dU ;
if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)) {
double dParS, dParE ;
pCompo->GetDomain( dParS, dParE) ;
if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dU, dParE))))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
pCrv->Invert() ;
if ( m_dAddedOverlap > EPS_SMALL)
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
}
pCrv->SetExtrusion( vtTool) ;
// la porto alla giusta quota
Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
Vector3d vtMove = ptEnd - ptIni ;
pCrv->Translate( vtMove) ;
// assegno la corretta pendenza
double dNini = ( ptEnd - ORIG) * vtTool ;
AdjustCurveSlope( pCrv, dNini, dNini + dElev) ;
// assegno punto finale dell'uscita
pCrv->GetEndPoint( ptP1) ;
return true ;
}
default :
return false ;
}
}
//----------------------------------------------------------------------------
bool
Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtTool, double dEndElev,
bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs, Point3d& ptP1, Vector3d& vtDir1)
{
// assegno i parametri
int nType = GetLeadOutType() ;
double dTang = m_Params.m_dLoTang ;
double dPerp = m_Params.m_dLoPerp ;
double dElev = m_Params.m_dLoElev ;
if ( m_TParams.m_nType != TT_MILL_POLISHING)
dElev = min( m_Params.m_dLoElev, dEndElev + GetLeadInOutToler()) ;
// se uscita come ingresso o step invertito
if ( nType == MILL_LO_AS_LI || bInvert) {
int nLiType = GetLeadInType() ;
switch ( nLiType) {
case MILL_LI_LINEAR : nType = MILL_LO_LINEAR ; break ;
case MILL_LI_TG_PERP : nType = MILL_LO_PERP_TG ; break ;
case MILL_LI_TANGENT : nType = MILL_LO_TANGENT ; break ;
case MILL_LI_GLIDE : nType = MILL_LO_GLIDE ; break ;
case MILL_LI_ZIGZAG : nType = MILL_LO_NONE ; break ;
case MILL_LI_HELIX : nType = MILL_LO_NONE ; break ;
default : nType = MILL_LO_NONE ; break ;
}
dTang = m_Params.m_dLiTang ;
dPerp = m_Params.m_dLiPerp ;
if ( nLiType == MILL_LI_HELIX) {
dTang = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
dPerp = dTang ;
}
dElev = m_Params.m_dLiElev ;
if ( m_TParams.m_nType != TT_MILL_POLISHING)
dElev = min( m_Params.m_dLiElev, dEndElev + GetLeadInOutToler()) ;
}
// senso di rotazione da dir tg a dir esterna
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
// verifico di poter fare l'uscita a inseguimento
if ( nType == MILL_LO_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL)
nType = MILL_LO_NONE ;
// eseguo a seconda del tipo
switch ( nType) {
case MILL_LO_NONE :
ptP1 = ptEnd ;
vtDir1 = vtEnd ;
return true ;
case MILL_LO_LINEAR :
{
// se utensile flottante, l'elevazione va tutta in un movimento finale aggiuntivo
double dFloatElev = 0 ;
if ( m_bTHoldFloating)
swap( dElev, dFloatElev) ;
// calcolo punto finale dell'uscita
Vector3d vtPerp = vtEnd ;
Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtTool * dElev ;
vtDir1 = ptP1 - ptEnd ;
if ( ! vtDir1.Normalize())
return false ;
// inserisco movimento di uscita
bool bOk = ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
// eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
if ( m_Params.m_dLoCompLen > 10 * EPS_SMALL) {
vtDir1 = OrthoCompo( vtDir1, vtTool) ;
bOk = bOk && vtDir1.Normalize() ;
vtDir1.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 += vtDir1 * m_Params.m_dLoCompLen ;
bOk = bOk && ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
// eventuale movimento in elevazione per flottante
if ( m_bTHoldFloating && dFloatElev > 10 * EPS_SMALL) {
ptP1 += dFloatElev * vtTool ;
bOk = bOk && ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
return bOk ;
}
case MILL_LO_PERP_TG :
{
Vector3d vtPerp = vtEnd ;
Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
Point3d ptMid = ptEnd + vtPerp * dPerp ;
ptP1 = ptMid + vtEnd * dTang + vtTool * dElev ;
vtDir1 = ptP1 - ptMid ; vtDir1.Normalize() ;
return ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL &&
AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
case MILL_LO_TANGENT :
{
// se utensile flottante, l'elevazione va tutta in un movimento finale aggiuntivo
double dFloatElev = 0 ;
if ( m_bTHoldFloating)
swap( dElev, dFloatElev) ;
// calcolo punto finale dell'uscita
Vector3d vtPerp = vtEnd ;
Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtTool * dElev ;
vtDir1 = ptP1 - ptEnd ;
if ( ! vtDir1.Normalize())
return false ;
// inserisco movimento di uscita
PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtTool)) ;
if ( IsNull( pCrv))
return false ;
Vector3d vtDirF ;
if ( ! pCrv->GetEndDir( vtDirF))
return false ;
bool bOk = true ;
bOk = ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
// eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
if ( m_Params.m_dLoCompLen > 10 * EPS_SMALL) {
vtDir1 = OrthoCompo( vtDirF, vtTool) ;
bOk = bOk && vtDir1.Normalize() ;
vtDir1.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 += vtDir1 * m_Params.m_dLoCompLen ;
bOk = bOk && ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
// eventuale movimento in elevazione per flottante
if ( m_bTHoldFloating && dFloatElev > 10 * EPS_SMALL) {
ptP1 += dFloatElev * vtTool ;
bOk = bOk && ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
return bOk ;
}
case MILL_LO_GLIDE :
{
// recupero la parte richiesta della curva di ritorno
PtrOwner<ICurveComposite> pCrv ;
if ( ! bInvert) {
double dU ;
if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) {
if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( 0, dU))))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
if ( m_dAddedOverlap > EPS_SMALL)
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
}
else {
double dLen, dU ;
if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)) {
double dParS, dParE ;
pCompo->GetDomain( dParS, dParE) ;
if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dU, dParE))))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
pCrv->Invert() ;
if ( m_dAddedOverlap > EPS_SMALL)
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
}
pCrv->SetExtrusion( vtTool) ;
// la porto alla giusta quota
Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
Vector3d vtMove = ptEnd - ptIni ;
pCrv->Translate( vtMove) ;
// assegno la corretta pendenza
double dNini = ( ptEnd - ORIG) * vtTool ;
AdjustCurveSlope( pCrv, dNini, dNini + dElev) ;
// emetto
AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) ;
// assegno punto e direzione finale dell'uscita
pCrv->GetEndPoint( ptP1) ;
pCrv->GetEndDir( vtDir1) ;
return true ;
}
default :
return false ;
}
}
//----------------------------------------------------------------------------
bool
Milling::AdjustOscillParams( const ICurve* pCrv, bool& bPathOscEnable, double& dRampLen, double& dFlatLen)
{
// se c'è oscillazione cerco di aggiustare le lunghezze dei Flat per finire con la stessa quota di partenza
dRampLen = abs( m_Params.m_dOscRampLen) ;
dFlatLen = abs( m_Params.m_dOscFlatLen) ;
if ( bPathOscEnable) {
// lunghezza del percorso
double dLen ; pCrv->GetLength( dLen) ;
// se percorso più corto di mezza oscillazione, la disabilito
if ( dLen < 2 * dRampLen + 2 * OSC_MIN_LEN) {
bPathOscEnable = false ;
m_pMchMgr->SetWarning( 2361, "Warning in Milling : oscillation impossible") ;
}
else {
int nOsc = max( static_cast<int>( dLen / ( 2 * dRampLen + 2 * dFlatLen)), 1) ;
dFlatLen = ( dLen - nOsc * 2 * dRampLen) / ( 2 * nOsc) ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddOscillLine( const ICurveLine* pLine, const Vector3d& vtTool, double dRampLen, double dFlatLen)
{
// lunghezze dei tratti di oscillazione
dRampLen = max( dRampLen, OSC_MIN_LEN) ;
dFlatLen = max( dFlatLen, OSC_MIN_LEN) ;
double vLenRef[4] = { dRampLen, dRampLen + dFlatLen, 2 * dRampLen + dFlatLen, 2 * dRampLen + 2 * dFlatLen} ;
// lunghezza della linea
double dLen ; pLine->GetLength( dLen) ;
// lunghezza corrente sulla linea
double dCurrLen = 0 ;
// emissione oscillazioni
while ( dCurrLen < dLen - EPS_ZERO) {
// lunghezza rimanente
double dNextLen = dLen - dCurrLen ;
// se inizio è sul primo tratto (rampa discendente)
if ( m_dCurrOscillLen < vLenRef[0] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrOscillLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * m_dCurrOscillLen / vLenRef[0]) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrOscillLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen = vLenRef[0] ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[0] - m_dCurrOscillLen ;
m_dCurrOscillLen = vLenRef[0] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul secondo tratto (parte piatta in basso)
else if ( m_dCurrOscillLen < vLenRef[1] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrOscillLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrOscillLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen = vLenRef[1] ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[1] - m_dCurrOscillLen ;
m_dCurrOscillLen = vLenRef[1] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul terzo tratto (rampa ascendente)
else if ( m_dCurrOscillLen < vLenRef[2] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrOscillLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * ( vLenRef[2] - m_dCurrOscillLen) / ( vLenRef[2] - vLenRef[1])) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrOscillLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen = vLenRef[2] ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[2] - m_dCurrOscillLen ;
m_dCurrOscillLen = vLenRef[2] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// altrimenti è sul quarto tratto (parte piatta in alto)
else {
// se fine linea è entro il tratto
if ( m_dCurrOscillLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrOscillLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen = 0 ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[3] - m_dCurrOscillLen ;
m_dCurrOscillLen = 0 ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddOscillArc( const ICurveArc* pArc, const Vector3d& vtTool, double dRampLen, double dFlatLen)
{
// lunghezze dei tratti di oscillazione
dRampLen = max( dRampLen, OSC_MIN_LEN) ;
dFlatLen = max( dFlatLen, OSC_MIN_LEN) ;
double vLenRef[4] = { dRampLen, dRampLen + dFlatLen, 2 * dRampLen + dFlatLen, 2 * dRampLen + 2 * dFlatLen} ;
// parametria dell'arco
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
double dLen ; pArc->GetLength( dLen) ;
// lunghezza corrente sull'arco
double dCurrLen = 0 ;
// emissione oscillazioni
while ( dCurrLen < dLen - EPS_ZERO) {
// lunghezza rimanente
double dNextLen = dLen - dCurrLen ;
// se inizio è sul primo tratto (rampa discendente)
if ( m_dCurrOscillLen < vLenRef[0] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrOscillLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * m_dCurrOscillLen / vLenRef[0]) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrOscillLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen = vLenRef[0] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[0] - m_dCurrOscillLen ;
m_dCurrOscillLen = vLenRef[0] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul secondo tratto (parte piatta in basso)
else if ( m_dCurrOscillLen < vLenRef[1] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrOscillLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrOscillLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen = vLenRef[1] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[1] - m_dCurrOscillLen ;
m_dCurrOscillLen = vLenRef[1] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul terzo tratto (rampa ascendente)
else if ( m_dCurrOscillLen < vLenRef[2] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrOscillLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * ( vLenRef[2] - m_dCurrOscillLen) / ( vLenRef[2] - vLenRef[1])) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrOscillLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen = vLenRef[2] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[2] - m_dCurrOscillLen ;
m_dCurrOscillLen = vLenRef[2] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// altrimenti è sul quarto tratto (parte piatta in alto)
else {
// se fine linea è entro il tratto
if ( m_dCurrOscillLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrOscillLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrOscillLen = 0 ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[3] - m_dCurrOscillLen ;
m_dCurrOscillLen = 0 ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, TabData& tdTabs)
{
// se ci sono i tab cerco di aggiustare le lunghezze dei Bottom per finire con la stessa quota di partenza
double dTabLen = m_Params.m_dTabLen + m_TParams.m_dDiam ;
double dTabAngle = Clamp( abs( m_Params.m_dTabAngle), 15., 75.) ;
tdTabs.m_dRampLen = min( abs( m_Params.m_dTabHeight) / tan( dTabAngle * DEGTORAD), abs( dTabLen) / 2 - OSC_MIN_LEN) ;
tdTabs.m_dTopLen = abs( dTabLen) - 2 * tdTabs.m_dRampLen ;
tdTabs.m_dBottomLen = abs( m_Params.m_dTabDist) - abs( dTabLen) ;
if ( bPathTabsEnable) {
// lunghezza del percorso
double dLen ; pCrv->GetLength( dLen) ; dLen -= m_dAddedOverlap ;
// se percorso non permette nemmeno un tab disabilito
if ( dLen < ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen)) {
bPathTabsEnable = false ;
m_pMchMgr->SetWarning( 2363, "Warning in Milling : tabs impossible") ;
}
else {
// calcolo numero di tabs e distanza
int nTabs = max( static_cast<int>( dLen / ( 2 * tdTabs.m_dRampLen + tdTabs.m_dBottomLen + tdTabs.m_dTopLen)), 0) ;
nTabs = min( nTabs, m_Params.m_nTabMax) ;
if ( nTabs < m_Params.m_nTabMin) {
if ( dLen > ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen) * m_Params.m_nTabMin)
nTabs = m_Params.m_nTabMin ;
else
m_pMchMgr->SetWarning( 2364, "Warning in Milling : tabs number less than minimum") ;
}
if ( nTabs > 0)
tdTabs.m_dBottomLen = ( dLen - nTabs * ( 2 * tdTabs.m_dRampLen + tdTabs.m_dTopLen)) / nTabs ;
}
}
// verifico che le lughezze non siano inferiori al minimo
tdTabs.m_dRampLen = max( tdTabs.m_dRampLen, OSC_MIN_LEN) ;
tdTabs.m_dBottomLen = max( tdTabs.m_dBottomLen, OSC_MIN_LEN) ;
tdTabs.m_dTopLen = max( tdTabs.m_dTopLen, OSC_MIN_LEN) ;
return true ;
}
//----------------------------------------------------------------------------
static void
PeriodicIntervalsSubract( Intervals& ivItv, double dPeriod, double dMin, double dMax)
{
if ( dMin < - EPS_SMALL) {
ivItv.Subtract( dPeriod + dMin, dPeriod) ;
dMin = 0 ;
}
if ( dMax > dPeriod + EPS_SMALL) {
ivItv.Subtract( dMin, dPeriod) ;
dMax -= dPeriod ;
}
if ( dMin < dMax)
ivItv.Subtract( dMin, dMax) ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcTabsPositions( const ICurveComposite* pCompo, double dDepth, bool bPathTabsEnable, const TabData& tdTabs, DBLVECTOR& vdTabs)
{
// reset posizioni Tabs
vdTabs.clear() ;
// recupero gruppo ausiliario per Tabs
int nTabsId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_TABS) ;
// se Tabs non abilitati, cancello gruppo ausiliario relativo ed esco
if ( ! bPathTabsEnable) {
m_pGeomDB->Erase( nTabsId) ;
return true ;
}
// disabilito eventuale registrazione comandi EXE (riabilitazione automatica)
CmdLogOff cmdLogOff ;
// creo o svuoto gruppo ausiliario tabs
if ( nTabsId == GDB_ID_NULL) {
nTabsId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nTabsId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nTabsId, MCH_TABS) ;
}
// altrimenti, lo svuoto
else
m_pGeomDB->EmptyGroup( nTabsId) ;
// lunghezza di un Tab
double dTabLen = tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen ;
// lunghezza del percorso
double dLen ; pCompo->GetLength( dLen) ; dLen -= m_dAddedOverlap ;
// vettore estrusione del percorso
Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;
if ( vtExtr.IsSmall())
vtExtr = Z_AX ;
// determinazione intervalli validi
Intervals ivTabs ;
// inizializzo intervallo valido (non sono ammessi tab a cavallo di inizio/fine)
ivTabs.Set( 0, dLen - dTabLen) ;
// elimino le zone con piccolo raggio e quelle vicine agli angoli
const double RAD_MIN = 50 ;
const double CORNER_RAG = 2 ;
const double CORNER_ANG = 5 ;
const double CORNER_DIST = 2 ;
bool bContinue = true ;
double dJointLen = 0 ;
const ICurve* pCurrCrv = pCompo->GetFirstCurve() ;
const ICurve* pNextCrv = pCompo->GetNextCurve() ;
while ( pNextCrv != nullptr) {
// calcolo lunghezza entità
double dEntLen = 0 ;
pCurrCrv->GetLength( dEntLen) ;
// se arco, verifico se spigolo o inferiore a raggio minimo
const ICurveArc* pArc = GetCurveArc( pCurrCrv) ;
if ( pArc != nullptr) {
// determino il raggio sul profilo
bool bCCW = ( pArc->GetAngCenter() > 0) ;
double dRad = pArc->GetRadius() ;
if ( m_Params.m_nWorkSide == MILL_WS_LEFT)
dRad += m_TParams.m_dDiam / 2 * ( bCCW ? 1 : -1) ;
else if ( m_Params.m_nWorkSide == MILL_WS_RIGHT)
dRad += m_TParams.m_dDiam / 2 * ( bCCW ? -1 : 1) ;
// se raggio molto piccolo è uno spigolo
if ( dRad < CORNER_RAG) {
double dMin = dJointLen - CORNER_DIST - dTabLen ;
double dMax = dJointLen + dEntLen + CORNER_DIST ;
PeriodicIntervalsSubract( ivTabs, dLen, dMin, dMax) ;
}
// se raggio è piccolo
else if ( dRad < RAD_MIN) {
double dMin = dJointLen - dTabLen ;
double dMax = dJointLen + dEntLen ;
PeriodicIntervalsSubract( ivTabs, dLen, dMin, dMax) ;
}
}
// aggiorno lunghezza alla giunzione con la successiva
dJointLen += dEntLen ;
// verifico se angolo tra le entità
Vector3d vtTg1 ; pCurrCrv->GetEndDir( vtTg1) ;
Vector3d vtTg2 ; pNextCrv->GetStartDir( vtTg2) ;
if ( abs( ( vtTg1 ^ vtTg2) * vtExtr) > sin( CORNER_ANG * DEGTORAD)) {
double dMin = dJointLen - CORNER_DIST - dTabLen ;
double dMax = dJointLen + CORNER_DIST ;
PeriodicIntervalsSubract( ivTabs, dLen, dMin, dMax) ;
}
// passo al successivo
pCurrCrv = pNextCrv ;
if ( bContinue) {
pNextCrv = pCompo->GetNextCurve() ;
if ( pNextCrv == nullptr && pCompo->IsClosed()) {
pNextCrv = pCompo->GetFirstCurve() ;
bContinue = false ;
}
}
else
pNextCrv = nullptr ;
}
// determino posizioni di inizio dei Tabs
double dLastIns = -1 - 2 * dTabLen ;
double dNextTab = 0.5 * tdTabs.m_dBottomLen ;
double dCurrLen = 0 ;
while ( dCurrLen + dNextTab < dLen) {
double dPos = dCurrLen + dNextTab ;
double dPrev, dNext ;
if ( ivTabs.IsInside( dPos)) {
vdTabs.emplace_back( dPos) ;
dLastIns = dPos ;
}
else if ( ivTabs.GetPrevNearest( dPos, dPrev) && dPrev > dLastIns + 1.5 * dTabLen) {
vdTabs.emplace_back( dPrev) ;
dLastIns = dPrev ;
}
else if ( ivTabs.GetNextNearest( dPos, dNext) && dNext > dLastIns + dTabLen) {
vdTabs.emplace_back( dNext) ;
dLastIns = dNext ;
}
dCurrLen += dNextTab + dTabLen ;
dNextTab = tdTabs.m_dBottomLen ;
}
// recupero posizioni tabs adiacenti di precedenti lavorazioni, se accettabili
DBLVECTOR vdAdj ;
double dMaxDist = m_TParams.m_dDiam + 10. ;
BBox3d b3Mill ;
m_pGeomDB->GetGlobalBBox( m_nOwnerId, b3Mill) ;
b3Mill.Expand( dMaxDist) ;
int nOpeId = m_pMchMgr->GetNextActiveOperation( m_pMchMgr->GetPhaseDisposition( m_nPhase)) ;
while ( nOpeId != GDB_ID_NULL && m_pMchMgr->GetOperationPhase( nOpeId) == m_nPhase) {
if ( nOpeId != m_nOwnerId) {
int nTabId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetFirstNameInGroup( nOpeId, MCH_TABS)) ;
while ( nTabId != GDB_ID_NULL) {
Point3d ptCen ;
if ( ExeCenterPoint( nTabId, GDB_ID_ROOT, ptCen) && b3Mill.EnclosesXY( ptCen)) {
// porto il centro alla quota del percorso
ptCen += vtExtr * ( dDepth - m_Params.m_dTabHeight) ;
// calcolo la distanza del centro dal percorso
double dDist ; double dPar, dAdjLen ; int nFlag ;
DistPointCurve distPC( ptCen, *pCompo) ;
if ( distPC.GetDist( dDist) && dDist < dMaxDist &&
distPC.GetParamAtMinDistPoint( 0, dPar, nFlag) &&
pCompo->GetLengthAtParam( dPar, dAdjLen)) {
double dPos = dAdjLen - dTabLen / 2 ;
if ( dPos < 0)
dPos += dLen ;
double dPrev, dNext ;
if ( ivTabs.IsInside( dPos))
vdAdj.emplace_back( dPos) ;
else if ( ivTabs.GetPrevNearest( dPos, dPrev) && abs( dPos - dPrev) <= dTabLen / 2)
vdAdj.emplace_back( dPrev) ;
else if ( ivTabs.GetNextNearest( dPos, dNext) && abs( dNext - dPos) <= dTabLen / 2)
vdAdj.emplace_back( dNext) ;
}
}
nTabId = m_pGeomDB->GetNext( nTabId) ;
}
}
nOpeId = m_pMchMgr->GetNextActiveOperation( nOpeId) ;
}
// correggo posizione tabs per eventuali adiacenti
if ( ! vdAdj.empty()) {
// ordino le posizioni adiacenti in senso crescente lungo la lavorazione
sort( vdAdj.begin(), vdAdj.end()) ;
// se non sono presenti tabs
if ( vdTabs.empty()) {
for ( int i = 0 ; i < int( vdAdj.size()) && i < m_Params.m_nTabMax ; ++ i) {
vdTabs.emplace_back( vdAdj[i]) ;
}
}
// altrimenti
else {
// per ogni posizione adiacente
for ( int i = 0 ; i < int( vdAdj.size()) ; ++ i) {
double dPos = vdAdj[i] ;
// cerco quale posizione già definita sostituire
for ( int j = 0 ; j < int( vdTabs.size()) ; ++ j) {
if ( abs( dPos - vdTabs[j]) < EPS_SMALL)
;
else if ( dPos < vdTabs[j]) {
if ( j == 0)
vdTabs[j] = dPos ;
else {
if ( abs( dPos - vdTabs[j-1]) < abs( vdTabs[j] - dPos))
vdTabs[j-1] = dPos ;
else
vdTabs[j] = dPos ;
}
break ;
}
else if ( j == int( vdTabs.size()) - 1) {
vdTabs[j] = dPos ;
break ;
}
}
}
}
}
// inserisco geometria ausiliaria per i tabs
for ( auto& dPos : vdTabs) {
// recupero la posizione
double dU ;
Point3d ptCen ;
if ( pCompo->GetParamAtLength( dPos + dTabLen / 2, dU) &&
pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptCen)) {
// porto il centro alla quota del tab
ptCen -= vtExtr * ( dDepth - m_Params.m_dTabHeight) ;
// creo il cerchio
PtrOwner<ICurveArc> pCircle( CreateCurveArc()) ;
if ( ! IsNull( pCircle) && pCircle->Set( ptCen, vtExtr, m_TParams.m_dDiam / 2)) {
int nCircId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nTabsId, Release( pCircle)) ;
m_pGeomDB->SetMaterial( nCircId, AQUA) ;
}
}
}
// aggiungo la posizione tappo
vdTabs.emplace_back( dLen + m_dAddedOverlap + 100.) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs)
{
// lunghezze dei tratti di oscillazione
double vLen[4] = { 0,
tdTabs.m_dRampLen,
tdTabs.m_dRampLen + tdTabs.m_dTopLen,
tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ;
// lunghezza della linea
double dLen ; pLine->GetLength( dLen) ;
// lunghezza corrente sulla linea
double dCurrLen = 0 ;
// indice corrente di posizione
int nI = 0 ;
// emissione oscillazioni
while ( dCurrLen < dLen - EPS_ZERO && nI < int( vdTabs.size())) {
// lunghezze di riferimento dei tratti di oscillazione
double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ;
// lunghezza rimanente
double dNextLen = dLen - dCurrLen ;
// se inizio è sul primo tratto (parte piatta in basso)
if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[0] ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[0] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[0] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul secondo tratto (rampa ascendente)
else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[1] ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[1] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[1] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul terzo tratto (parte piatta in alto)
else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[2] ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[2] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[2] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// altrimenti è sul quarto tratto (rampa discendente)
else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[3] ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[3] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[3] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// altrimenti passo all'intervallo successivo
else
++ nI ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs)
{
// lunghezze dei tratti di oscillazione
double vLen[4] = { 0,
tdTabs.m_dRampLen,
tdTabs.m_dRampLen + tdTabs.m_dTopLen,
tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ;
// parametri dell'arco
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
double dLen ; pArc->GetLength( dLen) ;
// lunghezza corrente sull'arco
double dCurrLen = 0 ;
// indice corrente di posizione
int nI = 0 ;
// emissione oscillazioni
while ( dCurrLen < dLen - EPS_ZERO && nI < int( vdTabs.size())) {
// lunghezze di riferimento dei tratti di oscillazione
double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ;
// lunghezza rimanente
double dNextLen = dLen - dCurrLen ;
// se inizio è sul primo tratto (parte piatta in basso)
if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) {
// se fine arco è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine arco è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[0] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine arco è oltre
else {
dCurrLen += vLenRef[0] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[0] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul secondo tratto (rampa ascendente)
else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) {
// se fine arco è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine arco è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[1] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine arco è oltre
else {
dCurrLen += vLenRef[1] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[1] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul terzo tratto (parte piatta in alto)
else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) {
// se fine arco è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine arco è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[2] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine arco è oltre
else {
dCurrLen += vLenRef[2] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[2] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// altrimenti è sul quarto tratto (rampa discendente)
else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) {
// se fine arco è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine arco è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[3] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine arco è oltre
else {
dCurrLen += vLenRef[3] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[3] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// altrimenti passo all'intervallo successivo
else
++ nI ;
}
return true ;
}
//----------------------------------------------------------------------------
double
Milling::GetRadiusForStartEndElevation( bool bExtra) const
{
// se da non estendere
if ( ! bExtra)
return ( 0.5 * m_TParams.m_dTDiam) ;
// aumentato
double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ;
return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ;
}
//----------------------------------------------------------------------------
bool
Milling::GetSimplePointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr) const
{
// per frese che lavorano di testa
if ( m_TParams.m_nType == TT_MILL_STD) {
// eseguo verifica in direzione utensile
double dToolRad = m_TParams.m_dTDiam / 2 ;
double dToolLen = m_TParams.m_dMaxMat ;
double dToolDeltaLen = m_TParams.m_dTLen - m_TParams.m_dLen ;
double dTemp ;
if ( ! GetElevation( m_nPhase, ptP - dToolDeltaLen * vtTool, vtTool, dToolRad, dToolLen, MIN_SAFEDIST, vtTool, dTemp))
return false ;
return ( dTemp < 10 * EPS_SMALL) ;
}
// per frese che lavorano solo di fianco e per lame
else {
// eseguo verifica in direzione correzione
double dToolRad = m_TParams.m_dTDiam / 2 ;
double dToolThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dToolDeltaLen = m_TParams.m_dTLen - m_TParams.m_dLen ;
double dTemp ;
if ( ! GetElevation( m_nPhase, ptP - dToolDeltaLen * vtTool, vtTool, dToolRad, dToolThick, MIN_SAFEDIST, vtRetr, dTemp))
return false ;
return ( dTemp < 10 * EPS_SMALL) ;
}
}
//----------------------------------------------------------------------------
bool
Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr, double dSafeZ) const
{
// per frese normali
if ( m_TParams.m_nType == TT_MILL_STD) {
// determino se la posizione è fuori dal grezzo (considero movimento fresa lungo il suo asse)
double dTemp ;
double dToolRad = m_TParams.m_dTDiam / 2 ;
double dToolLen = m_TParams.m_dMaxMat ;
if ( ! GetElevation( m_nPhase, ptP, vtTool, dToolRad, dToolLen, MIN_SAFEDIST, vtTool, dTemp))
return false ;
return ( dTemp < 10 * EPS_SMALL) ;
}
// per lame e frese che non lavorano di testa
else {
// determino se la posizione è fuori dal grezzo (considero movimento utensile in +/- Z)
double dTemp ;
Vector3d vtMove = ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtSafe = vtRetr ; vtSafe.z = 0 ; vtSafe.Normalize() ;
double dToolRad = m_TParams.m_dTDiam / 2 ;
double dToolLen = ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ? m_TParams.m_dThick : m_TParams.m_dMaxMat) ;
bool bOut = true ;
if ( ! GetElevation( m_nPhase, ptP, vtTool, dToolRad, dToolLen, MIN_SAFEDIST, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) {
bOut = false ;
if ( ! m_bTiltingTab)
return false ;
}
// se tavola basculante (o asse ralla) e non esterno, provo in direzione utensile
if ( m_bTiltingTab && ! bOut) {
vtMove = vtTool ;
if ( ! GetElevation( m_nPhase, ptP, vtTool, dToolRad, dToolLen, MIN_SAFEDIST, vtMove, dTemp) || dTemp > 10 * EPS_SMALL)
return false ;
}
return true ;
}
}
//----------------------------------------------------------------------------
bool
Milling::GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const
{
// derivo punti più bassi dell'utensile
Vector3d vtDown = -FromUprightOrtho( vtTool) ;
Point3d ptP1 = ptP + vtDown * 0.5 * m_TParams.m_dTDiam ;
Point3d ptP2 = ptP1 + vtTool * ((( m_TParams.m_nType & TF_SAWBLADE) == 0) ? m_TParams.m_dLen : m_TParams.m_dThick) ;
// determino la posizione dei punti rispetto al grezzo
// ciclo sui grezzi
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
// se il grezzo compare nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
BBox3d b3Raw ;
m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ;
if ( ! b3Raw.IsEmpty()) {
if ( ptP1.z < b3Raw.GetMax().z + 10 * EPS_SMALL ||
ptP2.z < b3Raw.GetMax().z + 10 * EPS_SMALL)
return false ;
}
}
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::GetPointBelowRaw( const Point3d& ptP, const Vector3d& vtTool) const
{
// derivo punti più alti dell'utensile
Vector3d vtUp = FromUprightOrtho( vtTool) ;
Point3d ptP1 = ptP + vtUp * 0.5 * m_TParams.m_dTDiam ;
Point3d ptP2 = ptP1 + vtTool * ((( m_TParams.m_nType & TF_SAWBLADE) == 0) ? m_TParams.m_dLen : m_TParams.m_dThick) ;
// determino la posizione dei punti rispetto al grezzo
// ciclo sui grezzi
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
// se il grezzo compare nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
BBox3d b3Raw ;
m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ;
if ( ! b3Raw.IsEmpty()) {
if ( ptP1.z > b3Raw.GetMin().z - 10 * EPS_SMALL ||
ptP2.z > b3Raw.GetMin().z - 10 * EPS_SMALL)
return false ;
}
}
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU, bool bInvertSide, bool bSawSpecial)
{
// verifico curva
if ( pCompo == nullptr)
return false ;
// versore correzione nullo per default
Vector3d vtCorr ;
// se utensile non centrato, calcolo del versore correzione
if ( m_Params.m_nWorkSide != MILL_WS_CENTER)
vtCorr = CalcCorrDir( pCompo, dU, bInvertSide, bSawSpecial) ;
// imposto versore correzione
SetCorrDir( vtCorr) ;
// se rinvio da sotto in uso, non devo impostare direzione aux da correzione
if ( m_bAggrBottom)
return true ;
// se impostato uso direttamente da lavorazione, imposto anche come versore aux
if ( m_Params.m_nSolCh == MCH_SCC_ADIR_NEAR || m_Params.m_nSolCh == MCH_SCC_ADIR_FAR) {
SetAuxDir( vtCorr) ;
return true ;
}
// 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 ;
}
}
// reset o assegnamento da parametro di lavorazione nelle UserNotes
Vector3d vtAux ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTAUXDIR, vtAux))
vtAux.Normalize() ;
SetAuxDir( vtAux) ;
return true ;
}
//----------------------------------------------------------------------------
Vector3d
Milling::CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide, bool bSawSpecial) const
{
// verifico curva
if ( pCompo == nullptr)
return V_NULL ;
// se utensile centrato, direzione di correzione nulla
if ( m_Params.m_nWorkSide == MILL_WS_CENTER)
return V_NULL ;
// se speciale lame, aggiusto il parametro di calcolo
if ( bSawSpecial && ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
if ( pCompo->GetCurveCount() == 3)
dU = 1.5 ;
else if ( pCompo->GetCurveCount() == 2) {
double dLen0 ; pCompo->GetCurve( 0)->GetLength( dLen0) ;
double dLen1 ; pCompo->GetCurve( 1)->GetLength( dLen1) ;
dU = ( dLen0 > dLen1 ? 0.5 : 1.5) ;
}
}
// angolo di rotazione da tg a versore corr/aux
bool bCcwRot = (( m_Params.m_nWorkSide == MILL_WS_LEFT) != bInvertSide) ;
double dCaRot = ( bCcwRot ? ANG_RIGHT : -ANG_RIGHT) ;
// dominio parametrico della curva
double dUs, dUe ;
pCompo->GetDomain( dUs, dUe) ;
// se inizio
if ( dU < dUs + EPS_ZERO) {
// recupero la tangente dopo
Point3d ptP ;
Vector3d vtN ;
pCompo->GetPointTang( dU, ICurve::FROM_PLUS, ptP, vtN) ;
vtN.Rotate( m_vtTool, dCaRot) ;
return vtN ;
}
// se fine
else if ( dU > dUe - EPS_ZERO) {
// recupero la tangente prima
Point3d ptP ;
Vector3d vtN ;
pCompo->GetPointTang( dU, ICurve::FROM_MINUS, ptP, vtN) ;
vtN.Rotate( m_vtTool, dCaRot) ;
return vtN ;
}
// altrimenti
else {
// recupero la tangente prima e dopo il punto
Point3d ptP1, ptP2 ;
Vector3d vtT1, vtT2 ;
pCompo->GetPointTang( dU, ICurve::FROM_MINUS, ptP1, vtT1) ;
pCompo->GetPointTang( dU, ICurve::FROM_PLUS, ptP2, vtT2) ;
// se coincidono
if ( AreSameVectorApprox( vtT1, vtT2)) {
Vector3d vtN = vtT1 ;
vtN.Rotate( m_vtTool, dCaRot) ;
return vtN ;
}
// se sono opposte
else if ( AreOppositeVectorApprox( vtT1, vtT2)) {
Vector3d vtN = ( bCcwRot ? vtT2 : vtT1) ;
return vtN ;
}
// altrimenti
else {
Vector3d vtN = ( vtT1 + vtT2) / 2 ;
vtN.Rotate( m_vtTool, dCaRot) ;
return vtN ;
}
}
}
//----------------------------------------------------------------------------
bool
Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs) const
{
// determino opzioni di offset
int nFlag = ICurve::OFF_FILLET ;
if ( pCompo->IsClosed()) {
Vector3d vtStart ; pCompo->GetStartDir( vtStart) ;
Vector3d vtEnd ; pCompo->GetEndDir( vtEnd) ;
if ( ! AreSameVectorEpsilon( vtStart, vtEnd, sin( 5 * DEGTORAD)))
nFlag |= ICurve::OFF_FORCE_OPEN ;
}
if ( m_Params.m_bLeaveTab || m_Params.m_bOscEnable)
nFlag |= ICurve::OFF_MEDIA_INTDZ ;
// determino se curva piatta e recupero suo vettore estrusione
Plane3d plPlane ;
bool bIsFlat = pCompo->IsFlat( plPlane, false, 10 * EPS_SMALL) ;
Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;
// se curva piatta con estrusione non perpendicolare forzo offset avanzato
bool bAdvOffs = ( bIsFlat && abs( vtExtr * plPlane.GetVersN()) < cos( 0.1 * DEGTORAD)) ;
// eseguo offset semplice
if ( ! bAdvOffs && pCompo->SimpleOffset( dSignOffs, nFlag))
return true ;
// eseguo offset avanzato
if ( bIsFlat) {
OffsetCurve OffsCrv ;
if ( OffsCrv.Make( pCompo, dSignOffs, nFlag)) {
ICurve* pOffs = OffsCrv.GetLongerCurve() ;
if ( pOffs != nullptr) {
pCompo->Clear() ;
pCompo->AddCurve( pOffs) ;
pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ;
return true ;
}
else {
Point3d ptOffs ;
Vector3d vtOut ;
if ( OffsCrv.GetPointOffset( ptOffs, vtOut)) {
const double MIN_MOVE = 1 ;
Vector3d vtStart = vtOut ;
double dStaLen = 10 ;
Point3d ptStart ;
if ( pCompo->GetStartPoint( ptStart)) {
Vector3d vtTmp = ptOffs - ptStart ;
if ( vtTmp.Normalize()) {
double dCosA = abs( vtTmp * vtOut) ;
dStaLen = max( m_TParams.m_dDiam / 2 * sqrt( ( 1 - dCosA) / ( 1 + dCosA)), MIN_MOVE) ;
vtTmp.Rotate( vtExtr, 0, 1) ;
if ( vtTmp * vtOut < 0)
vtTmp.Invert() ;
vtStart = vtTmp ;
}
}
Vector3d vtEnd = vtOut ;
double dEndLen = 10 ;
Point3d ptEnd ;
if ( pCompo->GetEndPoint( ptEnd)) {
Vector3d vtTmp = ptOffs - ptEnd ;
if ( vtTmp.Normalize()) {
double dCosA = abs( vtTmp * vtOut) ;
dEndLen = max( m_TParams.m_dDiam / 2 * sqrt( ( 1 - dCosA) / ( 1 + dCosA)), MIN_MOVE) ;
vtTmp.Rotate( vtExtr, 0, 1) ;
if ( vtTmp * vtOut < 0)
vtTmp.Invert() ;
vtEnd = vtTmp ;
}
}
pCompo->Clear() ;
pCompo->AddPoint( ptOffs) ;
pCompo->AddLine( ptOffs + dStaLen * vtStart, false) ;
pCompo->AddLine( ptOffs + dEndLen * vtEnd) ;
return true ;
}
}
}
}
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::TrimExtendCurveToClosedStm( ICurveComposite* pCompo, int nCstmId, bool bInvert)
{
// dati preparatori
const ISurfTriMesh* pCstm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nCstmId)) ;
if ( pCstm == nullptr || ! pCstm->IsClosed())
return false ;
Frame3d frCstm ;
if ( ! m_pGeomDB->GetGlobFrame( nCstmId, frCstm))
return false ;
BBox3d b3Tes = pCstm->GetAllTriaBox() ;
if ( b3Tes.IsEmpty())
return false ;
double dTriExtLen ;
b3Tes.GetDiameter( dTriExtLen) ;
// inverto offset su centro utensile
double dCompOffs = 0.5 * m_TParams.m_dDiam * ( ( m_Params.m_nWorkSide == MILL_WS_RIGHT) != bInvert ? 1 : -1) ;
if ( ! CalcOffset( pCompo, -dCompOffs))
return false ;
// porto la curva nel riferimento della superficie
pCompo->ToLoc( frCstm) ;
// allungo la curva in testa e coda per essere sicuro che gli estremi siano esterni
if ( ! pCompo->AddLineTg( dTriExtLen, false) || ! pCompo->AddLineTg( dTriExtLen, true))
return false ;
// calcolo intersezioni con superficie chiusa
INTDBLVECTOR vInters ;
if ( ! IntersCurveSurfTmExt( *pCompo, *pCstm, 10 * EPS_SMALL, vInters))
return false ;
// prendo prima intersezione entrante e ultima uscente
double dParStart = -1 ;
for ( int i = 0 ; i < int( vInters.size()) ; ++ i) {
if ( vInters[i].first == CSIT_OUT_IN || vInters[i].first == CSIT_ON_IN) {
dParStart = vInters[i].second ;
break ;
}
}
double dParEnd = -1 ;
for ( int i = int( vInters.size()) - 1 ; i >= 0 ; -- i) {
if ( vInters[i].first == CSIT_IN_OUT || vInters[i].first == CSIT_IN_ON) {
dParEnd = vInters[i].second ;
break ;
}
}
// eseguo trim ed unisco le eventuali parti allineate
if ( ! pCompo->TrimStartEndAtParam( dParStart, dParEnd) ||
! pCompo->MergeCurves(10 * EPS_SMALL, 10 * EPS_ANG_SMALL))
return false ;
// riporto la curva in globale
pCompo->ToGlob( frCstm) ;
// ritorno in centro utensile
if ( ! CalcOffset(pCompo, dCompOffs))
return false ;
return true ;
}
Reference in New Issue View Git Blame Copy Permalink