Dario Sassi
4ab7788d6d
- aggiunta gestione OnSpecialApplyMachining appena prima del calcolo dei collegamenti tra lavorazioni.
1738 lines
61 KiB
C++
1738 lines
61 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2018-2020
|
|
//----------------------------------------------------------------------------
|
|
// File : Mortising.cpp Data : 18.02.20 Versione : 2.2b3
|
|
// Contenuto : Implementazione gestione mortasature.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 25.02.18 DS Creazione modulo.
|
|
// 18.02.20 DS Aggiunta gestione MaxElev da NoteUtente.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "MachMgr.h"
|
|
#include "DllMain.h"
|
|
#include "Mortising.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/EGkSfrCreate.h"
|
|
#include "/EgtDev/Include/EGkSurfTriMesh.h"
|
|
#include "/EgtDev/Include/EGkUserObjFactory.h"
|
|
#include "/EgtDev/Include/EGnStringKeyVal.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
|
|
using namespace std ;
|
|
|
|
//------------------------------ Errors --------------------------------------
|
|
// 2501 = "Error in Mortising : UpdateToolData failed"
|
|
// 2502 = "Error in Mortising : Offset not computable"
|
|
// 2503 = "Error in Mortising : Empty RawBox"
|
|
// 2504 = "Error in Mortising : Depth not computable"
|
|
// 2505 = "Error in Mortising : Entity GetElevation"
|
|
// 2506 = "Error in Mortising : Chaining failed"
|
|
// 2507 = "Error in Mortising : axes values not calculable"
|
|
// 2508 = "Error in Mortising : outstroke xx"
|
|
// 2509 = "Error in Mortising : link movements not calculable"
|
|
// 2510 = "Error in Mortising : link outstroke xx"
|
|
// 2511 = "Error in Mortising : post apply not calculable"
|
|
// 2512 = "Error in Mortising : Tool MaxMaterial too small (xx)"
|
|
// 2513 = "Error in Mortising : Closed path not allowed"
|
|
// 2514 = "Error in Mortising : special apply not calculable"
|
|
// 2551 = "Warning in Mortising : Skipped entity (xx)"
|
|
// 2552 = "Warning in Mortising : Plunges not found"
|
|
// 2553 = "Warning in Mortising : Tool name changed (xx)"
|
|
// 2554 = "Warning in Mortising : Tool data changed (xx)"
|
|
// 2555 = "Warning in Mortising : skipped Path too short"
|
|
// 2556 = "Warning in Mortising : machining step too small (xx)"
|
|
// 2557 = "Warning in Mortising : machining step (xxx) bigger than MaxMaterial (yyy)"
|
|
// 2558 = "Warning in Mortising : machining depth (xxx) bigger than MaxMaterial (yyy)"
|
|
|
|
//----------------------------------------------------------------------------
|
|
USEROBJ_REGISTER( GetOperationClass( OPER_MORTISING), Mortising) ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
const string&
|
|
Mortising::GetClassName( void) const
|
|
{
|
|
return USEROBJ_GETNAME( Mortising) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Mortising*
|
|
Mortising::Clone( void) const
|
|
{
|
|
// alloco oggetto
|
|
Mortising* pMort = new(nothrow) Mortising ;
|
|
// eseguo copia dei dati
|
|
if ( pMort != nullptr) {
|
|
try {
|
|
pMort->m_vId = m_vId ;
|
|
pMort->m_pMchMgr = m_pMchMgr ;
|
|
pMort->m_nPhase = m_nPhase ;
|
|
pMort->m_Params = m_Params ;
|
|
pMort->m_TParams = m_TParams ;
|
|
pMort->m_nStatus = m_nStatus ;
|
|
pMort->m_nMortises = m_nMortises ;
|
|
}
|
|
catch( ...) {
|
|
delete pMort ;
|
|
return nullptr ;
|
|
}
|
|
}
|
|
// ritorno l'oggetto
|
|
return pMort ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::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_nMortises) + szNewLine ;
|
|
sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::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_nMortises, vString[++k]))
|
|
return false ;
|
|
if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k]))
|
|
return false ;
|
|
}
|
|
catch( ...) {
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::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_nMortises))
|
|
return false ;
|
|
}
|
|
else if ( sKey == KEY_STAT) {
|
|
if ( ! FromString( sVal, m_nStatus))
|
|
return false ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//----------------------------------------------------------------------------
|
|
Mortising::Mortising( void)
|
|
{
|
|
m_Params.m_sName = "*" ;
|
|
m_Params.m_sToolName = "*" ;
|
|
m_TParams.m_sName = "*" ;
|
|
m_TParams.m_sHead = "*" ;
|
|
m_nStatus = MCH_ST_TO_VERIFY ;
|
|
m_nMortises = 0 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::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 MortisingData* pDdata = GetMortisingData( 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
|
|
Mortising::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_TOOLINVERT :
|
|
if ( bVal != m_Params.m_bToolInvert)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_bToolInvert = bVal ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::SetParam( int nType, int nVal)
|
|
{
|
|
switch ( nType) {
|
|
case MPA_WORKSIDE :
|
|
if ( ! m_Params.VerifyWorkSide( nVal))
|
|
return false ;
|
|
if ( nVal != m_Params.m_nWorkSide)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_nWorkSide = nVal ;
|
|
return true ;
|
|
case MPA_STEPTYPE :
|
|
if ( ! m_Params.VerifyStepType( nVal))
|
|
return false ;
|
|
if ( nVal != m_Params.m_nStepType)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_nStepType = nVal ;
|
|
return true ;
|
|
case MPA_SCC :
|
|
if ( ! m_Params.VerifySolCh( nVal))
|
|
return false ;
|
|
if ( nVal != m_Params.m_nSolCh)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_nSolCh = nVal ;
|
|
return true ;
|
|
case MPA_FACEUSE :
|
|
if ( ! m_Params.VerifyFaceUse( nVal))
|
|
return false ;
|
|
if ( nVal != m_Params.m_nFaceUse)
|
|
m_nStatus |= ( MCH_ST_PARAM_MODIF | MCH_ST_GEO_MODIF) ;
|
|
m_Params.m_nFaceUse = nVal ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::SetParam( int nType, double dVal)
|
|
{
|
|
switch ( nType) {
|
|
case MPA_SPEED :
|
|
if ( ! m_TParams.VerifySpeed( dVal))
|
|
return false ;
|
|
if ( abs( m_TParams.m_dSpeed - dVal) < EPS_MACH_ANG_PAR)
|
|
dVal = 0 ;
|
|
if ( abs( dVal - m_Params.m_dSpeed) > EPS_MACH_ANG_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dSpeed = dVal ;
|
|
return true ;
|
|
case MPA_FEED :
|
|
if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR)
|
|
dVal = 0 ;
|
|
if ( abs( dVal - m_Params.m_dFeed) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dFeed = dVal ;
|
|
return true ;
|
|
case MPA_STARTFEED :
|
|
if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
|
|
dVal = 0 ;
|
|
if ( abs( dVal - m_Params.m_dStartFeed) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dStartFeed = dVal ;
|
|
return true ;
|
|
case MPA_ENDFEED :
|
|
if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
|
|
dVal = 0 ;
|
|
if ( abs( dVal - m_Params.m_dEndFeed) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dEndFeed = dVal ;
|
|
return true ;
|
|
case MPA_TIPFEED :
|
|
if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
|
|
dVal = 0 ;
|
|
if ( abs( dVal - m_Params.m_dTipFeed) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dTipFeed = dVal ;
|
|
return true ;
|
|
case MPA_OFFSR :
|
|
if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR)
|
|
dVal = UNKNOWN_PAR ;
|
|
if ( abs( dVal - m_Params.m_dOffsR) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dOffsR = dVal ;
|
|
return true ;
|
|
case MPA_OFFSL :
|
|
if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
|
|
dVal = UNKNOWN_PAR ;
|
|
if ( abs( dVal - m_Params.m_dOffsL) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dOffsL = dVal ;
|
|
return true ;
|
|
case MPA_DEPTH: {
|
|
string sVal = ToString( dVal) ;
|
|
if ( sVal != m_Params.m_sDepth)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_sDepth = sVal ;
|
|
} return true ;
|
|
case MPA_STARTPOS :
|
|
if ( abs( dVal - m_Params.m_dStartPos) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dStartPos = dVal ;
|
|
return true ;
|
|
case MPA_STEP :
|
|
if ( abs( dVal - m_Params.m_dStep) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dStep = dVal ;
|
|
return true ;
|
|
case MPA_STARTADDLEN :
|
|
if ( abs( dVal - m_Params.m_dStartAddLen) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dStartAddLen = dVal ;
|
|
return true ;
|
|
case MPA_ENDADDLEN :
|
|
if ( abs( dVal - m_Params.m_dEndAddLen) > EPS_MACH_LEN_PAR)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_dEndAddLen = dVal ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::SetParam( int nType, const string& sVal)
|
|
{
|
|
switch ( nType) {
|
|
case MPA_TOOL : {
|
|
const ToolData* pTdata ;
|
|
if ( ! m_Params.VerifyTool( m_pMchMgr->GetCurrToolsMgr(), sVal, pTdata))
|
|
return false ;
|
|
if ( ! SameTool( m_TParams, *pTdata))
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_sToolName = sVal ;
|
|
m_Params.m_ToolUuid = pTdata->m_Uuid ;
|
|
m_TParams = *pTdata ;
|
|
} return true ;
|
|
case MPA_DEPTH_STR :
|
|
if ( sVal != m_Params.m_sDepth)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_sDepth = sVal ;
|
|
return true ;
|
|
case MPA_SYSNOTES :
|
|
if ( sVal != m_Params.m_sSysNotes)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_sSysNotes = sVal ;
|
|
return true ;
|
|
case MPA_USERNOTES :
|
|
if ( sVal != m_Params.m_sUserNotes)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_sUserNotes = sVal ;
|
|
return true ;
|
|
case MPA_INITANGS :
|
|
if ( sVal != m_Params.m_sInitAngs)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_sInitAngs = sVal ;
|
|
return true ;
|
|
case MPA_BLOCKEDAXIS :
|
|
if ( sVal != m_Params.m_sBlockedAxis)
|
|
m_nStatus |= MCH_ST_PARAM_MODIF ;
|
|
m_Params.m_sBlockedAxis = sVal ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::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 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 Mortising : Skipped entity " + ToString( Id) ;
|
|
m_pMchMgr->SetWarning( 2551, 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
|
|
Mortising::Preview( bool bRecalc)
|
|
{
|
|
// reset numero percorsi di lavoro generati
|
|
m_nMortises = 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( 2501, "Error in Mortising : UpdateToolData failed") ;
|
|
return false ;
|
|
}
|
|
|
|
// se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
|
|
if ( bChain && ! Chain( nAuxId)) {
|
|
m_pMchMgr->SetLastError( 2506, "Error in Mortising : Chaining failed") ;
|
|
return false ;
|
|
}
|
|
// recupero gruppo per geometria di Preview
|
|
int nPvId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_PV) ;
|
|
// se non c'è, lo aggiungo
|
|
if ( nPvId == GDB_ID_NULL) {
|
|
nPvId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
|
|
if ( nPvId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGeomDB->SetName( nPvId, MCH_PV) ;
|
|
}
|
|
// altrimenti lo svuoto
|
|
else
|
|
m_pGeomDB->EmptyGroup( nPvId) ;
|
|
|
|
// lavoro ogni singola catena
|
|
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
|
|
while ( nPathId != GDB_ID_NULL) {
|
|
if ( ! ProcessPath( nPathId, nPvId, GDB_ID_NULL))
|
|
return false ;
|
|
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::Apply( bool bRecalc, bool bPostApply)
|
|
{
|
|
// reset numero mortasature generate
|
|
int nCurrMortises = m_nMortises ;
|
|
m_nMortises = 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( 2501, "Error in Mortising : UpdateToolData failed") ;
|
|
return false ;
|
|
}
|
|
|
|
// 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_nMortises = nCurrMortises ;
|
|
string sLog = string( "Mortising apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
|
|
LOG_DBG_INFO( GetEMkLogger(), sLog.c_str()) ;
|
|
// eseguo aggiornamento assi macchina e collegamento con operazione precedente
|
|
if ( ! Update( bPostApply))
|
|
return false ;
|
|
m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
|
|
LOG_DBG_INFO( GetEMkLogger(), "Update done") ;
|
|
// esco con successo
|
|
return true ;
|
|
}
|
|
m_nStatus = MCH_ST_TO_VERIFY ;
|
|
|
|
// recupero gruppo per geometria ausiliaria
|
|
int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ;
|
|
bool bChain = false ;
|
|
// se non c'è, lo aggiungo
|
|
if ( nAuxId == GDB_ID_NULL) {
|
|
nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
|
|
if ( nAuxId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGeomDB->SetName( nAuxId, MCH_AUX) ;
|
|
m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ;
|
|
bChain = true ;
|
|
}
|
|
// altrimenti, se chiesto ricalcolo, lo svuoto
|
|
else if ( bRecalc) {
|
|
m_pGeomDB->EmptyGroup( nAuxId) ;
|
|
bChain = true ;
|
|
}
|
|
|
|
// recupero gruppo per vista ausiliaria
|
|
int nAuxViewId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUXVIEW) ;
|
|
// se non c'è, lo aggiungo
|
|
if ( nAuxViewId == GDB_ID_NULL) {
|
|
nAuxViewId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
|
|
if ( nAuxViewId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGeomDB->SetName( nAuxViewId, MCH_AUXVIEW) ;
|
|
m_pGeomDB->SetMaterial( nAuxViewId, Color( 64, 0, 0)) ;
|
|
m_pGeomDB->SetStatus( nAuxViewId, GDB_ST_OFF) ;
|
|
}
|
|
// altrimenti, se necessario chain, lo svuoto
|
|
else if ( bChain) {
|
|
m_pGeomDB->EmptyGroup( nAuxViewId) ;
|
|
}
|
|
|
|
// 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) ;
|
|
|
|
// se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
|
|
if ( bChain) {
|
|
if ( ! Chain( nAuxId)) {
|
|
m_pMchMgr->SetLastError( 2506, "Error in Mortising : Chaining failed") ;
|
|
return false ;
|
|
}
|
|
CalcSurfAuxView( nAuxId, nAuxViewId) ;
|
|
}
|
|
|
|
// lavoro ogni singola catena
|
|
bool bOk = true ;
|
|
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
|
|
while ( nPathId != GDB_ID_NULL) {
|
|
if ( ! ProcessPath( nPathId, GDB_ID_NULL, nClId))
|
|
bOk = false ;
|
|
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
|
|
}
|
|
if ( ! bOk)
|
|
return false ;
|
|
|
|
// assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
|
|
CalcAndSetBBox( nClId) ;
|
|
|
|
// 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(), "Mortising apply done") ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::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_nMortises == 0) {
|
|
m_pMchMgr->SetWarning( 2552, "Warning in Mortising : Plunges not found") ;
|
|
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, true)) {
|
|
string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
|
|
if ( sInfo.empty())
|
|
m_pMchMgr->SetLastError( 2507, "Error in Mortising : axes values not calculable") ;
|
|
else
|
|
m_pMchMgr->SetLastError( 2508, "Error in Mortising : 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( 2514, sSpecErr) ;
|
|
else
|
|
m_pMchMgr->SetLastError( 2514, "Error in Mortising : 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( 2509, "Error in Mortising : link movements not calculable") ;
|
|
else
|
|
m_pMchMgr->SetLastError( 2510, "Error in Mortising : link outstroke ") ;
|
|
return false ;
|
|
}
|
|
|
|
// esecuzione eventuali personalizzazioni finali
|
|
string sPostErr ;
|
|
if ( bPostApply && ! PostApply( sPostErr)) {
|
|
if ( ! IsEmptyOrSpaces( sPostErr))
|
|
m_pMchMgr->SetLastError( 2511, sPostErr) ;
|
|
else
|
|
m_pMchMgr->SetLastError( 2511, "Error in Mortising : post apply not calculable") ;
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::GetParam( int nType, bool& bVal) const
|
|
{
|
|
switch ( nType) {
|
|
case MPA_INVERT :
|
|
bVal = m_Params.m_bInvert ;
|
|
return true ;
|
|
case MPA_TOOLINVERT :
|
|
bVal = m_Params.m_bToolInvert ;
|
|
return true ;
|
|
}
|
|
bVal = false ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::GetParam( int nType, int& nVal) const
|
|
{
|
|
switch ( nType) {
|
|
case MPA_TYPE :
|
|
nVal = MT_MORTISING ;
|
|
return true ;
|
|
case MPA_WORKSIDE :
|
|
nVal = m_Params.m_nWorkSide ;
|
|
return true ;
|
|
case MPA_STEPTYPE :
|
|
nVal = m_Params.m_nStepType ;
|
|
return true ;
|
|
case MPA_SCC :
|
|
nVal = m_Params.m_nSolCh ;
|
|
return true ;
|
|
case MPA_FACEUSE :
|
|
nVal = m_Params.m_nFaceUse ;
|
|
return true ;
|
|
}
|
|
nVal = 0 ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::GetParam( int nType, double& dVal) const
|
|
{
|
|
switch ( nType) {
|
|
case MPA_SPEED :
|
|
dVal = GetSpeed() ;
|
|
return true ;
|
|
case MPA_FEED :
|
|
dVal = GetFeed() ;
|
|
return true ;
|
|
case MPA_STARTFEED :
|
|
dVal = GetStartFeed() ;
|
|
return true ;
|
|
case MPA_ENDFEED :
|
|
dVal = GetEndFeed() ;
|
|
return true ;
|
|
case MPA_TIPFEED :
|
|
dVal = GetTipFeed() ;
|
|
return true ;
|
|
case MPA_OFFSR :
|
|
dVal = GetOffsR() ;
|
|
return true ;
|
|
case MPA_OFFSL :
|
|
dVal = GetOffsL() ;
|
|
return true ;
|
|
case MPA_STARTPOS :
|
|
dVal = m_Params.m_dStartPos ;
|
|
return true ;
|
|
case MPA_STEP :
|
|
dVal = m_Params.m_dStep ;
|
|
return true ;
|
|
case MPA_STARTADDLEN :
|
|
dVal = m_Params.m_dStartAddLen ;
|
|
return true ;
|
|
case MPA_ENDADDLEN :
|
|
dVal = m_Params.m_dEndAddLen ;
|
|
return true ;
|
|
}
|
|
dVal = 0 ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::GetParam( int nType, string& sVal) const
|
|
{
|
|
switch ( nType) {
|
|
case MPA_NAME :
|
|
sVal = m_Params.m_sName ;
|
|
return true ;
|
|
case MPA_TOOL :
|
|
sVal = m_Params.m_sToolName ;
|
|
return true ;
|
|
case MPA_DEPTH_STR :
|
|
sVal = m_Params.m_sDepth ;
|
|
return true ;
|
|
case MPA_TUUID :
|
|
sVal = ToString( m_Params.m_ToolUuid) ;
|
|
return true ;
|
|
case MPA_UUID :
|
|
sVal = ToString( m_Params.m_Uuid) ;
|
|
return true ;
|
|
case MPA_SYSNOTES :
|
|
sVal = m_Params.m_sSysNotes ;
|
|
return true ;
|
|
case MPA_USERNOTES :
|
|
sVal = m_Params.m_sUserNotes ;
|
|
return true ;
|
|
case MPA_INITANGS :
|
|
sVal = m_Params.m_sInitAngs ;
|
|
return true ;
|
|
case MPA_BLOCKEDAXIS :
|
|
sVal = m_Params.m_sBlockedAxis ;
|
|
return true ;
|
|
}
|
|
sVal = "" ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const ToolData&
|
|
Mortising::GetToolData( void) const
|
|
{
|
|
return m_TParams ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::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 Mortising : tool name changed (" +
|
|
m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
|
|
m_pMchMgr->SetWarning( 2553, sInfo) ;
|
|
m_Params.m_sToolName = m_TParams.m_sName ;
|
|
}
|
|
if ( bChanged) {
|
|
string sInfo = "Warning in Mortising : tool data changed (" +
|
|
m_Params.m_sToolName + ")" ;
|
|
m_pMchMgr->SetWarning( 2554, sInfo) ;
|
|
}
|
|
// se modificato, aggiusto lo stato
|
|
if ( bChanged)
|
|
m_nStatus = MCH_ST_TO_VERIFY ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::GetGeometry( SELVECTOR& vIds) const
|
|
{
|
|
// restituisco l'elenco delle entità
|
|
vIds = m_vId ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::VerifyGeometry( SelData Id, int& nSubs, int& nType)
|
|
{
|
|
// ammessi : tutte curve o tutte facce di trimesh
|
|
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
|
|
if ( pGObj == nullptr)
|
|
return false ;
|
|
// se ammesse curve ed è tale
|
|
if ( nType != GEO_SURF && ( pGObj->GetType() & GEO_CURVE) != 0) {
|
|
const ICurve* pCurve = nullptr ;
|
|
// se direttamente la curva
|
|
if ( Id.nSub == SEL_SUB_ALL) {
|
|
pCurve = ::GetCurve( pGObj) ;
|
|
if ( pCurve != nullptr) {
|
|
if ( pCurve->GetType() == CRV_COMPO)
|
|
nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
|
|
else
|
|
nSubs = 0 ;
|
|
}
|
|
}
|
|
// altrimenti sottocurva di composita
|
|
else {
|
|
const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
|
|
if ( pCompo != nullptr)
|
|
pCurve = pCompo->GetCurve( Id.nSub) ;
|
|
nSubs = 0 ;
|
|
}
|
|
return ( pCurve != nullptr) ;
|
|
}
|
|
// se altrimenti ammesse superfici trimesh ed è tale
|
|
else if ( nType != GEO_CURVE && ( pGObj->GetType() & GEO_SURF) != 0) {
|
|
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
|
|
if ( pSurf == nullptr)
|
|
return false ;
|
|
// se direttamente la superficie
|
|
if ( Id.nSub == SEL_SUB_ALL) {
|
|
nSubs = pSurf->GetFacetCount() ;
|
|
return true ;
|
|
}
|
|
// altrimenti faccia di superficie trimesh
|
|
else {
|
|
// se faccia non esistente
|
|
if ( Id.nSub > pSurf->GetFacetCount())
|
|
return false ;
|
|
// tutto bene
|
|
nSubs = 0 ;
|
|
return true ;
|
|
}
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
ICurve*
|
|
Mortising::GetCurve( SelData Id)
|
|
{
|
|
// ammessi : curve o facce di polymesh
|
|
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
|
|
if ( pGObj == nullptr)
|
|
return nullptr ;
|
|
// ne recupero il riferimento globale
|
|
Frame3d frGlob ;
|
|
if ( ! m_pGeomDB->GetGlobFrame( Id.nId, frGlob))
|
|
return nullptr ;
|
|
// se curva
|
|
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
|
|
PtrOwner<ICurve> pCurve ;
|
|
// se direttamente curva
|
|
if ( Id.nSub == SEL_SUB_ALL) {
|
|
// recupero e duplico la curva
|
|
const ICurve* pOriCurve = ::GetCurve( pGObj) ;
|
|
if ( pOriCurve != nullptr)
|
|
pCurve.Set( pOriCurve->Clone()) ;
|
|
// se estrusione mancante, imposto default
|
|
Vector3d vtExtr ;
|
|
if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall())
|
|
pCurve->SetExtrusion( Z_AX) ;
|
|
}
|
|
// altrimenti sottocurva di composita
|
|
else {
|
|
// recupero la composita
|
|
const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
|
|
if ( pCompo != nullptr) {
|
|
// duplico la curva semplice
|
|
const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ;
|
|
if ( pOriCurve != nullptr) {
|
|
pCurve.Set( pOriCurve->Clone()) ;
|
|
// recupero estrusione e spessore
|
|
Vector3d vtExtr ;
|
|
if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall())
|
|
vtExtr = Z_AX ;
|
|
pCurve->SetExtrusion( vtExtr) ;
|
|
double dThick ;
|
|
if ( pCompo->GetThickness( dThick))
|
|
pCurve->SetThickness( dThick) ;
|
|
}
|
|
}
|
|
}
|
|
if ( IsNull( pCurve))
|
|
return nullptr ;
|
|
// la porto in globale
|
|
pCurve->ToGlob( frGlob) ;
|
|
// la restituisco
|
|
return Release( pCurve) ;
|
|
}
|
|
// se altrimenti superficie
|
|
else if ( ( pGObj->GetType() & GEO_SURF) != 0) {
|
|
// recupero la trimesh
|
|
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
|
|
if ( pSurf == nullptr)
|
|
return nullptr ;
|
|
// recupero l'indice della faccia
|
|
int nFacet = ( ( Id.nSub == SEL_SUB_ALL) ? 0 : Id.nSub) ;
|
|
// recupero i contorni della faccia
|
|
POLYLINEVECTOR vPL ;
|
|
pSurf->GetFacetLoops( nFacet, vPL) ;
|
|
if ( vPL.empty())
|
|
return nullptr ;
|
|
// recupero la normale esterna della faccia
|
|
Vector3d vtN ;
|
|
if ( ! pSurf->GetFacetNormal( nFacet, vtN))
|
|
return nullptr ;
|
|
// creo la curva a partire da quello esterno
|
|
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
|
|
pCrvCompo->FromPolyLine( vPL[0]) ;
|
|
if ( ! pCrvCompo->IsValid())
|
|
return nullptr ;
|
|
// assegno l'estrusione dalla normale alla faccia
|
|
pCrvCompo->SetExtrusion( vtN) ;
|
|
// unisco le eventuali parti allineate
|
|
pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
|
|
// la porto in globale
|
|
pCrvCompo->ToGlob( frGlob) ;
|
|
// sistemazioni varie
|
|
int nToolDir ;
|
|
if ( ( m_Params.m_nFaceUse & 64) != 0)
|
|
nToolDir = TOOL_ORTUP ;
|
|
else if ( ( m_Params.m_nFaceUse & 32) != 0)
|
|
nToolDir = TOOL_ORTHO ;
|
|
else
|
|
nToolDir = TOOL_PAR_SLANT ;
|
|
int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
|
|
AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, V_NULL, {}, m_TParams.m_dThick, 2) ;
|
|
// la restituisco
|
|
return Release( pCrvCompo) ;
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return nullptr ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::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 curva
|
|
vpCrvs.emplace_back( GetCurve( Id)) ;
|
|
// ne verifico la validità
|
|
if ( IsNull( vpCrvs.back())) {
|
|
string sInfo = "Warning in Mortising : Skipped entity " + ToString( Id) ;
|
|
m_pMchMgr->SetWarning( 2551, sInfo) ;
|
|
vpCrvs.back().Reset() ;
|
|
}
|
|
}
|
|
// preparo i dati per il concatenamento
|
|
bool bFirst = true ;
|
|
Point3d ptNear = ORIG ;
|
|
double dToler = 10 * EPS_SMALL ;
|
|
ChainCurves chainC ;
|
|
chainC.Init( true, dToler, int( vpCrvs.size())) ;
|
|
for ( size_t i = 0 ; i < vpCrvs.size() ; ++ i) {
|
|
// recupero la curva e il suo riferimento
|
|
ICurve* pCrv = vpCrvs[i] ;
|
|
if ( pCrv == nullptr)
|
|
continue ;
|
|
// recupero i dati della curva necessari al concatenamento e li assegno
|
|
Point3d ptStart, ptEnd ;
|
|
Vector3d vtStart, vtEnd ;
|
|
if ( ! pCrv->GetStartPoint( ptStart) || ! pCrv->GetStartDir( vtStart) ||
|
|
! pCrv->GetEndPoint( ptEnd) || ! pCrv->GetEndDir( vtEnd))
|
|
return false ;
|
|
if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd))
|
|
return false ;
|
|
// se prima curva, assegno inizio della ricerca
|
|
if ( bFirst) {
|
|
ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
|
|
bFirst = false ;
|
|
}
|
|
}
|
|
// recupero i percorsi concatenati
|
|
int nCount = 0 ;
|
|
INTVECTOR vnId2 ;
|
|
while ( chainC.GetChainFromNear( ptNear, false, vnId2)) {
|
|
// creo una curva composita
|
|
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
|
|
if ( IsNull( pCrvCompo))
|
|
return false ;
|
|
// estrusione e spessore
|
|
Vector3d vtExtr = Z_AX ;
|
|
double dThick = 0 ;
|
|
// vettore Id originali
|
|
SELVECTOR vId2 ;
|
|
vId2.reserve( vnId2.size()) ;
|
|
// recupero le curve semplici e le inserisco nella curva composita
|
|
for ( size_t i = 0 ; i < vnId2.size() ; ++ i) {
|
|
int nId = abs( vnId2[i]) - 1 ;
|
|
bool bInvert = ( vnId2[i] < 0) ;
|
|
vId2.emplace_back( m_vId[nId]) ;
|
|
// recupero la curva
|
|
ICurve* pCrv = vpCrvs[nId] ;
|
|
// se necessario, la inverto
|
|
if ( bInvert)
|
|
pCrv->Invert() ;
|
|
// recupero eventuali estrusione e spessore
|
|
Vector3d vtTemp ;
|
|
if ( pCrv->GetExtrusion( vtTemp)) {
|
|
vtExtr = vtTemp ;
|
|
double dTemp ;
|
|
if ( pCrv->GetThickness( dTemp) && 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) ;
|
|
// creo nuovo gruppo
|
|
int nPathId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpDestId, Frame3d()) ;
|
|
if ( nPathId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGeomDB->SetName( nPathId, MCH_PATH + ToString( ++ nCount)) ;
|
|
m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( vId2)) ;
|
|
// inserisco la curva composita nel gruppo destinazione
|
|
int nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::Release( pCrvCompo)) ;
|
|
if ( nNewId == GDB_ID_NULL)
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::CalcSurfAuxView( int nAuxId, int nAuxViewId)
|
|
{
|
|
const double FAT_RAD = 0.5 ;
|
|
if ( m_Params.m_nFaceUse != MILL_FU_NONE) {
|
|
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
|
|
while ( nPathId != GDB_ID_NULL) {
|
|
int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
|
|
const ICurve* pCrv = ::GetCurve( m_pGeomDB->GetGeoObj( nCrvId)) ;
|
|
if ( pCrv != nullptr) {
|
|
ISurfFlatRegion* pSfr = GetSurfFlatRegionFromFatCurve( pCrv->Clone(), FAT_RAD, false, false) ;
|
|
if ( pSfr != nullptr) {
|
|
int nSfrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nAuxViewId, pSfr) ;
|
|
}
|
|
}
|
|
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::ProcessPath( int nPathId, int nPvId, int nClId)
|
|
{
|
|
// recupero gruppo per geometria temporanea
|
|
const string GRP_TEMP = "Temp" ;
|
|
int nTempId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, GRP_TEMP) ;
|
|
// se non c'è, lo aggiungo
|
|
if ( nTempId == GDB_ID_NULL) {
|
|
nTempId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
|
|
if ( nTempId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGeomDB->SetName( nTempId, GRP_TEMP) ;
|
|
}
|
|
// altrimenti lo svuoto
|
|
else
|
|
m_pGeomDB->EmptyGroup( nTempId) ;
|
|
// in ogni caso lo dichiaro temporaneo e non visibile
|
|
m_pGeomDB->SetLevel( nTempId, GDB_LV_TEMP) ;
|
|
m_pGeomDB->SetStatus( nTempId, GDB_ST_OFF) ;
|
|
|
|
// copio la curva composita da elaborare
|
|
int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
|
|
if ( m_pGeomDB->GetGeoType( nCrvId) != CRV_COMPO)
|
|
return false ;
|
|
int nCopyId = m_pGeomDB->CopyGlob( nCrvId, GDB_ID_NULL, nTempId) ;
|
|
if ( nCopyId == GDB_ID_NULL)
|
|
return false ;
|
|
ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( nCopyId)) ;
|
|
|
|
// eventuale inversione percorso
|
|
if ( m_Params.m_bInvert)
|
|
pCompo->Invert() ;
|
|
|
|
// recupero estrusione e spessore
|
|
Vector3d vtExtr = Z_AX ;
|
|
pCompo->GetExtrusion( vtExtr) ;
|
|
double dThick ;
|
|
pCompo->GetThickness( dThick) ;
|
|
// se molto vicina alla direzione Z+ la approssimo con questa (per compensare piccoli errori e limiti macchine)
|
|
const double MAX_APPROX_DIR = cos( 0.2 * DEGTORAD) ;
|
|
if ( vtExtr * Z_AX > MAX_APPROX_DIR)
|
|
vtExtr = Z_AX ;
|
|
|
|
// eventuale inversione direzione utensile
|
|
if ( m_Params.m_bToolInvert) {
|
|
vtExtr.Invert() ;
|
|
pCompo->SetExtrusion( vtExtr) ;
|
|
dThick = - dThick ;
|
|
pCompo->SetThickness( dThick) ;
|
|
}
|
|
|
|
// verifico non sia un percorso chiuso
|
|
if ( pCompo->IsClosed()) {
|
|
m_pMchMgr->SetLastError( 2513, "Error in Mortising : Closed path not allowed") ;
|
|
return false ;
|
|
}
|
|
|
|
// eventuali allungamenti/accorciamenti
|
|
{
|
|
// inclinazione della direzione utensile rispetto al movimento
|
|
Vector3d vtTg ; pCompo->GetMidDir( vtTg) ;
|
|
double dSinAng = max( ( vtTg ^ vtExtr).Len(), sin( 30 * DEGTORAD)) ;
|
|
double dStartAddLen = m_Params.m_dStartAddLen / dSinAng ;
|
|
double dEndAddLen = m_Params.m_dEndAddLen / dSinAng ;
|
|
// verifico che il percorso sia abbastanza lungo
|
|
double dLen ; pCompo->GetLength( dLen) ;
|
|
if ( dLen + dStartAddLen + dEndAddLen < 10 * EPS_SMALL) {
|
|
m_pMchMgr->SetWarning( 2555, "Warning in Mortising : 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 ( dStartAddLen > EPS_SMALL) {
|
|
if ( ! pCompo->ExtendStartByLen( dStartAddLen))
|
|
return false ;
|
|
dLen += dStartAddLen ;
|
|
}
|
|
if (dEndAddLen > EPS_SMALL) {
|
|
if ( ! pCompo->ExtendEndByLen( dEndAddLen))
|
|
return false ;
|
|
dLen += dEndAddLen ;
|
|
}
|
|
// eventuale accorciamenti (da fare dopo tutti gli allungamenti)
|
|
if ( dStartAddLen < - EPS_SMALL) {
|
|
if ( ! pCompo->TrimStartAtLen( -dStartAddLen))
|
|
return false ;
|
|
dLen += dStartAddLen ;
|
|
}
|
|
if ( dEndAddLen < - EPS_SMALL) {
|
|
if ( ! pCompo->TrimEndAtLen( dLen + dEndAddLen))
|
|
return false ;
|
|
dLen += dEndAddLen ;
|
|
}
|
|
}
|
|
|
|
// unisco le parti allineate
|
|
if ( ! pCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL))
|
|
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) ;
|
|
|
|
// determino il versore ausiliario
|
|
Vector3d vtAux = ( ptEnd - ptStart) ^ vtExtr ;
|
|
vtAux.Normalize() ;
|
|
if ( vtAux.z < -EPS_ZERO)
|
|
vtAux.Invert() ;
|
|
|
|
// sistemo per lato di lavoro e offset radiale
|
|
Vector3d vtSide = ( ptEnd - ptStart) ^ vtExtr ;
|
|
vtSide.Normalize() ;
|
|
if ( m_Params.m_nWorkSide == MORTISE_WS_LEFT)
|
|
vtSide.Invert() ;
|
|
if ( AreOppositeVectorApprox( vtAux, vtSide))
|
|
pCompo->Translate( vtSide * m_TParams.m_dThick) ;
|
|
if ( abs( GetOffsR()) > EPS_SMALL)
|
|
pCompo->Translate( vtSide * GetOffsR()) ;
|
|
|
|
// 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( 2503, "Error in Mortising : Empty RawBox") ;
|
|
return false ;
|
|
}
|
|
|
|
// recupero distanza da fondo dei grezzi interessati dal percorso
|
|
double dRbDist = 0 ;
|
|
if ( AreSameVectorApprox( vtExtr, Z_AX)) {
|
|
if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, m_TParams.m_dTDiam, dRbDist))
|
|
return false ;
|
|
}
|
|
|
|
// valuto l'espressione dell'affondamento
|
|
ExeLuaSetGlobNumVar( "TH", abs( dThick)) ;
|
|
ExeLuaSetGlobNumVar( "RB", dRbDist) ;
|
|
double dDepth ;
|
|
string sMyDepth = m_Params.m_sDepth ;
|
|
if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) {
|
|
m_pMchMgr->SetLastError( 2504, "Error in Mortising : Depth not computable") ;
|
|
return false ;
|
|
}
|
|
// se spessore positivo, lo sottraggo dal risultato
|
|
if ( dThick > 0)
|
|
dDepth -= dThick ;
|
|
// sottraggo eventuale offset longitudinale
|
|
dDepth -= GetOffsL() ;
|
|
|
|
// recupero nome del path
|
|
string sPathName ;
|
|
m_pGeomDB->GetName( nPathId, sPathName) ;
|
|
|
|
// assegno il versore fresa
|
|
Vector3d vtTool = vtExtr ;
|
|
|
|
// calcolo l'elevazione massima
|
|
double dElev ;
|
|
if ( CalcPathElevation( pCompo, vtTool, dDepth, GetRadiusForStartEndElevation(), m_TParams.m_dThick, dElev)) {
|
|
if ( dElev < EPS_SMALL && AreSameVectorApprox( vtExtr, Z_AX)) {
|
|
BBox3d b3Crv ;
|
|
pCompo->GetLocalBBox( b3Crv) ;
|
|
dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z + min( 0., dThick) + dDepth) ;
|
|
}
|
|
}
|
|
else
|
|
return false ;
|
|
// eventuale imposizione massima elevazione da note utente
|
|
double dMaxElev ;
|
|
if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev) && dElev > dMaxElev)
|
|
dElev = dMaxElev ;
|
|
|
|
// ingombro aggiuntivo da larghezza sega a catena quando inclinata rispetto al movimento
|
|
Vector3d vtTg ; pCompo->GetMidDir( vtTg) ;
|
|
double dSinAng = max( ( vtTg ^ vtExtr).Len(), sin( 30 * DEGTORAD)) ;
|
|
double dCosAng = min( abs( vtTg * vtExtr), cos( 30 * DEGTORAD)) ;
|
|
double dAddEnc = m_TParams.m_dDiam / 2 * dCosAng / dSinAng ;
|
|
|
|
// affondamento speciale da note utente (!!! da trasformare in parametro come gli altri !!!)
|
|
int nPlunge = 0 ;
|
|
GetValInNotes( m_Params.m_sUserNotes, UN_PLUNGE, nPlunge) ;
|
|
|
|
// verifico che lo step dell'utensile sia sensato
|
|
double dOkStep = ( nPlunge == MORTISE_PLUNGE_STEP || nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ ? m_Params.m_dStep : 0) ;
|
|
const double MIN_ZSTEP = 1.0 ;
|
|
if ( dOkStep >= EPS_SMALL && dOkStep < MIN_ZSTEP) {
|
|
dOkStep = MIN_ZSTEP ;
|
|
string sInfo = "Warning in Mortising : machining step too small (" +
|
|
ToString( m_Params.m_dStep, 2) + ")" ;
|
|
m_pMchMgr->SetWarning( 2556, sInfo) ;
|
|
}
|
|
|
|
// verifico che il massimo materiale dell'utensile sia sensato
|
|
const double MIN_MAXMAT = 1.0 ;
|
|
if ( m_TParams.m_dMaxMat < dElev && m_TParams.m_dMaxMat < MIN_MAXMAT) {
|
|
string sInfo = "Error in Mortising : Tool MaxMaterial too small (" +
|
|
ToString( m_TParams.m_dMaxMat, 2) + ")" ;
|
|
m_pMchMgr->SetLastError( 2512, sInfo) ;
|
|
return false ;
|
|
}
|
|
|
|
// se lo step supera la capacità dell'utensile
|
|
if ( dOkStep > m_TParams.m_dMaxMat + EPS_SMALL) {
|
|
dOkStep = m_TParams.m_dMaxMat ;
|
|
string sInfo = "Warning in Mortising : machining step (" + ToString( m_Params.m_dStep, 1) +
|
|
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
|
|
m_pMchMgr->SetWarning( 2557, sInfo) ;
|
|
}
|
|
// massimo affondamento dell'utensile
|
|
double dMaxDepth = m_TParams.m_dMaxMat - dAddEnc ;
|
|
// se l'elevazione supera il massimo affondamento dell'utensile
|
|
if ( dElev > dMaxDepth + EPS_SMALL) {
|
|
// segnalo, riduco e continuo
|
|
string sInfo = "Warning in Mortising : machining depth (" + ToString( dElev, 1) +
|
|
") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
|
|
m_pMchMgr->SetWarning( 2558, sInfo) ;
|
|
dDepth -= dElev - dMaxDepth ;
|
|
dElev = dMaxDepth ;
|
|
}
|
|
|
|
// se richiesta anteprima
|
|
if ( nPvId != GDB_ID_NULL) {
|
|
// creo gruppo per geometria di anteprima del percorso
|
|
int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nPvId, Frame3d()) ;
|
|
if ( nPxId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGeomDB->SetName( nPxId, sPathName) ;
|
|
m_pGeomDB->SetMaterial( nPxId, GREEN) ;
|
|
// creo l'anteprima del percorso
|
|
if ( ! GenerateMortisingPv( nPxId, pCompo))
|
|
return false ;
|
|
}
|
|
|
|
// se richiesta lavorazione
|
|
if ( nClId != GDB_ID_NULL) {
|
|
// creo gruppo per geometria di lavorazione del percorso
|
|
int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ;
|
|
if ( nPxId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGeomDB->SetName( nPxId, sPathName) ;
|
|
m_pGeomDB->SetMaterial( nPxId, BLUE) ;
|
|
|
|
// assegno il vettore estrazione al gruppo del percorso
|
|
m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ;
|
|
// assegno i punti di inizio e fine al gruppo del percorso
|
|
m_pGeomDB->SetInfo( nPxId, KEY_START, ptStart) ;
|
|
m_pGeomDB->SetInfo( nPxId, KEY_END, ptEnd) ;
|
|
// assegno l'elevazione massima
|
|
m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;
|
|
|
|
// Imposto dati comuni
|
|
SetPathId( nPxId) ;
|
|
SetToolDir( vtTool) ;
|
|
SetAuxDir( vtAux) ;
|
|
|
|
// Calcolo la mortasatura
|
|
if ( ! GenerateMortisingCl( pCompo, vtTool, dDepth, dElev, dOkStep, nPlunge))
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double dThick,
|
|
double& dElev) const
|
|
{
|
|
dElev = 0 ;
|
|
int nMaxInd = pCompo->GetCurveCount() - 1 ;
|
|
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
|
|
// curva corrente
|
|
const ICurve* pCrvC = pCompo->GetCurve( i) ;
|
|
// calcolo elevazione
|
|
double dCurrElev ;
|
|
Point3d ptStart, ptMid, ptEnd ;
|
|
pCrvC->GetStartPoint( ptStart) ;
|
|
pCrvC->GetMidPoint( ptMid) ;
|
|
pCrvC->GetEndPoint( ptEnd) ;
|
|
Vector3d vtStartPerp, vtEndPerp ;
|
|
pCrvC->GetStartDir( vtStartPerp) ;
|
|
vtStartPerp *= -dRad ;
|
|
pCrvC->GetEndDir( vtEndPerp) ;
|
|
vtEndPerp *= dRad ;
|
|
Vector3d vtTg ; pCrvC->GetMidDir( vtTg) ;
|
|
Vector3d vtOrtho = vtTool ^ vtTg ;
|
|
vtOrtho.Normalize() ;
|
|
vtOrtho *= dThick ;
|
|
Vector3d vtDepth = -vtTool * dDepth ;
|
|
// linea centro utensile
|
|
if ( GetElevation( m_nPhase, ptStart + vtDepth, ptMid + vtDepth, ptEnd + vtDepth, vtTool, dCurrElev)) {
|
|
if ( dCurrElev > dElev)
|
|
dElev = dCurrElev ;
|
|
}
|
|
else {
|
|
m_pMchMgr->SetLastError( 2505, "Error in Mortising : Entity GetElevation") ;
|
|
return false ;
|
|
}
|
|
// sopra centro utensile
|
|
if ( GetElevation( m_nPhase, ptStart + vtDepth + vtOrtho, ptMid + vtDepth + vtOrtho, ptEnd + vtDepth + vtOrtho, vtTool, dCurrElev)) {
|
|
if ( dCurrElev > dElev)
|
|
dElev = dCurrElev ;
|
|
}
|
|
else {
|
|
m_pMchMgr->SetLastError( 2505, "Error in Mortising : Entity GetElevation") ;
|
|
return false ;
|
|
}
|
|
// da una parte
|
|
if ( GetElevation( m_nPhase, ptStart + vtStartPerp + vtDepth, ptMid + vtDepth,
|
|
ptEnd + vtEndPerp + vtDepth, vtTool, dCurrElev)) {
|
|
if ( dCurrElev > dElev)
|
|
dElev = dCurrElev ;
|
|
}
|
|
else {
|
|
m_pMchMgr->SetLastError( 2505, "Error in Mortising : Entity GetElevation") ;
|
|
return false ;
|
|
}
|
|
// dall'altra parte
|
|
if ( GetElevation( m_nPhase, ptStart + vtStartPerp + vtDepth, ptMid + vtDepth,
|
|
ptEnd + vtEndPerp + vtDepth, vtTool, dCurrElev)) {
|
|
if ( dCurrElev > dElev)
|
|
dElev = dCurrElev ;
|
|
}
|
|
else {
|
|
m_pMchMgr->SetLastError( 2505, "Error in Mortising : Entity GetElevation") ;
|
|
return false ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::GenerateMortisingPv( int nPathId, const ICurveComposite* pCompo)
|
|
{
|
|
// incremento numero di mortasature
|
|
++ m_nMortises ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::GenerateMortisingCl( const ICurveComposite* pCompo, const Vector3d& vtTool,
|
|
double dDepth, double dElev, double dOkStep, int nPlunge)
|
|
{
|
|
// inizio e fine
|
|
Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
|
|
Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ;
|
|
|
|
// verifico se affondamento ripetuto è veramente tale
|
|
if ( ( nPlunge == MORTISE_PLUNGE_START_END || nPlunge == MORTISE_PLUNGE_START_TO_END) && Dist( ptStart, ptEnd) < 10 * EPS_SMALL)
|
|
nPlunge = MORTISE_PLUNGE_START ;
|
|
|
|
// se affondamento inizio e fine
|
|
if ( nPlunge == MORTISE_PLUNGE_START_END) {
|
|
// affondamento iniziale
|
|
if ( ! GenerateOnePlungeCl( ptStart, ptEnd, vtTool, dDepth, dElev, dOkStep, MORTISE_PLUNGE_START, true))
|
|
return false ;
|
|
// affondamento finale
|
|
if ( ! GenerateOnePlungeCl( ptStart, ptEnd, vtTool, dDepth, dElev, dOkStep, MORTISE_PLUNGE_END, false))
|
|
return false ;
|
|
}
|
|
|
|
// se alrimenti affondamenti ripetuti da inizio a fine con ritorno basso
|
|
else if ( nPlunge == MORTISE_PLUNGE_START_TO_END) {
|
|
// distanza e vettore spostamento laterale
|
|
Vector3d vtDir = ptEnd - ptStart ;
|
|
double dLen = vtDir.Len() ;
|
|
vtDir.Normalize() ;
|
|
// affondamenti iniziale e intermedi
|
|
int kMax = ( int) floor( dLen / m_TParams.m_dDiam) ;
|
|
for ( int k = 0 ; k <= kMax ; ++ k) {
|
|
Point3d ptNewStart = ptStart + vtDir * k * m_TParams.m_dDiam ;
|
|
// se non è finale
|
|
if ( k != kMax || ! AreSamePointEpsilon( ptNewStart, ptEnd, 10 * EPS_SMALL)) {
|
|
if ( ! GenerateOnePlungeCl( ptNewStart, ptEnd, vtTool, dDepth, dElev, dOkStep, MORTISE_PLUNGE_START, k == 0))
|
|
return false ;
|
|
}
|
|
}
|
|
// affondamento finale
|
|
if ( ! GenerateOnePlungeCl( ptEnd, ptStart, vtTool, dDepth, dElev, dOkStep, MORTISE_PLUNGE_STEP, false))
|
|
return false ;
|
|
}
|
|
|
|
// altrimenti affondamento singolo
|
|
else {
|
|
if ( ! GenerateOnePlungeCl( ptStart, ptEnd, vtTool, dDepth, dElev, dOkStep, nPlunge, true))
|
|
return false ;
|
|
}
|
|
|
|
// reset dati di movimento
|
|
ResetMoveData() ;
|
|
// incremento numero di mortasature
|
|
++ m_nMortises ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, double dDepth, double dElev,
|
|
double dOkStep, int nPlunge, bool bFirst)
|
|
{
|
|
// compensazione elevazione/affondamento
|
|
double dDelta = dElev - dDepth ;
|
|
// pre-calcolo step per modalità con step
|
|
int nStep = 1 ;
|
|
double dStep = dElev ;
|
|
if ( nPlunge == MORTISE_PLUNGE_STEP || nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ) {
|
|
if ( dOkStep < EPS_SMALL)
|
|
dOkStep = dElev ;
|
|
nStep = max( 1, static_cast<int>( ceil( ( dElev - 10 * EPS_SMALL) / dOkStep))) ;
|
|
dStep = dElev / nStep ;
|
|
}
|
|
|
|
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
|
|
double dSafeZ = GetSafeZ() + GetDeltaSafeZ( vtTool) ;
|
|
double dStartElev = 0 ;
|
|
Point3d ptLi = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * dDelta ;
|
|
bool bUnderStart = GetAhPointUnderRaw( ptLi, vtTool, 0,
|
|
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStartElev) ;
|
|
// altrimenti ridetermino elevazione su inizio percorso di lavoro
|
|
if ( ! bUnderStart)
|
|
GetElevation( m_nPhase, ptLi, vtTool, GetRadiusForStartEndElevation(), vtTool, dStartElev) ;
|
|
|
|
// sicurezza su punto iniziale
|
|
double dAppr = dStartElev + dSafeZ ;
|
|
if ( nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ) {
|
|
double dStartDownElev ;
|
|
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStartDownElev))
|
|
dStartDownElev = dDelta ;
|
|
if ( dStartDownElev < EPS_SMALL)
|
|
dAppr = -dStep ;
|
|
}
|
|
|
|
// 1 -> punto approccio
|
|
int nFirstFlag = ( bFirst ? 1 : 0) ;
|
|
SetFlag( nFirstFlag) ;
|
|
Point3d ptP1 = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * ( dDelta + dAppr) ;
|
|
if ( AddRapidStartOrMove( ptP1, bFirst) == GDB_ID_NULL)
|
|
return false ;
|
|
SetFlag( 0) ;
|
|
|
|
// 2 -> punto fuori (se diverso dal precedente)
|
|
if ( m_Params.m_dStartPos < dAppr - 10 * EPS_SMALL) {
|
|
Point3d ptP2 = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * ( dDelta + m_Params.m_dStartPos) ;
|
|
if ( AddRapidMove( ptP2) == GDB_ID_NULL)
|
|
return false ;
|
|
}
|
|
|
|
// eseguo ciclo a seconda del tipo di affondamento
|
|
Point3d ptLast ;
|
|
if ( nPlunge == MORTISE_PLUNGE_START) {
|
|
// 3 -> punto in affondamento
|
|
SetFeed( GetStartFeed()) ;
|
|
SetFlag( 0) ;
|
|
Point3d ptP3 = ptStart + ( dDelta - dElev) * vtTool ;
|
|
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
|
|
return false ;
|
|
ptLast = ptStart ;
|
|
}
|
|
else if ( nPlunge == MORTISE_PLUNGE_END) {
|
|
// 3 -> punto in affondamento
|
|
SetFeed( GetStartFeed()) ;
|
|
SetFlag( 0) ;
|
|
Point3d ptP3 = ptEnd + ( dDelta - dElev) * vtTool ;
|
|
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
|
|
return false ;
|
|
ptLast = ptEnd ;
|
|
}
|
|
else {
|
|
// determino numero e affondamento degli step
|
|
const double RETURN_DIST = 10 ;
|
|
// a seconda del tipo
|
|
switch ( m_Params.m_nStepType) {
|
|
default : // ZIGZAG
|
|
for ( int i = 1 ; i <= nStep ; ++ i) {
|
|
// 3 -> punto in affondamento
|
|
SetFeed( GetStartFeed()) ;
|
|
SetFlag( 0) ;
|
|
Point3d ptP3 = (( i % 2 == 1) ? ptStart : ptEnd) + ( dDelta - i * dStep) * vtTool ;
|
|
if ( AddLinearMove( ptP3) == GDB_ID_NULL && ! ( i == 1 && nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ))
|
|
return false ;
|
|
// 4 -> punto termine
|
|
SetFeed( GetFeed()) ;
|
|
SetFlag( 0) ;
|
|
ptLast = (( i % 2 == 1) ? ptEnd : ptStart) ;
|
|
Point3d ptP4 = ptLast + ( dDelta - i * dStep) * vtTool ;
|
|
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
|
|
return false ;
|
|
}
|
|
break ;
|
|
case MORTISE_ST_ONEWAY :
|
|
for ( int i = 1 ; i <= nStep ; ++ i) {
|
|
// 3 -> punto in affondamento
|
|
SetFeed( GetStartFeed()) ;
|
|
SetFlag( 0) ;
|
|
Point3d ptP3 = ptStart + ( dDelta - i * dStep) * vtTool ;
|
|
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
|
|
return false ;
|
|
// 4 -> punto termine
|
|
SetFeed( GetFeed()) ;
|
|
SetFlag( 0) ;
|
|
ptLast = ptEnd ;
|
|
Point3d ptP4 = ptLast + ( dDelta - i * dStep) * vtTool ;
|
|
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
|
|
return false ;
|
|
// 5 -> ritorno sull'inizio, se non ultimo punto
|
|
if ( i < nStep) {
|
|
// retrocedo
|
|
SetFeed( GetFeed()) ;
|
|
SetFlag( 0) ;
|
|
Point3d ptP5a = ptP4 + RETURN_DIST * vtTool ;
|
|
if ( AddLinearMove( ptP5a) == GDB_ID_NULL)
|
|
return false ;
|
|
// ritorno sopra inizio
|
|
SetFeed( GetFeed()) ;
|
|
SetFlag( 0) ;
|
|
Point3d ptP5b = ptP3 + RETURN_DIST * vtTool ;
|
|
if ( AddLinearMove( ptP5b) == GDB_ID_NULL)
|
|
return false ;
|
|
}
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
|
|
// determino se la fine dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
|
|
double dEndElev = 0 ;
|
|
Point3d ptLo = ptLast + vtTool * dDelta ;
|
|
bool bUnderEnd = GetAhPointUnderRaw( ptLo, vtTool, 0,
|
|
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ;
|
|
// altrimenti ridetermino elevazione su fine percorso di lavoro
|
|
if ( ! bUnderEnd)
|
|
GetElevation( m_nPhase, ptLo, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev) ;
|
|
|
|
// sicurezza su punto finale
|
|
double dRetr = dEndElev + dSafeZ ;
|
|
if ( nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ) {
|
|
double dEndDownElev ;
|
|
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndDownElev))
|
|
dEndDownElev = dDelta ;
|
|
if ( dEndDownElev < EPS_SMALL)
|
|
dRetr = dEndElev - dStep ;
|
|
}
|
|
|
|
// 6 -> ritorno all'approccio
|
|
SetFeed( GetEndFeed()) ;
|
|
SetFlag( 104) ; // risalita sopra la fine
|
|
Point3d ptP6 = ptLast + vtTool * ( dDelta + dRetr) ;
|
|
if ( AddLinearMove( ptP6) == GDB_ID_NULL)
|
|
return false ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
double
|
|
Mortising::GetRadiusForStartEndElevation( void) const
|
|
{
|
|
const double DELTA_ELEV_RAD = 20.0 ;
|
|
return ( 0.5 * m_TParams.m_dTDiam + DELTA_ELEV_RAD) ;
|
|
}
|