Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
cc930cd503212f9749129daaec8b9d990f2fe305
EgtMachKernel/Milling.cpp
T
Dario Sassi cc930cd503 EgtMachKernel 2.2b2 : 
- in fresature e mortasature se elevazione troppo alta riduco sempre affondamnto con warning e non errore.
2020-02-14 11:34:57 +00:00

4193 lines
168 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2015-2016
//----------------------------------------------------------------------------
// File : Milling.cpp Data : 11.08.16 Versione : 1.6t2
// Contenuto : Implementazione gestione fresature.
//
//
//
// Modifiche : 07.06.15 DS Creazione modulo.
// 11.08.16 DS Miglioria gestione PV per più loop.
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "Milling.h"
#include "GeoConst.h"
#include "OperationConst.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/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//------------------------------ Constants ------------------------------------
static const double OSC_MIN_LEN = 0.1 ;
//------------------------------ Errors --------------------------------------
// 2301 = "Error in Milling : UpdateToolData failed"
// 2302 = "Error in Milling : Offset not computable"
// 2303 = "Error in Milling : Empty RawBox"
// 2304 = "Error in Milling : Depth not computable"
// 2305 = "Error in Milling : machining depth (xx) bigger than MaxMaterial (yy)"
// 2306 = "Error in Milling : Entity GetElevation"
// 2307 = "Error in Milling : missing aggregate from bottom"
// 2308 = "Error in Milling : path too far from part sides"
// 2309 = "Error in Milling : Approach not computable"
// 2310 = "Error in Milling : LeadIn not computable"
// 2311 = "Error in Milling : LeadOut not computable"
// 2312 = "Error in Milling : Retract not computable"
// 2313 = "Error in Milling : Linear Approx not computable"
// 2314 = "Error in Milling : LeadIn must be out of rawpart"
// 2315 = "Error in Milling : Chaining failed"
// 2316 = "Error in Milling : Tool MaxMaterial too small (xx)"
// 2317 = "Error in Milling : axes values not calculable"
// 2318 = "Error in Milling : outstroke xx"
// 2319 = "Error in Milling : link movements not calculable"
// 2320 = "Error in Milling : link outstroke xx"
// 2321 = "Error in Milling : post apply not calculable"
// 2322 = "Error in Milling : Tool loading failed"
// 2323 = "Error in Milling : machining depth (xxx) bigger than MaxDepth (yyy)"
// 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"
//----------------------------------------------------------------------------
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_dTHoldLen = m_dTHoldLen ;
pMill->m_dTHoldDiam = m_dTHoldDiam ;
pMill->m_nStatus = m_nStatus ;
pMill->m_nMills = m_nMills ;
pMill->m_bStepOn = m_bStepOn ;
pMill->m_dAddedOverlap = m_dAddedOverlap ;
pMill->m_nHeadSolCh = m_nHeadSolCh ;
pMill->m_bTiltingTab = m_bTiltingTab ;
pMill->m_bAboveHead = m_bAboveHead ;
pMill->m_bAggrBottom = m_bAggrBottom ;
pMill->m_dCurrOscillLen = m_dCurrOscillLen ;
}
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_dTHoldLen = 0 ;
m_dTHoldDiam = 0 ;
m_nStatus = MCH_ST_TO_VERIFY ;
m_nMills = 0 ;
m_bStepOn = false ;
m_dAddedOverlap = 0 ;
m_nHeadSolCh = MCH_SCC_NONE ;
m_bTiltingTab = false ;
m_bAboveHead = true ;
m_bAggrBottom = false ;
m_dCurrOscillLen = 0 ;
}
//----------------------------------------------------------------------------
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_SCC :
if ( ! m_Params.VerifySolCh( nVal))
return false ;
if ( nVal != m_Params.m_nSolCh)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nSolCh = nVal ;
return true ;
case MPA_FACEUSE :
if ( ! m_Params.VerifyFaceUse( nVal))
return false ;
if ( nVal != m_Params.m_nFaceUse)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nFaceUse = nVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::SetParam( int nType, double dVal)
{
switch ( nType) {
case MPA_SPEED :
if ( ! m_TParams.VerifySpeed( dVal))
return false ;
if ( abs( m_TParams.m_dSpeed - dVal) < EPS_MACH_ANG_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dSpeed) > EPS_MACH_ANG_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dSpeed = dVal ;
return true ;
case MPA_FEED :
if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dFeed = dVal ;
return true ;
case MPA_STARTFEED :
if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dStartFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartFeed = dVal ;
return true ;
case MPA_ENDFEED :
if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dEndFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dEndFeed = dVal ;
return true ;
case MPA_TIPFEED :
if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dTipFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dTipFeed = dVal ;
return true ;
case MPA_OFFSR :
if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR)
dVal = UNKNOWN_PAR ;
if ( abs( dVal - m_Params.m_dOffsR) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOffsR = dVal ;
return true ;
case MPA_OFFSL :
if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
dVal = UNKNOWN_PAR ;
if ( abs( dVal - m_Params.m_dOffsL) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOffsL = dVal ;
return true ;
case MPA_DEPTH : {
string sVal = ToString( dVal) ;
if ( sVal != m_Params.m_sDepth)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sDepth = sVal ;
} return true ;
case MPA_STARTPOS :
if ( abs( dVal - m_Params.m_dStartPos) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartPos = dVal ;
return true ;
case MPA_OVERL :
if ( abs( dVal - m_Params.m_dOverlap) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOverlap = dVal ;
return true ;
case MPA_STEP :
if ( abs( dVal - m_Params.m_dStep) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStep = dVal ;
return true ;
case MPA_STARTADDLEN :
if ( abs( dVal - m_Params.m_dStartAddLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartAddLen = dVal ;
return true ;
case MPA_ENDADDLEN :
if ( abs( dVal - m_Params.m_dEndAddLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dEndAddLen = dVal ;
return true ;
case MPA_OSCHEIGHT :
if ( abs( dVal - m_Params.m_dOscHeight) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOscHeight = dVal ;
return true ;
case MPA_OSCRAMPLEN :
if ( abs( dVal - m_Params.m_dOscRampLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOscRampLen = dVal ;
return true ;
case MPA_OSCFLATLEN :
if ( abs( dVal - m_Params.m_dOscFlatLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOscFlatLen = dVal ;
return true ;
case MPA_LITANG :
if ( abs( dVal - m_Params.m_dLiTang) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiTang = dVal ;
return true ;
case MPA_LIPERP :
if ( abs( dVal - m_Params.m_dLiPerp) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiPerp = dVal ;
return true ;
case MPA_LIELEV :
if ( abs( dVal - m_Params.m_dLiElev) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiElev = dVal ;
return true ;
case MPA_LICOMPLEN :
if ( abs( dVal - m_Params.m_dLiCompLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiCompLen = dVal ;
return true ;
case MPA_LOTANG :
if ( abs( dVal - m_Params.m_dLoTang) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoTang = dVal ;
return true ;
case MPA_LOPERP :
if ( abs( dVal - m_Params.m_dLoPerp) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoPerp = dVal ;
return true ;
case MPA_LOELEV :
if ( abs( dVal - m_Params.m_dLoElev) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoElev = dVal ;
return true ;
case MPA_LOCOMPLEN :
if ( abs( dVal - m_Params.m_dLoCompLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoCompLen = dVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::SetParam( int nType, const string& sVal)
{
switch ( nType) {
case MPA_TOOL : {
const ToolData* pTdata ;
if ( ! m_Params.VerifyTool( m_pMchMgr->GetCurrToolsMgr(), sVal, pTdata))
return false ;
if ( ! SameTool( m_TParams, *pTdata))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sToolName = sVal ;
m_Params.m_ToolUuid = pTdata->m_Uuid ;
m_TParams = *pTdata ;
} return true ;
case MPA_DEPTH_STR :
if ( sVal != m_Params.m_sDepth)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sDepth = sVal ;
return true ;
case MPA_SYSNOTES :
if ( sVal != m_Params.m_sSysNotes)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sSysNotes = sVal ;
return true ;
case MPA_USERNOTES :
if ( sVal != m_Params.m_sUserNotes)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sUserNotes = sVal ;
return true ;
case MPA_INITANGS :
if ( sVal != m_Params.m_sInitAngs)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sInitAngs = sVal ;
return true ;
case MPA_BLOCKEDAXIS :
if ( sVal != m_Params.m_sBlockedAxis)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sBlockedAxis = sVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::SetGeometry( const SELVECTOR& vIds)
{
// verifico validità gestore DB geometrico
if ( m_pGeomDB == nullptr)
return false ;
// reset della geometria corrente
m_vId.clear() ;
// verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve, tutti testi o tutte facce)
int nType = GEO_NONE ;
for ( const auto& Id : vIds) {
// test sull'entità
int nSubs ;
if ( ! VerifyGeometry( Id, nSubs, nType)) {
string sInfo = "Warning in Milling : Skipped entity " + ToString( Id) ;
m_pMchMgr->SetWarning( 2351, sInfo) ;
continue ;
}
// posso aggiungere alla lista
m_vId.emplace_back( Id) ;
}
// aggiorno lo stato
m_nStatus |= MCH_ST_GEO_MODIF ;
// restituisco presenza geometria da lavorare
return ( ! m_vId.empty() || vIds.empty()) ;
}
//----------------------------------------------------------------------------
bool
Milling::Preview( bool bRecalc)
{
// reset numero percorsi di lavoro generati
m_nMills = 0 ;
// verifico validità gestore DB geometrico e Id del gruppo
if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
return false ;
// recupero gruppo per geometria ausiliaria
int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ;
bool bChain = false ;
// se non c'è, lo aggiungo
if ( nAuxId == GDB_ID_NULL) {
nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nAuxId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nAuxId, MCH_AUX) ;
m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ;
bChain = true ;
}
// altrimenti, se chiesto ricalcolo, lo svuoto
else if ( bRecalc) {
m_pGeomDB->EmptyGroup( nAuxId) ;
bChain = true ;
}
// aggiorno dati geometrici dell'utensile
if ( ! UpdateToolData()) {
m_pMchMgr->SetLastError( 2301, "Error in Milling : UpdateToolData failed") ;
return false ;
}
m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ;
// aggiorno anche se non necessario, comunque operazione veloce
// rendo corrente l'utensile usato nella lavorazione
if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) {
m_pMchMgr->SetLastError( 2322, "Error in Milling : Tool loading failed") ;
return false ;
}
// recupero i dati del portautensile
int nToolId = m_pMchMgr->GetCalcTool() ;
m_dTHoldLen = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_LEN, m_dTHoldLen) ;
m_dTHoldDiam = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_DIAM, m_dTHoldDiam) ;
// se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
if ( bChain && ! Chain( nAuxId)) {
m_pMchMgr->SetLastError( 2315, "Error in Milling : Chaining failed") ;
return false ;
}
// recupero gruppo per geometria di Preview
int nPvId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_PV) ;
// se non c'è, lo aggiungo
if ( nPvId == GDB_ID_NULL) {
nPvId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nPvId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nPvId, MCH_PV) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nPvId) ;
// lavoro ogni singola catena
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL) {
if ( ! ProcessPath( nPathId, nPvId, GDB_ID_NULL))
return false ;
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::Apply( bool bRecalc, bool bPostApply)
{
// reset numero percorsi di lavoro generati
int nCurrMills = m_nMills ;
m_nMills = 0 ;
// verifico validità gestore DB geometrico e Id del gruppo
if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
return false ;
// aggiorno dati geometrici dell'utensile
bool bToolChanged = true ;
if ( ! UpdateToolData( &bToolChanged)) {
m_pMchMgr->SetLastError( 2301, "Error in Milling : UpdateToolData failed") ;
return false ;
}
m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ;
// verifico se necessario continuare nell'aggiornamento
if ( ! bRecalc && ! bToolChanged &&
( m_nStatus == MCH_ST_OK || ( ! bPostApply && m_nStatus == MCH_ST_NO_POSTAPPL))) {
m_nMills = nCurrMills ;
LOG_DBG_INFO( GetEMkLogger(), "Milling apply skipped : status already ok") ;
return true ;
}
m_nStatus = MCH_ST_TO_VERIFY ;
// recupero gruppo per geometria ausiliaria
int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ;
bool bChain = false ;
// se non c'è, lo aggiungo
if ( nAuxId == GDB_ID_NULL) {
nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nAuxId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nAuxId, MCH_AUX) ;
m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ;
bChain = true ;
}
// altrimenti, se chiesto ricalcolo, lo svuoto
else if ( bRecalc) {
m_pGeomDB->EmptyGroup( nAuxId) ;
bChain = true ;
}
// 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_dTHoldLen = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_LEN, m_dTHoldLen) ;
m_dTHoldDiam = 0 ;
m_pGeomDB->GetInfo( nToolId, TTH_DIAM, m_dTHoldDiam) ;
// recupero gruppo per geometria di lavorazione (Cutter Location)
int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ;
// se non c'è, lo aggiungo
if ( nClId == GDB_ID_NULL) {
nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nClId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nClId, MCH_CL) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nClId) ;
// 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 ;
// 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 ;
}
// assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
CalcAndSetBBox( nClId) ;
// eseguo aggiornamento assi macchina e collegamento con operazione precedente
if ( ! Update( bPostApply))
return false ;
// aggiorno stato della lavorazione
m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
// dichiaro successiva da aggiornare
UpdateFollowingOperationsStatus( MCH_ST_OTH_MODIF) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::Update( bool bPostApply)
{
// verifico validità gestore DB geometrico e Id del gruppo
if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
return false ;
// se lavorazione vuota, esco
if ( m_nMills == 0) {
m_pMchMgr->SetWarning( 2352, "Warning in Milling : No machinable path") ;
return true ;
}
// imposto eventuale asse bloccato da lavorazione
if ( ! m_Params.m_sBlockedAxis.empty()) {
string sAxis, sVal ;
Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ;
double dVal = 0 ;
FromString( sVal, dVal) ;
m_pMchMgr->ClearRotAxisBlock() ;
m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ;
}
// calcolo gli assi macchina
string sHint = ExtractHint( m_Params.m_sUserNotes) ;
if ( ! m_Params.m_sInitAngs.empty())
sHint = m_Params.m_sInitAngs ;
if ( ! CalculateAxesValues( sHint)) {
string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
if ( sInfo.empty())
m_pMchMgr->SetLastError( 2317, "Error in Milling : axes values not calculable") ;
else
m_pMchMgr->SetLastError( 2318, "Error in Milling : outstroke ") ;
return false ;
}
// gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
if ( ! AdjustStartEndMovements()) {
string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
if ( sInfo.empty())
m_pMchMgr->SetLastError( 2319, "Error in Milling : link movements not calculable") ;
else
m_pMchMgr->SetLastError( 2320, "Error in Milling : link outstroke ") ;
return false ;
}
// esecuzione eventuali personalizzazioni
if ( bPostApply && ! PostApply()) {
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_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_LITANG :
dVal = m_Params.m_dLiTang ;
return true ;
case MPA_LIPERP :
dVal = m_Params.m_dLiPerp ;
return true ;
case MPA_LIELEV :
dVal = m_Params.m_dLiElev ;
return true ;
case MPA_LICOMPLEN :
dVal = m_Params.m_dLiCompLen ;
return true ;
case MPA_LOTANG :
dVal = m_Params.m_dLoTang ;
return true ;
case MPA_LOPERP :
dVal = m_Params.m_dLoPerp ;
return true ;
case MPA_LOELEV :
dVal = m_Params.m_dLoElev ;
return true ;
case MPA_LOCOMPLEN :
dVal = m_Params.m_dLoCompLen ;
return true ;
}
dVal = 0 ;
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::GetParam( int nType, string& sVal) const
{
switch ( nType) {
case MPA_NAME :
sVal = m_Params.m_sName ;
return true ;
case MPA_TOOL :
sVal = m_Params.m_sToolName ;
return true ;
case MPA_DEPTH_STR :
sVal = m_Params.m_sDepth ;
return true ;
case MPA_TUUID :
sVal = ToString( m_Params.m_ToolUuid) ;
return true ;
case MPA_UUID :
sVal = ToString( m_Params.m_Uuid) ;
return true ;
case MPA_SYSNOTES :
sVal = m_Params.m_sSysNotes ;
return true ;
case MPA_USERNOTES :
sVal = m_Params.m_sUserNotes ;
return true ;
case MPA_INITANGS :
sVal = m_Params.m_sInitAngs ;
return true ;
case MPA_BLOCKEDAXIS :
sVal = m_Params.m_sBlockedAxis ;
return true ;
}
sVal = "" ;
return false ;
}
//----------------------------------------------------------------------------
const ToolData&
Milling::GetToolData( void) const
{
return m_TParams ;
}
//----------------------------------------------------------------------------
bool
Milling::UpdateToolData( bool* pbChanged)
{
// recupero il gestore DB utensili della macchina corrente
ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
if ( pTMgr == nullptr)
return false ;
// recupero l'utensile nel DB utensili
const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
if ( pTdata == nullptr)
return false ;
// verifico se sono diversi (ad esclusione del nome)
m_TParams.m_sName = pTdata->m_sName ;
bool bChanged = ! SameTool( m_TParams, *pTdata) ;
// aggiorno comunque i parametri
m_TParams = *pTdata ;
// eventuali segnalazioni
if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) {
string sInfo = "Warning in Milling : tool name changed (" +
m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
m_pMchMgr->SetWarning( 2353, sInfo) ;
m_Params.m_sToolName = m_TParams.m_sName ;
}
if ( bChanged) {
string sInfo = "Warning in Milling : tool data changed (" +
m_Params.m_sToolName + ")" ;
m_pMchMgr->SetWarning( 2354, sInfo) ;
}
// se definito parametro di ritorno, lo assegno
if ( pbChanged != nullptr)
*pbChanged = bChanged ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::GetGeometry( SELVECTOR& vIds) const
{
// restituisco l'elenco delle entità
vIds = m_vId ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::VerifyGeometry( SelData Id, int& nSubs, int& nType)
{
// ammessi : curve, testi, facce di trimesh o regioni
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
if ( pGObj == nullptr)
return false ;
// se ammesse curve ed è tale
if ( ( nType == GEO_NONE || nType == GEO_CURVE) && ( pGObj->GetType() & GEO_CURVE) != 0) {
nType = GEO_CURVE ;
const ICurve* pCurve = nullptr ;
// se direttamente la curva
if ( Id.nSub == SEL_SUB_ALL) {
pCurve = ::GetCurve( pGObj) ;
if ( pCurve == nullptr)
return false ;
if ( pCurve->GetType() == CRV_COMPO)
nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
else
nSubs = 0 ;
}
// altrimenti sottocurva di composita
else {
const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
pCurve = ( pCompo != nullptr ? pCompo->GetCurve( Id.nSub) : nullptr) ;
if ( pCurve == nullptr)
return false ;
nSubs = 0 ;
}
return true ;
}
// se altrimenti ammessi testi ed è tale
else if ( ( nType == GEO_NONE || nType == EXT_TEXT) && pGObj->GetType() == EXT_TEXT) {
nType = EXT_TEXT ;
const IExtText* pText = ::GetExtText( pGObj) ;
if ( pText == nullptr)
return false ;
// tutto bene
nSubs = 0 ;
return true ;
}
// se altrimenti ammesse superfici trimesh ed è tale
else if ( ( nType == GEO_NONE || nType == SRF_TRIMESH) && pGObj->GetType() == SRF_TRIMESH) {
nType = SRF_TRIMESH ;
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
if ( pSurf == nullptr)
return false ;
// se direttamente la superficie
if ( Id.nSub == SEL_SUB_ALL) {
// deve avere una sola faccia
if ( pSurf->GetFacetCount() != 1)
return false ;
nSubs = 1 ;
}
// altrimenti faccia di superficie trimesh
else {
// se faccia non esistente
if ( Id.nSub > pSurf->GetFacetCount())
return false ;
nSubs = 0 ;
}
return true ;
}
// se altrimenti ammesse regioni ed è tale
else if ( ( nType == GEO_NONE || nType == SRF_FLATRGN) && pGObj->GetType() == SRF_FLATRGN) {
nType = SRF_FLATRGN ;
const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
if ( pReg == nullptr)
return false ;
// se direttamente la regione
if ( Id.nSub == SEL_SUB_ALL) {
nSubs = pReg->GetChunkCount() ;
}
// altrimenti chunk di regione
else {
// se chunk non esistente
if ( Id.nSub >= pReg->GetChunkCount())
return false ;
// tutto bene
nSubs = 0 ;
}
return true ;
}
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
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()) ;
// se estrusione mancante, imposto default
Vector3d vtExtr ;
if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall())
pCurve->SetExtrusion( Z_AX) ;
}
// altrimenti sottocurva di composita
else {
// recupero la composita
const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
if ( pCompo == nullptr)
return false ;
// recupero la curva semplice
const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ;
if ( pOriCurve == nullptr)
return false ;
// la duplico
pCurve.Set( pOriCurve->Clone()) ;
// recupero estrusione e spessore
Vector3d vtExtr ;
if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall())
vtExtr = Z_AX ;
pCurve->SetExtrusion( vtExtr) ;
double dThick ;
if ( pCompo->GetThickness( dThick))
pCurve->SetThickness( dThick) ;
}
if ( IsNull( pCurve))
return false ;
// la porto in globale
pCurve->ToGlob( frGlob) ;
// la restituisco
lstPC.emplace_back( Release( pCurve)) ;
return true ;
}
// se altrimenti testo
else if ( pGObj->GetType() == EXT_TEXT) {
// recupero il testo
const IExtText* pText = ::GetExtText( pGObj) ;
if ( pText == nullptr)
return false ;
// recupero l'outline del testo
if ( ! pText->GetOutline( lstPC))
return false ;
// porto le curve in globale
for ( auto pCrv : lstPC)
pCrv->ToGlob( frGlob) ;
// ritorno
return true ;
}
// se altrimenti superficie
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) ;
AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, m_TParams.m_dThick) ;
// la restituisco
lstPC.emplace_back( Release( pCrvCompo)) ;
return true ;
}
// se altrimenti regione
else if ( pGObj->GetType() == SRF_FLATRGN) {
// recupero la regione
const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
if ( pReg == nullptr)
return false ;
// recupero la normale della regione
Vector3d vtN = pReg->GetNormVersor() ;
if ( vtN.IsSmall())
return false ;
// sistemazioni varie
int nToolDir ;
if ( ( m_Params.m_nFaceUse & 64) != 0)
nToolDir = TOOL_ORTUP ;
else if ( ( m_Params.m_nFaceUse & 32) != 0)
nToolDir = TOOL_ORTHO ;
else
nToolDir = TOOL_PARAL ;
int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
// determino intervallo di chunk
int nCstart = 0 ;
int nCend = pReg->GetChunkCount() ;
if ( Id.nSub != SEL_SUB_ALL) {
nCstart = Id.nSub ;
nCend = nCstart + 1 ;
}
// ciclo sui chunk
for ( int nC = nCstart ; nC < nCend ; ++ nC) {
// recupero i contorni del chunk
for ( int nL = 0 ; nL < pReg->GetLoopCount( nC) ; ++ nL) {
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo) || ! pCrvCompo->AddCurve( pReg->GetLoop( nC, nL)))
return false ;
// assegno l'estrusione dalla normale alla regione
pCrvCompo->SetExtrusion( vtN) ;
// unisco le eventuali parti allineate
pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
// la porto in globale
pCrvCompo->ToGlob( frGlob) ;
// sistemazioni varie
AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, m_TParams.m_dThick) ;
// la restituisco
lstPC.emplace_back( Release( pCrvCompo)) ;
}
}
return true ;
}
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
Milling::Chain( int nGrpDestId)
{
// vettore puntatori alle curve
ICURVEPOVECTOR vpCrvs ;
vpCrvs.reserve( m_vId.size()) ;
// vettore selettori delle curve originali
SELVECTOR vInds ;
vInds.reserve( m_vId.size()) ;
// recupero tutte le curve e le porto in globale
for ( const auto& Id : m_vId) {
// prendo le curve
ICURVEPLIST lstPC ;
if ( ! GetCurves( Id, lstPC)) {
string sInfo = "Warning in Milling : Skipped entity " + ToString( Id) ;
m_pMchMgr->SetWarning( 2351, sInfo) ;
}
for ( auto pCrv : lstPC) {
vpCrvs.emplace_back( pCrv) ;
vInds.emplace_back( Id) ;
}
}
// preparo i dati per il concatenamento
bool bFirst = true ;
Point3d ptNear = ORIG ;
double dToler = 10 * EPS_SMALL ;
ChainCurves chainC ;
chainC.Init( true, dToler, int( vpCrvs.size())) ;
for ( size_t i = 0 ; i < vpCrvs.size() ; ++ i) {
// recupero la curva e il suo riferimento
ICurve* pCrv = vpCrvs[i] ;
if ( pCrv == nullptr)
continue ;
// recupero i dati della curva necessari al concatenamento e li assegno
Point3d ptStart, ptEnd ;
Vector3d vtStart, vtEnd ;
if ( ! pCrv->GetStartPoint( ptStart) || ! pCrv->GetStartDir( vtStart) ||
! pCrv->GetEndPoint( ptEnd) || ! pCrv->GetEndDir( vtEnd))
return false ;
if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd))
return false ;
// se prima curva, assegno inizio della ricerca
if ( bFirst) {
ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
bFirst = false ;
}
}
// recupero i percorsi concatenati
int nCount = 0 ;
INTVECTOR vnId2 ;
while ( chainC.GetChainFromNear( ptNear, false, vnId2)) {
// creo una curva composita
PtrOwner<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_dTDiam - 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_dTDiam - 10 * EPS_SMALL ;
ptCen.Translate( dOffset * pCamData->GetCorrDir()) ;
}
}
// negli altri casi, non devo fare alcunché
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 ( ! AreSameVectorApprox( vtStart, vtEnd)) {
bool bAngCCW = ( ( vtEnd ^ vtStart) * vtTool > 0.0) ;
if ( m_Params.m_dOverlap > EPS_SMALL ||
m_Params.m_nWorkSide == MILL_WS_CENTER ||
( m_Params.m_nWorkSide == MILL_WS_RIGHT && ! bAngCCW) ||
( m_Params.m_nWorkSide == MILL_WS_LEFT && bAngCCW))
pCompo->ChangeStartPoint( 0.5) ;
}
}
// eventuali allungamenti/accorciamenti per percorso aperto o chiuso senza sovrapposizione
if ( ! pCompo->IsClosed() || m_Params.m_dOverlap < EPS_SMALL) {
// verifico che il percorso sia abbastanza lungo
double dLen ; pCompo->GetLength( dLen) ;
if ( dLen + m_Params.m_dStartAddLen + m_Params.m_dEndAddLen < 10 * EPS_SMALL) {
m_pMchMgr->SetWarning( 2355, "Warning in Milling : skipped Path too short") ;
return true ;
}
// se una sola entità circonferenza completa, la divido in due per poterla allungare
if ( pCompo->GetCurveCount() == 1 && pCompo->IsClosed())
pCompo->AddJoint( 0.5) ;
// eventuali allungamenti
if ( m_Params.m_dStartAddLen > EPS_SMALL) {
if ( ! pCompo->ExtendStartByLen( m_Params.m_dStartAddLen))
return false ;
dLen += m_Params.m_dStartAddLen ;
}
if ( m_Params.m_dEndAddLen > EPS_SMALL) {
if ( ! pCompo->ExtendEndByLen( m_Params.m_dEndAddLen))
return false ;
dLen += m_Params.m_dEndAddLen ;
}
// eventuale accorciamenti (da fare dopo tutti gli allungamenti)
if ( m_Params.m_dStartAddLen < - EPS_SMALL) {
if ( ! pCompo->TrimStartAtLen( - m_Params.m_dStartAddLen))
return false ;
dLen += m_Params.m_dStartAddLen ;
}
if ( m_Params.m_dEndAddLen < - EPS_SMALL) {
if ( ! pCompo->TrimEndAtLen( dLen + m_Params.m_dEndAddLen))
return false ;
dLen += m_Params.m_dEndAddLen ;
}
}
// se utensile non centrato, eseguo correzione raggio utensile ed eventuale offset
double dOffs = 0.5 * m_TParams.m_dDiam + GetOffsR() ;
if ( m_Params.m_nWorkSide != MILL_WS_CENTER && abs( dOffs) > EPS_SMALL) {
// valore offset
double dSignOffs = ( m_Params.m_nWorkSide == MILL_WS_RIGHT) ? dOffs : - dOffs ;
// esecuzione offset
if ( ! CalcOffset( pCompo, dSignOffs)) {
m_pMchMgr->SetLastError( 2302, "Error in Milling : Offset not computable") ;
return false ;
}
}
// eventuale sovrapposizione per percorso chiuso
m_dAddedOverlap = 0 ;
if ( pCompo->IsClosed()) {
if ( m_Params.m_dOverlap > EPS_SMALL) {
double dParS, dParE ;
if ( pCompo->GetParamAtLength( 0.0, dParS) &&
pCompo->GetParamAtLength( m_Params.m_dOverlap, dParE)) {
PtrOwner<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 ;
// flag di oscillazione del percorso corrente
bool bPathOscEnable = m_Params.m_bOscEnable ;
// se utensile lama, disabilito eventuale oscillazione
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
if ( bPathOscEnable) {
bPathOscEnable = false ;
m_pMchMgr->SetWarning( 2359, "Warning in Milling : oscillation incompatible with saw blade") ;
}
}
// recupero i punti di inizio e fine (per poi salvarli nelle info di CL path)
Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ;
// recupero il box del grezzo in globale
BBox3d b3Raw ;
if ( ! GetRawGlobBox( m_nPhase, nPathId, 0.5 * m_TParams.m_dTDiam, b3Raw) || b3Raw.IsEmpty()) {
m_pMchMgr->SetLastError( 2303, "Error in Milling : Empty RawBox") ;
return false ;
}
// recupero distanza da fondo dei grezzi interessati dal percorso
double dRbDist = 0 ;
if ( AreSameVectorApprox( vtTool, Z_AX)) {
if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, m_TParams.m_dTDiam, dRbDist))
return false ;
}
// valuto l'espressione dell'affondamento
ExeLuaSetGlobNumVar( "TH", abs( dThick)) ;
ExeLuaSetGlobNumVar( "RB", dRbDist) ;
double dDepth ;
string sMyDepth = m_Params.m_sDepth ;
if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) {
m_pMchMgr->SetLastError( 2304, "Error in Milling : Depth not computable") ;
return false ;
}
// se spessore positivo, lo sottraggo dal risultato
if ( dThick > 0)
dDepth -= dThick ;
// sottraggo eventuale offset longitudinale
dDepth -= GetOffsL() ;
// recupero nome del path
string sPathName ;
m_pGeomDB->GetName( nPathId, sPathName) ;
// eventuale approssimazione con segmenti di retta
int nSplitArcs = m_pMchMgr->GetCurrMachiningsMgr()->GetSplitArcs() ;
bool bSplitArcs = ( nSplitArcs == SPLAR_ALWAYS ||
( nSplitArcs == SPLAR_NO_XY_PLANE && ! vtTool.IsZplus()) ||
( nSplitArcs == SPLAR_GEN_PLANE && vtTool.IsGeneric())) ;
if ( bSplitArcs && ! ApproxWithLines( pCompo)) {
m_pMchMgr->SetLastError( 2313, "Error in Milling : Linear Approx not computable") ;
return false ;
}
// verifiche sull'ampiezza dell'angolo al centro degli eventuali archi
VerifyArcs( pCompo) ;
// calcolo l'elevazione massima
double dElev ;
if ( CalcPathElevation( pCompo, vtTool, dDepth, 0.5 * m_TParams.m_dDiam, dElev)) {
if ( dElev < EPS_SMALL && AreSameVectorApprox( vtTool, Z_AX)) {
BBox3d b3Crv ;
pCompo->GetLocalBBox( b3Crv) ;
dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z + min( 0., dThick) + dDepth) ;
}
}
else
return false ;
// eventuale imposizione massima elevazione da note utente
double dMaxElev ;
if ( FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxElev="), dMaxElev) && dElev > dMaxElev)
dElev = dMaxElev ;
// eventuale aggiuntivo all'elevazione per l'oscillazione
double dAddElev = ( bPathOscEnable ? abs( m_Params.m_dOscHeight) : 0) ;
// eventuale elevazione di fianco (solo per lama)
double dSideElev = 0 ;
FromString( ExtractInfo( m_Params.m_sUserNotes, "SideElev="), dSideElev) ;
// verifico che lo step dell'utensile sia sensato
double dOkStep = ( m_Params.m_dStep > EPS_SMALL ? m_Params.m_dStep + EPS_SMALL : 0) ;
const double MIN_ZSTEP = 1.0 ;
if ( dOkStep >= EPS_SMALL && dOkStep < MIN_ZSTEP) {
dOkStep = MIN_ZSTEP + EPS_SMALL ;
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 = m_TParams.m_dMaxMat - max( dThick, 0.0) ;
dElev = m_TParams.m_dMaxMat ;
}
}
// altrimenti lavorazione a step
else {
// massimo affondamento dell'utensile
double dSafe = m_pMchMgr->GetCurrMachiningsMgr()->GetMaxDepthSafe() ;
double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? 0 : m_dTHoldLen) - dSafe ;
// se c'è oscillazione e l'elevazione complessiva supera la capacità dell'utensile, annullo l'oscillazione
if ( bPathOscEnable && dElev + dAddElev > dMaxDepth + EPS_SMALL) {
bPathOscEnable = false ;
dAddElev = 0 ;
m_pMchMgr->SetWarning( 2360, "Warning in Milling : oscillation incompatible with depth") ;
}
// se l'elevazione supera il massimo affondamento dell'utensile
if ( dElev > dMaxDepth + EPS_SMALL) {
// segnalo, riduco e continuo
string sInfo = "Warning in Milling : machining depth (" + ToString( dElev, 1) +
") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
m_pMchMgr->SetWarning( 2358, sInfo) ;
dDepth -= ( dElev - dMaxDepth) ;
dElev = dMaxDepth ;
}
}
}
// per lame e con elevazione di lato definita
else if ( dSideElev > EPS_SMALL) {
if ( dSideElev > m_TParams.m_dMaxMat) {
string sInfo = "Error in Milling : machining depth (" + ToString( dSideElev, 1) +
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetLastError( 2305, sInfo) ;
return false ;
}
}
// verifico se tavola basculante
bool bTiltTab = false ;
m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab) && bTiltTab) ;
// verifico se testa da sopra (Z+)
m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ;
// verifiche per fresatura dal basso
m_bAggrBottom = false ;
if ( ! VerifyPathFromBottom( pCompo, vtTool))
return false ;
// se richiesta anteprima
if ( nPvId != GDB_ID_NULL) {
// creo gruppo per geometria di anteprima del percorso
int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nPvId, Frame3d()) ;
if ( nPxId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nPxId, sPathName) ;
m_pGeomDB->SetMaterial( nPxId, GREEN) ;
// creo l'anteprima del percorso
if ( ! GenerateMillingPv( nPxId, pCompo))
return false ;
}
// se richiesta lavorazione
if ( nClId != GDB_ID_NULL) {
// creo gruppo per geometria di lavorazione del percorso
int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ;
if ( nPxId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nPxId, sPathName) ;
m_pGeomDB->SetMaterial( nPxId, BLUE) ;
// assegno il vettore estrazione al gruppo del percorso
m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ;
// assegno i punti di inizio e fine al gruppo del percorso
m_pGeomDB->SetInfo( nPxId, KEY_START, ptStart) ;
m_pGeomDB->SetInfo( nPxId, KEY_END, ptEnd) ;
// assegno l'elevazione massima
m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;
// Imposto dati comuni
SetPathId( nPxId) ;
SetToolDir( vtTool) ;
// 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 ( ! AddSawZigZagMilling( pCompo, vtTool, dDepth, dSideElev, dOkStep, bSplitArcs))
return false ;
}
// se altrimenti una sola passata
else if ( dOkStep < EPS_SMALL || dOkStep > dElev) {
m_bStepOn = false ;
if ( ! AddStandardMilling( pCompo, vtTool, dDepth, dElev, bSplitArcs, bPathOscEnable))
return false ;
}
// se altrimenti passate a zig-zag
else if ( m_Params.m_nStepType == MILL_ST_ZIGZAG) {
m_bStepOn = true ;
if ( ! AddZigZagMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathOscEnable))
return false ;
}
// se altrimenti passate a one-way
else if ( m_Params.m_nStepType == MILL_ST_ONEWAY) {
m_bStepOn = true ;
if ( ! AddOneWayMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathOscEnable))
return false ;
}
// 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 ;
}
if ( ! AddSpiralMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathOscEnable))
return false ;
}
// se utensile lama, porto il percorso sull'estremo della stessa
AdjustPathDrawForSaw( nPxId) ;
}
// 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_dTDiam - 10 * EPS_SMALL ;
Vector3d vtPrevCorr ;
for ( int nId = m_pGeomDB->GetFirstInGroup( nClPathId) ;
nId != GDB_ID_NULL ;
nId = m_pGeomDB->GetNext( nId)) {
// recupero l'oggetto geometrico
IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nId) ;
if ( pGObj == nullptr)
continue ;
// recupero i dati Cam dell'entità e verifico sia definito il versore correzione
CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nId)) ;
if ( pCamData == nullptr || pCamData->GetCorrDir().IsSmall())
continue ;
Vector3d vtCorr = pCamData->GetCorrDir() ;
// eseguo traslazione generale
Vector3d vtMove = - dOffset * vtCorr ;
pGObj->Translate( vtMove) ;
pCamData->Translate( vtMove) ;
// se il vettore correzione attuale è diverso dal precedente
if ( ! AreSameVectorApprox( vtCorr, vtPrevCorr)) {
// se curva
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
// compenso differenza su punto iniziale
Vector3d vtDiff = - dOffset * ( vtPrevCorr - vtCorr) ;
ICurve* pCrv = ::GetCurve( pGObj) ;
Point3d ptStart ;
pCrv->GetStartPoint( ptStart) ;
pCrv->ModifyStart( ptStart + vtDiff) ;
// se arco, aggiorno il centro
if ( pGObj->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCrv) ;
pCamData->SetCenter( pArc->GetCenter()) ;
}
}
}
// aggiorno precedente versore correzione
vtPrevCorr = vtCorr ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad,
double& dElev) const
{
dElev = 0 ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// calcolo elevazione
double dCurrElev ;
Point3d ptStart, ptMid, ptEnd ;
pCrvC->GetStartPoint( ptStart) ;
pCrvC->GetMidPoint( ptMid) ;
pCrvC->GetEndPoint( ptEnd) ;
Vector3d vtStartPerp, vtMidPerp, vtEndPerp, vtTg ;
pCrvC->GetStartDir( vtTg) ;
vtStartPerp = vtTg ^ vtTool ;
vtStartPerp.Normalize() ;
vtStartPerp *= dRad ;
pCrvC->GetMidDir( vtTg) ;
vtMidPerp = vtTg ^ vtTool ;
vtMidPerp.Normalize() ;
vtMidPerp *= dRad ;
pCrvC->GetEndDir( vtTg) ;
vtEndPerp = vtTg ^ vtTool ;
vtEndPerp.Normalize() ;
vtEndPerp *= dRad ;
Vector3d vtDepth = vtTool * dDepth ;
// linea centro utensile
if ( GetElevation( m_nPhase, ptStart - vtDepth, ptMid - vtDepth, ptEnd - vtDepth, vtTool, dCurrElev)) {
if ( dCurrElev > dElev)
dElev = dCurrElev ;
}
else {
m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ;
return false ;
}
// da una parte
if ( GetElevation( m_nPhase, ptStart + vtStartPerp - vtDepth, ptMid + vtMidPerp - vtDepth,
ptEnd + vtEndPerp - vtDepth, vtTool, dCurrElev)) {
if ( dCurrElev > dElev)
dElev = dCurrElev ;
}
else {
m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ;
return false ;
}
// dall'altra parte
if ( GetElevation( m_nPhase, ptStart - vtStartPerp - vtDepth, ptMid - vtMidPerp - vtDepth,
ptEnd - vtEndPerp - vtDepth, vtTool, dCurrElev)) {
if ( dCurrElev > dElev)
dElev = dCurrElev ;
}
else {
m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ;
return false ;
}
}
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'è tavola basculante, esco
if ( m_bTiltingTab)
return true ;
// recupero dati di eventuale rinvio da sotto
if ( ! GetAggrBottomData( m_TParams.m_sHead, m_AggrBottom) || m_AggrBottom.nType == 0) {
m_pMchMgr->SetLastError( 2307, "Error in Milling : missing aggregate from bottom") ;
return false ;
}
// calcolo la massima distanza minima del percorso dal contorno del grezzo
double dExpand = 0.5 * m_TParams.m_dTDiam ;
double dDist = - INFINITO ;
Vector3d vtDir ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// considero inizio della prima curva, punto medio e fine di tutte
Point3d ptP ;
double dCurrDist = 0 ;
Vector3d vtCurrDir ;
if ( i == 0) {
pCrvC->GetStartPoint( ptP) ;
GetMinDistanceFromRawSide( m_nPhase, ptP, dExpand, dCurrDist, vtCurrDir) ;
if ( dCurrDist > dDist) {
dDist = dCurrDist ;
vtDir = vtCurrDir ;
}
}
pCrvC->GetMidPoint( ptP) ;
GetMinDistanceFromRawSide( m_nPhase, ptP, dExpand, dCurrDist, vtCurrDir) ;
if ( dCurrDist > dDist) {
dDist = dCurrDist ;
vtDir = vtCurrDir ;
}
pCrvC->GetEndPoint( ptP) ;
GetMinDistanceFromRawSide( m_nPhase, ptP, dExpand, dCurrDist, vtCurrDir) ;
if ( dCurrDist > dDist) {
dDist = dCurrDist ;
vtDir = vtCurrDir ;
}
}
// se supera il limite, errore
if ( dDist > m_AggrBottom.dDMax) {
m_pMchMgr->SetLastError( 2308, "Error in Milling : path too far from part sides") ;
return false ;
}
// assegno direzione di accesso e segnalo utilizzo aggregato da sotto
m_vtAggrBottom = vtDir ;
m_bAggrBottom = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo)
{
// creo copia della curva composita
PtrOwner< ICurve> pCrv( pCompo->Clone()) ;
if ( IsNull( pCrv))
return false ;
// calcolo la regione
PtrOwner<ISurfFlatRegion> pSfr ;
pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), 0.5 * m_TParams.m_dDiam, false, false)) ;
if ( IsNull( pSfr))
return false ;
// ne recupero il contorno
PtrOwner< ICurve> pCrv2 ;
pCrv2.Set( pSfr->GetLoop( 0, 0)) ;
if ( IsNull( pCrv2))
return false ;
// inserisco la curva nel DB
int nC2Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv2)) ;
if ( nC2Id == GDB_ID_NULL)
return false ;
// assegno nome e colore
m_pGeomDB->SetName( nC2Id, MCH_PV_CUT) ;
m_pGeomDB->SetMaterial( nC2Id, LIME) ;
// eventuali altri contorni ( interni di contornatura chiusa)
const int MAX_INT_LOOP = 1000 ;
for ( int i = 1 ; i <= MAX_INT_LOOP ; ++i) {
PtrOwner< ICurve> pCrv3 ;
pCrv3.Set( pSfr->GetLoop( 0, i)) ;
if ( IsNull( pCrv3))
break ;
// inserisco la curva nel DB
int nC3Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv3)) ;
if ( nC3Id == GDB_ID_NULL)
return false ;
// assegno nome e colore
m_pGeomDB->SetName( nC3Id, MCH_PV_CUT) ;
m_pGeomDB->SetMaterial( nC3Id, LIME) ;
}
// inserisco la regione nel DB
int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfr)) ;
if ( nRId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ;
m_pGeomDB->SetMaterial( nRId, INVISIBLE) ;
// la copio anche come regione ridotta
int nRrId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
if ( nRrId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ;
m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, bool bSplitArcs, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// ciclo sulle curve elementari
bool bClosed = pCompo->IsClosed() ;
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) {
// dati inizio entità
Point3d ptStart ;
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart ;
pCurve->GetStartDir( vtStart) ;
// determino elevazione su inizio percorso di lavoro
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev) ;
// 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-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ;
dStElev = - LIO_ELEV_TOL ;
}
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti, approccio per lame
else {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
return false ;
}
// affondo al punto iniziale
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, i+1) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( bPathOscEnable) {
if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
SetFeed( GetFeed()) ;
if ( bPathOscEnable) {
if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se ultima entità, uscita e retrazione
if ( i == nMaxInd) {
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ;
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// per lame non è necessario
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<int>( ceil( dElev / dOkStep))) ;
double dStep = dElev / nStep ;
bool bClosed = pCompo->IsClosed() ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
// ciclo sugli step
for ( int j = 1 ; j <= nStep ; ++ j) {
// flag direzione (prima passata indice 1)
bool bInvert = ( ( j % 2) == 0) ;
m_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 ;
pCurve->GetStartDir( vtStart) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( j == 1) {
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
}
else
dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
// se primo step aggiungo approccio per frese normali
if ( j == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti, affondo al punto iniziale
else {
// se lama
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
SetFlag( 0) ;
if ( j == 1) {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
return false ;
}
// eseguo affondo
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
else {
if ( AddRapidMove( ptP1) == GDB_ID_NULL)
return false ;
}
}
// altrimenti, affondo in feed opportuna
else {
SetFeed( ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP) ? GetStartFeed() : GetTipFeed()) ;
if ( AddLinearMove( ptP1) == GDB_ID_NULL)
return false ;
}
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bInvert, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1)) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se ultima entità, uscita e se ultimo step retrazione
if ( i == nMaxInd) {
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ;
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( j == nStep) {
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
}
else
dEndElev = - LIO_ELEV_TOL ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// se ultimo step aggiungo retrazione per frese normali
if ( j == nStep && ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// per lame non è necessario
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// percorso speciale : chiuso e con attacco a spirale o zigzag
bool bSpecial = pCompo->IsClosed() && IsLeadInHelixOrZigzag() ;
// percorso senza retrazioni intermedie : chiuso e con attacco e uscita con punti esterni coincidenti
bool bMidRetract = true ;
if ( pCompo->IsClosed()) {
int nLiType = GetLeadInType() ;
int nLoType = GetLeadOutType() ;
if ( nLiType == MILL_LI_NONE && ( nLoType == MILL_LO_NONE || nLoType == MILL_LO_AS_LI))
bMidRetract = false ;
if ( ( nLiType == MILL_LI_TANGENT || nLiType == MILL_LI_LINEAR) &&
nLoType == MILL_LO_AS_LI &&
abs( m_Params.m_dLiTang) < EPS_SMALL)
bMidRetract = false ;
if ( ( nLiType == MILL_LI_TANGENT || nLiType == MILL_LI_LINEAR) &&
( nLoType == MILL_LO_TANGENT || nLoType == MILL_LO_LINEAR) &&
abs( m_Params.m_dLiTang) < EPS_SMALL &&
abs( m_Params.m_dLoTang) < EPS_SMALL &&
abs( m_Params.m_dLiPerp - m_Params.m_dLoPerp) < EPS_SMALL)
bMidRetract = false ;
}
// verifico se attacco e uscita sopra il grezzo
Point3d ptStart ;
pCompo->GetStartPoint( ptStart) ;
ptStart -= vtTool * dDepth ;
Point3d ptEnd ;
pCompo->GetEndPoint( ptEnd) ;
ptEnd -= vtTool * dDepth ;
bool bAboveStartEnd = m_bAboveHead && GetPointAboveRaw( ptStart, vtTool) && GetPointAboveRaw( ptEnd, vtTool) ;
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<int>( ceil( dElev / dOkStep))) ;
double dStep = dElev / nStep ;
// ciclo sugli step
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int j = 1 ; j <= nStep ; ++ j) {
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
// ciclo sulle curve elementari
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// copio la curva
PtrOwner<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 ;
pCurve->GetStartDir( vtStart) ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pCompo, i) ;
// punto inizio attacco
Point3d ptP1 ;
// se speciale e step intermedio
if ( bSpecial && j > 1) {
ptP1 = ptStart + dStep * vtTool ;
}
// altrimenti
else {
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
// determino inizio attacco
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev) ;
// 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-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev - ( j - 1) * dStep) ;
dStElev = ( j - 1) * dStep ;
}
// approccio standard al punto iniziale
if ( j == 1 || bMidRetract) {
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStartEnd)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti approccio diretto al punto iniziale
else {
if ( ! AddDirectApproach( ptP1)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
}
// altrimenti, approccio per lame
else {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
return false ;
}
// affondo al punto iniziale
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, i+1) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
else {
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se ultima entità, uscita e retrazione
if ( i == nMaxInd) {
// se speciale e step intermedio salto uscita e retrazione
if ( bSpecial && j != nStep)
continue ;
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ;
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali (esclusi step intermedi senza retrazione)
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0 && ( j == nStep || bMidRetract)) {
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveStartEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// per lame non è necessario
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
// se attacco ad inseguimento (per ora nullo), parto sopra di elevazione in attacco
double dStart = 0 ;
if ( m_Params.m_nLeadInType == MILL_LI_NONE)
dStart = m_Params.m_dLiElev ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<int>( ceil( ( dElev + dStart) / dOkStep))) ;
double dStep = ( dElev + dStart) / nStep ;
// determino dati del percorso
double dTotLen ; pCompo->GetLength( dTotLen) ;
bool bClosed = pCompo->IsClosed() ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
// se chiuso -> sempre in avanti
if ( bClosed) {
// ciclo sugli step
for ( int j = 0 ; j <= nStep ; ++ j) {
// ciclo sulle curve elementari
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
double dCurrLen = 0 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// affondamento a inizio curva
Vector3d vtStaDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
// affondamento a fine curva
double dCrvLen ; pCrvC->GetLength( dCrvLen) ;
dCurrLen += dCrvLen ;
Vector3d vtEndDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
// se prima entità di primo step, approccio e affondo
if ( i == 0 && j == 0) {
// dati inizio entità
Point3d ptStart ;
pCrvC->GetStartPoint( ptStart) ;
ptStart -= vtStaDepth ;
Vector3d vtStart ;
pCrvC->GetStartDir( vtStart) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = 0 ;
dStElev -= dStart ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev) ;
// 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-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti, affondo al punto iniziale per lame
else {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
return false ;
}
// eseguo affondamento
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, i+1) ;
// elaborazioni sulla curva corrente
if ( pCrvC->GetType() == CRV_LINE) {
const ICurveLine* pLine = GetCurveLine( pCrvC) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
PtrOwner<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) == 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 ;
pCrvC->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// per lame non è necessario
}
}
}
}
// altrimenti aperto -> avanti e indietro
else {
// ciclo sugli step
for ( int j = 0 ; j <= nStep ; ++ j) {
// flag direzione (prima passata indice 0)
bool bInvert = ( ( j % 2) == 1) ;
// ciclo sulle curve elementari
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
double dCurrLen = 0 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ;
// copio la curva
PtrOwner<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 ;
pCurve->GetStartDir( vtStart) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
dStElev -= dStart ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1))
return false ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
}
// altrimenti, affondo per lame
else {
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bInvert, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1)) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( j == nStep && bPathOscEnable) {
PtrOwner<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) == 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 ;
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
// per lame non è necessario
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
class LeadIOStatus
{
public :
LeadIOStatus( Milling* pMill)
{ m_pMill = pMill ;
m_dLiPerp = m_pMill->m_Params.m_dLiPerp ;
m_dLoPerp = m_pMill->m_Params.m_dLoPerp ;
}
~LeadIOStatus( void)
{ Restore() ;
}
void Restore( void)
{ m_pMill->m_Params.m_dLiPerp = m_dLiPerp ;
m_pMill->m_Params.m_dLoPerp = m_dLoPerp ;
}
private :
Milling* m_pMill ;
double m_dLiPerp ;
double m_dLoPerp ;
} ;
//----------------------------------------------------------------------------
bool
Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
// flag di percorso chiuso
bool bClosed = pCompo->IsClosed() ;
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<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 > EPS_SMALL) ;
if ( bAdjustLiPerp)
m_Params.m_dLiPerp = max( 0., m_Params.m_dLiPerp - ( nStep - 1) * dStep) ;
bool bAdjustLoPerp = ( m_Params.m_dLoPerp > EPS_SMALL) ;
m_Params.m_dLoPerp = 0. ;
// ciclo sugli step
for ( int j = 1 ; j <= nStep ; ++ j) {
// flag direzione (prima passata indice 1)
bool bInvert = ( ( j % 2) == 0) ;
// copio la curva
PtrOwner<ICurveComposite> pMyCompo( pCompo->Clone()) ;
if ( IsNull( pMyCompo))
return false ;
// eseguo offset
double dSignOffs = ( dElev - j * dStep) * ( m_Params.m_nWorkSide == MILL_WS_LEFT ? - 1 : 1) ;
if ( ! CalcOffset( pMyCompo, dSignOffs))
return false ;
// dopo primo step annullo parametro di attacco
if ( j > 1)
m_Params.m_dLiPerp = 0. ;
// ciclo sulle curve elementari
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pMyCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ;
// copio la curva
PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
if ( IsNull( pCurve))
return false ;
if ( bInvert)
pCurve->Invert() ;
// se prima entità, se primo step approccio e sempre affondo
if ( i == 0) {
// dati inizio entità
Point3d ptStart ;
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart ;
pCurve->GetStartDir( vtStart) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( j == 1) {
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
}
else
dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
// se primo step
if ( j == 1) {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
return false ;
}
// eseguo affondo
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// altrimenti, affondo in feed opportuna
else {
SetFeed( ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP) ? GetStartFeed() : GetTipFeed()) ;
if ( AddLinearMove( ptP1) == GDB_ID_NULL)
return false ;
}
// aggiungo attacco
bool bTang = (( ! bInvert && m_Params.m_dLiTang > EPS_SMALL) || ( bInvert && m_Params.m_dLoTang > EPS_SMALL)) ;
SetFeed( bTang ? GetStartFeed() : GetTipFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bInvert, pCompo, bSplitArcs)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
return false ;
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1)) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptP3 = pLine->GetEnd() ;
SetFeed( GetFeed()) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ;
pArc->GetEndPoint( ptP3) ;
SetFeed( GetFeed()) ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se ultima entità, uscita e se ultimo step retrazione
if ( i == nMaxInd) {
// se ultima passata, ripristino parametri originali di attacco/uscita
if ( j == nStep)
LioStatus.Restore() ;
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ;
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( j == nStep) {
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
}
else
dEndElev = - LIO_ELEV_TOL ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
}
// per lame retrazione non è necessaria
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bOutStart, bool bAboveStart)
{
SetFlag( 1) ;
// se con aggregato da sotto
if ( m_bAggrBottom) {
// aggiuntivo in Z
double dAggZ = max( dElev + max( dSafeAggrBottZ, dAppr), 0.) ;
// distanza dal bordo del pezzo
double dDistBottom ;
if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, dDistBottom))
dDistBottom = 0 ;
// pre-approccio
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ;
// se rinvio da sotto che richiede speciale rotazione
if ( m_AggrBottom.nType == 1) {
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
if ( AddRapidStart( ptP00, MCH_CL_AGB_DWN) == GDB_ID_NULL)
return false ;
SetAuxDir( m_vtAggrBottom) ;
SetFlag( 0) ;
if ( AddRapidMove( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
}
// altrimenti rinvio normale
else {
SetAuxDir( m_vtAggrBottom) ;
if ( AddRapidStart( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
}
}
// se testa da sopra senza aggregato da sotto, approccio mai da Z negativo
Vector3d vtAppr = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtAppr.z = 0 ;
vtAppr.Normalize() ;
}
// se non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
double dElevZ = vtAppr.z * dElev ;
if ( ! bAboveStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
// se distanza di sicurezza minore di distanza di inizio
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 1 -> punto sopra inizio
Point3d ptP1 = ptP + vtAppr * ( dElev + dAppr) ;
if ( ( ! m_bAggrBottom && AddRapidStart( ptP1) == GDB_ID_NULL) ||
( m_bAggrBottom && AddRapidMove( ptP1) == GDB_ID_NULL))
return false ;
}
else {
// 1a -> punto sopra inizio
Point3d ptP1b = ptP + vtAppr * ( dElev + dAppr) ;
Point3d ptP1a = ptP1b + vtAppr * ( dSafeDist - dAppr) ;
if ( ( ! m_bAggrBottom && AddRapidStart( ptP1a) == GDB_ID_NULL) ||
( m_bAggrBottom && AddRapidMove( ptP1a) == GDB_ID_NULL))
return false ;
// 1b -> punto appena sopra inizio
if ( ( dElev + dAppr) > EPS_SMALL) {
SetFlag( 0) ;
if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
return false ;
}
}
// affondo al punto iniziale
SetFlag( 0) ;
SetFeed( ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP) ? GetStartFeed() : GetTipFeed()) ;
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
}
// sono sopra il pezzo ma non abbastanza
else if ( bAboveStart && ( min( dElevZ, 0.) + dAppr) > 10 * EPS_SMALL) {
// 1b -> punto appena sopra inizio (in Z globale)
Point3d ptP1b = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ;
if ( AddRapidStart( ptP1b) == GDB_ID_NULL)
return false ;
// affondo al punto iniziale
SetFlag( 0) ;
SetFeed( ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP) ? GetStartFeed() : GetTipFeed()) ;
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
}
// altrimenti
else {
// affondo diretto al punto iniziale
if ( ( ! m_bAggrBottom && AddRapidStart( ptP) == GDB_ID_NULL) ||
( m_bAggrBottom && AddRapidMove( ptP) == GDB_ID_NULL))
return false ;
SetFlag( 0) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddDirectApproach( const Point3d& ptP)
{
SetFlag( 1) ;
// affondo diretto al punto iniziale
if ( AddRapidMove( ptP) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bAboveEnd)
{
// se testa da sopra senza aggregato da sotto, approccio mai da Z negativo
Vector3d vtAppr = vtTool ;
if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) {
vtAppr.z = 0 ;
vtAppr.Normalize() ;
}
// se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
double dElevZ = vtAppr.z * dElev ;
if ( ! bAboveEnd && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + vtAppr * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + vtAppr * ( dElev + dAppr) ;
if ( dElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + vtAppr * ( dSafeDist - dAppr) ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
}
// sono sopra il pezzo ma non abbastanza
else if ( bAboveEnd && ( min( dElevZ, 0.) + dAppr) > 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ;
if ( dElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + Z_AX * ( dSafeDist - dAppr) ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
}
// se con aggregato da sotto
if ( m_bAggrBottom) {
// aggiuntivo in Z
double dAggZ = max( dElev + max( dSafeAggrBottZ, dAppr), 0.) ;
// distanza dal bordo del pezzo
double dDistBottom ;
if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, dDistBottom))
dDistBottom = 0 ;
// post-retract
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ;
if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL)
return false ;
// se rinvio da sotto che richiede speciale rotazione
if ( m_AggrBottom.nType == 1) {
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
if ( AddRapidMove( ptP00, MCH_CL_AGB_UP) == GDB_ID_NULL)
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
int
Milling::GetLeadInType( void) const
{
if ( abs( m_Params.m_dLiTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
abs( m_Params.m_dLiPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1))
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) &&
( m_Params.m_dLiTang < min( 0.1 * m_TParams.m_dDiam, 1.0) || m_Params.m_dLiElev < 10 * EPS_SMALL))
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) &&
m_bStepOn && m_Params.m_nStepType == MILL_ST_ZIGZAG)
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) &&
m_bStepOn && m_Params.m_nStepType == MILL_ST_SPIRAL)
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) &&
( m_TParams.m_nType & TF_SAWBLADE) != 0)
return MILL_LI_LINEAR ;
return m_Params.m_nLeadInType ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const
{
// Assegno tipo e parametri
int nType = GetLeadInType() ;
double dTang = m_Params.m_dLiTang ;
double dPerp = m_Params.m_dLiPerp ;
double dElev = min( m_Params.m_dLiElev, dStElev + LIO_ELEV_TOL) ;
// se step invertito
if ( bInvert) {
switch ( m_Params.m_nLeadOutType) {
case MILL_LO_LINEAR : nType = MILL_LI_LINEAR ; break ;
case MILL_LO_TANGENT : nType = MILL_LI_TANGENT ; break ;
case MILL_LO_GLIDE : nType = MILL_LI_GLIDE ; break ;
case MILL_LO_AS_LI : /* resta inalterato */ ; break ;
default : nType = MILL_LI_NONE ; break ;
}
if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
dTang = m_Params.m_dLoTang ;
dPerp = m_Params.m_dLoPerp ;
dElev = min( m_Params.m_dLoElev, dStElev + LIO_ELEV_TOL) ;
}
}
// senso di rotazione da dir tg a dir esterna
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
// verifico di poter fare l'ingresso a inseguimento
if ( nType == MILL_LI_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL)
nType = MILL_LI_NONE ;
// Calcolo punto iniziale
switch ( nType) {
case MILL_LI_NONE :
ptP1 = ptStart ;
return true ;
case MILL_LI_LINEAR :
case MILL_LI_TANGENT : {
Vector3d vtPerp = vtStart ;
vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtN * dElev ;
return true ;
}
case MILL_LI_GLIDE :
{
if ( ! bInvert) {
double dLen, dU ;
if ( ! pCompo->GetLength( dLen) || ! pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU) ||
! pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) {
if ( ! pCompo->GetStartPoint( ptP1))
return false ;
}
}
else {
double dU ;
if ( ! pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU) ||
! pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) {
if ( ! pCompo->GetEndPoint( ptP1))
return false ;
}
}
ptP1 += vtN * ( vtN * ( ptStart - ptP1)) + vtN * dElev ;
return true ;
}
case MILL_LI_ZIGZAG :
ptP1 = ptStart ;
return true ;
case MILL_LI_HELIX :
ptP1 = ptStart ;
return true ;
default :
return false ;
}
}
//----------------------------------------------------------------------------
bool
Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
const Vector3d& vtN, bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs)
{
// Assegno il tipo
int nType = GetLeadInType() ;
double dTang = m_Params.m_dLiTang ;
// se step invertito
if ( bInvert) {
switch ( GetLeadOutType()) {
case MILL_LO_LINEAR : nType = MILL_LI_LINEAR ; 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 ;
}
// verifico di poter fare l'ingresso a inseguimento
if ( nType == MILL_LI_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL)
nType = MILL_LI_NONE ;
// Eseguo a seconda del tipo
switch ( nType) {
case MILL_LI_NONE :
return true ;
case MILL_LI_LINEAR :
return ( AddLinearMove( ptStart, MCH_CL_LEADIN) != GDB_ID_NULL) ;
case MILL_LI_TANGENT :
{
PtrOwner<ICurve> pCrv( GetArc2PVN( ptStart, ptP1, - vtStart, vtN)) ;
if ( IsNull( pCrv))
return false ;
pCrv->Invert() ;
// eventuale spezzatura
if ( bSplitArcs) {
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( IsNull( pCompo) || ! pCompo->AddCurve( Release( pCrv)) || ! ApproxWithLines( pCompo))
return false ;
return ( AddCurveMove( pCompo, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
else {
return ( AddCurveMove( pCrv, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
}
case MILL_LI_GLIDE :
{
// recupero la parte richiesta della curva
PtrOwner<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( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dU, dParE)))
return false ;
if ( m_dAddedOverlap > EPS_SMALL) {
pCrv->Invert() ;
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
pCrv->Invert() ;
}
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
}
else {
double dU ;
if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) {
if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( 0, dU)))
return false ;
if ( m_dAddedOverlap > EPS_SMALL)
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
pCrv->Invert() ;
}
pCrv->SetExtrusion( vtN) ;
// la porto alla giusta quota
Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
Vector3d vtMove = ptStart - ptFin ;
pCrv->Translate( vtMove) ;
// assegno la corretta pendenza
double dNini = ( ptP1 - ORIG) * vtN ;
double dNfin = ( ptStart - ORIG) * vtN ;
AdjustCurveSlope( pCrv, dNini, dNfin) ;
// eventuale spezzatura
if ( bSplitArcs && ! ApproxWithLines( pCrv))
return false ;
// emetto
return ( AddCurveMove( pCrv) != GDB_ID_NULL) ;
}
case MILL_LI_ZIGZAG :
{
double dDeltaN = ( ptStart - ptP1) * vtN ;
int nStep = int( ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL))) ;
double dStep = - dDeltaN / nStep ;
Point3d ptPa = ptP1 + vtStart * 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
Point3d ptPb = ptP1 - vtStart * 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
for ( int i = 1 ; i <= nStep ; ++ i) {
if ( AddLinearMove( ptPa - vtN * ( i - 0.75) * dStep, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
if ( AddLinearMove( ptPb - vtN * ( i - 0.25) * dStep, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
return ( AddLinearMove( ptStart, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
case MILL_LI_HELIX :
{
bool bAtLeft = ( m_Params.m_nWorkSide != MILL_WS_RIGHT) ;
// vettore dal punto al centro elica
Vector3d vtCen = vtStart ;
vtCen.Rotate( vtN, 0, ( bAtLeft ? 1 : - 1)) ;
// dati dell'elica
double dRad = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
Point3d ptCen = ptP1 + vtCen * dRad ;
double dDeltaN = ( ptStart - ptP1) * vtN ;
double dAngCen = ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL)) * ( bAtLeft ? ANG_FULL : - ANG_FULL) ;
// creo l'elica
PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
if ( IsNull( pArc) || ! pArc->Set( ptCen, vtN, dRad, - vtCen, dAngCen, dDeltaN))
return false ;
// eventuale spezzatura
if ( bSplitArcs) {
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( IsNull( pCompo) || ! pCompo->AddCurve( Release( pArc)) || ! ApproxWithLines( pCompo))
return false ;
return ( AddCurveMove( pCompo, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
else {
// emetto l'elica
return ( AddCurveMove( pArc, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
}
default :
return false ;
}
}
//----------------------------------------------------------------------------
int
Milling::GetLeadOutType( void) const
{
if ( abs( m_Params.m_dLoTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
abs( m_Params.m_dLoPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
m_Params.m_nLeadOutType != MILL_LO_AS_LI)
return MILL_LO_NONE ;
return m_Params.m_nLeadOutType ;
}
//----------------------------------------------------------------------------
bool
Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, double dEndElev,
bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs, Point3d& ptP1)
{
// assegno i parametri
int nType = GetLeadOutType() ;
double dTang = m_Params.m_dLoTang ;
double dPerp = m_Params.m_dLoPerp ;
double dElev = min( m_Params.m_dLoElev, dEndElev + LIO_ELEV_TOL) ;
// se uscita come ingresso o step invertito
if ( nType == MILL_LO_AS_LI || bInvert) {
int nLiType = GetLeadInType() ;
switch ( nLiType) {
case MILL_LI_LINEAR : nType = MILL_LO_LINEAR ; break ;
case MILL_LI_TANGENT : nType = MILL_LO_TANGENT ; break ;
case MILL_LI_GLIDE : nType = MILL_LO_GLIDE ; break ;
case MILL_LI_ZIGZAG : nType = MILL_LO_LINEAR ; break ;
case MILL_LI_HELIX : nType = MILL_LO_TANGENT ; break ;
default : nType = MILL_LO_NONE ; break ;
}
dTang = m_Params.m_dLiTang ;
dPerp = m_Params.m_dLiPerp ;
if ( nLiType == MILL_LI_HELIX) {
dTang = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
dPerp = dTang ;
}
dElev = min( m_Params.m_dLiElev, dEndElev + LIO_ELEV_TOL) ;
}
// senso di rotazione da dir tg a dir esterna
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
// verifico di poter fare l'uscita a inseguimento
if ( nType == MILL_LO_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL)
nType = MILL_LO_NONE ;
// eseguo a seconda del tipo
switch ( nType) {
case MILL_LO_NONE :
ptP1 = ptEnd ;
return true ;
case MILL_LO_LINEAR :
{
Vector3d vtPerp = vtEnd ;
vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ;
return ( AddLinearMove( ptP1, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
case MILL_LO_TANGENT :
{
// calcolo punto finale dell'uscita
Vector3d vtPerp = vtEnd ;
vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ;
// inserisco uscita
PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ;
if ( IsNull( pCrv))
return false ;
// eventuale spezzatura
if ( bSplitArcs) {
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( IsNull( pCompo) || ! pCompo->AddCurve( Release( pCrv)) || ! ApproxWithLines( pCompo))
return false ;
return ( AddCurveMove( pCompo, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
else {
return ( AddCurveMove( pCrv, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
}
case MILL_LO_GLIDE :
{
// recupero la parte richiesta della curva di ritorno
PtrOwner<ICurveComposite> pCrv ;
if ( ! bInvert) {
double dU ;
if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) {
if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( 0, dU)))
return false ;
if ( m_dAddedOverlap > EPS_SMALL)
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
}
else {
double dLen, dU ;
if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)) {
double dParS, dParE ;
pCompo->GetDomain( dParS, dParE) ;
if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dU, dParE)))
return false ;
if ( m_dAddedOverlap > EPS_SMALL) {
pCrv->Invert() ;
pCrv->TrimStartAtLen( m_dAddedOverlap) ;
pCrv->Invert() ;
}
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
pCrv->Invert() ;
}
pCrv->SetExtrusion( vtN) ;
// la porto alla giusta quota
Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
Vector3d vtMove = ptEnd - ptIni ;
pCrv->Translate( vtMove) ;
// assegno la corretta pendenza
double dNini = ( ptEnd - ORIG) * vtN ;
AdjustCurveSlope( pCrv, dNini, dNini + dElev) ;
// eventuale spezzatura
if ( bSplitArcs && ! ApproxWithLines( pCrv))
return false ;
// emetto
AddCurveMove( pCrv) ;
// assegno punto finale dell'uscita
pCrv->GetEndPoint( ptP1) ;
return true ;
}
default :
return false ;
}
}
//----------------------------------------------------------------------------
bool
Milling::AdjustOscillParams( const ICurve* pCrv, bool& bPathOscEnable, double& dRampLen, double& dFlatLen)
{
// se c'è oscillazione cerco di aggiustare le lunghezze dei Flat per finire con la stessa quota di partenza
dRampLen = abs( m_Params.m_dOscRampLen) ;
dFlatLen = abs( m_Params.m_dOscFlatLen) ;
if ( bPathOscEnable) {
// lunghezza del percorso
double dLen ; pCrv->GetLength( dLen) ;
// se percorso più corto di mezza oscillazione, la disabilito
if ( dLen < 2 * dRampLen + 2 * OSC_MIN_LEN)
bPathOscEnable = false ;
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 ;
}
//----------------------------------------------------------------------------
double
Milling::GetRadiusForStartEndElevation( void) const
{
const double DELTA_ELEV_RAD = 20.0 ;
double dDeltaRad = DELTA_ELEV_RAD + max( max( m_Params.m_dStartAddLen, m_Params.m_dEndAddLen), 0.0) ;
return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ;
}
//----------------------------------------------------------------------------
bool
Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev) const
{
// per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento fresa lungo il suo asse)
double dTemp ;
if ( ! GetElevation( m_nPhase, ptP, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTemp))
return false ;
return ( dTemp < 10 * EPS_SMALL || dTemp > dElev + 10 * EPS_SMALL) ;
}
// per lame
else {
// determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento lama in Z)
double dTemp ;
if ( ! GetElevation( m_nPhase, ptP, vtTool, 0.5 * m_TParams.m_dDiam, Z_AX, dTemp) || dTemp > 10 * EPS_SMALL)
return false ;
if ( ! GetElevation( m_nPhase, ptP + vtTool * m_TParams.m_dThick, vtTool, 0.5 * m_TParams.m_dDiam, Z_AX, dTemp) || dTemp > 10 * EPS_SMALL)
return false ;
return true ;
}
}
//----------------------------------------------------------------------------
bool
Milling::GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const
{
// derivo punti più bassi dell'utensile
Vector3d vtDown = - FromUprightOrtho( vtTool) ;
Point3d ptP1 = ptP + vtDown * 0.5 * m_TParams.m_dTDiam ;
Point3d ptP2 = ptP1 + vtTool * ((( m_TParams.m_nType & TF_SAWBLADE) == 0) ? m_TParams.m_dLen : m_TParams.m_dThick) ;
// determino la posizione dei punti rispetto al grezzo
// ciclo sui grezzi
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
// se il grezzo compare nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
BBox3d b3Raw ;
m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ;
if ( ! b3Raw.IsEmpty()) {
if ( ptP1.z < b3Raw.GetMax().z + 10 * EPS_SMALL ||
ptP2.z < b3Raw.GetMax().z + 10 * EPS_SMALL)
return false ;
}
}
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU)
{
// verifico curva
if ( pCompo == nullptr)
return false ;
// se utensile centrato, direzione di correzione nulla
if ( m_Params.m_nWorkSide == MILL_WS_CENTER)
return true ;
// calcolo del versore correzione
Vector3d vtCorr = CalcCorrDir( pCompo, dU) ;
// imposto versore correzione
SetCorrDir( vtCorr) ;
// se rinvio da sotto in uso, non devo impostare direzione aux da correzione
if ( m_bAggrBottom)
return true ;
// se impostato uso direttamente da lavorazione, imposto anche come versore aux
if ( m_Params.m_nSolCh == MCH_SCC_ADIR_NEAR || m_Params.m_nSolCh == MCH_SCC_ADIR_FAR)
SetAuxDir( vtCorr) ;
// se standard o nullo o suo opposto
if ( m_Params.m_nSolCh == MCH_SCC_STD || m_Params.m_nSolCh == MCH_SCC_NONE || m_Params.m_nSolCh == MCH_SCC_OPPOSITE) {
// verifico se richiesto dalla testa
if ( m_nHeadSolCh == MCH_SCC_ADIR_NEAR || m_nHeadSolCh == MCH_SCC_ADIR_FAR)
SetAuxDir( vtCorr) ;
}
return true ;
}
//----------------------------------------------------------------------------
Vector3d
Milling::CalcCorrDir( const ICurveComposite* pCompo, double dU)
{
// verifico curva
if ( pCompo == nullptr)
return V_NULL ;
// se utensile centrato, direzione di correzione nulla
if ( m_Params.m_nWorkSide == MILL_WS_CENTER)
return V_NULL ;
// angolo di rotazione da tg a versore corr/aux
bool bCcwRot = (m_Params.m_nWorkSide == MILL_WS_LEFT) ;
double dCaRot = ( bCcwRot ? ANG_RIGHT : -ANG_RIGHT) ;
// dominio parametrico della curva
double dUs, dUe ;
pCompo->GetDomain( dUs, dUe) ;
// se inizio
if ( dU < dUs + EPS_ZERO) {
// recupero la tangente dopo
Point3d ptP ;
Vector3d vtN ;
pCompo->GetPointTang( dU, ICurve::FROM_PLUS, ptP, vtN) ;
vtN.Rotate( m_vtTool, dCaRot) ;
return vtN ;
}
// se fine
else if ( dU > dUe - EPS_ZERO) {
// recupero la tangente prima
Point3d ptP ;
Vector3d vtN ;
pCompo->GetPointTang( dU, ICurve::FROM_MINUS, ptP, vtN) ;
vtN.Rotate( m_vtTool, dCaRot) ;
return vtN ;
}
// altrimenti
else {
// recupero la tangente prima e dopo il punto
Point3d ptP1, ptP2 ;
Vector3d vtT1, vtT2 ;
pCompo->GetPointTang( dU, ICurve::FROM_MINUS, ptP1, vtT1) ;
pCompo->GetPointTang( dU, ICurve::FROM_PLUS, ptP2, vtT2) ;
// se coincidono
if ( AreSameVectorApprox( vtT1, vtT2)) {
Vector3d vtN = vtT1 ;
vtN.Rotate( m_vtTool, dCaRot) ;
return vtN ;
}
// se sono opposte
else if ( AreOppositeVectorApprox( vtT1, vtT2)) {
Vector3d vtN = ( bCcwRot ? vtT2 : vtT1) ;
return vtN ;
}
// altrimenti
else {
Vector3d vtN = ( vtT1 + vtT2) / 2 ;
vtN.Rotate( m_vtTool, dCaRot) ;
return vtN ;
}
}
}
//----------------------------------------------------------------------------
bool
Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs)
{
// eseguo offset semplice
int nFlag = ICurve::OFF_FILLET | ICurve::OFF_FORCE_OPEN ;
if ( pCompo->SimpleOffset( dSignOffs, nFlag))
return true ;
// se curva piatta, provo con offset avanzato
bool bOk = false ;
Plane3d plPlane ;
Vector3d vtExtr ;
pCompo->GetExtrusion( vtExtr) ;
if ( pCompo->IsFlat( plPlane, 100 * EPS_SMALL) &&
AreSameOrOppositeVectorApprox( vtExtr, plPlane.GetVersN())) {
OffsetCurve OffsCrv ;
if ( OffsCrv.Make( pCompo, dSignOffs, nFlag)) {
ICurve* pOffs = OffsCrv.GetLongerCurve() ;
if ( pOffs != nullptr) {
pCompo->Clear() ;
pCompo->AddCurve( pOffs) ;
bOk = true ;
}
}
}
return bOk ;
}
Reference in New Issue View Git Blame Copy Permalink