Dario Sassi
b88aa9cf18
- correzioni per rinvio da sotto speciale (MDC) - ottimizzato caricamento altri utensili su testa con più uscite - salvato stato visualizzazione macchina e aggiunta funzione per restituirlo - si garantisce la visualizzazione completa della macchina durante Apply e Update delle lavorazioni.
2988 lines
113 KiB
C++
2988 lines
113 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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 "MachiningConst.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/EGkUserObjFactory.h"
|
|
#include "/EgtDev/Include/EGnStringKeyVal.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
|
|
using namespace std ;
|
|
|
|
//------------------------------ 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 : link movements not calculable"
|
|
// 2319 = "Error in Milling : post apply not calculable"
|
|
|
|
//----------------------------------------------------------------------------
|
|
USEROBJ_REGISTER( "EMkMilling", 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_Params = m_Params ;
|
|
pMill->m_TParams = m_TParams ;
|
|
}
|
|
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 ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Milling::Save( STRVECTOR& vString) const
|
|
{
|
|
try {
|
|
int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 2 ;
|
|
vString.insert( vString.begin(), nSize, "") ;
|
|
int k = - 1 ;
|
|
if ( ! SetVal( KEY_IDS, m_vId, vString[++k]))
|
|
return false ;
|
|
for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
|
|
vString[++k] = m_Params.ToString( i) ;
|
|
for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
|
|
vString[++k] = m_TParams.ToString( i) ;
|
|
if ( ! SetVal( KEY_PHASE, m_nPhase, vString[++k]))
|
|
return false ;
|
|
if ( ! SetVal( KEY_NUM, m_nMills, 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 ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//----------------------------------------------------------------------------
|
|
Milling::Milling( void)
|
|
{
|
|
m_Params.m_sName = "*" ;
|
|
m_Params.m_sToolName = "*" ;
|
|
m_TParams.m_sName = "*" ;
|
|
m_TParams.m_sHead = "*" ;
|
|
m_nMills = 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 :
|
|
m_Params.m_bInvert = bVal ;
|
|
return true ;
|
|
case MPA_LEAVETAB :
|
|
m_Params.m_bLeaveTab = bVal ;
|
|
return true ;
|
|
case MPA_TOOLINVERT :
|
|
m_Params.m_bToolInvert = bVal ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Milling::SetParam( int nType, int nVal)
|
|
{
|
|
switch ( nType) {
|
|
case MPA_WORKSIDE :
|
|
if ( ! m_Params.VerifyWorkSide( nVal))
|
|
return false ;
|
|
m_Params.m_nWorkSide = nVal ;
|
|
return true ;
|
|
case MPA_STEPTYPE :
|
|
if ( ! m_Params.VerifyStepType( nVal))
|
|
return false ;
|
|
m_Params.m_nStepType = nVal ;
|
|
return true ;
|
|
case MPA_LEADINTYPE :
|
|
if ( ! m_Params.VerifyLeadInType( nVal))
|
|
return false ;
|
|
m_Params.m_nLeadInType = nVal ;
|
|
return true ;
|
|
case MPA_LEADOUTTYPE :
|
|
if ( ! m_Params.VerifyLeadOutType( nVal))
|
|
return false ;
|
|
m_Params.m_nLeadOutType = nVal ;
|
|
return true ;
|
|
case MPA_SCC :
|
|
if ( ! m_Params.VerifySolCh( nVal))
|
|
return false ;
|
|
m_Params.m_nSolCh = nVal ;
|
|
return true ;
|
|
case MPA_FACEUSE :
|
|
if ( ! m_Params.VerifyFaceUse( nVal))
|
|
return false ;
|
|
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)
|
|
m_Params.m_dSpeed = 0 ;
|
|
else
|
|
m_Params.m_dSpeed = dVal ;
|
|
return true ;
|
|
case MPA_FEED :
|
|
if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR)
|
|
m_Params.m_dFeed = 0 ;
|
|
else
|
|
m_Params.m_dFeed = dVal ;
|
|
return true ;
|
|
case MPA_STARTFEED :
|
|
if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
|
|
m_Params.m_dStartFeed = 0 ;
|
|
else
|
|
m_Params.m_dStartFeed = dVal ;
|
|
return true ;
|
|
case MPA_ENDFEED :
|
|
if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
|
|
m_Params.m_dEndFeed = 0 ;
|
|
else
|
|
m_Params.m_dEndFeed = dVal ;
|
|
return true ;
|
|
case MPA_TIPFEED :
|
|
if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
|
|
m_Params.m_dTipFeed = 0 ;
|
|
else
|
|
m_Params.m_dTipFeed = dVal ;
|
|
return true ;
|
|
case MPA_OFFSR :
|
|
if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR)
|
|
m_Params.m_dOffsR = UNKNOWN_PAR ;
|
|
else
|
|
m_Params.m_dOffsR = dVal ;
|
|
return true ;
|
|
case MPA_OFFSL :
|
|
if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
|
|
m_Params.m_dOffsL = UNKNOWN_PAR ;
|
|
else
|
|
m_Params.m_dOffsL = dVal ;
|
|
return true ;
|
|
case MPA_DEPTH :
|
|
m_Params.m_sDepth = ToString( dVal) ;
|
|
return true ;
|
|
case MPA_STARTPOS :
|
|
m_Params.m_dStartPos = dVal ;
|
|
return true ;
|
|
case MPA_OVERL :
|
|
m_Params.m_dOverlap = dVal ;
|
|
return true ;
|
|
case MPA_STEP :
|
|
m_Params.m_dStep = dVal ;
|
|
return true ;
|
|
case MPA_STARTADDLEN :
|
|
m_Params.m_dStartAddLen = dVal ;
|
|
return true ;
|
|
case MPA_ENDADDLEN :
|
|
m_Params.m_dEndAddLen = dVal ;
|
|
return true ;
|
|
case MPA_LITANG :
|
|
m_Params.m_dLiTang = dVal ;
|
|
return true ;
|
|
case MPA_LIPERP :
|
|
m_Params.m_dLiPerp = dVal ;
|
|
return true ;
|
|
case MPA_LIELEV :
|
|
m_Params.m_dLiElev = dVal ;
|
|
return true ;
|
|
case MPA_LICOMPLEN :
|
|
m_Params.m_dLiCompLen = dVal ;
|
|
return true ;
|
|
case MPA_LOTANG :
|
|
m_Params.m_dLoTang = dVal ;
|
|
return true ;
|
|
case MPA_LOPERP :
|
|
m_Params.m_dLoPerp = dVal ;
|
|
return true ;
|
|
case MPA_LOELEV :
|
|
m_Params.m_dLoElev = dVal ;
|
|
return true ;
|
|
case MPA_LOCOMPLEN :
|
|
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 ;
|
|
m_Params.m_sToolName = sVal ;
|
|
m_Params.m_ToolUuid = pTdata->m_Uuid ;
|
|
m_TParams = *pTdata ;
|
|
} break ;
|
|
case MPA_DEPTH_STR :
|
|
m_Params.m_sDepth = sVal ;
|
|
return true ;
|
|
case MPA_SYSNOTES :
|
|
m_Params.m_sSysNotes = sVal ;
|
|
break ;
|
|
case MPA_USERNOTES :
|
|
m_Params.m_sUserNotes = sVal ;
|
|
break ;
|
|
case MPA_INITANGS :
|
|
m_Params.m_sInitAngs = sVal ;
|
|
break ;
|
|
case MPA_BLOCKEDAXIS :
|
|
m_Params.m_sBlockedAxis = sVal ;
|
|
break ;
|
|
default :
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
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 o tutte facce)
|
|
int nType = GEO_NONE ;
|
|
for ( const auto& Id : vIds) {
|
|
// test sull'entità
|
|
int nSubs ;
|
|
if ( ! VerifyGeometry( Id, nSubs, nType)) {
|
|
string sOut = "Entity " + ToString( Id) + " skipped by Milling" ;
|
|
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
|
|
continue ;
|
|
}
|
|
// posso aggiungere alla lista
|
|
m_vId.emplace_back( Id) ;
|
|
}
|
|
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 ;
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
// 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 ;
|
|
}
|
|
|
|
// 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 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
|
|
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
|
|
while ( nPathId != GDB_ID_NULL) {
|
|
if ( ! ProcessPath( nPathId, GDB_ID_NULL, nClId))
|
|
return false ;
|
|
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
|
|
}
|
|
|
|
//// imposto l'utensile per l'anteprima !!! provvisorio per test !!!
|
|
// if ( ! m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()))
|
|
// return false ;
|
|
// ShowTool( 0, 0) ;
|
|
|
|
// eseguo aggiornamento assi macchina e collegamento con operazione precedente
|
|
return Update() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Milling::Update( void)
|
|
{
|
|
// 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) {
|
|
LOG_INFO( GetEMkLogger(), "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)) {
|
|
m_pMchMgr->SetLastError( 2317, "Error in Milling : axes values not calculable") ;
|
|
return false ;
|
|
}
|
|
|
|
// gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
|
|
if ( ! AdjustStartEndMovements()) {
|
|
m_pMchMgr->SetLastError( 2318, "Error in Milling : link movements not calculable") ;
|
|
return false ;
|
|
}
|
|
|
|
// esecuzione eventuali personalizzazioni
|
|
if ( ! PostApply()) {
|
|
m_pMchMgr->SetLastError( 2319, "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 ;
|
|
}
|
|
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_LITANG :
|
|
dVal = m_Params.m_dLiTang ;
|
|
return true ;
|
|
case MPA_LIPERP :
|
|
dVal = m_Params.m_dLiPerp ;
|
|
return true ;
|
|
case MPA_LIELEV :
|
|
dVal = m_Params.m_dLiElev ;
|
|
return true ;
|
|
case MPA_LICOMPLEN :
|
|
dVal = m_Params.m_dLiCompLen ;
|
|
return true ;
|
|
case MPA_LOTANG :
|
|
dVal = m_Params.m_dLoTang ;
|
|
return true ;
|
|
case MPA_LOPERP :
|
|
dVal = m_Params.m_dLoPerp ;
|
|
return true ;
|
|
case MPA_LOELEV :
|
|
dVal = m_Params.m_dLoElev ;
|
|
return true ;
|
|
case MPA_LOCOMPLEN :
|
|
dVal = m_Params.m_dLoCompLen ;
|
|
return true ;
|
|
}
|
|
dVal = 0 ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Milling::GetParam( int nType, string& sVal) const
|
|
{
|
|
switch ( nType) {
|
|
case MPA_NAME :
|
|
sVal = m_Params.m_sName ;
|
|
return true ;
|
|
case MPA_TOOL :
|
|
sVal = m_Params.m_sToolName ;
|
|
return true ;
|
|
case MPA_DEPTH_STR :
|
|
sVal = m_Params.m_sDepth ;
|
|
return true ;
|
|
case MPA_TUUID :
|
|
sVal = ToString( m_Params.m_ToolUuid) ;
|
|
return true ;
|
|
case MPA_UUID :
|
|
sVal = ToString( m_Params.m_Uuid) ;
|
|
return true ;
|
|
case MPA_SYSNOTES :
|
|
sVal = m_Params.m_sSysNotes ;
|
|
return true ;
|
|
case MPA_USERNOTES :
|
|
sVal = m_Params.m_sUserNotes ;
|
|
return true ;
|
|
case MPA_INITANGS :
|
|
sVal = m_Params.m_sInitAngs ;
|
|
return true ;
|
|
case MPA_BLOCKEDAXIS :
|
|
sVal = m_Params.m_sBlockedAxis ;
|
|
return true ;
|
|
}
|
|
sVal = "" ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const ToolData&
|
|
Milling::GetToolData( void) const
|
|
{
|
|
return m_TParams ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Milling::UpdateToolData( void)
|
|
{
|
|
// recupero il gestore DB utensili della macchina corrente
|
|
ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
|
|
if ( pTMgr == nullptr)
|
|
return false ;
|
|
// recupero l'utensile nel DB utensili
|
|
const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
|
|
if ( pTdata == nullptr)
|
|
return false ;
|
|
// aggiorno i parametri
|
|
m_TParams = *pTdata ;
|
|
if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) {
|
|
string sLog = "Warning in Milling : tool name changed (" +
|
|
m_Params.m_sToolName + "->" + m_TParams.m_sName +")" ;
|
|
LOG_INFO( GetEMkLogger(), sLog.c_str()) ;
|
|
}
|
|
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 : tutte curve o tutte facce di trimesh
|
|
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
|
|
if ( pGObj == nullptr)
|
|
return false ;
|
|
// se ammesse curve ed è tale
|
|
if ( nType != GEO_SURF && ( pGObj->GetType() & GEO_CURVE) != 0) {
|
|
const ICurve* pCurve = nullptr ;
|
|
// se direttamente la curva
|
|
if ( Id.nSub == SEL_SUB_ALL) {
|
|
pCurve = ::GetCurve( pGObj) ;
|
|
if ( pCurve != nullptr) {
|
|
if ( pCurve->GetType() == CRV_COMPO)
|
|
nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
|
|
else
|
|
nSubs = 0 ;
|
|
}
|
|
}
|
|
// altrimenti sottocurva di composita
|
|
else {
|
|
const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
|
|
if ( pCompo != nullptr)
|
|
pCurve = pCompo->GetCurve( Id.nSub) ;
|
|
nSubs = 0 ;
|
|
}
|
|
return ( pCurve != nullptr) ;
|
|
}
|
|
// se altrimenti ammesse superfici trimesh ed è tale
|
|
else if ( nType != GEO_CURVE && ( pGObj->GetType() & GEO_SURF) != 0) {
|
|
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
|
|
if ( pSurf == nullptr)
|
|
return false ;
|
|
// se direttamente la superficie
|
|
if ( Id.nSub == SEL_SUB_ALL) {
|
|
nSubs = pSurf->GetFacetCount() ;
|
|
return true ;
|
|
}
|
|
// altrimenti faccia di superficie trimesh
|
|
else {
|
|
// se faccia non esistente
|
|
if ( Id.nSub > pSurf->GetFacetCount())
|
|
return false ;
|
|
// tutto bene
|
|
nSubs = 0 ;
|
|
return true ;
|
|
}
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
ICurve*
|
|
Milling::GetCurve( SelData Id)
|
|
{
|
|
// ammessi : curve o facce di polymesh
|
|
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
|
|
if ( pGObj == nullptr)
|
|
return nullptr ;
|
|
// ne recupero il riferimento globale
|
|
Frame3d frGlob ;
|
|
if ( ! m_pGeomDB->GetGlobFrame( Id.nId, frGlob))
|
|
return nullptr ;
|
|
// se curva
|
|
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
|
|
PtrOwner<ICurve> pCurve ;
|
|
// se direttamente curva
|
|
if ( Id.nSub == SEL_SUB_ALL) {
|
|
// recupero e duplico la curva
|
|
const ICurve* pOriCurve = ::GetCurve( pGObj) ;
|
|
if ( pOriCurve != nullptr)
|
|
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) {
|
|
// duplico la curva semplice
|
|
const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ;
|
|
if ( pOriCurve != nullptr) {
|
|
pCurve.Set( pOriCurve->Clone()) ;
|
|
// recupero estrusione e spessore
|
|
Vector3d vtExtr ;
|
|
if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall())
|
|
vtExtr = Z_AX ;
|
|
pCurve->SetExtrusion( vtExtr) ;
|
|
double dThick ;
|
|
if ( pCompo->GetThickness( dThick))
|
|
pCurve->SetThickness( dThick) ;
|
|
}
|
|
}
|
|
}
|
|
if ( IsNull( pCurve))
|
|
return nullptr ;
|
|
// la porto in globale
|
|
pCurve->ToGlob( frGlob) ;
|
|
// la restituisco
|
|
return Release( pCurve) ;
|
|
}
|
|
// se altrimenti superficie
|
|
else if ( ( pGObj->GetType() & GEO_SURF) != 0) {
|
|
// recupero la trimesh
|
|
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
|
|
if ( pSurf == nullptr)
|
|
return nullptr ;
|
|
// 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 nullptr ;
|
|
// recupero la normale esterna della faccia
|
|
Vector3d vtN ;
|
|
if ( ! pSurf->GetFacetNormal( nFacet, vtN))
|
|
return nullptr ;
|
|
// creo la curva a partire da quello esterno
|
|
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
|
|
pCrvCompo->FromPolyLine( vPL[0]) ;
|
|
if ( ! pCrvCompo->IsValid())
|
|
return nullptr ;
|
|
// assegno l'estrusione dalla normale alla faccia
|
|
pCrvCompo->SetExtrusion( vtN) ;
|
|
// la porto in globale
|
|
pCrvCompo->ToGlob( frGlob) ;
|
|
// sistemazioni varie
|
|
AdjustCurveFromSurf( pCrvCompo) ;
|
|
// la restituisco
|
|
return Release( pCrvCompo) ;
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return nullptr ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Milling::AdjustCurveFromSurf( ICurveComposite* pCrvCompo)
|
|
{
|
|
// tipo posizione utensile
|
|
enum { TOOL_PARAL = 1, TOOL_ORTHO = 2, TOOL_ORTUP = 3} ;
|
|
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 ;
|
|
// tipo di utilizzo contorno faccia
|
|
enum { FACE_DOWN = 1, FACE_TOP = 2, FACE_FRONT = 3, FACE_BACK = 4, FACE_LEFT = 5, FACE_RIGHT = 6, FACE_CONT = 7} ;
|
|
int nFace = ( m_Params.m_nFaceUse & 31) ;
|
|
|
|
// copia della curva originale
|
|
PtrOwner<ICurveComposite> pCopy( pCrvCompo->Clone()) ;
|
|
|
|
// se richiesto contorno
|
|
if ( nFace == FACE_CONT) {
|
|
// cerco l'estremo più alto e lo imposto come inizio
|
|
double dU = 0 ;
|
|
double dUmax = 0 ;
|
|
double dZmax = - INFINITO ;
|
|
Point3d ptP ;
|
|
while ( pCrvCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP)) {
|
|
if ( ptP.z > dZmax + EPS_SMALL) {
|
|
dZmax = ptP.z ;
|
|
dUmax = dU ;
|
|
}
|
|
dU += 1 ;
|
|
}
|
|
if ( dU != 0)
|
|
pCrvCompo->ChangeStartPoint( dUmax) ;
|
|
}
|
|
// altrimenti
|
|
else {
|
|
// ingombro
|
|
BBox3d b3Box ;
|
|
pCrvCompo->GetLocalBBox( b3Box) ;
|
|
double dMin = b3Box.GetMin().z ;
|
|
double dMax = b3Box.GetMax().z ;
|
|
if ( nFace == FACE_FRONT || nFace == FACE_BACK) {
|
|
dMin = b3Box.GetMin().y ;
|
|
dMax = b3Box.GetMax().y ;
|
|
}
|
|
else if ( nFace == FACE_RIGHT || nFace == FACE_LEFT) {
|
|
dMin = b3Box.GetMin().x ;
|
|
dMax = b3Box.GetMax().x ;
|
|
}
|
|
double dTol = min( ( dMax - dMin) / 4., 20.) ;
|
|
// cerco il punto medio delle curve più vicino all'estremo desiderato
|
|
double dRef = dMin ;
|
|
if ( nFace == FACE_DOWN || nFace == FACE_FRONT || nFace == FACE_LEFT)
|
|
dRef = dMax ;
|
|
const ICurve* pCrv = pCrvCompo->GetFirstCurve() ;
|
|
while ( pCrv != nullptr) {
|
|
Point3d ptMid ; pCrv->GetMidPoint( ptMid) ;
|
|
switch ( nFace) {
|
|
case FACE_DOWN : dRef = min( dRef, ptMid.z) ; break ;
|
|
case FACE_TOP : dRef = max( dRef, ptMid.z) ; break ;
|
|
case FACE_FRONT : dRef = min( dRef, ptMid.y) ; break ;
|
|
case FACE_BACK : dRef = max( dRef, ptMid.y) ; break ;
|
|
case FACE_LEFT : dRef = min( dRef, ptMid.x) ; break ;
|
|
case FACE_RIGHT : dRef = max( dRef, ptMid.x) ; break ;
|
|
}
|
|
pCrv = pCrvCompo->GetNextCurve() ;
|
|
}
|
|
// elimino le linee troppo discoste dal riferimento dall'inizio e poi dalla fine
|
|
pCrv = pCrvCompo->GetFirstCurve() ;
|
|
while ( pCrv != nullptr) {
|
|
Point3d ptMid ; pCrv->GetMidPoint( ptMid) ;
|
|
if ( ( nFace == FACE_DOWN && ptMid.z > dRef + dTol) ||
|
|
( nFace == FACE_TOP && ptMid.z < dRef - dTol) ||
|
|
( nFace == FACE_FRONT && ptMid.y > dRef + dTol) ||
|
|
( nFace == FACE_BACK && ptMid.y < dRef - dTol) ||
|
|
( nFace == FACE_LEFT && ptMid.x > dRef + dTol) ||
|
|
( nFace == FACE_RIGHT && ptMid.x < dRef - dTol)) {
|
|
ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( false) ;
|
|
delete( pErase) ;
|
|
pCrv = pCrvCompo->GetFirstCurve() ;
|
|
}
|
|
else
|
|
break ;
|
|
}
|
|
pCrv = pCrvCompo->GetLastCurve() ;
|
|
while ( pCrv != nullptr) {
|
|
Point3d ptMid ; pCrv->GetMidPoint( ptMid) ;
|
|
if ( ( nFace == FACE_DOWN && ptMid.z > dRef + dTol) ||
|
|
( nFace == FACE_TOP && ptMid.z < dRef - dTol) ||
|
|
( nFace == FACE_FRONT && ptMid.y > dRef + dTol) ||
|
|
( nFace == FACE_BACK && ptMid.y < dRef - dTol) ||
|
|
( nFace == FACE_LEFT && ptMid.x > dRef + dTol) ||
|
|
( nFace == FACE_RIGHT && ptMid.x < dRef - dTol)) {
|
|
ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( true) ;
|
|
delete( pErase) ;
|
|
pCrv = pCrvCompo->GetLastCurve() ;
|
|
}
|
|
else
|
|
break ;
|
|
}
|
|
}
|
|
// determino il versore estrusione (utensile)
|
|
if ( nToolDir == TOOL_ORTHO)
|
|
pCrvCompo->SetThickness( 0) ;
|
|
else if ( nToolDir == TOOL_ORTUP) {
|
|
Vector3d vtN ;
|
|
pCrvCompo->GetExtrusion( vtN) ;
|
|
if ( vtN.z < - sin( 2 * DEGTORAD)) {
|
|
// pCrvCompo->Invert() ;
|
|
pCrvCompo->Translate( vtN * m_TParams.m_dThick) ;
|
|
pCrvCompo->SetExtrusion( - vtN) ;
|
|
}
|
|
pCrvCompo->SetThickness( 0) ;
|
|
}
|
|
else { // nToolDir == TOOL_PARAL
|
|
// sistemo versore
|
|
Vector3d vtN ;
|
|
pCrvCompo->GetExtrusion( vtN) ;
|
|
Point3d ptStart, ptEnd ;
|
|
pCrvCompo->GetStartPoint( ptStart) ;
|
|
pCrvCompo->GetEndPoint( ptEnd) ;
|
|
Vector3d vtT = ptEnd - ptStart ;
|
|
Vector3d vtExtr = vtN ^ vtT ;
|
|
if ( ! vtExtr.Normalize())
|
|
return false ;
|
|
pCrvCompo->SetExtrusion( vtExtr) ;
|
|
// elimino eventuali parti iniziali e/o finali dirette circa come il versore
|
|
const double MAX_ALL_COS = cos( 25 * DEGTORAD) ;
|
|
const ICurve* pCrv = pCrvCompo->GetFirstCurve() ;
|
|
while ( pCrv != nullptr) {
|
|
Vector3d vtDir ; pCrv->GetStartDir( vtDir) ;
|
|
if ( abs( vtDir * vtExtr) > MAX_ALL_COS) {
|
|
ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( false) ;
|
|
delete( pErase) ;
|
|
pCrv = pCrvCompo->GetFirstCurve() ;
|
|
}
|
|
else
|
|
break ;
|
|
}
|
|
pCrv = pCrvCompo->GetLastCurve() ;
|
|
while ( pCrv != nullptr) {
|
|
Vector3d vtDir ; pCrv->GetStartDir( vtDir) ;
|
|
if ( abs( vtDir * vtExtr) > MAX_ALL_COS) {
|
|
ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( true) ;
|
|
delete( pErase) ;
|
|
pCrv = pCrvCompo->GetLastCurve() ;
|
|
}
|
|
else
|
|
break ;
|
|
}
|
|
// determino lo spessore misurato lungo la direzione
|
|
if ( ! IsNull( pCopy)) {
|
|
Frame3d frOcs ; frOcs.Set( ORIG, vtExtr) ;
|
|
Frame3d frExtr ; frExtr.ToLoc( frOcs) ;
|
|
BBox3d b3Extr ; pCopy->GetBBox( frExtr, b3Extr) ;
|
|
if ( ! b3Extr.IsEmpty())
|
|
pCrvCompo->SetThickness( b3Extr.GetMax().z - b3Extr.GetMin().z) ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Milling::Chain( int nGrpDestId)
|
|
{
|
|
// vettore puntatori alle curve
|
|
POCRVVECTOR vpCrvs ;
|
|
vpCrvs.reserve( m_vId.size()) ;
|
|
// recupero tutte le curve e le porto in globale
|
|
for ( const auto& Id : m_vId) {
|
|
// prendo curva
|
|
vpCrvs.emplace_back( GetCurve( Id)) ;
|
|
// ne verifico la validità
|
|
if ( IsNull( vpCrvs.back())) {
|
|
string sOut = "Entity " + ToString( Id) + " skipped by Milling" ;
|
|
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
|
|
vpCrvs.back().Reset() ;
|
|
}
|
|
}
|
|
// 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( m_vId[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) && fabs( dTemp) > fabs( 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
|
|
{
|
|
// 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)) ;
|
|
|
|
// eventuale inversione percorso
|
|
if ( m_Params.m_bInvert)
|
|
pCompo->Invert() ;
|
|
|
|
// recupero estrusione e spessore
|
|
Vector3d vtExtr ;
|
|
pCompo->GetExtrusion( vtExtr) ;
|
|
double dThick ;
|
|
pCompo->GetThickness( dThick) ;
|
|
|
|
// eventuale inversione direzione utensile
|
|
if ( m_Params.m_bToolInvert) {
|
|
vtExtr.Invert() ;
|
|
pCompo->SetExtrusion( vtExtr) ;
|
|
dThick = - dThick ;
|
|
pCompo->SetThickness( dThick) ;
|
|
}
|
|
|
|
// 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) {
|
|
LOG_INFO( GetEMkLogger(), "Warning in Milling : skipped Path too small") ;
|
|
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 ;
|
|
// flag offset
|
|
int nFlag = ICurve::OFF_FILLET ;
|
|
// esecuzione offset
|
|
if ( ! pCompo->SimpleOffset( dSignOffs, nFlag)) {
|
|
// se curva piatta, provo con offset avanzato
|
|
bool bOk = false ;
|
|
Plane3d plPlane ;
|
|
if ( pCompo->IsFlat( plPlane, 100 * EPS_SMALL) &&
|
|
AreSameOrOppositeVectorApprox( vtExtr, plPlane.vtN)) {
|
|
OffsetCurve OffsCrv ;
|
|
if ( OffsCrv.Make( pCompo, dSignOffs, nFlag)) {
|
|
ICurve* pOffs = OffsCrv.GetLongerCurve() ;
|
|
if ( pOffs != nullptr) {
|
|
pCompo->Clear() ;
|
|
pCompo->AddCurve( pOffs) ;
|
|
bOk = true ;
|
|
}
|
|
}
|
|
}
|
|
if ( ! bOk) {
|
|
m_pMchMgr->SetLastError( 2302, "Error in Milling : Offset not computable") ;
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
|
|
// eventuale sovrapposizione per percorso chiuso
|
|
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)) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// unisco le parti allineate (tranne inizio-fine se chiusa)
|
|
if ( ! pCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false))
|
|
return false ;
|
|
|
|
// recupero il punto di inizio (per poi salvarlo nelle info di CL path)
|
|
Point3d ptStart ;
|
|
pCompo->GetStartPoint( ptStart) ;
|
|
|
|
// recupero il box del grezzo in globale
|
|
BBox3d b3Raw ;
|
|
if ( ! GetRawGlobBox( m_nPhase, nPathId, 0.5 * m_TParams.m_dDiam, 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( vtExtr, Z_AX)) {
|
|
if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, m_TParams.m_dDiam, 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 && ! vtExtr.IsZplus()) ||
|
|
( nSplitArcs == SPLAR_GEN_PLANE && vtExtr.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 il versore fresa
|
|
Vector3d vtTool = Z_AX ;
|
|
if ( ! vtExtr.IsSmall())
|
|
vtTool = vtExtr ;
|
|
|
|
// calcolo l'elevazione massima
|
|
double dElev ;
|
|
if ( CalcPathElevation( pCompo, vtTool, dDepth, 0.5 * m_TParams.m_dDiam, dElev)) {
|
|
if ( dElev < EPS_SMALL && AreSameVectorApprox( vtExtr, Z_AX)) {
|
|
BBox3d b3Crv ;
|
|
pCompo->GetLocalBBox( b3Crv) ;
|
|
dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z + min( 0., dThick) + dDepth) ;
|
|
}
|
|
}
|
|
else
|
|
return false ;
|
|
|
|
// verifico che lo step dell'utensile sia sensato
|
|
double dOkStep = m_Params.m_dStep ;
|
|
const double MIN_ZSTEP = 1.0 ;
|
|
if ( dOkStep >= EPS_SMALL && dOkStep < MIN_ZSTEP) {
|
|
dOkStep = MIN_ZSTEP ;
|
|
string sInfo = "Warning in Milling : machining step too small (" +
|
|
ToString( m_Params.m_dStep, 2) + ")" ;
|
|
LOG_INFO( GetEMkLogger(), sInfo.c_str()) ;
|
|
}
|
|
|
|
// per frese normali, verifico di non superare il massimo materiale
|
|
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
|
|
// 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 ;
|
|
}
|
|
// se lo step supera la capacità dell'utensile
|
|
if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) {
|
|
dOkStep = m_TParams.m_dMaxMat ;
|
|
string sInfo = "Warning in Milling : machining step (" + ToString( m_Params.m_dStep, 1) +
|
|
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
|
|
LOG_INFO( GetEMkLogger(), sInfo.c_str()) ;
|
|
}
|
|
// se lavorazione singola e l'elevazione supera la capacità dell'utensile
|
|
if ( ( dOkStep < EPS_SMALL || dOkStep > dElev) && dElev > m_TParams.m_dMaxMat + EPS_SMALL) {
|
|
// se affondamento riducibile : segnalo, riduco e continuo
|
|
if ( dDepth + max( dThick, 0.0) > m_TParams.m_dMaxMat) {
|
|
dDepth = m_TParams.m_dMaxMat - max( dThick, 0.0) ;
|
|
string sInfo = "Warning in Milling : machining depth (" + ToString( dElev, 1) +
|
|
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
|
|
LOG_INFO( GetEMkLogger(), sInfo.c_str()) ;
|
|
}
|
|
// altrimenti errore
|
|
else {
|
|
string sInfo = "Error in Milling : machining depth (" + ToString( dElev, 1) +
|
|
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
|
|
m_pMchMgr->SetLastError( 2305, sInfo.c_str()) ;
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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 lavorazione 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 il punto di inizio al gruppo del percorso
|
|
m_pGeomDB->SetInfo( nPxId, KEY_START, ptStart) ;
|
|
// assegno l'elevazione massima
|
|
m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;
|
|
|
|
// Imposto dati comuni
|
|
SetPathId( nPxId) ;
|
|
SetToolDir( vtTool) ;
|
|
|
|
// Se una sola passata
|
|
if ( dOkStep < EPS_SMALL || dElev <= dOkStep) {
|
|
// eseguo lavorazione
|
|
if ( ! AddStandardMilling( pCompo, vtTool, vtExtr, dDepth, dElev, bSplitArcs))
|
|
return false ;
|
|
}
|
|
// se altrimenti passate a zig-zag
|
|
else if ( m_Params.m_nStepType == MILL_ST_ZIGZAG) {
|
|
if ( ! AddZigZagMilling( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs))
|
|
return false ;
|
|
}
|
|
// se altrimenti passate a one-way
|
|
else if ( m_Params.m_nStepType == MILL_ST_ONEWAY) {
|
|
if ( ! AddOneWayMilling( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs))
|
|
return false ;
|
|
}
|
|
// se altrimenti passate a spirale
|
|
else if ( m_Params.m_nStepType == MILL_ST_SPIRAL) {
|
|
if ( ! AddSpiralMilling( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs))
|
|
return false ;
|
|
}
|
|
|
|
// assegno al gruppo l'ingombro del percorso di lavoro
|
|
BBox3d b3Grp ;
|
|
m_pGeomDB->GetGlobalBBox( nPxId, b3Grp) ;
|
|
m_pGeomDB->SetInfo( nPxId, KEY_PMIN, b3Grp.GetMin()) ;
|
|
m_pGeomDB->SetInfo( nPxId, KEY_PMAX, b3Grp.GetMax()) ;
|
|
}
|
|
|
|
// incremento numero di fresate
|
|
++ m_nMills ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Milling::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad,
|
|
double& dElev)
|
|
{
|
|
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 > - 0.5)
|
|
return true ;
|
|
// se c'è tavola basculante, esco
|
|
bool bTabTilting = false ;
|
|
if ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTabTilting) && bTabTilting)
|
|
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 dDist = 0 ;
|
|
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, dCurrDist, vtCurrDir) ;
|
|
if ( dCurrDist > dDist) {
|
|
dDist = dCurrDist ;
|
|
vtDir = vtCurrDir ;
|
|
}
|
|
}
|
|
pCrvC->GetMidPoint( ptP) ;
|
|
GetMinDistanceFromRawSide( m_nPhase, ptP, dCurrDist, vtCurrDir) ;
|
|
if ( dCurrDist > dDist) {
|
|
dDist = dCurrDist ;
|
|
vtDir = vtCurrDir ;
|
|
}
|
|
pCrvC->GetEndPoint( ptP) ;
|
|
GetMinDistanceFromRawSide( m_nPhase, ptP, 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, const Vector3d& vtExtr,
|
|
double dDepth, double dElev, 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 ;
|
|
|
|
// ciclo sulle curve elementari
|
|
bool bClosed = pCompo->IsClosed() ;
|
|
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(), dStElev))
|
|
dStElev = dElev ;
|
|
// determino inizio attacco
|
|
Point3d ptP1 ;
|
|
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, false, pCompo, ptP1))
|
|
return false ;
|
|
// determino se l'inizio dell'attacco è fuori dal grezzo
|
|
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
|
|
// determino se l'inizio dell'attacco è sopra il grezzo
|
|
bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// aggiungo approccio per frese normali con spazio sopra attacco
|
|
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
|
|
// correggo elevazione iniziale con punto inizio attacco
|
|
dStElev -= ( ptP1 - ptStart) * vtExtr ;
|
|
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
|
|
if ( IsLeadInHelixOrZigzag()) {
|
|
ptP1 += vtExtr * ( 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 o diretto
|
|
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, vtExtr, false, pCompo, bSplitArcs)) {
|
|
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
|
|
return false ;
|
|
}
|
|
}
|
|
// 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 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(), dEndElev))
|
|
dEndElev = dElev ;
|
|
// aggiungo uscita
|
|
Point3d ptP1 ;
|
|
SetFeed( GetEndFeed()) ;
|
|
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, 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) {
|
|
// correggo elevazione finale con punto fine uscita
|
|
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
|
|
// determino se la fine dell'uscita è sopra il grezzo
|
|
bool bAboveEnd = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// 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, const Vector3d& vtExtr,
|
|
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 ;
|
|
|
|
// 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) ;
|
|
// 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(), dStElev))
|
|
dStElev = dElev ;
|
|
}
|
|
else
|
|
dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ;
|
|
// determino inizio attacco
|
|
Point3d ptP1 ;
|
|
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, bInvert, pCompo, ptP1))
|
|
return false ;
|
|
// determino se l'inizio dell'attacco è fuori dal grezzo
|
|
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
|
|
// determino se l'inizio dell'attacco è sopra il grezzo
|
|
bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// se primo step aggiungo approccio per frese normali
|
|
if ( j == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
|
|
// correggo elevazione iniziale con punto inizio attacco
|
|
dStElev -= ( ptP1 - ptStart) * vtExtr ;
|
|
// 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 ? GetStartFeed() : GetTipFeed()) ;
|
|
if ( AddLinearMove( ptP1) == GDB_ID_NULL)
|
|
return false ;
|
|
}
|
|
}
|
|
// aggiungo attacco
|
|
SetFeed( GetStartFeed()) ;
|
|
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, bInvert, pCompo, bSplitArcs)) {
|
|
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
|
|
return false ;
|
|
}
|
|
}
|
|
// 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) {
|
|
// 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(), dEndElev))
|
|
dEndElev = dElev ;
|
|
}
|
|
else
|
|
dEndElev = - LIO_ELEV_TOL ;
|
|
// aggiungo uscita
|
|
Point3d ptP1 ;
|
|
SetFeed( GetEndFeed()) ;
|
|
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, 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) {
|
|
// correggo elevazione finale con punto fine uscita
|
|
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
|
|
// determino se la fine dell'uscita è sopra il grezzo
|
|
bool bAboveEnd = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// 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, const Vector3d& vtExtr,
|
|
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 ;
|
|
|
|
// percorso speciale : chiuso e con attacco a spirale o zigzag
|
|
bool bSpecial = pCompo->IsClosed() && IsLeadInHelixOrZigzag() ;
|
|
|
|
// 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) {
|
|
// 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) ;
|
|
// punto inizio attacco
|
|
Point3d ptP1 ;
|
|
// se speciale e step intermedio
|
|
if ( bSpecial && j > 1) {
|
|
ptP1 = ptStart + dStep * vtExtr ;
|
|
}
|
|
// altrimenti
|
|
else {
|
|
// determino elevazione su inizio attacco
|
|
double dStElev ;
|
|
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
|
|
dStElev = dElev ;
|
|
// determino inizio attacco
|
|
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, false, pCompo, ptP1))
|
|
return false ;
|
|
// determino se l'inizio dell'attacco è fuori dal grezzo
|
|
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
|
|
// determino se l'inizio dell'attacco è sopra il grezzo
|
|
bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// aggiungo approccio per frese normali
|
|
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
|
|
// correggo elevazione iniziale con punto inizio attacco
|
|
dStElev -= ( ptP1 - ptStart) * vtExtr ;
|
|
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
|
|
if ( IsLeadInHelixOrZigzag()) {
|
|
ptP1 += vtExtr * ( dStElev - ( j - 1) * dStep) ;
|
|
dStElev = ( j - 1) * dStep ;
|
|
}
|
|
// 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, vtExtr, false, pCompo, bSplitArcs)) {
|
|
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
|
|
return false ;
|
|
}
|
|
}
|
|
// 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 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(), dEndElev))
|
|
dEndElev = dElev ;
|
|
// aggiungo uscita
|
|
Point3d ptP1 ;
|
|
SetFeed( GetEndFeed()) ;
|
|
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, 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) {
|
|
// correggo elevazione finale con punto fine uscita
|
|
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
|
|
// determino se la fine dell'uscita è sopra il grezzo
|
|
bool bAboveEnd = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// 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::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
|
|
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 ;
|
|
// 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 ;
|
|
|
|
// 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
|
|
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(), dStElev))
|
|
dStElev = 0 ;
|
|
dStElev -= dStart ;
|
|
// determino inizio attacco
|
|
Point3d ptP1 ;
|
|
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, false, pCompo, ptP1))
|
|
return false ;
|
|
// determino se l'inizio dell'attacco è fuori dal grezzo
|
|
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
|
|
// determino se l'inizio dell'attacco è sopra il grezzo
|
|
bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// aggiungo approccio per frese normali
|
|
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
|
|
// correggo elevazione iniziale con punto inizio attacco
|
|
dStElev -= ( ptP1 - ptStart) * vtExtr ;
|
|
// 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, vtExtr, false, pCompo, bSplitArcs)) {
|
|
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
|
|
return false ;
|
|
}
|
|
}
|
|
// elaborazioni sulla curva corrente
|
|
if ( pCrvC->GetType() == CRV_LINE) {
|
|
const ICurveLine* pLine = GetCurveLine( pCrvC) ;
|
|
Point3d ptP3 = pLine->GetEnd() ;
|
|
ptP3 -= vtEndDepth ;
|
|
SetFeed( GetFeed()) ;
|
|
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
|
|
return false ;
|
|
}
|
|
else if ( pCrvC->GetType() == CRV_ARC) {
|
|
const ICurveArc* pArc = GetCurveArc( pCrvC) ;
|
|
Point3d ptCen = pArc->GetCenter() ;
|
|
ptCen -= vtStaDepth ;
|
|
double dAngCen = pArc->GetAngCenter() ;
|
|
Vector3d vtN = pArc->GetNormVersor() ;
|
|
Point3d ptP3 ;
|
|
pArc->GetEndPoint( ptP3) ;
|
|
ptP3 -= vtEndDepth ;
|
|
SetFeed( GetFeed()) ;
|
|
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(), dEndElev))
|
|
dEndElev = dElev ;
|
|
// aggiungo uscita
|
|
Point3d ptP1 ;
|
|
SetFeed( GetEndFeed()) ;
|
|
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, 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) {
|
|
// correggo elevazione finale con punto fine uscita
|
|
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
|
|
// determino se la fine dell'uscita è sopra il grezzo
|
|
bool bAboveEnd = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// 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) {
|
|
// ciclo sulle curve elementari
|
|
double dCurrLen = 0 ;
|
|
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
|
|
// flag direzione (prima passata indice 0)
|
|
bool bInvert = ( ( j % 2) == 1) ;
|
|
// 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(), dStElev))
|
|
dStElev = dElev ;
|
|
dStElev -= dStart ;
|
|
// determino inizio attacco
|
|
Point3d ptP1 ;
|
|
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, bInvert, pCompo, ptP1))
|
|
return false ;
|
|
// aggiungo approccio per frese normali
|
|
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
|
|
// correggo elevazione iniziale con punto inizio attacco
|
|
dStElev -= ( ptP1 - ptStart) * vtExtr ;
|
|
// determino se l'inizio dell'attacco è fuori dal grezzo
|
|
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
|
|
// determino se l'inizio dell'attacco è sopra il grezzo
|
|
bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// 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, vtExtr, bInvert, pCompo, bSplitArcs)) {
|
|
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
|
|
return false ;
|
|
}
|
|
}
|
|
// elaborazioni sulla curva corrente
|
|
if ( pCurve->GetType() == CRV_LINE) {
|
|
ICurveLine* pLine = GetCurveLine( pCurve) ;
|
|
Point3d ptP3 = pLine->GetEnd() ;
|
|
ptP3 -= vtEndDepth ;
|
|
SetFeed( GetFeed()) ;
|
|
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
|
|
return false ;
|
|
}
|
|
else if ( pCurve->GetType() == CRV_ARC) {
|
|
ICurveArc* pArc = GetCurveArc( pCurve) ;
|
|
Point3d ptCen = pArc->GetCenter() ;
|
|
ptCen -= vtStaDepth ;
|
|
double dAngCen = pArc->GetAngCenter() ;
|
|
Vector3d vtN = pArc->GetNormVersor() ;
|
|
Point3d ptP3 ;
|
|
pArc->GetEndPoint( ptP3) ;
|
|
ptP3 -= vtEndDepth ;
|
|
SetFeed( GetFeed()) ;
|
|
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(), dEndElev))
|
|
dEndElev = dElev ;
|
|
// aggiungo uscita
|
|
Point3d ptP1 ;
|
|
SetFeed( GetEndFeed()) ;
|
|
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, 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) {
|
|
// correggo elevazione finale con punto fine uscita
|
|
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
|
|
// determino se la fine dell'uscita è sopra il grezzo
|
|
bool bAboveEnd = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ;
|
|
// 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::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, 90) ;
|
|
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 non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio
|
|
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
|
|
double dElevZ = vtTool.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 + vtTool * ( 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 + vtTool * ( dElev + dAppr) ;
|
|
Point3d ptP1a = ptP1b + vtTool * ( 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 ? 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 ? 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::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
|
|
double dElev, double dAppr, bool bAboveEnd)
|
|
{
|
|
// se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio
|
|
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
|
|
double dElevZ = vtTool.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 + vtTool * ( dElev + dAppr) ;
|
|
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
|
|
return false ;
|
|
}
|
|
else {
|
|
// 4a -> movimento di risalita appena sopra il punto finale
|
|
Point3d ptP4a = ptP + vtTool * ( 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 + vtTool * ( 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, 90) ;
|
|
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_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_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)
|
|
{
|
|
// 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())
|
|
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, ( bCcwRot ? 90 : - 90)) ;
|
|
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 - dTang, dU) ||
|
|
! pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) {
|
|
if ( ! pCompo->GetStartPoint( ptP1))
|
|
return false ;
|
|
}
|
|
}
|
|
else {
|
|
double dU ;
|
|
if ( ! pCompo->GetParamAtLength( 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())
|
|
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() ;
|
|
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 - dTang, dU)) {
|
|
double dParS, dParE ;
|
|
pCompo->GetDomain( dParS, dParE) ;
|
|
if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dU, dParE)))
|
|
return false ;
|
|
}
|
|
else {
|
|
if ( ! pCrv.Set( pCompo->Clone()))
|
|
return false ;
|
|
}
|
|
}
|
|
else {
|
|
double dU ;
|
|
if ( pCompo->GetParamAtLength( dTang, dU)) {
|
|
if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( 0, dU)))
|
|
return false ;
|
|
}
|
|
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, ( bAtLeft ? ANG_RIGHT : - ANG_RIGHT)) ;
|
|
// 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) {
|
|
switch ( GetLeadInType()) {
|
|
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 ;
|
|
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())
|
|
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, ( bCcwRot ? 90 : - 90)) ;
|
|
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, ( bCcwRot ? 90 : - 90)) ;
|
|
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ;
|
|
// inserisco uscita
|
|
PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ;
|
|
if ( IsNull( pCrv))
|
|
return false ;
|
|
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( dTang, dU)) {
|
|
if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( 0, dU)))
|
|
return false ;
|
|
}
|
|
else {
|
|
if ( ! pCrv.Set( pCompo->Clone()))
|
|
return false ;
|
|
}
|
|
}
|
|
else {
|
|
double dLen, dU ;
|
|
if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - dTang, dU)) {
|
|
double dParS, dParE ;
|
|
pCompo->GetDomain( dParS, dParE) ;
|
|
if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dU, dParE)))
|
|
return false ;
|
|
}
|
|
else {
|
|
if ( ! pCrv.Set( pCompo->Clone()))
|
|
return false ;
|
|
}
|
|
pCrv->Invert() ;
|
|
}
|
|
pCrv->SetExtrusion( vtN) ;
|
|
// la porto alla giusta quota
|
|
Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
|
|
Vector3d vtMove = 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 ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
double
|
|
Milling::GetRadiusForStartEndElevation( void)
|
|
{
|
|
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)
|
|
{
|
|
// determino se l'inizio dell'attacco è fuori dal grezzo
|
|
double dTemp ;
|
|
if ( ! GetElevation( m_nPhase, ptP, vtTool, 0.5 * m_TParams.m_dDiam, dTemp))
|
|
return false ;
|
|
return ( dTemp < 10 * EPS_SMALL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Milling::GetPointAboveRaw( const Point3d& ptP)
|
|
{
|
|
// determino la posizione del punto 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() && ptP.z < b3Raw.GetMax().z + 10 * EPS_SMALL)
|
|
return false ;
|
|
}
|
|
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
|
|
}
|
|
return true ;
|
|
}
|