Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f7d7d1ceaf3e97f8b2dd9346327bd55bcd10929d
EgtMachKernel/SurfFinishing.cpp
T
Riccardo Elitropi 51c34f98b6 EgtMachKernel 3.1f6 : 
- in Finitura di superfici corretti e migliorati i percorsi di lavorazione per Optimal e ZLevel
- in Finitura Optimal migliorati i controlli sull'ordine dei percorsi
- in Finitura di superfici rimosse funzioni non utilizzate.
2026-06-30 12:35:40 +02:00

6395 lines
274 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// EgalTech 2019-2019
//----------------------------------------------------------------------------
// File : SurfFinishing.cpp Data : 28.05.19 Versione : 2.1e5
// Contenuto : Implementazione gestione finitura superfici.
//
//
//
// Modifiche : 28.05.19 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "SurfFinishing.h"
#include "OperationConst.h"
#include "OperUserNotesConst.h"
#include "GeoConst.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkArcSpecial.h"
#include "/EgtDev/Include/EGkChainCurves.h"
#include "/EgtDev/Include/EGkOffsetCurve.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkIntersCurves.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkSurfLocal.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkDistPointSurfFr.h"
#include "/EgtDev/Include/EGkCAvToolSurfTm.h"
#include "/EgtDev/Include/EGkCAvSilhouetteSurfTm.h"
#include "/EgtDev/Include/EGkCalcPocketing.h"
#include "/EgtDev/Include/EGkIntervals.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EXeCmdLogOff.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkDistPointSurfTm.h"
#include "/EgtDev/Include/EGkPolygon3d.h"
#include "/EgtDev/Include/EGkPolygonElevation.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
#include <thread>
#include <future>
// per far dimenticare macro di WinUser.h
#undef GetClassName
using namespace std ;
//------------------------------ Errors --------------------------------------
// 3101 = "Error in SurfFinishing : UpdateToolData failed"
// 3102 = "Error in SurfFinishing : Tool loading failed"
// 3103 = "Error in SurfFinishing : Chaining failed"
// 3104 = "Error in SurfFinishing : Open Contour"
// 3105 = "Error in SurfFinishing : Contour Not Flat"
// 3106 = "Error in SurfFinishing : Tool Dir not perpendicular to Flat Area"
// 3107 = "Error in SurfFinishing : Empty RawBox"
// 3108 = "Error in SurfFinishing : Depth not computable"
// 3109 = "Error in SurfFinishing : Offset not computable"
// 3110 = "Error in SurfFinishing : Toolpath not computable"
// 3111 = "Error in SurfFinishing : Approach not computable"
// 3112 = "Error in SurfFinishing : Link not computable"
// 3113 = "Error in SurfFinishing : LeadIn not computable"
// 3114 = "Error in SurfFinishing : LeadOut not computable"
// 3115 = "Error in SurfFinishing : Retract not computable"
// 3116 = "Error in SurfFinishing : axes values not calculable"
// 3117 = "Error in SurfFinishing : outstroke xx"
// 3118 = "Error in SurfFinishing : link movements not calculable"
// 3119 = "Error in SurfFinishing : link outstroke"
// 3120 = "Error in SurfFinishing : post apply not calculable"
// 3121 = "Error in SurfFinishing : Linear Approx not computable"
// 3122 = "Error in SurfFinishing : aggregate from bottom not allowed"
// 3123 = "Error in SurfFinishing : missing surfaces"
// 3124 = "Error in SurfFinishing : region not computable"
// 3125 = "Error in SurfFinishing : CalcPocketing failed"
// 3126 = "Error in SurfFinishing : Computing ZConst Curves failed"
// 3127 = "Error in SurfFinishing : Computing ZConst Paths failed"
// 3128 = "Error in SurfFinishing : Curves with different extrusion"
// 3129 = "Error in SurfFinishing : Splitting surfaces failed"
// 3130 = "Error in SurfFinishing : Computing tool region failed"
// 3131 = "Error in SurfFinishing : Computing Surface Offset failed"
// 3132 = "Error in SurfFinishing : Computing Offset Edges failed"
// 3133 = "Error in SurfFinishing : Projecting curves on Surface failed"
// 3134 = "Error in SurfFinishing : Projecting Path failed"
// 3135 = "Error in SurfFinishing : Calc Region Elvation failed"
// 3136 = "Error in SurfFinishing : special apply not calculable"
// 3137 = "Error in SurfFinishing : Tool direction too steepy"
// 3151 = "Warning in SurfFinishing : Skipped entity (xx)"
// 3152 = "Warning in SurfFinishing : No machinable path"
// 3153 = "Warning in SurfFinishing : Tool name changed (xx)"
// 3154 = "Warning in SurfFinishing : Tool data changed (xx)"
// 3155 = "Warning in SurfFinishing : Pencil path not completed"
//----------------------------------------------------------------------------
static string KEY_THICK = "THICK" ;
static string SRF_SUPP_LAYER_NAME = "SUPP" ;
const double SILH_SAMPLING = 1. ;
const double SUPP_SURF_RADIAL_OFFS = 5. ;
const double TILT_ANG_DEG = 60.0 ;
enum {
PENCIL_CORNER = 0,
PENCIL_FAT_CORNER = 1,
PENCIL_REGION = 2
} ;
#define DEBUG 0
#define DEBUG_SFR 0
#define ENABLE_ZCONST_PATH_DEBUG 0
#define ENABLE_OPTIMAL_DEBUG 0
#define ENABLE_OPTIMAL_SOFT_DEBUG 0
#define ENABLE_OPTIMAL_FINAL_CURVES_DEBUG 0
#define ENABLE_PENCIL_DEBUG 0
#define ENABLE_LINK_DEBUG 0
#define ENABLE_MAXDOWN_STARTEND_DEBUG 0
#if DEBUG || DEBUG_SFR || ENABLE_ZCONST_PATH_DEBUG || ENABLE_OPTIMAL_DEBUG || ENABLE_OPTIMAL_SOFT_DEBUG || \
ENABLE_PENCIL_DEBUG || ENABLE_OPTIMAL_FINAL_CURVES_DEBUG || ENABLE_LINK_DEBUG || ENABLE_MAXDOWN_STARTEND_DEBUG
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#endif
//----------------------------------------------------------------------------
USEROBJ_REGISTER( GetOperationClass( OPER_SURFFINISHING), SurfFinishing) ;
//----------------------------------------------------------------------------
const string&
SurfFinishing::GetClassName( void) const
{
return USEROBJ_GETNAME( SurfFinishing) ;
}
//----------------------------------------------------------------------------
SurfFinishing*
SurfFinishing::Clone( void) const
{
// alloco oggetto
SurfFinishing* pSrF = new(nothrow) SurfFinishing ;
// eseguo copia dei dati
if ( pSrF != nullptr) {
try {
pSrF->m_vId = m_vId ;
pSrF->m_pMchMgr = m_pMchMgr ;
pSrF->m_nPhase = m_nPhase ;
pSrF->m_Params = m_Params ;
pSrF->m_TParams = m_TParams ;
pSrF->m_Frame = m_Frame ;
pSrF->m_dTheta = m_dTheta ;
pSrF->m_dPhi = m_dPhi ;
pSrF->m_dTHoldBase = m_dTHoldBase ;
pSrF->m_dTHoldLen = m_dTHoldLen ;
pSrF->m_dTHoldDiam = m_dTHoldDiam ;
pSrF->m_nStatus = m_nStatus ;
pSrF->m_nPaths = m_nPaths ;
}
catch( ...) {
delete pSrF ;
return nullptr ;
}
}
// ritorno l'oggetto
return pSrF ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::Dump( string& sOut, bool bMM, const char* szNewLine) const
{
sOut += GetClassName() + "[mm]" + szNewLine ;
sOut += KEY_PHASE + EQUAL + ToString( m_nPhase) + szNewLine ;
sOut += KEY_IDS + EQUAL + ToString( m_vId) + szNewLine ;
for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
sOut += m_Params.ToString( i) + szNewLine ;
for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
sOut += m_TParams.ToString( i) + szNewLine ;
sOut += KEY_NUM + EQUAL + ToString( m_nPaths) + szNewLine ;
sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::Save( int nBaseId, STRVECTOR& vString) const
{
try {
int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 3 ;
vString.insert( vString.begin(), nSize, "") ;
int k = - 1 ;
if ( ! SetVal( KEY_IDS, m_vId, vString[++k]))
return false ;
for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
vString[++k] = m_Params.ToString( i) ;
for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
vString[++k] = m_TParams.ToString( i) ;
if ( ! SetVal( KEY_PHASE, m_nPhase, vString[++k]))
return false ;
if ( ! SetVal( KEY_NUM, m_nPaths, vString[++k]))
return false ;
if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k]))
return false ;
}
catch( ...) {
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::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_nPaths))
return false ;
}
else if ( sKey == KEY_STAT) {
if ( ! FromString( sVal, m_nStatus))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
SurfFinishing::SurfFinishing( 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_nStatus = MCH_ST_TO_VERIFY ;
m_nPaths = 0 ;
m_bRunning = false ;
m_Frame.Reset() ; // inizialmente invalido
m_dTheta = 0. ; // orientamento come asse Z di m_Frame
m_dPhi = 0. ; // orientamento come asse Z di m_Frame
}
//----------------------------------------------------------------------------
bool
SurfFinishing::Prepare( const string& sSawName)
{
// 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 SurfFinishingData* pDdata = GetSurfFinishingData( pMMgr->GetMachining( sSawName)) ;
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
SurfFinishing::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 ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::SetParam( int nType, int nVal)
{
switch ( nType) {
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 ;
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 ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::SetParam( int nType, double dVal)
{
switch ( nType) {
case MPA_SPEED :
if ( ! m_TParams.VerifySpeed( dVal))
return false ;
if ( AreSameAngValue( dVal, m_TParams.m_dSpeed))
dVal = 0 ;
m_Params.m_dSpeed = dVal ;
return true ;
case MPA_FEED :
if ( AreSameLenValue( dVal, m_TParams.m_dFeed))
dVal = 0 ;
if ( ! AreSameLenValue( dVal, m_Params.m_dFeed))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dFeed = dVal ;
return true ;
case MPA_STARTFEED :
if ( AreSameLenValue( dVal, m_TParams.m_dStartFeed))
dVal = 0 ;
if ( ! AreSameLenValue( dVal, m_Params.m_dStartFeed))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartFeed = dVal ;
return true ;
case MPA_ENDFEED :
if ( AreSameLenValue( dVal, m_TParams.m_dEndFeed))
dVal = 0 ;
if ( ! AreSameLenValue( dVal, m_Params.m_dEndFeed))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dEndFeed = dVal ;
return true ;
case MPA_TIPFEED :
if ( AreSameLenValue( dVal, m_TParams.m_dTipFeed))
dVal = 0 ;
if ( ! AreSameLenValue( dVal, m_Params.m_dTipFeed))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dTipFeed = dVal ;
return true ;
case MPA_OFFSR :
if ( AreSameLenValue( dVal, m_TParams.m_dOffsR))
dVal = UNKNOWN_PAR ;
if ( ! AreSameLenValue( dVal, m_Params.m_dOffsR))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOffsR = 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 ( ! AreSameLenValue( dVal, m_Params.m_dStartPos))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartPos = dVal ;
return true ;
case MPA_OVERL :
if ( ! AreSameLenValue( dVal, m_Params.m_dOverlap))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOverlap = dVal ;
return true ;
case MPA_SIDESTEP :
if ( ! AreSameLenValue( dVal, m_Params.m_dSideStep))
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_LIPERP :
if ( abs( dVal - m_Params.m_dLiPerp) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiPerp = dVal ;
return true ;
case MPA_LOTANG :
if ( abs( dVal - m_Params.m_dLoTang) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoTang = dVal ;
return true ;
case MPA_LOPERP :
if ( abs( dVal - m_Params.m_dLoPerp) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoPerp = dVal ;
return true ;
case MPA_APPROX :
if ( abs( dVal - m_Params.m_dApprox) > EPS_SMALL)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dApprox = dVal ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::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
SurfFinishing::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
for ( const auto& Id : vIds) {
// test sull'entità
int nSubs ;
if ( ! VerifyGeometry( Id, nSubs)) {
string sInfo = "Warning in SurfFinishing : Skipped entity " + ToString( Id) ;
m_pMchMgr->SetWarning( 3151, 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()) ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::Preview( bool bRecalc)
{
// non esiste preview, si fa apply
return Apply( bRecalc, false) ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::Apply( bool bRecalc, bool bPostApply)
{
// se calcoli già in corso, esco
if ( m_bRunning) {
LOG_DBG_INFO( GetEMkLogger(), "SurfFinishing::Apply already running") ;
return true ;
}
m_bRunning = true ;
bool bOk = MyApply( bRecalc, bPostApply) ;
m_bRunning = false ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::MyApply( bool bRecalc, bool bPostApply)
{
// reset numero percorsi di finitura generati
int nCurrPaths = m_nPaths ;
m_nPaths = 0 ;
// verifico validità gestore DB geometrico e Id del gruppo
if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
return false ;
// aggiorno dati geometrici dell'utensile
if ( ! UpdateToolData()) {
m_pMchMgr->SetLastError( 3101, "Error in SurfFinishing : UpdateToolData failed") ;
return false ;
}
// non è prevista finitura superficie con aggregato da sotto
if ( IsAggrBottom( m_TParams.m_sHead)) {
m_pMchMgr->SetLastError( 3122, "Error in SurfFinishing : aggregate from bottom not allowed") ;
return false ;
}
// se modificata geometria, necessario ricalcolo
if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
bRecalc = true ;
// 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 ;
}
else {
// altrimenti, controllo esistenza delle regioni (per compatibilità)
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL && ! bChain) {
int nGeoId = m_pGeomDB->GetFirstInGroup( nPathId) ;
while ( nGeoId != GDB_ID_NULL && ! bChain) {
if ( m_Params.m_nSubType == SURFFIN_SUB_ZIGZAG || m_Params.m_nSubType == SURFFIN_SUB_ONEWAY ||
m_Params.m_nSubType == SURFFIN_SUB_SPIRALIN || m_Params.m_nSubType == SURFFIN_SUB_SPIRALOUT ||
m_Params.m_nSubType == SURFFIN_SUB_Z_CONST || m_Params.m_nSubType == SURFFIN_SUB_OPTIMAL ||
m_Params.m_nSubType == SURFFIN_SUB_PENCIL)
bChain = ( m_pGeomDB->GetGeoType( nGeoId) != SRF_FLATRGN) ;
else if ( m_Params.m_nSubType == SURFFIN_SUB_PROJECT)
bChain = ( m_pGeomDB->GetGeoType( nPathId) != CRV_COMPO) ;
nGeoId = m_pGeomDB->GetNext( nGeoId) ;
}
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
if ( bChain)
m_pGeomDB->EmptyGroup( nAuxId) ;
}
// se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
if ( bChain && ! Chain( nAuxId)) {
m_pMchMgr->SetLastError( 3103, "Error in SurfFinishing : Chaining failed") ;
return false ;
}
// se modifica del frame, necessario ricalcolo
UpdateFrameAndToolDir( nAuxId, bRecalc) ;
// recupero il gruppo per posizionamento Frame e versore utensile
int nFrameId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUXVIEW) ;
// se non c'è lo aggiungo
if ( nFrameId == GDB_ID_NULL) {
nFrameId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nFrameId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nFrameId, MCH_AUXVIEW) ;
m_pGeomDB->SetStatus( nFrameId, GDB_ST_OFF) ;
}
// se richiesto il ricalcolo lo aggiorno
else if ( bRecalc)
m_pGeomDB->EmptyGroup( nFrameId) ;
// 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_nPaths = nCurrPaths ;
string sLog = string( "SurfFinishing 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 ;
// se c'è geometria, aggiungo il frame e il versore utensile al suo interno
if ( m_pGeomDB->GetFirstGroupInGroup( nAuxId) != GDB_ID_NULL) {
PtrOwner<IGeoFrame3d> pFrGeo( CreateGeoFrame3d()) ;
if ( IsNull( pFrGeo) || ! pFrGeo->Set( m_Frame))
return false ;
int nFrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nFrameId, ::Release( pFrGeo)) ;
if ( nFrId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetStatus( nFrId, GDB_ST_ON) ;
Vector3d vtSperic = GetToGlob( FromSpherical( 25.0, m_dTheta, m_dPhi), m_Frame) ;
PtrOwner<IGeoVector3d> vtToolGeo( CreateGeoVector3d()) ;
if ( IsNull( vtToolGeo) || ! vtToolGeo->Set( vtSperic))
return false ;
vtToolGeo->ChangeBase( m_Frame.Orig()) ;
int nToolVtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nFrameId, ::Release( vtToolGeo)) ;
if ( nToolVtId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetStatus( nToolVtId, GDB_ST_ON) ;
m_pGeomDB->SetMaterial( nToolVtId, FUCHSIA) ;
// nel caso di lavorazioni Optimal o Zlevel nascondo tale frame
if ( m_Params.m_nSubType == SURFFIN_SUB_Z_CONST || m_Params.m_nSubType == SURFFIN_SUB_OPTIMAL)
m_pGeomDB->SetStatus( nToolVtId, GDB_ST_OFF) ;
}
// 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( 3102, "Error in SurfFinishing : 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) ;
// lavoro ogni singola regione piana
if ( m_Params.m_nSubType == SURFFIN_SUB_ZIGZAG || m_Params.m_nSubType == SURFFIN_SUB_ONEWAY ||
m_Params.m_nSubType == SURFFIN_SUB_SPIRALIN || m_Params.m_nSubType == SURFFIN_SUB_SPIRALOUT ||
m_Params.m_nSubType == SURFFIN_SUB_Z_CONST || m_Params.m_nSubType == SURFFIN_SUB_OPTIMAL ||
m_Params.m_nSubType == SURFFIN_SUB_PENCIL) {
bool bOk = true ;
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL) {
if ( ! ProcessSfr( nPathId, GDB_ID_NULL, nClId))
bOk = false ;
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
if ( ! bOk)
return false ;
}
// lavoro ogni singola curva composita
else if ( m_Params.m_nSubType == SURFFIN_SUB_PROJECT) {
bool bOk = true ;
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL) {
if ( ! ProcessCrv( nPathId, GDB_ID_NULL, nClId))
bOk = false ;
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
if ( ! bOk)
return false ;
}
else
return false ;
// assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
CalcAndSetBBox( nClId) ;
// eseguo aggiornamento assi macchina e collegamento con operazione precedente
if ( ! Update( bPostApply))
return false ;
// aggiorno stato della lavorazione
m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
// dichiaro successiva da aggiornare
UpdateFollowingOperationsStatus( MCH_ST_OTH_MODIF) ;
LOG_DBG_INFO( GetEMkLogger(), "SurfFinishing apply done") ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::Update( bool bPostApply)
{
// verifico validità gestore DB geometrico e Id del gruppo
if ( m_pGeomDB == nullptr || ! m_pGeomDB->ExistsObj( m_nOwnerId))
return false ;
// se lavorazione vuota, esco
if ( m_nPaths == 0) {
m_pMchMgr->SetWarning( 3152, "Warning in SurfFinishing : No machinable path") ;
return true ;
}
// elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo)
RemoveClimbRiseHome() ;
// imposto eventuale asse bloccato da lavorazione
SetBlockedRotAxis( m_Params.m_sBlockedAxis) ;
// calcolo gli assi macchina
string sHint = ExtractHint( m_Params.m_sUserNotes) ;
if ( ! m_Params.m_sInitAngs.empty())
sHint = m_Params.m_sInitAngs ;
if ( ! CalculateAxesValues( sHint)) {
string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
if ( sInfo.empty())
m_pMchMgr->SetLastError( 3116, "Error in SurfFinishing : axes values not calculable") ;
else
m_pMchMgr->SetLastError( 3117, "Error in SurfFinishing : outstroke ") ;
return false ;
}
// assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
CalcAndSetAxesBBox() ;
// esecuzione eventuali personalizzazioni speciali
string sSpecErr ;
if ( bPostApply && ! SpecialApply( sSpecErr)) {
if ( ! IsEmptyOrSpaces( sSpecErr))
m_pMchMgr->SetLastError( 3136, sSpecErr) ;
else
m_pMchMgr->SetLastError( 3136, "Error in SurfFinishing : 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( 3118, "Error in SurfFinishing : link movements not calculable") ;
else
m_pMchMgr->SetLastError( 3119, "Error in SurfFinishing : link outstroke ") ;
return false ;
}
// esecuzione eventuali personalizzazioni finali
string sPostErr ;
if ( bPostApply && ! PostApply( sPostErr)) {
if ( ! IsEmptyOrSpaces( sPostErr))
m_pMchMgr->SetLastError( 3120, sPostErr) ;
else
m_pMchMgr->SetLastError( 3120, "Error in SurfFinishing : post apply not calculable") ;
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetParam( int nType, bool& bVal) const
{
switch ( nType) {
case MPA_INVERT :
bVal = m_Params.m_bInvert ;
return true ;
}
bVal = false ;
return false ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetParam( int nType, int& nVal) const
{
switch ( nType) {
case MPA_TYPE :
nVal = MT_SURFFINISHING ;
return true ;
case MPA_SUBTYPE :
nVal = m_Params.m_nSubType ;
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 ;
}
nVal = 0 ;
return false ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::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_STARTPOS :
dVal = m_Params.m_dStartPos ;
return true ;
case MPA_OVERL :
dVal = m_Params.m_dOverlap ;
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_LIPERP :
dVal = m_Params.m_dLiPerp ;
return true ;
case MPA_LOTANG :
dVal = m_Params.m_dLoTang ;
return true ;
case MPA_LOPERP :
dVal = m_Params.m_dLoPerp ;
return true ;
case MPA_APPROX :
dVal = m_Params.m_dApprox ;
return true ;
}
dVal = 0 ;
return false ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::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&
SurfFinishing::GetToolData( void) const
{
return m_TParams ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::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 SurfFinishing : tool name changed (" +
m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
m_pMchMgr->SetWarning( 3153, sInfo) ;
m_Params.m_sToolName = m_TParams.m_sName ;
}
if ( bChanged) {
string sInfo = "Warning in SurfFinishing : tool data changed (" +
m_Params.m_sToolName + ")" ;
m_pMchMgr->SetWarning( 3154, sInfo) ;
}
// se modificato, aggiusto lo stato
if ( bChanged)
m_nStatus = MCH_ST_TO_VERIFY ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetGeometry( SELVECTOR& vIds) const
{
// restituisco l'elenco delle entità
vIds = m_vId ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const
{
// compenso il raggio dell'utensile
ptP += pCamData->GetCorrDir() * ( m_TParams.m_dDiam / 2) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::VerifyGeometry( SelData Id, int& nSubs)
{
// ammessi : curve o superfici
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
if ( pGObj == nullptr)
return false ;
// se curva
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
const ICurve* pCurve = nullptr ;
// se direttamente la curva
if ( Id.nSub == SEL_SUB_ALL) {
pCurve = ::GetCurve( pGObj) ;
if ( pCurve != nullptr) {
if ( pCurve->GetType() == CRV_COMPO)
nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
else
nSubs = 0 ;
}
}
// altrimenti sottocurva di composita
else {
const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
if ( pCompo != nullptr)
pCurve = pCompo->GetCurve( Id.nSub) ;
nSubs = 0 ;
}
return ( pCurve != nullptr) ;
}
// se altrimenti è superficie trimesh
else if ( pGObj->GetType() == SRF_TRIMESH) {
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
return ( pSurf != nullptr && pSurf->GetFacetCount() >= 1) ;
}
// se altrimenti è superficie Bezier
else if ( pGObj->GetType() == SRF_BEZIER) {
const ISurfBezier* pSurf = ::GetSurfBezier( pGObj) ;
return ( pSurf != nullptr && pSurf->IsValid()) ;
}
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
{
// ammessi : curve, superfici TriMesh e superfici Bezier
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 ;
// recupero il tipo
int nType = pGObj->GetType() ;
// se curva
if ( ( nType & GEO_CURVE) != 0) {
PtrOwner<ICurve> pCurve ;
// se direttamente curva
if ( Id.nSub == SEL_SUB_ALL) {
// recupero la curva
const ICurve* pOriCurve = ::GetCurve( pGObj) ;
if ( pOriCurve == nullptr)
return false ;
// la duplico
pCurve.Set( pOriCurve->Clone()) ;
// se estrusione mancante, imposto default
Vector3d vtExtr ;
if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall())
pCurve->SetExtrusion( Z_AX) ;
}
// altrimenti sottocurva di composita
else {
// recupero la composita
const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
if ( pCompo == nullptr)
return false ;
// recupero la curva semplice
const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ;
if ( pOriCurve == nullptr)
return false ;
// la duplico
pCurve.Set( pOriCurve->Clone()) ;
// recupero estrusione e spessore
Vector3d vtExtr ;
if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall())
vtExtr = Z_AX ;
pCurve->SetExtrusion( vtExtr) ;
double dThick ;
if ( pCompo->GetThickness( dThick))
pCurve->SetThickness( dThick) ;
}
if ( IsNull( pCurve))
return false ;
// la porto in globale
pCurve->ToGlob( frGlob) ;
// la restituisco
lstPC.emplace_back( Release( pCurve)) ;
return true ;
}
// se superficie TriMesh
else if ( nType == SRF_TRIMESH)
return true ;
// se superficie Bezier
else if ( nType == SRF_BEZIER)
return true ;
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::FlattenCurves( ICURVEPOVECTOR& vpCrv) const
{
// se la lista è vuota, non faccio nulla
if ( vpCrv.empty())
return true ;
// scorro le curve
for ( int i = 0 ; i < ssize( vpCrv) ; ++ i) {
// se nulla o non valida, errore
if ( vpCrv[i] == nullptr || ! vpCrv[i]->IsValid())
return false ;
// definisco un riferimento a partire dalla sua estrusione
Vector3d vtExtr = Z_AX ; vpCrv[i]->GetExtrusion( vtExtr) ;
Frame3d frRef ;
if ( ! frRef.Set( ORIG, vtExtr))
return false ;
// porto la curva in tale riferimento
vpCrv[i]->ToLoc( frRef) ;
BBox3d B3Loc ; vpCrv[i]->GetLocalBBox( B3Loc) ;
Point3d ptMaxGlob = GetToGlob( B3Loc.GetMax(), frRef) ;
vpCrv[i]->ToGlob( frRef) ;
// proeitto la curva sul piano definito dalla sua estrusione e dal suo punto locale più elevato
Plane3d plRef ;
if ( ! plRef.Set( ptMaxGlob, vtExtr))
return false ;
vpCrv[i].Set( ProjectCurveOnPlane( *vpCrv[i], plRef)) ;
vpCrv[i]->SetExtrusion( vtExtr) ;
if ( IsNull( vpCrv[i]) || ! vpCrv[i]->IsValid())
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::Chain( int nGrpDestId)
{
// vettore puntatori alle curve
ICURVEPOVECTOR vpCrvs ;
vpCrvs.reserve( m_vId.size()) ;
// vettore selettori delle curve originali
SELVECTOR vInds ;
// recupero tutte le curve e le porto in globale
for ( const auto& Id : m_vId) {
// prendo le curve
ICURVEPLIST lstPC ;
if ( ! GetCurves( Id, lstPC)) {
string sInfo = "Warning in SurfFinishing : Skipped entity " + ToString( Id) ;
m_pMchMgr->SetWarning( 3151, sInfo) ;
}
for ( auto pCrv : lstPC) {
vpCrvs.emplace_back( pCrv) ;
vInds.emplace_back( Id) ;
}
}
// appiattisco le curve di contorno
if ( ! FlattenCurves( vpCrvs)) {
m_pMchMgr->SetLastError( 3105, "Error in SurfFinishing : Contour Not Flat") ;
return false ;
}
// se finitura a proiezione di curve
if ( m_Params.m_nSubType == SURFFIN_SUB_PROJECT) {
int nGroupName = -1 ;
for ( int i = 0 ; i < ssize( vpCrvs) ; ++ i) {
// 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)) ;
m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( nGroupName)) ;
// definisco la curva composita associata
PtrOwner<ICurveComposite> pCrvCompo( ConvertCurveToComposite( Release( vpCrvs[i]))) ;
if ( IsNull( pCrvCompo) || ! pCrvCompo->IsValid())
return false ;
int nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::CloneCurveComposite( pCrvCompo)) ;
if ( nNewId == GDB_ID_NULL)
return false ;
// memorizzo la Thickness e l'Estrusione nelle Info del gruppo
double dThick ; pCrvCompo->GetThickness( dThick) ;
Vector3d vtExtr ; pCrvCompo->GetExtrusion( vtExtr) ;
m_pGeomDB->SetInfo( nNewId, KEY_THICK, dThick) ;
m_pGeomDB->SetInfo( nNewId, KEY_EXTR, vtExtr) ;
}
return true ;
}
// preparo i dati per il concatenamento
Vector3d vtExtr = Z_AX ;
bool bFirst = true ;
Point3d ptNear = ORIG ;
double dToler = 10 * EPS_SMALL ;
ChainCurves chainC ;
chainC.Init( true, dToler, int( vpCrvs.size())) ;
for ( size_t i = 0 ; i < vpCrvs.size() ; ++ i) {
// recupero la curva e il suo riferimento
ICurve* pCrv = vpCrvs[i] ;
if ( pCrv == nullptr)
continue ;
// recupero i dati della curva necessari al concatenamento e li assegno
Point3d ptStart, ptEnd ;
Vector3d vtStart, vtEnd ;
if ( ! pCrv->GetStartPoint( ptStart) || ! pCrv->GetStartDir( vtStart) ||
! pCrv->GetEndPoint( ptEnd) || ! pCrv->GetEndDir( vtEnd))
return false ;
if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd))
return false ;
// se prima curva, assegno inizio della ricerca
if ( bFirst) {
pCrv->GetExtrusion( vtExtr) ;
ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
bFirst = false ;
}
// altrimenti
else {
Vector3d vtTmpExtr ; pCrv->GetExtrusion( vtTmpExtr) ;
if ( ! AreSameVectorApprox( vtTmpExtr, vtExtr)) {
m_pMchMgr->SetLastError( 3128, "Error in SurfFinishing : Curves with different extrusion") ;
return false ;
}
}
}
// recupero i percorsi concatenati e definisco la regione piana di svuotatura
SurfFlatRegionByContours SfrByC ;
INTVECTOR vnId2 ;
while ( chainC.GetChainFromNear( ptNear, false, vnId2)) {
// creo una curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// estrusione e spessore
Vector3d vtExtr = Z_AX ;
double dThick = 0 ;
// vettore Id originali
SELVECTOR vId2 ;
vId2.reserve( vnId2.size()) ;
// recupero le curve semplici e le inserisco nella curva composita
for ( size_t i = 0 ; i < vnId2.size() ; ++ i) {
int nId = abs( vnId2[i]) - 1 ;
bool bInvert = ( vnId2[i] < 0) ;
vId2.emplace_back( vInds[nId]) ;
// recupero la curva
ICurve* pCrv = vpCrvs[nId] ;
// se necessario, la inverto
if ( bInvert)
pCrv->Invert() ;
// recupero eventuali estrusione e spessore
Vector3d vtTemp ;
if ( pCrv->GetExtrusion( vtTemp)) {
vtExtr = vtTemp ;
double dTemp ;
if ( pCrv->GetThickness( dTemp) && abs( dTemp) > abs( dThick))
dThick = dTemp ;
}
// la aggiungo alla curva composta
if ( ! pCrvCompo->AddCurve( ::Release( vpCrvs[nId]), true, dToler))
return false ;
}
// se non sono state inserite curve, vado oltre
if ( pCrvCompo->GetCurveCount() == 0)
continue ;
// imposto estrusione e spessore
pCrvCompo->SetExtrusion( vtExtr) ;
pCrvCompo->SetThickness( dThick) ;
// 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 SurfFinishing : Contour Not Flat") ;
else
m_pMchMgr->SetLastError( 2404, "Error in SurfFinishing : 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))
return false ;
// inserisco la curva nella regione piana
SfrByC.AddCurve( Release( pCrvCompo)) ;
}
// scorro le regioni piane ricavate dalle curve
int nGroupName = -1 ;
PtrOwner<ISurfFlatRegion> pSfrCurr( SfrByC.GetSurf()) ;
while ( ! IsNull( pSfrCurr) && pSfrCurr->IsValid()) {
// la normale del Chunk deve essere coerente con l'estrusione ricavata
if ( AreOppositeVectorApprox( pSfrCurr->GetNormVersor(), vtExtr))
pSfrCurr->Invert() ;
// 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)) ;
m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( nGroupName)) ;
// recupero il Chunk corrente
PtrOwner<ISurfFlatRegion> pSfrChunk( pSfrCurr->CloneChunk( nC)) ;
if ( IsNull( pSfrChunk) || ! pSfrChunk->IsValid())
return false ;
int nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::CloneSurfFlatRegion( pSfrChunk)) ;
if ( nNewId == GDB_ID_NULL)
return false ;
// salvo eventuali lati aperti per il Chunk corrente
for ( int nL = 0 ; nL < pSfrChunk->GetLoopCount( 0) ; ++ nL) {
// recupero il Loop
PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfrChunk->GetLoop( 0, nL))) ;
if ( IsNull( pCrvLoop) || ! pCrvLoop->IsValid())
return false ;
// 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) ;
}
// memorizzo la Thickness e l'Estrusione nelle Info del gruppo
if ( nL == 0) {
double dThick = pCrvLoop->GetTempParam( 1) ;
m_pGeomDB->SetInfo( nNewId, KEY_THICK, dThick) ;
m_pGeomDB->SetInfo( nNewId, KEY_EXTR, vtExtr) ;
}
}
}
// aggiorno la regione piana con la successiva calcolata
pSfrCurr.Set( SfrByC.GetSurf()) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::UpdateFrameAndToolDir( int nAuxId, bool& bRecalc)
{
// di base il ricalcolo è attivo
bRecalc = true ;
Frame3d FrOld = m_Frame ;
// se lavorazione con superficie
if ( m_Params.m_nSubType == SURFFIN_SUB_ZIGZAG || m_Params.m_nSubType == SURFFIN_SUB_ONEWAY ||
m_Params.m_nSubType == SURFFIN_SUB_SPIRALIN || m_Params.m_nSubType == SURFFIN_SUB_SPIRALOUT ||
m_Params.m_nSubType == SURFFIN_SUB_Z_CONST || m_Params.m_nSubType == SURFFIN_SUB_OPTIMAL ||
m_Params.m_nSubType == SURFFIN_SUB_PENCIL) {
PtrOwner<ISurfFlatRegion> pSfr( nullptr) ;
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL) {
// recupero la superficie
int nSfrId = m_pGeomDB->GetFirstInGroup( nPathId) ;
if ( m_pGeomDB->GetGeoType( nSfrId) != SRF_FLATRGN)
return false ;
const ISurfFlatRegion* pSfrGeo = GetSurfFlatRegion( m_pGeomDB->GetGeoObj( nSfrId)) ;
if ( pSfrGeo != nullptr && pSfrGeo->IsValid()) {
if ( IsNull( pSfr) || ! pSfr->IsValid()) {
if ( ! pSfr.Set( CloneSurfFlatRegion( pSfrGeo)))
return false ;
else
pSfr->Add( *pSfrGeo) ;
}
}
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
if ( ! IsNull( pSfr) && pSfr->IsValid()) {
// definisco un frame intrinseco dalla superficie
Point3d ptCentroid ; pSfr->GetCentroid( ptCentroid) ;
Frame3d frLoc ;
if ( ! frLoc.Set( ptCentroid, pSfr->GetNormVersor()))
return false ;
// recupero la PolyLine dal loop esterno in locale al frame creato
PolyLine PLLoc ;
PtrOwner<ICurve> pExtLoop( pSfr->GetLoop( 0, 0)) ;
if ( IsNull( pExtLoop) || ! pExtLoop->IsValid() ||
! pExtLoop->ApproxWithLines( EPS_SMALL, EPS_ANG_ZERO, ICurve::APL_SPECIAL, PLLoc) ||
! PLLoc.ToLoc( frLoc))
return false ;
// calcolo il rettangolo ad area minima
Point3d ptFrCenter ; Vector3d vtFrX ;
double dDimX, dDimY ;
if ( ! PLLoc.GetMinAreaRectangleXY( ptFrCenter, vtFrX, dDimX, dDimY))
return false ;
// oriento il frame in modo opportuno rispetto all'asse X
if ( vtFrX.x < - SQRT1_2)
vtFrX.Invert() ;
else if ( abs( vtFrX.x) < SQRT1_2 && vtFrX.y < - SQRT1_2)
vtFrX.Invert() ;
// definisco il frame
ptFrCenter.ToGlob( frLoc) ;
vtFrX.ToGlob( frLoc) ;
if ( ! m_Frame.Set( ptFrCenter, pSfr->GetNormVersor(), vtFrX))
return false ;
}
}
// se lavorazione come curva di proiezione
else if ( m_Params.m_nSubType == SURFFIN_SUB_PROJECT) {
ICURVEPOVECTOR vCrv ;
int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
while ( nPathId != GDB_ID_NULL) {
// recupero la curva (le curve di proiezione)
int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
if ( m_pGeomDB->GetGeoType( nCrvId) != CRV_LINE && m_pGeomDB->GetGeoType( nCrvId) != CRV_ARC &&
m_pGeomDB->GetGeoType( nCrvId) != CRV_COMPO && m_pGeomDB->GetGeoType( nCrvId) != CRV_BEZIER)
return false ;
// recupero la curva
const ICurve* pCrv = GetCurve( m_pGeomDB->GetGeoObj( nCrvId)) ;
if ( pCrv == nullptr || ! pCrv->IsValid())
return false ;
// la memorizzo
if ( ! vCrv.emplace_back( pCrv->Clone()))
return false ;
nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
}
if ( ! vCrv.empty()) {
Point3d ptCentroid ; vCrv[0]->GetCentroid( ptCentroid) ;
Vector3d vtExtrusion ; vCrv[0]->GetExtrusion( vtExtrusion) ;
Frame3d frLoc ;
if ( ! frLoc.Set( ptCentroid, vtExtrusion))
return false ;
// recupero la PolyLine assocuata alla prima curva in locale al frame creato
PolyLine PLLoc ;
if ( IsNull( vCrv[0]) || ! vCrv[0]->IsValid() ||
! vCrv[0]->ApproxWithLines( EPS_SMALL, EPS_ANG_ZERO, ICurve::APL_SPECIAL, PLLoc) ||
! PLLoc.ToLoc( frLoc))
return false ;
// calcolo il rettangolo ad area minima
Point3d ptFrCenter ; Vector3d vtFrX ;
double dDimX, dDimY ;
if ( ! PLLoc.GetMinAreaRectangleXY( ptFrCenter, vtFrX, dDimX, dDimY))
return false ;
ptFrCenter.ToGlob( frLoc) ;
vtFrX.ToGlob( frLoc) ;
if ( ! m_Frame.Set( ptFrCenter, vtExtrusion, vtFrX))
return false ;
}
}
// recupero Theta e Phi correnti
double dOldTheta = m_dTheta ;
double dOldPhi = m_dPhi ;
const double ANG_TOL = 10. * EPS_ANG_SMALL ;
// verifico se presenti parametri Theta e Phi per possibile orientamento utensile in locale al frame corrente
m_dTheta = 0. ; m_dPhi = 0. ;
string sTiltAngs{} ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_TILT_ANGS, sTiltAngs)) {
STRVECTOR vsAngs ;
if ( Tokenize( sTiltAngs, ",", vsAngs) && ssize( vsAngs) == 2) {
double dTheta = 0., dPhi = 0. ;
if ( FromString( vsAngs[0], dTheta) && FromString( vsAngs[1], dPhi)) {
m_dTheta = dTheta ;
m_dPhi = dPhi ;
}
}
}
// verifico se aggiornare gli angoli
if ( ! bRecalc &&
( ! AreSameFrame( FrOld, m_Frame) || abs( m_dTheta - dOldTheta) > ANG_TOL || abs( m_dPhi - dOldPhi) > ANG_TOL))
bRecalc = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetSurfacesByIds( SURFLOCALVECTOR& vSrfLoc, SURFLOCALVECTOR& vSrfSuppLoc, Frame3d& frSurf)
{
// funzione che restituisce le superfici attive, le superfici di supporto e il frame di riferimento
vSrfLoc.clear() ;
vSrfSuppLoc.clear() ;
// recupero le superfici attive e le superfici nel Layer di supporto
INTVECTOR vSurfId, vSurfSuppId ;
GetActiveSurfaces( vSurfId, vSurfSuppId) ;
// porto tutte le superfici nel riferimento della prima
for ( const int& nSurfId : vSurfId) {
if ( vSrfLoc.empty()) {
if ( ! m_pGeomDB->GetGlobFrame( nSurfId, frSurf))
return false ;
}
vSrfLoc.emplace_back( m_pGeomDB, nSurfId, frSurf) ;
}
if ( ! frSurf.IsValid())
return false ;
for ( const int& nSrfSuppId : vSurfSuppId)
vSrfSuppLoc.emplace_back( m_pGeomDB, nSrfSuppId, frSurf) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dRad, double dLen, double& dElev) const
{
// 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 ;
// 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'inizio
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
SurfFinishing::SetCAvTlStmForSurfaces( ICAvToolSurfTm* pCAvTlStm, const ISurfFlatRegion* pSfrCnt, double dDepth,
double dToolLen, double dToolDiam, double dToolCornRad,
double dToolSideAng, double dToolMaxMat, double dMachOffsR,
const SURFLOCALVECTOR& vSurfLoc, const SURFLOCALVECTOR& vSurfSuppLoc)
{
// controllo dei parametri
if ( pCAvTlStm == nullptr || vSurfLoc.empty())
return false ;
// definisco l'ambiente di correzione dei percorsi utensili
if ( abs( dToolSideAng) < EPS_ANG_SMALL)
pCAvTlStm->SetStdTool( dToolLen + dMachOffsR, dToolDiam / 2. + dMachOffsR, dToolCornRad + dMachOffsR) ;
else {
double dDeltaRad ;
double dSideAngRad = dToolSideAng * DEGTORAD ;
if ( dToolSideAng > 0.) {
if ( dToolCornRad < EPS_SMALL)
dDeltaRad = dToolMaxMat * tan( dSideAngRad) ;
else
dDeltaRad = dToolCornRad * cos( dSideAngRad) +
( dToolMaxMat + dToolCornRad * ( sin( dSideAngRad) - 1)) * tan( dSideAngRad) ;
}
else
dDeltaRad = tan( dSideAngRad) * dToolMaxMat ;
double dStemRad = dToolDiam / 2. + dDeltaRad ;
double dTipRad = dToolDiam / 2. ;
pCAvTlStm->SetAdvTool( dToolLen + dMachOffsR, dStemRad + dMachOffsR,
dToolMaxMat, dTipRad + dMachOffsR, dToolCornRad + dMachOffsR) ;
}
// aggiungo tutte le superfici di lavoro
for ( int i = 0 ; i < ssize( vSurfLoc) ; ++ i) {
// superfici ammesse : TriMesh, Bezier
const ISurf* pSurf = GetSurf( vSurfLoc[i].Get()) ;
if ( pSurf != nullptr && pSurf->IsValid()) {
int nType = pSurf->GetType() ;
// se TriMesh
if ( nType == SRF_TRIMESH) {
const ISurfTriMesh* pStm = GetSurfTriMesh( pSurf) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0) {
if ( i == 0)
pCAvTlStm->SetSurfTm( *pStm) ;
else
pCAvTlStm->AddSurfTm( *pStm) ;
}
}
// se Bezier
else if ( nType == SRF_BEZIER) {
const ISurfBezier* pSBz = GetSurfBezier( pSurf) ;
if ( pSBz != nullptr && pSBz->IsValid()) {
double dOldTol = GetSurfBezierAuxSurfRefinedTol() ;
SetSurfBezierAuxSurfRefinedTol( 5. * EPS_SMALL) ;
const ISurfTriMesh* pStm = pSBz->GetAuxSurfRefined() ;
SetSurfBezierAuxSurfRefinedTol( dOldTol) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0) {
if ( i == 0)
pCAvTlStm->SetSurfTm( *pStm) ;
else
pCAvTlStm->AddSurfTm( *pStm) ;
}
}
}
}
}
// aggiungo le superfici di supporto
if ( ! vSurfSuppLoc.empty()) {
/* Se considero interamente la superficie di supporto ho diversi svantaggi :
1) Incrementa notevolmente il Box complessivo delle superfici di lavoro
=> Ho molti più punti nelle griglie di campionamento per Silhouette o percorsi di collisione
2) Calcolo l'Offset di TriMesh di parti "lontane" dalla regione corrente di lavoro
=> Più tempo computazionale per Offset
=> Superfici con più triangoli
*/
// definisco una superficie di contenimento ; L'Offset verrà fatto solo sulle parti di Stm interne ad essa
PtrOwner<ISurfTriMesh> pStmContainment( CreateSurfTriMesh()) ;
if ( IsNull( pStmContainment))
return false ;
if ( pSfrCnt != nullptr && pSfrCnt->IsValid() && abs( dDepth) > 10. * EPS_SMALL) {
// considero la regione complessiva di lavoro dell'utensile all'interno della quale non può uscire
double dOffs = dToolDiam / 2. + m_Params.m_dOverlap + SUPP_SURF_RADIAL_OFFS + 50. * EPS_SMALL ;
PtrOwner<ISurfFlatRegion> pSfrFreeMove( pSfrCnt->CreateOffsetSurf( dOffs, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrFreeMove) || ! pSfrFreeMove->IsValid())
return false ;
// definisco una TriMesh di estrusione da questa regione
pSfrFreeMove->Translate( - dDepth * pSfrCnt->GetNormVersor()) ;
CICURVEPVECTOR vpCrv ;
for ( int nC = 0 ; nC < pSfrFreeMove->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfrFreeMove->GetLoopCount( nC) ; ++ nL)
vpCrv.emplace_back( pSfrFreeMove->GetLoop( nC, nL)) ;
}
pStmContainment.Set( GetSurfTriMeshByRegionExtrusion( vpCrv, ( dDepth + dToolLen) * pSfrCnt->GetNormVersor())) ;
}
// definisco la tolleranza lineare per Offset
double dLinTol = 2. ;
// recupero le superfici singole ( più veloce che calcolare Offset complessivo)
for ( const SurfLocal& SurfSupp : vSurfSuppLoc) {
// le superfici di supporto devono essere ben definite ed avere un volume chiuso
const ISurf* pSurfSupp = GetSurf( SurfSupp.Get()) ;
if ( pSurfSupp == nullptr || ! pSurfSupp->IsValid())
continue ;
int nType = pSurfSupp->GetType() ;
PtrOwner<ISurfTriMesh> pTruncStm ;
// se TriMesh
if ( nType == SRF_TRIMESH) {
const ISurfTriMesh* pStm = GetSurfTriMesh( pSurfSupp) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0) {
if ( ! pTruncStm.Set( CloneSurfTriMesh( pStm)))
continue ;
}
}
// se Bezier
else if ( nType == SRF_BEZIER) {
const ISurfBezier* pSBz = GetSurfBezier( pSurfSupp) ;
if ( pSBz != nullptr && pSBz->IsValid()) {
double dOldTol = GetSurfBezierAuxSurfRefinedTol() ;
SetSurfBezierAuxSurfRefinedTol( 5. * EPS_SMALL) ;
const ISurfTriMesh* pStm = pSBz->GetAuxSurfRefined() ;
SetSurfBezierAuxSurfRefinedTol( dOldTol) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0) {
if ( ! pTruncStm.Set( CloneSurfTriMesh( pStm)))
continue ;
}
}
}
// tengo la la tengo la parte di superficie
if ( IsNull( pTruncStm) || ! pTruncStm->IsValid())
return false ;
if ( ! IsNull( pStmContainment) && pStmContainment->IsValid() &&
pStmContainment->GetTriangleCount() > 0 && pStmContainment->IsClosed()) {
PtrOwner<ISurfTriMesh> pStmTemp( CloneSurfTriMesh( pTruncStm)) ;
if ( IsNull( pStmTemp) || ! pStmTemp->IsValid())
return false ;
if ( pStmTemp->Intersect( *pStmContainment) && pStmTemp->IsClosed())
pTruncStm.Set( Release( pStmTemp)) ;
}
// calcolo l'Offset
if ( ! IsNull( pTruncStm) && pTruncStm->IsValid()) {
PtrOwner<ISurfTriMesh> pStmSuppOffs( CreateSurfTriMeshOffset( pTruncStm, SUPP_SURF_RADIAL_OFFS, dLinTol)) ;
if ( ! IsNull( pStmSuppOffs) && pStmSuppOffs->IsValid() && pStmSuppOffs->GetTriangleCount() > 0)
pCAvTlStm->AddSurfTm( *Release( pStmSuppOffs)) ;
}
}
}
return true ;
}
//---------------------------------------------------------------------------
bool
SurfFinishing::EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d& frSurf, const Vector3d& vtMove,
double dDepth, ISurfFlatRegion* pSfrCnt) const
{
// controllo dei parametri
if ( vSurfLoc.empty() || pSfrCnt == nullptr || ! pSfrCnt->IsValid())
return true ;
// calcolo silhouette dell'insieme di superfici
CISURFTMPVECTOR vpStm ; vpStm.reserve( vSurfLoc.size()) ;
for ( int i = 0 ; i < ssize( vSurfLoc) ; ++ i) {
// recupero la superficie
const ISurf* pSurf = GetSurf( vSurfLoc[i].Get()) ;
if ( pSurf == nullptr || ! pSurf->IsValid())
continue ;
int nType = pSurf->GetType() ;
// se TriMesh
if ( nType == SRF_TRIMESH) {
const ISurfTriMesh* pStm = GetSurfTriMesh( pSurf) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0)
vpStm.emplace_back( pStm) ;
}
// se Bezier
else if ( nType == SRF_BEZIER) {
const ISurfBezier* pSBz = GetSurfBezier( pSurf) ;
if ( pSBz != nullptr && pSBz->IsValid()) {
double dOldTol = GetSurfBezierAuxSurfRefinedTol() ;
SetSurfBezierAuxSurfRefinedTol( 5. * EPS_SMALL) ;
const ISurfTriMesh* pStm = pSBz->GetAuxSurfRefined() ;
SetSurfBezierAuxSurfRefinedTol( dOldTol) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0)
vpStm.emplace_back( pStm) ;
}
}
}
// determino il frame locale delle superfici analizzando la prima
Frame3d frPocket ;
Point3d ptCen ; pSfrCnt->GetCentroid( ptCen) ;
frPocket.Set( ptCen, vtMove) ;
frPocket.ToLoc( frSurf) ;
const double SILH_TOL = 1. ;
PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
if ( IsNull( pCavParSilh) || ! pCavParSilh->SetData( vpStm, frPocket, SILH_TOL))
return false ;
POLYLINEVECTOR vPL ;
if ( ! pCavParSilh->GetSilhouette( - dDepth, vPL))
return false ;
// creazione della regione piana dalle PolyLine ricavate dalla Silhouette
const double SILH_ARC_TOL = SILH_TOL / 10. ;
const double SILH_ARC_FEA_MAX = 100. ;
SurfFlatRegionByContours SfrMaker ;
for ( const PolyLine& PL : vPL) {
// recupero la curva dalla silhouette
PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
if ( IsNull( pSilCrv))
return false ;
pSilCrv->FromPolyLine( PL) ;
// approssimo con archi
PolyArc PA ;
if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
if ( ! IsNull( pTempCrv) && pTempCrv->FromPolyArc( PA) && pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG) &&
pTempCrv->MergeCurves( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG))
pSilCrv.Set( pTempCrv) ;
}
// aggiungo per regione
if ( ! SfrMaker.AddCurve( Release( pSilCrv)))
return false ;
}
PtrOwner<ISurfFlatRegion> pSfrSil( SfrMaker.GetSurf()) ;
if ( ! IsNull( pSfrSil)) {
pSfrSil->ToGlob( frSurf) ;
double dPockRadOffs = SILH_ARC_TOL ;
pSfrSil->Offset( dPockRadOffs, ICurve::OFF_CHAMFER) ;
pSfrSil->Offset( m_TParams.m_dDiam, ICurve::OFF_FILLET) ;
#if DEBUG_SFR
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "FlatRegions MaxDown") ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay, "SfrMaxDow") ;
int nSfr = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pSfrSil->Clone()) ;
m_pGeomDB->SetMaterial( nSfr, Color( 1., 0., 0., .5)) ;
#endif
// intersezione tra contorno e regione
if ( ! pSfrCnt->Intersect( *pSfrSil)) {
// ricreo la regione originale
PtrOwner<ISurfFlatRegion> pSfrCntCopy( CloneSurfFlatRegion( pSfrCnt)) ;
if ( IsNull( pSfrCntCopy) || ! pSfrCntCopy->IsValid())
return false ;
pSfrCnt->Clear() ;
pSfrCnt->CopyFrom( pSfrCntCopy) ;
}
// azzero le proprietà delle curve semplici dei contorni delle regioni
for ( int nC = 0 ; nC < pSfrCnt->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfrCnt->GetLoopCount( nC) ; ++ nL) {
for ( int nCrv = 0 ; ; ++ nCrv) {
if ( ! pSfrCnt->SetCurveTempProp( nC, nL, nCrv, TEMP_PROP_CLOSE_EDGE, 0) ||
! pSfrCnt->SetCurveTempProp( nC, nL, nCrv, TEMP_PROP_CLOSE_EDGE, 1))
break ;
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::EraseMaxDownStartEndPolyLine( PolyLine& PL) const
{
// verifico che la PolyLine sia valida
if ( PL.GetPointNbr() <= 2)
return true ;
const double START_END_LEN = 2. ;
// Definisco la curva composita di non collisione iniziale
PtrOwner<ICurveComposite> pCompoStartNoColl( CreateCurveComposite()) ;
if ( IsNull( pCompoStartNoColl))
return false ;
#if ENABLE_MAXDOWN_STARTEND_DEBUG
PNTULIST& _ptUList = PL.GetUPointList() ;
for ( const POINTU& _ptU : _ptUList) {
PtrOwner<IGeoPoint3d> _pt( CreateGeoPoint3d()) ; _pt->Set( _ptU.first) ;
int _nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, ::Release( _pt)) ;
m_pGeomDB->SetMaterial( _nPtId, RED) ;
}
#endif
// scorro i punti della PolyLine
PNTULIST& ptUList = PL.GetUPointList() ;
bool bFirst = true ;
for ( PNTULIST::iterator Iter = ptUList.begin() ; Iter != ptUList.end() ; ++ Iter) {
if ( bFirst) {
pCompoStartNoColl->AddPoint( ( *Iter).first) ;
bFirst = false ;
}
else
pCompoStartNoColl->AddLine( ( *Iter).first) ;
// al primo punto di collisione trovato
if ( ( *Iter).second > EPS_SMALL) {
// verifico se curva sufficientemente lunga
double dLen = 0. ; pCompoStartNoColl->GetLength( dLen) ;
if ( dLen > START_END_LEN) {
pCompoStartNoColl->TrimStartAtLen( dLen - START_END_LEN) ;
ptUList.erase( ptUList.begin(), Iter) ;
pCompoStartNoColl->Invert() ;
for ( int nU = 0 ; nU < pCompoStartNoColl->GetCurveCount() ; ++ nU) {
const ICurve* pCrv = pCompoStartNoColl->GetCurve( nU) ;
if ( pCrv != nullptr && pCrv->IsValid()) {
Point3d ptS ; pCrv->GetStartPoint( ptS) ;
ptUList.emplace_front( make_pair( ptS, 0.)) ;
}
}
Point3d ptListStart ; pCompoStartNoColl->GetEndPoint( ptListStart) ;
if ( ! AreSamePointApprox( ptUList.front().first, ptListStart))
ptUList.emplace_front( make_pair( ptListStart, 0.)) ;
}
#if ENABLE_MAXDOWN_STARTEND_DEBUG
PtrOwner<IGeoPoint3d> _pt( CreateGeoPoint3d()) ; _pt->Set( ( *Iter).first) ;
int _nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, ::Release( _pt)) ;
m_pGeomDB->SetMaterial( _nPtId, LIME) ;
int _nCrvId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, ::CloneCurveComposite( pCompoStartNoColl)) ;
m_pGeomDB->SetMaterial( _nCrvId, AQUA) ;
#endif
break ;
}
}
// dalla fine della PolyLine, ripeto le considerazioni fatte
// scorro i punti della PolyLine
bFirst = true ;
pCompoStartNoColl->Clear() ;
for ( PNTULIST::reverse_iterator Iter = ptUList.rbegin() ; Iter != ptUList.rend() ; ++ Iter) {
if ( bFirst) {
pCompoStartNoColl->AddPoint( ( *Iter).first) ;
bFirst = false ;
}
else
pCompoStartNoColl->AddLine( ( *Iter).first) ;
// al primo punto di collisione trovato
if ( ( *Iter).second > EPS_SMALL) {
#if ENABLE_MAXDOWN_STARTEND_DEBUG
PtrOwner<IGeoPoint3d> _pt( CreateGeoPoint3d()) ; _pt->Set( ( *Iter).first) ;
int _nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, ::Release( _pt)) ;
m_pGeomDB->SetMaterial( _nPtId, LIME) ;
#endif
// verifico se curva sufficientemente lunga
double dLen = 0. ; pCompoStartNoColl->GetLength( dLen) ;
if ( dLen > START_END_LEN) {
pCompoStartNoColl->TrimStartAtLen( dLen - START_END_LEN) ;
// recupero l'iteratore corretto
PNTULIST::iterator myIter = Iter.base() ; -- Iter ;
ptUList.erase( myIter, ptUList.end()) ;
pCompoStartNoColl->Invert() ;
for ( int nU = 0 ; nU < pCompoStartNoColl->GetCurveCount() ; ++ nU) {
const ICurve* pCrv = pCompoStartNoColl->GetCurve( nU) ;
if ( pCrv != nullptr && pCrv->IsValid()) {
Point3d ptS ; pCrv->GetStartPoint( ptS) ;
ptUList.emplace_back( make_pair( ptS, 0.)) ;
}
}
Point3d ptListStart ; pCompoStartNoColl->GetEndPoint( ptListStart) ;
if ( ! AreSamePointApprox( ptUList.front().first, ptListStart))
ptUList.emplace_back( make_pair( ptListStart, 0.)) ;
}
#if ENABLE_MAXDOWN_STARTEND_DEBUG
int _nCrvId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, ::CloneCurveComposite( pCompoStartNoColl)) ;
m_pGeomDB->SetMaterial( _nCrvId, AQUA) ;
#endif
break ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::ProcessCrv( int nPathId, int nPvId, int nClId)
{
// recupero gruppo per geometria temporanea
const string GRP_TEMP = "Temp" ;
int nTempId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, GRP_TEMP) ;
// se non c'è, lo aggiungo
if ( nTempId == GDB_ID_NULL) {
nTempId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nTempId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nTempId, GRP_TEMP) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nTempId) ;
// in ogni caso lo dichiaro temporaneo e non visibile
m_pGeomDB->SetLevel( nTempId, GDB_LV_TEMP) ;
m_pGeomDB->SetStatus( nTempId, GDB_ST_OFF) ;
// recupero la curva composita dal database geometrico
int nCrvCompoId = m_pGeomDB->GetFirstInGroup( nPathId) ;
if ( m_pGeomDB->GetGeoType( nCrvCompoId) != CRV_COMPO)
return false ;
// copio la curva composits da elaborare
int nCopyId = m_pGeomDB->CopyGlob( nCrvCompoId, GDB_ID_NULL, nTempId) ;
if ( nCopyId == GDB_ID_NULL)
return false ;
const ICurveComposite* pCrvCompoGDB( GetCurveComposite( m_pGeomDB->GetGeoObj( nCopyId))) ;
if ( ! pCrvCompoGDB->IsValid())
return false ;
// recupero estrusione e spessore
Vector3d vtExtr = Z_AX ;
if ( m_pGeomDB->ExistsInfo( nCrvCompoId, KEY_EXTR))
m_pGeomDB->GetInfo( nCrvCompoId, KEY_EXTR, vtExtr) ;
double dThick = 0. ;
if ( m_pGeomDB->ExistsInfo( nCrvCompoId, KEY_THICK))
m_pGeomDB->GetInfo( nCrvCompoId, KEY_THICK, dThick) ;
// valuto l'espressione dell'affondamento
ExeLuaSetGlobNumVar( "TH", abs( dThick)) ;
double dDepth ;
string sMyDepth = m_Params.m_sDepth ;
if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) {
m_pMchMgr->SetLastError( 3108, "Error in SurfFinishing : Depth not computable") ;
return false ;
}
// se spessore positivo, lo sottraggo al risultato
if ( dThick > 0)
dDepth -= dThick ;
// verifico che la curva sia piana
Plane3d plPlane ;
if ( ! pCrvCompoGDB->IsFlat( plPlane)) {
m_pMchMgr->SetLastError( 3005, "Error in SurfFinishing : Contour Not Flat") ;
return false ;
}
// recupero nome del path
string sPathName ;
m_pGeomDB->GetName( nPathId, sPathName) ;
// assegno il versore fresa e il versore movimento
Vector3d vtTool = vtExtr ;
Vector3d vtToolFrame ;
if ( GetLocalToolDir( vtToolFrame))
vtTool = vtToolFrame ;
Vector3d vtMove = vtExtr ;
// 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( vtTool) ;
// recupero le superfici di lavoro e di supporto
SURFLOCALVECTOR vSrfLoc, vSrfLocSupp ;
Frame3d frSurf ;
if ( ! GetSurfacesByIds( vSrfLoc, vSrfLocSupp, frSurf)) {
m_pMchMgr->SetLastError( 3123, "Error in SurfFinishing : missing surfaces") ;
return false ;
}
// l'angolo solido tra la direzione di movimento e la direzione utensile deve essere compreso in 45deg
if ( m_dTheta > TILT_ANG_DEG) {
m_pMchMgr->SetLastError( 3137, "Error in SurfFinishing : Tool direction too steepy") ;
return false ;
}
// predispongo l'ambiente di correzione dei percorsi utensili
PtrOwner<ICAvToolSurfTm> pCAvTlStm( CreateCAvToolSurfTm()) ;
if ( IsNull( pCAvTlStm) ||
! SetCAvTlStmForSurfaces( pCAvTlStm, nullptr, dDepth, m_TParams.m_dLen, m_TParams.m_dDiam,
m_TParams.m_dCornRad, m_TParams.m_dSideAng, m_TParams.m_dMaxMat,
GetOffsR(), vSrfLoc, vSrfLocSupp)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
// Imposto dati comuni
SetPathId( nPxId) ;
SetToolDir( vtTool) ;
Vector3d vtAux ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTAUXDIR, vtAux))
vtAux.Normalize() ;
SetAuxDir( vtAux) ;
// assegno il vettore estrusione al gruppo del percorso
m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ;
// Eseguo la lavorazione a seconda del tipo
double dElev = dDepth ;
switch ( m_Params.m_nSubType) {
case SURFFIN_SUB_PROJECT :
if ( ! AddProjection( pCAvTlStm, vSrfLoc, frSurf, pCrvCompoGDB, vtTool, vtMove, dDepth, dElev, bSplitArcs))
return false ;
break ;
}
}
// incremento numero di percorsi
++ m_nPaths ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
{
// recupero gruppo per geometria temporanea
const string GRP_TEMP = "Temp" ;
int nTempId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, GRP_TEMP) ;
// se non c'è, lo aggiungo
if ( nTempId == GDB_ID_NULL) {
nTempId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
if ( nTempId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nTempId, GRP_TEMP) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nTempId) ;
// in ogni caso lo dichiaro temporaneo e non visibile
m_pGeomDB->SetLevel( nTempId, GDB_LV_TEMP) ;
m_pGeomDB->SetStatus( nTempId, GDB_ST_OFF) ;
// 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 ;
const ISurfFlatRegion* pSfrGDB( GetSurfFlatRegion( m_pGeomDB->GetGeoObj( nCopyId))) ;
if ( ! pSfrGDB->IsValid())
return false ;
// 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) ;
// valuto l'espressione dell'affondamento
ExeLuaSetGlobNumVar( "TH", abs( dThick)) ;
double dDepth ;
string sMyDepth = m_Params.m_sDepth ;
if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) {
m_pMchMgr->SetLastError( 3108, "Error in SurfFinishing : Depth not computable") ;
return false ;
}
// se spessore positivo, lo sottraggo al risultato
if ( dThick > 0)
dDepth -= dThick ;
// recupero il Loop esterno della regione da svuotatare
PtrOwner<ICurve> pCrvExt( pSfrGDB->GetLoop( 0, 0)) ;
if ( IsNull( pCrvExt) || ! pCrvExt->IsValid())
return false ;
// verifico sia piana e sistemo senso antiorario visto dalla direzione di estrusione
Plane3d plPlane ; double dArea ;
if ( ! pCrvExt->GetArea( plPlane, dArea)) {
m_pMchMgr->SetLastError( 3005, "Error in SurfFinishing : Contour Not Flat") ;
return false ;
}
if ( abs( plPlane.GetVersN() * vtExtr) < cos( 10. * EPS_ANG_SMALL)) {
m_pMchMgr->SetLastError( 3006, "Error in SurfFinishing : Tool Dir not perpendicular to Flat Area") ;
return false ;
}
if ( plPlane.GetVersN() * vtExtr * dArea < 0)
pCrvExt->Invert() ;
// recupero nome del path
string sPathName ;
m_pGeomDB->GetName( nPathId, sPathName) ;
// assegno il versore fresa e il versore movimento
Vector3d vtTool = vtExtr ;
Vector3d vtToolFrame ;
if ( GetLocalToolDir( vtToolFrame))
vtTool = vtToolFrame ;
Vector3d vtMove = vtExtr ;
// 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( vtTool) ;
// recupero le superfici di lavoro e di supporto
SURFLOCALVECTOR vSrfLoc, vSrfLocSupp ;
Frame3d frSurf ;
if ( ! GetSurfacesByIds( vSrfLoc, vSrfLocSupp, frSurf)) {
m_pMchMgr->SetLastError( 3123, "Error in SurfFinishing : missing surfaces") ;
return false ;
}
// determino la regione da lavorare
PtrOwner<ISurfFlatRegion> pSfrCnt( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrCnt) || ! pSfrCnt->AddExtLoop( *pCrvExt)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
for ( int nL = 1 ; nL < pSfrGDB->GetLoopCount( 0) ; ++ nL) {
// recupero l'isola
PtrOwner<ICurve> pCrvIsl( pSfrGDB->GetLoop( 0, nL)) ;
if ( IsNull( pCrvIsl) || ! pCrvIsl->IsValid() ||
! pSfrCnt->AddIntLoop( Release( pCrvIsl))) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
}
// se regione non valida, non faccio nulla
if ( ! pSfrCnt->IsValid())
return true ;
// calcolo l'elevazione al di sopra della curva
double dElev = 0. ;
if ( ! CalcRegionElevation( pSfrCnt, vtExtr, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev)) {
m_pMchMgr->SetLastError( 3135, "Error in SurfFinishing : Calc Region Elvation failed") ;
return false ;
}
// posiziono la superficie a quella quota (top del grezzo)
if ( dElev > EPS_SMALL) {
pSfrCnt->Translate( vtExtr * dElev) ;
dDepth += dElev ;
}
// controllo di non scendere al di sotto del grezzo con la depth
double dInvElev = 0. ;
pSfrCnt->Invert() ;
if ( ! CalcRegionElevation( pSfrCnt, vtExtr, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dInvElev)) {
m_pMchMgr->SetLastError( 3135, "Error in SurfFinishing : Calc Region Elvation failed") ;
return false ;
}
pSfrCnt->Invert() ;
if ( dDepth > dInvElev - EPS_SMALL) {
double dToolDepth = m_TParams.m_dMaxMat ;
if ( m_TParams.m_nType != TT_COMPO && abs( m_TParams.m_dSideAng) < EPS_SMALL)
dToolDepth = m_TParams.m_dCornRad ;
dDepth = dInvElev + dToolDepth ;
}
// l'angolo solido tra la direzione di movimento e la direzione utensile deve essere compreso in 45deg
if ( m_dTheta > TILT_ANG_DEG) {
m_pMchMgr->SetLastError( 3137, "Error in SurfFinishing : Tool direction too steepy") ;
return false ;
}
// alla regione di contorno applico un Offset stabilito dal parametro di Overlap.
// NB. Questo bordo tiene conto della direzione utensile
if ( ! pSfrCnt->Offset( m_Params.m_dOverlap, ICurve::OFF_FILLET)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
// se non valida, non faccio nulla
if ( ! pSfrCnt->IsValid())
return true ;
#if DEBUG_SFR
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "FlatRegions") ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay, "Sfr_by_curves") ;
int nSfr = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pSfrCnt->Clone()) ;
m_pGeomDB->SetMaterial( nSfr, Color( 0., 1., 0., .5)) ;
#endif
// predispongo l'ambiente di correzione dei percorsi utensili
PtrOwner<ICAvToolSurfTm> pCAvTlStm( CreateCAvToolSurfTm()) ;
PtrOwner<ISurfFlatRegion> pSfrCntLoc( CloneSurfFlatRegion( pSfrCnt)) ;
if ( IsNull( pCAvTlStm) ||
IsNull( pSfrCntLoc) || ! pSfrCntLoc->IsValid() ||
! pSfrCntLoc->ToLoc( frSurf) ||
! SetCAvTlStmForSurfaces( pCAvTlStm, pSfrCntLoc, dDepth, m_TParams.m_dLen, m_TParams.m_dDiam,
m_TParams.m_dCornRad, m_TParams.m_dSideAng, m_TParams.m_dMaxMat,
GetOffsR(), vSrfLoc, vSrfLocSupp)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
// tengo una copia della regione attuale, nel caso di finitura Optimal
PtrOwner<ISurfFlatRegion> pSfrCntOrig( nullptr) ;
if ( m_Params.m_nSubType == SURFFIN_SUB_OPTIMAL) {
if ( ! pSfrCntOrig.Set( CloneSurfFlatRegion( pSfrCnt)) || ! pSfrCntOrig->IsValid())
return false ;
}
// se richiesto, elimino le parti al massimo affondamento
bool bSkipMaxDown = true ;
GetValInNotes( m_Params.m_sUserNotes, UN_SKIPMAXDOWN, bSkipMaxDown) ;
if ( bSkipMaxDown && m_Params.m_nSubType != SURFFIN_SUB_Z_CONST && m_Params.m_nSubType != SURFFIN_SUB_PENCIL) {
PtrOwner<ISurfFlatRegion> pSfrMaxDown( CloneSurfFlatRegion( pSfrCnt)) ;
if ( IsNull( pSfrMaxDown) || ! pSfrMaxDown->IsValid() ||
! EraseMaxDownSurf( vSrfLoc, frSurf, vtMove, dDepth, pSfrMaxDown)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
// se non valida, non faccio nulla
if ( ! pSfrMaxDown->IsValid())
return true ;
// la regione la lavorare è l'intersezione tra quest'ultima e il contorno
pSfrCnt->Intersect( *pSfrMaxDown) ;
}
// se regione risultante vuota, non devo fare altro
if ( ! pSfrCnt->IsValid())
return true ;
// la regione viene considerata con lati tutti chiusi
for ( int nC = 0 ; nC < pSfrCnt->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfrCnt->GetLoopCount( nC) ; ++ nL) {
for ( int nU = 0 ; nU < pSfrCnt->GetLoopCurveCount( nC, nL) ; ++ nU) {
pSfrCnt->SetCurveTempProp( nC, nL, nU, TEMP_PROP_CLOSE_EDGE, 0) ;
pSfrCnt->SetCurveTempProp( nC, nL, nU, TEMP_PROP_CLOSE_EDGE, 1) ;
}
}
}
#if DEBUG_SFR
int nLay3 = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay3, "Sfr_Final") ;
int nSfrF = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay3, pSfrCnt->Clone()) ;
m_pGeomDB->SetMaterial( nSfrF, LIME) ;
#endif
// Imposto dati comuni
SetPathId( nPxId) ;
SetToolDir( vtTool) ;
Vector3d vtAux ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTAUXDIR, vtAux))
vtAux.Normalize() ;
SetAuxDir( vtAux) ;
// assegno il vettore estrusione al gruppo del percorso
m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ;
// inserisco le superfici di supporto tra le superfici locali
for ( SurfLocal& SurfLocSupp : vSrfLocSupp)
vSrfLoc.emplace_back( SurfLocSupp) ;
// Eseguo la lavorazione a seconda del tipo
dElev = dDepth ;
switch ( m_Params.m_nSubType) {
case SURFFIN_SUB_ZIGZAG :
if ( ! AddZigZag( pCAvTlStm, frSurf, pSfrCnt, vtTool, vtMove, dDepth, dElev, bSplitArcs))
return false ;
break ;
case SURFFIN_SUB_ONEWAY :
if ( ! AddOneWay( pCAvTlStm, frSurf, pSfrCnt, vtTool, vtMove, dDepth, dElev, bSplitArcs))
return false ;
break ;
case SURFFIN_SUB_SPIRALIN :
if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, vtMove, dDepth, dElev, bSplitArcs, true))
return false ;
break ;
case SURFFIN_SUB_SPIRALOUT :
if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, vtMove, dDepth, dElev, bSplitArcs, false))
return false ;
break ;
case SURFFIN_SUB_Z_CONST :
if ( ! AddZConst( pCAvTlStm, vSrfLoc, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs))
return false ;
break ;
case SURFFIN_SUB_OPTIMAL :
if ( ! AddOptimal( pCAvTlStm, vSrfLoc, frSurf, pSfrCnt, pSfrCntOrig, vtTool, vtMove, dDepth, dElev, bSplitArcs))
return false ;
break ;
case SURFFIN_SUB_PENCIL :
if ( ! AddPencil( pCAvTlStm, vSrfLoc, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs))
return false ;
break ;
}
}
// incremento numero di percorsi
++ m_nPaths ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::SimplifyCurve( ICurveComposite* pCompo, const Frame3d& frLocXY, double dMergeLinTol, double dMergeAndTolDeg,
double dSmallDefLinTol, double dSmallDefAngTolDeg,
double dArcApproxLinTol, double dArcApproxAngTolDeg) const
{
// controllo dei parametri
if ( pCompo == nullptr || ! pCompo->IsValid())
return false ;
// eseguo le modifiche su una copia della curva originale in locale al frame XY
PtrOwner<ICurveComposite> pCompoLoc( CloneCurveComposite( pCompo)) ;
if ( IsNull( pCompoLoc))
return false ;
pCompoLoc->ToLoc( frLocXY) ;
// ricavo il punto iniziale e finale
Point3d ptStart ; pCompoLoc->GetStartPoint( ptStart) ;
Point3d ptEnd ; pCompoLoc->GetEndPoint( ptEnd) ;
// merge per uniformità
bool bOk = pCompoLoc->MergeCurves( dMergeLinTol, dMergeAndTolDeg, false) ;
// rimozione Spikes o Curve Z
bOk = bOk && pCompoLoc->RemoveSmallDefects( dSmallDefLinTol, dSmallDefAngTolDeg, true) ;
// interpolazione mediante linee ed archi
PolyArc PA ;
bOk = bOk && pCompoLoc->ApproxWithArcsEx( dArcApproxLinTol, dArcApproxAngTolDeg, LIN_FEA_STD, PA) &&
pCompoLoc->Clear() && pCompoLoc->FromPolyArc( PA) ;
// controllo aggiuntivo sui punti iniziali e finali che siano gli stessi
Point3d ptNewStart, ptNewEnd ;
bOk = bOk && pCompoLoc->GetStartPoint( ptNewStart) && pCompoLoc->GetEndPoint( ptNewEnd) &&
AreSamePointApprox( ptNewStart, ptStart) && AreSamePointApprox( ptNewEnd, ptEnd) ;
// controllo che non si siano create auto-intersezioni
SelfIntersCurve SIC( *pCompoLoc) ;
bOk = bOk && ( SIC.GetCrossIntersCount() == 0) ;
// se tutto bene, sostiuisco la curva originale con la modificata
if ( bOk) {
pCompoLoc->ToGlob( frLocXY) ;
pCompo->CopyFrom( pCompoLoc) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetActiveSurfaces( INTVECTOR& vSurfId, INTVECTOR& vSurfSuppId) const
{
// NB.
// - vSrufInd contiene gli Id delle superfici selezionate ( nel caso non ci siano superfici
// selezionate, allora vengono considerate tutte le superfici presenti nei grezzi attivi della fase)
// - vSurfSupp contiene gli Id delle superfici di supporto, quindi quelle superici da cui si vuole
// mantenere una certa distanza con l'utensile ( senza che siano selezionate)
// pulisco vettore superfici
vSurfId.clear() ;
vSurfSuppId.clear() ;
// verifiche
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
return false ;
// cerco tra gli oggetti selezionati
for ( const auto& Id : m_vId) {
int nEntId = Id.nId ;
int nType = m_pGeomDB->GetGeoType( nEntId) ;
if ( nType == SRF_TRIMESH || nType == SRF_BEZIER)
vSurfId.emplace_back( nEntId) ;
}
// controllo se sono state trovate delle superfici
bool bNoSurfId = ( vSurfId.empty()) ;
// scorro tutte le superfici dei pezzi nei grezzi attivi della fase
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
if ( m_pMchMgr->VerifyRawPartPhase(nRawId, m_nPhase)) {
// ciclo sui pezzi del grezzo
int nPartId = m_pMchMgr->GetFirstPartInRawPart( nRawId) ;
while ( nPartId != GDB_ID_NULL) {
// ciclo sui layer dei pezzi
int nLayId = m_pGeomDB->GetFirstGroupInGroup( nPartId) ;
while ( nLayId != GDB_ID_NULL) {
// ciclo sulle entità del layer
int nEntId = m_pGeomDB->GetFirstInGroup( nLayId) ;
while ( nEntId != GDB_ID_NULL) {
// se entità superficie e visibile, la aggiungo
int nStat ;
if ( ( m_pGeomDB->GetGeoType( nEntId) == SRF_TRIMESH ||
m_pGeomDB->GetGeoType( nEntId) == SRF_BEZIER) &&
m_pGeomDB->GetCalcStatus( nEntId, nStat) && nStat != GDB_ST_OFF) {
// se non sono state selezionate superfici precedentemente, memorizzo tale id
if ( bNoSurfId)
vSurfId.emplace_back( nEntId) ;
// verifico se è presente una superficie di controllo
string sLayIdName ;
if ( m_pGeomDB->GetName( nLayId, sLayIdName) && EqualNoCase( sLayIdName, SRF_SUPP_LAYER_NAME))
vSurfSuppId.emplace_back( nEntId) ;
}
// passo alla entità successiva
nEntId = m_pGeomDB->GetNext( nEntId) ;
}
nLayId = m_pGeomDB->GetNextGroup( nLayId) ;
}
nPartId = m_pMchMgr->GetNextPartInRawPart( nPartId) ;
}
}
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Vector3d& vtTool,
const Vector3d& vtMove, double dDepth, ICRVCOMPOPOVECTOR& vpCrvs)
{
// se non ho curve, non faccio nulla
if ( vpCrvs.empty())
return true ;
// se classe di calcolo per collisioni valida
if ( pCAvTlStm != nullptr) {
// porto i dati geometrici in locale alle superfici
Vector3d vtToolL = GetToLoc( vtTool, frSurf) ; // direzione utensile
Vector3d vtMoveL = GetToLoc( vtMove, frSurf) ; // direzione risalita per collisione
const double MIN_DIST = 1. ;
const double MAX_DIST = 50. ;
double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
// se presente Flag di SkipMaxDown, elimino le parti iniziali e finali dei percorsi che non hanno subito una collisione
bool bEraseStartEndMaxDown = false ;
GetValInNotes( m_Params.m_sUserNotes, UN_SKIPMAXDOWN, bEraseStartEndMaxDown) ;
// scorro le curve
double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ;
for ( int i = 0 ; i < ssize( vpCrvs) ; ++ i) {
// controllo che la curva sia valida
if ( IsNull( vpCrvs[i]) || ! vpCrvs[i]->IsValid())
continue ;
// approssimo la curva con una polilinea
PolyLine PL ;
if ( ! vpCrvs[i]->ApproxWithLines( min( LIN_TOL_FINE, m_Params.m_dApprox), ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
return false ;
// eventuale aggiunta di punti per garantire max distanza
if ( ! PL.AdjustForMaxSegmentLen( dDist))
return false ;
// porto nel riferimento delle superfici
PL.ToLoc( frSurf) ;
// traslo della lunghezza utensile diminuita dell'affondamento
PL.Translate( vtToolL * m_TParams.m_dLen - vtMoveL * dDepth) ;
// eseguo CAv
if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtToolL, vtMoveL, m_Params.m_dApprox, ( i + 1) * dProgCoeff))
return false ;
// contro-traslo della lunghezza utensile
PL.Translate( - vtToolL * m_TParams.m_dLen) ;
// riporto la polilinea nel riferimento della curva
PL.ToGlob( frSurf) ;
// se devo eliminare i punti inziali e finali senza collisione, modifico la PolyLine
if ( bEraseStartEndMaxDown)
EraseMaxDownStartEndPolyLine( PL) ;
// elimino i punti allineati
PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
// creo una curva composita a partire dalla polilinea
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( IsNull( pCompo) || ! pCompo->FromPolyLine( PL))
return false ;
// sostituisco la vecchia curva con la nuova
vpCrvs[i].Set( pCompo) ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs)
{
// calcolo lo ZigZag
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, GetLocalSideAngle(), 5.,
POCKET_ZIGZAG, false, false, m_Params.m_bInvert, true, true, false, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., false, vpCrvs)) {
m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
return false ;
}
// correggo i percorsi mediante collisione con le supercici
if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, vtMove, dDepth, vpCrvs)) {
m_pMchMgr->SetLastError( 3134, "Error in SurfFinishing : Projecting Path failed") ;
return false ;
}
// aggiungo i percorsi di finitura calcolati
if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vpCrvs, vtTool, vtMove, dElev, dDepth, bSplitArcs))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs)
{
// calcolo OneWay
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, GetLocalSideAngle(), 5.,
POCKET_ONEWAY, false, false, m_Params.m_bInvert, true, true, false, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., false, vpCrvs)) {
m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
return false ;
}
// correggo i percorsi mediante collisione con le supercici
if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, vtMove, dDepth, vpCrvs)) {
m_pMchMgr->SetLastError( 3134, "Error in SurfFinishing : Projecting Path failed") ;
return false ;
}
// aggiungo i percorsi di finitura calcolati
if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vpCrvs, vtTool, vtMove, dElev, dDepth, bSplitArcs))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut)
{
// calcolo la spirale
int nType = ( bInVsOut ? POCKET_SPIRALIN : POCKET_SPIRALOUT) ;
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, GetLocalSideAngle(), 5.,
nType, false, false, m_Params.m_bInvert, true, true, false, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., false, vpCrvs)) {
m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
return false ;
}
// correggo i percorsi mediante collisione con le supercici
if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, vtMove, dDepth, vpCrvs)) {
m_pMchMgr->SetLastError( 3134, "Error in SurfFinishing : Projecting Path failed") ;
return false ;
}
// aggiungo i percorsi di finitura calcolati
if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vpCrvs, vtTool, vtMove, dElev, dDepth, bSplitArcs))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfr,
const Vector3d& vtTool, set<double>& setZAmbiguos) const
{
// controllo dei parametri
setZAmbiguos.clear() ;
if ( pSfr == nullptr || ! pSfr->IsValid())
return false ;
// creo un frame centrato sulla superficie piana
Frame3d frSfr ;
Point3d ptC ; pSfr->GetCentroid( ptC) ;
if ( ! frSfr.Set( ptC, pSfr->GetNormVersor()) || ! frSfr.IsValid())
return false ;
// porto una copia della superficie in questo frame
PtrOwner<ISurfFlatRegion> pSfrLoc( CloneSurfFlatRegion( pSfr)) ;
if ( IsNull( pSfrLoc) || ! pSfrLoc->IsValid() || ! pSfrLoc->ToLoc( frSfr))
return false ;
// scorro le superfici trimesh selezionate
for ( int nS = 0 ; nS < ssize( vSrfLoc) ; ++ nS) {
// recupero la superficie
const ISurf* pSurf = GetSurf( vSrfLoc[nS].Get()) ;
if ( pSurf == nullptr || ! pSurf->IsValid())
continue ;
int nType = pSurf->GetType() ;
PtrOwner<ISurfTriMesh> pStm( nullptr) ;
// se TriMesh
if ( nType == SRF_TRIMESH) {
const ISurfTriMesh* pSurftm = GetSurfTriMesh( pSurf) ;
if ( pSurftm != nullptr && pSurftm->IsValid() && pSurftm->GetTriangleCount() > 0) {
if ( ! pStm.Set( CloneSurfTriMesh( pSurftm)))
continue ;
}
}
// se Bezier
else if ( nType == SRF_BEZIER) {
const ISurfBezier* pSurfBz = GetSurfBezier( pSurf) ;
if ( pSurfBz != nullptr && pSurfBz->IsValid()) {
double dOldTol = GetSurfBezierAuxSurfRefinedTol() ;
SetSurfBezierAuxSurfRefinedTol( 5. * EPS_SMALL) ;
const ISurfTriMesh* pSurftm = pSurfBz->GetAuxSurfRefined() ;
SetSurfBezierAuxSurfRefinedTol( dOldTol) ;
if ( pSurftm != nullptr && pSurftm->IsValid() && pSurftm->GetTriangleCount() > 0) {
if ( ! pStm.Set( CloneSurfTriMesh( pSurftm)))
continue ;
}
}
}
// scorro le facce
for ( int nF = 0 ; nF < pStm->GetFacetCount() ; ++ nF) {
// recupero il centro e la normale della faccia
Point3d ptCenter ;
Vector3d vtNorm ;
if ( pStm->GetFacetCenter( nF, ptCenter, vtNorm)) {
// confronto la normale con la direzione dell'utensile
vtNorm.ToGlob( frSurf) ;
if ( AreSameVectorEpsilon( vtNorm, vtTool, 10 * EPS_SMALL)) {
// recupero i contorni della faccia
POLYLINEVECTOR vPL ;
if ( pStm->GetFacetLoops( nF, vPL)) {
// devo verificare che tale faccia effettivamente sia contenuta all'interno della *pSfr.
// Essendo la normale della faccia orientata circa la direzione utensile, posso effettuare un confronto diretto
SurfFlatRegionByContours SfrByC ;
for ( int nPL = 0 ; nPL < ssize( vPL) ; ++ nPL) {
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo) || ! pCrvCompo->FromPolyLine( vPL[nPL]))
return false ;
// porto la curva nel riferimento della superficie piana di classificazione
pCrvCompo->ToLoc( frSfr) ;
// aggiungo la curva alla FlatRegion
SfrByC.AddCurve( Release( pCrvCompo)) ;
}
ptCenter.ToLoc( frSfr) ;
// recupero la superficie
PtrOwner<ISurfFlatRegion> pSfrFace( SfrByC.GetSurf()) ;
if ( IsNull( pSfrFace) || ! pSfrFace->IsValid()) {
// in questo caso potrei avere geometrie complesse per le facce della pStm
setZAmbiguos.insert( ptCenter.z) ;
continue ;
}
// se esiste intersezione tra pSfrFace e pSfr allora salvo la Z locale
pSfrFace->Intersect( *pSfrLoc) ;
if ( ! IsNull( pSfrFace) && pSfrFace->IsValid())
setZAmbiguos.insert( ptCenter.z) ;
}
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
ISurfFlatRegion*
SurfFinishing::GetSfrSilhouette( const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frLvl0, double dDepth) const
{
// inizializzo vettore di puntatori a superfici costanti
CISURFTMPVECTOR vpStm ; vpStm.reserve( vSrfLoc.size()) ;
// scorro le superfici
for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
// recupero la superficie TriMesh
const ISurfTriMesh* pStm = GetSurfTriMesh( vSrfLoc[i].Get()) ;
// se valida, la memorizzo
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0)
vpStm.emplace_back( pStm) ;
}
// inizializzo classe di calcolo della silhouette
const double SILH_TOL = 1.0 ;
PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
if ( IsNull( pCavParSilh) || ! pCavParSilh->SetData( vpStm, frLvl0, SILH_TOL))
return nullptr ;
// vettore di PolyLine
POLYLINEVECTOR vPL ;
if ( ! pCavParSilh->GetSilhouette( dDepth, vPL))
return nullptr ;
// creo la regione piana dalle PolyLine ricavate dalla Silhouette
SurfFlatRegionByContours SfrMaker ;
for ( auto& PL : vPL) {
// recupero la curva dalla silhouette
PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
if ( IsNull( pSilCrv))
return nullptr ;
pSilCrv->FromPolyLine( PL) ;
// approssimo con archi
const double SILH_ARC_TOL = 100 * EPS_SMALL ;
const double SILH_ARC_FEA_MAX = 100. ;
PolyArc PA ;
if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
if ( ! IsNull( pTempCrv) &&
pTempCrv->FromPolyArc( PA) &&
pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG) &&
pTempCrv->MergeCurves( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG))
pSilCrv.Set( pTempCrv) ;
}
// aggiungo per regione
if ( ! SfrMaker.AddCurve( Release( pSilCrv)))
return nullptr ;
}
return ( SfrMaker.GetSurf()) ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
const ISurfFlatRegion* pSfrClass, const Vector3d& vtTool, double dDepth, vector<ICRVCOMPOPOVECTOR>& vCrvCompo) const
{
// funzione per calcolare le curve singole di finitura mediante Silhouette e le regioni da non rovinare
// NB. Come primo TempParam delle curve viene memorizzata la distanza tra essa e il piano della pSfrClass
// controllo che la regione piana sia definita correttamente
vCrvCompo.clear() ;
if ( pSfrClass == nullptr || ! pSfrClass->IsValid())
return false ;
// definisco un frame implicito rispetto alla superficie di classificazione
Frame3d frLocXY ;
Point3d ptC ; pSfrClass->GetCentroid( ptC) ;
frLocXY.Set( ptC, pSfrClass->GetNormVersor()) ;
// NB. Essendo una finitura a Z costante, devo controllare che i piani di finitura non facciano
// overlap con facce delle TriMesh selezionate con normale simile a vtTool
set<double> setZAmbiguos ;
PtrOwner<ISurfFlatRegion> pSfrZCheck( CloneSurfFlatRegion( pSfrClass)) ;
if ( IsNull( pSfrZCheck) || ! pSfrZCheck->IsValid() ||
! GetZConstQuotesInsideSfrParallelToTool( vSrfLoc, frSurf, pSfrZCheck, vtTool, setZAmbiguos))
return false ;
// aggiorno la ProgressBar al 40%
ExeProcessEvents( 40, 0) ;
// calcolo la silhouette sui diversi piani
for ( int nPlane = 1 ; nPlane * m_Params.m_dSideStep < dDepth + EPS_SMALL ; ++ nPlane) {
// riservo lo spazio nel vettore delle curve
vCrvCompo.resize( vCrvCompo.size() + 1) ;
// definisco la Zlocale per il calcolo della silhouette
double dZLoc = - nPlane * m_Params.m_dSideStep ;
for ( set<double>::iterator it = setZAmbiguos.begin() ; it != setZAmbiguos.end() ; ++ it) {
if ( abs( *it - dZLoc) < 5. * EPS_SMALL)
dZLoc += ( nPlane == 1 ? - 10. * EPS_SMALL : + 10. * EPS_SMALL) ;
}
// calcolo vettore di PolyLine ottenute al piano corrente
POLYLINEVECTOR vPL ;
if ( ! pCavParSilh->GetSilhouette( dZLoc, vPL))
return false ;
// classifico le PolyLine in base alla regione
POLYLINEVECTOR vPLInsideSfr ;
for ( PolyLine& PL : vPL) {
// porto la PolyLine a contatto con la regione
PL.Translate( - dZLoc * pSfrClass->GetNormVersor()) ;
// converto in curva composita
PtrOwner<ICurveComposite> pCrvPL( CreateCurveComposite()) ;
if ( IsNull( pCrvPL) || ! pCrvPL->FromPolyLine( PL))
return false ;
// classifico la curva con la superficie
CRVCVECTOR ccClass ;
if ( ! pSfrClass->GetCurveClassification( *pCrvPL, EPS_SMALL, ccClass))
return false ;
// tengo tutti i tratti non esterni alla superficie
for ( int i = 0 ; i < ssize( ccClass) ; ++ i) {
if ( ccClass[i].nClass != CRVC_OUT) {
PtrOwner<ICurveComposite> pCrvCompoPartIn( ConvertCurveToComposite( pCrvPL->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE))) ;
if ( ! IsNull( pCrvCompoPartIn) && pCrvCompoPartIn->IsValid()) {
vPLInsideSfr.emplace_back( PolyLine()) ;
// riporto la curva alla quota giusta
pCrvCompoPartIn->Translate( dZLoc * pSfrClass->GetNormVersor()) ;
pCrvCompoPartIn->ApproxWithLines( 0, 0, ICurve::APL_SPECIAL, vPLInsideSfr.back()) ;
}
}
}
}
swap( vPL, vPLInsideSfr) ;
for ( PolyLine& PL : vPL) {
// recupero la curva dalla silhouette
PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
if ( IsNull( pSilCrv))
return false ;
pSilCrv->FromPolyLine( PL) ;
// approssimo con archi
const double SILH_ARC_TOL = 0.1 * SILH_SAMPLING ;
const double SILH_ARC_FEA_MAX = 100. ;
PolyArc PA ;
if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
if ( ! IsNull( pTempCrv) &&
pTempCrv->FromPolyArc( PA) &&
pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG) &&
pTempCrv->MergeCurves( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG))
pSilCrv.Set( pTempCrv) ;
}
SimplifyCurve( pSilCrv, frLocXY) ;
vCrvCompo.back().emplace_back( Release( pSilCrv)) ;
}
// controllo validità delle curve
for ( int i = 0 ; i < ssize( vCrvCompo.back()) ; ++ i)
if ( vCrvCompo.back()[i] == nullptr || ! vCrvCompo.back()[i]->IsValid())
return false ;
// preparo i dati per il concatenamento
bool bFirst = true ;
Point3d ptNear = ORIG ;
double dToler = 500. * EPS_SMALL ;
ChainCurves chainC ;
chainC.Init( false, dToler, int( vCrvCompo.back().size())) ;
for ( int i = 0 ; i < ssize( vCrvCompo.back()) ; ++ i) {
// recupero i dati della curva necessari al concatenamento e li assegno
Point3d ptStart, ptEnd ;
Vector3d vtStart, vtEnd ;
if ( ! vCrvCompo.back()[i]->GetStartPoint( ptStart) || ! vCrvCompo.back()[i]->GetStartDir( vtStart) ||
! vCrvCompo.back()[i]->GetEndPoint( ptEnd) || ! vCrvCompo.back()[i]->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 ;
}
}
// vettore delle curve composite risultante
ICRVCOMPOPOVECTOR vCrvCompoChained ;
// recupero i percorsi concatenati
INTVECTOR vnInd ;
while ( chainC.GetChainFromNear( ptNear, true, vnInd)) {
// creo una curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// recupero le curve semplici e le inserisco nella curva composita
for ( int i = 0 ; i < ssize( vnInd) ; ++ i) {
int nId = abs( vnInd[i]) - 1 ;
// la aggiungo alla curva composta
if ( ! pCrvCompo->AddCurve( CloneCurveComposite( vCrvCompo.back()[nId]), true, dToler))
return false ;
}
// aggiorno il nuovo punto vicino
if ( pCrvCompo->GetCurveCount() > 0) {
pCrvCompo->GetEndPoint( ptNear) ;
vCrvCompoChained.emplace_back( Release( pCrvCompo)) ;
}
}
swap( vCrvCompoChained, vCrvCompo.back()) ;
// salvo lo Step come primo temp param della curva e inverto se necessario
for ( int i = 0 ; i < ssize( vCrvCompo.back()) ; ++ i) {
vCrvCompo.back()[i]->SetTempParam( - nPlane * m_Params.m_dSideStep, 0) ;
if ( m_Params.m_bInvert)
vCrvCompo.back()[i]->Invert() ;
}
// aggiorno la ProgressBar
ExeProcessEvents( 40 + int( 40 / ( dDepth / max( 0.1, m_Params.m_dSideStep)) * ( nPlane - 1)), 0) ;
}
// controllo la validità di tutte le curve trovate
for ( int i = 0 ; i < ssize( vCrvCompo) ; ++ i) {
for ( int j = 0 ; j < ssize( vCrvCompo[i]) ; ++ j) {
if ( vCrvCompo[i][j] == nullptr || ! vCrvCompo[i][j]->IsValid())
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const CISURFTMPVECTOR& vpStm, const Frame3d& frSurf,
vector<ICRVCOMPOPOVECTOR>& vCrvCompo, const Vector3d& vtTool, const ISurfFlatRegion* pSfr,
double dDepth, ICRVCOMPOPOVECTOR& vCrvPath) const
{
// funzione per collegare le curve trovate creando quindi i percorsi di lavoro
// NB. Nel primo TempParam deve essere memorizzata la distanza del piano della curva con il piano della Sfr
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid())
return false ;
// porto il tool nel frame della superficie
Vector3d vtToolLoc = GetToLoc( vtTool, frSurf) ;
// porto tutte le curve nel piano XY locale alla pSfr e, per ognuna di esse, definisco la regione
// piana di proiezione del materiale rimosso orientato a sinistra della curva
Frame3d frXY ;
Point3d ptCenter ; pSfr->GetCentroid( ptCenter) ;
if ( ! frXY.Set( ptCenter, vtToolLoc))
return false ;
vector<ISURFFRPOVECTOR> vSfrRemMatCol ; vSfrRemMatCol.resize( vCrvCompo.size()) ; // RemovedMaterialColumn
double dRadSignOffs = m_Params.m_bInvert ? m_TParams.m_dDiam / 2. : - m_TParams.m_dDiam / 2. ;
#if ENABLE_ZCONST_PATH_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "Crv & Sfr") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
#endif
for ( int i = 0 ; i < ssize( vCrvCompo) ; ++ i) {
vSfrRemMatCol[i].resize( vCrvCompo[i].size()) ;
for ( int j = 0 ; j < ssize( vCrvCompo[i]) ; ++ j) {
// Frame locale XY
vCrvCompo[i][j]->ToLoc( frXY) ;
vCrvCompo[i][j]->SetExtrusion( m_Params.m_bInvert ? - Z_AX : Z_AX) ;
SurfFlatRegionByContours SfrBC ;
// --- Se curva chiusa
if ( vCrvCompo[i][j]->IsClosed()) {
SfrBC.AddCurve( CloneCurveComposite( vCrvCompo[i][j])) ;
OffsetCurve OffsCrv ;
OffsCrv.Make( vCrvCompo[i][j], dRadSignOffs, ICurve::OFF_FILLET) ;
PtrOwner<ICurve> pCrvIsl( OffsCrv.GetLongerCurve()) ;
while ( ! IsNull( pCrvIsl)) {
SfrBC.AddCurve( Release( pCrvIsl)) ;
pCrvIsl.Set( OffsCrv.GetLongerCurve()) ;
}
}
// --- Se curva aperta
else {
OffsetCurve OffsCrv ;
OffsCrv.Make( vCrvCompo[i][j], dRadSignOffs, ICurve::OFF_FILLET) ;
// [euristico, migliorabile/da_correggere]
PtrOwner<ICurve> pCrvInt( OffsCrv.GetLongerCurve()) ;
if ( ! IsNull( pCrvInt)) {
pCrvInt->Invert() ;
Point3d ptS ; pCrvInt->GetStartPoint( ptS) ;
Point3d ptE ; vCrvCompo[i][j]->GetStartPoint( ptE) ;
PtrOwner<ICurveComposite> pSfrLoop( CreateCurveComposite()) ;
if ( IsNull( pSfrLoop))
return false ;
pSfrLoop->AddCurve( CloneCurveComposite( vCrvCompo[i][j])) ;
pSfrLoop->AddLine( ptS) ;
pSfrLoop->AddCurve( Release( pCrvInt)) ;
pSfrLoop->AddLine( ptE) ;
SfrBC.AddCurve( Release( pSfrLoop)) ;
}
}
vSfrRemMatCol[i][j].Set( SfrBC.GetSurf()) ;
if ( IsNull( vSfrRemMatCol[i][j]) || ! vSfrRemMatCol[i][j]->IsValid())
vSfrRemMatCol[i][j].Set( GetSurfFlatRegionFromFatCurve( vCrvCompo[i][j]->Clone(), m_TParams.m_dDiam / 2., false, false)) ;
// tutte rivolte come Z_AX ( vtTool locale)
if ( AreOppositeVectorApprox( vSfrRemMatCol[i][j]->GetNormVersor(), Z_AX))
vSfrRemMatCol[i][j]->Invert() ;
#if ENABLE_ZCONST_PATH_DEBUG
Color myCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay, ToString( vCrvCompo[i][j]->GetTempParam( 0))) ;
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, vCrvCompo[i][j]->Clone()) ;
m_pGeomDB->SetMaterial( nId, myCol) ;
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, vSfrRemMatCol[i][j]->Clone()) ;
myCol.SetAlpha( .25) ;
m_pGeomDB->SetMaterial( nId, myCol) ;
#endif
}
}
// definisco le relazioni delle curve mediante le superfici create
int nRowSize = int( vCrvCompo.size()) ;
int nColSize = 0 ;
for ( int i = 0 ; i < nRowSize ; ++ i)
nColSize = max( nColSize, int( vCrvCompo[i].size())) ;
unordered_map<int, INTINTVECTOR> MapLock ;
unordered_map<int, INTINTVECTOR> MapUnlock ;
for ( int nR = ssize( vCrvCompo) - 1 ; nR >= 1 ; -- nR) {
for ( int nC = 0 ; nC < ssize( vCrvCompo[nR]) ; ++ nC) {
for ( int nCol = 0 ; nCol < ssize( vCrvCompo[nR - 1]) ; ++ nCol) {
PtrOwner<ISurfFlatRegion> pSfrCheck( CloneSurfFlatRegion( vSfrRemMatCol[nR][nC])) ;
if ( ! IsNull( pSfrCheck)) {
pSfrCheck->Intersect( *vSfrRemMatCol[nR - 1][nCol]) ;
if ( pSfrCheck->IsValid() && pSfrCheck->GetChunkCount() > 0) {
int nKeyLock = nR * nColSize + nC ;
int nKeyUnLock = ( nR - 1) * nColSize + nCol ;
MapLock[nKeyLock].emplace_back( make_pair( nR - 1, nCol)) ;
MapUnlock[nKeyUnLock].emplace_back( make_pair( nR, nC)) ;
}
}
}
}
}
// definisco i gruppi di curve indpendenti; Un insieme di curve risulta indipendente da un altro
// insieme se l'ordine di esecuzione di essi è indifferente ;
// [non esiste alcuna curva nel gruppo A che interferisce con una curva del gruppo B)
vector<ICRVCOMPOPOVECTOR> vIndependentCurveGroup ;
bool bGroup = true ;
int nCont = 0 ;
while ( bGroup && nCont < nRowSize * nColSize) {
++ nCont ;
bGroup = false ;
// cerco la prima curva non ancora inserita in un gruppo
for ( int nR = ssize( vCrvCompo) - 1 ; nR >= 0 && ! bGroup ; -- nR) {
// scorro sulle colonne ( dalla prima all'ultima) [ordine casuale]
for ( int nC = 0 ; nC < ssize( vCrvCompo[nR]) && ! bGroup ; ++ nC) {
// se la curva attuale già in un gruppo ( quindi nullptr), passo alla successiva
if ( vCrvCompo[nR][nC] == nullptr)
continue ;
// se trovo una curva, allora ho un nuovo gruppo da analizzare
bGroup = true ;
// creazione spazio per un nuovo gruppo
vIndependentCurveGroup.resize( vIndependentCurveGroup.size() + 1) ;
INTINTVECTOR vMapIndCheck = { make_pair( nR, nC)} ;
// finchè ho indici di riga-colonna da verificare
while ( ! vMapIndCheck.empty()) {
// memorizzo gli indici correnti
int nCurrRow = vMapIndCheck.back().first ;
int nCurrCol = vMapIndCheck.back().second ;
// tolgo l'elemento ( non devo ricontrollarlo all'iterazione successiva)
vMapIndCheck.pop_back() ;
// aggiungo la curva al percorso corrente
vIndependentCurveGroup.back().emplace_back( Release( vCrvCompo[nCurrRow][nCurrCol])) ;
// --- se la curva non è bloccata da nessun'altra
auto itLock = MapLock.find( nCurrRow * nColSize + nCurrCol) ;
if ( itLock == MapLock.end()) {
; // non faccio nulla ( ultimo piano locale)
}
// --- altrimenti
else {
// --- scorro le curve che bloccano quella corrente
for ( int i = 0 ; i < ssize( itLock->second) ; ++ i) {
int nBR = itLock->second[i].first ;
int nBC = itLock->second[i].second ;
INTINT Key = make_pair( nBR, nBC) ;
auto itUnLock = MapUnlock.find( nBR * nColSize + nBC) ;
// verifico che non ci siano altre curve bloccate
bool bLock = false ;
for ( int j = 0 ; j < ssize( itUnLock->second) && ! bLock ; ++ j)
bLock = ( vCrvCompo[itUnLock->second[j].first][itUnLock->second[j].second] != nullptr) ;
if ( ! bLock)
vMapIndCheck.emplace_back( Key) ;
}
}
}
}
}
}
#if ENABLE_ZCONST_PATH_DEBUG
nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "Independent Groups") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
vector<Color> vCol ;
vector<int> vLay ;
for ( int nPath = 0 ; nPath < int( vIndependentCurveGroup.size()) ; ++ nPath) {
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
vLay.emplace_back( nLay) ;
Color myCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
vCol.emplace_back( myCol) ;
for ( auto& pCrv : vIndependentCurveGroup[nPath]) {
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, CloneCurveComposite( pCrv)) ;
m_pGeomDB->SetMaterial( nId, myCol) ;
}
}
#endif
// definisco il piano locale della regione piana ( frXY è centrato su di essa)
Plane3d plProjection ;
if ( ! plProjection.Set( ORIG, Z_AX))
return false ;
// ordino i gruppi di curve indipendenti
typedef pair<int, pair<double, double>> INTDBLDBL ; // <Ind, <ZMax, ZMin>>
vector<INTDBLDBL> vMapGrpZLoc ;
vMapGrpZLoc.reserve( vIndependentCurveGroup.size()) ;
for ( int i = 0 ; i < ssize( vIndependentCurveGroup) ; ++ i) {
// scorro le curve del gruppo cercando quella più in alto ( rispetto alla Zlocale di frXY)
double dZMax = - INFINITO ;
double dZMin = INFINITO ;
for ( auto& pCrv : vIndependentCurveGroup[i]) {
double dCurrZ = pCrv->GetTempParam( 0) ;
dZMax = max( dZMax, dCurrZ) ;
dZMin = min( dZMin, dCurrZ) ;
}
vMapGrpZLoc.emplace_back( make_pair( i, make_pair( dZMax, dZMin))) ;
}
// ordino
sort( vMapGrpZLoc.begin(), vMapGrpZLoc.end(), []( const INTDBLDBL& GrpA, const INTDBLDBL& GrpB) {
// Se ZMax coincidenti, viene prima quello con ZMin superiore
if ( abs( GrpA.second.first - GrpB.second.first) < 10. * EPS_SMALL)
return ( GrpA.second.second > GrpB.second.second) ;
// Se diffeenti, viene prima quello con ZMax superiore
return ( GrpA.second > GrpB.second) ;
}) ;
#if ENABLE_ZCONST_PATH_DEBUG
nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "Ordered Independent Groups") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
vLay.clear() ;
for ( int nPath = 0 ; nPath < int( vMapGrpZLoc.size()) ; ++ nPath) {
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
vLay.emplace_back( nLay) ;
for ( auto& pCrv : vIndependentCurveGroup[vMapGrpZLoc[nPath].first]) {
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, CloneCurveComposite( pCrv)) ;
m_pGeomDB->SetMaterial( nId, vCol[vMapGrpZLoc[nPath].first]) ;
}
}
#endif
// tengo una copia dei bordi della regione ( servono per limitare i collegamenti tra le curve dei Path)
PtrOwner<ISurfFlatRegion> pSfrClass( CloneSurfFlatRegion( pSfr)) ;
if ( IsNull( pSfrClass) || ! pSfrClass->IsValid() || ! pSfrClass->ToLoc( frXY))
return false ;
ICRVCOMPOPOVECTOR vCrvSfrLoops ;
for ( int nC = 0 ; nC < pSfrClass->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfrClass->GetLoopCount( nC) ; ++ nL) {
PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfrClass->GetLoop( nC, nL))) ;
if ( IsNull( pCrvLoop) || ! pCrvLoop->IsValid())
return false ;
// tutti i loop sono orientati come il loop esterno
// NB. Per classificare i collegamenti si usa la regione, non queste curve !
// [ Vengono utilizzate per non inizializzare ogni volta una curva corrispondente al bordo
// della superficie di classificazione]
if ( nL > 0)
pCrvLoop->Invert() ;
vCrvSfrLoops.emplace_back( Release( pCrvLoop)) ;
}
}
// porto tutte le regioni nel frame locale XY per la verifica di collegamenti verticali
CISURFTMPVECTOR vpStmLoc ; vpStmLoc.reserve( vpStm.size()) ;
for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
PtrOwner<ISurfTriMesh> pStmLoc( CloneSurfTriMesh( vpStm[i])) ;
if ( ! IsNull( pStmLoc) && pStmLoc->IsValid() && pStmLoc->GetTriangleCount() > 0) {
pStmLoc->ToLoc( frXY) ;
vpStmLoc.emplace_back( ::Release( pStmLoc)) ;
#if 0
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vpStmLoc[i]->Clone()) ;
#endif
}
}
// definisco i collegamenti tra i percorsi
#if ENABLE_ZCONST_PATH_DEBUG
nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "Paths") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
#endif
const double LINK_TOL = 25. * EPS_SMALL ;
Point3d ptRef = P_INVALID ;
for ( int i = 0 ; i < ssize( vMapGrpZLoc) ; ++ i) {
// recupero l'indice ordinato del percorso
int nPath = vMapGrpZLoc[i].first ;
// inverto il vettore delle curve di bordo del percorso corrente
reverse( vIndependentCurveGroup[nPath].begin(), vIndependentCurveGroup[nPath].end()) ;
// definisco il vettore dei collegamenti creati tra le curve
// NB. Un collegamento potrebbe non essere valido e non realizzabile
// NB. Il collegamento i-esimo collega la curva di bordo (i-1)-esima con la curva di bordo i-esima
ICRVCOMPOPOVECTOR vCompoLink ;
vCompoLink.resize( vIndependentCurveGroup[nPath].size()) ; // nullptr per ogni Link
// --- se non ho curve, passo al gruppo successivo
if ( vIndependentCurveGroup[nPath].empty())
continue ;
// --- se ho una sola curva, allora controllo se posso cambiare il suo punto d'inizio
// nel caso non sia la prima in assoluto [ -> controllo ptRef]
if ( ssize( vIndependentCurveGroup[nPath]) == 1) {
if ( ptRef.IsValid()) {
// --- se la curva di bordo singola è aperta
if ( ! vIndependentCurveGroup[nPath][0]->IsClosed()) {
// ... se necessario la inverto per recuperare l'estremo più vicino a ptRef
// [ per ora le curve aperte possono essere invertite nelle finiture a ZLevel]
Point3d ptS ; vIndependentCurveGroup[nPath][0]->GetStartPoint( ptS) ;
Point3d ptE ; vIndependentCurveGroup[nPath][0]->GetEndPoint( ptE) ;
if ( SqDist( ptE, ptRef) < SqDist( ptS, ptRef))
vIndependentCurveGroup[nPath][0]->Invert() ;
}
// --- se la curva di bordo singola è chiusa
else {
// cerco il punto a minima distanza da ptRef ( non inverto, tengo il senso di lavorazione)
double dMinPar = 0. ;
int nFlag = 0 ;
DistPointCurve( ptRef, *vIndependentCurveGroup[nPath][0]).GetParamAtMinDistPoint( 0., dMinPar, nFlag) ;
vIndependentCurveGroup[nPath][0]->ChangeStartPoint( dMinPar) ;
}
}
// inserisco la curva nel percorso
vCrvPath.emplace_back( Release( vIndependentCurveGroup[nPath][0])) ;
// aggiorno il punto di riferimento
vCrvPath.back()->GetEndPoint( ptRef) ;
#if ENABLE_ZCONST_PATH_DEBUG
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLay, "Single") ;
Color myCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, CloneCurveComposite( vCrvPath.back())) ;
m_pGeomDB->SetMaterial( nId, myCol) ;
#endif
continue ;
}
// --- se ho più curve di bordo, scorro le curve a due a due per creare i collegamenti
for ( int nCompo = 0 ; nCompo < ssize( vIndependentCurveGroup[nPath]) - 1 ; ++ nCompo) {
// se prima curva di bordo e ho un punto di riferimento valido
if ( nCompo == 0 && ptRef.IsValid()) {
// --- se la prima curva di bordo è aperta
if ( ! vIndependentCurveGroup[nPath][0]->IsClosed()) {
// ... se necessario la inverto per recuperare l'estremo più vicino a ptRef
// [ per ora le curve aperte possono essere invertite nelle finiture a ZLevel]
Point3d ptS ; vIndependentCurveGroup[nPath][0]->GetStartPoint( ptS) ;
Point3d ptE ; vIndependentCurveGroup[nPath][0]->GetEndPoint( ptE) ;
if ( SqDist( ptE, ptRef) < SqDist( ptS, ptRef))
vIndependentCurveGroup[nPath][0]->Invert() ;
}
// --- se la prima curva di bordo è chiusa
else {
// cerco il punto a minima distanza da ptRef ( non inverto, tengo il senso di lavorazione)
double dMinPar = 0. ;
int nFlag = 0 ;
DistPointCurve( ptRef, *vIndependentCurveGroup[nPath][0]).GetParamAtMinDistPoint( 0., dMinPar, nFlag) ;
vIndependentCurveGroup[nPath][0]->ChangeStartPoint( dMinPar) ;
}
}
// come riferimento imposto inizialmente il punto finale della curva corrente
vIndependentCurveGroup[nPath][nCompo]->GetEndPoint( ptRef) ;
// --- se la curva di bordo successiva è aperta...
if ( ! vIndependentCurveGroup[nPath][nCompo + 1]->IsClosed()) {
// ... se necessario la inverto per recuperare l'estremo più vicino a quello corrente
// [ per ora le curve aperte possono essere invertite nelle finiture a ZLevel]
Point3d ptS ; vIndependentCurveGroup[nPath][nCompo + 1]->GetStartPoint( ptS) ;
Point3d ptE ; vIndependentCurveGroup[nPath][nCompo + 1]->GetEndPoint( ptE) ;
if ( SqDist( ptE, ptRef) < SqDist( ptS, ptRef))
vIndependentCurveGroup[nPath][nCompo + 1]->Invert() ;
}
// --- se la curva successiva è chiusa
else {
// cerco il punto a minima distanza ( non inverto, tengo il senso di lavorazione)
double dMinPar = 0. ;
int nFlag = 0 ;
DistPointCurve( ptRef, *vIndependentCurveGroup[nPath][nCompo + 1]).GetParamAtMinDistPoint( 0., dMinPar, nFlag) ;
vIndependentCurveGroup[nPath][nCompo + 1]->ChangeStartPoint( dMinPar) ;
}
// definisco il collegamento diretto come tratto lineare
Point3d ptStartLink ; vIndependentCurveGroup[nPath][nCompo]->GetEndPoint( ptStartLink) ;
Point3d ptEndLink ; vIndependentCurveGroup[nPath][nCompo + 1]->GetStartPoint( ptEndLink) ;
PtrOwner<ICurveLine> pLineLink( CreateCurveLine()) ;
if ( IsNull( pLineLink) || ! pLineLink->Set( ptStartLink, ptEndLink) || ! pLineLink->IsValid())
continue ; // il Link rimane nullptr
// !<--- se il Link è parallelo a vtTool ( Z_AX in locale), allora scendo verticalmente
Vector3d vtDirLink ; pLineLink->GetStartDir( vtDirLink) ;
if ( AreSameOrOppositeVectorEpsilon( vtDirLink, Z_AX, 100. * EPS_SMALL)) {
// la proiezione del Link è automaticamente all'interno della superficie di classificazione
vCompoLink[nCompo + 1].Set( ConvertCurveToComposite( Release( pLineLink))) ;
}
else {
// !<--- se il tratto lineare è troppo lungo, non considero il collegamento come valido
if ( SqDist( ptStartLink, ptEndLink) > 4. * m_TParams.m_dDiam * m_TParams.m_dDiam)
continue ; // il Link rimane nullptr
// proietto la curva nel piano locale della superficie di classificazione ( Z=0 ; Z_AX)
PtrOwner<ICurve> pLineLinkProj( ProjectCurveOnPlane( *pLineLink, plProjection)) ;
if ( IsNull( pLineLinkProj) || ! pLineLinkProj->IsValid())
return false ;
// effettuo la classificazione
CRVCVECTOR ccClass ;
if ( ! pSfrClass->GetCurveClassification( *pLineLinkProj, EPS_SMALL, ccClass))
continue ; // il Link rimane nullptr
// inizializzo il link come curva vuota e scorro le classificazioni ottenute
vCompoLink[nCompo + 1].Set( CreateCurveComposite()) ;
for ( int i = 0 ; i < ssize( ccClass) ; ++ i) {
// recupero il tratto di curva corrente
PtrOwner<ICurve> pSubCrv( pLineLinkProj->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE)) ;
if ( IsNull( pSubCrv) || ! pSubCrv->IsValid()) // troppo piccolo...
continue ; // passo al tratto di classificazione successivo
// --- se la curva non è esterna alla regione, la conservo
if ( ccClass[i].nClass != CRVC_OUT) {
if ( ! vCompoLink[nCompo + 1]->AddCurve( Release( pSubCrv), true, LINK_TOL))
return false ;
}
// --- se la curva è esterna, devo seguire il bordo della regione di classificazione
else {
// recupero gli estremi del segmento di classificazione esterno alla pSfrClass
Point3d ptStartOnSfr ; pLineLinkProj->GetPointD1D2( ccClass[i].dParS, ICurve::FROM_MINUS, ptStartOnSfr) ;
Point3d ptEndOnSfr ; pLineLinkProj->GetPointD1D2( ccClass[i].dParE, ICurve::FROM_MINUS, ptEndOnSfr) ;
// scorro tutti i loop della regione di classificazione
for ( int j = 0 ; j < ssize( vCrvSfrLoops) ; ++ j) {
// se i punti trovati sono sul loop corrente
if ( vCrvSfrLoops[j]->IsPointOn( ptStartOnSfr, LINK_TOL) &&
vCrvSfrLoops[j]->IsPointOn( ptEndOnSfr, LINK_TOL)) {
// devo orientare la SubCrv secondo il giusto verso di percorrenza
double dUS ; vCrvSfrLoops[j]->GetParamAtPoint( ptStartOnSfr, dUS, LINK_TOL) ;
double dUE ; vCrvSfrLoops[j]->GetParamAtPoint( ptEndOnSfr, dUE, LINK_TOL) ;
PtrOwner<ICurve> pCrvA( ( vCrvSfrLoops[j]->CopyParamRange( dUS, dUE))) ;
PtrOwner<ICurve> pCrvB( ( vCrvSfrLoops[j]->CopyParamRange( dUE, dUS))) ;
double dLenA = INFINITO ; double dLenB = INFINITO ;
if ( ! IsNull( pCrvA) && pCrvA->IsValid())
pCrvA->GetLength( dLenA) ;
if ( ! IsNull( pCrvB) && pCrvB->IsValid()) {
// sempre percorsa in senso opposto
pCrvB->Invert() ;
pCrvB->GetLength( dLenB) ;
}
// aggiungo la curva
if ( ! vCompoLink[nCompo + 1]->AddCurve( dLenA < dLenB ? Release( pCrvA) : Release( pCrvB), true, LINK_TOL))
return false ;
}
}
}
}
// se il link trovato non è valido, passo al successivo
if ( ! vCompoLink[nCompo + 1]->IsValid())
continue ; // il link rimane inizializzato e non valido ( 0 curve)
// !<-- ripristino la forma del loop tra inizio e fine
Point3d ptS ; vCompoLink[nCompo + 1]->GetStartPoint( ptS) ;
vCompoLink[nCompo + 1]->Translate( ptStartLink - ptS) ;
vCompoLink[nCompo + 1]->SetExtrusion( Z_AX) ;
double dNini = ( ptStartLink - ORIG) * Z_AX ;
double dNfin = ( ptEndLink - ORIG) * Z_AX ;
AdjustCurveSlope( vCompoLink[nCompo + 1], dNini, dNfin) ;
#if 0
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCompoLink[nCompo + 1]->Clone()) ;
m_pGeomDB->SetMaterial( nId, RED) ;
#endif
// verifico se il Link è aderente ad una parete verticale, in caso positivo, modifico il Link corrente
if ( ! CalcZConstLink( vCompoLink[nCompo + 1], ptStartLink, ptEndLink, pCAvTlStm, frXY, frSurf, Z_AX, dDepth, vpStmLoc))
return false ;
}
}
// calcolo il percorso unendo le curve di bordo con i Link ricavati
const double PATH_TOL = 1500. * EPS_SMALL ;
#if ENABLE_ZCONST_PATH_DEBUG
int nLay = GDB_ID_NULL ;
Color myCol = INVISIBLE ;
#endif
for ( int nCompo = 0 ; nCompo < ssize( vIndependentCurveGroup[nPath]) ; ++ nCompo) {
if ( IsNull( vCompoLink[nCompo]) || ! vCompoLink[nCompo]->IsValid()) {
#if ENABLE_ZCONST_PATH_DEBUG
nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
myCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
#endif
if ( ! vCrvPath.emplace_back( CreateCurveComposite()))
return false ;
}
else {
#if ENABLE_ZCONST_PATH_DEBUG
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, CloneCurveComposite( vCompoLink[nCompo])) ;
m_pGeomDB->SetMaterial( nId, myCol) ;
#endif
vCrvPath.back()->AddCurve( Release( vCompoLink[nCompo]), true, PATH_TOL) ;
}
#if ENABLE_ZCONST_PATH_DEBUG
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, CloneCurveComposite( vIndependentCurveGroup[nPath][nCompo])) ;
m_pGeomDB->SetMaterial( nId, myCol) ;
#endif
vCrvPath.back()->AddCurve( Release( vIndependentCurveGroup[nPath][nCompo]), true, PATH_TOL) ;
}
}
// riporto i percorsi nel frame originale
for ( int i = 0 ; i < ssize( vCrvPath) ; ++ i)
vCrvPath[i]->ToGlob( frXY) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcZConstLink( ICurveComposite* pCompoLink, const Point3d& ptStartLink, const Point3d& ptEndLink, ICAvToolSurfTm* pCAvTlStm,
const Frame3d& frPocket, const Frame3d& frSurf, const Vector3d& vtTool, double dDepth,
const CISURFTMPVECTOR& vpStm) const
{
// verifica dei parametri in ingresso
if ( pCompoLink == nullptr || ! pCompoLink->IsValid() ||
! ptStartLink.IsValid() || ! ptEndLink.IsValid() || ! vtTool.IsValid() ||
pCAvTlStm == nullptr || ! frPocket.IsValid() || ! frSurf.IsValid() || ! vtTool.IsValid())
return false ;
for ( const ISurfTriMesh* pStm : vpStm) {
if ( pStm == nullptr || ! pStm->IsValid() || pStm->GetTriangleCount() == 0)
return false ;
}
// verifico se il link è lungo una parete verticiale (escludo gli estremi in quanto forzati)
Vector3d vtMove = vtTool ; // !<--
double dLen = pCompoLink->GetLength( dLen) ;
const int MAX_POINTS = 5 ;
bool bFound = false ;
for ( int i = 1 ; !bFound && i < MAX_POINTS + 1 ; ++ i) {
double dLenCurr = i * ( dLen / MAX_POINTS + 1) ;
double dUCurr ; pCompoLink->GetParamAtLength( dLenCurr, dUCurr) ;
Point3d ptCurr ; pCompoLink->GetPointD1D2( dUCurr, ICurve::FROM_MINUS, ptCurr) ;
for ( const ISurfTriMesh* pStm : vpStm) {
DistPointSurfTm distPtStm( ptCurr, *pStm) ;
INTVECTOR vIndMinDistTria ;
if ( distPtStm.GetMinDistTriaIndices( vIndMinDistTria)) {
for ( int nTria : vIndMinDistTria) {
Triangle3d Tria ; pStm->GetTriangle( nTria, Tria) ;
if ( abs( Tria.GetN() * vtTool) < cos( 88. * DEGTORAD)) {
vtMove = Tria.GetN() ;
bFound = true ;
break ;
}
}
}
}
}
if ( bFound) {
vtMove = Media( vtMove, vtTool, 0.2) ;
vtMove.Normalize() ;
}
// approssimo la curva con una polilinea
PolyLine PL ;
if ( ! pCompoLink->ApproxWithLines( m_Params.m_dApprox, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
return false ;
#if ENABLE_ZCONST_PATH_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, Frame3d()) ;
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCompoLink->Clone()) ;
m_pGeomDB->SetMaterial( nId, RED) ;
#endif
// eventuale aggiunta di punti per garantire max distanza
const double MIN_DIST = 1. ;
const double MAX_DIST = 50. ;
double dDist = Clamp( m_TParams.m_dDiam / 2., MIN_DIST, MAX_DIST) ;
if ( ! PL.AdjustForMaxSegmentLen( dDist))
return false ;
// porto nel riferimento delle superfici
PL.ToGlob( frPocket) ;
// porto i dati geometrici in locale alle superfici
Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
Vector3d vtMoveL = GetToLoc( vtMove, frSurf) ;
// traslo della lunghezza utensile
PL.Translate( vtToolL * ( m_TParams.m_dLen)) ;
// eseguo il test del percorso
if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtToolL, vtMoveL, m_Params.m_dApprox))
return false ;
// contro-traslo della lunghezza utensile
PL.Translate( - vtToolL * m_TParams.m_dLen) ;
// riporto la polilinea nel riferimento della curva
PL.ToLoc( frPocket) ;
#if ENABLE_ZCONST_PATH_DEBUG
for ( const POINTU& ptU : PL.GetUPointList()) {
PtrOwner<IGeoPoint3d> myPt( CreateGeoPoint3d()) ;
myPt->Set( ptU.first) ;
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, myPt->Clone()) ;
m_pGeomDB->SetMaterial( nId, WHITE) ;
}
#endif
// elimino i punti allineati
PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
// sostituisco primo ed ultimo punto con quelli forzati
PL.EraseFirstUPoint() ;
PL.EraseLastUPoint() ;
PL.AddUPoint( 0, ptStartLink, false) ;
PL.AddUPoint( PL.GetPointNbr(), ptEndLink, true) ;
// creo una curva composita a partire dalla polilinea
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( IsNull( pCompo) || ! pCompo->FromPolyLine( PL))
return false ;
#if ENABLE_ZCONST_PATH_DEBUG
nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompo->Clone()) ;
m_pGeomDB->SetMaterial( nId, LIME) ;
#endif
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{
// controllo che la regione sia definita correttamente
if ( pSfrCnt == nullptr || ! pSfrCnt->IsValid())
return false ;
// aggiorno la ProgressBar del 5% per simulare l'inizio della funzione
ExeProcessEvents( 5, 0) ;
// definisco un frame implicito dalla superficie
Frame3d frSfr ;
Point3d ptC ; pSfrCnt->GetCentroid( ptC) ;
if ( ! frSfr.Set( ptC, pSfrCnt->GetNormVersor()))
return false ;
frSfr.ToLoc( frSurf) ; // in locale alle SrfLoc
// aggiusto la regione a seconda dei parametri e la porto nel frame locale delle superfici
// NB. Per rendere questa superficie coerente con le superfici degli altri tipi di lavorazione, devo effettuare un ControOffset
// del raggio utensile. Se la lavorazione fosse a ZigZag le curve si trovano all'interno di questa regione del raggio utensile
// ( questo passaggio è calcolato implicitamente dalla lavorazione di Pocketing ZigZag). Nel caso di Lavorazione a ZLevel bisogna
// aggiungere questo passaggio in modo tale che dalla curva originaria Offsettata del parametro di Overlap, tutto l'utensile stia
// al suo interno.
PtrOwner<ISurfFlatRegion> pSfrClass( pSfrCnt->CreateOffsetSurf( - m_TParams.m_dDiam / 2. + EPS_SMALL, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrClass) || ! pSfrClass->IsValid() || ! pSfrClass->ToLoc( frSurf))
return false ;
// inizializzo la classe di calcolo delle silhouette
CISURFTMPVECTOR vpStm ; vpStm.reserve( vSrfLoc.size()) ;
// scorro le superfici
for ( int i = 0 ; i < ssize( vSrfLoc) ; ++ i) {
// recupero la superficie
const ISurf* pSurf = GetSurf( vSrfLoc[i].Get()) ;
if ( pSurf == nullptr || ! pSurf->IsValid())
continue ;
int nType = pSurf->GetType() ;
// se TriMesh
if ( nType == SRF_TRIMESH) {
const ISurfTriMesh* pStm = GetSurfTriMesh( pSurf) ;
// se valida, memorizzo
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0)
vpStm.emplace_back( pStm) ;
}
// se Bezier
if ( nType == SRF_BEZIER) {
const ISurfBezier* pSBz = GetSurfBezier( pSurf) ;
if ( pSBz != nullptr && pSBz->IsValid()) {
double dOldTol = GetSurfBezierAuxSurfRefinedTol() ;
SetSurfBezierAuxSurfRefinedTol( 5. * EPS_SMALL) ;
const ISurfTriMesh* pStm = pSBz->GetAuxSurfRefined() ;
SetSurfBezierAuxSurfRefinedTol( dOldTol) ;
// se valida, memorizzo
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0)
vpStm.emplace_back( pStm) ;
}
}
}
const double TOL_SAMPLING = 1. ;
PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
if ( IsNull( pCavParSilh) ||
! pCavParSilh->SetData( vpStm, frSfr, TOL_SAMPLING, m_TParams.m_dSideAng, m_TParams.m_dDiam,
m_TParams.m_dCornRad, m_TParams.m_dMaxMat, GetOffsR(), dDepth))
return false ;
// aggiorno la ProgressBar al 30%
ExeProcessEvents( 30, 0) ;
// recupero le curve singole definite dal bordo della Silhouette
vector<ICRVCOMPOPOVECTOR> vCrvCompo ;
if ( ! CalcZConstSilCrv( pCavParSilh, vSrfLoc, frSurf, pSfrClass, vtTool, dDepth, vCrvCompo)) {
m_pMchMgr->SetLastError( 3126, "Error in SurfFinishing : Computing ZConst Curves failed") ;
return false ;
}
// se non ho curve, esco
bool bNoCrv = true ;
for ( int i = 0 ; i < ssize( vCrvCompo) && bNoCrv ; ++ i)
bNoCrv = ( vCrvCompo[i].empty()) ;
if ( bNoCrv)
return true ;
// collego tra loro le curve trovate
ICRVCOMPOPOVECTOR vCrvPath ;
if ( ! CreateZConstPaths( pCAvTlStm, vpStm, frSurf, vCrvCompo, vtTool, pSfrClass, dDepth, vCrvPath)) {
m_pMchMgr->SetLastError( 3127, "Error in SurfFinishing : Computing ZConst Paths failed") ;
return false ;
}
// se non ho percorsi, errore
if ( vCrvPath.empty())
return false ;
ExeProcessEvents( 90, 0) ;
// porto tutti i percorsi in Globale
for ( int i = 0 ; i < ssize( vCrvPath) ; ++ i)
vCrvPath[i]->ToGlob( frSurf) ;
// aggiungo i percorsi di finitura calcolati
if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vCrvPath, vtTool, vtTool, dElev, dDepth, bSplitArcs))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::OrderOptimalPathsByZLoc( const ISurfFlatRegion* pSfrCntZConst, const ISurfFlatRegion* pSfrCntZigZag,
VECTORPATHS& vCrvPaths) const
{
// le curve devono essere tutte valide
for ( const PATH& path : vCrvPaths) {
if ( path.pCrvPath == nullptr || ! path.pCrvPath->IsValid())
return false ;
}
// se ho meno di due percorsi, non faccio nulla
if ( ssize( vCrvPaths) <= 1)
return true ;
// determino il piano contenente la superficie di lavoro ( identico per pSfrCntZigZag e pSfrCntZConst)
Point3d ptCenter ;
Vector3d vtN ;
if ( pSfrCntZigZag != nullptr && pSfrCntZigZag->IsValid()) {
pSfrCntZigZag->GetCentroid( ptCenter) ;
vtN = pSfrCntZigZag->GetNormVersor() ;
}
else if ( pSfrCntZConst != nullptr && pSfrCntZConst->IsValid()) {
pSfrCntZConst->GetCentroid( ptCenter) ;
vtN = pSfrCntZConst->GetNormVersor() ;
}
Plane3d plSfr ;
if ( ! plSfr.Set( ptCenter, vtN))
return false ;
// definisco una mappa [indice curva, ZStart rispetto plSfr, ZEnd rispetto plSfr]
typedef tuple<int, double, double> BoundaryMap ;
vector<BoundaryMap> vBoundaryMap ; vBoundaryMap.reserve( vCrvPaths.size()) ;
for ( int i = 0 ; i < int( vCrvPaths.size()) ; ++ i) {
// recupero gli estremi della curva
Point3d ptS ; vCrvPaths[i].pCrvPath->GetStartPoint( ptS) ;
Point3d ptE ; vCrvPaths[i].pCrvPath->GetEndPoint( ptE) ;
// determino la Z dei punti rispetto al piano
double dZStart = abs( ( DistPointPlane( ptS, plSfr))) ;
double dZEnd = abs( ( DistPointPlane( ptE, plSfr))) ;
// memorizzo i risultati
vBoundaryMap.emplace_back( make_tuple( i, dZStart, dZEnd)) ;
}
// Regole per ordinamento delle curve ricavate
// --- Ordino le curve in base a ptStart crescente rispetto al piano plSfr
const double ZTOL = 10. * EPS_SMALL ;
sort( vBoundaryMap.begin(), vBoundaryMap.end(), [&]( const BoundaryMap& MapA, const BoundaryMap& MapB) {
if ( abs( get<1>( MapA) - get<1>( MapB)) < ZTOL)
return ( get<2>( MapA) < get<2>( MapB)) ;
return ( get<1>( MapA) < get<1>( MapB)) ;
}) ;
// ricerco tutte le mappe alla stessa quota iniziale e le classifico in gruppi ( già ordinati)
vector<vector<BoundaryMap>> vGroups ; vGroups.reserve( vBoundaryMap.size()) ;
vector<BoundaryMap> vCurrGroup ;
double dZRef = get<1>( vBoundaryMap.front()) ;
vCurrGroup.push_back( vBoundaryMap.front()) ;
for ( int i = 1 ; i < ssize( vBoundaryMap) ; ++ i) {
const BoundaryMap& Map = vBoundaryMap[i] ;
double dZStart = get<1>( Map) ;
if ( abs( dZStart - dZRef) < ZTOL)
vCurrGroup.push_back( Map) ;
else {
vGroups.emplace_back( vCurrGroup) ;
vCurrGroup.clear() ;
vCurrGroup.push_back( Map) ;
dZRef = dZStart ;
}
}
vGroups.push_back( vCurrGroup) ; // ultimo gruppo
if ( vGroups.empty())
return true ;
// per ogni mappa di gruppo, riordino per punto di vicinanza
INTVECTOR vFinalOrder ; vFinalOrder.reserve( vCrvPaths.size()) ;
Point3d ptRef ;
{
int nInd0 = get<0>( vGroups[0][0]) ;
vCrvPaths[nInd0].pCrvPath->GetStartPoint( ptRef) ;
}
for ( int i = 0 ; i < ssize( vGroups) ; ++ i) {
vector<BoundaryMap>& vGroup = vGroups[i] ;
int nSize = int( vGroup.size()) ;
BOOLVECTOR vUsed( nSize, false) ;
INTVECTOR vOrderGroup ; vOrderGroup.reserve( nSize) ;
Point3d ptCurr = ptRef ;
for ( int j = 0 ; j < nSize ; ++ j) {
double dMinSqDist = INFINITO ;
int nBestInd = -1 ;
for ( int k = 0 ; k < nSize ; ++ k) {
if ( vUsed[k])
continue ;
int nInd = get<0>( vGroup[k]) ;
Point3d ptStart ;
vCrvPaths[nInd].pCrvPath->GetStartPoint( ptStart) ;
double dSqDist = SqDist( ptCurr, ptStart) ;
if ( dSqDist < dMinSqDist) {
dMinSqDist = dSqDist ;
nBestInd = k ;
}
}
vUsed[nBestInd] = true ;
int nRealIdBest = get<0>( vGroup[nBestInd]) ;
vOrderGroup.push_back( nRealIdBest) ;
Point3d ptEnd ;
vCrvPaths[nRealIdBest].pCrvPath->GetEndPoint( ptEnd) ;
ptCurr = ptEnd ;
}
// aggiugno al vettore finale
for ( int nInd : vOrderGroup)
vFinalOrder.push_back( nInd) ;
// aggiorno ptRef
Point3d ptEndLast ;
vCrvPaths[vOrderGroup.back()].pCrvPath->GetEndPoint( ptEndLast) ;
ptRef = ptEndLast ;
}
// ricostruisco i percorsi finali
VECTORPATHS vTmp ; vTmp.resize( vCrvPaths.size()) ;
for ( int i = 0; i < ssize( vFinalOrder) ; ++i) {
int nInd = vFinalOrder[i] ;
vTmp[i].pCrvPath.Set( Release( vCrvPaths[nInd].pCrvPath)) ;
vTmp[i].nType = vCrvPaths[nInd].nType ;
}
swap(vCrvPaths, vTmp) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::OrderOptimalPathsByDistance( const Point3d& ptRef, VECTORPATHS& vCrvPaths, bool bAllowInvert) const
{
// il punto di riferimento deve essere valido
if ( ! ptRef.IsValid())
return false ;
// le curve devono essere tutte valide
for ( const PATH& path : vCrvPaths) {
if ( path.pCrvPath == nullptr || ! path.pCrvPath->IsValid())
return false ;
}
// se ho meno di due percorsi, non faccio nulla
if ( ssize( vCrvPaths) <= 1)
return true ;
// ordino i percorsi per vicinananza
BIPNTVECTOR vPtStartEnd ; vPtStartEnd.reserve( vCrvPaths.size()) ;
for ( int i = 0 ; i < ssize( vCrvPaths) ; ++ i) {
vPtStartEnd.emplace_back( BIPOINT()) ;
vCrvPaths[i].pCrvPath->GetStartPoint( vPtStartEnd.back().first) ;
vCrvPaths[i].pCrvPath->GetEndPoint( vPtStartEnd.back().second) ;
}
Point3d ptRefCurr = ptRef ;
for ( int nCount = 0 ; nCount < ssize( vCrvPaths) ; ++ nCount) {
double dSqMinDist = INFINITO - 1 ;
int nBestIndex = nCount ;
bool bStartVsEnd = true ;
for ( int i = nCount ; i < ssize( vCrvPaths) ; ++ i) {
double dSqCurrDistStart = SqDist( ptRefCurr, vPtStartEnd[i].first) ;
double dSqCurrDistEnd = ( bAllowInvert ? SqDist( ptRefCurr, vPtStartEnd[i].second) : INFINITO) ;
if ( dSqCurrDistStart < dSqMinDist) {
dSqMinDist = dSqCurrDistStart ;
nBestIndex = i ;
bStartVsEnd = true ;
}
if ( bAllowInvert && dSqCurrDistEnd < dSqMinDist) {
dSqMinDist = dSqCurrDistEnd ;
nBestIndex = i ;
bStartVsEnd = false ;
}
}
if ( bAllowInvert && ! bStartVsEnd) {
vCrvPaths[nBestIndex].pCrvPath->Invert() ;
swap( vPtStartEnd[nBestIndex].first, vPtStartEnd[nBestIndex].second) ; // in realtà questa riga non serve...
}
vCrvPaths[nBestIndex].pCrvPath->GetEndPoint( ptRefCurr) ;
swap( vCrvPaths[nBestIndex], vCrvPaths[nCount]) ;
swap( vPtStartEnd[nBestIndex], vPtStartEnd[nCount]) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::OrderAndConnectPencilCurves( ICRVCOMPOPOVECTOR& vCrvCompo, double dLinkTol) const
{
// elimino tutte le curve invalide
for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
if ( vCrvCompo[i] == nullptr || ! vCrvCompo[i]->IsValid() || vCrvCompo[i]->GetCurveCount() == 0) {
vCrvCompo.erase( vCrvCompo.begin() + i) ;
-- i ;
}
}
// se ho meno di 2 curve da ordinare, non faccio nulla
if ( int( vCrvCompo.size()) < 2)
return true ;
// vettore dei quadrati delle distanze
DBLVECTOR vdMinSqDist( vCrvCompo.size(), INFINITO) ;
// ---- ordino le curve in base al punto iniziale della corrente ----
// NB. punto iniziale, non finale !
for ( int i = 0 ; i < int( vCrvCompo.size()) - 1 ; ++ i) {
Point3d ptRef ; vCrvCompo[i]->GetStartPoint( ptRef) ;
int nMinInd = i + 1 ;
for ( int j = i + 1 ; j < int( vCrvCompo.size()) ; ++ j) {
// se chiusa, cambio il suo punto iniziale in quello più vicino alla curva corrente
if ( vCrvCompo[j]->IsClosed()) {
double dU ;
int nFlag = 0 ;
if ( DistPointCurve( ptRef, *vCrvCompo[j]).GetParamAtMinDistPoint( 0., dU, nFlag))
vCrvCompo[j]->ChangeStartPoint( dU) ;
}
Point3d ptCheck ; vCrvCompo[j]->GetStartPoint( ptCheck) ;
double dSqDist = SqDist( ptRef, ptCheck) ;
if ( dSqDist < vdMinSqDist[i]) {
vdMinSqDist[i] = dSqDist ;
nMinInd = j ;
}
}
swap( vCrvCompo[i + 1], vCrvCompo[nMinInd]) ;
}
// controllo la distanza tra le curve ordinate, se accettabile, collegamento lineare
ICRVCOMPOPOVECTOR vCrvCompoOrdered ; vCrvCompoOrdered.reserve( vCrvCompo.size()) ;
bool bNewPath = true ;
for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
if ( bNewPath) {
vCrvCompoOrdered.emplace_back( Release( vCrvCompo[i])) ;
bNewPath = false ;
}
else {
Point3d ptCurr ; vCrvCompo[i]->GetStartPoint( ptCurr) ;
vCrvCompoOrdered.back()->AddLine( ptCurr) ;
vCrvCompoOrdered.back()->AddCurve( Release( vCrvCompo[i])) ;
}
bNewPath = ( vdMinSqDist[i] > dLinkTol * dLinkTol) ;
}
swap( vCrvCompo, vCrvCompoOrdered) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetOffsetCurvesFromPencilProjection( const ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfrClass,
double dOffs, int nPencilType, ICRVCOMPOPOVECTOR& vCrvCompoRes) const
{
// se non ho curve, non faccio nulla
if ( vCrvCompo.empty())
return true ;
// se non ho una superficie di classificazione non faccio nulla
if ( pSfrClass == nullptr || ! pSfrClass->IsValid())
return true ;
// se pencil Singola o multipla
if ( nPencilType == PENCIL_CORNER || nPencilType == PENCIL_FAT_CORNER) {
// calcolo le curve di Offset
ICURVEPVECTOR vCrv ; vCrv.reserve( vCrvCompo.size()) ;
for ( const auto& pCompo : vCrvCompo) {
// considero la curva solo se valida
if ( pCompo != nullptr && pCompo->IsValid() && pCompo->GetCurveCount() > 0)
if ( ! vCrv.emplace_back( CloneCurveComposite( pCompo))) {
for ( auto& pCrv : vCrv) { delete( pCrv) ; pCrv = nullptr ;}
return false ;
}
}
ICURVEPOVECTOR vCrvOffs ;
if ( nPencilType == PENCIL_CORNER) {
if ( ! CalcOffsetCurves( vCrv, vCrvOffs, dOffs)) {
for ( auto& pCrv : vCrv) { delete( pCrv) ; pCrv = nullptr ;}
return false ;
}
}
else if ( nPencilType == PENCIL_FAT_CORNER) {
if ( ! CalcFatOffsetCurves( vCrv, vCrvOffs, dOffs, false, false, false)) {
for ( auto& pCrv : vCrv) { delete( pCrv) ; pCrv = nullptr ;}
return false ;
}
}
for ( auto& pCrv : vCrv) { delete( pCrv) ; pCrv = nullptr ;}
for ( auto& pCrv : vCrvOffs)
vCrvCompoRes.emplace_back( ConvertCurveToComposite( Release( pCrv))) ;
// classifico le curve tenendo solo le parti interne alla superficie
ICRVCOMPOPOVECTOR vCrvCompoInSfr ;
for ( const auto& pCrvCompo : vCrvCompoRes) {
// se curva non valida, passo alla successiva
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
continue ;
CRVCVECTOR ccClass ;
if ( pSfrClass->GetCurveClassification( *pCrvCompo, EPS_SMALL, ccClass)) {
for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) {
if ( ccClass[i].nClass != CRVC_OUT) {
PtrOwner<ICurveComposite> pMyCompo( ConvertCurveToComposite( pCrvCompo->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE))) ;
if ( ! IsNull( pMyCompo) && pMyCompo->IsValid()) {
if ( ! vCrvCompoInSfr.emplace_back( Release( pMyCompo)))
return false ;
}
}
}
}
}
swap( vCrvCompoInSfr, vCrvCompoRes) ;
}
// se pencil per regione a ZigZag
else if ( nPencilType == PENCIL_REGION) {
// definisco la regione di Offset per percorsi a ZigZag
PtrOwner<ISurfFlatRegion> pSfrZigZag( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrZigZag))
return false ;
// aggiungo le regioni di Fat curve
for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
PtrOwner<ISurfFlatRegion> pSfrFat( GetSurfFlatRegionFromFatCurve( vCrvCompo[i]->Clone(), dOffs + m_TParams.m_dDiam / 2., false, false)) ;
if ( ! IsNull( pSfrFat) && pSfrFat->IsValid()) {
if ( IsNull( pSfrZigZag) || ! pSfrZigZag->IsValid())
pSfrZigZag.Set( Release( pSfrFat)) ;
else
pSfrZigZag->Add( *pSfrFat) ;
}
}
// limito la superficie con la regione di contenimento
if ( ! IsNull( pSfrZigZag) && pSfrZigZag->IsValid()) {
if ( ! pSfrZigZag->Intersect( *pSfrClass))
return false ;
}
// creo le curve di finitura a ZigZag
if ( ! IsNull( pSfrZigZag) && pSfrZigZag->IsValid()) {
// scorro i Chunk della regione
for ( int nC = 0 ; nC < pSfrZigZag->GetChunkCount() ; ++ nC) {
// recupero il Chunk
PtrOwner<ISurfFlatRegion> pSfrChunk( pSfrZigZag->CloneChunk( nC)) ;
if ( IsNull( pSfrChunk) || ! pSfrChunk->IsValid())
return false ;
// considero il Chunk come tutto chiuso
for ( int nL = 0 ; nL < pSfrChunk->GetLoopCount( 0) ; ++ nL) {
for ( int nU = 0 ; nU < pSfrChunk->GetLoopCurveCount( 0, nL) ; ++ nU)
pSfrChunk->SetCurveTempProp( 0, nL, nU, TEMP_PROP_CLOSE_EDGE, 0) ;
}
// lavoro a ZigZag
ICRVCOMPOPOVECTOR vCrvZigZag ;
if ( ! CalcPocketing( pSfrChunk, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, m_Params.m_dSideAngle,
5., POCKET_SUB_ZIGZAG, false, false, m_Params.m_bInvert, true, true, false, false,
false, P_INVALID, nullptr, true, INFINITO, GetLeadInType(), m_Params.m_dLiTang, 0.,
GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., false, vCrvZigZag))
return false ;
// inserisco le curve ricavate
for ( auto& pCompo : vCrvZigZag) {
if ( pCompo != nullptr && pCompo->IsValid())
vCrvCompoRes.emplace_back( Release( pCompo)) ;
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::ProjectExposedPencilCurvesOnPlane( ICAvToolSurfTm* pCAvTlStm, const ICRVCOMPOPOVECTOR& vCrvCompo,
const Plane3d& plProj, const Vector3d& vtAxL, const Vector3d& vtMoveL,
double dOffs, double dDepth, ICRVCOMPOPOVECTOR& vCrvCompoProj) const
{
// se classe di collisione non valida, errore
if ( pCAvTlStm == nullptr)
return false ;
vCrvCompoProj.clear() ;
// se non ho curve da proeittare, non faccio nulla
if ( vCrvCompo.empty())
return true ;
// definisco la tolleranza di campionamento
double dSampleTol = m_Params.m_dApprox ;
// scorro le curve
for ( const auto& pCrvCompo : vCrvCompo) {
// se la curva non è valida, passo alla successiva
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
continue ;
// memorizzo le entità Geometriche
Vector3d vtExtr ; pCrvCompo->GetExtrusion( vtExtr) ;
int nProp0 = pCrvCompo->GetTempProp( 0) ;
int nProp1 = pCrvCompo->GetTempProp( 1) ;
double dPar0 = pCrvCompo->GetTempParam( 0) ;
double dPar1 = pCrvCompo->GetTempParam( 1) ;
// approssimo, campiono e traslo la curva per calcolare le collisioni
PolyLine PL ;
pCrvCompo->ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL) ;
PL.AdjustForMaxSegmentLen( dSampleTol) ;
PL.Translate( vtAxL * m_TParams.m_dLen) ;
if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, dSampleTol))
return false ;
#if ENABLE_PENCIL_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "pencil_PointCollision") ;
int nLayId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetStatus( nLayId, GDB_ST_OFF) ;
// contro-traslo i punti per renderli riportarli in posizione originale
// ( dU mi dice di quanto alzarli per evitare la collisione con la superficie)
PolyLine PL_debug = PL ;
for ( auto& ptU : PL_debug.GetUPointList())
ptU.first.Translate( - vtAxL * ( m_TParams.m_dLen + ptU.second)) ;
double dUmin = INFINITO ;
double dUMax = - INFINITO ;
for ( POINTU& ptU : PL_debug.GetUPointList()) {
if ( ptU.second > dUMax)
dUMax = ptU.second ;
if ( ptU.second < dUmin)
dUmin = ptU.second ;
}
for ( POINTU& ptU : PL_debug.GetUPointList()) {
double myAngle = 240 + 120 * ( ptU.second / ( dUMax - dUmin)) ;
IGeoPoint3d* pt = CreateGeoPoint3d() ; pt->Set( ptU.first) ;
int nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, pt) ;
m_pGeomDB->SetInfo( nPtId, "dU", ToString( ptU.second)) ;
m_pGeomDB->SetMaterial( nPtId, Color( GetColorFromHSV( HSV( myAngle, 1., 1.)))) ;
}
#endif
// elimino tutti i punti che si trovano ad una profondità inferiore di dDepth
// elimino tutti i punti che presentano un dU > 2 * dOffs
bool bFirst = true ;
POLYLINEVECTOR vPLTemp ;
for ( auto& ptU : PL.GetUPointList()) {
if ( ptU.second < 2. * dOffs + EPS_SMALL &&
DistPointPlane( ptU.first - vtAxL * ( m_TParams.m_dLen + ptU.second), plProj) < dDepth + EPS_ZERO) {
if ( bFirst) {
vPLTemp.emplace_back( PolyLine()) ;
bFirst = false ;
}
vPLTemp.back().AddUPoint( 0., ptU.first) ;
}
else
bFirst = true ;
}
// elimino le PolyLine invalide e proietto i punti sul piano della pSfrCnt
for ( int i = 0 ; i < int( vPLTemp.size()) ; ++ i) {
if ( vPLTemp[i].GetPointNbr() < 2) {
vPLTemp.erase( vPLTemp.begin() + i) ;
-- i ;
}
else {
for ( auto& ptU : vPLTemp[i].GetUPointList())
ptU.first = ProjectPointOnPlane( ptU.first, plProj) ;
}
}
// per le PolyLine rimanenti, definisco le curve
for ( int i = 0 ; i < int( vPLTemp.size()) ; ++ i) {
// recupero la PolyLine corrente
PolyLine& PL = vPLTemp[i] ;
// rimuovo i punti allineati
PL.RemoveAlignedPoints( dSampleTol) ;
// definisco una curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo) || ! pCrvCompo->FromPolyLine( PL)) {
m_pMchMgr->SetWarning( 3155, "Warning in SurfFinishing : Pencil path not completed") ;
continue ;
}
// se la curva risultate è valida
if ( pCrvCompo->IsValid()) {
// -- TODO -- controllo eventuali auto-intersezioni nel piano (?)
// imposto i parametri temporanei
pCrvCompo->SetExtrusion( vtExtr) ;
pCrvCompo->SetTempProp( nProp0, 0) ;
pCrvCompo->SetTempProp( nProp1, 1) ;
pCrvCompo->SetTempParam( dPar0, 0) ;
pCrvCompo->SetTempParam( dPar1, 1) ;
// memorizzo la curva ricavata
vCrvCompoProj.emplace_back( Release( pCrvCompo)) ;
}
}
}
// concateno le curve
return ( ChainPencilCurves( vCrvCompoProj, 10 * dSampleTol, false)) ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::WorkPencilCurves( const ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfrCnt, int nPencilType, double dOffs, int nOffs,
double dDepth, double dElev, double dLinTol, const Vector3d& vtTool, const SURFLOCALVECTOR& vSrfLoc,
const Frame3d& frSurf, ICAvToolSurfTm* pCAvTlStm, bool bSplitArcs)
{
// se non ho curve da proiettare, non faccio nulla
if ( vCrvCompo.empty())
return true ;
// se regione non valida, errore
if ( pSfrCnt == nullptr || ! pSfrCnt->IsValid())
return false ;
// porto i dati geometrici in locale alle superfici
Vector3d vtAxL = vtTool ;
vtAxL.ToLoc( frSurf) ;
Vector3d vtMoveL = vtAxL ;
// Data l'approssimazione lineare di una TriMesh considero il calcolo delle collisioni con
// un utensile leggermente più piccolo
PtrOwner<ICAvToolSurfTm> pCAvTlStm_Smaller( CreateCAvToolSurfTm()) ;
if ( IsNull( pCAvTlStm_Smaller) ||
! SetCAvTlStmForSurfaces( pCAvTlStm_Smaller, pSfrCnt, dDepth, m_TParams.m_dLen,
m_TParams.m_dDiam - 100 * EPS_SMALL, m_TParams.m_dCornRad, m_TParams.m_dSideAng,
m_TParams.m_dMaxMat, GetOffsR(), vSrfLoc, SURFLOCALVECTOR{}))
return false ;
// definisco il piano di pSfrCnt in locale alle superfici
Point3d ptCen ; pSfrCnt->GetCentroid( ptCen) ;
ptCen.ToLoc( frSurf) ;
Plane3d plProj ;
if ( ! plProj.Set( ptCen, vtAxL))
return false ;
// proietto le curve visibili dalla pSfrCnt rispetto a vtTool sul piano calcolato
ICRVCOMPOPOVECTOR vCrvCompoProj ;
if ( ! ProjectExposedPencilCurvesOnPlane( pCAvTlStm_Smaller, vCrvCompo, plProj, vtAxL, vtMoveL, dOffs, dDepth, vCrvCompoProj))
return false ;
// se non ho curve, non faccio nulla
if ( vCrvCompoProj.empty()) {
m_pMchMgr->SetWarning( 3152, "Warning in SurfFinishing : No machinable path") ;
return true ;
}
#if ENABLE_PENCIL_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "pencil_CompoProj") ;
int nLayId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetStatus( nLayId, GDB_ST_OFF) ;
for ( const auto& pCompo : vCrvCompoProj) {
int nCrvId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, pCompo->Clone()) ;
m_pGeomDB->SetMaterial( nCrvId, LIME) ;
}
#endif
// definisco la superficie di classificazione delle curve
double dRegOffs = - m_TParams.m_dDiam / 2. + m_Params.m_dOverlap + 2 * EPS_SMALL ;
PtrOwner<ISurfFlatRegion> pSfrClass( pSfrCnt->CreateOffsetSurf( dRegOffs, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrClass))
return false ;
if ( ! pSfrClass->IsValid())
return true ;
pSfrClass->ToLoc( frSurf) ;
// vettore di Curve pencil proiettate all'interno della regione di classifiazione
ICRVCOMPOPOVECTOR vCrvCompoInSfr ;
// se Pencil singola o multipla
if ( nPencilType == PENCIL_CORNER || nPencilType == PENCIL_FAT_CORNER) {
// per ogni step di Offset...
for ( int i = 0 ; i < nOffs ; ++ i) {
// calcolo le curve di Offset
ICRVCOMPOPOVECTOR vCrvCompoInSfrInStep ;
if ( ! GetOffsetCurvesFromPencilProjection( vCrvCompoProj, pSfrClass, i * m_Params.m_dSideStep, nPencilType, vCrvCompoInSfrInStep))
return false ;
// concateno le curve ottenute
if ( ! ChainPencilCurves( vCrvCompoInSfrInStep, min( m_Params.m_dSideStep / 2., dLinTol), false))
return false ;
// memorizzo le curve
for ( auto& pCrvCompo : vCrvCompoInSfrInStep) {
if ( pCrvCompo != nullptr && pCrvCompo->IsValid()) {
if ( ! vCrvCompoInSfr.emplace_back( Release( pCrvCompo)))
return false ;
}
}
}
// concateno ed unisco eventuali Offset
double dLinkTol = 0 ;
if ( nOffs > 1)
dLinkTol = SQRT2 * m_Params.m_dSideStep + 10 * EPS_SMALL ;
if ( ! OrderAndConnectPencilCurves( vCrvCompoInSfr, dLinkTol))
return false ;
}
// se Pencil per regioni a ZigZag
else if ( nPencilType == PENCIL_REGION) {
// calcolo le curve di Offset
if ( ! GetOffsetCurvesFromPencilProjection( vCrvCompoProj, pSfrClass, nOffs, nPencilType, vCrvCompoInSfr))
return false ;
}
// se nessuna curva rimanente, non faccio nulla
if ( vCrvCompoInSfr.empty()) {
m_pMchMgr->SetWarning( 3152, "Warning in SurfFinishing : No machinable path") ;
return true ;
}
// lavoro le curve
for ( const auto& pCrvCompo : vCrvCompoInSfr) {
if ( pCrvCompo != nullptr && pCrvCompo->IsValid()) {
pCrvCompo->ToGlob( frSurf) ;
if ( ! AddProjection( pCAvTlStm, vSrfLoc, frSurf, pCrvCompo, vtTool, vtTool, dDepth, dElev, bSplitArcs))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::ChainPencilCurves( ICRVCOMPOPOVECTOR& vCrvCompo, double dLinTol, bool bAllowInvert) const
{
// se non ho curve da lavorare, non faccio nulla
if ( vCrvCompo.empty())
return true ;
/* Algoritmo : scorro le curve e se ricavo due estremi più vicini della tolleranza li concatento
* andando ad aggiungere il punto medio tra i due.
* Se due curve vengono concatenate, l'algoritmo riparte.
* Se nessuna curva viene conatenata, l'algoritmo termina.
* [ numero massimo di iterazioni definito da MAXITER]
- Ad una curva chiusa non si concatenano altre curve.
- Se due curve possono essere concatenate, ma l'estremo di una di esse che non
è coinvolto dal concatenamento tocca l'altra curva, esse non vengono concatenate */
bool bFinish = false ;
const int MAXITER = 10000 ;
int nIter = 0 ;
while ( ! bFinish && nIter < MAXITER) {
// scorro le curve
bool bJoint = false ;
for ( int i = 0 ; i < int( vCrvCompo.size()) - 1 && ! bJoint ; ++ i) {
// se curva i-esima chiusa, non faccio nulla
if ( vCrvCompo[i]->IsClosed())
continue ;
// recupero gli estremi della curva i-esima
Point3d ptStart_i ; vCrvCompo[i]->GetStartPoint( ptStart_i) ;
Point3d ptEnd_i ; vCrvCompo[i]->GetEndPoint( ptEnd_i) ;
for ( int j = i + 1 ; j < int( vCrvCompo.size()) && ! bJoint ; ++ j) {
// se curva j-esima chiusa, non faccio nulla
if ( vCrvCompo[j]->IsClosed())
continue ;
// recupero gli estremi della curva j-esima
Point3d ptStart_j ; vCrvCompo[j]->GetStartPoint( ptStart_j) ;
Point3d ptEnd_j ; vCrvCompo[j]->GetEndPoint( ptEnd_j) ;
// controllo se i punti sono vicino tra loro
if ( AreSamePointEpsilon( ptStart_i, ptEnd_j, dLinTol)) {
// controllo che il punto finale della curva i-esima sia distante dalla j-esima
double dSqDist = 0. ;
if ( DistPointCurve( ptEnd_i, *vCrvCompo[j]).GetSqDist( dSqDist) &&
dSqDist < dLinTol * dLinTol)
continue ;
Point3d ptMid = Media( ptStart_i, ptEnd_j) ;
vCrvCompo[i]->ModifyStart( ptMid) ;
vCrvCompo[j]->ModifyEnd( ptMid) ;
vCrvCompo[j]->AddCurve( Release( vCrvCompo[i])) ;
vCrvCompo.erase( vCrvCompo.begin() + i) ;
bJoint = true ;
}
else if ( bAllowInvert && AreSamePointEpsilon( ptStart_i, ptStart_j, dLinTol)) {
// controllo che il punto finale della curva i-esima sia distante dalla j-esima
double dSqDist = 0. ;
if ( DistPointCurve( ptEnd_i, *vCrvCompo[j]).GetSqDist( dSqDist) &&
dSqDist < dLinTol * dLinTol)
continue ;
Point3d ptMid = Media( ptStart_i, ptStart_j) ;
vCrvCompo[i]->ModifyStart( ptMid) ;
vCrvCompo[j]->ModifyStart( ptMid) ;
vCrvCompo[j]->Invert() ;
vCrvCompo[j]->AddCurve( Release( vCrvCompo[i])) ;
vCrvCompo.erase( vCrvCompo.begin() + i) ;
bJoint = true ;
}
else if ( bAllowInvert && AreSamePointEpsilon( ptEnd_i, ptEnd_j, dLinTol)) {
// controllo che il punto inziale della curva i-esima sia distante dalla j-esima
double dSqDist = 0. ;
if ( DistPointCurve( ptStart_i, *vCrvCompo[j]).GetSqDist( dSqDist) &&
dSqDist < dLinTol * dLinTol)
continue ;
Point3d ptMid = Media( ptEnd_i, ptEnd_j) ;
vCrvCompo[i]->ModifyEnd( ptMid) ;
vCrvCompo[j]->ModifyEnd( ptMid) ;
vCrvCompo[j]->Invert() ;
vCrvCompo[i]->AddCurve( Release( vCrvCompo[j])) ;
vCrvCompo.erase( vCrvCompo.begin() + j) ;
bJoint = true ;
}
else if ( AreSamePointEpsilon( ptEnd_i, ptStart_j, dLinTol)) {
// controllo che il punto inziale della curva i-esima sia distante dalla j-esima
double dSqDist = 0. ;
if ( DistPointCurve( ptStart_i, *vCrvCompo[j]).GetSqDist( dSqDist) &&
dSqDist < dLinTol * dLinTol)
continue ;
Point3d ptMid = Media( ptEnd_i, ptStart_j) ;
vCrvCompo[i]->ModifyEnd( ptMid) ;
vCrvCompo[j]->ModifyStart( ptMid) ;
vCrvCompo[i]->AddCurve( Release( vCrvCompo[j])) ;
vCrvCompo.erase( vCrvCompo.begin() + j) ;
bJoint = true ;
}
}
}
bFinish = ( ! bJoint) ;
++ nIter ;
}
// controllo se le curve ricavate sono troppo corte e se posso chiuderle
for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
// se troppo corte le elimino
double dLen = 0. ;
vCrvCompo[i]->GetLength( dLen) ;
if ( dLen < dLinTol + EPS_ZERO) {
vCrvCompo.erase( vCrvCompo.begin() + i) ;
-- i ;
}
else if ( vCrvCompo[i]->GetCurveCount() > 1) {
Point3d ptStart ; vCrvCompo[i]->GetStartPoint( ptStart) ;
Point3d ptEnd ; vCrvCompo[i]->GetEndPoint( ptEnd) ;
// se estremi vicini, li unisco chiudendo la curva
if ( AreSamePointEpsilon( ptStart, ptEnd, dLinTol)) {
Point3d ptMid = Media( ptStart, ptEnd) ;
vCrvCompo[i]->ModifyStart( ptMid) ;
vCrvCompo[i]->ModifyEnd( ptMid) ;
vCrvCompo[i]->Close() ; // non dovrebbe fare nulla
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetSurfTriMeshFromOffset( const SURFLOCALVECTOR& vSrfLoc, double dOffs,
double dLinTol, ISurfTriMesh* pStmOffs) const
{
// controllo dei parametri
if ( pStmOffs == nullptr)
return false ;
// se non ho superfici non faccio nulla
if ( vSrfLoc.empty())
return true ;
// recupero il vettore di superfici chiuse
CISURFTMPVECTOR vStmClosed ; vStmClosed.reserve( vSrfLoc.size()) ;
for ( const SurfLocal& Surf : vSrfLoc) {
const ISurfTriMesh* pStm = GetSurfTriMesh( Surf.Get()) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->IsClosed())
vStmClosed.push_back( pStm) ;
}
// Offset della superficie TriMesh
PtrOwner<ISurfTriMesh> pMyStmOffs( CreateSurfTriMeshesOffset( vStmClosed, dOffs, dLinTol)) ;
if ( ! IsNull( pMyStmOffs) && pMyStmOffs->IsValid() && pMyStmOffs->GetTriangleCount() > 0)
pStmOffs->CopyFrom( pMyStmOffs) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetCurvesFromSurfTriMeshesOffset( const ISurfTriMesh* pStmOffs, double dBiTanAng, double dLinTol,
int nOffs, const ISurfFlatRegion* pSfrCntLoc, ICRVCOMPOPOVECTOR& vCrvCompo)
{
// se superficie non valida non faccio nulla
vCrvCompo.clear() ;
if ( pStmOffs == nullptr)
return false ;
if ( ! pStmOffs->IsValid() || pStmOffs->GetTriangleCount() == 0)
return true ;
// predispongo il concatenamento ( ammettendo inversione dei segmenti)
ChainCurves chainC ;
chainC.Init( true, EPS_SMALL, pStmOffs->GetEdgeCount()) ;
// definisco una struttura per informazioni geometriche
struct EdgeInfo {
int nE ;
Point3d ptP1, ptP2 ;
EdgeInfo( int nEdge, const Point3d& PointP1, const Point3d& PointP2)
: nE( nEdge), ptP1( PointP1), ptP2( PointP2) {}
} ;
// scorro gli Edge della superficie
vector<EdgeInfo> vEdgeInfo ; vEdgeInfo.reserve( pStmOffs->GetEdgeCount()) ;
for ( int nE = 0 ; nE < pStmOffs->GetEdgeCount() ; ++ nE) {
// recupero gli estremi e l'angolo dell'Edge corrente
Point3d ptP1, ptP2 ;
double dAng ;
if ( ! pStmOffs->GetEdge( nE, ptP1, ptP2, dAng))
return false ;
// se angolo al di fuori della tolleranza, passo all'Edge successivo
if ( dAng > - ( ANG_STRAIGHT - dBiTanAng))
continue ;
// se triangoli flippati non li considero ( possibili errore su TriMesh di Offset)
// NB. ---- TODO migliorare ricostruzione TriMesh da VolZMap
if ( dAng < - ANG_STRAIGHT + EPS_ANG_SMALL || dAng > ANG_STRAIGHT - EPS_ANG_SMALL)
continue ;
// se Edge parallelo alla direzione utensile, lo scarto
Vector3d vtEdgeDir = ptP2 - ptP1 ;
vtEdgeDir.Normalize() ;
if ( AreSameOrOppositeVectorEpsilon( vtEdgeDir, pSfrCntLoc->GetNormVersor(), 10 * EPS_SMALL))
continue ;
// memorizzo le entità geometriche ricavate
vEdgeInfo.emplace_back( nE, ptP1, ptP2) ;
// inserisco i punti estremi e i versori tangenti nel classe di concatenamento
chainC.AddCurve( int( vEdgeInfo.size()), ptP1, vtEdgeDir, ptP2, vtEdgeDir) ;
}
// inizializzo il piano definito dalla superficie locale di contenimento
/* NB. I singoli tratti ottenuti analizzando gli Edges della superficie TriMesh sono orientati
* in base al triangolo preso di riferimento. Riconcatendando questi segmenti in una curva
* composita singola nello spazio 3d bisogna definire il suo orientamento in modo opportuno.
* --> Fruttando la superficie di contenimento ( definita quindi con normale pari a vtTool)
* è possibile proeittare le curve nel piano e definire la loro estrusione ( +/- vtTool)
e il loro orientamento ( CW/CCW) analizzando le normali dei triangoli della TriMesh */
Point3d ptSfrC ; pSfrCntLoc->GetCentroid( ptSfrC) ;
Vector3d vtN = pSfrCntLoc->GetNormVersor() ;
Plane3d plProj ;
if ( ! plProj.Set( ptSfrC, vtN))
return false ;
// recupero i contorni ( fermandomi a tutte le biforcazioni nello spazio 3d)
INTVECTOR vnId ;
while ( chainC.GetChainFromNear( ORIG, true, vnId)) {
// creo una composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// scorro i tratti mediante gli indici
for ( int i = 0 ; i < int( vnId.size()) ; ++ i) {
int nId = abs( vnId[i]) - 1 ;
bool bInvert = ( vnId[i] < 0) ;
if ( bInvert)
swap( vEdgeInfo[nId].ptP1, vEdgeInfo[nId].ptP2) ;
// aggiungo il segmento alla composita
if ( i == 0)
pCrvCompo->AddPoint( vEdgeInfo[nId].ptP1) ;
pCrvCompo->AddLine( vEdgeInfo[nId].ptP2) ;
}
// se curva valida, la oriento ( CW/CCW)
if ( pCrvCompo->IsValid() && pCrvCompo->GetCurveCount() > 0) {
// proietto la curva sul piano definito precedentemente
PtrOwner<ICurve> pCrvProj( ProjectCurveOnPlane( *pCrvCompo, plProj)) ;
if ( ! IsNull( pCrvProj) && pCrvProj->IsValid()) {
/* La curva originaria nello spazio 3d è l'insieme dei tratti lineare definiti dagli
* Edges della superficie TriMesh che hanno superato il filtro sull'angolo di bitangenza.
* Dato che un Edge è sempre definito tra due facce della TriMesh, è possibile calcolare
* il versore medio tra le due normali e, nel riferimento di vtTool, controllare verso che
* lato punta rispetto alla curva proeittata */
// numero di segmenti che compongono la curva 3d
int nSeg = int( vnId.size()) ;
// numero di segmenti ( dispari) che analizzo per la decisione del verso di percorrenza
int nSampleEdges = min( 5, nSeg + ( IsEven( nSeg) ? 1 : 0)) ;
// contatore di posizioni MDS_RIGHT associanti al numero di segmenti scelto
int nSideRight = 0 ;
for ( int j = 0 ; j < nSampleEdges ; ++ j) {
// recupero le geometrie del segmento scelto
int nInd = ( nSeg + j * nSampleEdges) % nSeg ;
const EdgeInfo& EdgeRef = vEdgeInfo[abs( vnId[nInd])] ;
int nV1, nV2 ;
int nF1, nF2 ;
double dAng ;
Vector3d vtN1, vtN2 ;
if ( ! pStmOffs->GetEdge( EdgeRef.nE, nV1, nV2, nF1, nF2, dAng) ||
! pStmOffs->GetFacetNormal( nF1, vtN1) ||
! pStmOffs->GetFacetNormal( nF2, vtN2))
return false ;
// calcolo la media tra le normali delle due facce che lo definiscono
Vector3d vtM = SQRT1_2 * ( vtN1 + vtN2) ;
// recupero la componente ortogonale a vtTool
Vector3d vtMProj = OrthoCompo( vtM, vtN) ;
// prendo il punto medio dell'Edge scelto e lo sposto leggermente lungo vtMProj, proeitto poi
// tale punto sul piano definito dalla superficie di contenimento ( piano su cui è proiettata
// la curva 3d in esame)
// NB. vtMProj è un versore che, osservato dal piano di proiezione, punta verso l'esterno della TriMesh
Point3d ptCheck = ProjectPointOnPlane( Media( EdgeRef.ptP1, EdgeRef.ptP2) + 50 * EPS_SMALL * vtMProj, plProj) ;
// se il punto si trova alla sua destra, incremento il contatore
int nSide ;
if ( DistPointCurve( ptCheck, *pCrvProj).GetSideAtMinDistPoint( 0., vtN, nSide) &&
nSide == MDS_RIGHT)
++ nSideRight ;
}
// come estrusione alla curva 3d assegno il versore utensile
pCrvCompo->SetExtrusion( vtN) ;
// inverto la curva se i punti di campionamento sono stati trovati alla sua destra
// NB. La curva 3d deve mantenere la superficie TriMesh alla sua sinistra ( MSD_LEFT)
if ( nSideRight < int( floor( nSampleEdges / 2.)))
pCrvCompo->Invert() ;
// memorizzo la curva3d orientata
vCrvCompo.emplace_back( Release( pCrvCompo)) ;
}
}
}
#if ENABLE_PENCIL_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "pencil_NOchainedCurves") ;
int nLayId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetStatus( nLayId, GDB_ST_OFF) ;
for ( auto& pCompo : vCrvCompo) {
int nCrvId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, pCompo->Clone()) ;
m_pGeomDB->SetMaterial( nCrvId, Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.)) ;
}
#endif
// controllo se posso allacciare per vicinanza le curve ( diagonale 3d come tolleranza)
return ( ChainPencilCurves( vCrvCompo, SQRT3 * dLinTol, false)) ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddPencil( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
const ISurfFlatRegion* pSfrCnt, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{
// recupero il tipo di Pencil
int nPencilType = PENCIL_CORNER ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_TYPE, nPencilType)) {
if ( nPencilType != PENCIL_CORNER && nPencilType != PENCIL_FAT_CORNER &&
nPencilType != PENCIL_REGION)
return false ;
}
// recupero l'Offset della superficie TriMesh ( e aggiungo una leggera tolleranza)
double dStmOffs = m_TParams.m_dDiam / 2. + 220. * EPS_SMALL ; // [in base a test, modificabile]
// recupero la tolleranza lineare per l'Offset [ 0.5, ...]
double dLinTol = max( 0.5, dStmOffs / 4.) ;
// recupero il numero di passate richieste [1, 100]
int nOffs = 1 ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_STEPNUMBER, nOffs))
nOffs = Clamp( nOffs, 1, 100) ;
// recupero l'angolo di Bitangenza
double dBiTangAng = 120. ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_BITANGANG, dBiTangAng))
dBiTangAng = Clamp( dBiTangAng, 0., 180.) ;
// recupero la superficie di Offset
PtrOwner<ISurfTriMesh> pStmOffs( CreateSurfTriMesh()) ;
if ( IsNull( pStmOffs) ||
! GetSurfTriMeshFromOffset( vSrfLoc, dStmOffs, dLinTol, pStmOffs)) {
m_pMchMgr->SetLastError( 3131, "Error in SurfFinishing : Computing Surface Offset failed") ;
return false ;
}
#if ENABLE_PENCIL_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "pencil_Curves_debug") ;
int nLayId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetStatus( nLayId, GDB_ST_OFF) ;
ISurfTriMesh* pStm = CloneSurfTriMesh( pStmOffs) ;
int nSfrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, pStm->Clone()) ;
m_pGeomDB->SetMaterial( nSfrId, Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.)) ;
#endif
// recupero le curve da seguire
ICRVCOMPOPOVECTOR vCrvCompo ;
PtrOwner<ISurfFlatRegion> pSfrCntLoc( CloneSurfFlatRegion( pSfrCnt)) ;
if ( IsNull( pSfrCntLoc) || ! pSfrCntLoc->IsValid() || ! pSfrCntLoc->ToLoc( frSurf))
return false ;
if ( ! GetCurvesFromSurfTriMeshesOffset( pStmOffs, dBiTangAng, dLinTol, nOffs, pSfrCntLoc, vCrvCompo)) {
m_pMchMgr->SetLastError( 3132, "Error in SurfFinishing : Computing Offset Edges failed") ;
return false ;
}
// se non ho curve, non faccio nulla
if ( vCrvCompo.empty()) {
m_pMchMgr->SetWarning( 3152, "Warning in SurfFinishing : No machinable path") ;
return true ;
}
#if ENABLE_PENCIL_DEBUG
nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "pencil_chainedCurves") ;
nLayId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetStatus( nLayId, GDB_ST_OFF) ;
for ( auto& pCompo : vCrvCompo) {
int nCrvId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayId, pCompo->Clone()) ;
m_pGeomDB->SetMaterial( nCrvId, Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.)) ;
}
#endif
// lavoro le curve ricavate
if ( ! WorkPencilCurves( vCrvCompo, pSfrCnt, nPencilType, dStmOffs, nOffs, dDepth, dElev, dLinTol, vtTool, vSrfLoc, frSurf, pCAvTlStm, bSplitArcs)) {
m_pMchMgr->SetLastError( 3133, "Error in SurfFinishing : Projecting curves on Surface failed") ;
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
int
SurfFinishing::GetOptimalSubType() const
{
// controllo se richiesto altro tipo di lavorazione
int nSubType = POCKET_ZIGZAG ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_OPTIMALTYPE, nSubType)) {
// ammessi ZIG_ZAG, SPIRAL_IN, SPIRAL_OUT
if ( nSubType != POCKET_ZIGZAG && nSubType != POCKET_SPIRALIN && nSubType != POCKET_SPIRALOUT)
nSubType = POCKET_ZIGZAG ;
}
return nSubType ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcOptimalZigZagCurves( ISURFFRPOVECTOR& vSfrZigZagProj, const Frame3d& frSurf, const Vector3d& vtTool,
double dDepth, ICAvToolSurfTm* pCAvTlStm, VECTORPATHS& vPaths) const
{
#if ENABLE_OPTIMAL_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "ZigZag") ;
int nLayPock = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayPock, "Pocket") ;
m_pGeomDB->SetStatus( nLayPock, GDB_ST_OFF) ;
int nLayPockApprox = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayPockApprox, "PocketApprox") ;
m_pGeomDB->SetStatus( nLayPockApprox, GDB_ST_OFF) ;
int nLayCrv = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayCrv, "Curves") ;
m_pGeomDB->SetStatus( nLayCrv, GDB_ST_OFF) ;
int nLaySfrProj = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLaySfrProj, "SfrProj") ;
m_pGeomDB->SetStatus( nLaySfrProj, GDB_ST_OFF) ;
#endif
// controllo se richiesto altro tipo di lavorazione
int nSubType = GetOptimalSubType() ;
// Scorro le superfici presenti
for ( ISurfFlatRegion* pSfrZigZag : vSfrZigZagProj) {
if ( pSfrZigZag == nullptr || ! pSfrZigZag->IsValid())
continue ;
#if ENABLE_OPTIMAL_DEBUG
int nSfrProjId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySfrProj, pSfrZigZag->Clone()) ;
m_pGeomDB->SetMaterial( nSfrProjId, Color( 1., 0., 0., .5)) ;
#endif
// per ogni Chunk della superficie a ZigZag, calcolo le curve di lavoro
ICRVCOMPOPOVECTOR vCrvCompoZigZag ;
for ( int nC = 0 ; nC < pSfrZigZag->GetChunkCount() ; ++ nC) {
// recupero il Chunk corrente
PtrOwner<ISurfFlatRegion> pSfrChunk( pSfrZigZag->CloneChunk( nC)) ;
if ( IsNull( pSfrChunk) || ! pSfrZigZag->IsValid())
return false ;
// la lavorazione corrente deve essere sul bordo di tale regione
for ( int nC = 0 ; nC < pSfrChunk->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfrChunk->GetLoopCount( nC) ; ++ nL) {
for ( int nU = 0 ; nU < pSfrChunk->GetLoopCurveCount( nC, nL) ; ++ nU)
pSfrChunk->SetCurveTempProp( nC, nL, nU, TEMP_PROP_CLOSE_AS_OPEN, 0) ;
}
}
// porto il Chunk in Globale
pSfrChunk->ToGlob( frSurf) ;
// eseguo il calcolo della lavorazione ZigZag
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! CalcPocketing( pSfrChunk, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, GetLocalSideAngle(), 5.,
nSubType, false, false, false, true, true, false, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., false, vpCrvs)) {
m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
return false ;
}
// memorizzo le curve ricavate
for ( int i = 0 ; i < ssize( vpCrvs) ; ++ i) {
#if ENABLE_OPTIMAL_DEBUG
PtrOwner<ICurveComposite> pCompoCL( CloneCurveComposite( vpCrvs[i])) ;
pCompoCL->ToLoc( frSurf) ;
int nCrvId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayPock, ::Release( pCompoCL)) ;
m_pGeomDB->SetMaterial( nCrvId, YELLOW) ;
#endif
vCrvCompoZigZag.emplace_back( Release( vpCrvs[i])) ;
}
}
// porto i dati geometrici in locale alle superfici ( proeittando)
Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
const double MIN_DIST = 1. ;
const double MAX_DIST = 50. ;
double dDist = Clamp( m_Params.m_dApprox, MIN_DIST, MAX_DIST) ;
// ciclo sui percorsi ricavati
double dProgCoeff = 1. / max( static_cast<int>( ssize( vCrvCompoZigZag)), 1) ;
for ( int i = 0 ; i < ssize( vCrvCompoZigZag) ; ++ i) {
// se non valida, passo alla successiva
if ( IsNull( vCrvCompoZigZag[i]) || ! vCrvCompoZigZag[i]->IsValid())
continue ;
// correggo il percorso per non interferire con le superfici
if ( pCAvTlStm != nullptr) {
// approssimo la curva con una polilinea
PolyLine PL ;
if ( ! vCrvCompoZigZag[i]->ApproxWithLines( min( LIN_TOL_FINE, m_Params.m_dApprox), ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL) ||
! PL.AdjustForMaxSegmentLen( dDist))
return false ;
// porto nel riferimento delle superfici
PL.ToLoc( frSurf) ;
#if ENABLE_OPTIMAL_DEBUG
PtrOwner<ICurveComposite> pCompoPL( CreateCurveComposite()) ;
pCompoPL->FromPolyLine( PL) ;
int nPLId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayPockApprox, ::Release( pCompoPL)) ;
m_pGeomDB->SetMaterial( nPLId, ORANGE) ;
#endif
// traslo della lunghezza utensile diminuita dell'affondamento
PL.Translate( vtToolL * ( m_TParams.m_dLen - dDepth)) ;
// eseguo CAv
if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtToolL, vtToolL, m_Params.m_dApprox, ( i + 1) * dProgCoeff))
return false ;
// contro-traslo della lunghezza utensile
PL.Translate( - vtToolL * m_TParams.m_dLen) ;
// elimino i punti allineati
PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
// creo una curva composita a partire dalla polilinea
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo) || ! pCrvCompo->FromPolyLine( PL))
return false ;
#if ENABLE_OPTIMAL_DEBUG
int nCrvId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayCrv, CloneCurveComposite( pCrvCompo)) ;
m_pGeomDB->SetMaterial( nCrvId, RED) ;
#endif
// definisco un nuovo percorso
vPaths.resize( vPaths.size() + 1) ;
vPaths.back().nType = SURFFIN_SUB_ZIGZAG ;
vPaths.back().pCrvPath.Set( pCrvCompo) ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcOptimalZigZagSfrByZConstCrv( const ISurfFlatRegion* pSfrLoc, const CISURFTMPVECTOR& vpStm, const Vector3d& vtToolLoc,
double dExtraCollOffs, ICurveComposite* pCompoSil, ISurfFlatRegion* pSfrCollCompoSil) const
{
// verifica dei parametri
if ( pSfrLoc == nullptr || ! pSfrLoc->IsValid() ||
vpStm.empty() ||
pCompoSil == nullptr || ! pCompoSil->IsValid() ||
pSfrCollCompoSil == nullptr)
return false ;
pSfrCollCompoSil->Clear() ;
// abballisco e semplifico la curva calcolata
Point3d ptC ; pSfrLoc->GetCentroid( ptC) ;
Frame3d frLoc ;
if ( ! frLoc.Set( ptC, pSfrLoc->GetNormVersor()))
return false ;
SimplifyCurve( pCompoSil, frLoc) ;
// definisco una regione di FatCurve pari al valore dell'Offset richiesto
PtrOwner<ISurfFlatRegion> pSfrFat( GetSurfFlatRegionFromFatCurve( CloneCurveComposite( pCompoSil), dExtraCollOffs, false, false)) ;
if ( IsNull( pSfrFat) || ! pSfrFat->IsValid())
return false ;
pSfrCollCompoSil->CopyFrom( pSfrFat) ;
// verifico che sia orientata correttamente
if ( AreOppositeVectorApprox( pSfrLoc->GetNormVersor(), pSfrCollCompoSil->GetNormVersor()))
pSfrCollCompoSil->Invert() ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcOptimalZConstCurves( const ISurfFlatRegion* pSfrLoc, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
const Vector3d& vtTool, double dAngDegSplit, double dAngDegTol, double dDepth,
ICAvToolSurfTm* pCAvTlStm, VECTORPATHS& vPaths, ISurfFlatRegion* pSfrToolColl) const
{
// se la superficie non è valida, non restituisco nulla
if ( pSfrToolColl == nullptr)
return false ;
if ( pSfrLoc == nullptr || ! pSfrLoc->IsValid())
return true ;
// mi assicuro di non uscire dalla superficie originale
PtrOwner<ISurfFlatRegion> pMySfrZConst( CloneSurfFlatRegion( pSfrLoc)) ;
if ( IsNull( pMySfrZConst) || ! pMySfrZConst->IsValid())
return false ;
for ( int nC = 0 ; nC < pMySfrZConst->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pMySfrZConst->GetLoopCount( nC) ; ++ nL) {
for ( int nU = 0 ; nU < pMySfrZConst->GetLoopCurveCount( nC, nL) ; ++ nU)
pMySfrZConst->SetCurveTempProp( nC, nL, nU, 0, TEMP_PROP_CLOSE_EDGE) ;
}
}
// inizializzo la classe di calcolo delle silhouette
CISURFTMPVECTOR vpStm ; vpStm.reserve( vSrfLoc.size()) ;
// scorro le superfici
for ( int i = 0 ; i < ssize( vSrfLoc) ; ++ i) {
// recupero la superficie
const ISurf* pSurf = GetSurf( vSrfLoc[i].Get()) ;
if ( pSurf == nullptr || ! pSurf->IsValid())
continue ;
int nType = pSurf->GetType() ;
// se TriMesh
if ( nType == SRF_TRIMESH) {
const ISurfTriMesh* pStm = GetSurfTriMesh( pSurf) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0)
vpStm.emplace_back( pStm) ;
}
// se Bezier
else if ( nType == SRF_BEZIER) {
const ISurfBezier* pSBz = GetSurfBezier( pSurf) ;
if ( pSBz != nullptr && pSBz->IsValid()) {
double dOldTol = GetSurfBezierAuxSurfRefinedTol() ;
SetSurfBezierAuxSurfRefinedTol( 5. * EPS_SMALL) ;
const ISurfTriMesh* pStm = pSBz->GetAuxSurfRefined() ;
SetSurfBezierAuxSurfRefinedTol( dOldTol) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0)
vpStm.emplace_back( pStm) ;
}
}
}
// definisco il frame della regione piana
Frame3d frSfr ;
Point3d ptC ; pSfrLoc->GetCentroid( ptC) ;
if ( ! frSfr.Set( ptC, pSfrLoc->GetNormVersor()))
return false ;
// inizializzo classe di calcolo per le curve a ZConst con utensile corrente
PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
if ( IsNull( pCavParSilh) ||
! pCavParSilh->SetData( vpStm, frSfr, SILH_SAMPLING, m_TParams.m_dSideAng, m_TParams.m_dDiam, m_TParams.m_dCornRad,
m_TParams.m_dMaxMat, GetOffsR(), dDepth))
return false ;
// recupero le curve singole definite dal bordo della Silhouette
vector<ICRVCOMPOPOVECTOR> vvCrvCompo ;
if ( ! CalcZConstSilCrv( pCavParSilh, vSrfLoc, frSurf, pMySfrZConst, vtTool, dDepth, vvCrvCompo)) {
m_pMchMgr->SetLastError( 3126, "Error in SurfFinishing : Computing ZConst Curves failed") ;
return false ;
}
// se non ho ricato curve, non faccio nulla
if ( vvCrvCompo.empty())
return true ;
// definisco i parametri e le geometrie locali
// --- versore direzione utensile e versore direzione movimento
Vector3d vtAxL = vtTool ;
vtAxL.ToLoc( frSurf) ;
// --- tolleranza di campionamento per punti della PolyLine
const double MIN_DIST = 1. ;
const double MAX_DIST = 50. ;
double dDist = Clamp( m_Params.m_dApprox, MIN_DIST, MAX_DIST) ;
// --- angolo di Split per conservazione o meno dei tratti di PolyLine
double dCosLimit = cos( dAngDegSplit * DEGTORAD + EPS_ANG_SMALL) ;
double dCosUpperBound = cos( ( dAngDegSplit - dAngDegTol) * DEGTORAD + EPS_ANG_SMALL) ;
// --- classificazione punti e PolyLine corrispondenti
enum { VALID = 0, AMBIGUOUS = 1, DISCARD = 2 } ;
// --- offset correttivo per regioni di collisione
const double dExtraOffs = m_TParams.m_dDiam / 2. ;
#if ENABLE_OPTIMAL_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "Surf") ;
int nLayStm = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayStm, "Surf") ;
for ( auto& pStm : vpStm) {
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayStm, CloneSurfTriMesh( pStm)) ;
m_pGeomDB->SetMaterial( a, YELLOW) ;
}
nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "ZConst") ;
int nLayOrigCrv = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayOrigCrv, "Orig_curves") ;
m_pGeomDB->SetStatus( nLayOrigCrv, GDB_ST_OFF) ;
int nLayPt = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayPt, "Sample_pts") ;
m_pGeomDB->SetStatus( nLayPt, GDB_ST_OFF) ;
int nLayNorm = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayNorm, "Normals") ;
m_pGeomDB->SetStatus( nLayNorm, GDB_ST_OFF) ;
int nLayCrv = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayCrv, "Curves") ;
m_pGeomDB->SetStatus( nLayCrv, GDB_ST_OFF) ;
int nLaySfrColl = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLaySfrColl, "SfrColl") ;
m_pGeomDB->SetStatus( nLaySfrColl, GDB_ST_OFF) ;
#endif
// scorro i piani di ZConst ricavati...
for ( int i = 0 ; i < ssize( vvCrvCompo) ; ++ i) {
// Dalle curve si ricavano le PolyLine corrispondeti e vengono suddivise in 3 categorie :
// - PolyLine valide : definite da punti di campionamento consecutivi dove esiste una normale di
// di collisione con angolo rispetto a vtTool > dSplitAngDeg
// - PolyLine ambigue : definite da punti di campionamento consecutivi dove esiste una normale di
// di collisione con angolo rispetto a vtTool > dSplitAngDeg con tolleranza
// - PolyLine invalide : definite da punti di campionamento consecutivi dove non esiste una normale
// di collisone con angolo rispetto a vtTool > dSplitAngDeg con tolleranza
vector<pair<int, PolyLine>> vTypePL ; // vettore PolyLine di classificazione
POLYLINEVECTOR vPL ; // PolyLine risultanti
bool bStart = true ;
// la distanza dalla Sfr è memorizzata nel primo TempParam [*]
double dSfrDist = 0. ;
// per il piano corrente scorro le curve di Silhouette ricavate
for ( int j = 0 ; j < ssize( vvCrvCompo[i]) ; ++ j) {
// se curva non valida, passo alla successiva
if ( IsNull( vvCrvCompo[i][j]) || ! vvCrvCompo[i][j]->IsValid())
continue ;
dSfrDist = vvCrvCompo[i][j]->GetTempParam( 0) ; // [*]
#if ENABLE_OPTIMAL_DEBUG
int nCrvOrigId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayOrigCrv, vvCrvCompo[i][j]->Clone()) ;
m_pGeomDB->SetMaterial( nCrvOrigId, ORANGE) ;
#endif
// recupero la PolyLine della curva corrente e la campiono
PolyLine PL ;
vvCrvCompo[i][j]->ApproxWithLines( EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL) ;
if ( ! PL.AdjustForMaxSegmentLen( dDist))
return false ;
// scorro i punti della PolyLine e li calssifico
for ( const POINTU& ptU : PL.GetUPointList()) {
// La curva di Silhouette, una volta approssimata, può presentare alcuni punti quel poco
// che basta più lontani dalla superficie per non ricavare alcuna collisione.
// NB. Le curve ricavate sono approssimate, mergiate e leggermente smussate.
// --> In questo caso sposto leggermente il punto verso la superficie ( algoritmo iterativo fino a collisione individuata)
// NB. Le curve di Silhouette per definizione sono orientate lasciando le vStm alla loro destra
int nPointType = DISCARD ;
VCT3DVECTOR vecvN ;
double dMinDist = INFINITO - 1 ;
for ( int nSurf = 0 ; nSurf < ssize( vpStm) ; ++ nSurf) {
DistPointSurfTm distPtSurfTm( ptU.first, *vpStm[nSurf]) ;
double dMyDist = INFINITO - 2 ;
if ( distPtSurfTm.GetDist( dMyDist) && dMyDist < dMinDist) {
dMinDist = dMyDist ;
INTVECTOR vTriaMinDist ; distPtSurfTm.GetMinDistTriaIndices( vTriaMinDist) ;
Triangle3d Tria ;
vecvN.clear() ;
for ( int nTria : vTriaMinDist) {
vpStm[nSurf]->GetTriangle( nTria, Tria) ;
vecvN.push_back( Tria.GetN()) ;
}
}
}
// classificazione del punto
if ( ! vecvN.empty()) {
for ( const Vector3d& vtN : vecvN) {
if ( abs( vtN * vtAxL) < dCosLimit) {
nPointType = VALID ;
break ;
}
else if ( abs( vtN * vtAxL) < dCosUpperBound)
nPointType = AMBIGUOUS ;
}
}
#if ENABLE_OPTIMAL_DEBUG
PtrOwner<IGeoPoint3d> pt( CreateGeoPoint3d()) ;
pt->Set( ptU.first) ;
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayPt, Release( pt)) ;
m_pGeomDB->SetMaterial( a, nPointType == VALID ? GREEN :
nPointType == AMBIGUOUS ? LIME : BLACK) ;
for ( Vector3d& vtN : vecvN) {
PtrOwner<IGeoVector3d> vt( CreateGeoVector3d()) ;
vt->Set( vtN) ;
vt->Translate( ptU.first - ORIG) ;
int _vN = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayNorm, vt->Clone()) ;
m_pGeomDB->SetMaterial( _vN, Color( abs( vt->GetVector().x), abs( vt->GetVector().y), abs( vt->GetVector().z))) ;
}
#endif
// inserisco il punto nel tipo di PolyLine corrispondente
if ( bStart) {
vTypePL.emplace_back( make_pair( nPointType, PolyLine())) ;
vTypePL.back().second.AddUPoint( 0., ptU.first) ;
bStart = false ;
}
else {
if ( vTypePL.back().first == nPointType)
vTypePL.back().second.AddUPoint( 0., ptU.first) ;
else {
vTypePL.emplace_back( make_pair( nPointType, PolyLine())) ;
vTypePL.back().second.AddUPoint( 0., ptU.first) ;
}
}
}
// costruisco le PolyLine definitive
bool bFirst = true ;
int nPL = ssize( vTypePL) ;
for ( int nInd = 0 ; nInd < nPL ; ++ nInd) {
// se tratto valido
if ( vTypePL[nInd].first == VALID) {
// indice tratto precedente e successivo
int nPrevInd = ( nPL + nInd - 1) % nPL ;
int nAfterInd = ( nPL + nInd + 1) % nPL ;
// nuova PolyLine da definire
if ( bFirst) {
vPL.emplace_back( PolyLine()) ;
bFirst = false ;
}
// se tratto precedente ambiguo, lo aggiungo al tratto corrente e lo rendo invalido
if ( nPL > 1 && ( vTypePL[nPrevInd].first == AMBIGUOUS || vTypePL[nPrevInd].first == VALID)) {
// controllo che i punti siano sufficientemente vicini ( sqrt( 2) * dDist))
Point3d ptBack, ptCurr ;
vTypePL[nPrevInd].second.GetLastPoint( ptBack) ;
vTypePL[nInd].second.GetFirstPoint( ptCurr) ;
if ( AreSamePointEpsilon( ptBack, ptCurr, SQRT2 * dDist)) {
for ( const POINTU& ptU : vTypePL[nPrevInd].second.GetUPointList())
vPL.back().AddUPoint( 0., ptU.first) ;
vTypePL[nPrevInd].first = DISCARD ;
}
}
// aggiungo il tratto corrente e lo rendo invalido
for ( const POINTU& ptU : vTypePL[nInd].second.GetUPointList())
vPL.back().AddUPoint( 0., ptU.first) ;
vTypePL[nInd].first = DISCARD ;
// se tratto successivo ambiguo, lo aggiungo al tratto corrente e lo rendo invalido
if ( vTypePL[nAfterInd].first == AMBIGUOUS) {
// controllo che i punti siano sufficientemente vicini ( sqrt( 2) * dDist))
Point3d ptForward, ptCurr ;
vTypePL[nAfterInd].second.GetFirstPoint( ptForward) ;
vTypePL[nInd].second.GetLastPoint( ptCurr) ;
if ( AreSamePointEpsilon( ptForward, ptCurr, SQRT2 * dDist)) {
for ( POINTU& ptU : vTypePL[nAfterInd].second.GetUPointList())
vPL.back().AddUPoint( 0., ptU.first) ;
vTypePL[nAfterInd].first = DISCARD ;
++ nInd ;
}
}
}
// se tratto invalido, allora dovrò definire una nuova PolyLine
else if ( vTypePL[nInd].first == DISCARD)
bFirst = true ;
}
// verifico se inizio e fine delle PolyLine sono sufficientemente vicine, in caso positivo unisco in una PolyLine unica
if ( ssize( vPL) == 1 && vPL[0].GetPointNbr() > 1 && ! vPL[0].IsClosed()) {
Point3d ptStart ; vPL[0].GetFirstPoint( ptStart) ;
Point3d ptEnd ; vPL[0].GetLastPoint( ptEnd) ;
if ( AreSamePointEpsilon( ptStart, ptEnd, SQRT2 * dDist))
vPL[0].Close() ;
}
else if ( ssize( vPL) > 1) {
BOOLVECTOR vbSkipIndex ; vbSkipIndex.resize( vPL.size()) ;
for ( int i = 0 ; i < ssize( vPL) ; ++ i)
vbSkipIndex[i] = ( vPL[i].IsClosed()) ;
for ( int i = 0 ; i < ssize( vPL) ; ++ i) {
if ( ! vbSkipIndex[i]) {
Point3d ptEnd ; vPL[i].GetLastPoint( ptEnd) ;
for ( int j = 0 ; j < ssize( vPL) ; ++ j) {
if ( j != i && ! vbSkipIndex[j]) {
Point3d ptStart ; vPL[j].GetFirstPoint( ptStart) ;
if ( AreSamePointEpsilon( ptStart, ptEnd, SQRT2 * dDist)) {
for ( POINTU& ptU : vPL[j].GetUPointList())
vPL[i].AddUPoint( 0., ptU.first) ;
vbSkipIndex[j] = true ;
vPL[j].Clear() ;
-- i ;
break ;
}
}
}
}
}
}
}
// dalle PolyLine recupero le curve
vvCrvCompo[i].clear() ;
for ( const PolyLine& PL : vPL) {
// se vuota, non faccio nulla
if ( PL.GetPointNbr() < 2)
continue ;
// se PolyLine troppo corta, non la memorizzo
double dLen = 0. ; PL.GetLength( dLen) ;
if ( dLen < m_TParams.m_dDiam)
continue ;
// definisco la curva
PtrOwner<ICurveComposite> pNewCompo( CreateCurveComposite()) ;
if ( IsNull( pNewCompo) || ! pNewCompo->FromPolyLine( PL))
continue ;
// aggiorno la regione per il calcolo dello ZigZag ( la funzione abbellisce le curve)
PtrOwner<ISurfFlatRegion> pSfrColl( CreateSurfFlatRegion()) ;
CalcOptimalZigZagSfrByZConstCrv( pSfrLoc, vpStm, vtAxL, - dExtraOffs, pNewCompo, pSfrColl) ;
if ( ! IsNull( pSfrColl) && pSfrColl->IsValid()) {
if ( ! pSfrToolColl->IsValid())
pSfrToolColl->CopyFrom( pSfrColl) ;
else
pSfrToolColl->Add( *pSfrColl) ;
}
vvCrvCompo[i].emplace_back( Release( pNewCompo)) ;
// memorizzo come primo TempParam la distanza della superficie ( per coerenza)
vvCrvCompo[i].back()->SetTempParam( dSfrDist, 0) ;
#if ENABLE_OPTIMAL_DEBUG
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayCrv, vvCrvCompo[i].back()->Clone()) ;
m_pGeomDB->SetMaterial( a, FUCHSIA) ;
#endif
}
}
// la superficie complessiva di collisione viene limitata al bordo
if ( pSfrToolColl->IsValid()) {
#if 0
pSfrToolColl->Offset( - dExtraOffs, ICurve::OFF_FILLET) ;
#endif
if ( pSfrToolColl->IsValid())
pSfrToolColl->Intersect( *pSfrLoc) ;
#if ENABLE_OPTIMAL_DEBUG
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySfrColl, pSfrToolColl->Clone()) ;
m_pGeomDB->SetMaterial( a, Color( 255, 0, 255, 50)) ;
#endif
}
// collego tra loro le curve trovate definendo quindi un percorso
ICRVCOMPOPOVECTOR vCrv ;
if ( ! CreateZConstPaths( pCAvTlStm, vpStm, frSurf, vvCrvCompo, vtTool, pMySfrZConst, dDepth, vCrv)) {
m_pMchMgr->SetLastError( 3127, "Error in SurfFinishing : Computing ZConst Paths failed") ;
return false ;
}
// restituisco i percorsi trovati
for ( int i = 0 ; i < ssize( vCrv) ; ++ i) {
vPaths.resize( vPaths.size() + 1) ;
vPaths.back().pCrvPath.Set( Release( vCrv[i])) ;
vPaths.back().nType = SURFFIN_SUB_Z_CONST ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AreSameSfrChunkEpsilon( const ISurfFlatRegion* pSfrChunkA, const ISurfFlatRegion* pSfrChunkB, double dMaxDist) const
{
// se esiste una superficie non valida, sicuro le superfici non sono sovrapposte
if ( pSfrChunkA == nullptr || pSfrChunkB == nullptr || ! pSfrChunkA->IsValid() || ! pSfrChunkB->IsValid())
return false ;
// Verifico che le sueprfici siano orientate correntamente
if ( ! AreSameVectorApprox( pSfrChunkA->GetNormVersor(), pSfrChunkB->GetNormVersor()))
return false ;
double dMyMaxDist = max( 10. * EPS_SMALL, dMaxDist) ;
// verifico mediate FatCurves dei bordi se in tolleranza
PtrOwner<ICurve> pCrvExtBorderA( pSfrChunkA->GetLoop( 0, 0)) ;
PtrOwner<ICurve> pCrvExtBorderB( pSfrChunkB->GetLoop( 0, 0)) ;
if ( IsNull( pCrvExtBorderA) || IsNull( pCrvExtBorderB) || ! pCrvExtBorderA->IsValid() || ! pCrvExtBorderB->IsValid())
return false ;
PtrOwner<ISurfFlatRegion> pSfrFatExtA( GetSurfFlatRegionFromFatCurve( pCrvExtBorderA->Clone(), dMyMaxDist, false, false)) ;
if ( IsNull( pSfrFatExtA) || ! pSfrFatExtA->IsValid())
return false ;
CRVCVECTOR ccClass ;
if ( ! pSfrFatExtA->GetCurveClassification( *pCrvExtBorderB, EPS_SMALL, ccClass) ||
! ( ssize( ccClass) == 1 && ccClass[0].nClass == CRVC_IN))
return false ;
// Recupero la superficie con più isole
int nIslA = pSfrFatExtA->GetLoopCount( 0) - 1 ;
int nIslB = pSfrChunkB->GetLoopCount( 0) - 1 ;
if ( nIslA == 0 && nIslB == 0)
return true ;
const ISurfFlatRegion* pSfrA = ( nIslA >= nIslB ? pSfrChunkA : pSfrChunkB) ;
const ISurfFlatRegion* pSfrB = ( nIslA < nIslB ? pSfrChunkA : pSfrChunkB) ;
if ( pSfrA == nullptr || pSfrB == nullptr)
return false ;
// Regioni di Controllo
ISURFFRPOVECTOR vFatSurfA ; vFatSurfA.reserve( nIslA) ;
for ( int nIsl = 0 ; nIsl < nIslA ; ++ nIsl) {
PtrOwner<ICurve> pCrvIsl( pSfrA->GetLoop( 0, nIsl + 1)) ;
if ( ! IsNull( pCrvIsl) && pCrvIsl->IsValid()) {
PtrOwner<ISurfFlatRegion> pSfrFat( GetSurfFlatRegionFromFatCurve( pCrvIsl->Clone(), dMaxDist, false, false)) ;
if ( ! IsNull( pSfrFat) && pSfrFat->IsValid()) {
if ( ! vFatSurfA.emplace_back( Release( pSfrFat)))
return false ;
}
}
}
// Loop dell'altra regione
for ( int nIsl = 0 ; nIsl < nIslB ; ++ nIsl) {
PtrOwner<ICurve> pCrvIsl( pSfrB->GetLoop( 0, nIsl + 1)) ;
if ( ! IsNull( pCrvIsl) && pCrvIsl->IsValid()) {
// Se curva troppo stretta, non la considero
OffsetCurve OffsCrv ;
if ( OffsCrv.Make( pCrvIsl, dMaxDist, ICurve::OFF_FILLET)) {
PtrOwner<ICurve> pCrv( OffsCrv.GetLongerCurve()) ;
if ( IsNull( pCrv) || ! pCrv->IsValid())
continue ;
}
// verifico che esista una regione Fat che la contenga
bool bOk = true ;
for ( const ISurfFlatRegion* pSfrFat : vFatSurfA) {
CRVCVECTOR ccClass ;
if ( pSfrFat->GetCurveClassification( *pCrvExtBorderB, EPS_SMALL, ccClass) &&
ssize( ccClass) == 1 && ccClass[0].nClass == CRVC_IN) {
bOk = true ;
break ;
}
}
if ( ! bOk)
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcOptimalZigZagRegion( const ISurfFlatRegion* pSfrCntLoc, const ISurfFlatRegion* pSfrZLevelColl, ISURFFRPOVECTOR& vpSfrZigZagProj) const
{
// verifico validità dei parametri
if ( pSfrCntLoc == nullptr || ! pSfrCntLoc->IsValid())
return false ;
vpSfrZigZagProj.clear() ;
// se non esiste una regione di ZLevelColl, quindi non esistono curve di Zlevel, tutta la superficie deve
// essere lavorata in ZigZag
if ( pSfrZLevelColl == nullptr || ! pSfrZLevelColl->IsValid())
return ( vpSfrZigZagProj.emplace_back( CloneSurfFlatRegion( pSfrCntLoc))) ;
// separo ogni Chunk della regione a ZigZag (ognuno di essi verrà lavorato singolarmanete)
PtrOwner<ISurfFlatRegion> pSfrZigZag( CloneSurfFlatRegion( pSfrCntLoc)) ;
if ( IsNull( pSfrZigZag) || ! pSfrZigZag->IsValid())
return false ;
if ( ! pSfrZigZag->Subtract( *pSfrZLevelColl))
return false ;
if ( pSfrZigZag->IsValid()) {
#if 0
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrZigZag->Clone()) ;
#endif
// Offset di confine tra passata Zlevel e ZigZag (per sicurezza è meglio lasciare questo valore non nullo, dato che la CAv è fatta
// su una PolyLine che potrebbe approssimare archi, trovando quindi collisioni nei punti intermedi di esso creando Spike verticali)
const double EXTRA_OFFS_TOL = 25. * EPS_SMALL ; // (alzare se necessario)
for ( int nC = 0 ; nC < pSfrZigZag->GetChunkCount() ; ++ nC) {
PtrOwner<ISurfFlatRegion> pSfrZigZagChunk( pSfrZigZag->CloneChunk( nC)) ;
if ( ! IsNull( pSfrZigZagChunk) && pSfrZigZagChunk->IsValid()) {
// verifico che il Chunk non sia troppo "snello"
double dMaxOffs = 0. ;
pSfrZigZagChunk->GetMaxOffset( dMaxOffs) ;
if ( dMaxOffs < m_TParams.m_dDiam / 2. - 20. * EPS_SMALL)
continue ;
#if 0
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrZigZagChunk->Clone()) ;
#endif
// Effettuo un Offset per portare la regione di ZigZag a confine con la regione di Finitura ZConst (in tolleranza)
if ( ! pSfrZigZagChunk->Offset( m_TParams.m_dDiam / 2. - EXTRA_OFFS_TOL, ICurve::OFF_FILLET))
return false ;
// Regolarizzo la regione mediante Offset-ControOffset
pSfrZigZagChunk->Offset( - m_TParams.m_dDiam / 2., ICurve::OFF_FILLET) ;
pSfrZigZagChunk->Offset( m_TParams.m_dDiam / 2., ICurve::OFF_FILLET) ;
// evito in ogni modo di uscire dalla regione originaria
pSfrZigZagChunk->Intersect( *pSfrCntLoc) ;
#if 0
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrZigZagChunk->Clone()) ;
#endif
vpSfrZigZagProj.emplace_back( Release( pSfrZigZagChunk)) ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
const ISurfFlatRegion* pSfrCnt, const ISurfFlatRegion* pSfrCntExt,
const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs)
{
// se entrambe le regioni non sono valide, non faccio nulla
if ( ( pSfrCnt == nullptr || ! pSfrCnt->IsValid()) && ( pSfrCntExt == nullptr || ! pSfrCntExt->IsValid()))
return false ;
// recupero l'angolo di Split e la rispettiva tolleranza
double dAngDegSplit = 45. ; GetValInNotes( m_Params.m_sUserNotes, UN_SPLITANGLE, dAngDegSplit) ;
double dAngDegTol = 5. ; GetValInNotes( m_Params.m_sUserNotes, UN_ANGLETOL, dAngDegTol) ;
// tengo una copia della regione di contorno in locale alle superfici
PtrOwner<ISurfFlatRegion> pSfrCntLoc( CloneSurfFlatRegion( pSfrCnt)) ;
if ( IsNull( pSfrCntLoc) || ! pSfrCntLoc->IsValid() || ! pSfrCntLoc->ToLoc( frSurf))
return false ;
// --- [1°] calcolo delle curve ZLevel e [2°] definizione della regione di proiezione per Zlevel ---
PtrOwner<ISurfFlatRegion> pSfrCntLimit( pSfrCntLoc->CreateOffsetSurf( - m_TParams.m_dDiam / 2. + EPS_SMALL, ICurve::OFF_FILLET)) ;
if ( IsNull( pSfrCntLimit))
return false ;
// calcolo tutte le curve a ZLevel e determino la regione rimossa da queste curve
VECTORPATHS vPathsZConst ;
PtrOwner<ISurfFlatRegion> pSfrZLevelColl( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrZLevelColl) ||
! CalcOptimalZConstCurves( pSfrCntLimit, vSrfLoc, frSurf, vtTool, dAngDegSplit, dAngDegTol, dDepth, pCAvTlStm, vPathsZConst, pSfrZLevelColl)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
// [3°] calcolo della regione di proiezione ZigZag ---
ISURFFRPOVECTOR vSfrZigZagProj ;
if ( ! CalcOptimalZigZagRegion( pSfrCntLimit, pSfrZLevelColl, vSfrZigZagProj)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
// [4°] calcolo delle curve ZigZag ---
VECTORPATHS vPathsZigZag ;
if ( ! vSfrZigZagProj.empty()) {
if ( ! CalcOptimalZigZagCurves( vSfrZigZagProj, frSurf, vtTool, dDepth, pCAvTlStm, vPathsZigZag)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
}
if ( vPathsZConst.empty() && vPathsZigZag.empty())
return true ;
// porto tutti i percorsi in globale
for ( PATH& path : vPathsZConst) {
if ( IsNull( path.pCrvPath) || ! path.pCrvPath->IsValid())
continue ;
path.pCrvPath->ToGlob( frSurf) ;
}
for ( PATH& path : vPathsZigZag) {
if ( IsNull( path.pCrvPath) || ! path.pCrvPath->IsValid())
continue ;
path.pCrvPath->ToGlob( frSurf) ;
}
// ordino i percorsi ricavati, priorità alle curve di ZConst per pareti verticali
VECTORPATHS vPaths ;
if ( ! OrderOptimalPathsByZLoc( pSfrCntExt, pSfrCnt, vPathsZConst))
return false ;
Point3d ptRef = ORIG ;
if ( ! vPathsZConst.empty())
vPathsZConst.back().pCrvPath->GetStartPoint( ptRef) ;
if ( ! OrderOptimalPathsByDistance( ptRef, vPathsZigZag, GetOptimalSubType() == SURFROU_SUB_ZIGZAG))
return false ;
for ( PATH& path : vPathsZConst) {
vPaths.resize( vPaths.size() + 1) ;
vPaths.back().pCrvPath.Set( ::Release( path.pCrvPath)) ;
vPaths.back().nType = path.nType ;
}
for ( PATH& path : vPathsZigZag) {
vPaths.resize( vPaths.size() + 1) ;
vPaths.back().pCrvPath.Set( ::Release( path.pCrvPath)) ;
vPaths.back().nType = path.nType ;
}
#if ENABLE_OPTIMAL_FINAL_CURVES_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "Curves") ;
int nSpiralLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nSpiralLay, "Spiral") ;
int nZConstLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nZConstLay, "ZConst") ;
for ( int i = 0 ; i < int( vPaths.size()) ; ++ i) {
if ( ! IsNull( vPaths[i].pCrvPath) && vPaths[i].pCrvPath->IsValid()) {
if ( vPaths[i].nType == SURFFIN_SUB_Z_CONST) {
int nPathId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nZConstLay, CloneCurveComposite( vPaths[i].pCrvPath)) ;
m_pGeomDB->SetMaterial( nPathId, GREEN) ;
}
else if ( vPaths[i].nType == SURFFIN_SUB_ZIGZAG) {
int nPathId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nSpiralLay, CloneCurveComposite( vPaths[i].pCrvPath)) ;
m_pGeomDB->SetMaterial( nPathId, RED) ;
}
}
}
#endif
// aggiungo i percorsi di finitura calcolati
ICRVCOMPOPOVECTOR vCrvCompo ; vCrvCompo.resize( vPaths.size()) ;
for ( int i = 0 ; i < ssize( vPaths) ; ++ i)
vCrvCompo[i].Set( Release( vPaths[i].pCrvPath)) ;
if ( ! AddFinishing( ( pSfrCntExt == nullptr || ! pSfrCntExt->IsValid()) ? pSfrCnt : pSfrCntExt,
pCAvTlStm, frSurf, vCrvCompo, vtTool, vtMove, dElev, dDepth, bSplitArcs))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
const ICurveComposite* pCrvCompo, const Vector3d& vtTool, const Vector3d& vtMove, double dDepth,
double dElev, bool bSplitArcs)
{
// controllo che la curva sia valida
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return false ;
// definisco un sistema di riferimento locale alla curva
Point3d ptStart ; pCrvCompo->GetStartPoint( ptStart) ;
Frame3d frLoc ;
if ( ! frLoc.Set( ptStart, vtMove))
return false ;
// definisco il frame inverso per il calcolo del Box3d
Frame3d frLocInv = frLoc ;
if ( ! frLocInv.Invert())
return false ;
// definisco variabili globali
BBox3d BBox3Loc ; // box totale delle superici rispetto a frLoc
ISURFTMPOVECTOR vpStm ; // superfici TriMesh selezionate in globale
ICRVCOMPOPOVECTOR vCrvToProj ; // vettore delle curve da proiettare sulla superficie
// scorro il vettore di superfici selezionate
for ( int i = 0 ; i < ssize( vSrfLoc) ; ++ i) {
// recupero la superficie ( TriMesh o Bezier)
const ISurf* pSurf = GetSurf( vSrfLoc[i].Get()) ;
if ( pSurf == nullptr || ! pSurf->IsValid())
continue ;
int nType = pSurf->GetType() ;
PtrOwner<ISurfTriMesh> pSurfTm ;
// se TriMesh
if ( nType == SRF_TRIMESH) {
const ISurfTriMesh* pStm = GetSurfTriMesh( pSurf) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0) {
if ( ! pSurfTm.Set( CloneSurfTriMesh( pStm)))
continue ;
}
}
// se Bezier
else if ( nType == SRF_BEZIER) {
const ISurfBezier* pSBz = GetSurfBezier( pSurf) ;
if ( pSBz != nullptr && pSBz->IsValid()) {
double dOldTol = GetSurfBezierAuxSurfRefinedTol() ;
SetSurfBezierAuxSurfRefinedTol( 5. * EPS_SMALL) ;
const ISurfTriMesh* pStm = pSBz->GetAuxSurfRefined() ;
SetSurfBezierAuxSurfRefinedTol( dOldTol) ;
if ( pStm != nullptr && pStm->IsValid() && pStm->GetTriangleCount() > 0) {
if ( ! pSurfTm.Set( CloneSurfTriMesh( pStm)))
continue ;
}
}
}
// porto la supercicie nel riferimento globale come TriMesh
if ( IsNull( pSurfTm) || ! pSurfTm->IsValid() || ! pSurfTm->ToGlob( frSurf))
return false ;
// calcolo il box rispetto a frLoc e sommo i contributi
BBox3d BBox ;
if ( ! pSurfTm->GetBBox( frLocInv, BBox))
return false ;
BBox3Loc.Add( BBox) ;
// memorizzo la superficie nel vettore
vpStm.emplace_back( Release( pSurfTm)) ;
}
// recupero flag per saltare parti a massimo affondamento
bool bSkipMaxDown = true ;
GetValInNotes( m_Params.m_sUserNotes, UN_SKIPMAXDOWN, bSkipMaxDown) ;
if ( bSkipMaxDown) {
// definisco i dati di calcolo della Silhouette
const double SILH_TOL = 1.0 ;
CISURFTMPVECTOR vSurf ; vSurf.reserve( vpStm.size()) ;
for ( int i = 0; i < ssize( vpStm) ; ++ i)
vSurf.emplace_back( vpStm[i]) ;
PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
if ( IsNull( pCavParSilh) || ! pCavParSilh->SetData( vSurf, frLoc, SILH_TOL))
return false ;
// recupero il vettore di PolyLine della silhouette
POLYLINEVECTOR vPL ;
if ( ! pCavParSilh->GetSilhouette( BBox3Loc.GetMin().z , vPL))
return false ;
// creo la regione piana dalle PolyLine ricavate dalla Silhouette
const double SILH_ARC_TOL = 0.1 * SILH_TOL ;
const double SILH_ARC_FEA_MAX = 100. ;
SurfFlatRegionByContours SfrMaker ;
for ( const PolyLine& PL : vPL) {
// recupero la curva dalla silhouette
PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
if ( IsNull( pSilCrv))
return false ;
pSilCrv->FromPolyLine( PL) ;
// approssimo con archi
PolyArc PA ;
if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
if ( ! IsNull( pTempCrv) &&
pTempCrv->FromPolyArc( PA) &&
pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG) &&
pTempCrv->MergeCurves( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG))
pSilCrv.Set( pTempCrv) ;
}
// aggiungo per regione
if ( ! SfrMaker.AddCurve( Release( pSilCrv))) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
}
// definisco la regione piana
PtrOwner<ISurfFlatRegion> pSfrSil( SfrMaker.GetSurf()) ;
if ( ! IsNull( pSfrSil) && pSfrSil->IsValid()) {
// Offset alla Silhouette
double dPockRadOffs = SILH_ARC_TOL ;
pSfrSil->Offset( dPockRadOffs, ICurve::OFF_CHAMFER) ;
// aggiungo un Offset del raggio utensile sottratto di una leggera quantità per consentire ai percorsi di essere
// all'interno di una regione che consente all'utensile di avere una collisione con normale di contatto circa
// perpendicolare rispetto all'estrusione
pSfrSil->Offset( m_TParams.m_dDiam / 2. - SILH_TOL, ICurve::OFF_FILLET) ;
// porto la curva e la Silhouette nel frame locale per classificazione ( alla stezza zLoc)
PtrOwner<ICurveComposite> pCrvCompoCL( CloneCurveComposite( pCrvCompo)) ;
if ( IsNull( pCrvCompoCL) || ! pCrvCompoCL->IsValid())
return false ;
pCrvCompoCL->Translate( BBox3Loc.GetMin().z * vtMove) ;
pCrvCompoCL->ToLoc( frLoc) ;
pSfrSil->ToLoc( frLoc) ;
// classifico
CRVCVECTOR ccClass ;
if ( pSfrSil->GetCurveClassification( *pCrvCompoCL, EPS_SMALL, ccClass)) {
for ( int i = 0 ; i < ssize( ccClass) ; ++ i) {
// se tratto di curva interno
if ( ccClass[i].nClass != CRVC_OUT) {
// recupero la curva
PtrOwner<ICurve> pCrvInt( pCrvCompo->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE)) ;
if ( ! IsNull( pCrvInt) && pCrvInt->IsValid())
vCrvToProj.emplace_back( ConvertCurveToComposite( Release( pCrvInt))) ;
}
}
}
}
}
else
vCrvToProj.emplace_back( CloneCurveComposite( pCrvCompo)) ;
// correggo i percorsi mediante collisione con le supercici
if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, vtMove, dDepth, vCrvToProj)) {
m_pMchMgr->SetLastError( 3134, "Error in SurfFinishing : Projecting Path failed") ;
return false ;
}
// aggiungo il percorso di finitura calcolati
for ( int i = 0 ; i < ssize( vCrvToProj) ; ++ i) {
ICRVCOMPOPOVECTOR vCrvSingle ;
vCrvSingle.emplace_back( Release( vCrvToProj[i])) ;
if ( ! AddFinishing( nullptr, pCAvTlStm, frSurf, vCrvSingle, vtTool, vtMove, dElev, dDepth, bSplitArcs))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
SetFlag( 1) ;
// se sopra attacco c'è spazio per sicurezza o approccio
double dSafeDist = dSafeZ ;
if ( dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
// se distanza di sicurezza minore di distanza di inizio
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 1 -> punto sopra inizio
Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
else {
// 1a -> punto sopra inizio
Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
Point3d ptP1a = ptP1b + vtTool * ( dSafeDist - dAppr) ;
if ( ( AddRapidStart( ptP1a) == GDB_ID_NULL))
return false ;
// 1b -> punto appena sopra inizio
if ( ( dElev + dAppr) > EPS_SMALL) {
SetFlag( 0) ;
if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
return false ;
}
}
// affondo al punto iniziale
SetFlag( 0) ;
SetFeed( GetTipFeed()) ;
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
}
else {
// affondo diretto al punto iniziale
SetFlag( 0) ;
if ( AddRapidStart( ptP) == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
// 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) == GDB_ID_NULL)
return false ;
}
// affondo al punto iniziale
SetFlag( 0) ;
SetFeed( GetTipFeed()) ;
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
}
else {
// affondo diretto al punto iniziale
SetFlag( 0) ;
if ( AddRapidMove( ptP) == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
// 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) == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
// se sopra uscita c'è spazio per sicurezza o approccio
double dSafeDist = dSafeZ ;
if ( dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + vtTool * ( dElev + dAppr) ;
if ( dElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + vtTool * ( dSafeDist - dAppr) ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
int
SurfFinishing::GetLeadInType( void) const
{
if ( abs( m_Params.m_dLiTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
abs( m_Params.m_dLiPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1))
return SURFFIN_LI_NONE ;
return m_Params.m_nLeadInType ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, const Vector3d& vtNorm,
Point3d& ptP1) const
{
// Assegno tipo e parametri
int nType = GetLeadInType() ;
double dTang = m_Params.m_dLiTang ;
double dPerp = m_Params.m_dLiPerp ;
// Calcolo punto iniziale
switch ( nType) {
case SURFFIN_LI_NONE :
ptP1 = ptStart ;
return true ;
case SURFFIN_LI_LINEAR :
case SURFFIN_LI_TANGENT :
{
Vector3d vtPerp = vtStart ;
Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
vtPerp.Rotate( vtRot, 0, -1) ;
if ( vtPerp * vtNorm < -EPS_ZERO)
vtPerp.Invert() ;
ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp ;
}
return true ;
default :
return false ;
}
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, bool bSplitArcs)
{
// Se inizio e fine coincidono, non devo fare alcunchè
if ( AreSamePointApprox( ptP1, ptStart))
return true ;
// Assegno il tipo
int nType = GetLeadInType() ;
// Eseguo a seconda del tipo
switch ( nType) {
case SURFFIN_LI_NONE :
return true ;
case SURFFIN_LI_LINEAR :
return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
case SURFFIN_LI_TANGENT :
PtrOwner<ICurve> pCrv( GetArc2PVN( ptStart, ptP1, - vtStart, vtTool)) ;
if ( IsNull( pCrv))
return false ;
pCrv->Invert() ;
return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
return true ;
}
//----------------------------------------------------------------------------
int
SurfFinishing::GetLeadOutType( void) const
{
if ( abs( m_Params.m_dLoTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
abs( m_Params.m_dLoPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
m_Params.m_nLeadOutType != SURFFIN_LO_AS_LI)
return SURFFIN_LO_NONE ;
return m_Params.m_nLeadOutType ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtTool, const Vector3d& vtNorm, Point3d& ptP1) const
{
// Assegno tipo e parametri
int nType = GetLeadOutType() ;
double dTang = m_Params.m_dLoTang ;
double dPerp = m_Params.m_dLoPerp ;
// se uscita come ingresso
if ( nType == SURFFIN_LO_AS_LI) {
int nLiType = GetLeadInType() ;
switch ( nLiType) {
case SURFFIN_LI_LINEAR : nType = SURFFIN_LO_LINEAR ; break ;
case SURFFIN_LI_TANGENT : nType = SURFFIN_LO_TANGENT ; break ;
default : nType = SURFFIN_LO_NONE ; break ;
}
dTang = m_Params.m_dLiTang ;
dPerp = m_Params.m_dLiPerp ;
}
// Calcolo punto finale
switch ( nType) {
case SURFFIN_LO_NONE :
ptP1 = ptEnd ;
return true ;
case SURFFIN_LO_LINEAR :
case SURFFIN_LO_TANGENT :
{
// calcolo punto finale dell'uscita
Vector3d vtPerp = vtEnd ;
Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
vtPerp.Rotate( vtRot, 0, -1) ;
if ( vtPerp * vtNorm < -EPS_ZERO)
vtPerp.Invert() ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ;
}
return true ;
default :
return false ;
}
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Point3d& ptP1, const Vector3d& vtTool, bool bSplitArcs)
{
// Se inizio e fine coincidono, non devo fare alcunchè
if ( AreSamePointApprox( ptEnd, ptP1))
return true ;
// Assegno tipo e parametri
int nType = GetLeadOutType() ;
// se uscita come ingresso
if ( nType == SURFFIN_LO_AS_LI) {
int nLiType = GetLeadInType() ;
switch ( nLiType) {
case SURFFIN_LI_LINEAR : nType = SURFFIN_LO_LINEAR ; break ;
case SURFFIN_LI_TANGENT : nType = SURFFIN_LO_TANGENT ; break ;
default : nType = SURFFIN_LO_NONE ; break ;
}
}
// eseguo a seconda del tipo
switch ( nType) {
case SURFFIN_LO_NONE :
return true ;
case SURFFIN_LO_LINEAR :
return ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
case SURFFIN_LO_TANGENT :
// inserisco uscita
PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtTool)) ;
if ( IsNull( pCrv))
return false ;
// emetto movimento
return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptStart, const Point3d& ptEnd,
const Vector3d& vtInit, const Vector3d& vtTool, const Vector3d& vtMove,
bool bLeadInVsOut, Point3d& ptP1) const
{
// se inizio e fine coincidono, non faccio nulla
if ( AreSamePointApprox( ptStart, ptEnd))
return true ;
// porto i punti e il versori nel riferimento superficie
Point3d ptStartL = GetToLoc( ptStart, frSurf) ;
Point3d ptEndL = GetToLoc( ptEnd, frSurf) ;
Vector3d vtInitL = GetToLoc( vtInit, frSurf) ;
Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
Vector3d vtMoveL = GetToLoc( vtMove, frSurf) ;
// porto i punti dal tip al naso mandrino
ptStartL += vtToolL * m_TParams.m_dLen ;
ptEndL += vtToolL * m_TParams.m_dLen ;
// definisco la PolyLine del tratto da seguire
PNTULIST lstPntU ;
// --- caso di LeadIn
if ( bLeadInVsOut) {
// recupero il tipo di LeadIn
switch( GetLeadInType()) {
case SURFFIN_LI_NONE :
return true ;
case SURFFIN_LI_LINEAR : {
// inserisco gli estremi del tratto lineare
lstPntU = { { ptStartL, 0}, { ptEndL, 1}} ;
}
break ;
case SURFFIN_LI_TANGENT : {
// definisco la curva ad arco
PtrOwner<ICurve> pCrv( GetArc2PVN( ptEndL, ptStartL, - vtInitL, vtToolL)) ;
if ( IsNull( pCrv))
return false ;
pCrv->Invert() ;
// inserisco i punti nella lista, campionandola
PolyLine PL ;
pCrv->ApproxWithLines( m_Params.m_dApprox, EPS_ANG_SMALL, ICurve::APL_SPECIAL, PL) ;
lstPntU = PL.GetUPointList() ;
}
break ;
}
lstPntU.reverse() ;
}
// --- caso di LeadOut
else {
// recupero il tipo di LeadOut
int nType = GetLeadOutType() ;
// se uscita come ingresso
if ( nType == SURFFIN_LO_AS_LI) {
int nLiType = GetLeadInType() ;
switch ( nLiType) {
case SURFFIN_LI_LINEAR : nType = SURFFIN_LO_LINEAR ; break ;
case SURFFIN_LI_TANGENT : nType = SURFFIN_LO_TANGENT ; break ;
default : nType = SURFFIN_LO_NONE ; break ;
}
}
// eseguo a seconda del tipo
switch( nType) {
case SURFFIN_LO_NONE :
return true ;
case SURFFIN_LO_LINEAR : {
// inserisco gli estremi del tratto lineare
lstPntU = { { ptStartL, 0}, { ptEndL, 1}} ;
}
break ;
case SURFFIN_LO_TANGENT : {
// definisco la curva ad arco
PtrOwner<ICurve> pCrv( GetArc2PVN( ptStartL, ptEndL, vtInitL, vtToolL)) ;
if ( IsNull( pCrv))
return false ;
// inserisco i punti nella lista, campionandola
PolyLine PL ;
pCrv->ApproxWithLines( m_Params.m_dApprox, EPS_ANG_SMALL, ICurve::APL_SPECIAL, PL) ;
lstPntU = PL.GetUPointList() ;
}
break ;
}
}
// se non ho inserito almeno 2 punti nella lista, non faccio nulla
if ( ssize( lstPntU) < 2)
return true ; // per sicurezza...
// eseguo controllo collisione
if ( ! pCAvTlStm->TestPath( lstPntU, vtToolL, vtMoveL, m_Params.m_dApprox, 0.))
return false ;
// cerco l'ultimo punto non spostato per evitare collisione
bool bFound = false ;
auto currPU = lstPntU.begin() ;
while ( ! bFound && currPU != lstPntU.end()) {
auto nextPU = next( currPU) ;
if ( nextPU == lstPntU.end() || nextPU->second > m_Params.m_dApprox) {
bFound = true ;
ptP1 = GetToGlob( currPU->first - vtToolL * ( m_TParams.m_dLen + currPU->second), frSurf) ;
}
currPU = nextPU ;
}
return bFound ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, const Vector3d& vtMove,
const ISurfFlatRegion* pSfrCnt, double dDepth, double dSafeZ, ICAvToolSurfTm* pCAvTlStm,
const Frame3d& frSurf, ICurveComposite* pCrvLink) const
{
// controllo dei parametri
if ( pCAvTlStm == nullptr || pCrvLink == nullptr || pSfrCnt == nullptr)
return false ;
// se estremi coincidenti, non faccio nulla
pCrvLink->Clear() ;
if ( AreSamePointApprox( ptStart, ptEnd))
return true ;
// porto le entità geometriche nel riferimento delle superfici
Point3d ptEndL = GetToLoc( ptEnd, frSurf) ;
Point3d ptStartL = GetToLoc( ptStart, frSurf) ;
Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
Vector3d vtMoveL = GetToLoc( vtMove, frSurf) ;
// porto i punti sul top dell'utensile
ptEndL += vtToolL * m_TParams.m_dLen ;
ptStartL += vtToolL * m_TParams.m_dLen ;
// mi assicuro che il collegamento non interferica con la superficie
PNTULIST lstPntU{ { ptEndL, 0.}, { ptStartL, 1.}} ;
if ( ! pCAvTlStm->TestPath( lstPntU, vtToolL, vtMoveL, m_Params.m_dApprox, 0.))
return false ;
// determino un piano al di sotto della lavorazione, orientato come pSfrCnt
// --- serve per individuare la quota ZLocMax per i Link tra le curve di finitura
Point3d ptC ; pSfrCnt->GetCentroid( ptC) ;
Plane3d plZLocMin ;
if ( ! plZLocMin.Set( ptC, vtMove))
return false ;
plZLocMin.Translate( - vtMove * 10. * ( m_TParams.m_dLen + abs( dDepth))) ;
// determino il punto con ZLocale più alta
Point3d ptZMax = ptEnd ;
double dZMax = 0. ;
for ( const POINTU& ptU : lstPntU) {
Point3d ptUGlob = GetToGlob( ptU.first - vtToolL * m_TParams.m_dLen, frSurf) ;
double dCurrZ = DistPointPlane( ptUGlob, plZLocMin) ;
if ( dCurrZ > dZMax) {
dZMax = dCurrZ ;
ptZMax = ptUGlob ;
}
}
// determino elevazione sopra a ptEnd
double dEndElev = dSafeZ + abs( ( ptZMax - ptEnd) * vtMove) ;
double dStartElev = dSafeZ + abs( ( ptZMax - ptStart) * vtMove) ;
// definisco il collegamento
pCrvLink->AddPoint( ptEnd) ;
pCrvLink->AddLine( ptEnd + vtMove * dEndElev) ;
pCrvLink->AddLine( ptStart + vtMove * dStartElev) ;
pCrvLink->AddLine( ptStart) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetSurfaceNormalAtPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptTool, const Vector3d& vtTool,
const Vector3d& vtMove, Vector3d& vtNorm) const
{
// porto il punto e i versori nel riferimento superficie
Point3d ptToolL = GetToLoc( ptTool, frSurf) ;
Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
Vector3d vtMoveL = GetToLoc( vtMove, frSurf) ;
// porto i punti dal tip al naso mandrino
ptToolL += vtToolL * m_TParams.m_dLen ;
// affondo di poco il punto per ricavare ultima superficie di contatto e sua normale
double dMove ;
Vector3d vtNormL ;
if ( ! pCAvTlStm->TestPosition( ptToolL - vtToolL, vtToolL, vtMoveL, dMove, &vtNormL) || dMove < EPS_SMALL)
return false ;
// porto la normale in globale
vtNorm = GetToGlob( vtNormL, frSurf) ;
return true ;
}
//----------------------------------------------------------------------------
double
SurfFinishing::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
SurfFinishing::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
SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ICRVCOMPOPOVECTOR& vCrvCompo,
const Vector3d& vtTool, const Vector3d& vtMove, double dElev, double dDepth, bool bSplitArcs)
{
// se non ho curve, non faccio nulla
if ( vCrvCompo.empty())
return true ;
// se classe di calcolo per le collisioni non inizializzata, errore
if ( pCAvTlStm == nullptr)
return false ;
// tutte le curve devono essere valide e ben definite
for ( const PtrOwner<ICurveComposite>& pMCrv : vCrvCompo) {
if ( pMCrv == nullptr || ! pMCrv->IsValid())
return false ;
}
// recupero distanze di sicurezza
double dSafeZ = GetSafeZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
#if ENABLE_LINK_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "movements") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
int nLayCurve = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayCurve, "curves") ;
int nLayLink = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayLink, "links") ;
int nLayLeadInOut = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLayLeadInOut, "leadInOut") ;
Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
#endif
// ciclo sulle curve
bool bStart = true ;
double dStElev = dElev ;
Point3d ptStart, ptP1 ;
Vector3d vtStart ;
for ( int nCrv = 0 ; nCrv < ssize( vCrvCompo) ; ++ nCrv) {
#if ENABLE_LINK_DEBUG
int nIdCrv = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayCurve, CloneCurveComposite( vCrvCompo[nCrv])) ;
m_pGeomDB->SetMaterial( nIdCrv, PURPLE) ;
#endif
// ciclo sulle curve elementari
int nMaxInd = vCrvCompo[nCrv]->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = vCrvCompo[nCrv]->GetCurve( i) ;
// copio la curva
PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
if ( IsNull( pCurve))
return false ;
// --- se prima entità in assoluto
if ( bStart) {
// dati inizio entità
pCurve->GetStartPoint( ptStart) ;
pCurve->GetStartDir( vtStart) ;
// determino normale della superficie sul punto iniziale
Vector3d vtNorm ;
if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtMove, vtNorm)) {
Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtMove, vtNorm))
vtNorm = V_NULL ;
}
// determino inizio attacco
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
return false ;
#if ENABLE_LINK_DEBUG
PtrOwner<IGeoPoint3d> pt( CreateGeoPoint3d()) ;
pt->Set( ptStart) ;
int nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayLeadInOut, pt->Clone()) ;
m_pGeomDB->SetMaterial( nPtId, BLUE) ;
pt->Set( ptP1) ;
nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayLeadInOut, pt->Clone()) ;
m_pGeomDB->SetMaterial( nPtId, AQUA) ;
#endif
// eventuale correzione inizio attacco per evitare interferenze
if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptP1, ptStart, vtStart, vtTool, vtMove, true, ptP1))
return false ;
#if ENABLE_LINK_DEBUG
pt->Set( ptP1) ;
nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayLeadInOut, pt->Clone()) ;
m_pGeomDB->SetMaterial( nPtId, TEAL) ;
#endif
// determino elevazione su inizio attacco
if ( ! GetElevation( m_nPhase, ptStart - 10. * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtMove, dStElev))
dStElev = dElev ;
dStElev -= ( ptP1 - ptStart) * vtTool ;
// --- approccio globale al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
return false ;
}
bStart = false ;
// --- aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
return false ;
}
}
// elaborazioni sulla curva corrente (segmento di retta o arco)
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptP3 = pLine->GetEnd() ;
Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
SetFeed( GetRightFeed( vtMove, vtTool)) ;
if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
return false ;
}
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
Vector3d vtMove ; pArc->GetStartDir( vtMove) ;
SetFeed( GetRightFeed( vtMove, vtTool)) ;
if ( AddCurveMove( pArc, bSplitArcs) == GDB_ID_NULL)
return false ;
}
// --- se ultima entità
if ( i == nMaxInd) {
// dati fine entità
Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ;
// --- se ultima entità in assoluto
if ( nCrv == ssize( vCrvCompo) - 1) {
// determino normale della superficie sul punto finale
Vector3d vtNorm ;
if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtMove, vtNorm)) {
Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtMove, vtNorm))
vtNorm = V_NULL ;
}
// determino fine uscita
if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
return false ;
#if ENABLE_LINK_DEBUG
PtrOwner<IGeoPoint3d> pt( CreateGeoPoint3d()) ;
pt->Set( ptEnd) ;
int nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayLeadInOut, pt->Clone()) ;
m_pGeomDB->SetMaterial( nPtId, BLUE) ;
pt->Set( ptP1) ;
nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayLeadInOut, pt->Clone()) ;
m_pGeomDB->SetMaterial( nPtId, AQUA) ;
#endif
// eventuale correzione fine uscita per evitare interferenze
if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtEnd, vtTool, vtMove, false, ptP1))
return false ;
#if ENABLE_LINK_DEBUG
pt->Set( ptP1) ;
nPtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayLeadInOut, pt->Clone()) ;
m_pGeomDB->SetMaterial( nPtId, TEAL) ;
#endif
// aggiungo uscita
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
return false ;
}
// determino elevazione su fine uscita
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10. * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
// aggiungo retroazione finale
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
return false ;
}
}
// --- se ultima entità di percorso intermedio
else {
// punto iniziale entità per la curva successiva
vCrvCompo[nCrv+1]->GetStartPoint( ptStart) ;
// se inizio e fine sono coincidenti, non faccio nulla
if ( AreSamePointApprox( ptEnd, ptStart))
continue ;
// definisco il collegamento tra i due percorsi
PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
if ( IsNull( pCrvLink) ||
! GetLinkFromPaths( ptStart, ptEnd, vtTool, vtMove, pSfrCnt, dDepth, dSafeZ, pCAvTlStm, frSurf, pCrvLink))
return false ;
#if ENABLE_LINK_DEBUG
int nIdLink = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayLink, CloneCurveComposite( pCrvLink)) ;
m_pGeomDB->SetMaterial( nIdLink, RED) ;
#endif
SetFeed( GetEndFeed()) ;
if ( ! AddCurveMove( pCrvLink, bSplitArcs))
return false ;
ptP1 = ptStart ;
}
}
}
}
ExeProcessEvents( 100, 0) ;
return true ;
}
//----------------------------------------------------------------------------
double
SurfFinishing::GetLocalSideAngle() const
{
// se non ho un frame Valido, allora è rispetto all'asse x globale
if ( ! m_Frame.IsValid())
return m_Params.m_dSideAngle ;
// calcolo l'angolo tra l'asse x generale e l'asse x locale
// NB. Il frame Locale è sempre orientato con il versore Z perpendicolare alle curve di Finitura selezionate
double dExtraSideAng = 0. ;
bool bDet ;
Frame3d frSrf ;
frSrf.Set( ORIG, m_Frame.VersZ()) ;
frSrf.VersX().GetRotation( m_Frame.VersX(), m_Frame.VersZ(), dExtraSideAng, bDet) ;
return ( m_Params.m_dSideAngle + dExtraSideAng) ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetLocalToolDir( Vector3d& vtToolLoc) const
{
// l'orientamento dell'utensile mediante il versore ausiliario definito dagli angoli theta e phi viene applicato solo
// se lavorazione in Spiral, ZigZag, OneWay o Projection
if ( m_Params.m_nSubType != SURFFIN_SUB_ZIGZAG && m_Params.m_nSubType != SURFFIN_SUB_ONEWAY &&
m_Params.m_nSubType != SURFFIN_SUB_SPIRALIN && m_Params.m_nSubType != SURFFIN_SUB_SPIRALOUT &&
m_Params.m_nSubType != SURFFIN_SUB_PROJECT)
return false ;
// ricerca del vettore direzione utensile locale all'interno del gruppo Owner della lavorazione di finitura corrente
int nFrameId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUXVIEW) ;
if ( nFrameId == GDB_ID_NULL)
return false ;
int nId = m_pGeomDB->GetFirstInGroup( nFrameId) ;
while ( nId != GDB_ID_NULL) {
if ( m_pGeomDB->GetGeoType( nId) == GEO_VECT3D) {
const IGeoVector3d* vGeoLoc = GetGeoVector3d( m_pGeomDB->GetGeoObj( nId)) ;
if ( vGeoLoc != nullptr && vGeoLoc->IsValid()) {
vtToolLoc = vGeoLoc->GetVector() ;
vtToolLoc.Normalize() ;
return true ;
}
}
nId = m_pGeomDB->GetNext( nId) ;
}
return false ;
}
Reference in New Issue View Git Blame Copy Permalink