Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f0e295d9d6461d9e4a27a75b8369d7272b72812e
EgtMachKernel/PocketingNT.cpp
T
Riccardo Elitropi 1b97ec5310 EgtMachKernel : 
- in PocketingNT, SurfFinishing e SurfRoughing aggiunto flag per Conventional Milling per curve di svuotatura singole.
2026-05-11 10:03:58 +02:00

6788 lines
284 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2017-2023
//----------------------------------------------------------------------------
// File : PocketingNT.cpp Data : 17.12.23 Versione : 2.5l3
// Contenuto : Implementazione gestione svuotature.
//
//
//
// Modifiche : 04.02.17 DS Creazione modulo.
// 24.02.22 DS Corretta ed estesa VerifyPathFromBottom.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "PocketingNT.h"
#include "OperationConst.h"
#include "OperUserNotesConst.h"
#include "MachiningConst.h"
#include "GeoConst.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkBiArcs.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/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkDistPointSurfTm.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkCurveLocal.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkPolygonElevation.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGkIntervals.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EGkCalcPocketing.h"
#include "/EgtDev/Include/EGkSurfLocal.h"
#include "/EgtDev/Include/EGkDistPointSurfFr.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkCDeClosedSurfTmClosedSurfTm.h"
#include "/EgtDev/Include/EgtIniFile.h"
#include <algorithm>
using namespace std ;
//------------------------------ Costanti ------------------------------------
static string KEY_OPEN = "OPEN" ;
static string KEY_THICK = "THICK" ;
static int LINK_CURVE_PROP = -3 ;
static double EXTRA_ELEV = 5. ;
static double EXTRA_DEPTH = 5. ;
static double SAFETY_LINK_COS = cos( - ( 175 * DEGTORAD)) ;
static double TOOL_RAD_PTSTART = 20. ;
//------------------------------ Errori/Warnings --------------------------------------
// 2401 = "Error in PocketingNT : UpdateToolData failed"
// 2402 = "Error in PocketingNT : Open Contour"
// 2403 = "Error in PocketingNT : Contour Not Flat"
// 2404 = "Error in PocketingNT : Tool Not Perpendicular to Flat Area"
// 2405 = "Error in PocketingNT : Empty RawBox"
// 2406 = "Error in PocketingNT : Depth not computable"
// 2408 = "Error in PocketingNT : Entity GetElevation"
// 2409 = "Error in PocketingNT : missing aggregate from bottom"
// 2410 = "Error in PocketingNT : path too far from part sides"
// 2411 = "Error in PocketingNT : toolpath allocation failed"
// 2412 = "Error in PocketingNT : Offset not computable"
// 2413 = "Error in PocketingNT : Toolpath not computable"
// 2414 = "Error in PocketingNT : Approach not computable"
// 2415 = "Error in PocketingNT : LeadIn not computable"
// 2416 = "Error in PocketingNT : LeadOut not computable"
// 2417 = "Error in PocketingNT : Retract not computable"
// 2418 = "Error in PocketingNT : Link not computable"
// 2419 = "Error in PocketingNT : Linear Approx not computable"
// 2420 = "Error in PocketingNT : Return toolpath not computable"
// 2421 = "Error in PocketingNT : Chaining failed"
// 2422 = "Error in PocketingNT : Tool MaxMaterial too small (xxx)"
// 2423 = "Error in PocketingNT : axes values not calculable"
// 2424 = "Error in PocketingNT : outstroke xxx"
// 2425 = "Error in PocketingNT : link movements not calculable"
// 2426 = "Error in PocketingNT : link outstroke xxx"
// 2427 = "Error in PocketingNT : post apply not calculable"
// 2428 = "Error in PocketingNT : Tool loading failed"
// 2429 = "Error in PocketingNT : machining depth (xxx) bigger than MaxDepth (yyy)"
// 2430 = "Error in PocketingNT : adjust open edges failed"
// 2431 = "Error in PocketingNT : LeadIn with Mill NoTip in material"
// 2432 = "Error in PocketingNT : Mirror for Double calculation failed"
// 2433 = "Error in PocketingNT : Calc Region Elevation failed"
// 2434 = "Error in PocketingNT : Managing Open Edges inside Raw failed"
// 2435 = "Error in PocketingNT : Managing Open Edges on Raw failed"
// 2436 = "Error in PocketingNT : not valid Raw"
// 2437 = "Error in PocketingNT : not valid Trim Surf"
// 2438 = "Error in PocketingNT : not valid Pocketing Volume"
// 2439 = "Error in PocketingNT : special apply not calculable"
// 2451 = "Warning in PocketingNT : Skipped entity (xx)"
// 2452 = "Warning in PocketingNT : No pocket"
// 2453 = "Warning in PocketingNT : Tool name changed (xx)"
// 2454 = "Warning in PocketingNT : Tool data changed (xx)"
// 2455 = "Warning in PocketingNT : No machinable pocket"
// 2456 = "Warning in PocketingNT : machining step too small (xx)"
// 2457 = "Warning in PocketingNT : machining step (xxx) bigger than MaxMaterial (yyy)"
// 2458 = "Warning in PocketingNT : machining depth (xxx) bigger than MaxMaterial (yyy)"
// 2459 = "Warning in PocketingNT : Steps too far away from Raw"
//----------------------------------------------------------------------------
// Debug
#define DEBUG_STM_TOPOLOGY 0 // Debug per topologia faccia selezionata per pStm
#define DEBUG_OPEN_EDGE_EXTENSION 0 // Debug estensione dei lati aperti
#define DEBUG_OPEN_EDGE_IN_RAW 0 // Debug gestione lati aperti interni al grezzo
#define DEBUG_SFR_STEPS 0 // Debug Sfr ( Pock e Limit) nei vari step ( risultato finale per CalcPocketing)
#define DEBUG_SFR_RAW 0 // Debug intersezioni tra SurfFlatRegion e SurfTriMesh
#define DEBUG_STM_EXTRUSION 0 // Debug superficie TriMesh di estrusione dei lati chiusi
#define DEBUG_SFR_GEO_EXT 0 // Debug FlatRegion per geometrie dei lati chiusi (in Processpath)
#define DEBUG_GLIDE 0 // Debug percorsi a Scivolo ( LeadIn/LeadOut)
#define DEBUG_MAXDEPTH 0 // Debug per controllo di MaxDepth
#define DEBUG_SAFETY_LINK 0 // Debug raccordi tra percorsi di lavorazioni differenti
#define DEBUG_FEED 0 // Debug per Feed
#define DEBUG_START_POINT 0 // Debug per scelta del punto iniziale
#define DEBUG_PATH_CL 0 // Debug per valori memorizzati nel percorso del CL
#define DEBUG_ZIGZAG_LEADIN 0 // Debug per ZigZag LeadIn
#define DEBUG_DOUBLE_PARALLEL 0 // Debug per Pocketing in Doppio con Parallelo
#define DEBUG 0 // Debug
#if DEBUG_STM_TOPOLOGY || DEBUG_OPEN_EDGE_EXTENSION || DEBUG_OPEN_EDGE_IN_RAW || DEBUG_SFR_STEPS || DEBUG_SFR_RAW || DEBUG_SFR_GEO_EXT || \
DEBUG_GLIDE || DEBUG_SAFETY_LINK || DEBUG_FEED || DEBUG_START_POINT || DEBUG_PATH_CL || DEBUG_ZIGZAG_LEADIN || DEBUG_DOUBLE_PARALLEL || \
DEBUG
#include "EgtDev/Include/EGkGeoPoint3d.h"
#include "EgtDev/Include/EGkGeoVector3d.h"
#include "EgtDev/Include/EGkFrame3d.h"
int nGrpDebugFeed = GDB_ID_NULL, nLayDebugFeed = GDB_ID_NULL ;
#endif
//----------------------------------------------------------------------------
// USEROBJ_REGISTER( GetOperationClass( OPER_POCKETING), PocketingNT) ;
//----------------------------------------------------------------------------
const string&
PocketingNT::GetClassName( void) const
{
return USEROBJ_GETNAME( PocketingNT) ;
}
//----------------------------------------------------------------------------
PocketingNT*
PocketingNT::Clone( void) const
{
// alloco oggetto
PocketingNT* pPock = new(nothrow) PocketingNT ;
// eseguo copia dei dati
if ( pPock != nullptr) {
try {
pPock->m_vId = m_vId ;
pPock->m_pMchMgr = m_pMchMgr ;
pPock->m_nPhase = m_nPhase ;
pPock->m_Params = m_Params ;
pPock->m_TParams = m_TParams ;
pPock->m_dTHoldBase = m_dTHoldBase ;
pPock->m_dTHoldLen = m_dTHoldLen ;
pPock->m_dTHoldDiam = m_dTHoldDiam ;
pPock->m_nStatus = m_nStatus ;
pPock->m_nPockets = m_nPockets ;
pPock->m_bTiltingTab = m_bTiltingTab ;
pPock->m_vtTiltingAx = m_vtTiltingAx ;
pPock->m_bAboveHead = m_bAboveHead ;
pPock->m_bAggrBottom = m_bAggrBottom ;
pPock->m_bOpenOutRaw = m_bOpenOutRaw ;
pPock->m_dOpenMinSafe = m_dOpenMinSafe ;
}
catch( ...) {
delete pPock ;
return nullptr ;
}
}
// ritorno l'oggetto
return pPock ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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) {
string sTmp = m_Params.ToString( i) ;
if ( ! IsEmptyOrSpaces( sTmp))
sOut += sTmp + szNewLine ;
}
for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) {
string sTmp = m_TParams.ToString( i) ;
if ( ! IsEmptyOrSpaces( sTmp))
sOut += sTmp + szNewLine ;
}
sOut += KEY_NUM + EQUAL + ToString( m_nPockets) + szNewLine ;
sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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) {
string sParam = m_Params.ToString( i) ;
if ( ! sParam.empty())
vString[++k] = sParam ;
}
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_nPockets, vString[++k]))
return false ;
if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k]))
return false ;
vString.resize( k + 1) ;
}
catch( ...) {
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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_nPockets))
return false ;
}
else if ( sKey == KEY_STAT) {
if ( ! FromString( sVal, m_nStatus))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
PocketingNT::PocketingNT( 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_dMaxHelixRad = INFINITO ;
m_nStatus = MCH_ST_TO_VERIFY ;
m_nPockets = 0 ;
m_bTiltingTab = false ;
m_bAboveHead = true ;
m_bAggrBottom = false ;
m_bOpenOutRaw = false ;
m_dOpenMinSafe = 0 ;
m_bRunning = false ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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 PocketingData* pDdata = GetPocketingData( 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
PocketingNT::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
PocketingNT::SetParam( int nType, int nVal)
{
switch ( nType) {
case MPA_LEADINTYPE :
if ( ! m_Params.VerifyLeadInType( nVal))
return false ;
if ( nVal != m_Params.m_nLeadInType)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nLeadInType = nVal ;
return true ;
case MPA_LEADOUTTYPE :
if ( ! m_Params.VerifyLeadOutType( nVal))
return false ;
if ( nVal != m_Params.m_nLeadOutType)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nLeadOutType = nVal ;
return true ;
case MPA_SCC :
if ( ! m_Params.VerifySolCh( nVal))
return false ;
if ( nVal != m_Params.m_nSolCh)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nSolCh = nVal ;
return true ;
case MPA_SUBTYPE :
if ( ! m_Params.VerifySubType( nVal))
return false ;
if ( nVal != m_Params.m_nSubType)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nSubType = nVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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_SIDESTEP :
if ( abs( dVal - m_Params.m_dSideStep) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dSideStep = dVal ;
return true ;
case MPA_SIDEANGLE :
if ( abs( dVal - m_Params.m_dSideAngle) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dSideAngle = 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_LIELEV :
if ( abs( dVal - m_Params.m_dLiElev) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiElev = dVal ;
return true ;
case MPA_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_EPICYCLESRAD :
if ( abs( dVal - m_Params.m_dEpicyclesRad) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dEpicyclesRad = dVal ;
return true ;
case MPA_EPICYCLESDIST :
if ( abs( dVal - m_Params.m_dEpicyclesDist) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dEpicyclesDist = dVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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
PocketingNT::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 PocketingNT : Skipped entity " + ToString( Id) ;
m_pMchMgr->SetWarning( 2451, 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
PocketingNT::Preview( bool bRecalc)
{
// reset numero percorsi di svuotatura generati
m_nPockets = 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( 2401, "Error in PocketingNT : UpdateToolData failed") ;
return false ;
}
// 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( 2428, "Error in PocketingNT : 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( 2421, "Error in PocketingNT : 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 regione piana
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
PocketingNT::Apply( bool bRecalc, bool bPostApply)
{
// se calcoli già in corso, esco
if ( m_bRunning) {
LOG_DBG_INFO( GetEMkLogger(), "PocketingNT::Apply already running") ;
return true ;
}
m_bRunning = true ;
bool bOk = MyApply( bRecalc, bPostApply) ;
m_bRunning = false ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::MyApply( bool bRecalc, bool bPostApply)
{
// reset numero percorsi di svuotatura generati
int nCurrPockets = m_nPockets ;
m_nPockets = 0 ;
// reset raggio massimo attacco ad elica nel caso di cerchi
m_dMaxHelixRad = INFINITO ;
// 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( 2401, "Error in PocketingNT : 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_nPockets = nCurrPockets ;
string sLog = string( "PocketingNT 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 ;
}
// altrimenti, controllo esistenza delle regioni (per compatibilità)
else {
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL && ! bChain) {
int nGeoId = m_pGeomDB->GetFirstInGroup( nPathId) ;
while ( nGeoId != GDB_ID_NULL && ! bChain) {
bChain = ( m_pGeomDB->GetGeoType( nGeoId) != SRF_FLATRGN) ;
nGeoId = m_pGeomDB->GetNext( nGeoId) ;
}
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
if ( bChain)
m_pGeomDB->EmptyGroup( nAuxId) ;
}
// 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( 2428, "Error in PocketingNT : 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) ;
// recupero gruppo per geometria di lavorazione (Cutter Location)
int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ;
// se non c'è, lo aggiungo
if ( nClId == GDB_ID_NULL) {
nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nClId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nClId, MCH_CL) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nClId) ;
// elimino eventuale gruppo geometria simmetrica per lavorazione in doppio
int nDblId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_DBL) ;
if ( nDblId != GDB_ID_NULL) {
m_pGeomDB->Erase( nDblId) ;
nDblId = GDB_ID_NULL ;
}
// se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
if ( bChain && ! Chain( nAuxId)) {
m_pMchMgr->SetLastError( 2421, "Error in PocketingNT : Chaining failed") ;
return false ;
}
// lavoro ogni singola catena
bool bOk = true ;
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL) {
if ( ! ProcessPath( nPathId, GDB_ID_NULL, nClId))
bOk = false ;
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
if ( ! bOk)
return false ;
// assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
CalcAndSetBBox( nClId) ;
// se lavorazione in doppio, aggiungo geometria della parte simmetrica
if ( ! CalcMirrorByDouble( nClId, m_Params.m_sUserNotes)) {
m_pMchMgr->SetLastError( 2432, "Error in PocketingNT : Mirror for Double calculation failed") ;
return false ;
}
// eseguo aggiornamento assi macchina e collegamento con operazione precedente
if ( ! Update( bPostApply))
return false ;
// aggiorno stato della lavorazione
m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
// dichiaro successiva da aggiornare
UpdateFollowingOperationsStatus( MCH_ST_OTH_MODIF) ;
LOG_DBG_INFO( GetEMkLogger(), "PocketingNT apply done") ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::Update( bool bPostApply)
{
// verifico validità gestore DB geometrico e Id del gruppo
if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
return false ;
// se geometria di lavorazione vuota, esco
if ( m_nPockets == 0 ) {
m_pMchMgr->SetWarning( 2452, "Warning in PocketingNT : No pocket") ;
return true ;
}
// se lavorazione vuota, esco
if ( ! IsAtLeastOnePathOk()) {
m_pMchMgr->SetWarning( 2455, "Warning in PocketingNT : No machinable pocket") ;
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( 2423, "Error in PocketingNT : axes values not calculable") ;
else
m_pMchMgr->SetLastError( 2424, "Error in PocketingNT : outstroke ") ;
return false ;
}
// assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
CalcAndSetAxesBBox() ;
// se lavorazione in doppio, calcolo assi e movimenti di approccio e retrazione relativi
if ( GetDoubleType( m_Params.m_sUserNotes) != 0) {
// elimino le entità CLIMB, RISE e HOME della lavorazione in doppio
RemoveClimbRiseHome( false) ;
// recupero i dati della testa in doppio e la imposto
string sDblTool ; string sDblTcPos ; string sDblHead ; int nDblExit ;
bool bOk = GetDoubleToolData( sDblTool, sDblTcPos, sDblHead, nDblExit) &&
m_pMchMgr->SetCalcTool( sDblTool, sDblHead, nDblExit) ;
// imposto eventuale asse bloccato da lavorazione
SetBlockedRotAxis( m_Params.m_sBlockedAxis, true) ;
// eseguo il calcolo
if ( bOk) {
if ( ! CalculateDoubleAxesValues( sHint)) {
string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
if ( sInfo.empty())
m_pMchMgr->SetLastError( 2423, "Error in PocketingNT : axes values not calculable for double") ;
else
m_pMchMgr->SetLastError( 2424, "Error in PocketingNT : double outstroke ") ;
bOk = false ;
}
}
// ripristino testa principale
m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()) ;
// in caso di errore, esco
if ( ! bOk)
return false ;
}
// esecuzione eventuali personalizzazioni speciali
string sSpecErr ;
if ( bPostApply && ! SpecialApply( sSpecErr)) {
if ( ! IsEmptyOrSpaces( sSpecErr))
m_pMchMgr->SetLastError( 2439, sSpecErr) ;
else
m_pMchMgr->SetLastError( 2439, "Error in PocketingNT : 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( 2425, "Error in PocketingNT : link movements not calculable") ;
else
m_pMchMgr->SetLastError( 2426, "Error in PocketingNT : link outstroke ") ;
return false ;
}
// esecuzione eventuali personalizzazioni finali
string sPostErr ;
if ( bPostApply && ! PostApply( sPostErr)) {
if ( ! IsEmptyOrSpaces( sPostErr))
m_pMchMgr->SetLastError( 2427, sPostErr) ;
else
m_pMchMgr->SetLastError( 2427, "Error in PocketingNT : post apply not calculable") ;
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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
PocketingNT::GetParam( int nType, int& nVal) const
{
switch ( nType) {
case MPA_TYPE :
nVal = MT_POCKETING ;
return true ;
case MPA_LEADINTYPE :
nVal = m_Params.m_nLeadInType ;
return true ;
case MPA_LEADOUTTYPE :
nVal = m_Params.m_nLeadOutType ;
return true ;
case MPA_SCC :
nVal = m_Params.m_nSolCh ;
return true ;
case MPA_SUBTYPE :
nVal = m_Params.m_nSubType ;
return true ;
}
nVal = 0 ;
return false ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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_SIDESTEP :
dVal = m_Params.m_dSideStep ;
return true ;
case MPA_SIDEANGLE :
dVal = m_Params.m_dSideAngle ;
return true ;
case MPA_LITANG :
dVal = m_Params.m_dLiTang ;
return true ;
case MPA_LIELEV :
dVal = m_Params.m_dLiElev ;
return true ;
case MPA_LOTANG :
dVal = m_Params.m_dLoTang ;
return true ;
case MPA_EPICYCLESRAD :
dVal = m_Params.m_dEpicyclesRad ;
return true ;
case MPA_EPICYCLESDIST :
dVal = m_Params.m_dEpicyclesDist ;
return true ;
}
dVal = 0 ;
return false ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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&
PocketingNT::GetToolData( void) const
{
return m_TParams ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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 PocketingNT : tool name changed (" +
m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
m_pMchMgr->SetWarning( 2453, sInfo) ;
m_Params.m_sToolName = m_TParams.m_sName ;
}
if ( bChanged) {
string sInfo = "Warning in PocketingNT : tool data changed (" +
m_Params.m_sToolName + ")" ;
m_pMchMgr->SetWarning( 2454, sInfo) ;
}
// se modificato, aggiusto lo stato
if ( bChanged)
m_nStatus = MCH_ST_TO_VERIFY ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::GetGeometry( SELVECTOR& vIds) const
{
// restituisco l'elenco delle entità
vIds = m_vId ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::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 ;
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
PocketingNT::AdjustCurvesByStmTopology( const ISurfTriMesh* pSurf, const Frame3d& frGlob, const ISurfTriMesh* pStmTrim,
ICURVEPLIST& lstPC)
{
// controllo dei parametri
if ( pSurf == nullptr || ! pSurf->IsValid())
return false ;
if ( lstPC.empty())
return true ;
// le curve devono essere tutte valide
for ( auto& pCrv : lstPC) {
if ( pCrv == nullptr || ! pCrv->IsValid())
return false ;
}
// trasformo la lista di curve in curve composite
ICRVCOMPOPOVECTOR vCrvCompo ; vCrvCompo.reserve( lstPC.size()) ;
for ( auto& pCrv : lstPC) {
PtrOwner<ICurveComposite> pCrvCompo( ConvertCurveToComposite( pCrv->Clone())) ;
if ( IsNull( pCrvCompo) || ! pCrvCompo->IsValid() ||
! vCrvCompo.emplace_back( Release( pCrvCompo)))
return false ;
}
// se non ho isole e non esistono lati aperti, non faccio nulla
// Le isole chiuse necessitano di essere estruse
if ( int( vCrvCompo.size()) == 1) {
bool bSomeOpen = false ;
for ( int i = 0 ; i < vCrvCompo.back()->GetCurveCount() && ! bSomeOpen ; ++ i) {
bSomeOpen = ( vCrvCompo.back()->GetCurve( i)->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) ;
if ( bSomeOpen)
break ;
}
if ( ! bSomeOpen)
return true ;
}
// controllo se esistono lati aperti interni alla superficie di Trim, in caso positivo, non faccio nulla
const double TOL_PT_INSIDE_STM = 3. ;
for ( auto& pCrvCompo : vCrvCompo) {
// recupero i tratti omogenei
ICRVCOMPOPOVECTOR vpCrvs ;
GetHomogeneousParts( pCrvCompo, vpCrvs) ;
// scorro i tratti alla ricerca di lati aperti
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
// analizzo le sottocurve del tratto
for ( int j = 0 ; j < vpCrvs[i]->GetCurveCount() ; ++ j) {
// per ogni sottocurva considero punto iniziale, finale e medio per campionarla
// ( si potrebbe in futuro campionare in maniera più fitta )
PNTVECTOR vPt( 3, P_INVALID) ;
vpCrvs[i]->GetCurve( j)->GetStartPoint( vPt[0]) ;
vpCrvs[i]->GetCurve( j)->GetMidPoint( vPt[1]) ;
vpCrvs[i]->GetCurve( j)->GetEndPoint( vPt[2]) ;
// classifico tali punti rispetto alla superficie
bool bOpenEdgeInStm = false ;
double dDist = 0. ;
for ( int nPt = 0 ; nPt < int( vPt.size()) && ! bOpenEdgeInStm ; ++ nPt) {
DistPointSurfTm DistPtStm( vPt[nPt], *pStmTrim) ;
bOpenEdgeInStm = ( DistPtStm.IsPointInside() &&
DistPtStm.GetDist( dDist) &&
dDist > TOL_PT_INSIDE_STM) ;
}
if ( bOpenEdgeInStm)
return true ; // !!! molto restrittivo, bisogna capire cosa fare...
}
}
}
}
// recupero il volume di svuotatura
PtrOwner<ISurfTriMesh> pStmRawCl( CloneSurfTriMesh( pStmTrim)) ;
PtrOwner<ISurfTriMesh> pStmVol( CloneSurfTriMesh( pStmTrim)) ;
PtrOwner<ISurfTriMesh> pSurfGlob( CloneSurfTriMesh( pSurf)) ;
if ( IsNull( pStmRawCl) || ! pStmRawCl->IsValid() ||
IsNull( pStmVol) || ! pStmVol->IsValid() ||
IsNull( pSurfGlob) || ! pSurfGlob->IsValid() || ! pSurfGlob->ToGlob( frGlob) ||
! pStmVol->Subtract( *pSurfGlob))
return false ;
#if DEBUG_STM_TOPOLOGY
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "StmFaceTopology") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
int nStmLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nStmLay, "Stm") ;
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nStmLay, pSurfGlob->Clone()) ;
m_pGeomDB->SetMaterial( nId, TEAL) ;
int nClISlLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nClISlLay, "Closed_Isl") ;
int nRawLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nRawLay, "Raw") ;
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawLay, pStmRawCl->Clone()) ;
m_pGeomDB->SetMaterial( nId, PURPLE) ;
int nVolLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nVolLay, "Vol") ;
int nCrvLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nCrvLay, "Result") ;
#endif
// le isole sono considerate estese fino al grezzo; creo dei solidi di estrusione per le isole chiuse
if ( int( vCrvCompo.size() > 1)) {
Vector3d vtN ; lstPC.back()->GetExtrusion( vtN) ;
const double EXTR_LEN = 1000. ;
SurfFlatRegionByContours SfrByC ;
for ( auto& pCrvCompo : vCrvCompo) {
if ( ! SfrByC.AddCurve( CloneCurveComposite( pCrvCompo)))
return false ;
}
PtrOwner<ISurfFlatRegion> pSfr( SfrByC.GetSurf()) ;
if ( IsNull( pSfr) || ! pSfr->IsValid())
return false ;
for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
for ( int nL = 1 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
bool bClosedIsl = true ;
int nTmpProp = TEMP_PROP_INVALID ;
for ( int nU = 0 ; nU < pSfr->GetLoopCurveCount( nC, nL) && bClosedIsl ; ++ nU)
bClosedIsl = ( pSfr->GetCurveTempProp( nC, nL, nU, nTmpProp, 0) && nTmpProp == TEMP_PROP_CLOSE_EDGE) ;
if ( bClosedIsl) {
PtrOwner<ICurve> pCrvLoop( pSfr->GetLoop( nC, nL)) ;
if ( ! IsNull( pCrvLoop) && pCrvLoop->IsValid()) {
pCrvLoop->Translate( - EXTR_LEN / 2. * vtN) ;
pCrvLoop->SetExtrusion( vtN) ;
OffsetCurve OffsCrv ;
if ( ! OffsCrv.Make( pCrvLoop, 10 * EPS_SMALL, ICurve::OFF_FILLET) ||
! pCrvLoop.Set( OffsCrv.GetLongerCurve()))
return false ;
PtrOwner<ISurfTriMesh> pStmExtr( GetSurfTriMeshByExtrusion( pCrvLoop, EXTR_LEN * vtN, true)) ;
if ( ! IsNull( pStmExtr) && pStmExtr->IsValid() && pStmExtr->IsClosed()) {
double dVol = 0. ;
if ( pStmExtr->GetVolume( dVol) && dVol < 0.)
pStmExtr->Invert() ;
#if DEBUG_STM_TOPOLOGY
int nIslId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nClISlLay, CloneSurfTriMesh( pStmExtr)) ;
m_pGeomDB->SetMaterial( nIslId, BLACK) ;
#endif
if ( ! pStmVol->Subtract( *pStmExtr))
return false ;
}
}
}
}
}
}
#if DEBUG_STM_TOPOLOGY
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nVolLay, pStmVol->Clone()) ;
m_pGeomDB->SetMaterial( nId, GREEN) ;
#endif
// se volume non chiuso, errore
if ( ! pStmVol->IsClosed())
return false ;
// se il volume è composto da più parti, scelgo quella inerente alla superficie TriMesh selezionata
if ( pStmVol->GetPartCount() > 1) {
// Box della TriMesh da lavorare
BBox3d BBoxPock ; pSurfGlob->GetLocalBBox( BBoxPock) ;
BBoxPock.Expand( 50. * EPS_SMALL) ; // euristica
for ( int nP = 0 ; nP < pStmVol->GetPartCount() ; ++ nP) {
// Box della parte
BBox3d BBoxPart ; pStmVol->GetPartLocalBBox( nP, BBoxPart) ;
BBoxPart.Expand( 50. * EPS_SMALL) ; // euristica
BBox3d BBoxInt ;
if ( ! BBoxPart.FindIntersection( BBoxPock, BBoxInt) || BBoxInt.IsEmpty()) {
pStmVol->RemovePart( nP) ;
-- nP ;
}
}
}
// proeitto la superficie ricavata e il grezzo sul piano intrinseco della regione piana
Vector3d vtN ; lstPC.back()->GetExtrusion( vtN) ;
Point3d ptC ; lstPC.back()->GetCentroid( ptC) ;
Plane3d plProj ;
if ( ! plProj.Set( ptC, vtN))
return false ;
POLYLINEVECTOR vPLVol, vPLRaw ;
if ( ! pStmVol->GetSilhouette( plProj, 20 * EPS_SMALL, vPLVol))
return false ;
if ( ! pStmRawCl->GetSilhouette( plProj, 20 * EPS_SMALL, vPLRaw))
return false ;
#if DEBUG_STM_TOPOLOGY
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawLay, pStmRawCl->Clone()) ;
m_pGeomDB->SetMaterial( nId, BLUE) ;
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nVolLay, pStmVol->Clone()) ;
m_pGeomDB->SetMaterial( nId, LIME) ;
#endif
// recupero le due superfici piane
SurfFlatRegionByContours SfrBCVol, SfrBCRaw ;
for ( PolyLine& PL : vPLVol) {
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( ! IsNull( pCompo) && pCompo->FromPolyLine( PL))
SfrBCVol.AddCurve( Release( pCompo)) ;
}
for ( PolyLine& PL : vPLRaw) {
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( ! IsNull( pCompo) && pCompo->FromPolyLine( PL))
SfrBCRaw.AddCurve( Release( pCompo)) ;
}
PtrOwner<ISurfFlatRegion> pSfrVol( SfrBCVol.GetSurf()) ;
PtrOwner<ISurfFlatRegion> pSfrRaw( SfrBCRaw.GetSurf()) ;
if ( IsNull( pSfrVol) || IsNull( pSfrRaw) ||
! pSfrVol->IsValid() || ! pSfrRaw->IsValid())
return false ;
if ( AreOppositeVectorApprox( vtN, pSfrVol->GetNormVersor()))
pSfrVol->Invert() ;
if ( AreOppositeVectorApprox( vtN, pSfrRaw->GetNormVersor()))
pSfrRaw->Invert() ;
#if DEBUG_STM_TOPOLOGY
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawLay, pSfrRaw->Clone()) ;
m_pGeomDB->SetMaterial( nId, BLUE) ;
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nVolLay, pSfrVol->Clone()) ;
m_pGeomDB->SetMaterial( nId, LIME) ;
#endif
// se la nuova superficie ricavata contiene un tratto chiuso, allora non faccio nulla
// ( Esempio di una tasca inclinata con gradini )
const double OFFSET_FOR_CLOSE = 1. ; // euristico
PtrOwner<ISurfFlatRegion> pSfrVol_Clone( pSfrVol->CreateOffsetSurf( - OFFSET_FOR_CLOSE, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrVol_Clone))
return false ;
for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
ICRVCOMPOPOVECTOR vpCrvs ;
GetHomogeneousParts( vCrvCompo[i], vpCrvs) ;
for ( int j = 0 ; j < int( vpCrvs.size()) ; ++ j) {
if ( vpCrvs[j]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) {
CRVCVECTOR ccClass ;
if ( pSfrVol_Clone->GetCurveClassification( *vpCrvs[j], EPS_SMALL, ccClass)) {
for ( int k = 0 ; k < int( ccClass.size()) ; ++ k) {
if ( ccClass[k].nClass != CRVC_OUT) {
// non estendo la superficie in quanto rovina il grezzo adiacente ad un chiuso
return true ;
}
}
}
else
return false ;
}
}
}
// definisco i lati aperti della nuova regione da svuotare
// --- i lati aperti sono quelli in comune con la proiezione del grezzo
for ( auto& pCrv : lstPC)
delete( pCrv) ;
lstPC.clear() ;
pSfrRaw->Offset( - 50 * EPS_SMALL, ICurve::OFF_FILLET) ;
for ( int nC = 0 ; nC < pSfrVol->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfrVol->GetLoopCount( nC) ; ++ nL) {
// recupero il Loop
PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pSfrVol->GetLoop( nC, nL))) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->IsValid())
return false ;
for ( int nU = 0 ; nU < pCompoLoop->GetCurveCount() ; ++ nU) {
PNTVECTOR vPt( 3, P_INVALID) ;
pCompoLoop->GetCurve( nU)->GetStartPoint( vPt[0]) ;
pCompoLoop->GetCurve( nU)->GetMidPoint( vPt[1]) ;
pCompoLoop->GetCurve( nU)->GetEndPoint( vPt[2]) ;
pCompoLoop->SetCurveTempProp( nU, TEMP_PROP_OPEN_EDGE, 0) ;
for ( int nPt = 0 ; nPt < int( vPt.size()) ; ++ nPt) {
bool bIsInside = true ;
IsPointInsideSurfFr( vPt[nPt], pSfrRaw, EPS_SMALL, bIsInside) ;
if ( bIsInside) {
pCompoLoop->SetCurveTempProp( nU, TEMP_PROP_CLOSE_EDGE, 0) ;
break ;
}
}
}
#if DEBUG_STM_TOPOLOGY
for ( int nU = 0 ; nU < pCompoLoop->GetCurveCount() ; ++ nU) {
int nProp0 ; pCompoLoop->GetCurveTempProp( nU, nProp0, 0) ;
int nInd = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nCrvLay, pCompoLoop->GetCurve( nU)->Clone()) ;
m_pGeomDB->SetMaterial( nInd, ( nProp0 == 0 ? BLUE : RED)) ;
}
#endif
lstPC.emplace_back( Release( pCompoLoop)) ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::GetCurves( const SelData& Id, const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmTrim, 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 ;
Vector3d vtExtr ;
// 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()) ;
// recupero eventuali informazioni per lati aperti
SetCurveAllTempProp( Id.nId, false, pCurve) ;
// se estrusione mancante, imposto default
if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall())
pCurve->SetExtrusion( Z_AX) ;
// sistemo senso antiorario visto dalla direzione di estrusione
Plane3d plPlane ; double dArea ;
pOriCurve->GetArea( plPlane, dArea) ;
if ( plPlane.GetVersN() * vtExtr * dArea < 0)
pCurve->Invert() ;
}
// 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()) ;
// reset proprietà temporanee
ResetCurveAllTempProp( pCurve) ;
// recupero estrusione e spessore
if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall())
vtExtr = Z_AX ;
pCurve->SetExtrusion( vtExtr) ;
double dThick ;
if ( pCompo->GetThickness( dThick))
pCurve->SetThickness( dThick) ;
// sistemo senso antiorario visto dalla direzione di estrusione
Plane3d plPlane ; double dArea ;
pCompo->GetArea( plPlane, dArea) ;
if ( plPlane.GetVersN() * vtExtr * dArea < 0)
pCurve->Invert() ;
}
if ( IsNull( pCurve))
return false ;
// la porto in globale
pCurve->ToGlob( frGlob) ;
// la restituisco
lstPC.emplace_back( Release( pCurve)) ;
return true ;
}
// --- se 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 ;
// reset proprietà temporanee
for ( auto pCrv : lstPC)
ResetCurveAllTempProp( pCrv) ;
// porto le curve in globale
for ( auto pCrv : lstPC)
pCrv->ToGlob( frGlob) ;
// ritorno
return true ;
}
// --- se superficie
else if ( pGObj->GetType() == SRF_TRIMESH) {
// recupero la trimesh
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
if ( pSurf == nullptr)
return false ;
// recupero l'indice della faccia
int nFacet = ( ( Id.nSub == SEL_SUB_ALL) ? 0 : Id.nSub) ;
// recupero i contorni della faccia
POLYLINEVECTOR vPL ;
pSurf->GetFacetLoops( nFacet, vPL) ;
if ( vPL.empty())
return false ;
// per ogni loop recupero le curve composite
ICURVEPLIST lstCrvLoops ;
for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
pCrvCompo->FromPolyLine( vPL[i]) ;
if ( ! pCrvCompo->IsValid())
return false ;
// reset proprietà temporanee
ResetCurveAllTempProp( pCrvCompo) ;
// determino eventuali lati aperti e aggiorno proprietà del contorno
int nInd = 0 ;
double dPar ;
bool bFound = vPL[i].GetFirstU( dPar, true) ;
while ( bFound) {
// recupero il flag
int nFlag = int( dPar) ;
// se non c'è nulla di adiacente, lato aperto
if ( nFlag == SVT_NULL)
pCrvCompo->SetCurveTempProp( nInd, TEMP_PROP_OPEN_EDGE) ;
// altrimenti verifico se la faccia adiacente forma diedro convesso o concavo
else {
bool bAdjac ;
Point3d ptP1, ptP2 ;
double dAng ;
if ( ! pSurf->GetFacetsContact( nFacet, nFlag, bAdjac, ptP1, ptP2, dAng))
dAng = - ANG_RIGHT ;
if ( dAng > - EPS_ANG_SMALL)
pCrvCompo->SetCurveTempProp( nInd, TEMP_PROP_OPEN_EDGE) ;
}
// passo al successivo
++ nInd ;
bFound = vPL[i].GetNextU( dPar, true) ;
}
// recupero la normale esterna della faccia
Vector3d vtN ;
if ( ! pSurf->GetFacetNormal( nFacet, vtN))
return false ;
// assegno l'estrusione dalla normale alla faccia
pCrvCompo->SetExtrusion( vtN) ;
// unisco le eventuali parti allineate
pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
// la porto in globale
pCrvCompo->ToGlob( frGlob) ;
// sistemazioni varie
AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, {}, 0) ;
// la restituisco
if ( m_bAllClose)
ResetCurveAllTempProp( pCrvCompo) ;
lstCrvLoops.emplace_back( Release( pCrvCompo)) ;
}
// aggiusto la topologia della faccia
AdjustCurvesByStmTopology( pSurf, frGlob, ( pStmTrim == nullptr ? pStmRaw : pStmTrim), lstCrvLoops) ;
for ( auto& pCrv : lstCrvLoops)
lstPC.emplace_back( pCrv) ;
return true ;
}
// --- se regione piana
else if ( pGObj->GetType() == SRF_FLATRGN) {
// recupero la regione
const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
if ( pReg == nullptr)
return false ;
// recupero la normale della regione
Vector3d vtN = pReg->GetNormVersor() ;
if ( vtN.IsSmall())
return false ;
// determino intervallo di chunk
int nCstart = 0 ;
int nCend = pReg->GetChunkCount() ;
if ( Id.nSub != SEL_SUB_ALL) {
nCstart = Id.nSub ;
nCend = nCstart + 1 ;
}
// ciclo sui chunk
for ( int nC = nCstart ; nC < nCend ; ++ nC) {
// recupero i contorni del chunk
for ( int nL = 0 ; nL < pReg->GetLoopCount( nC) ; ++ nL) {
PtrOwner<ICurveComposite> pCrvCompo ;
if ( ! pCrvCompo.Set( ConvertCurveToComposite( pReg->GetLoop( nC, nL))))
return false ;
// reset proprietà temporanee
ResetCurveAllTempProp( pCrvCompo) ;
// assegno l'estrusione dalla normale alla regione
pCrvCompo->SetExtrusion( vtN) ;
// unisco le eventuali parti allineate
pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
// la porto in globale
pCrvCompo->ToGlob( frGlob) ;
// sistemazioni varie
AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, {}, 0) ;
// la restituisco
lstPC.emplace_back( Release( pCrvCompo)) ;
}
}
return true ;
}
// -- altrimenti errore
else
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::SetCurveAllTempProp( int nCrvId, bool bForcedClose, ICurve* pCurve, bool* pbSomeOpen)
{
if ( pCurve == nullptr)
return false ;
if ( pbSomeOpen != nullptr)
*pbSomeOpen = false ;
// reset proprietà temporanee
ResetCurveAllTempProp( pCurve) ;
if ( m_bAllClose)
return true ;
// se forzato chiuso o non presenti info per lati aperti, esco
if ( bForcedClose || ! m_pGeomDB->ExistsInfo( nCrvId, KEY_OPEN))
return true ;
// recupero info sui lati aperti
INTVECTOR vOpen ;
m_pGeomDB->GetInfo( nCrvId, KEY_OPEN, vOpen) ;
// se curva composita
ICurveComposite* pCC = GetCurveComposite( pCurve) ;
if ( pCC != nullptr) {
for ( int j : vOpen) {
if ( pCC->SetCurveTempProp( j, 1)) {
if ( pbSomeOpen != nullptr)
*pbSomeOpen = true ;
}
}
}
// altrimenti
else {
if ( ! vOpen.empty() && vOpen[0] == 0) {
pCurve->SetTempProp( 1) ;
if ( pbSomeOpen != nullptr)
*pbSomeOpen = true ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::SetSfrLoopsAllTempProp( int nSfrId, ISurfFlatRegion* pSfr)
{
if ( pSfr == nullptr)
return false ;
pSfr->SetTempProp( TEMP_PROP_INVALID, 0) ;
pSfr->SetTempProp( TEMP_PROP_INVALID, 1) ;
// recupero le info per lati aperti
int nCount = -1 ;
while ( m_pGeomDB->ExistsInfo( nSfrId, KEY_OPEN + ToString( ++ nCount))) {
// recupero info sui lati aperti
INTVECTOR vOpen ;
m_pGeomDB->GetInfo( nSfrId, KEY_OPEN + ToString( nCount), vOpen) ;
// se non ho lati aperti, passo al loop successivo
if ( vOpen.empty())
continue ;
// assegno le proprietà di lato aperto
for ( int i = 0 ; i < pSfr->GetLoopCurveCount( 0, nCount) ; ++ i) {
pSfr->SetCurveTempProp( 0, nCount, i, TEMP_PROP_CLOSE_EDGE, 0) ;
pSfr->SetCurveTempProp( 0, nCount, i, TEMP_PROP_INVALID, 1) ;
}
for ( int i : vOpen)
pSfr->SetCurveTempProp( 0, nCount, i, TEMP_PROP_OPEN_EDGE, 0) ;
} ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::ResetCurveAllTempProp( ICurve* pCurve)
{
if ( pCurve == nullptr)
return false ;
pCurve->SetTempProp( 0) ;
ICurveComposite* pCC = GetCurveComposite( pCurve) ;
if ( pCC != nullptr) {
for ( int i = 0 ; i < pCC->GetCurveCount() ; ++ i)
pCC->SetCurveTempProp( i, TEMP_PROP_CLOSE_EDGE) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::Chain( int nGrpDestId)
{
// flag per imposizione lati chiusi
m_bAllClose = GetForcedClosed() ;
// recupero il grezzo in globale
PtrOwner<ISurfTriMesh> pStmRaw( GetRaw()) ;
if ( IsNull( pStmRaw) || ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0) {
m_pMchMgr->SetLastError( 2436, "Error in PocketingNT : not valid Raw") ;
return false ;
}
// recupero la superficie di Trim in globale [nullptr se non presente]
PtrOwner<ISurfTriMesh> pStmTrim( GetStmTrim()) ;
// struct per informazioni da salvare sul gruppo Aux come su chiave KEY_IDS
struct InfoCrvSel {
Point3d ptOnCrv ; // per determinare a quale curva si riferisce nella regione piana
bool bFound ; // per ottimizzare la ricerca
SELVECTOR vIds ; // SELVECTOR originario
InfoCrvSel( const Point3d& ptOC, const SELVECTOR& vI)
: ptOnCrv( ptOC), bFound( false), vIds( vI) {} ;
} ;
vector<InfoCrvSel> vInfoCrvSel ;
// vettore puntatori e selettori alle curve
ICURVEPOVECTOR vpCrvs ; vpCrvs.reserve( m_vId.size()) ;
SELVECTOR vInds ; vInds.reserve( m_vId.size()) ;
// recupero tutte le curve e le porto in globale
for ( const SelData& Id : m_vId) {
// prendo le curve
ICURVEPLIST lstPC ;
if ( ! GetCurves( Id, pStmRaw, pStmTrim, lstPC)) {
string sInfo = "Warning in PocketingNT : Skipped entity " + ToString( Id) ;
m_pMchMgr->SetWarning( 2451, sInfo) ;
}
for ( auto pCrv : lstPC) {
vpCrvs.emplace_back( pCrv) ;
vInds.emplace_back( Id) ;
}
}
// preparo i dati per il concatenamento
bool bFirst = true ;
Point3d ptNear = ORIG ;
double dToler = 10. * EPS_SMALL ;
ChainCurves chainC ;
chainC.Init( true, dToler, ssize( vpCrvs)) ;
for ( int i = 0 ; i < ssize( vpCrvs) ; ++ 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( 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 e definisco la regione piana di svuotatura
ICRVCOMPOPOVECTOR vCrvCompo ;
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 ( int i = 0 ; i < ssize( vnId2) ; ++ i) {
int nId = abs( vnId2[i]) - 1 ;
bool bInvert = ( vnId2[i] < 0) ;
vId2.emplace_back( vInds[nId]) ;
// recupero la curva
ICurve* pCrv = vpCrvs[nId] ;
// se necessario, la inverto
if ( bInvert)
pCrv->Invert() ;
// recupero eventuali estrusione e spessore
Vector3d vtTemp ;
if ( pCrv->GetExtrusion( vtTemp)) {
vtExtr = vtTemp ;
double dTemp ;
if ( pCrv->GetThickness( dTemp) && abs( dTemp) > abs( dThick))
dThick = dTemp ;
}
// la aggiungo alla curva composta
if ( ! pCrvCompo->AddCurve( ::Release( vpCrvs[nId]), true, dToler))
return false ;
}
// se non sono state inserite curve, vado oltre
if ( pCrvCompo->GetCurveCount() == 0)
continue ;
// se la curva non è chiusa, errore
if ( ! pCrvCompo->IsClosed()) {
m_pMchMgr->SetLastError( 2402, "Error in PocketingNT : Open Contour") ;
return false ;
}
// imposto estrusione e spessore
pCrvCompo->SetExtrusion( vtExtr) ;
pCrvCompo->SetThickness( dThick) ;
// verifico sia piana e se necessario la appiattisco
PtrOwner<ICurve> pFlatCrv( FlattenCurve( *pCrvCompo, 50 * EPS_SMALL, 50 * EPS_ANG_SMALL, FLTCRV_USE_EXTR)) ;
if ( IsNull( pFlatCrv)) {
Plane3d plPlane ;
if ( ! pCrvCompo->IsFlat( plPlane, true, 50 * EPS_SMALL))
m_pMchMgr->SetLastError( 2403, "Error in PocketingNT : Contour Not Flat") ;
else
m_pMchMgr->SetLastError( 2404, "Error in PocketingNT : Tool Not Perpendicular to Flat Area") ;
return false ;
}
pFlatCrv->GetExtrusion( vtExtr) ;
pCrvCompo->Clear() ;
pCrvCompo->AddCurve( Release( pFlatCrv)) ;
// salvo vettore estrusione
pCrvCompo->SetExtrusion( vtExtr) ;
// salvo la thickness come seconda temp prop ( la Sfr rimuove la thick delle curve)
pCrvCompo->SetTempParam( dThick, 1) ;
// aggiorno il nuovo punto vicino
pCrvCompo->GetEndPoint( ptNear) ;
// se utile, approssimo con archi
if ( ! ApproxWithArcsIfUseful( pCrvCompo, true))
return false ;
// inserisco la curva nella regione piana
vCrvCompo.emplace_back( Release( pCrvCompo)) ;
// salvo vettore estrusione
vCrvCompo.back()->SetExtrusion( vtExtr) ;
// salvo la thickness come seconda temp prop ( la Sfr rimuove la thick delle curve)
vCrvCompo.back()->SetTempParam( dThick, 1) ;
// salvo le Info della curva corrente
Point3d ptStart ; vCrvCompo.back()->GetStartPoint( ptStart) ;
vInfoCrvSel.emplace_back( ptStart, vId2) ;
}
// ordino le curve creando una regione piana
SurfFlatRegionByContours SfrByC ;
for ( int i = 0 ; i < ssize( vCrvCompo) ; ++ i) {
// memorizzo la Thickness nei TempParams
vCrvCompo[i]->SetTempParam( vCrvCompo[i]->GetTempParam( 1), 1) ;
SfrByC.AddCurve( Release( vCrvCompo[i])) ;
}
// scorro le regioni piane ricavate dalle curve
int nGroupName = 0 ;
PtrOwner<ISurfFlatRegion> pSfrCurr( SfrByC.GetSurf()) ;
while ( ! IsNull( pSfrCurr) && pSfrCurr->IsValid()) {
// per ogni Chunk
for ( int nC = 0 ; nC < pSfrCurr->GetChunkCount() ; ++ nC) {
// 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( ++ nGroupName)) ;
// recupero il Chunk corrente
PtrOwner<ISurfFlatRegion> pSfrChunk( pSfrCurr->CloneChunk( nC)) ;
if ( IsNull( pSfrChunk) || ! pSfrChunk->IsValid())
return false ;
// recupero la Thickness e l'Estrusione dal Loop esterno
PtrOwner<ICurveComposite> pCrvInfo( ConvertCurveToComposite( pSfrChunk->GetLoop( 0, 0))) ;
if ( IsNull( pCrvInfo) || ! pCrvInfo->IsValid())
return false ;
double dThick = pCrvInfo->GetTempParam( 1) ;
Vector3d vtExtr ; pCrvInfo->GetExtrusion( vtExtr) ;
// assegno come proprietà del gruppo le Info di selezione delle entità selezionate originarie
string sInfo ;
for ( int nInfo = 0 ; nInfo < ssize( vInfoCrvSel) ; ++ nInfo) {
if ( ! vInfoCrvSel[nInfo].bFound) {
if ( pCrvInfo->IsPointOn( vInfoCrvSel[nInfo].ptOnCrv, 5. * EPS_SMALL)) {
sInfo += ToString( vInfoCrvSel[nInfo].vIds) ;
vInfoCrvSel[nInfo].bFound = true ;
}
}
}
for ( int nL = 1 ; nL < pSfrChunk->GetLoopCount( 0) ; ++ nL) {
PtrOwner<ICurve> pCrvLoop( pSfrChunk->GetLoop( 0, nL)) ;
if ( IsNull( pCrvLoop) || ! pCrvLoop->IsValid())
continue ;
for ( int nInfo = 0 ; nInfo < ssize( vInfoCrvSel) ; ++ nInfo) {
if ( ! vInfoCrvSel[nInfo].bFound) {
if ( pCrvLoop->IsPointOn( vInfoCrvSel[nInfo].ptOnCrv, 5. * EPS_SMALL)) {
sInfo += ToString( vInfoCrvSel[nInfo].vIds) ;
vInfoCrvSel[nInfo].bFound = true ;
}
}
}
}
m_pGeomDB->SetInfo( nPathId, KEY_IDS, sInfo) ;
// -------------- Verifico quale part del Grezzo bisogna considerare ----------------
if ( ! ChooseRawPart( pSfrChunk, ( pStmTrim == nullptr ? pStmRaw : pStmTrim))) {
m_pMchMgr->SetLastError( 2436, "Error in PocketingNT : not valid Raw") ;
return false ;
}
// -------------- Controllo esistenza di lati aperti interni al grezzo --------------
// Questi lati vengono Offsettati, raccordati e considerati poi come chiusi
if ( ! ManageOpenEdges( pSfrChunk, ( pStmTrim == nullptr ? pStmRaw : pStmTrim))) {
m_pMchMgr->SetLastError( 2434, "Error in PocketingNT : Managing Open Edges inside Part failed") ;
return false ;
}
// ------------- Estendo i lati aperti sul bordo per possibili proiezioni -------------
if ( ! ExtendOpenEdges( pSfrChunk, ( pStmTrim == nullptr ? pStmRaw : pStmTrim))) {
m_pMchMgr->SetLastError( 2435, "Error in PocketingNT : Managing Open Edges on Raw failed") ;
return false ;
}
// scorro i suoi Loop
int nNewId = GDB_ID_NULL ;
for ( int nL = 0 ; nL < pSfrChunk->GetLoopCount( 0) ; ++ nL) {
// recupero il Loop
PtrOwner<ICurveComposite> pCrvLoop( CreateCurveComposite()) ;
if ( IsNull( pCrvLoop) ||
! pCrvLoop.Set( ConvertCurveToComposite( pSfrChunk->GetLoop( 0, nL))) ||
! pCrvLoop->IsValid())
return false ;
// se loop esterno, aggiungo la superfifice al gruppo con le relative informazioni
if ( nL == 0) {
nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::CloneSurfFlatRegion( pSfrChunk)) ;
if ( nNewId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetInfo( nNewId, KEY_THICK, dThick) ;
m_pGeomDB->SetInfo( nNewId, KEY_EXTR, vtExtr) ;
}
// memorizzo le proprietà di lato aperto nelle Info del gruppo
INTVECTOR vIndOpen ;
for ( int nU = 0 ; nU < pCrvLoop->GetCurveCount() ; ++ nU) {
int nTmpProp0 = TEMP_PROP_INVALID ;
if ( pCrvLoop->GetCurveTempProp( nU, nTmpProp0, 0) && nTmpProp0 == TEMP_PROP_OPEN_EDGE)
vIndOpen.emplace_back( nU) ;
}
if ( ! vIndOpen.empty())
m_pGeomDB->SetInfo( nNewId, KEY_OPEN + ToString( nL), vIndOpen) ;
}
}
// aggiorno la regione piana con la successiva calcolata
pSfrCurr.Set( SfrByC.GetSurf()) ;
}
return true ;
}
//----------------------------------------------------------------------------
ISurfTriMesh*
PocketingNT::GetRaw( void)
{
// controllo MachManager e database geometrico
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
return nullptr ;
// creo Stm del grezzo
PtrOwner<ISurfTriMesh> pStmRaw( CreateSurfTriMesh()) ;
if ( IsNull( pStmRaw))
return nullptr ;
pStmRaw->AdjustTopology() ;
// Id prima RawPart
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
// verifico che il grezzo compaia nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
// recupero l'oggetto dal database con tale Id
int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nRawSolidId) ;
if ( pGObj == nullptr)
return nullptr ;
// recupero il frame in cui si trova
Frame3d frRaw ;
m_pGeomDB->GetGlobFrame( nRawSolidId, frRaw) ;
// controllo che sia una Trimesh
if ( pGObj->GetType() == SRF_TRIMESH) {
SurfLocal StmRawPart( GetSurfTriMesh( pGObj), frRaw, GLOB_FRM) ;
// lo aggiungo alla Trimesh complessiva
pStmRaw->Add( *GetSurfTriMesh( StmRawPart)) ;
}
}
// passo al grezzo successivo
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
return ( ( pStmRaw->IsValid() && pStmRaw->GetTriangleCount() > 0) ? Release( pStmRaw) : nullptr) ;
}
//----------------------------------------------------------------------------
ISurfTriMesh*
PocketingNT::GetStmTrim( void)
{
// controllo se è presente una superficie di Trim
int nStmTrimId = GDB_ID_NULL ;
if ( ! GetValInNotes( m_Params.m_sUserNotes, UN_TRIMEXT, nStmTrimId))
return nullptr ;
// creo Stm della superficie di Trim
PtrOwner<ISurfTriMesh> pStmTrim( CreateSurfTriMesh()) ;
if ( IsNull( pStmTrim))
return nullptr ;
pStmTrim->AdjustTopology() ;
// recupero l'oggetto geometrico
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nStmTrimId) ;
if ( pGObj == nullptr)
return nullptr ;
// controllo che sia una superficie TriMesh
if ( pGObj->GetType() != SRF_TRIMESH)
return nullptr ;
// ne recupero il riferimento globale
Frame3d frGlob ;
if ( ! m_pGeomDB->GetGlobFrame( nStmTrimId, frGlob))
return nullptr ;
// recupero la TriMesh di Trim
SurfLocal StmRawPart( GetSurfTriMesh( pGObj), frGlob, GLOB_FRM) ;
pStmTrim->Add( *GetSurfTriMesh( StmRawPart)) ;
return ( ( pStmTrim->IsValid() && pStmTrim->GetTriangleCount() > 0) ? Release( pStmTrim) : nullptr) ;
}
//----------------------------------------------------------------------------
ISurfTriMesh*
PocketingNT::GetExtrusionStm( const ISurfFlatRegion* pSfr, const Vector3d& vtExtr)
{
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid())
return nullptr ;
/*
pSfr -> superficie da cui estrudere i lati chiusi
vtExtrs -> vettore estrusione dei lati chiusi di pSfr
*/
PtrOwner<ISurfFlatRegion> pMySfr( CloneSurfFlatRegion( pSfr)) ;
if ( IsNull( pMySfr) || ! pMySfr->IsValid())
return nullptr ;
// zuppa di triangoli
StmFromTriangleSoup stmSoup ;
stmSoup.Start() ;
// scorro i Loop della superficie piana
bool bExistClose = false ;
for ( int nC = 0 ; nC < pMySfr->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pMySfr->GetLoopCount( nC) ; ++ nL) {
// recupero il Loop come curva composita
PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pMySfr->GetLoop( nC, nL))) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->IsValid())
return nullptr ;
// recupero i tratti con proprietà uniformi
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! GetHomogeneousParts( pCompoLoop, vpCrvs))
return nullptr ;
// scorro i tratti omogenei chiusi
for ( int nP = 0 ; nP < int( vpCrvs.size()) ; ++ nP) {
if ( vpCrvs[nP]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) {
// approssimo la curva ad una PolyLine
PolyLine PL ;
vpCrvs[nP]->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL) ;
// estrusione del tratto chiuso
PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
if ( IsNull( pStm) ||
! pStm->AdjustTopology() ||
! pStm->CreateByExtrusion( PL, vtExtr))
return nullptr ;
// aggiungo i triangoli ricavati alla zuppa
if ( ! IsNull( pStm) && pStm->IsValid()) {
for ( int nT = 0 ; nT < pStm->GetTriangleCount() ; ++ nT) {
Triangle3d myTria ; pStm->GetTriangle( nT, myTria) ;
stmSoup.AddTriangle( myTria) ;
}
bExistClose = true ;
}
}
}
}
}
// inizializzo la superficie di estrusione
PtrOwner<ISurfTriMesh> pStmExtrusion( CreateSurfTriMesh()) ;
if ( IsNull( pStmExtrusion))
return nullptr ;
pStmExtrusion->AdjustTopology() ;
stmSoup.End() ;
if ( bExistClose) {
pStmExtrusion.Set( stmSoup.GetSurf()) ;
if ( IsNull( pStmExtrusion))
return nullptr ;
return ( ( pStmExtrusion->IsValid() && pStmExtrusion->GetTriangleCount() > 0) ? Release( pStmExtrusion) : nullptr) ;
}
return ( Release( pStmExtrusion)) ;
}
//----------------------------------------------------------------------------
ISurfFlatRegion*
PocketingNT::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs)
{
// interseco la superficie alla quota corrente
PNTVECTOR vPnt ;
BIPNTVECTOR vBpt ;
TRIA3DVECTOR vTria ;
if ( ! IPPStm.GetInters( dDist, vPnt, vBpt, vTria))
return nullptr ;
// se non c'è intersezione
if ( vBpt.empty())
return CreateSurfFlatRegion() ;
// definisco la tolleranza per i concatenamenti
double dToler = EPS_SMALL ;
// costruisco la FlatRegion da ritornare
SurfFlatRegionByContours SfrByC ;
// Considero l'intersezione solo con Curve ( escludo punti e superfici)
ChainCurves chainC ;
chainC.Init( false, dToler, int( vBpt.size())) ;
for ( int i = 0 ; i < int( vBpt.size()) ; ++ i) {
Vector3d vtDir = vBpt[i].second - vBpt[i].first ;
vtDir.Normalize() ;
if ( ! chainC.AddCurve( i + 1, vBpt[i].first, vtDir, vBpt[i].second, vtDir))
return nullptr ;
}
// recupero i percorsi concatenati
Point3d ptNear = ( vBpt.empty() ? ORIG : vBpt[0].first) ;
INTVECTOR vId ;
while ( chainC.GetChainFromNear( ptNear, false, vId)) {
// creo una curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return nullptr ;
// recupero gli estremi dei segmenti, creo le linee e le inserisco nella composita
bool bAdded = true ;
for ( int i = 0 ; i < int( vId.size()) ; ++ i) {
// creo un segmento di retta
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
if ( IsNull( pLine))
return nullptr ;
// recupero gli estremi ( non vanno mai invertiti per opzione di concatenamento)
int nInd = abs( vId[i]) - 1 ;
Point3d ptStart = ( bAdded ? vBpt[nInd].first : ptNear) ;
Point3d ptEnd = vBpt[nInd].second ;
// provo ad accodarlo alla composita
bAdded = ( Dist( ptStart, ptEnd) > dToler / 2 &&
pLine->Set( ptStart, ptEnd) &&
pCrvCompo->AddCurve( Release( pLine), true, dToler)) ;
ptNear = ( bAdded ? ptEnd : ptStart) ;
}
// se lunghezza curva inferiore a 5 volte la tolleranza, la ignoro
double dCrvLen ;
if ( ! pCrvCompo->GetLength( dCrvLen) || dCrvLen < 5. * dToler)
continue ;
// se curva chiusa entro 5 volte la tolleranza ma considerata aperta, la chiudo bene
Point3d ptStart, ptEnd ;
if ( pCrvCompo->GetStartPoint( ptStart) &&
pCrvCompo->GetEndPoint( ptEnd) &&
AreSamePointEpsilon( ptStart, ptEnd, 5. * dToler) &&
! AreSamePointApprox( ptStart, ptEnd)) {
// porto il punto finale a coincidere esattamente con l'inizio
pCrvCompo->ModifyEnd( ptStart) ;
}
// unisco segmenti allineati
pCrvCompo->MergeCurves( 0.5 * dToler, ANG_TOL_STD_DEG) ;
pCrvCompo->Close() ; // per sicurezza...
// inserisco la curva nella FlatRegion
SfrByC.AddCurve( Release( pCrvCompo)) ;
}
// recupero la regione da restituire
PtrOwner<ISurfFlatRegion> pSfrFromCrvs( SfrByC.GetSurf()) ;
return ( ( ! IsNull( pSfrFromCrvs) && pSfrFromCrvs->IsValid()) ? Release( pSfrFromCrvs) : nullptr) ;
}
//----------------------------------------------------------------------------
ISurfFlatRegion*
PocketingNT::GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr,
const Vector3d& vtTool)
{
// controllo dei parametri
if ( pStmRaw == nullptr || ! pStmRaw->IsValid() ||
pSfr == nullptr || ! pSfr->IsValid())
return nullptr ;
// recupero il piano di taglio dalla regione piana
Point3d ptCen ; pSfr->GetCentroid( ptCen) ;
Plane3d plProj ;
if ( ! plProj.Set( ptCen, vtTool))
return nullptr ;
// recupero la Silhouette al piano trovato
POLYLINEVECTOR vPL ;
if ( ! pStmRaw->GetSilhouette( plProj, EPS_SMALL, vPL))
return nullptr ;
// se non trovo nessun contorno sono fuori dal grezzo, la superficie è vuota
if ( vPL.empty())
return ( CreateSurfFlatRegion()) ;
// costruisco la regione piana
SurfFlatRegionByContours SfrByC ;
for ( const PolyLine& PL : vPL) {
PtrOwner<ICurveComposite> pCrvLoop( CreateCurveComposite()) ;
if ( IsNull( pCrvLoop) || ! pCrvLoop->FromPolyLine( PL))
return nullptr ;
SfrByC.AddCurve( Release( pCrvLoop)) ;
}
PtrOwner<ISurfFlatRegion> pSfrRaw( SfrByC.GetSurf()) ;
if ( IsNull( pSfrRaw) || ! pSfrRaw->IsValid())
return nullptr ;
if ( AreOppositeVectorApprox( pSfrRaw->GetNormVersor(), vtTool))
pSfrRaw->Invert() ;
return Release( pSfrRaw) ;
}
//----------------------------------------------------------------------------
Point3d
PocketingNT::GetStartPointsByHead( const STEPINFOPOVECTOR& vStepInfo) const
{
// se non ho step, allora non ho un punto di riferimento
if ( vStepInfo.empty())
return P_INVALID ;
// sull'ultimo Step ( quindi sulla geometria più simile a quella originaria) cerco il tratto aperto più lungo
// ( inteso come media tra gli aperti sui Chunks)
// recupero la prima regione valida a partire dalla più profonda
auto it = vStepInfo.rbegin() ;
for ( ; it != vStepInfo.rend() ; ++ it) {
if ( ( *it).pSfrPock != nullptr && ( *it).pSfrPock->IsValid() &&
( *it).pSfrPock->GetChunkCount() > 0)
break ;
}
// recupero la regione
const ISurfFlatRegion* pSfr = ( *it).pSfrPock ;
if ( pSfr == nullptr || ! pSfr->IsValid() || pSfr->GetChunkCount() == 0)
return P_INVALID ;
#if DEBUG_START_POINT // rimuovi "const" nella dichiarazione della funzione
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "Start_Point") ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
DebugDrawSfr( pSfr, false, nLay) ;
#endif
// se la normale della regione è circa Z+ o Z- non devo fare nulla
if ( AreSameOrOppositeVectorApprox( pSfr->GetNormVersor(), Z_AX))
return P_INVALID ;
// dichiaro il nuovo punto per la possibile entrata
double dZGlob = ( m_bAboveHead ? - INFINITO : INFINITO) ;
Point3d ptRef = P_INVALID ;
// controllo se sono presenti dei lati aperti
vector<tuple<int, int, int, double, double>> vIndCrv ;
for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
// recupero il Loop
PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->IsValid())
return P_INVALID ;
// verifico se la curva è tutta chiusa
ICRVCOMPOPOVECTOR vpCrvs ;
bool bClosePock = ( GetHomogeneousParts( pCompoLoop, vpCrvs) &&
ssize( vpCrvs) == 1 && vpCrvs[0]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) ;
// scorro le sue curve
for ( int nU = 0 ; nU < pCompoLoop->GetCurveCount() ; ++ nU) {
const ICurve* pCrv = pCompoLoop->GetCurve( nU) ;
if ( pCrv == nullptr || ! pCrv->IsValid())
return P_INVALID ;
// scorro il lato corrente ( in generale aperto, chiuso solo se bordo tutto chiuso)
if ( pCrv->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE || bClosePock) {
// calcolo il Box globale della curva e memorizzo la componente Z ( media)
BBox3d BBoxGlob ;
if ( pCrv->GetLocalBBox( BBoxGlob)) {
// se testa da sopra
if ( m_bAboveHead) {
if ( BBoxGlob.GetMax().z > dZGlob + 10. * EPS_SMALL) {
dZGlob = BBoxGlob.GetMax().z ;
vIndCrv.clear() ;
vIndCrv.emplace_back( make_tuple( nC, nL, nU, BBoxGlob.GetMin().z, BBoxGlob.GetMax().z)) ;
}
else if ( BBoxGlob.GetMax().z > dZGlob - 10. * EPS_SMALL)
vIndCrv.emplace_back( make_tuple( nC, nL, nU, BBoxGlob.GetMin().z, BBoxGlob.GetMax().z)) ;
}
// se testa da sotto
else {
if ( BBoxGlob.GetMin().z < dZGlob - 10. * EPS_SMALL) {
dZGlob = BBoxGlob.GetMin().z ;
vIndCrv.clear() ;
vIndCrv.emplace_back( make_tuple( nC, nL, nU, BBoxGlob.GetMin().z, BBoxGlob.GetMax().z)) ;
}
else if ( BBoxGlob.GetMin().z < dZGlob + 10. * EPS_SMALL)
vIndCrv.emplace_back( make_tuple( nC, nL, nU, BBoxGlob.GetMin().z, BBoxGlob.GetMax().z)) ;
}
}
}
}
}
}
#if DEBUG_START_POINT
for ( int _i = 0 ; _i < ssize( vIndCrv) ; ++ _i) {
const ICurveComposite* _pCompo = ConvertCurveToComposite( pSfr->GetLoop( get<0>( vIndCrv[_i]), get<1>( vIndCrv[_i]))) ;
const ICurve* _pCurve = _pCompo->GetCurve( get<2>( vIndCrv[_i])) ;
int _nCrv = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, _pCurve->Clone()) ;
m_pGeomDB->SetMaterial( _nCrv, YELLOW) ;
}
#endif
// se non ho candidate, verifico se la tasca è tutta chiusa ( dato che un aperto disponibile per l'entrata non è stato trovato)
if ( vIndCrv.empty())
return P_INVALID ;
int nChunk = 0, nLoop = 0, nCurve = 0 ;
// se una sola candidata allora il punto è quello
if ( ssize( vIndCrv) == 1) {
nChunk = get<0>( vIndCrv[0]) ;
nLoop = get<1>( vIndCrv[0]) ;
nCurve = get<2>( vIndCrv[0]) ;
}
else {
int nIndTuple = 0 ;
double dZMin = - INFINITO, dZMax = + INFINITO ;
for ( int i = 0 ; i < ssize( vIndCrv) ; ++ i) {
// se testa da sopra
if ( m_bAboveHead) {
// scelgo la curva con Zmin massima
if ( get<3>( vIndCrv[i]) > dZMin) {
dZMin = get<3>( vIndCrv[i]) ;
nIndTuple = i ;
}
}
// se testa da sotto
else {
// scelgo la curva con ZMax minima
if ( get<4>( vIndCrv[i]) < dZMax) {
dZMax = get<4>( vIndCrv[i]) ;
nIndTuple = i ;
}
}
}
nChunk = get<0>( vIndCrv[nIndTuple]) ;
nLoop = get<1>( vIndCrv[nIndTuple]) ;
nCurve = get<2>( vIndCrv[nIndTuple]) ;
}
// Verifico se effettivamente l'utensile può entrare da quella sottocurva
PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nChunk, nLoop))) ;
if ( pCompoLoop == nullptr || ! pCompoLoop->IsValid())
return P_INVALID ;
const ICurve* pCurveRef = pCompoLoop->GetCurve( nCurve) ;
if ( pCurveRef == nullptr || ! pCurveRef->IsValid())
return P_INVALID ;
// il punto di riferimento per ora è il punto medio ( se i lati aperti sono segmenti va bene...)
pCurveRef->GetMidPoint( ptRef) ;
#if DEBUG_START_POINT
IGeoPoint3d* _ptRef = CreateGeoPoint3d() ; _ptRef->Set( ptRef) ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, _ptRef) ;
m_pGeomDB->SetMaterial( nLay, YELLOW) ;
#endif
double dToTLen = 0 ;
pCurveRef->GetLength( dToTLen) ;
if ( dToTLen > m_TParams.m_dDiam + GetOffsR())
return ptRef ;
// verifico se i tratti adiacenti permettono comunque una possibile entrata
int nToTCurves = pCompoLoop->GetCurveCount() ;
if ( nToTCurves == 1)
return ptRef ;
else {
const ICurve* pCurvePrev = pCompoLoop->GetCurve( ( nCurve - 1 + nToTCurves) % nToTCurves) ;
if ( pCurvePrev != nullptr && pCurvePrev->IsValid() && pCurvePrev->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
double dLenPrev ; pCurvePrev->GetLength( dLenPrev) ;
Vector3d vtPrevEnd ; pCurvePrev->GetEndDir( vtPrevEnd) ;
Vector3d vtStart ; pCurveRef->GetStartDir( vtStart) ;
dToTLen += max( 0.4, vtPrevEnd * vtStart) * dLenPrev ;
}
if ( dToTLen > m_TParams.m_dDiam + GetOffsR())
return ptRef ;
if ( nToTCurves > 2) {
const ICurve* pCurveNext = pCompoLoop->GetCurve( ( nCurve + 1 + nToTCurves) % nToTCurves) ;
if ( pCurveNext != nullptr && pCurveNext->IsValid() &&
pCurveNext->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
double dLenNext ; pCurveNext->GetLength( dLenNext) ;
Vector3d vtEnd ; pCurveRef->GetEndDir( vtEnd) ;
Vector3d vtNextStart ; pCurveNext->GetStartDir( vtNextStart) ;
dToTLen += max( 0.4, vtEnd * vtNextStart) * dLenNext ;
}
if ( dToTLen > m_TParams.m_dDiam + GetOffsR())
return ptRef ;
}
}
// potrei cercarne un altro... se serve migliorare...
return P_INVALID ;
}
//----------------------------------------------------------------------------
Point3d
PocketingNT::GetStartPointsFromSteps( const STEPINFOPOVECTOR& vStepInfo, int nCrvType) const
{
// se non ho step, allora non ho un punto di riferimento
if ( vStepInfo.empty())
return P_INVALID ;
// sull'ultimo Step ( quindi sulla geometria più simile a quella originaria) cerco il tratto aperto più lungo
// ( inteso come media tra gli aperti sui Chunks)
// recupero la prima regione valida a partire dalla più profonda
auto it = vStepInfo.rbegin() ;
for ( ; it != vStepInfo.rend() ; ++ it) {
if ( ( *it).pSfrPock != nullptr && ( *it).pSfrPock->IsValid() &&
( *it).pSfrPock->GetChunkCount() > 0)
break ;
}
// recupero la regione
const ISurfFlatRegion* pSfr = ( *it).pSfrPock ;
if ( pSfr == nullptr || ! pSfr->IsValid() || pSfr->GetChunkCount() == 0)
return P_INVALID ;
#if DEBUG_START_POINT // rimuovi "const" nella dichiarazione della funzione
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "Start_Point") ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
DebugDrawSfr( pSfr, false, nLay) ;
#endif
// scorro le curve
PNTVECTOR vPnts ;
for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
// recupero il loop come curva composita
PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
if ( IsNull( pCrvLoop) || ! pCrvLoop->IsValid())
continue ;
// recupero i tratti con proprietà uniformi
ICRVCOMPOPOVECTOR vpCrvs ;
GetHomogeneousParts( pCrvLoop, vpCrvs) ;
double dLenRef = 0. ;
int nIndRef = -1, nCrvRef = -1 ;
Point3d ptMid ;
// se bordo tutto aperto, allora cerco il punto medio della curva più lunga
if ( int( vpCrvs.size()) == 1 && vpCrvs[0]->GetTempProp() == TEMP_PROP_OPEN_EDGE) {
for ( int nU = 0 ; nU < vpCrvs[0]->GetCurveCount() ; ++ nU) {
double dLen = 0. ; vpCrvs[0]->GetCurve( nU)->GetLength( dLen) ;
if ( dLen > dLenRef) {
dLenRef = dLen ;
nIndRef = nU ;
}
}
if ( nIndRef == -1)
continue ;
vpCrvs[0]->GetCurve( nIndRef)->GetMidPoint( ptMid) ;
}
else {
// scorro i tratti con le proprietà richieste e cerco quello più lungo
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( vpCrvs[i]->GetTempProp() == nCrvType) {
// scorro le curve che lo compongono
for ( int j = 0 ; j < int( vpCrvs.size()) ; ++ j) {
// recupero la curva corrente
const ICurve* pCrv = vpCrvs[i]->GetCurve( j) ;
if ( pCrv != nullptr && pCrv->IsValid()) {
double dLen = 0. ; vpCrvs[i]->GetLength( dLen) ;
if ( dLen > dLenRef) {
dLenRef = dLen ;
nIndRef = i ;
nCrvRef = j ;
}
}
}
}
}
if ( nIndRef == -1 || nCrvRef == -1)
continue ;
vpCrvs[nIndRef]->GetCurve(nCrvRef)->GetMidPoint( ptMid) ;
}
#if DEBUG_START_POINT
PtrOwner<IGeoPoint3d> myPtMid( CreateGeoPoint3d()) ;
myPtMid->Set( ptMid) ;
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, myPtMid->Clone()) ;
m_pGeomDB->SetMaterial( nId, nCrvType == TEMP_PROP_CLOSE_EDGE ? AQUA : ORANGE) ;
#endif
vPnts.emplace_back( ptMid) ;
}
}
// se non ho punti allora esco
if ( vPnts.empty())
return P_INVALID ;
// recupero il punto medio
double dX = 0., dY = 0., dZ = 0. ;
for ( const Point3d& myPt : vPnts) {
dX += myPt.x ;
dY += myPt.y ;
dZ += myPt.z ;
}
Point3d ptStart = Point3d( dX / int( vPnts.size()),
dY / int( vPnts.size()),
dZ / int( vPnts.size())) ;
// proietto il punto sul primo step
ptStart.Translate( ( - ( *it).dDepth + vStepInfo.front().dDepth) * ( *it).pSfrPock->GetNormVersor()) ;
#if DEBUG_START_POINT
PtrOwner<IGeoPoint3d> myPtStart( CreateGeoPoint3d()) ;
myPtStart->Set( ptStart) ;
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, myPtStart->Clone()) ;
m_pGeomDB->SetMaterial( nId, YELLOW) ;
#endif
return ptStart ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::GetHomogeneousParts( const ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCrvs) const
{
// controllo dei parametri
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return false ;
vpCrvs.clear() ;
// scorro tutte le curve semplici nella composita
int nCurrTempProp ;
int nParStart = 0 ;
for ( int i = 0 ; i < pCrvCompo->GetCurveCount() ; ++ i) {
// ricavo la TmpProp
int nTempProp ;
pCrvCompo->GetCurveTempProp( i, nTempProp) ;
if ( i == 0) {
nCurrTempProp = nTempProp ;
nParStart = i ;
}
// se TmpProp differiscono, ricavo il tratto di curva omogeneo
else if ( nCurrTempProp != nTempProp) {
PtrOwner<ICurveComposite> pCrv( ConvertCurveToComposite( pCrvCompo->CopyParamRange( nParStart, i))) ;
if ( IsNull( pCrv))
return false ;
pCrv->SetTempProp( nCurrTempProp) ; // globale, al tratto di curva nel vettore
vpCrvs.emplace_back( Release( pCrv)) ;
nCurrTempProp = nTempProp ;
nParStart = i ;
}
}
// ultima curva...
PtrOwner<ICurveComposite> pCrvLast( ConvertCurveToComposite( pCrvCompo->CopyParamRange( nParStart, pCrvCompo->GetCurveCount()))) ;
if ( ! IsNull( pCrvLast)) {
pCrvLast->SetTempProp( nCurrTempProp) ;
vpCrvs.emplace_back( Release( pCrvLast)) ;
}
if ( vpCrvs.size() > 1) { // unisco il primo e l'ultimo se estremi compatibili
Point3d ptE ; vpCrvs.back()->GetEndPoint( ptE) ;
Point3d ptS ; vpCrvs[0]->GetStartPoint( ptS) ;
if ( AreSamePointApprox( ptS, ptE) && vpCrvs[0]->GetTempProp() == vpCrvs.back()->GetTempProp()) {
vpCrvs[0]->AddCurve( Release( vpCrvs.back()), false) ;
vpCrvs.erase( vpCrvs.end() - 1) ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::ExtendOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm)
{
/* I lati aperti vengono estesi (mediante proiezione del box di pStm tagliata da un piano definito
* da pSfr) in modo da estendere la regione di lavoro */
// controllo dei parametri
if ( pSfr == nullptr || pStm == nullptr)
return false ;
if ( ! pSfr->IsValid())
return true ;
// Se non richiesto controllo con il Grezzo, non estendo alcun lato
// ( NB. potrebbe essere scelto un unteriore parametro dalle note utenti)
int nOpenOutRaw ;
m_bOpenOutRaw = ( GetValInNotes( m_Params.m_sUserNotes, UN_OPENOUTRAW, nOpenOutRaw) && nOpenOutRaw != 0) ;
if ( m_bOpenOutRaw)
return true ;
// se la superficie non ha lati aperti, allora non devo fare nulla
bool bAllClosed = true ;
for ( int nC = 0 ; nC < pSfr->GetChunkCount() && bAllClosed ; ++ nC) {
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) && bAllClosed ; ++ nL) {
for ( int nU = 0 ; nU < pSfr->GetLoopCurveCount( nC, nL) && bAllClosed ; ++ nU) {
int nTmpProp = TEMP_PROP_INVALID ;
bAllClosed = ( pSfr->GetCurveTempProp( nC, nL, nU, nTmpProp, 0) &&
nTmpProp == TEMP_PROP_CLOSE_EDGE) ;
}
}
}
if ( bAllClosed)
return true ;
// recupero i Chunk della superficie
ISURFFRPOVECTOR vChunks( pSfr->GetChunkCount()) ;
for ( int nC = 0 ; nC < int( vChunks.size()) ; ++ nC)
vChunks[nC].Set( pSfr->CloneChunk( nC)) ;
#if DEBUG_OPEN_EDGE_EXTENSION
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay, "Open_edge_extension") ;
DebugDrawSfr( pSfr, false, nLay) ;
#endif
// clono la superficie trimesh ( devo effettuare un taglio)
PtrOwner<ISurfTriMesh> pStmCL( CloneSurfTriMesh( pStm)) ;
if ( IsNull( pStmCL) || ! pStmCL->IsValid() || pStmCL->GetTriangleCount() == 0)
return false ;
// definisco un piano di taglio per il grezzo, mediante la curva
Plane3d plCut ;
Point3d ptC ; pSfr->GetCentroid( ptC) ;
if ( ! plCut.Set( ptC, - pSfr->GetNormVersor()))
return false ;
// taglio il grezzo con il piano
if ( ! pStmCL->Cut( plCut, true))
return false ;
if ( ! pStmCL->IsValid() || pStmCL->GetTriangleCount() == 0)
return true ;
#if DEBUG_OPEN_EDGE_EXTENSION
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pStmCL->Clone()) ;
m_pGeomDB->SetMaterial( a, Color( 0.2, 0.2, 0.8, .65)) ;
#endif
// recupero il Box del grezzo definito dal frame implicito dal piano
Frame3d frCut ;
if ( ! frCut.Set( ptC, pSfr->GetNormVersor()))
return false ;
frCut.Invert() ;
BBox3d BBoxRawCut ;
if ( ! pStmCL->GetBBox( frCut, BBoxRawCut))
return false ;
#if DEBUG_OPEN_EDGE_EXTENSION
frCut.Invert() ;
DebugDrawBox( BBoxRawCut, frCut, nLay) ;
frCut.Invert() ;
#endif
// scorro i Chunk della superficie
bool bModifSfr = false ;
for ( int nC = 0 ; nC < int( vChunks.size()) ; ++ nC) {
// recupero il Loop esterno ( per ora non considero le isole)
PtrOwner<ICurveComposite> pCrvExtLoop( ConvertCurveToComposite( vChunks[nC]->GetLoop( 0, 0))) ;
if ( IsNull( pCrvExtLoop) || ! pCrvExtLoop->IsValid())
return false ;
// recupero i tratti con proprietà uniformi della superficie
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! GetHomogeneousParts( pCrvExtLoop, vpCrvs))
return false ;
// se il bordo è tutto chiuso, allora passo al prossimo Chunk
if ( int( vpCrvs.size()) == 1 && vpCrvs[0]->GetTempProp() == TEMP_PROP_CLOSE_EDGE)
continue ;
// definisco la nuova curva di bordo
PtrOwner<ICurveComposite> pCrvNewBorder( CreateCurveComposite()) ;
if ( IsNull( pCrvNewBorder))
return false ;
// definisco offset di estensione per tratti aperti
double dMaxDimBox = max( BBoxRawCut.GetDimX(), BBoxRawCut.GetDimY()) ;
double dOffs = min( 3. * m_TParams.m_dDiam, dMaxDimBox) + m_TParams.m_dDiam ;
double dOffsUser = 0. ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_PROJEXT, dOffsUser) && dOffsUser > EPS_SMALL)
dOffs = dOffsUser ;
// sostiuisco ogni tratto aperto con il suo Offset
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( vpCrvs[i]->GetTempProp() == TEMP_PROP_OPEN_EDGE) {
vpCrvs[i]->SetExtrusion( pSfr->GetNormVersor()) ;
OffsetCurve OffsCurve ;
OffsCurve.Make( vpCrvs[i], dOffs, ICurve::OFF_EXTEND) ;
PtrOwner<ICurveComposite> pCompoOpenOffs( ConvertCurveToComposite( OffsCurve.GetLongerCurve())) ;
if ( ! IsNull( pCompoOpenOffs) && pCompoOpenOffs->IsValid()) {
for ( int j = 0 ; j < pCompoOpenOffs->GetCurveCount() ; ++ j)
pCompoOpenOffs->SetCurveTempProp( j, TEMP_PROP_OPEN_EDGE, 0) ;
pCompoOpenOffs->SetTempProp( TEMP_PROP_OPEN_EDGE, 0) ;
vpCrvs[i].Set( Release( pCompoOpenOffs)) ;
}
}
}
// caso limite : tutta la curva è aperta
if ( int( vpCrvs.size()) == 1 && vpCrvs[0]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE)
pCrvNewBorder.Set( Release( vpCrvs[0])) ;
else {
// scorro i tratti omogenei
Point3d ptLineS, ptLineE ;
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
// recupero l'indice del tratto chiuso precedente e successivo
int nIndCLprec = ( i == 0 ? int( vpCrvs.size()) -1 : i - 1) ;
int nIndCLsucc = ( i == int( vpCrvs.size()) -1 ? 0 : i + 1) ;
// tratto lineare chiuso precedente
vpCrvs[nIndCLprec]->GetEndPoint( ptLineS) ;
vpCrvs[i]->GetStartPoint( ptLineE) ;
PtrOwner<ICurveLine> pLinePrec( CreateCurveLine()) ;
if ( ! IsNull( pLinePrec) && pLinePrec->Set( ptLineS, ptLineE)) {
#if DEBUG_OPEN_EDGE_EXTENSION
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pLinePrec->Clone()) ;
m_pGeomDB->SetMaterial( a, AQUA) ;
#endif
if ( ! pCrvNewBorder->AddCurve( Release( pLinePrec)))
return false ;
pCrvNewBorder->SetCurveTempProp( pCrvNewBorder->GetCurveCount() - 1, 0, TEMP_PROP_CLOSE_EDGE) ;
}
// tratto aperto esteso
#if DEBUG_OPEN_EDGE_EXTENSION
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, vpCrvs[i]->Clone()) ;
m_pGeomDB->SetMaterial( a, ORANGE) ;
#endif
if ( ! pCrvNewBorder->AddCurve( vpCrvs[i]->Clone()))
return false ;
// tratto lineare chiuso successivo
vpCrvs[i]->GetEndPoint( ptLineS) ;
vpCrvs[nIndCLsucc]->GetStartPoint( ptLineE) ;
PtrOwner<ICurveLine> pLineSucc( CreateCurveLine()) ;
if ( ! IsNull( pLineSucc) && pLineSucc->Set( ptLineS, ptLineE)) {
#if DEBUG_OPEN_EDGE_EXTENSION
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pLineSucc->Clone()) ;
m_pGeomDB->SetMaterial( a, AQUA) ;
#endif
if ( ! pCrvNewBorder->AddCurve( Release( pLineSucc)))
return false ;
pCrvNewBorder->SetCurveTempProp( pCrvNewBorder->GetCurveCount() - 1, 0, TEMP_PROP_CLOSE_EDGE) ;
}
}
else if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) {
#if DEBUG_OPEN_EDGE_EXTENSION
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, vpCrvs[i]->Clone()) ;
m_pGeomDB->SetMaterial( a, AQUA) ;
#endif
if ( ! pCrvNewBorder->AddCurve( vpCrvs[i]->Clone()))
return false ;
}
}
}
// ricostruisco il Chunk con il nuovo bordo
PtrOwner<ISurfFlatRegion> pNewChunk( CreateSurfFlatRegion()) ;
if ( IsNull( pNewChunk) || ! pNewChunk->AddExtLoop( Release( pCrvNewBorder)))
return false ;
for ( int nI = 1 ; nI < vChunks[nC]->GetLoopCount( 0) ; ++ nI) {
if ( ! pNewChunk->AddIntLoop( vChunks[nC]->GetLoop( 0, nI)))
return false ;
}
vChunks[nC].Set( Release( pNewChunk)) ;
bModifSfr = true ;
}
// recupero la regione finale
if ( bModifSfr) {
PtrOwner<ISurfFlatRegion> pSfrTmp( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrTmp))
return false ;
for ( auto& pSfrC : vChunks) {
if ( pSfrTmp->IsValid())
pSfrTmp->Add( *pSfrC) ;
else
pSfrTmp.Set( pSfrC) ;
}
pSfr->CopyFrom( pSfrTmp) ;
}
#if DEBUG_OPEN_EDGE_EXTENSION
DebugDrawSfr( pSfr, false, nLay) ;
#endif
return ( pSfr->IsValid()) ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion)
{
// controllo parametri :
if ( pSfr == nullptr || ! pSfr->IsValid() ||
pStmExtrusion == nullptr)
return false ;
// se non ho una superificie di estrusione, allora è tutto aperto
if ( ! pStmExtrusion->IsValid() || pStmExtrusion->GetTriangleCount() == 0) {
for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC)
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL)
for ( int nU = 0 ; nU < pSfr->GetLoopCurveCount( nC, nL) ; ++ nU)
pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_OPEN_EDGE, 0) ;
return true ;
}
// per ogni curva dei Loop della FlatRegion vengono presi 4 punti di controllo equidistanti.
// " IL LATO E' APERTO <=> TUTTI I PUNTI DI CONTROLLO NON SONO A CONTATTO CON pStmExtrusion "
const int NUM_POINTS = 4 ;
// scorro tutti i loop
for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
// recupero la curva composita del Loop
PtrOwner<ICurveComposite> pCrvCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
if ( IsNull( pCrvCompoLoop) || ! pCrvCompoLoop->IsValid())
return false ;
// scorro ogni sua sottocurva
for ( int nU = 0 ; nU < pCrvCompoLoop->GetCurveCount() ; ++ nU) {
// la sottocurva viene messa chiusa ( condizione base)
pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_OPEN_EDGE, 0) ;
// recupero la sottocurva
const ICurve* pCrv = pCrvCompoLoop->GetCurve( nU) ;
if ( pCrv == nullptr)
return false ;
// recupero i NUM_POINTS punti
bool bIsOnStm = true ;
for ( int nP = 0 ; nP < NUM_POINTS + 1 && bIsOnStm ; ++ nP) {
double dPar = ( 1. / ( 1. * NUM_POINTS)) * nP ;
Point3d ptPar ;
if ( ! pCrv->GetPointD1D2( dPar, ICurve::FROM_PLUS, ptPar))
return false ;
// scorro il vettore relativo alla regione di riferimento
DistPointSurfTm distCalculator( ptPar, *pStmExtrusion) ;
double dDist = 0. ;
distCalculator.GetDist( dDist) ;
bIsOnStm = ( dDist < 25 * EPS_SMALL) ;
}
if ( bIsOnStm)
pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_CLOSE_EDGE, 0) ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcLimitRegion( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrRaw, ISurfFlatRegion* pSfrLimit)
{
// controllo dei parametri
if ( pSfrPock == nullptr || ! pSfrPock->IsValid() ||
pSfrRaw == nullptr || ! pSfrRaw->IsValid())
return false ;
pSfrLimit->Clear() ;
// la superficie limite è data dalla sottrazione tra il grezzo e la superficie da svuotare
pSfrLimit->CopyFrom( pSfrRaw) ;
if ( pSfrLimit == nullptr || ! pSfrLimit->IsValid())
return false ;
// piccolo Offset di correzione
PtrOwner<ISurfFlatRegion> pSfrOffs( pSfrPock->CreateOffsetSurf( 10 * EPS_SMALL, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrOffs) || ! pSfrOffs->IsValid())
return false ;
// sottrazione
pSfrLimit->Subtract( *pSfrOffs) ;
// se richiesto non controllo dei lati aperti
if ( m_bOpenOutRaw && pSfrLimit->IsValid()) {
double dExtension = 4. * m_TParams.m_dDiam + max( 0., m_dOpenMinSafe) + EPS_SMALL ;
for ( int nC = 0 ; nC < pSfrPock->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfrPock->GetLoopCount( nC) ; ++ nL) {
// recupero la curva di bordo
PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfrPock->GetLoop( nC, nL))) ;
if ( IsNull( pCrvLoop) || ! pCrvLoop->IsValid())
return false ;
// recupero i tratti con proprietà omogenee
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! GetHomogeneousParts( pCrvLoop, vpCrvs))
return false ;
// scorro i tratti omogenei aperti
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( ! IsNull( vpCrvs[i]) && vpCrvs[i]->IsValid() && vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
// regione da sottrarre
PtrOwner<ISurfFlatRegion> pSfrSubtract( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrSubtract))
return false ;
if ( vpCrvs[i]->IsClosed()) {
pSfrSubtract.Set( GetSurfFlatRegionFromFatCurve( vpCrvs[i]->Clone(), dExtension, false, false)) ;
if ( IsNull( pSfrSubtract) || ! pSfrSubtract->IsValid())
return false ;
if ( AreOppositeVectorApprox( pSfrSubtract->GetNormVersor(), pSfrPock->GetNormVersor()))
pSfrSubtract->Invert() ;
}
else {
// creo la curva di Offset esterna ( deve esistere ed essere valida)
vpCrvs[i]->SetExtrusion( pSfrPock->GetNormVersor()) ;
OffsetCurve OffsCrv ;
PtrOwner<ICurve> pOffsExt( CreateCurveComposite()) ;
if ( IsNull( pOffsExt) ||
! OffsCrv.Make( vpCrvs[i], dExtension, ICurve::OFF_FILLET) ||
! pOffsExt.Set( OffsCrv.GetLongerCurve()) ||
IsNull( pOffsExt))
return false ;
// creo la curva di Offset interna ( se esiste e valida...)
PtrOwner<ICurve> pOffsInt( CreateCurveComposite()) ;
if ( IsNull( pOffsInt))
return false ;
if ( OffsCrv.Make( vpCrvs[i], - dExtension, ICurve::OFF_FILLET)) {
PtrOwner<ICurve> pMyCrv( OffsCrv.GetLongerCurve()) ;
if ( ! IsNull( pMyCrv) && pMyCrv->IsValid())
pOffsInt.Set( pMyCrv) ;
}
// recupero gli estremi della curva aperta corrente
Point3d pt1 ; vpCrvs[i]->GetEndPoint( pt1) ;
Point3d pt4 ; vpCrvs[i]->GetStartPoint( pt4) ;
// verifico se una delle due curve esiste
bool bExistExt = ( ! IsNull( pOffsExt) && pOffsExt->IsValid()) ;
bool bExistInt = ( ! IsNull( pOffsInt) && pOffsInt->IsValid()) ;
PtrOwner<ICurveComposite> pCrvExtLoopSurfInc( CreateCurveComposite()) ;
if ( IsNull( pCrvExtLoopSurfInc))
return false ;
if ( bExistExt && bExistInt) {
Point3d pt2 ; pOffsInt->GetEndPoint( pt2) ;
Point3d pt3 ; pOffsInt->GetStartPoint( pt3) ;
Point3d pt5 ; pOffsExt->GetStartPoint( pt5) ;
if ( ! pCrvExtLoopSurfInc->AddCurve( Release( pOffsExt)) ||
! pCrvExtLoopSurfInc->AddLine( pt1) ||
! pCrvExtLoopSurfInc->AddLine( pt2) ||
! pOffsInt->Invert() ||
! pCrvExtLoopSurfInc->AddCurve( Release( pOffsInt)) ||
! pCrvExtLoopSurfInc->AddLine( pt4) ||
! pCrvExtLoopSurfInc->AddLine( pt5))
return false ;
}
else if ( bExistExt) {
Point3d pt5 ; pOffsExt->GetStartPoint( pt5) ;
if ( ! pCrvExtLoopSurfInc->AddCurve( Release( pOffsExt)) ||
! pCrvExtLoopSurfInc->AddLine( pt1) ||
! pCrvExtLoopSurfInc->AddLine( pt4) ||
! pCrvExtLoopSurfInc->AddLine( pt5))
return false ;
}
else if ( bExistInt) {
Point3d pt5 ; pOffsInt->GetStartPoint( pt5) ;
if ( ! pCrvExtLoopSurfInc->AddCurve( Release( pOffsInt)) ||
! pCrvExtLoopSurfInc->AddLine( pt1) ||
! pCrvExtLoopSurfInc->AddLine( pt4) ||
! pCrvExtLoopSurfInc->AddLine( pt5))
return false ;
}
else
return false ;
// per sicurezza...
pCrvExtLoopSurfInc->Close() ;
if ( ! pSfrSubtract->AddExtLoop( Release( pCrvExtLoopSurfInc)))
return false ;
if ( pSfrSubtract->IsValid() && pSfrSubtract->GetChunkCount() > 0) {
Vector3d vtN = pSfrSubtract->GetNormVersor() ;
if ( AreOppositeVectorApprox( vtN, pSfrPock->GetNormVersor()))
pSfrSubtract->Invert() ;
}
}
if ( pSfrSubtract->IsValid())
pSfrLimit->Subtract( *pSfrSubtract) ;
}
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::ChooseRawPart( const ISurfFlatRegion* pSfrChunk, ISurfTriMesh* pStm) const
{
/* Funzione per rimuovere le Part di pStm che non interferiscono con pSfrChunk */
// Controllo dei parametri
if ( pSfrChunk == nullptr || ! pSfrChunk->IsValid())
return false ;
if ( pStm == nullptr || ! pStm->IsValid())
return true ;
// Se solo una Part, allora il grezzo da considerare è tutto
if ( pStm->GetPartCount() < 2)
return true ;
// Recupero la TriMesh ausiliaria del Chunk
const ISurfTriMesh* pStmAux = pSfrChunk->GetAuxSurf() ;
if ( pStmAux == nullptr)
return false ;
PtrOwner<ISurfTriMesh> pStmChunk( CloneSurfTriMesh( pStmAux)) ;
if ( IsNull( pStmChunk) || ! pStmChunk->IsValid())
return false ;
// Recupero il Box della TriMesh
BBox3d BBoxChunk ;
if ( ! pStmChunk->GetLocalBBox( BBoxChunk))
return false ;
// Scorro le Part della TriMesh
for ( int nPart = 0 ; nPart < pStm->GetPartCount() ; ++ nPart) {
// Recupero il Box della Part corrente
BBox3d BBoxPart ;
if ( ! pStm->GetPartLocalBBox( nPart, BBoxPart))
return false ;
// Se non c'è intersezione tra i Box, la Part corrente viene rimossa
BBox3d BBoxInt ;
if ( ! BBoxPart.FindIntersection( BBoxChunk, BBoxInt) || BBoxInt.IsEmpty()) {
pStm->RemovePart( nPart) ;
-- nPart ;
continue ;
}
// Se i Box fanno interferenza verifico in maniera corretta se davvero le superfici interferiscono
PtrOwner<ISurfTriMesh> pStmPart( pStm->ClonePart( nPart)) ;
if ( IsNull( pStmPart) || ! pStmPart->IsValid())
return false ;
if ( ! TestSurfTmSurfTm( *pStmChunk, *pStmPart, 10. * EPS_SMALL, true)) {
pStm->RemovePart( nPart) ;
-- nPart ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::ManageOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm)
{
/* Bisogna distingere tra lati aperti sul bordo del grezzo e lati aperti all'interno del grezzo ;
* I lati aperti all'interno del grezzo vanno estesi di circa il raggio utensile e poi considerati
* come chiusi */
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid() ||
pStm == nullptr)
return false ;
if ( ! pStm->IsValid())
return true ;
// Recupero dalle Note utenti il parametro OpenOutRaw
int nOpenOutRaw ;
m_bOpenOutRaw = ( GetValInNotes( m_Params.m_sUserNotes, UN_OPENOUTRAW, nOpenOutRaw) && nOpenOutRaw != 0) ;
// recupero i Chunk della superficie
ISURFFRPOVECTOR vChunks( pSfr->GetChunkCount()) ;
for ( int nC = 0 ; nC < int( vChunks.size()) ; ++ nC)
vChunks[nC].Set( pSfr->CloneChunk( nC)) ;
// definisco un frame locale nel piano XY
Frame3d frXY ;
Point3d ptCenter ; pSfr->GetCentroid( ptCenter) ;
if ( ! frXY.Set( ptCenter, pSfr->GetNormVersor()))
return false ;
// definisco Offset di tolleranza
m_dOpenInRawExtension = 1.05 * ( m_TParams.m_dDiam / 2.) ;
double dOpenExtension = 0. ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_OPEN, dOpenExtension) && dOpenExtension > EPS_SMALL)
m_dOpenInRawExtension = dOpenExtension ;
// se la superficie ha flag di OpenOutRaw e non è stata impostata alcuna estensione massima,
// non modifico la geometria, lascio l'aperto esattamente dove si trova
// se invece ho flat di OpenOutRaw, dato che il lato aperto viene lasciato tale, devo ridurre la
// sua estensione del raggio utensile
if ( m_bOpenOutRaw) {
if ( dOpenExtension < 10. * EPS_SMALL)
return true ;
else {
m_dOpenInRawExtension -= m_TParams.m_dDiam / 2. ;
if ( m_dOpenInRawExtension < EPS_SMALL) {
m_dOpenInRawExtension = 0. ;
return true ;
}
}
}
const double LEN_EXTENSION = 1000. ;
const double TOL_PT_INSIDE_STM = 3. ;
#if DEBUG_OPEN_EDGE_IN_RAW
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "_OpenEdgeInRaw") ;
int nLayBase = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayBase, "Orig") ;
int nLayConstr = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayConstr, "Construction") ;
int nLayResult = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayResult, "Result") ;
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayBase, pStm->Clone()) ;
m_pGeomDB->SetMaterial( _a, Color( .35, .65, .45, .35)) ;
#endif
// recupero solo la curva di bordo esterno, le isole aperte per ora sono trascurate
// scorro i Chunk della regione piana da lavorare
bool bModifSfr = false ;
for ( int nC = 0 ; nC < int( vChunks.size()) ; ++ nC) {
// recupero la curva di bordo
PtrOwner<ICurveComposite> pCrvBorder( ConvertCurveToComposite( vChunks[nC]->GetLoop( 0, 0))) ;
if ( IsNull( pCrvBorder) || ! pCrvBorder->IsValid())
return false ;
// recupero i tratti omogenei
ICRVCOMPOPOVECTOR vpCrvs ;
GetHomogeneousParts( pCrvBorder, vpCrvs) ;
// se tutta chiusa, non faccio nulla
if ( int( vpCrvs.size()) == 1 && vpCrvs[0]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE)
continue ;
// scorro i tratti alla ricerca di lati aperti ( esistono necessariamente)
bool bOpenCrvInPart = false ;
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
// analizzo le sottocurve del tratto
for ( int j = 0 ; j < vpCrvs[i]->GetCurveCount() ; ++ j) {
// per ogni sottocurva considero punto iniziale, finale e medio per campionarla
// ( si potrebbe in futuro campionare in maniera più fitta )
PNTVECTOR vPt( 3, P_INVALID) ;
vpCrvs[i]->GetCurve( j)->GetStartPoint( vPt[0]) ;
vpCrvs[i]->GetCurve( j)->GetMidPoint( vPt[1]) ;
vpCrvs[i]->GetCurve( j)->GetEndPoint( vPt[2]) ;
// classifico tali punti rispetto alla superficie
bool bOpenEdgeInStm = false ;
double dDist = 0. ;
for ( int nPt = 0 ; nPt < int( vPt.size()) && ! bOpenEdgeInStm ; ++ nPt) {
DistPointSurfTm DistPtStm( vPt[nPt], *pStm) ;
bOpenEdgeInStm = ( DistPtStm.IsPointInside() &&
DistPtStm.GetDist( dDist) &&
dDist > TOL_PT_INSIDE_STM) ;
}
// se curva aperta nel pezzo, la classifico
if ( bOpenEdgeInStm) {
vpCrvs[i]->SetCurveTempProp( j, TEMP_PROP_OPEN_EDGE_IN_RAW, 0) ;
bOpenCrvInPart = true ;
}
}
}
}
// se non sono state trovate curve interne al pezzo, allora passo al bordo successivo
if ( ! bOpenCrvInPart)
continue ;
// ricostruisco il bordo mediante proprietà assegnate ( esistono lati aperti interni al pezzo)
PtrOwner<ICurveComposite> pCrvNewBorder( CreateCurveComposite()) ;
if ( IsNull( pCrvNewBorder))
return false ;
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( ! pCrvNewBorder->AddCurve( Release( vpCrvs[i])))
return false ;
}
// recupero i nuovi tratti omogenei
GetHomogeneousParts( pCrvNewBorder, vpCrvs) ;
#if DEBUG_OPEN_EDGE_IN_RAW
DebugDrawOpenEdgesInRaw( vpCrvs, nLayBase) ;
#endif
// caso limite : tutta la curva è aperta ed interna alla regione
if ( int( vpCrvs.size()) == 1 && vpCrvs[0]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE_IN_RAW) {
// Offset del bordo del Chunk
OffsetCurve OffsCrv ;
OffsCrv.Make( pCrvNewBorder, m_dOpenInRawExtension, ICurve::OFF_FILLET) ;
pCrvNewBorder.Set( ConvertCurveToComposite( OffsCrv.GetLongerCurve())) ;
if ( IsNull( pCrvNewBorder) || ! pCrvNewBorder->IsValid())
return false ;
// considero il bordo come tutto chiuso ( evito entrate da fuori dal pezzo)
for ( int i = 0 ; i < pCrvNewBorder->GetCurveCount() ; ++ i)
pCrvNewBorder->SetCurveTempProp( i, m_bOpenOutRaw ? TEMP_PROP_OPEN_EDGE : TEMP_PROP_CLOSE_EDGE, 0) ;
}
// se invece presenta solo alcuni tratti Open interni al pezzo
else {
// porto tutti i tratti ricavati nel piano XY per le intersezioni
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i)
vpCrvs[i]->ToLoc( frXY) ;
// scorro i tratti con proprietà uniformi
bool bOk = true ;
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( ! bOk) {
// considero il tratto precedente come chiuso
for ( int j = 0 ; j < vpCrvs[i-1]->GetCurveCount() ; ++ j)
vpCrvs[i-1]->SetCurveTempProp( j, TEMP_PROP_CLOSE_EDGE, 0) ;
bOk = true ;
}
// se tratto Open interno al grezzo
if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE_IN_RAW) {
// effettuo Offset del tratto in esame
OffsetCurve OffsCrv ;
OffsCrv.Make( vpCrvs[i], m_dOpenInRawExtension, ICurve::OFF_FILLET) ;
PtrOwner<ICurveComposite> pCrvOffsOpenInPart( ConvertCurveToComposite( OffsCrv.GetLongerCurve())) ;
if ( IsNull( pCrvOffsOpenInPart) || ! pCrvOffsOpenInPart->IsValid()) {
bOk = false ;
continue ;
}
// recupero tratto precedente e successivo
int nIndPrev = ( i > 0 ? i - 1 : int( vpCrvs.size()) - 1) ;
int nIndAfter = ( i < int( vpCrvs.size()) - 1 ? i + 1 : 0) ;
// estendo per sicurezza il tratto di Offset ( per angoli acuti con i tratti adiacenti)
pCrvOffsOpenInPart->ExtendStartByLen( LEN_EXTENSION) ;
pCrvOffsOpenInPart->ExtendEndByLen( LEN_EXTENSION) ;
#if DEBUG_OPEN_EDGE_IN_RAW
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayConstr, pCrvOffsOpenInPart->Clone()) ;
m_pGeomDB->SetMaterial( _a, ORANGE) ;
#endif
// definisco due segmenti lineari
PtrOwner<ICurveLine> pLinePrev( CreateCurveLine()) ;
PtrOwner<ICurveLine> pLineAfter( CreateCurveLine()) ;
if ( IsNull( pLinePrev) || IsNull( pLineAfter))
return false ;
Point3d ptLineStart ;
Vector3d vtLineStart ;
vpCrvs[nIndPrev]->GetEndPoint( ptLineStart) ;
vpCrvs[nIndPrev]->GetEndDir( vtLineStart) ;
if ( ! pLinePrev->Set( ptLineStart, ptLineStart + LEN_EXTENSION * vtLineStart))
return false ;
#if DEBUG_OPEN_EDGE_IN_RAW
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayConstr, pLinePrev->Clone()) ;
m_pGeomDB->SetMaterial( _a, BLACK) ;
#endif
Point3d ptLineEnd ;
Vector3d vtLineEnd ;
vpCrvs[nIndAfter]->GetStartPoint( ptLineEnd) ;
vpCrvs[nIndAfter]->GetStartDir( vtLineEnd) ;
if ( ! pLineAfter->Set( ptLineEnd - LEN_EXTENSION * vtLineEnd, ptLineEnd))
return false ;
#if DEBUG_OPEN_EDGE_IN_RAW
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayConstr, pLineAfter->Clone()) ;
m_pGeomDB->SetMaterial( _a, BLACK) ;
#endif
// intersezione con primo segmento ( raccordo verso lato Open In Raw Offs)
Point3d ptIntS ;
double dUS_Trim_Line ;
double dUS_Trim_Offs ;
IntersCurveCurve ICC_Prev( *pLinePrev, *pCrvOffsOpenInPart) ;
if ( ICC_Prev.GetIntersCount() > 0 && ICC_Prev.GetIntersPointNearTo( 0, ptLineStart, ptIntS)) {
pLinePrev->GetParamAtPoint( ptIntS, dUS_Trim_Line) ;
pCrvOffsOpenInPart->GetParamAtPoint( ptIntS, dUS_Trim_Offs) ;
}
else {
bOk = false ;
continue ;
}
// intersezione con secondo segmento ( raccordo da Lato Open In Raw Offs)
Point3d ptIntE ;
double dUE_Trim_Line ;
double dUE_Trim_Offs ;
IntersCurveCurve ICC_After( *pLineAfter, *pCrvOffsOpenInPart) ;
if ( ICC_After.GetIntersCount() > 0 && ICC_After.GetIntersPointNearTo( 0, ptLineEnd, ptIntE)) {
pLineAfter->GetParamAtPoint( ptIntE, dUE_Trim_Line) ;
pCrvOffsOpenInPart->GetParamAtPoint( ptIntE, dUE_Trim_Offs) ;
}
else {
bOk = false ;
continue ;
}
// se le rette si intersecano tra loro prima di raccordarsi sull'Offset
if ( dUS_Trim_Offs > dUE_Trim_Offs) {
// recupero punto di intersezione tra le rette
IntersCurveCurve ILL( *pLinePrev, *pLineAfter) ;
Point3d ptIntersLL ;
if ( ILL.GetIntersCount() != 1 ||
! ILL.GetIntersPointNearTo( 0, ptLineStart, ptIntersLL) ||
! pLinePrev->GetParamAtPoint( ptIntersLL, dUS_Trim_Line) ||
! pLineAfter->GetParamAtPoint( ptIntersLL, dUE_Trim_Line)) {
bOk = false ;
continue ;
}
// pulisco la curva di Offset
pCrvOffsOpenInPart->Clear() ;
}
// se le rette non si intersecano tra loro
else {
double dU_Offs_Trim_Start = 0. ;
pCrvOffsOpenInPart->GetParamAtPoint( ptIntS, dU_Offs_Trim_Start) ;
pCrvOffsOpenInPart->TrimStartAtParam( dU_Offs_Trim_Start) ;
double dU_Offs_Trim_End = 0. ;
pCrvOffsOpenInPart->GetParamAtPoint( ptIntE, dU_Offs_Trim_End) ;
pCrvOffsOpenInPart->TrimEndAtParam( dU_Offs_Trim_End) ;
}
// aggiorno tutte le curve e le loro proprietà
pLinePrev->TrimEndAtParam( dUS_Trim_Line) ;
pLinePrev->SetTempProp( vpCrvs[nIndPrev]->GetTempProp( 0), 0) ;
vpCrvs[nIndPrev]->AddCurve( Release( pLinePrev), true) ;
pLineAfter->TrimStartAtParam( dUE_Trim_Line) ;
pLineAfter->SetTempProp( vpCrvs[nIndAfter]->GetTempProp( 0), 0) ;
vpCrvs[nIndAfter]->AddCurve( Release( pLineAfter), false) ;
vpCrvs[i].Set( Release( pCrvOffsOpenInPart)) ;
// assegno proprietà di lato aperto/chiuso
for ( int j = 0 ; j < vpCrvs[i]->GetCurveCount() ; ++ j)
vpCrvs[i]->SetCurveTempProp( j, m_bOpenOutRaw ? TEMP_PROP_OPEN_EDGE : TEMP_PROP_CLOSE_EDGE, 0) ;
}
}
// ricostrusico il nuovo bordo
pCrvNewBorder->Clear() ;
#if DEBUG_OPEN_EDGE_IN_RAW
DebugDrawOpenEdgesInRaw( vpCrvs, nLayResult) ;
#endif
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( ! IsNull( vpCrvs[i]) && vpCrvs[i]->IsValid() && vpCrvs[i]->GetCurveCount() > 0) {
if ( ! pCrvNewBorder->AddCurve( Release( vpCrvs[i])))
return false ;
}
}
// lo riporto nel frame globale
pCrvNewBorder->ToGlob( frXY) ;
}
// ricostruisco il Chunk con il nuovo bordo
PtrOwner<ISurfFlatRegion> pNewChunk( CreateSurfFlatRegion()) ;
if ( IsNull( pNewChunk) || ! pNewChunk->AddExtLoop( Release( pCrvNewBorder)))
return false ;
for ( int nI = 1 ; nI < vChunks[nC]->GetLoopCount( 0) ; ++ nI) {
if ( ! pNewChunk->AddIntLoop( vChunks[nC]->GetLoop( 0, nI)))
return false ;
}
vChunks[nC].Set( Release( pNewChunk)) ;
bModifSfr = true ;
}
// recupero la regione finale
if ( bModifSfr) {
PtrOwner<ISurfFlatRegion> pSfrTmp( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrTmp))
return false ;
for ( auto& pSfrC : vChunks) {
if ( pSfrTmp->IsValid())
pSfrTmp->Add( *pSfrC) ;
else
pSfrTmp.Set( pSfrC) ;
}
pSfr->CopyFrom( pSfrTmp) ;
}
#if DEBUG_OPEN_EDGE_IN_RAW
DebugDrawSfr( pSfr, false, nLayResult) ;
#endif
return ( pSfr->IsValid()) ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CheckMaxDepth( const ISurfFlatRegion* pSfr, double dDepth, const Vector3d& vtTool,
const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmExtrusion,
const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth)
{
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid() ||
pStmRaw == nullptr || ! pStmRaw->IsValid() ||
pStmExtrusion == nullptr)
return false ;
bSkipMaxDepth = false ;
#if DEBUG_MAXDEPTH
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "MaxDepth") ;
int nLaySfr = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLaySfr, "Sfr") ;
DebugDrawSfr( pSfr, false, nLaySfr) ;
int nLayRaw = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayRaw, "Raw") ;
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayRaw, pStmRaw->Clone()) ;
m_pGeomDB->SetMaterial( _a, Color( 0., 0., 1., .35)) ;
#endif
// se la superficie di estrusione dei chiusi è vuota
if ( ! pStmExtrusion->IsValid() || pStmExtrusion->GetTriangleCount() == 0) {
bSkipMaxDepth = true ;
return true ;
}
#if DEBUG_MAXDEPTH
int nLayStmExtr = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "StmExtrusion") ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayStmExtr, pStmExtrusion->Clone()) ;
m_pGeomDB->SetMaterial( _a, AQUA) ;
#endif
// adatto la regione piana attuale al grezzo
// NB. La pStmExtrusion potrebbe esistere ma non toccare nessun lato adattato al grezzo
PtrOwner<ISurfFlatRegion> pSfrRaw( GetSfrByStmIntersection( IPPStm, - dDepth, 0)) ;
if ( IsNull( pSfrRaw)) {
m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Slicing Raw failed") ;
return false ;
}
if ( ! pSfrRaw->IsValid() || pSfrRaw->GetChunkCount() == 0)
return true ; // ??? ( non deve capitare)
PtrOwner<ISurfFlatRegion> pSfrAdj( CloneSurfFlatRegion( pSfr)) ;
if ( IsNull( pSfrAdj) || ! pSfrAdj->IsValid() ||
! pSfrAdj->Translate( - dDepth * vtTool))
return false ;
pSfrAdj->Intersect( *pSfrRaw) ;
if ( ! pSfrAdj->IsValid())
return true ; // ??? ( non deve capitare)
// determino i lati aperti della regione ricavata
if ( ! ChooseCloseOrOpenEdge( pSfrAdj, pStmExtrusion)) {
m_pMchMgr->SetLastError( 3026, "Error in PocketingNT : Detecting open edges failed") ;
return false ;
}
#if DEBUG_MAXDEPTH
nLaySfr = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLaySfr, "Sfr_Raw_Inters") ;
DebugDrawSfr( pSfr, true, nLaySfr) ;
#endif
// controllo se la regione ha tutti i lati aperti
int nTmpProp = TEMP_PROP_INVALID ;
for ( int nC = 0 ; nC < pSfrAdj->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfrAdj->GetLoopCount( nL) ; ++ nL) {
for ( int nU = 0 ; nU < pSfrAdj->GetLoopCurveCount( nC, nL) ; ++ nU) {
if ( pSfrAdj->GetCurveTempProp( nC, nL, nU, nTmpProp, 0) &&
nTmpProp == TEMP_PROP_CLOSE_EDGE) {
return true ;
}
}
}
}
bSkipMaxDepth = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcGeoExtSurfFr( const ISurfFlatRegion* pSfrPock, const Vector3d& vtTool, const double dDepth, const ISurfTriMesh* pStmRaw,
const SELVECTOR& vGeoSel, ISURFFRPOVECTOR& vSfrGeoExt)
{
// verifica valdità dei parametri
if ( pSfrPock == nullptr || ! pSfrPock->IsValid() || pStmRaw == nullptr || ! pStmRaw->IsValid())
return false ;
if ( vGeoSel.empty())
return true ;
// porto la regione di svuotatura nel più basso
PtrOwner<ISurfFlatRegion> pSfr( CloneSurfFlatRegion( pSfrPock)) ;
if ( IsNull( pSfr) || ! pSfr->IsValid())
return false ;
pSfr->Translate( - vtTool * dDepth) ;
// sempre in questo piano calcolo la silhouette del Grezzo
PtrOwner<ISurfFlatRegion> pSfrRaw( GetSfrRawProjection( pStmRaw, pSfr, vtTool)) ;
// verifico se l'entità selezionata è una superficie TriMesh ( quindi un SoloId)
for ( const SelData& Id : vGeoSel) {
if ( m_pGeomDB->GetGeoType( Id.nId) == SRF_TRIMESH) {
// recupero la superficie TriMesh e il suo frame
const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( Id.nId)) ;
if ( pStm != nullptr) {
// recupero la faccia selezionata per la lavorazione
int nFace = Id.nSub ;
// recupero il piano passante per la faccia corrente
Point3d ptC ; Vector3d vtN ;
if ( ! pStm->GetFacetCenter( nFace, ptC, vtN))
continue ;
Plane3d plFace ; plFace.Set( ptC, vtN) ;
// recupero la regione piana della faccia corrente
POLYLINEVECTOR vPL ;
pStm->GetFacetLoops( nFace, vPL) ;
SurfFlatRegionByContours SfrByC ;
for ( PolyLine& PL : vPL) {
PtrOwner<ICurveComposite> pCompoLoop( CreateCurveComposite()) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->FromPolyLine( PL))
return false ;
SfrByC.AddCurve( Release( pCompoLoop)) ;
}
PtrOwner<ISurfFlatRegion> pSfrOrigFace( SfrByC.GetSurf()) ;
if ( IsNull( pSfrOrigFace) || ! pSfrOrigFace->IsValid())
return false ;
#if DEBUG_SFR_GEO_EXT
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrOrigFace->Clone()) ;
m_pGeomDB->SetMaterial( nId, Color( 0., 0., 1.)) ;
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmRaw->Clone()) ;
m_pGeomDB->SetMaterial( nId, Color( 255, 165, 0, 50)) ;
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrOrigFace->Clone()) ;
m_pGeomDB->SetMaterial( nId, Color( 0., 1., 0., .5)) ;
#endif
// recupero tutte le facce adiacenti alla faccia selezionata
INTSET setAdjFace ;
for ( int i = 0 ; i < ssize( vPL) ; ++ i) {
double dPar ;
bool bFound = vPL[i].GetFirstU( dPar, true) ;
while ( bFound) {
// recupero il flag
int nFlag = int( dPar) ;
// se c'è una adiacenza
if ( nFlag != SVT_NULL) {
bool bAdjac ;
Point3d ptP1, ptP2 ;
double dAng ;
if ( ! pStm->GetFacetsContact( nFace, nFlag, bAdjac, ptP1, ptP2, dAng))
dAng = - ANG_RIGHT ;
if ( dAng < - EPS_ANG_SMALL)
setAdjFace.insert( nFlag) ;
}
// passo al successivo
bFound = vPL[i].GetNextU( dPar, true) ;
}
}
// scorro tutte le facce ad eccezione di quella da lavorare
for ( auto Iter = setAdjFace.begin() ; Iter != setAdjFace.end() ; ++ Iter) {
int nAdjFace = *Iter ;
// recupero il bordo della faccia
POLYLINEVECTOR vPL ;
pStm->GetFacetLoops( nAdjFace, vPL) ;
// definisco una geometria di estrusione in direzione opposta alla normale corrente
// NB. Considero solo il Loop esterno per le pareti verticali, non mi aspetto isole...
Vector3d vtFaceN ; pStm->GetFacetNormal( nAdjFace, vtFaceN) ;
if ( ! vPL.empty()) {
PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
if ( ! IsNull( pStm) && pStm->AdjustTopology() && pStm->CreateByExtrusion( vPL[0], 4. * m_TParams.m_dDiam * ( - vtFaceN))) {
POLYLINEVECTOR vPLSil ;
if ( pStm->GetSilhouette( plFace, EPS_SMALL, vPLSil) && ! vPLSil.empty()) {
PtrOwner<ICurveComposite> pCompoLoop( CreateCurveComposite()) ;
if ( ! IsNull( pCompoLoop) && pCompoLoop->FromPolyLine( vPLSil[0])) {
PtrOwner<ISurfFlatRegion> pSfrCnt( CreateSurfFlatRegion()) ;
pSfrCnt->AddExtLoop( Release( pCompoLoop)) ;
if ( ! AreSameVectorApprox( pSfrCnt->GetNormVersor(), vtN))
pSfrCnt->Invert() ;
// rimuovo tutto ciò che non è interno alla regione originale selezionata
pSfrCnt->Subtract( *pSfrOrigFace) ;
vSfrGeoExt.emplace_back( Release( pSfrCnt)) ;
#if DEBUG_SFR_GEO_EXT
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vSfrGeoExt.back()->Clone()) ;
m_pGeomDB->SetMaterial( nId, Color( 1., 0., 0., .5)) ;
#endif
}
}
}
}
}
// se ho una regione valida
if ( ! vSfrGeoExt.empty()) {
for ( int i = 0 ; i < ssize( vSfrGeoExt) ; ++ i) {
// porto la superficie in globale
Frame3d frGlob ; m_pGeomDB->GetGlobFrame( Id.nId, frGlob) ;
vSfrGeoExt[i]->ToGlob( frGlob) ;
// la limito al grezzo
if ( ! IsNull( pSfrRaw) && pSfrRaw->IsValid()) {
vSfrGeoExt[i]->Intersect( *pSfrRaw) ;
if ( vSfrGeoExt[i]->IsValid()) {
// Assegno le proprietà di lato chiuso ad ogni parte trovata
for ( int nC = 0 ; nC < vSfrGeoExt[i]->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < vSfrGeoExt[i]->GetLoopCount( nC) ; ++ nL) {
for ( int nU = 0 ; nU < vSfrGeoExt[i]->GetLoopCurveCount( nC, nL) ; ++ nU)
vSfrGeoExt[i]->SetCurveTempProp( nC, nL, nU, TEMP_PROP_CLOSE_EDGE, 0) ;
}
}
#if DEBUG_SFR_GEO_EXT
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vSfrGeoExt[i]->Clone()) ;
m_pGeomDB->SetMaterial( nId, GRAY) ;
#endif
}
}
}
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
{
// aggiorno la ProgressBar del 5% per simulare l'inizio della funzione
ExeProcessEvents( 5, 0) ;
// 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) ;
// recupero la regione piana dal database geometrico
int nSfrId = m_pGeomDB->GetFirstInGroup( nPathId) ;
if ( m_pGeomDB->GetGeoType( nSfrId) != SRF_FLATRGN)
return false ;
// copio la regione piana da elaborare
int nCopyId = m_pGeomDB->CopyGlob( nSfrId, GDB_ID_NULL, nTempId) ;
if ( nCopyId == GDB_ID_NULL)
return false ;
ISurfFlatRegion* pSfr( GetSurfFlatRegion( m_pGeomDB->GetGeoObj( nCopyId))) ;
if ( pSfr == nullptr || ! pSfr->IsValid())
return false ;
// assegno le proprietà di lato aperto ai suoi loops
SetSfrLoopsAllTempProp( nSfrId, pSfr) ;
// recupero le geometrie di selezione originarie
string sGeoSel ; m_pGeomDB->GetInfo( nPathId, KEY_IDS, sGeoSel) ;
STRVECTOR vsSelEntity ; Tokenize( sGeoSel, ",", vsSelEntity) ;
SELVECTOR vGeoSel ; vGeoSel.reserve( int( ssize( vsSelEntity) / 2)) ;
for ( int i = 0 ; i < ssize( vsSelEntity) ; i = i + 2) {
SelData mySelData( GDB_ID_NULL, GDB_ID_NULL) ;
FromString( vsSelEntity[i], mySelData.nId) ;
if ( i + 1 < ssize( vsSelEntity))
FromString( vsSelEntity[i + 1], mySelData.nSub) ;
vGeoSel.emplace_back( mySelData) ;
}
// recupero estrusione e spessore
Vector3d vtExtr = Z_AX ;
if ( m_pGeomDB->ExistsInfo( nSfrId, KEY_EXTR))
m_pGeomDB->GetInfo( nSfrId, KEY_EXTR, vtExtr) ;
double dThick = 0. ;
if ( m_pGeomDB->ExistsInfo( nSfrId, KEY_THICK))
m_pGeomDB->GetInfo( nSfrId, KEY_THICK, dThick) ;
// eventuale inversione direzione utensile
if ( m_Params.m_bToolInvert) {
vtExtr.Invert() ;
dThick = - dThick ;
pSfr->Invert() ;
}
// 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( 2405, "Error in PocketingNT : 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( 2406, "Error in PocketingNT : 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 ;
// verifico che lo step dell'utensile sia sensato
double dOkStep = ( m_Params.m_dStep > EPS_SMALL ? m_Params.m_dStep + EPS_SMALL : 0) ;
const double MIN_ZSTEP = 1.0 ;
if ( dOkStep >= EPS_SMALL && dOkStep < MIN_ZSTEP) {
dOkStep = MIN_ZSTEP + EPS_SMALL ;
string sInfo = "Warning in PocketingNT : machining step too small (" +
ToString( m_Params.m_dStep, 2) + ")" ;
m_pMchMgr->SetWarning( 2456, sInfo) ;
}
// calcolo l'elevazione inversa per definire la Depth massima
double dInvElev = 0. ;
pSfr->Invert() ;
if ( ! CalcRegionElevation( pSfr, vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, dInvElev)) {
m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
return false ;
}
pSfr->Invert() ;
double dExtraDepth = ( dOkStep < EXTRA_DEPTH ? dOkStep / 2. : EXTRA_DEPTH) ;
if ( dOkStep < EPS_SMALL)
dExtraDepth = EXTRA_DEPTH ;
dDepth = min( dDepth, dInvElev + dExtraDepth) ;
// calcolo l'elevazione massima
double dElev = 0. ;
if ( ! CalcRegionElevation( pSfr, vtTool, dDepth, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev)) {
m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
return false ;
}
double dMaxElev ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev) && dElev > dMaxElev)
dElev = dMaxElev ;
// 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 PocketingNT : Tool MaxMaterial too small (" +
ToString( m_TParams.m_dMaxMat, 2) + ")" ;
m_pMchMgr->SetLastError( 2422, sInfo) ;
return false ;
}
// verifico di non superare il massimo materiale (se lo step supera la capacità dell'utensile)
if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) {
dOkStep = m_TParams.m_dMaxMat + EPS_SMALL ;
string sInfo = "Warning in PocketingNT : machining step (" + ToString( m_Params.m_dStep, 1) +
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetWarning( 2457, sInfo) ;
}
// recupero il grezzo e la superficie di Trim [nullptr se non presente]
PtrOwner<ISurfTriMesh> pStmRaw( GetRaw()) ;
if ( IsNull( pStmRaw) || ! ChooseRawPart( pSfr, pStmRaw) ||
! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0) {
m_pMchMgr->SetLastError( 3025, "Error in PocketingNT : RawPart not computable") ;
return false ;
}
PtrOwner<ISurfTriMesh> pStmTrim( GetStmTrim()) ;
if ( ! IsNull( pStmTrim)) {
if ( ! ChooseRawPart( pSfr, pStmTrim) || ! pStmTrim->IsValid() ||
pStmTrim->GetTriangleCount() == 0) {
m_pMchMgr->SetLastError( 3025, "Error in PocketingNT : RawPart not computable") ;
return false ;
}
}
#if DEBUG_SFR_RAW
int nGrpSR = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
int nLaySR = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpSR, GLOB_FRM) ;
m_pGeomDB->SetName( nLaySR, "Sfr_Raw_Position") ;
int _nRaw = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySR, pStmRaw->Clone()) ;
m_pGeomDB->SetMaterial( _nRaw, Color( .35, .46, .78, .1)) ;
if ( ! IsNull( pStmTrim)) {
int _nTrim = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySR, pStmTrim->Clone()) ;
m_pGeomDB->SetMaterial( _nTrim, Color( .65, .26, .58, .1)) ;
}
#endif
// se necessario modifico la geometria in caso di selezione originaria di TriMesh
// ( Gestione dei lati chiusi di una TriMesh tagliati su più facce del grezzo)
ISURFFRPOVECTOR vSurfFrGeoExt ;
pSfr->Translate( - vtTool * ( dDepth + m_TParams.m_dMaxMat)) ;
CalcGeoExtSurfFr( pSfr, vtTool, 0., pStmRaw, vGeoSel, vSurfFrGeoExt) ;
for ( int i = 0 ; i < ssize( vSurfFrGeoExt) ; ++ i)
pSfr->Subtract( *vSurfFrGeoExt[i]) ;
if ( ! pSfr->IsValid())
return true ; // nulla da svuotare
pSfr->Translate( vtTool * ( dDepth + m_TParams.m_dMaxMat)) ;
// definisco una trimesh derivante dalla regione piana mediante estrusione dei lati chiusi
// NB. La traslazione in questo caso è euristica
// NB. Questa superficie servirà per definire i lati chiusi una volta che la regione piana
// è stata intersecata con la superficie del grezzo
pSfr->Translate( - vtTool * ( dDepth + m_TParams.m_dMaxMat)) ;
Vector3d vtStmExtr = vtTool * ( abs( dDepth) + m_TParams.m_dMaxMat + dElev + m_TParams.m_dMaxMat) ;
PtrOwner<ISurfTriMesh> pStmExtrusion( GetExtrusionStm( pSfr, vtStmExtr)) ;
pSfr->Translate( vtTool * ( dDepth + m_TParams.m_dMaxMat)) ;
if ( IsNull( pStmExtrusion))
return false ;
#if DEBUG_STM_EXTRUSION
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay, "Extr_Stm_Close_edge") ;
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pStmExtrusion->Clone()) ;
m_pGeomDB->SetMaterial( _a, Color( 1., 0., 1., .75)) ;
m_pGeomDB->SetStatus( _a, GDB_ST_OFF) ;
#endif
// se lavorazione singola
if ( dOkStep < EPS_SMALL || dOkStep > dElev) {
// se l'elevazione supera la capacità dell'utensile
if ( dElev > m_TParams.m_dMaxMat + EPS_SMALL) {
string sInfo = "Warning in Pocketing : machining depth (" + ToString( dElev, 1) +
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetWarning( 2458, sInfo) ;
dDepth -= dElev - m_TParams.m_dMaxMat ;
dElev = m_TParams.m_dMaxMat ;
}
}
// altrimenti lavorazione a step
else {
// se l'elevazione supera il massimo affondamento dell'utensile
double dSafe = GetMaxDepthSafe() ;
double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? m_dTHoldBase : m_dTHoldLen) - dSafe ;
if ( dElev > dMaxDepth + EPS_SMALL) {
// controllo se posso evitare il controllo
Frame3d frSfr ;
Point3d ptCen ; pSfr->GetCentroid( ptCen) ;
Frame3d frPocket ;
if ( ! frPocket.Set( ptCen, vtTool) || ! frPocket.IsValid())
return false ;
IntersParPlanesSurfTm IPPStm( frPocket, *pStmRaw) ;
bool bSkipMaxDepth = false ;
if ( ! CheckMaxDepth( pSfr, dDepth, vtTool, pStmRaw, pStmExtrusion, IPPStm, bSkipMaxDepth))
return false ;
if ( ! bSkipMaxDepth) {
// segnalo, riduco e continuo
string sInfo = "Warning in PocketingNT : machining depth (" + ToString( dElev, 1) +
") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
m_pMchMgr->SetWarning( 2458, sInfo) ;
dDepth -= dElev - dMaxDepth ;
dElev = dMaxDepth ;
}
}
}
// verifico se tavola basculante
bool bTiltTab = false ;
m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab, m_vtTiltingAx) && bTiltTab) ;
// verifico se testa da sopra (Z+)
m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ;
// verifiche per svuotature dal basso
m_bAggrBottom = false ;
for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nL) ; ++ nL) {
// recupero la curva
PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
if ( IsNull( pCrvLoop) || ! pCrvLoop->IsValid())
return false ;
// se isola inverto
if ( nL > 0)
pCrvLoop->Invert() ;
// verifica
if ( ! VerifyPathFromBottom( pCrvLoop, vtTool))
return false ;
}
}
// recupero eventuale flag di lato aperto forzato fuori dal grezzo
int nOpenOutRaw ;
m_bOpenOutRaw = ( GetValInNotes( m_Params.m_sUserNotes, UN_OPENOUTRAW, nOpenOutRaw) && nOpenOutRaw != 0) ;
// recupero eventuale minima lunghezza di attacco su lato aperto
m_dOpenMinSafe = 5. ;
GetValInNotes( m_Params.m_sUserNotes, UN_OPENMINSAFE, m_dOpenMinSafe) ;
// se richiesta anteprima
if ( nPvId != GDB_ID_NULL) {
// creo gruppo per geometria di lavorazione del percorso
int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nPvId, Frame3d()) ;
if ( nPxId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nPxId, sPathName) ;
m_pGeomDB->SetMaterial( nPxId, GREEN) ;
// creo l'anteprima del percorso
int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, CloneSurfFlatRegion( pSfr)) ;
if ( nRId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ;
m_pGeomDB->SetMaterial( nRId, Color( 255, 0, 0, 60)) ;
// la copio anche come regione ridotta
int nRrId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
if ( nRrId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ;
m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
}
// 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) ;
// verifico se archi vanno approssimati con segmenti di retta
bool bSplitArcs = GetSplitArcs( vtExtr) ;
// verifico se svuotatura in doppio con parte di essa da eseguire in parallelo
// determino dunque numero e affondamento degli step
int nStep = 0 ;
double dStep = - EPS_SMALL, dLastStep = - EPS_SMALL ;
DBLVECTOR vdSteps ;
int nDouble = GetDoubleType( m_Params.m_sUserNotes) ;
bool bDouble = ( nDouble != 0) ;
bool bUniformStep = true ;
if ( bDouble) {
// solo se lavorazione in doppio, recupero il LastStep se presente
dLastStep = GetDoubleLastStep() ;
if ( dLastStep > EPS_SMALL && abs( dLastStep - m_Params.m_dStep) > 10. * EPS_SMALL) {
double dStepPart = dElev - dLastStep ;
bUniformStep = ( dStepPart < EPS_SMALL) ; // se LastStep maggiore dell'elevazione, allora non lo considero
if ( bUniformStep) {
string sInfo = "Warning in PocketingNT : LastStep (" + ToString( dLastStep, 3) + ") bigger than"
"Elevation (" + ToString( dElev, 3) + ")" ;
m_pMchMgr->SetWarning( 2458, sInfo) ;
}
else {
nStep = max( 1, static_cast<int>( ceil( dStepPart / dOkStep))) ;
dStep = dStepPart / nStep ;
for ( int i = 1 ; i <= nStep ; ++ i)
vdSteps.push_back( i * dStep) ;
vdSteps.push_back( vdSteps.back() + dLastStep) ;
}
}
}
if ( bUniformStep) {
nStep = max( 1, static_cast<int>( ceil( dElev / dOkStep))) ;
dStep = dElev / nStep ;
for ( int i = 1 ; i <= nStep ; ++ i)
vdSteps.push_back( i * dStep) ;
}
// step per progressBar
int nProgressBarStep = 0 ;
// vettore per gli step
STEPINFOPOVECTOR vStepInfo ; vStepInfo.reserve( vdSteps.size()) ;
// regione esterna per Geometria di Selezione
ISURFFRPOVECTOR vSfrGeoExt ;
CalcGeoExtSurfFr( pSfr, vtTool, dDepth - dElev + vdSteps.back(), ( pStmTrim == nullptr ? pStmRaw : pStmTrim), vGeoSel, vSfrGeoExt) ;
for ( int j = 0 ; j < ssize( vdSteps) ; ++ j) {
// per i contatori non controllo se effettivamente svuoto una superficie o meno
++ nProgressBarStep ; // aggiorno step per progressBar
// porto la superficie allo step corrente
PtrOwner<ISurfFlatRegion> pSfrPock( CloneSurfFlatRegion( pSfr)) ;
if ( IsNull( pSfrPock) || ! pSfrPock->IsValid() ||
! pSfrPock->Translate( - vtTool * ( dDepth - dElev + vdSteps[j])))
return false ;
// adatto la regione piana alla geometria del grezzo
PtrOwner<ISurfFlatRegion> pSfrTrim( GetSfrRawProjection( ( pStmTrim == nullptr ? pStmRaw : pStmTrim), pSfrPock, vtTool)) ;
if ( IsNull( pSfrTrim)) {
m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Slicing Raw failed") ;
return false ;
}
if ( pSfrTrim->IsValid() && pSfrTrim->GetChunkCount() > 0) {
// se valida, limito la superficie di svuotatura alla proiezione del grezzo
// NB. Se la svuotatura è un foro chiuso il cui il raggio della circonferenza non è superiore a 3 volte il diamentro della
// tasca corrente, evito di fare intersezioni
const double DIAM_RATIO = 3. ;
bool bSkipIntersection = ( IsPocketingHole( pSfrPock, m_TParams.m_dDiam / 2., GetOffsR(), GetSideStep(), m_Params.m_nSubType,
GetLeadInType(), m_Params.m_dLiTang, DIAM_RATIO)) ;
#if DEBUG_SFR_RAW
int _nSfr = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySR, pSfrTrim->Clone()) ;
m_pGeomDB->SetMaterial( _nSfr, Color( 0., 1., 0., .75)) ;
#endif
if ( ! bSkipIntersection)
pSfrPock->Intersect( *pSfrTrim) ;
}
else
continue ; // svuotatura fuori dalla proiezione del grezzo, passo al prossimo step
// se ci sono regioni di Estensione esterne alla regione
for ( int i = 0 ; i < ssize( vSfrGeoExt) ; ++ i) {
if ( ! IsNull( vSfrGeoExt[i]) && vSfrGeoExt[i]->IsValid())
pSfrPock->Subtract( *vSfrGeoExt[i]) ;
}
// se regione risultante non vuota
if ( pSfrPock->IsValid() && pSfrPock->GetChunkCount() > 0) {
// determino i lati aperti
if ( ! ChooseCloseOrOpenEdge( pSfrPock, pStmExtrusion)) {
m_pMchMgr->SetLastError( 3026, "Error in PocketingNT : Detecting open edges failed") ;
return false ;
}
#if DEBUG_SFR_STEPS
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay, "Sfr_Pocketing") ;
DebugDrawSfr( pSfrPock, false, nLay) ;
#endif
// determino la regione limite
PtrOwner<ISurfFlatRegion> pSfrLimit( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrLimit) ||
! CalcLimitRegion( pSfrPock, pSfrTrim, pSfrLimit)) {
m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Calc limit region failed") ;
return false ;
}
#if DEBUG_SFR_STEPS
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pSfrLimit->Clone()) ;
m_pGeomDB->SetMaterial( _a, Color( .5, .5, .5, .5)) ;
#endif
// inserisco le informazioni dello step nel vettore
vStepInfo.resize( vStepInfo.size() + 1) ;
vStepInfo.back().dDepth = vdSteps[j] ;
vStepInfo.back().dRelativeDepth = ( j + 1 == ssize( vdSteps) && ! bUniformStep ? dLastStep : dStep) ;
vStepInfo.back().pSfrPock.Set( Release( pSfrPock)) ;
vStepInfo.back().pSfrLimit.Set( CreateSurfFlatRegion()) ;
if ( pSfrLimit->IsValid())
vStepInfo.back().pSfrLimit.Set( pSfrLimit) ;
}
// aggiorno la progressBar
ExeProcessEvents( 5 + nProgressBarStep * 45 / nStep, 0) ;
}
// imposto dati comuni
SetPathId( nPxId) ;
SetToolDir( vtTool) ;
// calcolo le lavorazioni
Point3d ptPockStart ; pSfr->GetCentroid( ptPockStart) ;
Point3d ptPockEnd = ptPockStart ;
if ( ! AddPocket( vStepInfo, vtTool, dStep, bSplitArcs, ptPockStart, ptPockEnd))
return false ;
// assegno il vettore estrazione al gruppo del percorso
m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ;
// assegno l'elevazione massima
m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;
// assegno il punto di inizio e fine al gruppo del percorso
m_pGeomDB->SetInfo( nPxId, KEY_START, ptPockStart) ;
m_pGeomDB->SetInfo( nPxId, KEY_END, ptPockEnd) ;
#if DEBUG_PATH_CL
PtrOwner<IGeoPoint3d> ptS( CreateGeoPoint3d()) ; ptS->Set( ptPockStart) ;
int nPtSId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, Release( ptS)) ;
m_pGeomDB->SetMaterial( nPtSId, AQUA) ;
PtrOwner<IGeoPoint3d> ptE( CreateGeoPoint3d()) ; ptE->Set( ptPockEnd) ;
int nPtEId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, Release( ptE)) ;
m_pGeomDB->SetMaterial( nPtEId, ORANGE) ;
PtrOwner<IGeoVector3d> vtT( CreateGeoVector3d()) ; vtT->Set( vtTool, ptPockEnd) ;
int nVtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, Release( vtT)) ;
m_pGeomDB->SetMaterial( nVtId, Color( abs( vtTool.x), abs( vtTool.y), abs( vtTool.z))) ;
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ; pLine->Set( ptPockEnd, ptPockEnd + vtTool * dElev) ;
int nLineID = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, Release( pLine)) ;
m_pGeomDB->SetMaterial( nLineID, FUCHSIA) ;
#endif
}
// incremento numero di svuotature
++ m_nPockets ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dDepth,
double dRad, double dLen, double& dElev)
{
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid())
return false ;
// inizializzo l'elevazione
dElev = 0. ;
// recupero tutti i loop della regione
for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
// recupero la curva
PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
if ( IsNull( pCrvLoop) || ! pCrvLoop->IsValid())
return false ;
// se isola inverto
if ( nL > 0)
pCrvLoop->Invert() ;
// approssimo la curva con una polilinea che uso per creare il poligono equivalente
PolyLine PL ;
if ( ! pCrvLoop->ApproxWithLines( LIN_TOL_RAW, ANG_TOL_MAX_DEG, ICurve::APL_SPECIAL, PL))
return false ;
Polygon3d pgFacet ;
if ( ! pgFacet.FromPolyLine( PL))
return false ;
// aggiungo l'affondamento
pgFacet.Translate( - dDepth * vtTool) ;
// inizializzo l'elevazione corrente
double dMyElev = 0. ;
// inizializzo elevazioni per ogni grezzo
INTDBLVECTOR vRawElev ;
// ciclo sui grezzi della fase
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
// verifico che il grezzo compaia nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
// recupero la trimesh del grezzo
int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nStmId)) ;
if ( pStm != nullptr) {
// recupero il riferimento della trimesh
Frame3d frStm ;
m_pGeomDB->GetGlobFrame( nStmId, frStm) ;
// porto il poligono in questo riferimento
Polygon3d pgFacetL = pgFacet ;
pgFacetL.ToLoc( frStm) ;
// calcolo l'elevazione
double dCurrElev ;
if ( ! PolygonElevationInClosedSurfTm( pgFacetL, *pStm, true, dCurrElev))
return false ;
if ( dCurrElev > EPS_SMALL)
vRawElev.emplace_back( nStmId, dCurrElev) ;
}
}
// passo al grezzo successivo
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
// se trovate elevazioni
if ( ! vRawElev.empty()) {
// ordino il vettore secondo l'elevazione crescente
sort( vRawElev.begin(), vRawElev.end(), []( const INTDBL& a, const INTDBL& b)
{ return a.second < b.second ; }) ;
// box dell'insieme delle posizioni utensile all'inizioe
const double MAX_DIST_RAW = 200.0 ;
BBox3d b3Tool ;
pgFacet.GetLocalBBox( b3Tool) ;
b3Tool.Add( b3Tool.GetMin() + dLen * vtTool) ;
b3Tool.Add( b3Tool.GetMax() + dLen * vtTool) ;
if ( vtTool.IsX())
b3Tool.Expand( 0, dRad, dRad) ;
else if ( vtTool.IsY())
b3Tool.Expand( dRad, 0, dRad) ;
else if ( vtTool.IsZ())
b3Tool.Expand( dRad, dRad, 0) ;
else {
double dExpandX = dRad * sqrt( 1 - vtTool.x * vtTool.x) ;
double dExpandY = dRad * sqrt( 1 - vtTool.y * vtTool.y) ;
double dExpandZ = dRad * sqrt( 1 - vtTool.z * vtTool.z) ;
b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
}
b3Tool.Expand( MAX_DIST_RAW) ;
// verifico la reale interferenza dell'utensile con i diversi grezzi
for ( int i = 0 ; i < int( vRawElev.size()) ; ++ i) {
// box del grezzo
BBox3d b3Raw ;
m_pGeomDB->GetGlobalBBox( vRawElev[i].first, b3Raw) ;
// confronto con il box dell'utensile nella posizione precedente
BBox3d b3CurrTool = b3Tool ;
b3CurrTool.Translate( dMyElev * vtTool) ;
if ( b3Raw.Overlaps( b3CurrTool))
dMyElev = vRawElev[i].second ;
}
}
dElev = max( dElev, dMyElev) ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool)
{
// se non è svuotatura dal basso in alto, esco
if ( vtTool.z > MIN_ZDIR_TOP_TOOL)
return true ;
// se c'è testa non dall'alto o tavola basculante, esco
if ( ! m_bAboveHead || m_bTiltingTab)
return true ;
// recupero dati di eventuale rinvio da sotto
if ( ! GetAggrBottomData( m_TParams.m_sHead, m_AggrBottom) || m_AggrBottom.nType == 0) {
m_pMchMgr->SetLastError( 2409, "Error in PocketingNT : missing aggregate from bottom") ;
return false ;
}
// calcolo il minimo della massima distanza del percorso dal contorno del grezzo
double dMinDist = INFINITO ;
Vector3d vtMinDir ;
VCT3DVECTOR vDir ;
double dParS, dParE ; pCompo->GetDomain( dParS, dParE) ;
for ( double dPar = dParS ; dPar < dParE + EPS_PARAM ; dPar += 0.5) {
// distanza minima del punto e relativa direzione dal contorno del grezzo
Point3d ptP ; double dCurrDist = INFINITO ; Vector3d vtCurrDir ;
if ( pCompo->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptP) &&
GetMinDistanceFromRawSide( m_nPhase, ptP, 0, m_AggrBottom.vtMDir, MCH_AGB_DELTAMAX_MDIR, dCurrDist, vtCurrDir) &&
! vtCurrDir.IsSmallXY()) {
if ( dCurrDist < dMinDist - 10 * EPS_SMALL &&
find_if( vDir.begin(), vDir.end(), [&](const Vector3d& vtV){ return vtCurrDir * vtV > cos( 15 * DEGTORAD) ; }) == vDir.end()) {
// inserisco la direzione tra quelle già esplorate
vDir.emplace_back( vtCurrDir) ;
// determino la distanza di tutti gli altri punti dal contorno del grezzo lungo questa direzione
for ( double dPar2 = dParS ; dPar2 < dParE + EPS_PARAM ; dPar2 += 0.5) {
if ( abs( dPar2 - dPar) > EPS_PARAM) {
Point3d ptQ ;
double dQDist ;
if ( pCompo->GetPointD1D2( dPar2, ICurve::FROM_MINUS, ptQ) &&
GetDistanceFromRawSide( m_nPhase, ptQ, vtCurrDir, dQDist) && dQDist > dCurrDist)
dCurrDist = dQDist ;
}
}
// se la massima distanza trovata è inferiore al minimo, lo aggiorno
if ( dCurrDist < dMinDist) {
dMinDist = dCurrDist ;
vtMinDir = vtCurrDir ;
}
}
}
}
// se supera il limite, errore
if ( dMinDist - ( m_TParams.m_dDiam / 2 + GetOffsR()) > m_AggrBottom.dDMax) {
m_pMchMgr->SetLastError( 2410, "Error in PocketingNT : path too far from part sides") ;
return false ;
}
// assegno direzione di accesso e segnalo utilizzo aggregato da sotto
m_vtAggrBottom = vtMinDir ;
m_bAggrBottom = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo)
{
// creo copia della curva composita
PtrOwner<ICurve> pCrv( pCompo->Clone()) ;
if ( IsNull( pCrv))
return false ;
// calcolo la regione
SurfFlatRegionByContours SfrCntrRr ;
SfrCntrRr.AddCurve( Release( pCrv)) ;
PtrOwner<ISurfFlatRegion> pSfr( SfrCntrRr.GetSurf()) ;
if ( IsNull( pSfr))
return false ;
// ne recupero il contorno
PtrOwner< ICurve> pCrv2 ;
pCrv2.Set( pSfr->GetLoop( 0, 0)) ;
if ( IsNull( pCrv2))
return false ;
// inserisco la curva nel DB
int nC2Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv2)) ;
if ( nC2Id == GDB_ID_NULL)
return false ;
// assegno nome e colore
m_pGeomDB->SetName( nC2Id, MCH_PV_CUT) ;
m_pGeomDB->SetMaterial( nC2Id, RED) ;
// eventuali altri contorni ( interni di contornatura chiusa)
const int MAX_INT_LOOP = 1000 ;
for ( int i = 1 ; i <= MAX_INT_LOOP ; ++i) {
PtrOwner< ICurve> pCrv3 ;
pCrv3.Set( pSfr->GetLoop( 0, i)) ;
if ( IsNull( pCrv3))
break ;
// inserisco la curva nel DB
int nC3Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv3)) ;
if ( nC3Id == GDB_ID_NULL)
return false ;
// assegno nome e colore
m_pGeomDB->SetName( nC3Id, MCH_PV_CUT) ;
m_pGeomDB->SetMaterial( nC3Id, RED) ;
}
// inserisco la regione nel DB
int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfr)) ;
if ( nRId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ;
m_pGeomDB->SetMaterial( nRId, Color( 255, 0, 0, 60)) ;
// la copio anche come regione ridotta
int nRrId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
if ( nRrId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ;
m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcRetCurve( PathInfoPO& PathInfo, const StepInfoPO& StepInfo, const ICurveComposite* pCrvPath,
const Vector3d& vtTool, bool bHolePocketing, bool bInVsOut, ICurveComposite* pCrvGlide)
{
/* Funzione per il calcolo della curva a sciovolo (piana) in entrata o in uscita
pCrvGlide = nullptr */
// controllo dei parametri
if ( pCrvPath == nullptr || ! pCrvPath->IsValid() ||
pCrvGlide == nullptr)
return false ;
// se caso speciale curva a spirale
if ( bHolePocketing) {
Point3d ptStart ; pCrvPath->GetStartPoint( ptStart) ;
Point3d ptEnd ; pCrvPath->GetEndPoint( ptEnd) ;
if ( ! AreSamePointApprox( ptStart, ptEnd)) {
Vector3d vtStart ; pCrvPath->GetStartDir( vtStart) ;
PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
if ( IsNull( pArc) || ! pArc->Set2PVN( ptStart, ptEnd, - vtStart, vtTool)) {
m_pMchMgr->SetLastError( 2420, "Error in Pocketing : Return toolpath not computable") ;
return false ;
}
// inverto
pArc->Invert() ;
// definisco la curva per lo scivolo
PtrOwner<ICurveComposite> pCrvGlideTmp( CreateCurveComposite()) ;
if ( IsNull( pCrvGlideTmp) || ! pCrvGlideTmp->AddCurve( Release( pArc)))
return false ;
// calcolo la curva in base ai parametri
double dLen = 0. ; pCrvGlideTmp->GetLength( dLen) ;
double dParS, dParE ; pCrvGlideTmp->GetDomain( dParS, dParE) ;
double dU ;
// se LeadIn a scivolo, recupero il parametro sulla curva
if ( bInVsOut) {
if ( GetLeadInType() == POCKET_LI_GLIDE) {
if ( ! pCrvGlideTmp->GetParamAtLength( dLen - m_Params.m_dLiTang, dU))
dU = 0. ;
pCrvGlide->AddCurve( pCrvGlideTmp->CopyParamRange( dU, dParE)) ;
}
else
dU = dParE ;
// calcolo la curva di ritorno
PtrOwner<ICurveComposite> pCrvRet( ConvertCurveToComposite( pCrvGlideTmp->CopyParamRange( dParS, dU))) ;
if ( ! IsNull( pCrvRet) && pCrvRet->IsValid()) {
if ( ! PathInfo.pCrvRet.Set( Release( pCrvRet)))
return false ;
}
}
// Se LeadOut a scivolo
else {
if ( GetLeadOutType() == POCKET_LO_GLIDE) {
if ( ! pCrvGlideTmp->GetParamAtLength( m_Params.m_dLoTang, dU))
dU = dParE ;
pCrvGlide->AddCurve( pCrvGlideTmp->CopyParamRange( dParS, dU)) ;
if ( ! pCrvGlide->IsValid())
return false ;
}
}
}
// non c'è bisogno di verificare nulla con la regione limite
return true ;
}
// se regione di svuotatura generica
else {
// Entrata a Scivolo
if ( bInVsOut) {
// se l'entrata non è a scivolo, non faccio nulla
if ( GetLeadInType() != POCKET_LI_GLIDE)
return true ;
// se l'entrata è presso un lato aperto, non faccio nulla
if ( PathInfo.bOutStart)
return true ;
// l'entrata a scivolo viene eseguita nel caso di percorsi SpiralIn/Out o curve di bordo chiuse
if ( ( PathInfo.bSingleCrv && ! pCrvPath->IsClosed()) ||
( PathInfo.bOptTrap && ! pCrvPath->IsClosed()) ||
( PathInfo.bIsZigZagOneWayBorder && ! pCrvPath->IsClosed()))
return true ;
// inizializzo e recupero il percorso :
PtrOwner<ICurveComposite> pCrvGlideIn( CreateCurveComposite()) ;
if ( IsNull( pCrvGlideIn))
return false ;
// se chiuso
if ( pCrvPath->IsClosed())
pCrvGlideIn->CopyFrom( pCrvPath) ;
// se aperto
else {
// potrebbe esserci un percorso interno chiuso, lo cerco
Point3d ptStart ; pCrvPath->GetStartPoint( ptStart) ;
int nCrv = 0 ;
bool bOk = false ;
for ( ; nCrv < pCrvPath->GetCurveCount() ; ++ nCrv) {
const ICurve* pCrv = pCrvPath->GetCurve( nCrv) ;
if ( pCrv == nullptr)
return false ;
Point3d ptEnd ; pCrv->GetEndPoint( ptEnd) ;
if ( AreSamePointApprox( ptStart, ptEnd)) {
++ nCrv ;
bOk = true ;
break ;
}
}
// se non trovato, non faccio nulla
if ( ! bOk)
return true ;
// altrimenti, lo memorizzo
pCrvGlideIn.Set( ConvertCurveToComposite( pCrvPath->CopyParamRange( 0, nCrv))) ;
}
// se percorso a guida non valido, non faccio nulla
if ( IsNull( pCrvGlideIn) || ! pCrvGlideIn->IsValid())
return true ;
// controllo che la lunghezza del percorso sia compatibile
double dLen = 0. ;
if ( pCrvGlideIn->GetLength( dLen) && dLen < m_Params.m_dLiTang + 10 * EPS_SMALL)
return true ;
// recupero il tratto di curva alla fine
double dU, dParS, dParE ;
if ( ! pCrvGlideIn->GetParamAtLength( dLen - m_Params.m_dLiTang, dU) ||
! pCrvGlideIn->GetDomain( dParS, dParE))
return false ;
pCrvGlide->AddCurve( pCrvGlideIn->CopyParamRange( dU, dParE)) ;
if ( ! pCrvGlide->IsValid())
return false ;
}
// Uscita a scivolo
else {
// se l'uscita non è a scivolo, non faccio nulla
if ( GetLeadOutType() != POCKET_LO_GLIDE)
return true ;
// se l'uscita è presso un lato aperto, non faccio nulla
if ( PathInfo.bOutEnd)
return true ;
// se l'uscita è a scivolo e sono in un caso a trapezio, non faccio nulla
if ( PathInfo.bOptTrap)
return true ;
// inizializzo e recupero il percorso :
PtrOwner<ICurveComposite> pCrvGlideOut( CreateCurveComposite()) ;
if ( IsNull( pCrvGlideOut))
return false ;
// se il tratto è chiuso
if ( pCrvPath->IsClosed())
pCrvGlideOut->CopyFrom( pCrvPath) ;
// se aperto
else {
// percorro a ritroso il percorso cercano una curva che inizi presso la fine del percorso
Point3d ptEnd ; pCrvPath->GetEndPoint( ptEnd) ;
int nCrv = pCrvPath->GetCurveCount() - 1 ;
bool bOk = false ;
for ( ; nCrv >= 0 ; -- nCrv) {
const ICurve* pCrv = pCrvPath->GetCurve( nCrv) ;
if ( pCrv == nullptr)
return false ;
Point3d ptStart ; pCrv->GetStartPoint( ptStart) ;
if ( AreSamePointApprox( ptEnd, ptStart)) {
bOk = true ;
break ;
}
}
// se trovata, la memorizzo
if ( bOk) {
PtrOwner<ICurveComposite> pCrvTmp( ConvertCurveToComposite( pCrvPath->CopyParamRange( nCrv, pCrvPath->GetCurveCount() - 1))) ;
if ( ! IsNull( pCrvTmp) && pCrvTmp->IsValid()) {
pCrvGlideOut.Set( Release( pCrvTmp)) ;
}
}
}
// se curva valida
if ( ! IsNull( pCrvGlideOut) && pCrvGlideOut->IsValid()) {
// controllo che la lunghezza del percorso sia compatibile
double dLen = 0. ;
if ( pCrvGlideOut->GetLength( dLen) && dLen > m_Params.m_dLoTang + 10 * EPS_SMALL) {
// recupero il tratto di curva alla fine
double dU = 0. ;
if ( ! pCrvGlideOut->GetParamAtLength( m_Params.m_dLoTang, dU))
return false ;
pCrvGlide->AddCurve( pCrvGlideOut->CopyParamRange( 0., dU)) ;
}
// se non sufficientemente lunga, la guida diventa la curva stessa
else
pCrvGlide->AddCurve( Release( pCrvGlideOut)) ;
if ( ! pCrvGlide->IsValid())
return false ;
}
// se curva non valida, provo con estensione lineare ( TODO : arco ?)
else {
Point3d ptEnd ; pCrvPath->GetEndPoint( ptEnd) ;
Vector3d vtEnd ; pCrvPath->GetEndDir( vtEnd) ;
PtrOwner<ICurveComposite> pCrvGlideOut( CreateCurveComposite()) ;
if ( IsNull( pCrvGlideOut) ||
! pCrvGlideOut->AddPoint( ptEnd) ||
! pCrvGlideOut->AddLine( ptEnd + m_Params.m_dLoTang * vtEnd) ||
! pCrvGlideOut->IsValid())
return false ;
pCrvGlide->CopyFrom( pCrvGlideOut) ;
if ( ! pCrvGlide->IsValid())
return false ;
}
}
}
#if DEBUG_GLIDE
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay, "Glide_Crv") ;
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvPath->Clone()) ;
m_pGeomDB->SetMaterial( _a, GREEN) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvGlide->Clone()) ;
m_pGeomDB->SetMaterial( _a, bInVsOut ? LIME : FUCHSIA) ;
#endif
// verifico che il percorso sia al di fuori della regione limite
if ( StepInfo.pSfrPock != nullptr && StepInfo.pSfrPock->IsValid()) {
#if DEBUG_GLIDE
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, StepInfo.pSfrPock->Clone()) ;
m_pGeomDB->SetMaterial( _a, Color( 0., 1., 0., .35)) ;
#endif
if ( ! VerifyLeadInOutGlide( StepInfo.pSfrPock, pCrvGlide))
pCrvGlide->Clear() ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcPaths( STEPINFOPOVECTOR& vStepInfo)
{
// se non ho Step, non faccio nulla
if ( vStepInfo.empty())
return true ;
// punto finale di riferimento per il percorso attuale ( serve per trovare il punto iniziale
// del percorso successivo). Parto analizzando la testa ( da sopra/da sotto)
Point3d ptStartRef = GetStartPointsByHead( vStepInfo) ;
// --- se punto invalido e raggio utensile grande
if ( ! ptStartRef.IsValid() && m_TParams.m_dDiam / 2. > TOOL_RAD_PTSTART - EPS_ZERO) {
// cerco l'ingresso in base alla geometria iniziale della tasca
ptStartRef = GetStartPointsFromSteps( vStepInfo, TEMP_PROP_OPEN_EDGE) ;
if ( ! ptStartRef.IsValid())
ptStartRef = GetStartPointsFromSteps( vStepInfo, TEMP_PROP_CLOSE_EDGE) ;
}
// recupero flag per casi ottimizzati
double dMaxOptSize = m_Params.m_dSideStep ;
GetValInNotes( m_Params.m_sUserNotes, UN_MAXOPTSIZE, dMaxOptSize) ;
// recupero flag per calcolo delle Feed
bool bAdjustFeed = false ;
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch != nullptr) {
string sMachIni = pMch->GetMachineDir() + "\\" + pMch->GetMachineName() + ".ini" ;
int nAdjustFeed = GetPrivateProfileInt( MACHININGS_SEC.c_str(), POCKETING_FEED_KEY.c_str(), 0, sMachIni.c_str()) ;
bAdjustFeed = ( nAdjustFeed != 0) ;
}
bool bUnAdjustFeed = false ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_ADJUSTFEED, bUnAdjustFeed) && bUnAdjustFeed)
bAdjustFeed = true ;
// verifico se percorso di lucidatura
bool bAllOffset = false ;
bool bPolishing = ( m_TParams.m_nType == TT_MILL_POLISHING) ;
if ( bPolishing) {
int nType = GetType() ;
if ( ( nType == POCKET_SPIRALIN || GetType() == POCKET_SPIRALOUT) && m_Params.m_dEpicyclesRad < EPS_SMALL)
bPolishing = false ;
if ( bPolishing) {
if ( ( nType == POCKET_SPIRALIN || GetType() == POCKET_SPIRALOUT) && m_Params.m_dEpicyclesDist < 100. * EPS_SMALL) {
m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
return false ;
}
bAllOffset = true ;
}
}
// determino il SideStep
double dSideStep = ( ! bPolishing ? GetSideStep() : m_Params.m_dSideStep) ;
// determino se Conventional Milling o Climb Milling per curve singole
bool bConventionalMilling = ( m_Params.m_nSubType == POCKET_SPIRALIN || m_Params.m_nSubType == POCKET_SPIRALOUT ||
m_Params.m_nSubType == POCKET_ONEWAY || m_Params.m_nSubType == POCKET_CONFORMAL_ONEWAY) ;
// scorro gli indici delle superfici
for ( int i = 0 ; i < int( vStepInfo.size()) ; ++ i) {
// calcolo i percorsi di Pocketing ( o di lucidatura se richiesto)
ICRVCOMPOPOVECTOR vCrvPaths ;
if ( ! CalcPocketing( vStepInfo[i].pSfrPock, m_TParams.m_dDiam / 2, GetOffsR(), dSideStep,
m_Params.m_dSideAngle, m_dOpenMinSafe, m_Params.m_nSubType, true, true, m_Params.m_bInvert,
false, bConventionalMilling, true, bAdjustFeed, ptStartRef, vStepInfo[i].pSfrLimit, bAllOffset, dMaxOptSize,
GetLeadInType(), m_Params.m_dLiTang, m_Params.m_dLiElev, GetLeadOutType(), m_Params.m_dLoTang,
bPolishing, m_Params.m_dEpicyclesRad, m_Params.m_dEpicyclesDist, vCrvPaths)) {
m_pMchMgr->SetLastError( 3028, "Error in PocketingNT : Error in CalcPocketing") ;
return false ;
}
// se non ho ottenuto percorsi, errore
if ( vCrvPaths.empty())
return false ;
// sistemo gli archi per massimo angolo al centro
for ( int j = 0 ; j < ssize( vCrvPaths) ; ++ j)
VerifyArcs( vCrvPaths[j]) ;
// inserisco i percorsi nel vettore dei Paths
vStepInfo[i].vPaths.resize( vCrvPaths.size()) ;
for ( int j = 0 ; j < ssize( vCrvPaths) ; ++ j) {
// controllo se il percorso ha un ingresso presso un lato aperto
vStepInfo[i].vPaths[j].bOutStart = ( vCrvPaths[j]->GetCurveCount() > 0 &&
vCrvPaths[j]->GetFirstCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ;
if ( ! vStepInfo[i].vPaths[j].bOutStart && ! LeadInRawIsOk()) {
m_pMchMgr->SetLastError( 2431, "Error in Pocketing : LeadIn with Mill NoTip in material") ;
return false ;
}
if ( vStepInfo[i].vPaths[j].bOutStart && ! m_bOpenOutRaw) {
// se richiesto, controllo di essere davvero fuori dal grezzo [controllo basilare, migliorabile]
Point3d ptStart ; vCrvPaths[j]->GetStartPoint( ptStart) ;
double dElev ;
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
pCrvArc->Set( ptStart, m_vtTool, 50. * EPS_SMALL) ;
PtrOwner<ISurfFlatRegion> pSfrCheck( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrCheck) || ! pSfrCheck->AddExtLoop( Release( pCrvArc)))
return false ;
if ( CalcRegionElevation( pSfrCheck, m_vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev) &&
dElev > EPS_SMALL) {
vStepInfo[i].vPaths[j].bOutStart = false ;
delete( vCrvPaths[j]->RemoveFirstOrLastCurve( false)) ;
}
}
// controllo se il percorso ha un'uscita presso un lato aperto
vStepInfo[i].vPaths[j].bOutEnd = ( vCrvPaths[j]->GetCurveCount() > 0 &&
vCrvPaths[j]->GetLastCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ;
// controllo se il percorso è formato da una singola curva seguente il lato chiuso
vStepInfo[i].vPaths[j].bSingleCrv = ( vCrvPaths[j]->GetCurveCount() > 0 &&
vCrvPaths[j]->GetTempProp( 0) == TEMP_PROP_SINGLE_CURVE) ;
// controllo se caso ottimizzato a trapezio
vStepInfo[i].vPaths[j].bOptTrap = ( vCrvPaths[j]->GetCurveCount() > 0 &&
vCrvPaths[j]->GetTempProp( 0) == TEMP_PROP_OPT_TRAPEZOID) ;
// controllo se caso ottimizzato a spirale
vStepInfo[i].vPaths[j].bOptCirle = ( vCrvPaths[j]->GetCurveCount() > 0 &&
vCrvPaths[j]->GetTempProp( 0) == TEMP_PROP_OPT_CIRCLE) ;
// controllo se è un percorso a ZigZag/OneWay ( non curva di bordo)
vStepInfo[i].vPaths[j].bIsZigZagOneWayBorder = ( vCrvPaths[j]->GetCurveCount() > 0 &&
( m_Params.m_nSubType == POCKET_SUB_ONEWAY || m_Params.m_nSubType == POCKET_SUB_ZIGZAG) &&
vCrvPaths[j]->GetTempProp( 0) == TEMP_PROP_BORDER_CURVE) ;
// assegno il percorso
if ( ! vStepInfo[i].vPaths[j].pCrvPath.Set( vCrvPaths[j]))
return false ;
}
// definisco il nuovo punto di riferimento per il percorso successivo
// Se caso ottimizzato a spirale
if ( ssize( vStepInfo[i].vPaths) == 1 && vStepInfo[i].vPaths[0].bOptCirle) {
// Se entrata da fuori, ricomincio dall'esterno
if ( vStepInfo[i].vPaths[0].bOutStart)
vStepInfo[i].vPaths[0].pCrvPath->GetStartPoint( ptStartRef) ;
// altrimenti
else {
if ( m_Params.m_nSubType == POCKET_SPIRALOUT)
vStepInfo[i].vPaths[0].pCrvPath->GetEndPoint( ptStartRef) ; // è invertito
else
vStepInfo[i].vPaths[0].pCrvPath->GetStartPoint( ptStartRef) ;
}
}
// altrimenti rimane fisso al punto iniziale del percorso precedente
else
vStepInfo[i].vPaths.front().pCrvPath->GetStartPoint( ptStartRef) ;
// aggiorno la progressBar
ExeProcessEvents( 50 + i * 50 / ssize( vStepInfo), 0) ;
}
// controllo se la svuotatura è riferita ad un foro chiuso
bool bHolePocketing = true ;
for ( int i = 0 ; i < ssize( vStepInfo) && bHolePocketing ; ++ i) {
bHolePocketing = ( ssize( vStepInfo[i].vPaths) == 1 && vStepInfo[i].vPaths[0].bOptCirle &&
! vStepInfo[i].vPaths[0].bOutStart && ! vStepInfo[i].vPaths[0].bOutEnd) ;
}
// se foro chiuso ed entrata ad elica, aggiusto il raggio massimo
if ( bHolePocketing && m_Params.m_nSubType == POCKET_SUB_SPIRALOUT && GetLeadInType() == POCKET_LI_HELIX) {
for ( const StepInfoPO& currStep : vStepInfo) {
if ( currStep.pSfrPock != nullptr && currStep.pSfrPock->IsValid()) {
double dRad = 0. ;
currStep.pSfrPock->GetMaxOffset( dRad) ;
m_dMaxHelixRad = min( 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam), dRad - ( m_TParams.m_dDiam / 2. + GetOffsR())) ; ;
break ;
}
}
}
// calcolo la curva di ritorno ( se necessaria)
for ( int i = 0 ; i < ssize( vStepInfo) ; ++ i) {
for ( int j = 0 ; j < ssize( vStepInfo[i].vPaths) ; ++ j) {
if ( GetLeadInType() == POCKET_LI_GLIDE || bHolePocketing) {
PtrOwner<ICurveComposite> pCrvGlideIn( CreateCurveComposite()) ;
if ( IsNull( pCrvGlideIn) ||
! CalcRetCurve( vStepInfo[i].vPaths[j], vStepInfo[i], vStepInfo[i].vPaths[j].pCrvPath,
vStepInfo[i].pSfrPock->GetNormVersor(), bHolePocketing, true, pCrvGlideIn)) {
m_pMchMgr->SetLastError( 2415, "Error in PocketingNT : LeadIn not computable") ;
return false ;
}
if ( ! IsNull( pCrvGlideIn) && pCrvGlideIn->IsValid())
if ( ! vStepInfo[i].vPaths[j].pCrvGlideIn.Set( Release( pCrvGlideIn)))
return false ;
}
// se uscita a scivolo
if ( GetLeadOutType() == POCKET_LO_GLIDE || bHolePocketing) {
PtrOwner<ICurveComposite> pCrvGlideOut( CreateCurveComposite()) ;
if ( IsNull( pCrvGlideOut) ||
! CalcRetCurve( vStepInfo[i].vPaths[j], vStepInfo[i], vStepInfo[i].vPaths[j].pCrvPath,
vStepInfo[i].pSfrPock->GetNormVersor(), bHolePocketing, false, pCrvGlideOut)) {
m_pMchMgr->SetLastError( 2416, "Error in PocketingNT : LeadOut not computable") ;
return false ;
}
if ( ! IsNull( pCrvGlideOut) && pCrvGlideOut->IsValid())
if ( ! vStepInfo[i].vPaths[j].pCrvGlideOut.Set( Release( pCrvGlideOut)))
return false ;
}
}
}
// calcolo il percorso a ZigZag di ritorno ( se necessario)
if ( GetLeadInType() != POCKET_LI_NONE && GetLeadInType() != POCKET_LI_GLIDE) {
for ( int i = 0 ; i < ssize( vStepInfo) ; ++ i) {
for ( int j = 0 ; j < ssize( vStepInfo[i].vPaths) ; ++ j) {
if ( IsNull( vStepInfo[i].vPaths[j].pCrvPath) || ! vStepInfo[i].vPaths[j].pCrvPath->IsValid())
continue ;
PtrOwner<ICurveComposite> pCompoZigZag( CreateCurveComposite()) ;
if ( IsNull( pCompoZigZag))
return false ;
Point3d ptStart ; vStepInfo[i].vPaths[j].pCrvPath->GetStartPoint( ptStart) ;
bool bOk = true ;
for ( int nC = 0 ; bOk && nC < vStepInfo[i].vPaths[j].pCrvPath->GetCurveCount() ; ++ nC) {
const ICurve* pCrv = vStepInfo[i].vPaths[j].pCrvPath->GetCurve( nC) ;
bOk = ( pCrv != nullptr && pCrv->IsValid() && pCompoZigZag->AddCurve( *pCrv)) ;
if ( bOk) {
Point3d ptEnd ; pCrv->GetEndPoint( ptEnd) ;
if ( AreSamePointEpsilon( ptStart, ptEnd, 25. * EPS_SMALL))
break ;
}
}
if ( bOk)
vStepInfo[i].vPaths[j].pCrvZigZagIn.Set( Release( pCompoZigZag)) ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::ManageSmoothLink( const PathInfoPO& currPath, const PathInfoPO& nextPath, bool bSamePlane,
bool& bSmoothEnd, bool& bForceLinear)
{
// definizione smusso finale a seconda del tipo di lavorazioni
bSmoothEnd = true ;
bForceLinear = false ;
switch ( m_Params.m_nSubType)
{
case POCKET_SUB_SPIRALIN :
case POCKET_SUB_SPIRALOUT :
// ... se devo scendere allo step successivo presso un lato aperto
if ( ! bSamePlane && nextPath.bOutStart) {
// ... non smusso il percorso finale
bSmoothEnd = false ;
return true ;
}
break ;
case POCKET_SUB_ZIGZAG :
case POCKET_SUB_ONEWAY :
// ... se sono sullo stesso piano e passo da un tratto finale aperto ad un tratto iniziale aperto...
if ( bSamePlane && currPath.bOutEnd && nextPath.bOutStart) {
// .. smusso sia inizio che fine
return true ;
}
bForceLinear = true ;
break ;
case POCKET_SUB_CONFORMAL_ONEWAY :
case POCKET_SUB_CONFORMAL_ZIGZAG :
// ... se devo scendere allo step successivo presso un lato aperto
if ( ! bSamePlane && nextPath.bOutStart) {
// ... non smusso il percorso finale
bSmoothEnd = false ;
return true ;
}
break ;
default:
break ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::VerifyParallelPocketing( int nDouble, const STEPINFOPOVECTOR& vStepInfo) const
{
// verifico se lavorazione in doppio valida
if ( nDouble != 1 && nDouble != 2 && nDouble != 3)
return false ;
// se non ho piano di pocketing allora non devo fare nulla
if ( vStepInfo.empty())
return false ;
// se la macchina non presenta nel file .ini la possibilità di lavorazione in doppio parallela, esco
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch == nullptr)
return false ;
string sMachIni = pMch->GetMachineDir() + "\\" + pMch->GetMachineName() + ".ini" ;
int nPocketingDouble = GetPrivateProfileInt( MACHININGS_SEC.c_str(), POCKETING_PARALLEL_KEY.c_str(), 0, sMachIni.c_str()) ;
if ( nPocketingDouble != 1)
return false ;
// recupero il piano di Mirror
Point3d ptOn ; Vector3d vtNorm ;
if ( ! CalcMirrorPlaneByDouble( nDouble, m_Params.m_sUserNotes, ptOn, vtNorm))
return false ;
Plane3d plMirror ;
if ( ! plMirror.Set( ptOn, vtNorm))
return false ;
// recupero il piano dell'ultima svuotatura
bool bOk = false ;
Plane3d plLastStep ;
for ( auto Iter = vStepInfo.rbegin() ; ! bOk && Iter != vStepInfo.rend() ; ++ Iter) {
if ( Iter->pSfrPock != nullptr && Iter->pSfrPock->IsValid()) {
for ( int nPath = 0 ; ! bOk && nPath < ssize( ( *Iter).vPaths) ; ++ nPath) {
if ( ( *Iter).vPaths[nPath].pCrvPath != nullptr && ( *Iter).vPaths[nPath].pCrvPath->IsValid()) {
Point3d ptLastStep ; ( *Iter).pSfrPock->GetCentroid( ptLastStep) ;
bOk = ( plLastStep.Set( ptLastStep, ( *Iter).pSfrPock->GetNormVersor())) ;
}
}
}
}
if ( ! bOk)
return false ;
// verifico subito che la normale del piano si trovi entro un grado rispetto alla direzione di svuotatura ( tolleranza da .BTL)
if ( abs( plLastStep.GetVersN() * vtNorm) < cos( ( 1. - EPS_ANG_SMALL) * DEGTORAD))
return false ;
// se l'ultimo piano di pocketing si trova nel semipiano positivo di Mirroring e sufficientemente distante da esso non eseguo la lavorazione
// in parallelo ( SAFE_DIST_TOL è la distanza tra l'utensile e il piano di Mirror, quindi la distanza tra le due "punte" è il doppio)
const double SAFE_DIST_TOL = 5. ; // -->! distanza tra le punte è il doppio
double dDist = ( plLastStep.GetPoint() - ptOn) * plLastStep.GetVersN() ;
if ( dDist < EPS_SMALL)
return true ;
double dSafeTipDist = m_TParams.m_dTLen - m_TParams.m_dLen ; // nelle svuotature mi aspetto 0.
if ( dDist < dSafeTipDist + SAFE_DIST_TOL)
return true ;
return false ;
}
//----------------------------------------------------------------------------
double
PocketingNT::GetDoubleLastStep( void)
{
// se non è pocketing in doppio, restituisco valore negativo
const double FALSE_LASTSTEP = - EPS_SMALL ;
if ( GetDoubleType( m_Params.m_sUserNotes) == 0)
return FALSE_LASTSTEP ;
// recupero valore
const double MIN_LASTSTEP = 15 ;
double dDoubleLastStep = m_Params.m_dStep ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_LASTSTEP, dDoubleLastStep))
dDoubleLastStep = max( dDoubleLastStep, MIN_LASTSTEP) ;
return dDoubleLastStep ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcDoubleParallelPenultimateStep( int nDouble, int nIdDblS, double dStep, double dLastStep, const Point3d& ptNeatEnd, const Vector3d& vtEnd,
const INTVECTOR& vLeadOutId, const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool,
bool bSplitArcs, double dMinFeed)
{
// recupero l'ultima entità del percorso
int nIdDblEnd = m_pGeomDB->GetLastInGroup( m_nPathId) ;
if ( nIdDblS > nIdDblEnd)
return false ;
// determino il piano corrente di svuotatura
Plane3d plLastStep ;
if ( ! plLastStep.Set( ptNeatEnd, vtTool))
return false ;
INTVECTOR vIndCrvNotInLastStepPlane ;
// recupero il percorso dell'ultimo piano di pocketing
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( IsNull( pCompo))
return false ;
for ( int nEntId = nIdDblS + 1 ; nEntId <= nIdDblEnd ; ++ nEntId) {
// l'ultimo piano deve essere eseguito in parallelo, quindi modifico il Name delle entità
m_pGeomDB->SetName( nEntId, MCH_CL_PARALLEL_DBL) ;
const ICurve* pCrv = GetCurve( m_pGeomDB->GetGeoObj( nEntId)) ;
if ( pCrv == nullptr || ! pCrv->IsValid())
return false ;
// recupero l'entità camData corrispondente
CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
if ( pCamData != nullptr) {
double dFeed = pCamData->GetFeed() ;
// verifico se la curva corrente appartiene al piano del LastStep
bool bOnPlane = false ;
Plane3d plCrv ;
if ( pCrv->GetType() == CRV_LINE) {
Point3d ptS ; pCrv->GetStartPoint( ptS) ;
Point3d ptE ; pCrv->GetEndPoint( ptE) ;
if ( DistPointPlane( ptS, plLastStep) < 10. * EPS_SMALL && DistPointPlane( ptE, plLastStep) < 10. * EPS_SMALL)
bOnPlane = true ;
}
else if ( pCrv->IsFlat( plCrv, false, 10. * EPS_SMALL) &&
abs( DistPointPlane( plCrv.GetPoint(), plLastStep)) < 10. * EPS_SMALL &&
AreSameOrOppositeVectorApprox( plCrv.GetVersN(), plLastStep.GetVersN()))
bOnPlane = true ;
if ( ! bOnPlane)
vIndCrvNotInLastStepPlane.push_back( pCompo->GetCurveCount()) ;
else {
// NB : dLastStep non assume valore < 15 per definizione ( GetDoubleLastStep())
if ( dLastStep > dStep + 10. * EPS_SMALL) {
double dNewFeed = Clamp( dFeed * ( dStep / dLastStep), dMinFeed, GetFeed()) ;
pCamData->SetFeed( dNewFeed) ;
}
}
PtrOwner<ICurve> pCurve( pCrv->Clone()) ;
if ( IsNull( pCurve))
return false ;
pCurve->SetTempParam( dFeed, 0) ;
if ( ! pCompo->AddCurve( Release( pCurve)))
return false ;
}
}
#if DEBUG_DOUBLE_PARALLEL
int nCompoBC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompo->Clone()) ;
m_pGeomDB->SetMaterial( nCompoBC, RED) ;
for ( int i = 0 ; i < ssize( vIndCrvNotInLastStepPlane) ; ++ i) {
const ICurve* pCrv = pCompo->GetCurve( vIndCrvNotInLastStepPlane[i]) ;
int nEntId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ;
m_pGeomDB->SetMaterial( nEntId, YELLOW) ;
}
#endif
// calcolo il piano di Mirror
Point3d ptOn ; Vector3d vtNorm ;
CalcMirrorPlaneByDouble( nDouble, m_Params.m_sUserNotes, ptOn, vtNorm) ;
// dato che l'ultimo piano di svuotatura arriva alla Depth stabilita, bisogna aggiungere un alteriore piano che il secondo
// utensile deve svuotare. Essendo che i percorsi sono calcolati sempre sull'utensile principale, bisogna effettuare un'opportuna
// operazione di traslazione e di Mirror in modo da posizionare il primo utensile in modo tale che il secondo finisca in un piano
// di Pocketing specchiato e alla quota corretta rispetto al piano di Mirror calcolato.
double dDblTrasl = ( ( ptOn - ptNeatEnd) * vtTool) ; // ptNeat in quanto privo di possibile LeadOut
pCompo->Mirror( ptOn, vtNorm) ;
pCompo->Translate( 2. * ( dLastStep - dDblTrasl) * vtTool) ;
#if DEBUG_DOUBLE_PARALLEL
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompo->Clone()) ;
m_pGeomDB->SetMaterial( nId, LIME) ;
#endif
// dopo aver percorso l'ultimo Step devo raccordarmi per raggiungere quest'ultimo
Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
Vector3d vtStart ; pCompo->GetStartDir( vtStart) ;
// proietto il punto iniziale del percorso di Mirror sul piano di Mirror
Plane3d plMirror ; plMirror.Set( ptOn, vtNorm) ;
Point3d ptStartProj = ProjectPointOnPlane( ptStart, plMirror) ;
Point3d ptCurr ; GetCurrPos( ptCurr) ;
Point3d ptCurrProj = ProjectPointOnPlane( ptCurr, plMirror) ;
// se il punto corrente e la proiezione della destinazione non coincidono, definisco il collegamento
// -->! l'obiettivo è raggiungere ptStart, il punto iniziale del percorso dello Step aggiuntivo
SetFeed( GetStartFeed()) ; // per lo Step in doppio
if ( ! AreSamePointEpsilon( ptStartProj, ptCurrProj, 25. * EPS_SMALL)) {
// --- controllo se un collegamento lineare è valido
PtrOwner<ICurveComposite> pCrvSafeLink( CreateCurveComposite()) ;
if ( IsNull( pCrvSafeLink))
return false ;
pCrvSafeLink->AddPoint( ptCurrProj) ;
pCrvSafeLink->AddLine( ptStartProj) ;
if ( ! pCrvSafeLink->IsValid())
return false ;
bool bSafeLimit = true ;
if ( pSfrLimit != nullptr && pSfrLimit->IsValid()) {
for ( int nC = 0 ; nC < pSfrLimit->GetChunkCount() && bSafeLimit ; ++ nC) {
CRVCVECTOR ccClass ;
bSafeLimit = ( pSfrLimit->GetCurveClassification( *pCrvSafeLink, EPS_SMALL, ccClass) &&
ssize( ccClass) == 1 && ccClass[0].nClass == CRVC_OUT) ;
}
}
// --- altrimenti cerco un percorso di raccordo smussato ed in tangenza
if ( ! bSafeLimit) {
Vector3d vtEndDir = vtEnd ;
int nLastId = m_pGeomDB->GetLastInGroup( m_nPathId) ;
bool bOk = false ;
do {
const ICurve* pCrv = GetCurve( m_pGeomDB->GetGeoObj( nLastId)) ;
bOk = ( pCrv != nullptr && pCrv->IsValid()) ;
if ( bOk) {
pCrv->GetEndDir( vtEndDir) ;
bOk = CheckSafetyLink( ptCurr, vtEndDir, ptStart, vtStart, pSfrLimit, vtTool, false, bSafeLimit, pCrvSafeLink) ;
}
} while ( ! bOk) ;
if ( ! bOk)
return false ;
}
// aggiusto la pendenza della curva di raccordo calcolata
if ( ! IsNull( pCrvSafeLink) && pCrvSafeLink->IsValid()) {
SetFeed( GetEndFeed()) ;
pCrvSafeLink->SetExtrusion( vtTool) ;
double dNini = ( ptCurr - ORIG) * vtTool ;
double dNfin = ( ptStart - ORIG) * vtTool ;
AdjustCurveSlope( pCrvSafeLink, dNini, dNfin) ;
AddCurveMove( pCrvSafeLink, bSplitArcs, MCH_CL_PARALLEL_DBL) ;
}
}
else {
// aggiungo risalita nel vuoto
AddLinearMove( ptStart, bSplitArcs, MCH_CL_PARALLEL_DBL) ;
}
// aggiungo il percorso dello Step Extra ( con le opportune Feed)
for ( int nU = 0 ; nU < pCompo->GetCurveCount() ; ++ nU) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( nU) ;
PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
if ( IsNull( pCurve))
return false ;
// coefficiente feed ( riduzione di feed per sezione di taglio superiore al previsto )
double dFeed ; pCompo->GetCurveTempParam( nU, dFeed) ; // feed originaria
if ( vIndCrvNotInLastStepPlane.empty() ||
find( vIndCrvNotInLastStepPlane.begin(), vIndCrvNotInLastStepPlane.end(), nU) == vIndCrvNotInLastStepPlane.end()) {
if ( dLastStep - 2. * dDblTrasl > dStep)
dFeed = Clamp( dFeed * ( dStep / ( dLastStep - 2. * dDblTrasl)), dMinFeed, GetFeed()) ;
}
else {
#if DEBUG_DOUBLE_PARALLEL
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCurve->Clone()) ;
m_pGeomDB->SetMaterial( nId, AQUA) ;
#endif
}
SetFeed( dFeed) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3, bSplitArcs, MCH_CL_PARALLEL_DBL) == GDB_ID_NULL)
return false ;
}
else {
if ( AddCurveMove( pCurve, bSplitArcs, MCH_CL_PARALLEL_DBL) == GDB_ID_NULL)
return false ;
}
}
// aggiungo discesa per movimento di sincronizzazione
GetCurrPos( ptCurr) ;
double dDepth = ( - ( ptNeatEnd - ptCurr) * vtTool) / 2. ;
if ( dDepth > 25. * EPS_SMALL) { // sempre...
SetFeed( GetEndFeed()) ; // ho rimosso tutto il materiale
AddLinearMove( ptCurr - dDepth * vtTool, bSplitArcs, MCH_CL_PARALLEL_DBL) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::AddPocket( STEPINFOPOVECTOR& vStepInfo, const Vector3d& vtTool, double dStep, bool bSplitArcs,
Point3d& ptPockStart, Point3d& ptPockEnd)
{
// se non ho superfici da svuotare, non faccio nulla
if ( vStepInfo.empty())
return true ;
// calcolo i percorsi di svuotatura per ogni Step/SubStep
if ( ! CalcPaths( vStepInfo))
return false ;
#if DEBUG_FEED
nGrpDebugFeed = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
nLayDebugFeed = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpDebugFeed, GLOB_FRM) ;
m_pGeomDB->SetName( nGrpDebugFeed, "Feed") ;
#endif
// recupero distanze di sicurezza
double dSafeZ = GetSafeZ() ;
double dSafeAggrBottZ = GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
// elevazione sopra al punto attuale
// per il primo percorso in assoluto viene calcolato da CalcFirstElevation(), mentre per i percorsi successivi viene
// aggiornato a seconda che il percorso corrente sia sullo stesso piano del precedente o al di sotto di esso
double dCurrElev = 0. ;
// punto finale del percorso per ogni Chunk di lavorazione
Point3d ptEnd = P_INVALID ;
// recupero parametro di Feed minima
double dMinFeed = GetFeed() / FEED_MAX_REDUCE ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_MINFEED, dMinFeed))
dMinFeed = Clamp( dMinFeed, GetFeed() / FEED_MAX_REDUCE, GetFeed()) ;
// verifico se devo eseguire una lavorazione in doppio in parallelo
int nDouble = GetDoubleType( m_Params.m_sUserNotes) ;
bool bDouble = ( nDouble != 0) ;
bool bDoubleParallel = false ;
int nIdDblS = GDB_ID_NULL ;
INTVECTOR vLeadOutIds ;
if ( bDouble)
bDoubleParallel = VerifyParallelPocketing( nDouble, vStepInfo) ;
// scorro il vettore dei piani di pocketing
for ( int i = 0 ; i < ssize( vStepInfo) ; ++ i) {
// riferimento alle informazioni relative allo step i-esimo
StepInfoPO& currStep = vStepInfo[i] ;
// scorro i percorsi calcolati per il piano di pocketing i-esimo
for ( int j = 0 ; j < ssize( currStep.vPaths) ; ++ j) {
// riferimento alle informazioni relative al percorso j-esimo del piano di pocketing i-esimo
PathInfoPO& currPath = currStep.vPaths[j] ;
// ciclo sulle curve elementari del percorso attuale
int nMaxInd = currPath.pCrvPath->GetCurveCount() - 1 ;
for ( int k = 0 ; k <= nMaxInd ; ++ k) {
// curva corrente
const ICurve* pCrvC = currPath.pCrvPath->GetCurve( k) ;
// copio la curva
PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
if ( IsNull( pCurve))
return false ;
// coefficiente feed ( riduzione di feed per sezione di taglio superiore al previsto )
double dTempParam ; currPath.pCrvPath->GetCurveTempParam( k, dTempParam) ;
double dCoeffFeed = min( 1., ( dTempParam > EPS_SMALL ? dTempParam /= 1000 : 1)) ;
// se prima entità
if ( k == 0) {
// dati inizio entità
Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart ; pCurve->GetStartDir( vtStart) ;
// flag approccio libero in aria
if ( currPath.bOutStart)
dCoeffFeed = ( dTempParam > EPS_SMALL ? dTempParam : 1) ;
// se prima entità in assoluto, memorizzo il punto iniziale
bool bAbsFirst = ( i == 0 && j == 0) ;
if ( bAbsFirst)
ptPockStart = ptStart ;
// calcolo ptP1 per LeadIn iniziale ( punto per approccio a seconda del LeadIn)
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtTool, currPath.pCrvGlideIn, ptP1)) {
m_pMchMgr->SetLastError( 3013, "Error in PocketingNT : LeadIn not computable") ;
return false ;
}
// determino l'elevazione, per il primo percorso verifico anche la posizione della testa e nel caso
// aggiungo un eventuale direzione di 'Escape'
double dEscapeElev = 0. ;
Vector3d vtEscape ;
if ( bAbsFirst)
CalcFirstElevation( ptP1, vtTool, currStep, dSafeZ, dStep, dCurrElev, dEscapeElev, vtEscape) ;
bool bEscapeElev = ( dEscapeElev > 10. * EPS_SMALL && vtEscape.Len() > 10. * EPS_SMALL) ;
// sposto il focus su PtP1 per approccio, quindi riduco l'elevazione corrente se esso non coicide con ptStart
dCurrElev -= ( ptP1 - ptStart) * vtTool ;
// se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
if ( GetLeadInType() != POCKET_LI_NONE) {
double dMyLIO_ELEV_TOL = min( LIO_ELEV_TOL, dSafeZ) ;
// se prima entità in assoluto
if ( bAbsFirst) {
// se lucidatura forzo il valore al parametro di elevazione in ingresso
if ( m_TParams.m_nType == TT_MILL_POLISHING) {
ptP1 += vtTool * max( m_Params.m_dLiElev, dCurrElev + LIO_ELEV_TOL) ;
dCurrElev = 0. ;
}
// altrimenti, muovo ptP1 alla quota dell'elevazione corrente
else {
ptP1 += vtTool * ( dCurrElev + dMyLIO_ELEV_TOL) ;
dCurrElev = - min( LIO_ELEV_TOL, dSafeZ) ;
}
}
// altrimenti
else if ( ! currPath.bOutStart)
ptP1 += vtTool * ( currStep.dRelativeDepth) ;
}
// altrimenti, l'elevazione va nell'attacco anche nel caso in cui ho una direzione di 'Escape'
else if ( currPath.bOutStart && bAbsFirst && bEscapeElev) {
// muovo ptP1 alla quota dell'elevazione corrente
ptP1 += vtTool * dCurrElev ;
dCurrElev = - dSafeZ ;
}
// approccio al punto iniziale. Viene calcolata nel caso di primo percorso in assoluto o nel caso in cui
// la direzione di approccio non sia esattamente come vtTool ( quindi di perfetta discesa)
double dMySafeZ = ( bAbsFirst ? dSafeZ : 0.) ;
Point3d ptMyPos ; GetCurrPos( ptMyPos) ;
double dMyElev = ( bAbsFirst ? dCurrElev : ( ptMyPos - ptP1) * vtTool) ;
double dMyAppr = ( bAbsFirst ? dAppr : 0.) ;
if ( bAbsFirst || ! OrthoCompo( ptMyPos - ptP1, vtTool).IsSmall()) {
if ( bAbsFirst && bEscapeElev) {
if ( ! AddApproach( ptP1 + vtEscape * dEscapeElev, vtEscape, dMySafeZ, dSafeAggrBottZ, 0., dMyAppr, bSplitArcs, currPath.bOutStart)) {
m_pMchMgr->SetLastError( 3011, "Error in PocketingNT : Approach not computable") ;
return false ;
}
}
else {
if ( ! AddApproach( ptP1, vtTool, dMySafeZ, dSafeAggrBottZ, dMyElev, dMyAppr, bSplitArcs, currPath.bOutStart)) {
m_pMchMgr->SetLastError( 3011, "Error in PocketingNT : Approach not computable") ;
return false ;
}
}
}
// aggiungo LeadIn ( se necessario effettuo movimento di riposizionamento verso ptP1)
SetFeed( GetStartFeed()) ;
Point3d ptCurr ; GetCurrPos( ptCurr) ;
if ( ! AreSamePointApprox( ptP1, ptCurr)) {
Vector3d vtMove = ptP1 - ptCurr ; vtMove.Normalize() ;
double dElev = 0. ;
bool bInMaterial = true ;
if ( GetElevation( m_nPhase, ptCurr, ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, vtTool, dElev) &&
dElev < 10. * EPS_SMALL)
bInMaterial = false ;
SetFeed( bInMaterial ? GetRightFeed( vtMove, vtTool) : GetStartFeed()) ;
#if DEBUG_FEED
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ; pLine->Set( ptCurr, ptP1) ;
DebugDrawFeed( pLine->Clone(), bInMaterial ? GetRightFeed( vtMove, vtTool) : GetStartFeed(), nLayDebugFeed) ;
#endif
AddLinearMove( ptP1, bSplitArcs) ;
}
bool bNoneForced = ( currPath.bOutStart || currPath.bSingleCrv ||
( m_Params.m_nSubType == POCKET_SUB_ZIGZAG && ! currPath.bIsZigZagOneWayBorder) ||
( m_Params.m_nSubType == POCKET_SUB_ONEWAY && ! currPath.bIsZigZagOneWayBorder)) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, currStep.pSfrPock, Get( currPath.pCrvGlideIn), Get( currPath.pCrvZigZagIn),
( m_Params.m_nSubType == POCKET_SUB_SPIRALOUT ? m_Params.m_bInvert : ! m_Params.m_bInvert),
bSplitArcs, bNoneForced, false)) {
m_pMchMgr->SetLastError( 3013, "Error in PocketingNT : LeadIn not computable") ;
return false ;
}
}
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptP3 = pLine->GetEnd() ;
SetFeed( Clamp( dCoeffFeed * GetFeed(), dMinFeed, GetFeed())) ;
#if DEBUG_FEED
DebugDrawFeed( pCurve->Clone(), dCoeffFeed * GetFeed(), nLayDebugFeed) ;
#endif
if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else {
SetFeed( Clamp( dCoeffFeed * GetFeed(), dMinFeed, GetFeed())) ;
#if DEBUG_FEED
DebugDrawFeed( pCurve->Clone(), dCoeffFeed * GetFeed(), nLayDebugFeed) ;
#endif
if ( AddCurveMove( pCurve, bSplitArcs) == GDB_ID_NULL)
return false ;
}
// se ultima entità
if ( k == nMaxInd) {
// dati fine entità
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ;
// se sono l'ultima entità globale del percorso
if ( i == ssize( vStepInfo) - 1 && j == ssize( currStep.vPaths) - 1) {
// memorizzo il punto finale della lavorazione
ptPockEnd = ptEnd ;
// aggiungo LeadOut
int nLastId = GDB_ID_NULL ;
if ( bDoubleParallel)
nLastId = m_pGeomDB->GetLastInGroup( m_nPathId) ;
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, currStep.pSfrPock, currPath.pCrvGlideOut, bSplitArcs, false, ptP1)) {
m_pMchMgr->SetLastError( 3014, "Error in PocketingNT : LeadOut not computable") ;
return false ;
}
/* ---- se lavorazione in Doppio in Parallelo ---- */
if ( bDoubleParallel) {
int nCurrId = m_pGeomDB->GetLastInGroup( m_nPathId) ;
if ( nLastId != nCurrId) {
for ( int nId = nLastId + 1 ; nId <= nCurrId ; ++ nId)
vLeadOutIds.push_back( nId) ;
}
if ( ! CalcDoubleParallelPenultimateStep( nDouble, nIdDblS, dStep, currStep.dRelativeDepth, ptEnd, vtEnd, vLeadOutIds,
currStep.pSfrLimit, vtTool, bSplitArcs, dMinFeed))
return false ;
GetCurrPos( ptEnd) ;
}
// calcolo l'elevazione al di sopra del punto corrente. Esattamente come per la prima elevazione in assoluto potrei
// avere una direzione di 'Escape'
double dLastElev = 0., dEscapeElev = 0. ;
Vector3d vtEscape ;
if ( ! CalcLastElevation( ptP1, vtTool, currStep, dSafeZ, dStep, dLastElev, dEscapeElev, vtEscape))
return false ;
if ( dEscapeElev > 10. * EPS_SMALL && vtEscape.Len() > 10. * EPS_SMALL) {
AddLinearMove( ptP1 + vtTool * dLastElev, bSplitArcs) ;
if ( ! AddRetract( ptP1 + vtTool * dLastElev, vtEscape, dSafeZ, dSafeAggrBottZ, dEscapeElev, dAppr, bSplitArcs)) {
m_pMchMgr->SetLastError( 3015, "Error in PocketingNT : Retract not computable") ;
return false ;
}
}
else {
// aggiungo retroazione finale
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dLastElev, dAppr, bSplitArcs)) {
m_pMchMgr->SetLastError( 3015, "Error in PocketingNT : Retract not computable") ;
return false ;
}
}
}
// se invece ultima entità relativa, quindi ho un percorso successivo
else {
// ricavo il punto che devo raggiungere
bool bSamePlane = ( j < ssize( currStep.vPaths) - 1) ;
const PathInfoPO& PathToGo = ( bSamePlane ? currStep.vPaths[j+1] : vStepInfo[i+1].vPaths.front()) ;
Point3d ptDest ; Vector3d vtDest ;
// se entrata a scivolo ammissibile, allora la destinazione è l'inizio dello scivolo (nel piano)
if ( GetLeadInType() == POCKET_LI_GLIDE && ( PathToGo.pCrvGlideIn != nullptr &&
PathToGo.pCrvGlideIn->IsValid())) {
PathToGo.pCrvGlideIn->GetStartPoint( ptDest) ;
PathToGo.pCrvGlideIn->GetStartDir( vtDest) ;
}
// altrimenti è l'inizio del percorso
else {
PathToGo.pCrvPath->GetStartPoint( ptDest) ;
PathToGo.pCrvPath->GetStartDir( vtDest) ;
}
/* ---- // ---- se lavorazione in doppio e in parallelo ---- // ---- */
if ( bDoubleParallel && ! bSamePlane) {
if ( ( i + 2) == ssize( vStepInfo) && nIdDblS == GDB_ID_NULL)
nIdDblS = m_pGeomDB->GetLastInGroup( m_nPathId) ;
}
// determino se possibile aggiungere un collegamento smussato
bool bSafeLimit = false, bSmoothEnd = true, bForceLinear = false ;
ManageSmoothLink( currPath, PathToGo, bSamePlane, bSmoothEnd, bForceLinear) ; // verifico solo se fattibile
PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
if ( IsNull( pCrvLink))
return false ;
// se ho una curva di ritorno, allora uso quella
if ( currPath.pCrvRet != nullptr && currPath.pCrvRet->IsValid()) {
pCrvLink->CopyFrom( currPath.pCrvRet) ;
bSafeLimit = true ;
}
// altrimenti calcolo raccordo smussato
else {
if ( ! bForceLinear) {
if ( ! CheckSafetyLink( ptEnd, vtEnd, ptDest, vtDest, currStep.pSfrLimit, vtTool,
bSmoothEnd, bSafeLimit, pCrvLink))
return false ;
}
}
// determino l'elevazione sul punto corrente e sul punto di destinazione
dCurrElev = 0. ;
double dNextElev = 0. ;
// se il collegamento non rovina il grezzo
if ( bSafeLimit) {
// e sullo stesso piano di pocketing
if ( bSamePlane) {
if ( ( ( m_Params.m_nSubType == POCKET_SUB_SPIRALIN || m_Params.m_nSubType == POCKET_SUB_SPIRALOUT) &&
! vStepInfo[i].vPaths[j+1].bOutStart) ||
( m_Params.m_nSubType != POCKET_SUB_SPIRALIN && m_Params.m_nSubType != POCKET_SUB_SPIRALOUT &&
m_Params.m_nSubType != POCKET_CONFORMAL_ZIGZAG && m_Params.m_nSubType != POCKET_SUB_CONFORMAL_ONEWAY)) {
dCurrElev += currStep.dRelativeDepth ;
dNextElev = dCurrElev ;
}
}
else {
// ... ed è al piano di svuotatura sottostante
dNextElev += ( ptEnd - ptDest) * vtTool ;
}
}
// se il collegamento rovina il grezzo
else {
dCurrElev += currStep.dDepth ;
dNextElev += ( bSamePlane ? currStep.dDepth : vStepInfo[i+1].dDepth) ;
}
// per non passare a filo dello step precedente ( quindi nel caso si isole a filo delle stesse)
// aggiungo una elevazione extra nel caso di violazione della regione limite
SetFeed( GetEndFeed()) ;
dCurrElev += ( bSafeLimit ? 0. : EXTRA_ELEV) ;
dNextElev += ( bSafeLimit ? 0. : EXTRA_ELEV) ;
// se devo salire lungo vtTool da ptEnd, mi alzo
if ( dCurrElev > EPS_SMALL)
AddLinearMove( ptEnd + dCurrElev * vtTool, bSplitArcs) ;
// mi dirigo sopra a ptDest
Point3d ptCheck ;
if ( GetCurrPos( ptCheck) && ! AreSamePointApprox( ptCheck, ptDest + dNextElev * vtTool)) {
if ( pCrvLink->IsValid()) {
pCrvLink->Translate( dCurrElev * vtTool) ;
AddCurveMove( pCrvLink, bSplitArcs) ;
}
else
AddLinearMove( ptDest + dNextElev * vtTool, bSplitArcs) ;
}
// aggiorno l'elevazione corrente per il percorso successivo
dCurrElev = dNextElev ;
}
}
}
}
}
// aggiorno per sicurezza la ProgressBar nel caso di Step vuoti
ExeProcessEvents( 100, 0) ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcFirstElevation( const Point3d& ptP1, const Vector3d& vtTool,
const StepInfoPO& currStep, double dSafeZ, double dStep, double& dCurrElev,
double& dEscapeElev, Vector3d& vtEscape) const
{
// elevazione per ingresso
if ( ! GetElevation( m_nPhase, ptP1 - 10. * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dCurrElev))
dCurrElev = currStep.dDepth + 10. * EPS_SMALL ;
else
dCurrElev = max( dCurrElev, currStep.dDepth + 10. * EPS_SMALL) ;
dEscapeElev = 0. ;
vtEscape = V_NULL ;
double dMyEscapeElev = 0. ;
Vector3d vtMyEscape = vtTool ;
vtMyEscape.z = ( m_bAboveHead ? max( vtTool.z, 0.) : min( vtTool.z, 0.)) ;
bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab &&
GetAhPointUnderRaw( ptP1 + dCurrElev * vtTool, vtTool, 0., GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtMyEscape, dMyEscapeElev) ;
bool bUhAboveRaw = ! m_bAboveHead &&
GetUhPointAboveRaw( ptP1 + dCurrElev * vtTool, vtTool, 0., GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtMyEscape, dMyEscapeElev) ;
if ( bAhUnderRaw || bUhAboveRaw || m_bTiltingTab) {
dEscapeElev = dMyEscapeElev ;
vtEscape = vtMyEscape ;
vtEscape.Normalize() ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcLastElevation( const Point3d& ptP1, const Vector3d& vtTool, const StepInfoPO& currStep,
double dSafeZ, double dStep, double& dCurrElev, double& dEscapeElev, Vector3d& vtEscape) const
{
// elevazione per uscita
if ( ! GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, vtTool, dCurrElev))
dCurrElev = currStep.dDepth ;
dEscapeElev = 0. ;
vtEscape = V_NULL ;
double dMyEscapeElev = 0. ;
Vector3d vtMyEscape = vtTool ;
vtMyEscape.z = ( m_bAboveHead ? max( vtTool.z, 0.) : min( vtTool.z, 0.)) ;
bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab &&
GetAhPointUnderRaw( ptP1 + vtTool * dCurrElev, vtTool, 0., GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtMyEscape, dMyEscapeElev) ;
bool bUhAboveRaw = ! m_bAboveHead &&
GetUhPointAboveRaw( ptP1 + vtTool * dCurrElev, vtTool, 0., GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtMyEscape, dMyEscapeElev) ;
if ( bAhUnderRaw || bUhAboveRaw || m_bTiltingTab) {
dEscapeElev = dMyEscapeElev ;
vtEscape = vtMyEscape ;
vtEscape.Normalize() ;
}
return true ;
}
//----------------------------------------------------------------------------
double
PocketingNT::GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const
{
// Determino i versori
Vector3d vtM = vtMove ;
vtM.Normalize() ;
Vector3d vtT = vtTool ;
vtT.Normalize() ;
// Angolo tra movimento e versore utensile
double dCosMove = vtM * vtT ;
// Se l'utensile non ha movimento significativo di punta, si restituisce la feed standard
if ( dCosMove > - COS_ORTO_ANG_SMALL)
return GetFeed() ;
// Altrimenti non si deve superare la massima velocità di punta prevista
return min( GetFeed(), GetTipFeed() / abs( dCosMove)) ;
}
//------------------------------------------------------------------
double
PocketingNT::GetRightStartFeed( const Vector3d& vtMove, const Vector3d& vtTool) const
{
// Determino i versori
Vector3d vtM = vtMove ;
vtM.Normalize() ;
Vector3d vtT = vtTool ;
vtT.Normalize() ;
// Angolo tra movimento e versore utensile
double dCosMove = vtM * vtT ;
// Se l'utensile non ha movimento significativo di punta, si restituisce la feed standard
if ( dCosMove > - COS_ORTO_ANG_SMALL)
return GetStartFeed() ;
// Altrimenti non si deve superare la massima velocità di punta prevista
return min( GetStartFeed(), GetTipFeed() / abs( dCosMove)) ;
}
//------------------------------------------------------------------
bool
PocketingNT::CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB)
{
IntersCurveCurve IntersCC( *pCrvA, *pCrvB) ;
CRVCVECTOR ccClass ;
IntersCC.GetCurveClassification( 1, EPS_SMALL, ccClass) ;
if ( ccClass.size() != 3 || ccClass[0].nClass != CRVC_OUT || ccClass[1].nClass == CRVC_OUT || ccClass[2].nClass != CRVC_OUT)
return false ;
Point3d ptS, ptE ;
pCrvB->GetPointD1D2( ccClass[1].dParS, ICurve::FROM_MINUS, ptS) ;
pCrvB->GetPointD1D2( ccClass[1].dParE, ICurve::FROM_MINUS, ptE) ;
double dParS, dParE ;
pCrvA->GetParamAtPoint( ptS, dParS) ;
pCrvA->GetParamAtPoint( ptE, dParE) ;
PtrOwner<ICurveComposite> pCrvTmp( CloneCurveComposite( pCrvA)) ;
if ( IsNull( pCrvTmp))
return false ;
pCrvA->Clear() ;
pCrvA->AddCurve( pCrvB->CopyParamRange( ccClass[1].dParS, ccClass[1].dParE)) ;
pCrvA->AddCurve( pCrvTmp->CopyParamRange( dParE, dParS)) ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::ComputePolishingPath( ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool bSplitArcs)
{
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
PtrOwner<ICurveComposite> pCrvBound( CreateCurveComposite()) ; // curva bound da usare per CalcBoundedLink
ICRVCOMPOPOVECTOR vpCrvsEp ;
Frame3d frLoc ;
Vector3d vtExtr ; pMCrv->GetExtrusion( vtExtr) ;
frLoc.Set( ORIG, vtExtr) ;
pMCrv->ToLoc( frLoc) ;
for ( int i = 0 ; i < pMCrv->GetCurveCount() ; i ++) {
int nProp = 0 ;
if ( ! pMCrv->GetCurveTempProp( i, nProp))
return false ;
// se è un tratto di collegamento ho concluso percorso su cui aggiungere epicicli
if ( nProp == LINK_CURVE_PROP) {
if ( pCompo->IsValid()) {
PtrOwner<ICurveComposite> pCrvEp( CreateCurveComposite()) ;
// la curva di bound è l'offset che calcolo in AddEpicycles per la prima curva compo trovata in pMCrv
bool bAddEp = ( ! pCrvBound->IsValid()) ? AddEpicycles( pCompo, pCrvEp, pCrvBound) : AddEpicycles( pCompo, pCrvEp) ;
if ( ! bAddEp)
return false ;
vpCrvsEp.emplace_back( Release( pCrvEp)) ;
pCompo.Set( CreateCurveComposite()) ;
}
}
// se non è tratto di collegamento lo aggiungo alla curva
else {
if ( ! pCompo->AddCurve( pMCrv->GetCurve(i)->Clone()))
return false ;
}
}
// ultima curva
if ( ! IsNull( pCompo)) {
PtrOwner<ICurveComposite> pCrvEp( CreateCurveComposite()) ;
if ( ! AddEpicycles( pCompo, pCrvEp))
return false ;
vpCrvsEp.emplace_back( Release( pCrvEp)) ;
}
// calcolo i collegamenti
ICURVEPOVECTOR vLinks( vpCrvsEp.size()) ;
for ( int i = 1 ; i < int( vpCrvsEp.size()) ; ++ i) {
// punti e direzioni di inizio e fine
Point3d ptStart ; Vector3d vtStart ;
vpCrvsEp[i-1]->GetEndPoint( ptStart) ;
vpCrvsEp[i-1]->GetEndDir( vtStart) ;
Point3d ptEnd ; Vector3d vtEnd ;
vpCrvsEp[i]->GetStartPoint( ptEnd) ;
vpCrvsEp[i]->GetStartDir( vtEnd) ;
// calcolo il collegamento con biarchi (garantendo che non esca dalla svuotatura)
PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
if ( CalcBoundedLinkWithBiArcs( ptStart, vtStart, ptEnd, vtEnd, pCrvBound, pCrvLink)) {
vLinks[i].Set( pCrvLink) ;
}
else {
m_pMchMgr->SetLastError( 2413, "Error in PocketingNT : Toolpath not computable") ;
return false ;
}
}
// calcolo il percorso di ritorno
pRCrv->Clear() ;
if ( vpCrvsEp.size() >= 2) {
// punti di inizio e fine
Point3d ptStart ; Vector3d vtStart ;
vpCrvsEp.back()->GetEndPoint( ptStart) ;
vpCrvsEp.back()->GetEndDir( vtStart) ;
Point3d ptEnd ; Vector3d vtEnd ;
vpCrvsEp.front()->GetStartPoint( ptEnd) ;
vpCrvsEp.front()->GetStartDir( vtEnd) ;
// calcolo il ritorno con biarchi (garantendo che non esca dalla svuotatura)
PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
if ( CalcBoundedLinkWithBiArcs( ptStart, vtStart, ptEnd, vtEnd, pCrvBound, pCrvLink)) {
pRCrv->AddCurve( Release( pCrvLink)) ;
pRCrv->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false) ;
// se necessario, approssimo archi con rette
if ( bSplitArcs && ! ApproxWithLines( pRCrv)) {
m_pMchMgr->SetLastError( 2419, "Error in PocketingNT : Linear Approx not computable") ;
return false ;
}
VerifyArcs( pRCrv) ;
}
else {
m_pMchMgr->SetLastError( 2413, "Error in PocketingNT : Toolpath not computable") ;
return false ;
}
}
// creo il percorso di lavoro a partire dalla raccolta delle curve con epicicli e dei collegamenti
pMCrv->Clear() ;
for ( int i = 0 ; i < int( vpCrvsEp.size()) ; ++ i) {
// se collegamento da aggiungere
if ( ! IsNull( vLinks[i])) {
// accodo nel percorso di lavorazione
pMCrv->AddCurve( Release( vLinks[i])) ;
}
// aggiungo la curva
pMCrv->AddCurve( Release( vpCrvsEp[i])) ;
}
// se necessario, approssimo archi con rette
if ( bSplitArcs && ! ApproxWithLines( pMCrv)) {
m_pMchMgr->SetLastError( 2419, "Error in PocketingNT : Linear Approx not computable") ;
return false ;
}
VerifyArcs( pMCrv) ;
pMCrv->ToGlob( frLoc) ;
pRCrv->ToGlob( frLoc) ;
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::AddEpicycles( ICurveComposite* pCompo, ICurveComposite * pCrv, ICurveComposite * pCrvBound)
{
if ( m_Params.m_bInvert)
pCompo->Invert() ; // oriento la curva in senso antiorario
OffsetCurve OffsCrv ;
double dOffs = m_Params.m_dEpicyclesRad ;
if ( ! OffsCrv.Make( pCompo, dOffs, ICurve::OFF_FILLET)) {
m_pMchMgr->SetLastError( 2412, "Error in PocketingNT : Offset not computable") ;
return false ;
}
if ( OffsCrv.GetCurveCount() > 1)
return false ;
PtrOwner<ICurveComposite> pCrvOffs( GetCurveComposite( OffsCrv.GetCurve())) ;
if ( IsNull( pCrvOffs))
return false ;
// verifico se devo resitituire la curva offsettata
if ( pCrvBound)
pCrvBound->AddCurve( pCrvOffs->Clone()) ;
pCrv->Clear() ;
double dParPrec = 0 ;
for ( int i = 0 ; i < pCompo->GetCurveCount() ; i++) {
// calcolo distanza epicili specifica per quel tratto
double dLen ;
pCompo->GetCurve( i)->GetLength( dLen) ;
int nStep = max( 1, static_cast<int>( ceil( ( dLen) / m_Params.m_dEpicyclesDist))) ;
double dStep = 1.0 / nStep ;
for ( int k = 1 ; k <= nStep ; k ++) {
// creo epiciclo
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
Point3d ptCen ;
Vector3d vtDir ;
pCompo->GetCurve( i)->GetPointD1D2( k * dStep, ICurve::FROM_MINUS, ptCen, &vtDir) ;
vtDir.Normalize() ;
vtDir.Rotate( Z_AX, - 90) ;
Point3d pt = ptCen + vtDir * m_Params.m_dEpicyclesRad ;
pCrvArc->Set( ptCen, Z_AX, m_Params.m_dEpicyclesRad) ;
double dU ;
pCrvArc->GetParamAtPoint( pt, dU) ;
pCrvArc->ChangeStartPoint( dU) ;
// aggiungo tratto della curva offsettata
double dPar ;
pCrvOffs->GetParamAtPoint( pt, dPar) ;
bool bAdd = pCrv->AddCurve( pCrvOffs->CopyParamRange( dParPrec, dPar)) ;
// aggiungo epiciclo
if ( ! pCrv->AddCurve( Release( pCrvArc))) {
// se fallisco nell'aggiungere l'epiciclo tento nuovamente spostandolo di EPS_SMALL
if ( bAdd)
PtrOwner<ICurve> pCrvErased( pCrv->RemoveFirstOrLastCurve( true)) ;
k -- ;
dStep -= EPS_SMALL ;
if ( dStep < EPS_SMALL)
return false ;
}
else
dParPrec = dPar ;
}
}
// se necessario ripristino orientamento originale
if ( m_Params.m_bInvert)
pCrv->Invert() ;
return true ;
}
//------------------------------------------------------------------------------
bool
PocketingNT::CalcBoundedLinkWithBiArcs( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd, const Vector3d& vtEnd,
const ICurve* pCrvBound, ICurveComposite* pCrvLink)
{
double dAngStart, dAngEnd ;
vtStart.GetAngleXY( X_AX, dAngStart) ;
vtEnd.GetAngleXY( X_AX, dAngEnd) ;
PtrOwner<ICurve> pBiArcLink( GetBiArc( ptStart, -dAngStart, ptEnd, -dAngEnd, 0.5)) ;
if ( IsNull( pBiArcLink))
return false ;
// verifico se esce dalla svuotatura
CRVCVECTOR ccClass ;
IntersCurveCurve intCC( *pBiArcLink, *pCrvBound) ;
intCC.GetCurveClassification( 0, EPS_SMALL, ccClass) ;
// se nessuno o un solo tratto e interno, il biarco è il collegamento
if ( ccClass.empty() || ( ccClass.size() == 1 && ccClass[0].nClass == CRVC_IN)) {
pCrvLink->AddCurve( Release( pBiArcLink)) ;
}
// altrimenti creo un percorso con biarchi e opportuni tratti della curva di contenimento
else {
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( IsNull( pCompo))
return false ;
double dPar1, dPar2 ;
Point3d ptMinDist1, ptMinDist2 ;
Vector3d vtDir1, vtDir2 ;
double dAng1, dAng2 ;
int nFlag ;
DistPointCurve distPtSCrv( ptStart, *pCrvBound) ;
distPtSCrv.GetParamAtMinDistPoint( 0, dPar1, nFlag) ;
pCrvBound->GetPointTang( dPar1, ICurve::FROM_MINUS, ptMinDist1, vtDir1) ;
vtDir1.GetAngleXY( X_AX, dAng1) ;
DistPointCurve distPtECrv( ptEnd, *pCrvBound) ;
distPtECrv.GetParamAtMinDistPoint( 0, dPar2, nFlag) ;
pCrvBound->GetPointTang( dPar2, ICurve::FROM_MINUS, ptMinDist2, vtDir2) ;
vtDir2.GetAngleXY( X_AX, dAng2) ;
pCompo->AddCurve( GetBiArc( ptStart, -dAngStart, ptMinDist1, -dAng1, 0.5)) ; // primo biarco
pCompo->AddCurve( pCrvBound->CopyParamRange( dPar1, dPar2)) ; // tratto di pCrvBound
pCompo->AddCurve( GetBiArc( ptMinDist2, -dAng2, ptEnd, -dAngEnd, 0.5)) ; // secondo biarco
pCrvLink->AddCurve( Release( pCompo)) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bSplitArcs, bool bOutStart)
{
SetFlag( 1) ;
// se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi)
bool bBottomOutStart = false ;
if ( m_bAggrBottom) {
// distanza dal bordo del pezzo (se negativa il punto è fuori dal grezzo)
double dDistBottom ;
if ( ! GetAggrBottDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, ( m_AggrBottom.dEncH + dSafeZ), dDistBottom))
dDistBottom = 0 ;
bBottomOutStart = ( dDistBottom < - 10 * EPS_SMALL) ;
// aggiuntivo in Z
double dAggZ = ( bBottomOutStart ? 0. : max( dElev + max( dSafeAggrBottZ, dAppr), 0.)) ;
// pre-approccio
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
// se richiede speciale rotazione
if ( m_AggrBottom.nType == 1) {
// punto ruotato
Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ;
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
if ( AddRapidStart( ptP00, MCH_CL_AGB_DWN) == GDB_ID_NULL)
return false ;
// vado al punto standard
SetAuxDir( m_vtAggrBottom) ;
SetFlag( 0) ;
if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
}
// se altrimenti con rotazione per minimizzare la sporgenza
else if ( m_AggrBottom.nType == 3) {
// punto standard ruotato
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
if ( AddRapidStart( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
// la rotazione viene eseguita nel movimento successivo al punto sopra l'inizio lavorazione
SetAuxDir( m_vtAggrBottom) ;
SetFlag( 0) ;
}
// altrimenti rinvio normale
else {
SetAuxDir( m_vtAggrBottom) ;
if ( AddRapidStart( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
}
}
// altrimenti
else {
// se impostato come parametro di lavorazione nelle UserNotes
Vector3d vtAux ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTAUXDIR, vtAux))
vtAux.Normalize() ;
SetAuxDir( vtAux) ;
}
// se sopra attacco c'è spazio per sicurezza o approccio
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
if ( ! bBottomOutStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
// se distanza di sicurezza minore di distanza di inizio
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 1 -> punto sopra inizio
if ( AddRapidStartOrMove( ptP1, ! m_bAggrBottom, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else {
// 1a -> punto molto sopra inizio
Point3d ptP1a = ptP1 + vtTool * ( dSafeDist - dAppr) ;
if ( AddRapidStartOrMove( ptP1a, ! m_bAggrBottom, bSplitArcs) == GDB_ID_NULL)
return false ;
// 1 -> punto sopra inizio
if ( ( dElev + dAppr) > 10 * EPS_SMALL || (( dElev + dAppr) > -EPS_ZERO && dAppr > EPS_SMALL)) {
SetFlag( 0) ;
if ( AddRapidMove( ptP1, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else
ptP1 = ptP1a ;
}
// affondo al punto iniziale
SetFlag( 0) ;
bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP) ;
SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
if ( ! AreSamePointApprox( ptP1, ptP) && AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else {
// affondo diretto al punto iniziale
SetFlag( 0) ;
if ( AddRapidStartOrMove( ptP, ! m_bAggrBottom, bSplitArcs) == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bSplitArcs, bool bOutStart)
{
// se sopra attacco c'è spazio per approccio
if ( ( dElev + dAppr) > 10 * EPS_SMALL) {
// 1b -> punto appena sopra inizio
Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
if ( ( dElev + dAppr) > EPS_SMALL) {
SetFlag( 0) ;
if ( AddRapidMove( ptP1b, bSplitArcs) == GDB_ID_NULL)
return false ;
}
// affondo al punto iniziale
SetFlag( 0) ;
SetFeed( bOutStart ? GetStartFeed() : GetTipFeed()) ;
if ( AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else {
// affondo diretto al punto iniziale
SetFlag( 0) ;
if ( AddRapidMove( ptP, bSplitArcs) == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bSplitArcs)
{
// se sopra uscita c'è spazio per approccio
if ( ( dElev + dAppr) > 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4, bSplitArcs) == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bSplitArcs)
{
// se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi)
bool bBottomOutStart = false ;
double dDistBottom ;
if ( m_bAggrBottom) {
// distanza dal bordo del pezzo
if ( ! GetAggrBottDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, ( m_AggrBottom.dEncH + dSafeZ), dDistBottom))
dDistBottom = 0 ;
bBottomOutStart = ( dDistBottom < - 10 * EPS_SMALL) ;
}
// se sopra uscita c'è spazio per sicurezza o approccio
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
if ( ! bBottomOutStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + vtTool * ( dElev + dAppr) ;
if ( dElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a, bSplitArcs) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + vtTool * ( dSafeDist - dAppr) ;
if ( AddRapidMove( ptP4b, bSplitArcs) == GDB_ID_NULL)
return false ;
}
}
// se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi)
if ( m_bAggrBottom) {
// se con rotazione per minimizzare la sporgenza
if ( m_AggrBottom.nType == 3) {
// imposto rotazione su punto standard
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
}
// aggiuntivo in Z
double dAggZ = ( bBottomOutStart ? 0. : max( dElev + max( dSafeAggrBottZ, dAppr), 0.)) ;
// post-retract
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_OUT) == GDB_ID_NULL)
return false ;
// se richiede speciale rotazione
if ( m_AggrBottom.nType == 1) {
Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ;
Vector3d vtAux = m_vtAggrBottom ;
vtAux.Rotate( Z_AX, 0, 1) ;
SetAuxDir( vtAux) ;
if ( AddRapidMove( ptP00, bSplitArcs, MCH_CL_AGB_UP) == GDB_ID_NULL)
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcLeadInStart( Point3d& ptStart, const Vector3d& vtTool,
const ICurveComposite* pRCrv, Point3d& ptP1)
{
// Assegno tipo e parametri
int nType = GetLeadInType() ;
if ( nType == SURFROU_LI_GLIDE && ( pRCrv == nullptr || pRCrv->GetCurveCount() == 0))
nType = SURFROU_LI_NONE ;
// Calcolo punto iniziale
switch ( nType) {
case SURFROU_LI_NONE :
case SURFROU_LI_ZIGZAG :
case SURFROU_LI_HELIX :
ptP1 = ptStart ;
return true ;
case SURFROU_LI_GLIDE :
{
if ( ! pRCrv->GetStartPoint( ptP1))
return false ;
ptP1 += vtTool * ( vtTool * ( ptStart - ptP1)) ;
ptStart = ptP1 ;
return true ;
}
default :
return false ;
}
}
//----------------------------------------------------------------------------
bool
PocketingNT::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
const ISurfFlatRegion* pSfr, const ICurveComposite* pRCrv, const ICurveComposite* pRZigZag, bool bAtLeft, bool bSplitArcs,
bool bNoneForced, bool bSkipControl)
{
// Assegno il tipo
int nType = GetLeadInType() ;
if ( bNoneForced ||
AreSamePointEpsilon( ptP1, ptStart, 10 * EPS_SMALL) ||
( nType == POCKET_LI_GLIDE && ( pRCrv == nullptr || pRCrv->GetCurveCount() == 0)))
nType = POCKET_LI_NONE ;
// Se elica e fattibile lo creo
if ( nType == POCKET_LI_HELIX) {
// vettore dal punto al centro elica
Vector3d vtCen = vtStart ;
vtCen.Rotate( vtN, 0, ( bAtLeft ? 1 : - 1)) ;
// dati dell'elica
double dRad = min( 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam), m_dMaxHelixRad) ;
Point3d ptCen = ptP1 + vtCen * dRad ;
double dDeltaN = ( ptStart - ptP1) * vtN ;
double dAngCen = ceil( - dDeltaN / ( m_Params.m_dLiElev + 20 * EPS_SMALL)) * ( bAtLeft ? ANG_FULL : - ANG_FULL) ;
// verifico se fattibile
if ( bSkipControl || VerifyLeadInHelix( pSfr, ptStart, ptCen, dRad)) {
// creo l'elica
PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
if ( IsNull( pArc) || ! pArc->Set( ptCen, vtN, dRad, - vtCen, dAngCen, dDeltaN))
return false ;
// dovendo creare l'elica, sono nel materiale, quindi regolo la Feed
Vector3d vtTanHelix ; pArc->GetStartDir( vtTanHelix) ;
SetFeed( GetRightStartFeed( vtTanHelix, vtN)) ;
#if DEBUG_FEED
DebugDrawFeed( pArc->Clone(), GetRightStartFeed( vtTanHelix, vtN), nLayDebugFeed) ;
#endif
// emetto l'elica (con eventuale spezzatura)
return ( AddCurveMove( pArc, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
// altrimenti zigzag
else
nType = POCKET_LI_ZIGZAG ;
}
// Se zigzag e fattibile lo creo
if ( nType == POCKET_LI_ZIGZAG) {
// dati dello zigzag
double dDeltaN = ( ptStart - ptP1) * vtN ;
int nStep = int( ceil( - dDeltaN / ( m_Params.m_dLiElev + 20 * EPS_SMALL))) ;
double dStep = - dDeltaN / nStep ;
Point3d ptPa = ptP1 + vtStart * 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
Point3d ptPb = ptP1 - vtStart * 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
Vector3d vtTanZigZag = ( ptPa - vtN * 0.25 * dStep) - ptP1 ;
SetFeed( GetRightStartFeed( vtTanZigZag, vtN)) ;
// verifico se fattibile
if ( bSkipControl || VerifyLeadInZigZag( pSfr, ptStart, ptPa, ptPb)) {
for ( int i = 1 ; i <= nStep ; ++ i) {
#if DEBUG_FEED
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
Point3d ptCurr ; GetCurrPos( ptCurr) ; pLine->Set( ptCurr, ptPa - vtN * ( i - 0.75) * dStep) ;
DebugDrawFeed( pLine->Clone(), GetRightStartFeed( vtTanZigZag, vtN), nLayDebugFeed) ;
#endif
if ( AddLinearMove( ptPa - vtN * ( i - 0.75) * dStep, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
#if DEBUG_FEED
GetCurrPos( ptCurr) ; pLine->Set( ptCurr, ptPb - vtN * ( i - 0.25) * dStep) ;
DebugDrawFeed( pLine->Clone(), GetRightStartFeed( vtTanZigZag, vtN), nLayDebugFeed) ;
#endif
if ( AddLinearMove( ptPb - vtN * ( i - 0.25) * dStep, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
#if DEBUG_FEED
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
Point3d ptCurr ; GetCurrPos( ptCurr) ; pLine->Set( ptCurr, ptStart) ;
DebugDrawFeed( pLine->Clone(), GetRightStartFeed( vtTanZigZag, vtN), nLayDebugFeed) ;
#endif
return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
// altrimenti provo a modificare il percorso a ZigZag in maniera opportuna
else {
if ( AddSpecialLeadInZigZag( pRZigZag, ptStart, vtN, nStep, dStep))
return true ;
// altrimenti diretto ( controllo semplicemente se posso entrare di testa)
else {
nType = POCKET_LI_NONE ;
if ( m_TParams.m_nType == TT_MILL_NOTIP)
return false ;
}
}
}
// Se a scivolo e fattibile
if ( nType == POCKET_LI_GLIDE) {
if ( pRCrv != nullptr) {
// recupero la parte richiesta della curva di ritorno
PtrOwner<ICurveComposite> pCrv( CloneCurveComposite( pRCrv)) ;
if ( IsNull( pCrv) || ! pCrv->IsValid())
return false ;
pCrv->SetExtrusion( vtN) ;
// assegno la corretta pendenza
double dNini = ( ptP1 - ORIG) * vtN ;
double dNfin = ( ptStart - ORIG) * vtN ;
AdjustCurveSlope( pCrv, dNini, dNfin) ;
// assegno le Feed
Point3d ptS ; pCrv->GetStartPoint( ptS) ;
Point3d ptE ; pCrv->GetEndPoint( ptE) ;
Vector3d vtMove = ptE - ptS ;
SetFeed( GetRightStartFeed( vtMove, vtN)) ;
#if DEBUG_FEED
DebugDrawFeed( pCrv->Clone(), GetRightStartFeed( vtMove, vtN), nLayDebugFeed) ;
#endif
// emetto (con eventuale spezzatura)
return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
// altrimenti diretto
else
nType = POCKET_LI_NONE ;
}
// Se diretto
if ( nType == POCKET_LI_NONE) {
Point3d ptCurr = ptP1 ;
GetCurrPos( ptCurr) ;
if ( ! AreSamePointApprox( ptCurr, ptStart)) {
Vector3d vtMove = ptStart - ptCurr ; vtMove.Normalize() ;
double dElev = 0. ;
bool bInMaterial = true ;
if ( GetElevation( m_nPhase, ptCurr, ptStart, vtN, GetRadiusForStartEndElevation(), m_TParams.m_dLen, vtN, dElev) && dElev < 10. * EPS_SMALL)
bInMaterial = false ;
// Feed di Testa
SetFeed( bInMaterial ? GetTipFeed() : GetStartFeed()) ;
#if DEBUG_FEED
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ; pLine->Set( ptCurr, ptStart) ;
DebugDrawFeed( pLine->Clone(), bInMaterial ? GetTipFeed() : GetStartFeed(), nLayDebugFeed) ;
#endif
if ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
return true ;
}
// Altrimenti errore
return false ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
const ISurfFlatRegion* pSfr, const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
Point3d& ptP1)
{
// assegno i parametri
int nType = GetLeadOutType() ;
if ( bNoneForced ||
( nType == POCKET_LO_GLIDE && ( pRCrv == nullptr || pRCrv->GetCurveCount() == 0)))
nType = POCKET_LO_NONE ;
// eseguo a seconda del tipo
switch ( nType) {
case POCKET_LO_NONE :
{
// nessuna uscita
ptP1 = ptEnd ;
return true ;
}
case POCKET_LO_GLIDE :
{
// recupero la parte richiesta della curva di ritorno
PtrOwner<ICurveComposite> pCrv( CloneCurveComposite( pRCrv)) ;
if ( IsNull( pCrv) || ! pCrv->IsValid())
return false ;
pCrv->SetExtrusion( vtN) ;
// controllo se ammissibile
if ( VerifyLeadInOutGlide( pSfr, pCrv)) {
// recupero le quote per la curva
Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
double dExtraElev = 1.0 ;
if ( m_TParams.m_nType == TT_MILL_POLISHING)
dExtraElev = max( m_Params.m_dLiElev, 1.0) ;
ptFin += vtN * dExtraElev ;
double dNini = ( ptIni - ORIG) * vtN ;
double dNfin = ( ptFin - ORIG) * vtN ;
AdjustCurveSlope( pCrv, dNini, dNfin) ;
// emetto (con eventuale spezzatura)
if ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) == GDB_ID_NULL)
return false ;
ptP1 = ptFin ;
}
else {
// nessuna uscita
ptP1 = ptEnd ;
}
return true ;
}
default :
return false ;
}
}
//----------------------------------------------------------------------------
double
PocketingNT::GetRadiusForStartEndElevation( void) const
{
const double DELTA_ELEV_RAD = 4.0 ;
double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ;
return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::GetForcedClosed( void)
{
double dOpenLen ;
return ( GetValInNotes( m_Params.m_sUserNotes, UN_OPEN, dOpenLen) && dOpenLen < EPS_ZERO) ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CheckSafetyLink( const Point3d& ptCurr, const Vector3d& vtCurr,
const Point3d& ptDest, const Vector3d& vtDest,
const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool,
bool bSmoothEnd, bool& bSafeLimit, ICurveComposite* pCrvSafeLink)
{
// controllo dei parametri
if ( ! ptCurr.IsValid() || ! ptDest.IsValid() || ! vtCurr.IsValid() || ! vtDest.IsValid())
return false ;
pCrvSafeLink->Clear() ;
bSafeLimit = true ;
// porto ptDest alla stessa quota di ptCurr secondo vtTool
Plane3d plProj ;
if ( ! plProj.Set( ptCurr, vtTool))
return false ;
Point3d ptDestProj = ProjectPointOnPlane( ptDest, plProj) ;
// se coicidenti allora non devo creare alcun link
if ( AreSamePointApprox( ptCurr, ptDestProj))
return true ;
// definisco frame locale ( intersezioni nel piano XY)
Frame3d frLoc ;
if ( ! frLoc.Set( ptCurr, vtTool))
return false ;
// porto i punti nel piano locale
Point3d ptS = ORIG ;
Point3d ptE = GetToLoc( ptDestProj, frLoc) ;
Vector3d vtS = GetToLoc( vtCurr, frLoc) ;
Vector3d vtE = GetToLoc( vtDest, frLoc) ;
// ----------------------------- definisco il collegamento -----------------------------
PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
if ( IsNull( pCrvLink))
return false ;
bool bLinkLinear = ( ! pCrvLink->AddPoint( ptS) ||
! pCrvLink->AddLine( ptS + ( m_TParams.m_dDiam / 4.) * vtS)) ;
if ( bSmoothEnd) {
// ZigZag tra ptS e ptE mediante vtS e - vtE
bLinkLinear = ( bLinkLinear ||
! pCrvLink->AddLine( ptE - ( m_TParams.m_dDiam / 4.) * vtE) ||
! pCrvLink->AddLine( ptE) ||
( ! pCrvLink->IsValid() && pCrvLink->GetCurveCount() == 3)) ;
}
else {
// evito tratto ZigZag finale
bLinkLinear = ( bLinkLinear ||
! pCrvLink->AddLine( ptE) ||
( ! pCrvLink->IsValid() && pCrvLink->GetCurveCount() == 2)) ;
}
if ( ! bLinkLinear) {
SelfIntersCurve SIC( *pCrvLink) ;
bLinkLinear = ( SIC.GetCrossOrOverlapIntersCount() > 0) ;
}
if ( bLinkLinear) {
pCrvLink->Clear() ;
pCrvLink->AddPoint( ptS) ;
pCrvLink->AddLine( ptE) ;
if ( ! pCrvLink->IsValid())
return false ;
}
else {
// controllo variazioni angolari delle curve
Vector3d vtStart ; pCrvLink->GetCurve( 0)->GetStartDir( vtStart) ;
Vector3d vtMid ; pCrvLink->GetCurve( 1)->GetStartDir( vtMid) ;
Vector3d vtEnd ;
if ( bSmoothEnd)
pCrvLink->GetCurve( 2)->GetStartDir( vtEnd) ;
if ( vtStart * vtMid < SAFETY_LINK_COS) {
if ( bSmoothEnd) {
delete( pCrvLink->RemoveFirstOrLastCurve( false)) ;
delete( pCrvLink->RemoveFirstOrLastCurve( false)) ;
pCrvLink->AddLine( ptS, false) ;
pCrvLink->GetStartDir( vtMid) ;
}
else
pCrvLink->Clear() ;
}
if ( bSmoothEnd) {
if ( vtEnd * vtMid < SAFETY_LINK_COS) {
delete( pCrvLink->RemoveFirstOrLastCurve( true)) ;
delete( pCrvLink->RemoveFirstOrLastCurve( true)) ;
if ( ! pCrvLink->IsValid())
pCrvLink->AddPoint( ptS) ;
pCrvLink->AddLine( ptE) ;
}
}
if ( ! pCrvLink->IsValid()) {
pCrvLink->Clear() ;
pCrvLink->AddPoint( ptS) ;
pCrvLink->AddLine( ptE) ;
if ( ! pCrvLink->IsValid())
return false ;
}
}
#if DEBUG_SAFETY_LINK
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay, "Safety_Link") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvLink->Clone()) ;
m_pGeomDB->SetMaterial( _a, LIME) ;
#endif
// Smusso il Link secondo i parametri richiesti
CalcSmoothCurve( pCrvLink, m_TParams.m_dDiam / 8., m_TParams.m_dDiam / 8., false) ;
#if DEBUG_SAFETY_LINK
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvLink->Clone()) ;
m_pGeomDB->SetMaterial( _a, RED) ;
#endif
// controllo eventuale interferenza con la regione limite
PtrOwner<ISurfFlatRegion> pSfrLimitLoc( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrLimitLoc))
return false ;
if ( pSfrLimit != nullptr && pSfrLimit->IsValid()) {
pSfrLimitLoc.Set( CloneSurfFlatRegion( pSfrLimit)) ;
if ( IsNull( pSfrLimitLoc) || ! pSfrLimitLoc->IsValid() ||
! pSfrLimitLoc->ToLoc( frLoc) ||
! pSfrLimitLoc->Offset( m_TParams.m_dDiam / 2. + GetOffsR() - 10 * EPS_SMALL, ICurve::OFF_FILLET))
return false ;
#if DEBUG_SAFETY_LINK
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pSfrLimitLoc->Clone()) ;
m_pGeomDB->SetMaterial( _a, Color( .5, .5, .5, .35)) ;
#endif
for ( int nC = 0 ; nC < pSfrLimitLoc->GetChunkCount() && bSafeLimit ; ++ nC) {
CRVCVECTOR ccClass ;
bSafeLimit = ( pSfrLimitLoc->GetCurveClassification( *pCrvLink, EPS_SMALL, ccClass) &&
int( ccClass.size()) == 1 && ccClass[0].nClass == CRVC_OUT) ;
}
}
// se Link smussato ammissibile
if ( bSafeLimit) {
pCrvSafeLink->CopyFrom( pCrvLink) ;
pCrvSafeLink->ToGlob( frLoc) ;
return true ;
}
// se interferenza con la regione limite, allora provo con link lineare
else if ( ! IsNull( pSfrLimitLoc) && pSfrLimitLoc->IsValid()) {
pCrvLink->Clear() ;
pCrvLink->AddPoint( ptS) ;
pCrvLink->AddLine( ptE) ;
if ( ! pCrvLink->IsValid())
return false ;
#if DEBUG_SAFETY_LINK
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvLink->Clone()) ;
m_pGeomDB->SetMaterial( _a, YELLOW) ;
#endif
bSafeLimit = true ;
for ( int nC = 0 ; nC < pSfrLimitLoc->GetChunkCount() && bSafeLimit ; ++ nC) {
CRVCVECTOR ccClass ;
bSafeLimit = ( pSfrLimitLoc->GetCurveClassification( *pCrvLink, EPS_SMALL, ccClass) &&
int( ccClass.size()) == 1 && ccClass[0].nClass == CRVC_OUT) ;
}
}
if ( bSafeLimit) {
pCrvSafeLink->CopyFrom( pCrvLink) ;
pCrvSafeLink->ToGlob( frLoc) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::VerifyLeadInHelix( const ISurfFlatRegion* pSfr, const Point3d& ptStart,
const Point3d& ptCen, double dHelixRad)
{
// controllo validità dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid())
return false ;
Vector3d vtN = pSfr->GetNormVersor() ;
// porto il centro sullo stesso piano del contorno
Point3d ptCenL = ptCen - ( ptCen - ptStart) * vtN * vtN ;
// Offset della regione
PtrOwner<ISurfFlatRegion> pSfrOffs( pSfr->CreateOffsetSurf( - m_TParams.m_dDiam / 2 - GetOffsR() - dHelixRad + 10 * EPS_SMALL, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrOffs) || ! pSfrOffs->IsValid())
return false ;
// controllo se l'elica è valida
bool bIsInside ;
return ( IsPointInsideSurfFr( ptCenL, pSfrOffs, 0., bIsInside) && bIsInside) ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::VerifyLeadInZigZag( const ISurfFlatRegion* pSfr, const Point3d& ptStart,
const Point3d& ptPa, const Point3d& ptPb)
{
// controllo validità dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid())
return false ;
Vector3d vtN = pSfr->GetNormVersor() ;
// porto i punti sullo stesso piano del contorno
Point3d ptPaL = ptPa - ( ptPa - ptStart) * vtN * vtN ;
Point3d ptPbL = ptPb - ( ptPb - ptStart) * vtN * vtN ;
// Offset della regione
PtrOwner<ISurfFlatRegion> pSfrOffs( pSfr->CreateOffsetSurf( - m_TParams.m_dDiam / 2 - GetOffsR() + 10 * EPS_SMALL, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrOffs) || ! pSfrOffs->IsValid())
return false ;
// controllo se i due punti sono validi
bool bIsInside ;
return ( IsPointInsideSurfFr( ptPaL, pSfrOffs, 0., bIsInside) && bIsInside &&
IsPointInsideSurfFr( ptPbL, pSfrOffs, 0., bIsInside) && bIsInside) ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::VerifyLeadInOutGlide( const ISurfFlatRegion* pSfr, ICurveComposite* pCrvGlide)
{
// controllo validità dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid())
return false ;
// Offset della regione
PtrOwner<ISurfFlatRegion> pSfrOffs( pSfr->CreateOffsetSurf( - m_TParams.m_dDiam / 2 - GetOffsR() + 10 * EPS_SMALL, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrOffs) || ! pSfrOffs->IsValid())
return false ;
// controllo se la curva interseca la regione
CRVCVECTOR ccClass ;
if ( ! pSfrOffs->GetCurveClassification( *pCrvGlide, EPS_SMALL, ccClass))
return false ;
if ( int( ccClass.size()) == 1 && ccClass[0].nClass == CRVC_IN)
return true ;
// recupero il primo tratto In e Limito la curva a tale tratto
if ( ccClass[0].nClass != CRVC_IN)
return false ;
PtrOwner<ICurve> pCrvGlideInside( pCrvGlide->CopyParamRange( ccClass[0].dParS, ccClass[0].dParE)) ;
if ( IsNull( pCrvGlideInside) || ! pCrvGlideInside->IsValid())
return false ;
return ( pCrvGlide->Clear() && pCrvGlide->AddCurve( Release( pCrvGlideInside))) ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::AddSpecialLeadInZigZag( const ICurveComposite* pCompoPath, const Point3d& ptCurr, const Vector3d& vtTool,
int nStep, double dStep)
{
// verifico la validità della curva
if ( pCompoPath == nullptr || ! pCompoPath->IsValid())
return false ;
// verifico che la curva sia sufficientemente lunga per permettere un'entrata a ZigZag
double dMaxLen = min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
double dLen ; pCompoPath->GetLength( dLen) ;
if ( dLen < dMaxLen)
return false ;
#if DEBUG_ZIGZAG_LEADIN
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompoPath->Clone()) ;
m_pGeomDB->SetMaterial( _a, RED) ;
PtrOwner<IGeoPoint3d> _pt( CreateGeoPoint3d()) ; _pt->Set( ptCurr) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, _pt->Clone()) ;
m_pGeomDB->SetMaterial( _a, YELLOW) ;
#endif
// verifico che il punto iniziale sia effettivamente sulla curva
const double TOL = 25. * EPS_SMALL ;
if ( ! pCompoPath->IsPointOn( ptCurr, TOL))
return false ;
bool bAtStart = false ; // indica se lo ZigZag è vincolato prima della partenza
bool bAtEnd = false ; // indica se lo ZigZag è vincolato dopo l'arrivo
// recupero i due tratti di curva per lo ZigZag
PtrOwner<ICurveComposite> pCrvA( nullptr) ; // dal punto corrente segue la tangenza della curva
PtrOwner<ICurveComposite> pCrvB( nullptr) ; // dal punto corrente è opposta alla tangenza della curva
if ( pCompoPath->IsClosed()) {
// --- se curva chiusa, recupero il tratto iniziale e finale ( esistono per forza per precedente controllo sulla lunghezza)
PtrOwner<ICurveComposite> pCompoPathCL( CloneCurveComposite( pCompoPath)) ;
if ( IsNull( pCompoPathCL) || ! pCompoPathCL->IsValid())
return false ;
double dUCurr ; pCompoPathCL->GetParamAtPoint( ptCurr, dUCurr, TOL) ;
pCompoPathCL->ChangeStartPoint( dUCurr) ;
double dUA ; pCompoPathCL->GetParamAtLength( dMaxLen / 2., dUA) ;
double dUB ; pCompoPathCL->GetParamAtLength( dLen - dMaxLen / 2., dUB) ;
double dUS, dUE ;
pCompoPathCL->GetDomain( dUS, dUE) ;
pCrvA.Set( ConvertCurveToComposite( pCompoPathCL->CopyParamRange( dUS, dUA))) ;
if ( pCrvB.Set( ConvertCurveToComposite( pCompoPathCL->CopyParamRange( dUB, dUE))))
pCrvB->Invert() ;
}
else {
// --- se curva aperta, verifico se mi trovo vicino ad un estrmo
double dLenCurr ; pCompoPath->GetLengthAtPoint( ptCurr, dLenCurr, TOL) ;
bAtStart = ( dLenCurr < dMaxLen / 2.) ;
bAtEnd = ( dLenCurr > dLen - dMaxLen / 2.) ;
// se lontano da entrambi gli estremi, allora posso definire le due curve per lo ZigZag
if ( ! bAtStart && ! bAtEnd) {
double dUCurr ; pCompoPath->GetParamAtPoint( ptCurr, dUCurr, TOL) ;
double dUA ; pCompoPath->GetParamAtLength( dLenCurr + dMaxLen / 2. - EPS_SMALL, dUA) ;
double dUB ; pCompoPath->GetParamAtLength( dLenCurr - dMaxLen / 2. + EPS_SMALL, dUB) ;
pCrvA.Set( ConvertCurveToComposite( pCompoPath->CopyParamRange( dUCurr, dUA))) ;
if ( pCrvB.Set( ConvertCurveToComposite( pCompoPath->CopyParamRange( dUB, dUCurr))))
pCrvB->Invert() ;
}
else {
double dUS, dUE ; pCompoPath->GetDomain( dUS, dUE) ;
// se sono all'inizio
if ( bAtStart) {
double dUA ; pCompoPath->GetParamAtLength( dMaxLen - EPS_SMALL, dUA) ;
double dUMid ; pCompoPath->GetParamAtLength( dMaxLen / 2., dUMid) ;
pCrvA.Set( ConvertCurveToComposite( pCompoPath->CopyParamRange( dUMid, dUA))) ;
if ( pCrvB.Set( ConvertCurveToComposite( pCompoPath->CopyParamRange( dUS, dUMid))))
pCrvB->Invert() ;
}
// se alla fine
else if ( bAtEnd) {
double dUB ; pCompoPath->GetParamAtLength( dLen - dMaxLen + EPS_SMALL, dUB) ;
double dUMid ; pCompoPath->GetParamAtLength( dLen - dMaxLen / 2., dUMid) ;
pCrvA.Set( ConvertCurveToComposite( pCompoPath->CopyParamRange( dUMid, dUE))) ;
if ( pCrvB.Set( ConvertCurveToComposite( pCompoPath->CopyParamRange( dUB, dUMid))))
pCrvB->Invert() ;
}
}
}
// se le curve di ZigZag non sono valide, errore
if ( IsNull( pCrvA) || IsNull( pCrvB) || ! pCrvA->IsValid() || ! pCrvB->IsValid())
return false ;
// definisco i quattro tratti dello ZigZag
ICRVCOMPOPOVECTOR vCrvZigZagStep ; vCrvZigZagStep.resize( 4) ;
if ( ! vCrvZigZagStep[0].Set( Release( pCrvA)) ||
! vCrvZigZagStep[1].Set( CloneCurveComposite( vCrvZigZagStep[0])) || ! vCrvZigZagStep[1]->Invert() ||
! vCrvZigZagStep[2].Set( Release( pCrvB)) ||
! vCrvZigZagStep[3].Set( CloneCurveComposite( vCrvZigZagStep[2])) || ! vCrvZigZagStep[3]->Invert())
return false ;
// Assegno loro l'estrusione
vCrvZigZagStep[0]->SetExtrusion( vtTool) ;
vCrvZigZagStep[1]->SetExtrusion( vtTool) ;
vCrvZigZagStep[2]->SetExtrusion( vtTool) ;
vCrvZigZagStep[3]->SetExtrusion( vtTool) ;
#if DEBUG_ZIGZAG_LEADIN
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvZigZagStep[0]->Clone()) ;
m_pGeomDB->SetMaterial( _a, AQUA) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvZigZagStep[1]->Clone()) ;
m_pGeomDB->SetMaterial( _a, AQUA) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvZigZagStep[2]->Clone()) ;
m_pGeomDB->SetMaterial( _a, ORANGE) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvZigZagStep[3]->Clone()) ;
m_pGeomDB->SetMaterial( _a, ORANGE) ;
#endif
// uniformo la pendenza delle curve
Point3d ptIni, ptFin ;
double dNini, dNfin ;
for ( int i = 0 ; i < 4 ; ++ i) {
vCrvZigZagStep[i]->GetStartPoint( ptIni) ;
vCrvZigZagStep[i]->GetEndPoint( ptFin) ;
dNini = ( ptIni - ORIG) * vtTool ;
dNfin = ( ( ptFin - 0.25 * dStep * vtTool) - ORIG) * vtTool ;
AdjustCurveSlope( vCrvZigZagStep[i], dNini, dNfin) ;
}
#if DEBUG_ZIGZAG_LEADIN
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvZigZagStep[0]->Clone()) ;
m_pGeomDB->SetMaterial( _a, BLUE) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvZigZagStep[1]->Clone()) ;
m_pGeomDB->SetMaterial( _a, BLUE) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvZigZagStep[2]->Clone()) ;
m_pGeomDB->SetMaterial( _a, RED) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvZigZagStep[3]->Clone()) ;
m_pGeomDB->SetMaterial( _a, RED) ;
#endif
// uniformo le posizione delle curve
if ( bAtStart)
rotate( vCrvZigZagStep.begin(), vCrvZigZagStep.begin() + 3, vCrvZigZagStep.end()) ;
else if ( bAtEnd)
rotate( vCrvZigZagStep.begin(), vCrvZigZagStep.begin() + 1, vCrvZigZagStep.end()) ;
// calcolo la Feed in base alla pendenza
double dFeed = GetEndFeed() ;
for ( int i = 0 ; i < 4 ; ++ i) {
Point3d ptS ; vCrvZigZagStep[i]->GetStartPoint( ptS) ;
Point3d ptE ; vCrvZigZagStep[i]->GetEndPoint( ptE) ;
Vector3d vtMove = ptE - ptS ;
dFeed = min( dFeed, GetRightStartFeed( vtMove, vtTool)) ;
}
// definisco il percorso a ZigZag ( lo definisco dal basso verso l'alto)
Point3d ptRef = ptCurr ;
PtrOwner<ICurveComposite> pCompoZigZag( CreateCurveComposite()) ;
if ( IsNull( pCompoZigZag) || ! pCompoZigZag->AddPoint( ptRef))
return false ;
for ( int nS = 0 ; nS < nStep ; ++ nS) {
for ( int i = 3 ; i >= 0 ; -- i) {
PtrOwner<ICurveComposite> pCompo( CloneCurveComposite( vCrvZigZagStep[i])) ;
if ( IsNull( pCompo) || ! pCompo->IsValid())
return false ;
Point3d ptEndCurr ; pCompo->GetEndPoint( ptEndCurr) ;
pCompo->Translate( ptRef - ptEndCurr) ;
pCompo->GetStartPoint( ptRef) ;
#if DEBUG_ZIGZAG_LEADIN
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompo->Clone()) ;
m_pGeomDB->SetMaterial( _a, GREEN) ;
#endif
if ( ! pCompoZigZag->AddCurve( Release( pCompo), false, TOL))
return false ;
}
}
// verifico che tutto sia andato a buon fine
if ( pCompoZigZag->IsValid()) {
SetFeed( dFeed) ;
return ( AddCurveMove( pCompoZigZag) != GDB_ID_NULL) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir,
double& dDist, Vector3d& vtNorm)
{
if ( ! GetElevation( nPhase, ptP, vtDir, dDist, vtNorm))
return false ;
// se punto esterno al grezzo
if ( abs( dDist) < EPS_SMALL) {
double dDist1, dDist2 ;
if ( ! GetElevation( nPhase, ptP, -vtDir, dDist1))
return false ;
if ( ! GetElevation( nPhase, ptP - vtDir * ( dDist1), vtDir, dDist2, vtNorm))
return false ;
if ( abs( dDist2) > EPS_SMALL && abs( dDist1) > EPS_SMALL)
dDist = dDist2 - dDist1 ;
}
return true ;
}
// debug functions
//----------------------------------------------------------------------------
void
PocketingNT::DebugDrawSfr( const ISurfFlatRegion* pSfr, bool bUniform, int nLayer)
{
if ( pSfr == nullptr || ! pSfr->IsValid())
return ;
int nInd = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pSfr->Clone()) ;
m_pGeomDB->SetMaterial( nInd, Color( 0., 255., 0., .5)) ;
for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
PtrOwner<ICurveComposite> pCrvCompo( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
DebugDrawLoop( pCrvCompo->Clone(), nLayer, bUniform) ;
}
}
return ;
}
//----------------------------------------------------------------------------
void
PocketingNT::DebugDrawLoop( const ICurveComposite* pCrvCompo, int nLayer, bool bUniform)
{
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return ;
for ( int nU = 0 ; nU < pCrvCompo->GetCurveCount() ; ++ nU) {
int nProp0 ; pCrvCompo->GetCurveTempProp( nU, nProp0, 0) ;
int nProp1 ; pCrvCompo->GetCurveTempProp( nU, nProp1, 1) ;
int nInd = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pCrvCompo->GetCurve( nU)->Clone()) ;
m_pGeomDB->SetMaterial( nInd, bUniform ? WHITE : ( nProp0 == 0 ? BLUE : RED)) ;
}
return ;
}
//----------------------------------------------------------------------------
void
PocketingNT::DebugDrawBox( const BBox3d& BBox, const Frame3d& FrBox, int nLayer)
{
Point3d ptMin = BBox.GetMin() ; ptMin.ToGlob( FrBox) ;
Point3d ptMax = BBox.GetMax() ; ptMax.ToGlob( FrBox) ;
PtrOwner<ICurveComposite> pBase( CreateCurveComposite()) ;
pBase->AddPoint( ptMin) ;
Vector3d vtPtNext = ( ptMin - ORIG) + BBox.GetDimX() * FrBox.VersX() ;
pBase->AddLine( Point3d( vtPtNext.x, vtPtNext.y, vtPtNext.z)) ;
vtPtNext = ( ptMax - ORIG) - BBox.GetDimZ() * FrBox.VersZ() ;
pBase->AddLine( Point3d( vtPtNext.x, vtPtNext.y, vtPtNext.z)) ;
vtPtNext = ( ptMin - ORIG) + BBox.GetDimY() * FrBox.VersY() ;
pBase->AddLine( Point3d( vtPtNext.x, vtPtNext.y, vtPtNext.z)) ;
pBase->Close() ;
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
m_pGeomDB->SetMaterial( _a, YELLOW) ;
pBase->Translate( BBox.GetDimZ() * FrBox.VersZ()) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
m_pGeomDB->SetMaterial( _a, YELLOW) ;
pBase->Clear() ;
pBase->AddPoint( ptMin) ;
vtPtNext = ( ptMin - ORIG) + BBox.GetDimZ() * FrBox.VersZ() ;
pBase->AddLine( Point3d( vtPtNext.x, vtPtNext.y, vtPtNext.z)) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
m_pGeomDB->SetMaterial( _a, YELLOW) ;
pBase->Translate( BBox.GetDimX() * FrBox.VersX()) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
m_pGeomDB->SetMaterial( _a, YELLOW) ;
pBase->Translate( BBox.GetDimY() * FrBox.VersY()) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
m_pGeomDB->SetMaterial( _a, YELLOW) ;
pBase->Translate( - BBox.GetDimX() * FrBox.VersX()) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
m_pGeomDB->SetMaterial( _a, YELLOW) ;
PtrOwner<IGeoFrame3d> fr( CreateGeoFrame3d()) ;
fr->Set( FrBox) ;
_a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, fr->Clone()) ;
}
//----------------------------------------------------------------------------
void
PocketingNT::DebugDrawOpenEdgesInRaw( const ICRVCOMPOPOVECTOR& vpCrvs, int nlayer)
{
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
Color myColor = BLACK ;
if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE)
myColor = BLUE ;
else if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE)
myColor = RED ;
else if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE_IN_RAW)
myColor = ORANGE ;
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nlayer, vpCrvs[i]->Clone()) ;
m_pGeomDB->SetMaterial( _a, myColor) ;
}
}
//----------------------------------------------------------------------------
void
PocketingNT::DebugDrawFeed( const ICurve* pCrv, double dFeed, int nLay)
{
if ( pCrv == nullptr || ! pCrv->IsValid())
return ;
// recupero parametro di Feed minima
double dMinFeed = GetFeed() / FEED_MAX_REDUCE ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_MINFEED, dMinFeed))
dMinFeed = Clamp( dMinFeed, GetFeed() / FEED_MAX_REDUCE, GetFeed()) ;
double myAngle = 120 * ( ( ( dFeed - dMinFeed) / ( GetFeed() - dMinFeed))) ;
int nInd = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrv->Clone()) ;
m_pGeomDB->SetMaterial( nInd, GetColorFromHSV( HSV( myAngle, 1., 1.))) ;
return ;
}
Reference in New Issue View Git Blame Copy Permalink