Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
EgtMachKernel/WaterJetting.cpp
T
Dario Sassi dd45642748 EgtMachKernel : 
- modifica a Preview di WaterJetting per permettere magnetico di pezzi con questa lavorazione.
2026-04-01 10:20:44 +02:00

3193 lines
121 KiB
C++
Raw Permalink Blame History

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