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

6856 lines
296 KiB
C++
Raw Permalink 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 <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"
// 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. ;
enum {
PENCIL_CORNER = 0,
PENCIL_FAT_CORNER = 1,
PENCIL_REGION = 2
} ;
#define DEBUG 0
#define DEBUG_SFR 0
#define ENABLE_ZCONST_DEBUG 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
#if DEBUG || DEBUG_SFR || ENABLE_ZCONST_DEBUG || ENABLE_ZCONST_PATH_DEBUG || ENABLE_OPTIMAL_DEBUG || ENABLE_OPTIMAL_SOFT_DEBUG || ENABLE_PENCIL_DEBUG || ENABLE_OPTIMAL_FINAL_CURVES_DEBUG || ENABLE_LINK_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_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 ;
}
//----------------------------------------------------------------------------
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 ;
// 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 ;
// 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) ;
}
// 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) ;
// 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 ;
}
// 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 ( ! ProcessCrvCompo( 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::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) ;
}
}
// se finitura a proiezione di curve
if ( m_Params.m_nSubType == SURFFIN_SUB_PROJECT) {
int nGroupName = -1 ;
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ 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::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 ( 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 ( 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 < int( vSurfLoc.size()) ; ++ 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& vtTool,
double dDepth, ISurfFlatRegion* pSfrCnt)
{
// 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 < int( vSurfLoc.size()) ; ++ 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, vtTool) ;
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 ( auto& 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) ;
// 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 ( se 1 lato aperto)
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::ProcessCrvCompo( 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
Vector3d vtTool = 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 ;
}
// 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, 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
Vector3d vtTool = 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, vtTool, 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( vtTool * dElev) ;
dDepth += dElev ;
}
// controllo di non scendere al di sotto del grezzo con la depth
double dInvElev = 0. ;
pSfrCnt->Invert() ;
if ( ! CalcRegionElevation( pSfrCnt, vtTool, 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 ;
}
#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 ;
}
// alla regione di contorno applico un Offset stabilito dal parametro di Overlap
if ( ! pSfrCnt->Offset( m_Params.m_dOverlap + GetOffsR(), 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 ;
// tengo una copia della regione attuale, nel caso di finitura Optimal
PtrOwner<ISurfFlatRegion> pSfrCntOrig( CloneSurfFlatRegion( pSfrCnt)) ;
if ( IsNull( pSfrCntOrig) || ! 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, vtTool, 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 ;
// questa regione deve essere lavorata a SideStep
double dSideStepLowerBound = max( 0.5, m_Params.m_dSideStep) ; // per tolleranza di campionamento
if ( ! pSfrMaxDown->Offset( m_TParams.m_dDiam - dSideStepLowerBound + GetOffsR(), ICurve::OFF_FILLET))
return false ;
// 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, dDepth, dElev, bSplitArcs))
return false ;
break ;
case SURFFIN_SUB_ONEWAY :
if ( ! AddOneWay( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs))
return false ;
break ;
case SURFFIN_SUB_SPIRALIN :
if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs, true))
return false ;
break ;
case SURFFIN_SUB_SPIRALOUT :
if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, 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, 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,
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 vtAxL = vtTool ;
vtAxL.ToLoc( frSurf) ;
Vector3d vtMoveL = vtAxL ;
// scorro le curve
double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ;
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ 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( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
return false ;
// 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.ToLoc( frSurf) ;
// traslo della lunghezza utensile diminuita dell'affondamento
PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
// eseguo CAv
if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( i + 1) * dProgCoeff))
return false ;
// contro-traslo della lunghezza utensile
PL.Translate( - vtAxL * m_TParams.m_dLen) ;
// riporto la polilinea nel riferimento della curva
PL.ToGlob( frSurf) ;
// 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, double dDepth, double dElev, bool bSplitArcs)
{
// calcolo lo ZigZag
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, m_Params.m_dSideAngle, 5.,
POCKET_ZIGZAG, false, false, false, true, true, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., 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, 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, dElev, dDepth, bSplitArcs))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{
// calcolo OneWay
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, m_Params.m_dSideAngle, 5.,
POCKET_ONEWAY, false, false, false, true, true, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., 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, 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, dElev, dDepth, bSplitArcs))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
const Vector3d& vtTool, 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, m_Params.m_dSideAngle, 5.,
nType, false, false, false, true, true, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., 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, 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, 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 < int( vSrfLoc.size()) ; ++ nS) {
// recupero la superficie
const ISurf* pSurf = GetSurf( vSrfLoc[nS].Get()) ;
if ( pSurf == nullptr || ! pSurf->IsValid())
continue ;
int nType = pSurf->GetType() ;
PtrOwner<ISurfTriMesh> pStm ;
// se TriMesh
if ( nType == SRF_TRIMESH) {
const ISurfTriMesh* pSurftm = GetSurfTriMesh( pSurf) ;
if ( pSurftm != nullptr && pSurftm->IsValid() && pSurftm->GetTriangleCount() > 0) {
if ( ! pStm.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* pSurftm = pSBz->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)) {
// recupero la superficie piana dalle curve
SurfFlatRegionByContours SfrByC ;
for ( int nPL = 0 ; nPL < int( vPL.size()) ; ++ 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
// inserisco la Z del piano locale nell'insieme
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> pSfrZAmb( CloneSurfFlatRegion( pSfrClass)) ;
if ( IsNull( pSfrZAmb) || ! pSfrZAmb->IsValid() ||
! pSfrZAmb->Offset( m_TParams.m_dDiam / 2. + abs( m_Params.m_dOverlap), ICurve::OFF_FILLET))
return false ;
if ( ! GetZConstQuotesInsideSfrParallelToTool( vSrfLoc, frSurf, pSfrZAmb, 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 ( auto& 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 < int( ccClass.size()) ; ++ 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 ( auto& 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 < int( vCrvCompo.back().size()) ; ++ 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 < int( vCrvCompo.back().size()) ; ++ 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( int( i + 1), ptStart, vtStart, ptEnd, vtEnd))
return false ;
// se prima curva, assegno inizio della ricerca
if ( bFirst) {
ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
bFirst = false ;
}
}
// 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 ( size_t i = 0 ; i < vnInd.size() ; ++ 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 < int( vCrvCompo.back().size()) ; ++ 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 < int( vCrvCompo.size()) ; ++ i) {
for ( int j = 0 ; j < int( vCrvCompo[i].size()) ; ++ j) {
if ( vCrvCompo[i][j] == nullptr || ! vCrvCompo[i][j]->IsValid())
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, 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 < int( vCrvCompo.size()) ; ++ i) {
vSfrRemMatCol[i].resize( vCrvCompo[i].size()) ;
for ( int j = 0 ; j < int( vCrvCompo[i].size()) ; ++ 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 = int( vCrvCompo.size()) - 1 ; nR >= 1 ; -- nR) {
for ( int nC = 0 ; nC < int( vCrvCompo[nR].size()) ; ++ nC) {
for ( int nCol = 0 ; nCol < int( vCrvCompo[nR - 1].size()) ; ++ 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 = int( vCrvCompo.size()) - 1 ; nR >= 0 && ! bGroup ; -- nR) {
// scorro sulle colonne ( dalla prima all'ultima) [ordine casuale]
for ( int nC = 0 ; nC < int( vCrvCompo[nR].size()) && ! 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 < int( itLock->second.size()) ; ++ 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 < int( itUnLock->second.size()) && ! 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 < int( vIndependentCurveGroup.size()) ; ++ 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)) ;
}
}
// 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 < int( vMapGrpZLoc.size()) ; ++ 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 ( int( vIndependentCurveGroup[nPath].size()) == 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 < int( vIndependentCurveGroup[nPath].size()) - 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 ho una parete verticale ( localemente)
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))) ;
}
// --- se il tratto lineare è troppo lungo, non considero il collegamento come valido
else {
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 < int( ccClass.size()) ; ++ i) {
// recupero il tratto di curve 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 ptS_sfr ; pLineLinkProj->GetPointD1D2( ccClass[i].dParS, ICurve::FROM_MINUS, ptS_sfr) ;
Point3d ptE_sfr ; pLineLinkProj->GetPointD1D2( ccClass[i].dParE, ICurve::FROM_MINUS, ptE_sfr) ;
// scorro tutti i loop della regione di classificazione
for ( int j = 0 ; j < int( vCrvSfrLoops.size()) ; ++ j) {
// se i punti trovati sono sul loop corrente
if ( vCrvSfrLoops[j]->IsPointOn( ptS_sfr, LINK_TOL) &&
vCrvSfrLoops[j]->IsPointOn( ptE_sfr, LINK_TOL)) {
// devo orientare la SubCrv secondo il giusto verso di percorrenza
double dUS ; vCrvSfrLoops[j]->GetParamAtPoint( ptS_sfr, dUS, LINK_TOL) ;
double dUE ; vCrvSfrLoops[j]->GetParamAtPoint( ptE_sfr, 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)
// porto il link sul piano della curva più in alto tra le due
Point3d ptCheck ;
vIndependentCurveGroup[nPath][nCompo + 1]->GetStartPoint( ptCheck) ;
double dSfrDistNext = DistPointPlane( ptCheck, plProjection) ;
vIndependentCurveGroup[nPath][nCompo]->GetStartPoint( ptCheck) ;
double dSfrDistCurr = DistPointPlane( ptCheck, plProjection) ;
vCompoLink[nCompo + 1]->Translate( Z_AX * min( dSfrDistCurr, dSfrDistNext)) ;
// proietto tale Link sulla superficie
if ( ! CalcZConstProjectedLink( pCAvTlStm, frXY, frSurf, vtTool, dDepth, ptStartLink, ptEndLink, vCompoLink[nCompo + 1]))
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 < int( vIndependentCurveGroup[nPath].size()) - 1 ; ++ 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 < int( vCrvPath.size()) ; ++ i)
vCrvPath[i]->ToGlob( frXY) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcZConstProjectedLink( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frPocket,
const Frame3d& frSurf, const Vector3d& vtTool, double dDepth,
const Point3d ptStart_forced, const Point3d ptEnd_forced,
ICurveComposite* pCrv) const
{
// funzione per proiettare una curva su una supericie trimesh passando per la silhouette
// controllo dei parametri
if ( pCAvTlStm == nullptr || pCrv == nullptr || ! pCrv->IsValid())
return false ;
// approssimo la curva con una polilinea
PolyLine PL ;
if ( ! pCrv->ApproxWithLines( m_Params.m_dApprox, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
return false ;
// 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 vtAxL = GetToLoc( vtTool, frSurf) ;
Vector3d vtMoveL = vtAxL ;
// traslo della lunghezza utensile diminuita dell'affondamento
PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
// eseguo il test del percorso
if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox))
return false ;
// contro-traslo della lunghezza utensile
PL.Translate( - vtAxL * m_TParams.m_dLen) ;
// riporto la polilinea nel riferimento della curva
PL.ToLoc( frPocket) ;
// 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, ptStart_forced, false) ;
PL.AddUPoint( PL.GetPointNbr(), ptEnd_forced, true) ;
// controllo di non essere sceso oltre la depth (il link non per forza è vicino ad una curva di livello)
PNTULIST& myPtUList = PL.GetUPointList() ;
for ( POINTU& myPtU : myPtUList) {
#if ENABLE_ZCONST_DEBUG
PtrOwner<IGeoPoint3d> myPt( CreateGeoPoint3d()) ;
myPt->Set( myPtU.first) ;
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, myPt->Clone()) ;
m_pGeomDB->SetMaterial( a, WHITE) ;
#endif // ENABLE_OPTIMAL_DEBUG
if ( myPtU.first.z < - dDepth)
myPtU.first.z = - dDepth ;
}
// 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
pCrv->CopyFrom( pCompo) ;
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
PtrOwner<ISurfFlatRegion> pSfrClass( CloneSurfFlatRegion( pSfrCnt)) ;
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 < int( vSrfLoc.size()) ; ++ 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 < int( vCrvCompo.size()) && bNoCrv ; ++ i)
bNoCrv = ( vCrvCompo[i].empty()) ;
if ( bNoCrv)
return true ;
// collego tra loro le curve trovate
ICRVCOMPOPOVECTOR vCrvPath ;
if ( ! CreateZConstPaths( pCAvTlStm, 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 < int( vCrvPath.size()) ; ++ i)
vCrvPath[i]->ToGlob( frSurf) ;
// aggiungo i percorsi di finitura calcolati
if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vCrvPath, vtTool, dElev, dDepth, bSplitArcs))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::ApproxSilhouetteClosedPLForOptimal( PolyLine& PL, double dSampleTol, double dMaxLinTol, double dAngTol, double dLinFeaTol,
ICurveComposite* pCompoPL)
{
// approssimazione di una polyline di Silhouette per rimuovere Spikes di proiezione
// controllo dei parametri
if ( pCompoPL == nullptr)
return false ;
pCompoPL->Clear() ;
// se aperta errore
Plane3d plPL ;
double dArea ;
if ( ! PL.IsClosedAndFlat( plPL, dArea))
return false ;
// semplifico rimuovendo i punti allineati
PL.RemoveAlignedPoints( dSampleTol + 10 * EPS_SMALL) ;
// essendo chiusa, se presenti meno di 4 punti, non faccio nulla
int nPts = PL.GetPointNbr() ;
if ( nPts < 4)
return true ;
// porto la PolyLine nel frame LocaleXY
Frame3d frLoc ;
if ( ! frLoc.Set( plPL.GetPoint(), plPL.GetVersN()))
return false ;
PL.ToLoc( frLoc) ;
// --------------------------- scelta del punto iniziale ------------------------------
// creo un vettore contenente tutti i punti ( cerco nel mentre il segmento più lungo)
PNTVECTOR vPt ; vPt.reserve( nPts) ;
int nLongEdge = -1 ;
double dMaxSqLen = 0. ;
Point3d myPt ;
if ( ! PL.GetFirstPoint( myPt))
return false ;
vPt.emplace_back( myPt) ;
while ( PL.GetNextPoint( myPt)) {
double dCurrSqDist = SqDist( vPt.back(), myPt) ;
if ( dCurrSqDist > dMaxSqLen) {
dMaxSqLen = dCurrSqDist ;
nLongEdge = int( vPt.size()) - 1 ;
}
vPt.emplace_back( myPt) ;
}
if ( nLongEdge < 0 || nLongEdge > nPts - 2)
return false ;
// calcolo il punto iniziale come punto medio del segmento più lungo
Point3d ptStart = Media( vPt[nLongEdge], vPt[nLongEdge + 1]) ;
ChangePolyLineStart( PL, ptStart, 10 * EPS_SMALL) ;
nPts = PL.GetPointNbr() ;
// ---------------------- modifica dei punti Spike ---------------------------------
// creo un vettore di punti a partire dai punti della PolyLine
PNTVECTOR vPts ; vPts.reserve( nPts) ;
PL.GetFirstPoint( myPt) ;
vPts.emplace_back( myPt) ;
while ( PL.GetNextPoint( myPt))
vPts.emplace_back( myPt) ;
// dichiaro i versori tangenti consecutivi per il percorso della PolyLinea
Vector3d vtTanPrev, vtTan, vtTanAfter ;
// recupero il cosendo della tolleranza angolare
double dCosAngTol = abs( cos( dAngTol * DEGTORAD)) ;
// calcolo il quadrato della tolleranza lineare
double dSqMaxLinTol = dMaxLinTol * dMaxLinTol ;
// ciclo tutti i punti della PolyLine
for ( int i = 2 ; i < int( vPts.size()) - 1 ; ++ i) {
// se distanza tra punto attuale e precedente sopra al tolleranza, passo ai successivi
if ( SqDist( vPts[i], vPts[i-1]) > dSqMaxLinTol)
continue ;
// calcolo il versore tangente del segmento pecedente
vtTanPrev = vPts[i-1] - vPts[i-2] ;
vtTanPrev.Normalize() ;
// calcolo versore tangente attuale
vtTan = vPts[i] - vPts[i-1] ;
vtTan.Normalize() ;
// recupero la direzione successia
vtTanAfter = vPts[i+1] - vPts[i] ;
vtTanAfter.Normalize() ;
// controllo se l'angolo tra la direzione attuale e precedente supera la tolleranza
if ( abs( vtTanPrev * vtTan) > dCosAngTol && abs( vtTan * vtTanAfter) > dCosAngTol)
continue ; // se uno dei due sotto la tolleranza, analizzo segmento successivo
// se Spike individuato, modifico il punto corrente con il punto medio del segmento attuale
vPts[i] = Media( vPts[i], vPts[i-1]) ;
// il punto precedente diventa uguale all' i-2-esimo
vPts[i-1] = vPts[i-2] ;
}
// a partire da questi punti, creo la PolyLine
double dPar = -1 ;
PolyLine myPL ;
myPL.AddUPoint( ++ dPar, vPts[0]) ; // il primo punto è automaticamente inserito
Point3d myLastPtInPL = vPts[0] ;
for ( int i = 1 ; i < int( vPts.size()) ; ++ i) {
// se il punto corrente è già inserito nella PolyLine, passo al successivo
if ( AreSamePointApprox( vPts[i], myLastPtInPL))
continue ;
// altrimenti inserisco il punto nella Polyline e aggiorno il punto finale
myPL.AddUPoint( ++ dPar, vPts[i]) ;
myLastPtInPL = vPts[i] ;
}
// chiudo la PolyLine per sicurezza
myPL.Close() ;
// swap
swap( PL, myPL) ;
// recupero la curva composita dalla polyLine
if ( ! pCompoPL->FromPolyLine( PL) || ! pCompoPL->IsValid())
return false ;
// approssimo con archi
PolyArc PA ;
double dMyLinFea = dLinFeaTol ;
double dMyAngTol = dAngTol ;
if ( dMaxLinTol > LIN_TOL_STD) {
double dCoeff = ( dMaxLinTol - LIN_TOL_STD) / LIN_TOL_STD ;
dMyLinFea = min( LIN_FEA_STD + 1.0 * dCoeff * LIN_FEA_STD, 400.) ;
dMyAngTol = min( ANG_TOL_STD_DEG + 0.2 * dCoeff * ANG_TOL_STD_DEG, 60.) ;
}
if ( pCompoPL->ApproxWithArcsEx( dMaxLinTol, dMyAngTol, dMyLinFea, PA)) {
PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
if ( ! IsNull( pTempCrv) &&
pTempCrv->FromPolyArc( PA) &&
pTempCrv->RemoveSmallDefects( dMaxLinTol, ANG_TOL_STD_DEG) &&
pTempCrv->MergeCurves( dMaxLinTol, ANG_TOL_STD_DEG)) {
pCompoPL->CopyFrom( pTempCrv) ;
}
}
// riporto la curva nel frame di partenza
pCompoPL->ToGlob( frLoc) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetSfrBySilhouette( ICAvParSilhouettesSurfTm* pCavParSilh, double dDepth,
double dSilTolSamp, double dSilTolLin,
double dSilTolAng, ISurfFlatRegion* pSfrSil)
{
// funzione per resitutire una regione piana data la classe di calcolo per silhouette
// controllo dei parametri
if ( pSfrSil == nullptr)
return false ;
pSfrSil->Clear() ;
// recupero il vettore di PolyLine della silhouette
POLYLINEVECTOR vPL ;
if ( ! pCavParSilh->GetSilhouette( - dDepth, vPL))
return false ;
// creo la regione piana dalle PolyLine ricavate dalla Silhouette
SurfFlatRegionByContours SfrMaker ;
for ( auto& PL : vPL) {
// recupero la curva in base alla polyLine
PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
if ( IsNull( pSilCrv))
return false ;
if ( ! ApproxSilhouetteClosedPLForOptimal( PL, dSilTolSamp, dSilTolLin, ANG_TOL_STD_DEG, LIN_FEA_STD, pSilCrv))
return false ;
// aggiungo per regione
if ( ! SfrMaker.AddCurve( Release( pSilCrv)))
return false ;
}
// definisco la regione piana
PtrOwner<ISurfFlatRegion> pSfrTmp( SfrMaker.GetSurf()) ;
if ( ! IsNull( pSfrTmp) && pSfrTmp->IsValid())
pSfrSil->CopyFrom( pSfrTmp) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::SplitStmTrianglesByClippingAngle( const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
const Vector3d& vtTool, double dDepth, double dClippingAngle, double dTolerAngle,
ISURFTMPOVECTOR& vpStm1, ISURFTMPOVECTOR& vpStm2, double& dMaxFrontTriaRad) const
{
// Funzione per ciclare i triangoli di una TriMesh (*pStm)
// I triangoli che formano un angolo, in valore assoluto con vtTool, maggiore di dClippingAngle
// vengono inseriti nella zuppa TriaSoupZConst, gli altri in TriaSoupSpiral
// dMaxFrontTriaRad è il raggio massimo dei triangoli con normale che si discosta da vtTool per
// meno di dTolerAngle (triangoli frontalieri)
// definisco il piano di taglio alla profondità massima
Point3d ptCenter ; pSfrCnt->GetCentroid( ptCenter) ;
Plane3d plClipping ;
Point3d ptPlCl = GetToLoc( ptCenter, frSurf) ;
Vector3d vtNCl = GetToLoc( vtTool, frSurf) ;
if ( ! plClipping.Set( ptPlCl - vtNCl * ( dDepth + 25 * EPS_SMALL), - vtNCl))
return false ;
// porto il versore utensile nel riferimento locale
Vector3d vtToolLoc = vtTool ; vtToolLoc.ToLoc( frSurf) ;
// aggiusto i parametri
dClippingAngle = Clamp( dClippingAngle, 30., 60.) ; // [30°,60°]
dTolerAngle = Clamp( dTolerAngle, 1., 5.) ; // [1°,5°]
// definizione delle costanti
double dCosLimit = cos( dClippingAngle * DEGTORAD) ;
double dCosLimSup = cos( ( dClippingAngle - dTolerAngle) * DEGTORAD) ;
double dCosLimInf = cos( max( 0., ( dClippingAngle + dTolerAngle)) * DEGTORAD) ;
// scorro le superfici locali
for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
// recupero la regione come superficie trimesh (controllo la sua validità)
PtrOwner<ISurfTriMesh> pStm( CloneSurfTriMesh( GetSurfTriMesh( vSrfLoc[i].Get()))) ;
if ( IsNull( pStm) || ! pStm->IsValid())
continue ;
// NB. devo tagliare la supericie con un piano diretto come vtTool a profondità dDepth
// ( altrimenti rischio di calcolare regioni piane inutili)
if ( ! pStm->Cut( plClipping, false))
return false ;
// se non rimane nulla, passo alla successiva
if ( IsNull( pStm) || ! pStm->IsValid() || pStm->GetTriangleCount() == 0)
continue ;
// definizione delle sue zuppe di triangoli
StmFromTriangleSoup StmSoup1, StmSoup2 ;
StmSoup1.Start() ; StmSoup2.Start() ;
// scorro i triangoli della superficie
for ( int nT = 0 ; nT < pStm->GetTriangleCount() ; ++ nT) {
// recupero il triangolo corrente (controllo la sua validità)
Triangle3d Tria ; pStm->GetTriangle( nT, Tria) ;
if ( ! Tria.IsValid())
continue ;
// recupero la normale del triangolo
Vector3d vtN_tria = Tria.GetN() ;
// recupero il valore coseno dell'angolo
double dCos = vtN_tria * vtToolLoc ;
// se coseno negativo scarto il triangolo, non si lavorano i sottosquadra
if ( dCos < - EPS_SMALL)
continue ;
// se triangolo è forntaliero, lo inserisco nel vettore
if ( dCos < dCosLimSup && dCos > dCosLimInf) {
// recupero il raggio della sfera che contine il triangolo
BBox3d BBoxTria ;
double dRad ;
if ( ! Tria.GetLocalBBox( BBoxTria) || ! BBoxTria.GetRadius( dRad))
return false ;
// se raggio più grande del limite superiore, aggiorno
if ( dRad > dMaxFrontTriaRad)
dMaxFrontTriaRad = dRad ;
}
// se la normale del triangolo è sotto la tolleranza, lo inserisco nella zuppa ZConst
// più il prodottoscalare tende a 0, più i versori sono distanti
if ( ( abs( dCos) < dCosLimit + EPS_ANG_ZERO))
StmSoup1.AddTriangle( Tria.GetP( 0), Tria.GetP( 1), Tria.GetP( 2)) ;
else
StmSoup2.AddTriangle( Tria.GetP( 0), Tria.GetP( 1), Tria.GetP( 2)) ;
}
// fine scorrimento dei triangoli
StmSoup1.End() ; StmSoup2.End() ;
// recupero le superfici trimesh per ZCosnt (stmSoup1)
PtrOwner<ISurfTriMesh> pStmCurr( StmSoup1.GetSurf()) ;
while ( ! IsNull( pStmCurr) && pStmCurr->IsValid() && ( pStmCurr->GetTriangleCount() > 0)) {
// rimuovo le parti di superficie troppo piccole
for ( int nP = 0 ; nP < pStmCurr->GetPartCount() ; ++ nP) {
double dArea ;
if ( pStmCurr->GetPartArea( nP, dArea) && dArea < EPS_SMALL) {
pStmCurr->RemovePart( nP) ;
-- nP ;
}
}
// se rimane una superficie valida, allora la memorizzo
if ( pStmCurr->IsValid() && ( pStmCurr->GetTriangleCount() > 0))
vpStm1.emplace_back( Release( pStmCurr)) ;
// recupero eventuale altra superficie TriMesh
pStmCurr.Set( StmSoup1.GetSurf()) ;
} ;
// recupero le superfici trimesh per Spiral (stmSoup2)
pStmCurr.Set( StmSoup2.GetSurf()) ;
while ( ! IsNull( pStmCurr) && pStmCurr->IsValid() && ( pStmCurr->GetTriangleCount() > 0)) {
// rimuovo le parti di superficie troppo piccole
for ( int nP = 0 ; nP < pStmCurr->GetPartCount() ; ++ nP) {
double dArea ;
if ( pStmCurr->GetPartArea( nP, dArea) && dArea < EPS_SMALL) {
pStmCurr->RemovePart( nP) ;
-- nP ;
}
}
// se rimane una superficie valida, allora la memorizzo
if ( pStmCurr->IsValid() && ( pStmCurr->GetTriangleCount() > 0))
vpStm2.emplace_back( Release( pStmCurr)) ;
// recupero eventuale altra superficie TriMesh
pStmCurr.Set( StmSoup2.GetSurf()) ;
} ;
}
#if ENABLE_OPTIMAL_DEBUG
for ( int i = 0 ; i < int( vpStm1.size()) ; ++ i) { // ZConst -> Viola
PtrOwner<ISurfTriMesh> pStmToDraw( CloneSurfTriMesh( vpStm1[i])) ;
pStmToDraw->ToGlob( frSurf) ;
int _o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmToDraw->Clone()) ;
m_pGeomDB->SetMaterial( _o, PURPLE) ;
}
for ( int i = 0 ; i < int( vpStm2.size()) ; ++ i) { // Spiral -> Verde
PtrOwner<ISurfTriMesh> pStmToDraw( CloneSurfTriMesh( vpStm2[i])) ;
pStmToDraw->ToGlob( frSurf) ;
int _o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmToDraw->Clone()) ;
m_pGeomDB->SetMaterial( _o, GREEN) ;
}
#endif
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::OrderOptimalPathsByZLoc( const ISurfFlatRegion* pSfrCntZConst, const ISurfFlatRegion* pSfrCntZigZag,
VECTORPATHS& vCrvPaths) const
{
// le curve devono essere tutte valide
for ( auto& path : vCrvPaths) {
if ( path.pCrvPath == nullptr || ! path.pCrvPath->IsValid())
return false ;
}
// se ho meno di due percorsi, non faccio nulla
if ( int( vCrvPaths.size()) <= 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 && pSfrCntZigZag->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
// --- A parità di ptStart ordino per ptEnd crescente
sort( vBoundaryMap.begin(), vBoundaryMap.end(), []( const BoundaryMap& MapA, const BoundaryMap& MapB) {
if ( abs( get<1>( MapA) - get<1>( MapB)) < 10 * EPS_SMALL)
return ( get<2>( MapA) < get<2>( MapB)) ;
return ( get<1>( MapA) < get<1>( MapB)) ;
}) ;
VECTORPATHS vCrvPathsTmp ; vCrvPathsTmp.resize( vCrvPaths.size()) ;
for ( int i = 0 ; i < int( vBoundaryMap.size()) ; ++ i) {
vCrvPathsTmp[i].pCrvPath.Set( Release( vCrvPaths[get<0>( vBoundaryMap[i])].pCrvPath)) ;
vCrvPathsTmp[i].nType = vCrvPaths[get<0>( vBoundaryMap[i])].nType ;
}
swap( vCrvPathsTmp, vCrvPaths) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::ChooseFinishingForOptimal( const ISurfFlatRegion* pSfr, int nChunk, bool& bSpiral,
double& dSideAng)
{
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid())
return false ;
// controllo valore di nChunk
if ( nChunk < 0 || nChunk >= pSfr->GetChunkCount())
return false ;
// informazioni sul Chunk
int nLines = 0 ; double dMaxLineLen = 0. ; Vector3d vtTanMaxLine ;
int nArcs = 0 ; double dMaxArcLen = 0. ;
BBox3d BBox ; Vector3d vtX ;
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nChunk) ; ++ nL) {
// recupero il loop come curva composita
PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nChunk, nL))) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->IsValid())
return false ;
// se loop esterno calcolo il Box
if ( nL == 0) {
PolyLine PL ;
if ( ! pCompoLoop->ApproxWithLines( 100 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
return false ;
Point3d ptCenter ;
double dLen ; double dHeight ;
if ( ! PL.GetMinAreaRectangleXY( ptCenter, vtX, dLen, dHeight))
return false ;
}
// scorro le curve del Loop
for ( int nU = 0 ; nU < pCompoLoop->GetCurveCount() ; ++ nU) {
const ICurve* pCurve = pCompoLoop->GetCurve( nU) ;
if ( pCurve == nullptr || ! pCurve->IsValid())
return false ;
// se arco
if ( pCurve->GetType() == CRV_ARC) {
++ nArcs ;
double dLen ; pCurve->GetLength( dLen) ;
if ( dLen > dMaxArcLen)
dMaxArcLen = dLen ;
}
// se linea
else if ( pCurve->GetType() == CRV_LINE) {
++ nLines ;
double dLen ; pCurve->GetLength( dLen) ;
if ( dLen > dMaxLineLen) {
dMaxLineLen = dLen ;
pCurve->GetStartDir( vtTanMaxLine) ;
}
}
}
}
// di base lavorazione Spiral
bSpiral = true ;
// se l'entità più lunga è la linea
if ( dMaxLineLen > dMaxArcLen) {
// se ci sono in genere più linee che archi (60% linee)
if ( nLines / ( nLines + nArcs + 1) > .6) {
// se la direzione principale della linea concide con la direzione massima del box minimo
if ( AreSameOrOppositeVectorApprox( vtTanMaxLine, vtX)) {
bSpiral = false ; // ZigZag
X_AX.GetAngle( vtX, dSideAng) ;
dSideAng = abs( dSideAng) ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
ISurfTriMesh*
SurfFinishing::SplitStmTriaUnderClippingAngle( const SurfLocal SrfLoc, const Vector3d& vtTest, double dClippingAngle,
double dFrontTriaTolerAng, double& dMaxFrontTriaRad) const
{
// definisco le tolleranze
double dCosLimit = cos( dClippingAngle * DEGTORAD) ;
double dCosLimSup = cos( ( dClippingAngle - dFrontTriaTolerAng) * DEGTORAD) ;
double dCosLimInf = cos( max( 0., ( dClippingAngle + dFrontTriaTolerAng)) * DEGTORAD) ;
// recupero una superficie formata solo dai triangoli la cui normale ha un angolo minore di CLIPPING_EDGE
// rispetto al versore utensile
// scorro le superfici
StmFromTriangleSoup SpiralSoup ; SpiralSoup.Start() ;
// recupero la TriMesh ( solo la parte sopra alla dDepth)
const ISurfTriMesh* pStm = GetSurfTriMesh( SrfLoc.Get()) ;
if ( pStm == nullptr || ! pStm->IsValid())
return nullptr ;
// scorro i triangoli
for ( int nT = 0 ; nT < pStm->GetTriangleCount() ; ++ nT) {
// recupero il triangolo corrente (controllo la sua validità)
Triangle3d Tria ; pStm->GetTriangle( nT, Tria) ;
if ( ! Tria.IsValid())
continue ;
// recupero la normale del triangolo
Vector3d vtN_tria = Tria.GetN() ;
// recupero il valore coseno dell'angolo
double dCos = vtN_tria * vtTest ;
// se coseno negativo scarto il triangolo, non si lavorano i sottosquadra
if ( dCos < - EPS_SMALL)
continue ;
// se triangolo è forntaliero, lo inserisco nel vettore
if ( dCos < dCosLimSup && dCos > dCosLimInf) {
// recupero il raggio della sfera che contine il triangolo
BBox3d BBoxTria ;
double dRad ;
if ( ! Tria.GetLocalBBox( BBoxTria) || ! BBoxTria.GetRadius( dRad))
return nullptr ;
// se raggio più grande del limite superiore, aggiorno
if ( dRad > dMaxFrontTriaRad)
dMaxFrontTriaRad = dRad ;
}
// se la normale del triangolo è sopra la tolleranza, lo inserisco nella zuppa Spiral
// più il prodottoscalare tende a 0, più i versori sono distanti
if ( ( abs( dCos) > dCosLimit + EPS_ANG_ZERO))
SpiralSoup.AddTriangle( Tria.GetP( 0), Tria.GetP( 1), Tria.GetP( 2)) ;
}
SpiralSoup.End() ;
// recupero la superficie trimesh dalla zuppa
PtrOwner<ISurfTriMesh> pStmLoc( SpiralSoup.GetSurf()) ;
if ( ! IsNull( pStmLoc) && pStmLoc->IsValid() && pStmLoc->GetTriangleCount() > 0) {
pStmLoc->Repair() ; // rimozione possibili T-Junctions
#if ENABLE_OPTIMAL_DEBUG
int _o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmLoc->Clone()) ;
m_pGeomDB->SetMaterial( _o, PURPLE) ;
#endif
}
return Release( pStmLoc) ;
}
//----------------------------------------------------------------------------
ISurfFlatRegion*
SurfFinishing::GetSfrProjectedStmLoops( const ISURFTMPOVECTOR& vStm, const ISurfFlatRegion* pSfrContour,
const DBLVECTOR& vdLinFeaTol, const DBLVECTOR& vdAngTol, const DBLVECTOR& vdMaxLinTol) const
{
// controllo della regione di controllo
if ( pSfrContour == nullptr)
return nullptr ;
PtrOwner<ISurfFlatRegion> pSfr( CreateSurfFlatRegion()) ;
if ( IsNull( pSfr))
return nullptr ;
if ( ! pSfrContour->IsValid())
return Release( pSfr) ;
// definisco piano di proiezione dalla regione
Plane3d plProj ;
Point3d ptC ; pSfrContour->GetCentroid( ptC) ;
if ( ! plProj.Set( ptC, pSfrContour->GetNormVersor()))
return nullptr ;
// frame per classificazione delle curve (planeXY)
Frame3d frXY ;
if ( ! frXY.Set( ptC, pSfrContour->GetNormVersor()))
return nullptr ;
// per ogni superficie trimesh ...
for ( int nS = 0 ; nS < int( vStm.size()) ; ++ nS) {
// se non è valida allora passo alla successiva (potrebbe essere tutta associata a ZConst)
if ( vStm[nS] == nullptr || ! vStm[nS]->IsValid())
continue ;
// recupero le parti che la compongono
for ( int nP = 0 ; nP < vStm[nS]->GetPartCount() ; ++ nP) {
// se la Part corrente è piccola, la salto
double dArea = 0. ;
if ( vStm[nS]->GetPartArea( nP, dArea) && dArea < EPS_SMALL)
continue ;
// recupero i Loop della parte corrente
POLYLINEVECTOR vPL ;
if ( ! vStm[nS]->GetPartLoops( nP, vPL))
return nullptr ;
// recupero un vettore di curve composite (in 3d)
ICRVCOMPOPOVECTOR vCompoLoops ; vCompoLoops.reserve( vPL.size()) ;
for ( int nL = 0 ; nL < int( vPL.size()) ; ++ nL) {
if ( vPL[nL].IsClosed()) {
PtrOwner<ICurveComposite> pCompoLoop( CreateCurveComposite()) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->FromPolyLine( vPL[nL]) || ! pCompoLoop->IsValid())
return nullptr ;
// memorizzo la curva
vCompoLoops.emplace_back( Release( pCompoLoop)) ;
}
}
// creo un vettore di curve proiettate approssimate per la creazione della regione
SurfFlatRegionByContours SfrPart ;
for ( int nL = 0 ; nL < int( vCompoLoops.size()) ; ++ nL) {
#if ENABLE_OPTIMAL_DEBUG
//int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCompoLoops[nL]->Clone()) ;
//m_pGeomDB->SetMaterial( _a, WHITE) ;
#endif
// la proietto sul piano di proiezione
PtrOwner<ICurve> pCompoProj( ProjectCurveOnPlane( *vCompoLoops[nL], plProj)) ;
if ( IsNull( pCompoProj) || ! pCompoProj->IsValid())
continue ;
pCompoProj->ToLoc( frXY) ;
SelfIntersCurve SIC( *pCompoProj) ;
if ( SIC.GetIntersCount() > 0)
continue ;
pCompoProj->ToGlob( frXY) ;
#if ENABLE_OPTIMAL_DEBUG
//int _b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompoProj->Clone()) ;
//m_pGeomDB->SetMaterial( _b, AQUA) ;
#endif
SfrPart.AddCurve( Release( pCompoProj)) ;
}
PtrOwner<ISurfFlatRegion> pSfrPart( SfrPart.GetSurf()) ;
if ( ! IsNull( pSfrPart) && pSfrPart->IsValid()) {
// controllo che sia orientata corretamente
if ( AreOppositeVectorApprox( pSfrContour->GetNormVersor(), pSfrPart->GetNormVersor()))
pSfrPart->Invert() ;
// aggiungo alla regione *pSfr
if ( pSfr->IsValid()) {
if ( ! pSfr->Add( *pSfrPart))
return nullptr ;
}
else
pSfr.Set( pSfrPart) ;
}
}
}
#if ENABLE_OPTIMAL_DEBUG
Color myColor = AQUA ; myColor.SetAlpha( .25) ;
int _b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfr->Clone()) ;
m_pGeomDB->SetMaterial( _b, myColor) ;
#endif
return Release( pSfr) ;
}
//----------------------------------------------------------------------------
Point3d
SurfFinishing::CalcShapedPoint( const PNTUVVECT& myInfoStart, const PNTUVVECT& myInfoEnd, int nType, const Vector3d& vtAxL,
const Vector3d& vtMoveL, double dCosSplitAngle, double dLimInfCosSplitAng,
double dLimSupCosSplitAng, ICAvToolSurfTm* pCAvTlStm, int _nInd_debug) const
{
// recupero il tipo di ShapedPoint richiesto
if ( nType != 0 && nType != 1 && nType != 2)
return P_INVALID ;
bool bSpiral = ( nType == 0) ;
bool bZConst = ( nType == 1) ;
bool bBorder = ( nType == 2) ;
// metodo id bisezione
const int MAX_ITER = 10 ;
int nCount = 0 ;
PNTUVVECT ptU_vt1 = make_tuple( get<0>( myInfoStart), get<1>( myInfoStart), get<2>( myInfoStart)) ;
PNTUVVECT ptU_vt2 = make_tuple( get<0>( myInfoEnd), get<1>( myInfoEnd), get<2>( myInfoEnd)) ;
Point3d ptMid = Media( get<0>( ptU_vt1), get<0>( ptU_vt2)) ;
while ( nCount < MAX_ITER) {
// se estremi coincidenti, allora mi fermo
if ( SqDist( get<0>( ptU_vt1), get<0>( ptU_vt2)) < 4 * SQ_EPS_SMALL)
return ptMid ;
// verifica del punto medio
Point3d ptTest = ptMid ;
double dMove = 0. ;
VCT3DVECTOR vVtN ;
if ( ! pCAvTlStm->TestPositionAdv( ptTest, vtAxL, vtMoveL, dMove, vVtN))
return P_INVALID ;
// collisione nel punto medio
bool bMidColl = false ;
for ( int nV = 0 ; nV < int( vVtN.size()) && ! bMidColl ; ++ nV) {
double dAbsCos = abs( vVtN[nV] * vtAxL) ;
bMidColl = ( bSpiral ? dAbsCos > dCosSplitAngle + EPS_ANG_ZERO :
bZConst ? dAbsCos < dCosSplitAngle + EPS_ANG_ZERO :
bBorder ? dAbsCos > dLimInfCosSplitAng + EPS_ANG_ZERO &&
dAbsCos < dLimSupCosSplitAng + EPS_ANG_ZERO : false) ;
}
#if ENABLE_OPTIMAL_DEBUG
PtrOwner<IGeoPoint3d> myPt( CreateGeoPoint3d()) ;
myPt->Set( ptMid) ;
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, _nInd_debug, myPt->Clone()) ;
m_pGeomDB->SetMaterial( _a, bMidColl ? ORANGE : AQUA) ;
#endif
// collisione nel punto 1 di riferimento
bool b1Coll = false ;
for ( int nV = 0 ; nV < int( get<2>( ptU_vt1).size()) && ! b1Coll ; ++ nV) {
double dAbsCos = abs( get<2>( ptU_vt1)[nV] * vtAxL) ;
b1Coll = ( bSpiral ? dAbsCos > dCosSplitAngle + EPS_ANG_ZERO :
bZConst ? dAbsCos < dCosSplitAngle + EPS_ANG_ZERO :
bBorder ? dAbsCos > dLimInfCosSplitAng + EPS_ANG_ZERO &&
dAbsCos < dLimSupCosSplitAng + EPS_ANG_ZERO : false) ;
}
// definizione del nuovo intervallo per interpolazione
if ( b1Coll != bMidColl)
ptU_vt2 = make_tuple( ptMid, dMove, vVtN) ;
else
ptU_vt1 = make_tuple( ptMid, dMove, vVtN) ;
ptMid = Media( get<0>( ptU_vt1), get<0>( ptU_vt2)) ;
++ nCount ;
}
return ptMid ;
}
//----------------------------------------------------------------------------
int
SurfFinishing::ProcessSquare( int nFlag, double dLevel, double dQPt0, double dQpt1, double dQpt2, double dQpt3,
int& nI1s, int& nI1e, int& nI2s, int& nI2e) const
{
// Quadrato (C=corner E=edge) :
//
// C3 - E2 - C2
// | * * |
// E3 * E1
// | * * |
// C0 - E0 - C1
static int LineTable[16][4] = { { 0, -1, -1, -1}, // ( 0)
{ 2, 0, 5, 3}, // ( 1)
{ 2, 1, 4, 0}, // ( 2)
{ 1, 1, 3, -1}, // ( 3)
{ 2, 2, 5, 1}, // ( 4)
{ -1, -1, -1, -1}, // ( 5) -> ambiguo
{ 1, 2, 0, -1}, // ( 6)
{ 2, 2, 4, 3}, // ( 7)
{ 2, 3, 4, 2}, // ( 8)
{ 1, 0, 2, -1}, // ( 9)
{ -1, -1, -1, -1}, // ( 10) -> ambiguo
{ 2, 1, 5, 2}, // ( 11)
{ 1, 3, 1, -1}, // ( 12)
{ 2, 0, 4, 1}, // ( 13)
{ 2, 3, 5, 0}, // ( 14)
{ 0, -1, -1, -1} } ; // ( 15)
static int LineTableAmbiguos[4][5] = { { 2, 2, 1, 0, 3}, // ( 5-split)
{ 2, 2, 3, 0, 1}, // ( 5-stick)
{ 2, 1, 0, 3, 2}, // ( 10-split)
{ 2, 1, 2, 3, 0} } ; // ( 10-stick)
// flag fuori dai limiti
if ( nFlag < 0 || nFlag > 15)
return -1 ;
// nessuna linea
if ( LineTable[nFlag][0] == 0)
return 0 ;
int nLines = LineTable[nFlag][0] ;
// se almeno una linea
if ( nLines > 0) {
nI1s = LineTable[nFlag][1] ;
nI1e = LineTable[nFlag][2] ;
}
// se due linee
if ( nLines == 2) {
nI2s = LineTable[nFlag][2] ;
nI2e = LineTable[nFlag][3] ;
}
// se ambiguo
if ( nLines == -1) {
nLines = 2 ;
int nJump = ( nFlag == 5 ? 0 : 2) ;
int nShift = ( ( dQPt0 - dLevel) * ( dQpt2 - dLevel) > ( dQpt1 - dLevel) * ( dQpt3 - dLevel) ? 1 : 0) ;
nI1s = LineTableAmbiguos[nJump + nShift][1] ;
nI1e = LineTableAmbiguos[nJump + nShift][2] ;
nI2s = LineTableAmbiguos[nJump + nShift][3] ;
nI2e = LineTableAmbiguos[nJump + nShift][4] ;
}
return nLines ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::TestSubEdges( unordered_map<int, Point3d>& umEdgePnt, const INTVECTOR& vEdgeInd, int nType, int nFirst, int nLast,
const VECTORCOLLISIONSFR& vPntM, int nStepX, const Vector3d vtAxL, const Vector3d& vtMoveL,
double dCosSplitAng, double dLimInfCosSplitAng, double dLimSupCosSplitAng, ICAvToolSurfTm* pCAvTlStm, int _nInd_debug) const
{
for ( int k = nFirst ; k <= nLast ; ++ k) {
// recupero i differenti indici
int nKey = vEdgeInd[k] ;
int nInd = nKey / 4 ;
int nIndS, nIndE ;
int nMod = nKey % 4 ;
switch ( nMod)
{
case ( 0) :
nIndS = nInd ;
nIndE = nInd + 1 ;
break ;
case ( 1) :
nIndS = nInd ;
nIndE = nInd + nStepX + 1 ;
break ;
case ( 2) :
nIndS = nInd + 1 ;
nIndE = nInd + nStepX + 1 ;
break ;
case ( 3) :
nIndS = nInd ;
nIndE = nInd + nStepX + 2 ;
break ;
}
// calcolo il punto
Point3d ptQ = CalcShapedPoint( vPntM[nIndS].CollisionInfo, vPntM[nIndE].CollisionInfo, nType,
vtAxL, vtMoveL, dCosSplitAng, dLimInfCosSplitAng, dLimSupCosSplitAng, pCAvTlStm, _nInd_debug) ;
if ( ! ptQ.IsValid())
return false ;
umEdgePnt[nKey] = ptQ ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::MarchingSquares( const VECTORCOLLISIONSFR& vPntM, int nType, double dOffsTol, int nStepX, int nStepY, double dClippingAngle,
double dLimInfClippingAng, double dLimSupClippingAng, const Vector3d& vtAxL, const Vector3d& vtMoveL, ICAvToolSurfTm* pCAvTlStm,
ICRVCOMPOPOVECTOR& vCrvCompo) const
{
int _nInd_debug = GDB_ID_NULL ;
#if ENABLE_OPTIMAL_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "_marchingsquare") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_ON) ;
int nLyS = GDB_ID_NULL ;
int nLyZC = GDB_ID_NULL ;
int nLyBo = GDB_ID_NULL ;
if ( nType == 0) {
nLyS = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLyS, "_spiral") ;
m_pGeomDB->SetStatus( nLyS, GDB_ST_OFF) ;
_nInd_debug = nLyS ;
}
else if ( nType == 1) {
nLyZC = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLyZC, "_zconst") ;
m_pGeomDB->SetStatus( nLyZC, GDB_ST_OFF) ;
_nInd_debug = nLyZC ;
}
else if ( nType == 2) {
nLyBo = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLyBo, "_border") ;
m_pGeomDB->SetStatus( nLyBo, GDB_ST_OFF) ;
_nInd_debug = nLyBo ;
}
#endif
// definisco il tipo di contorno richiesto
if ( nType != 0 && nType != 1 && nType != 2)
return false ;
bool bSpiral = ( nType == 0) ;
bool bZConst = ( nType == 1) ;
bool bBorder = ( nType == 2) ;
// Analizzo gli edge da cui passano le curve cercate
vCrvCompo.clear() ;
unordered_map<int, Point3d> umEdgePnt( 6 * ( nStepX + nStepY)) ;
INTVECTOR vEdgeInd ;
vEdgeInd.reserve( 6 * ( nStepX + nStepY)) ;
double dCosSplitAngle = cos( dClippingAngle * DEGTORAD) ;
double dLimInfCosSplitAngle = cos( dLimInfClippingAng * DEGTORAD) ;
double dLimSupCosSplitAngle = cos( dLimSupClippingAng * DEGTORAD) ;
// Ciclo sui quadrati da analizzare
for ( int j = 0 ; j < nStepY ; ++ j) {
for ( int i = 0 ; i < nStepX ; ++ i) {
// indici dei vertici nella griglia
int nInd0 = i + j * ( nStepX + 1) ;
int nInd1 = ( i + 1) + j * ( nStepX + 1) ;
int nInd2 = ( i + 1) + ( j + 1) * ( nStepX + 1) ;
int nInd3 = i + ( j + 1) * ( nStepX + 1) ;
// flag del quadrato
bool bUp0 = ( bSpiral ? vPntM[nInd0].bInSpiral :
bZConst ? vPntM[nInd0].bInZConst :
bBorder ? vPntM[nInd0].bOnBorder : false) ;
bool bUp1 = ( bSpiral ? vPntM[nInd1].bInSpiral :
bZConst ? vPntM[nInd1].bInZConst :
bBorder ? vPntM[nInd1].bOnBorder : false) ;
bool bUp2 = ( bSpiral ? vPntM[nInd2].bInSpiral :
bZConst ? vPntM[nInd2].bInZConst :
bBorder ? vPntM[nInd2].bOnBorder : false) ;
bool bUp3 = ( bSpiral ? vPntM[nInd3].bInSpiral :
bZConst ? vPntM[nInd3].bInZConst :
bBorder ? vPntM[nInd3].bOnBorder : false) ;
// se tutti uguali, passo al successivo
if ( bUp0 == bUp1 && bUp0 == bUp2 && bUp0 == bUp3)
continue ;
// verifico Edge da calcolare
if ( bUp0 != bUp1) {
int nKey = 4 * nInd0 ;
if ( umEdgePnt.find( nKey) == umEdgePnt.end()) {
umEdgePnt[nKey] = P_INVALID ;
vEdgeInd.emplace_back( nKey) ;
}
}
if ( bUp3 != bUp2) {
int nKey = 4 * nInd3 ;
if ( umEdgePnt.find( nKey) == umEdgePnt.end()) {
umEdgePnt[nKey] = P_INVALID ;
vEdgeInd.emplace_back( nKey) ;
}
}
if ( bUp0 != bUp3) {
int nKey = 4 * nInd0 + 1 ;
if ( umEdgePnt.find( nKey) == umEdgePnt.end()) {
umEdgePnt[nKey] = P_INVALID ;
vEdgeInd.emplace_back( nKey) ;
}
}
if ( bUp1 != bUp2) {
int nKey = 4 * nInd1 + 1 ;
if ( umEdgePnt.find( nKey) == umEdgePnt.end()) {
umEdgePnt[nKey] = P_INVALID ;
vEdgeInd.emplace_back( nKey) ;
}
}
int nFlag = ( bSpiral ? ( ( vPntM[nInd0].bInSpiral ? 1 : 0) + ( vPntM[nInd1].bInSpiral ? 2 : 0) +
( vPntM[nInd2].bInSpiral ? 4 : 0) + ( vPntM[nInd3].bInSpiral ? 8 : 0)) :
bZConst ? ( ( vPntM[nInd0].bInZConst ? 1 : 0) + ( vPntM[nInd1].bInZConst ? 2 : 0) +
( vPntM[nInd2].bInZConst ? 4 : 0) + ( vPntM[nInd3].bInZConst ? 8 : 0)) :
bBorder ? ( ( vPntM[nInd0].bOnBorder ? 1 : 0) + ( vPntM[nInd1].bOnBorder ? 2 : 0) +
( vPntM[nInd2].bOnBorder ? 4 : 0) + ( vPntM[nInd3].bOnBorder ? 8 : 0)) : 0) ;
if ( nFlag == 1 || nFlag == 2 || nFlag == 4 || nFlag == 7 || nFlag == 8 || nFlag == 11 ||
nFlag == 13 || nFlag == 14) {
if ( bUp1 != bUp3) {
int nKey = 4 * nInd0 + 2 ;
if ( umEdgePnt.find( nKey) == umEdgePnt.end()) {
umEdgePnt[nKey] = P_INVALID ;
vEdgeInd.emplace_back( nKey) ;
}
}
if ( bUp0 != bUp2) {
int nKey = 4 * nInd0 + 3 ;
if ( umEdgePnt.find( nKey) == umEdgePnt.end()) {
umEdgePnt[nKey] = P_INVALID ;
vEdgeInd.emplace_back( nKey) ;
}
}
}
}
}
// Numero di edge da valutare
int nEdgeCnt = int( vEdgeInd.size()) ;
// Recupero il numero massimo di thread concorrenti
int nThreadMax = ( thread::hardware_concurrency()) / 2 ;
bool bOk = true ;
// Se un solo thread o pochi punti
if ( nThreadMax <= 1 || nEdgeCnt < 50)
TestSubEdges( umEdgePnt, vEdgeInd, nType, 0, nEdgeCnt - 1, vPntM, nStepX, vtAxL, vtMoveL,
dCosSplitAngle, dLimInfCosSplitAngle, dLimSupCosSplitAngle, pCAvTlStm, _nInd_debug) ;
// altrimenti
else {
const int MAX_PARTS = 32 ;
INTINTVECTOR vFstLst( MAX_PARTS) ;
// calcolo le parti del vettore
int nPartCnt = min( nThreadMax, MAX_PARTS) ;
int nPartDim = nEdgeCnt / nPartCnt + 1 ;
for ( int i = 0 ; i < nPartCnt ; ++ i) {
vFstLst[i].first = i * nPartDim ;
vFstLst[i].second = min( ( i + 1) * nPartDim, nEdgeCnt) - 1 ;
}
// processo le parti
future<bool> vRes[MAX_PARTS] ;
for ( int i = 0 ; i < nPartCnt ; ++ i)
vRes[i] = async( launch::async, &SurfFinishing::TestSubEdges, this, ref( umEdgePnt), cref( vEdgeInd),
nType, vFstLst[i].first, vFstLst[i].second, cref( vPntM), nStepX, cref( vtAxL),
cref( vtMoveL), dCosSplitAngle, dLimInfCosSplitAngle, dLimSupCosSplitAngle, ref( pCAvTlStm), _nInd_debug) ;
// attendo i risultati
int nFin = 0 ;
while ( nFin < nPartCnt) {
for ( int i = 0 ; i < nPartCnt ; ++ i) {
if ( vRes[i].valid() && vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
bOk = vRes[i].get() && bOk ;
++ nFin ;
}
}
}
}
// Predispongo il concatenamento
BIPNTVECTOR vBiPnt ;
vBiPnt.reserve( 2 * ( nStepX + nStepY)) ;
ChainCurves chainC ;
chainC.Init( false, EPS_SMALL, 2 * ( nStepX + nStepY)) ;
// Ciclo sui quadrati da analizzare
for ( int j = 0 ; j < nStepY ; ++ j) {
for ( int i = 0 ; i < nStepX ; ++ i) {
// indici dei vertici nella griglia
int nInd0 = i + j * ( nStepX + 1) ;
int nInd1 = ( i + 1) + j * ( nStepX + 1) ;
int nInd2 = ( i + 1) + ( j + 1) * ( nStepX + 1) ;
int nInd3 = i + ( j + 1) * ( nStepX + 1) ;
// flag del quadrato
int nFlag = ( bSpiral ? ( ( vPntM[nInd0].bInSpiral ? 1 : 0) + ( vPntM[nInd1].bInSpiral ? 2 : 0) +
( vPntM[nInd2].bInSpiral ? 4 : 0) + ( vPntM[nInd3].bInSpiral ? 8 : 0)) :
bZConst ? ( ( vPntM[nInd0].bInZConst ? 1 : 0) + ( vPntM[nInd1].bInZConst ? 2 : 0) +
( vPntM[nInd2].bInZConst ? 4 : 0) + ( vPntM[nInd3].bInZConst ? 8 : 0)) :
bBorder ? ( ( vPntM[nInd0].bOnBorder ? 1 : 0) + ( vPntM[nInd1].bOnBorder ? 2 : 0) +
( vPntM[nInd2].bOnBorder ? 4 : 0) + ( vPntM[nInd3].bOnBorder ? 8 : 0)) : 0) ;
// se quadrato con vertici tutti dello stesso tipo, passo al successivo
if ( nFlag == 0 || nFlag == 15)
continue ;
// chiavi
int vKey[6] = { 4 * nInd0, 4 * nInd1 + 1, 4 * nInd3, 4 * nInd0 + 1, 4 * nInd0 + 2, 4 * nInd0 + 3} ;
// calcolo segmenti da inserire
int nI1s, nI1e, nI2s, nI2e ;
double dLevel = .25 * ( get<1>( vPntM[nInd0].CollisionInfo) + get<1>( vPntM[nInd1].CollisionInfo) +
get<1>( vPntM[nInd2].CollisionInfo) + get<1>( vPntM[nInd3].CollisionInfo)) ;
int nSegCnt = ProcessSquare( nFlag, dLevel, get<1>( vPntM[nInd0].CollisionInfo), get<1>( vPntM[nInd1].CollisionInfo),
get<1>( vPntM[nInd1].CollisionInfo), get<1>( vPntM[nInd3].CollisionInfo), nI1s, nI1e, nI2s, nI2e) ;
if ( nSegCnt == -1)
return false ;
else if ( nSegCnt > 0) {
// inserisco il primo
Point3d ptL1s = umEdgePnt.find( vKey[nI1s])->second ;
Point3d ptL1e = umEdgePnt.find( vKey[nI1e])->second ;
vBiPnt.emplace_back( ptL1s, ptL1e) ;
Vector3d vtDir1 = ptL1e - ptL1s ; vtDir1.Normalize() ;
chainC.AddCurve( int( vBiPnt.size()), ptL1s, vtDir1, ptL1e, vtDir1) ;
#if ENABLE_OPTIMAL_DEBUG
PtrOwner<ICurveLine> pMyLine( CreateCurveLine()) ;
pMyLine->Set( ptL1s, ptL1e) ;
pMyLine->SetExtrusion( vtAxL) ;
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, _nInd_debug , Release( pMyLine)) ;
m_pGeomDB->SetMaterial( a, GREEN) ;
#endif
// inserisco il secondo se esiste
if ( nSegCnt == 2) {
Point3d ptL2s = umEdgePnt.find( vKey[nI2s])->second ;
Point3d ptL2e = umEdgePnt.find( vKey[nI2e])->second ;
vBiPnt.emplace_back( ptL2s, ptL2e) ;
Vector3d vtDir2 = ptL2e - ptL2s ; vtDir2.Normalize() ;
chainC.AddCurve( int( vBiPnt.size()), ptL2s, vtDir2, ptL2e, vtDir2) ;
#if ENABLE_OPTIMAL_DEBUG
PtrOwner<ICurveLine> pMyLine( CreateCurveLine()) ;
pMyLine->Set( ptL2s, ptL2e) ;
pMyLine->SetExtrusion( vtAxL) ;
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, _nInd_debug, Release( pMyLine)) ;
m_pGeomDB->SetMaterial( a, YELLOW) ;
#endif
}
}
}
}
// Recupero i contorni
INTVECTOR vnId ;
while ( chainC.GetChainFromNear( ORIG, false, vnId)) {
// creo la curva
vCrvCompo.emplace_back( CreateCurveComposite()) ;
vCrvCompo.back()->AddPoint( vBiPnt[vnId[0]-1].first) ;
for ( int i = 0 ; i < int( vnId.size()) ; ++ i)
vCrvCompo.back()->AddLine( vBiPnt[vnId[i]-1].second) ;
if ( ! vCrvCompo.back()->IsClosed())
vCrvCompo.pop_back() ;
else {
// controllo se sufficientemente estesa
double dMaxOffs ;
if ( CalcCurveLimitOffset( *vCrvCompo.back(), dMaxOffs) && dMaxOffs < dOffsTol)
vCrvCompo.pop_back() ;
}
}
// abbellisco le curve trovate
const double SILH_ARC_TOL = 0.1 ;
const double SILH_ARC_FEA_MAX = 100. ;
for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
#if ENABLE_OPTIMAL_DEBUG
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, _nInd_debug, vCrvCompo[i]->Clone()) ;
m_pGeomDB->SetMaterial( a, BLACK) ;
#endif
PolyArc PA ;
if ( vCrvCompo[i]->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)) {
vCrvCompo[i].Set( pTempCrv) ;
#if ENABLE_OPTIMAL_DEBUG
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, _nInd_debug, vCrvCompo[i]->Clone()) ;
m_pGeomDB->SetMaterial( a, PURPLE) ;
#endif
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetOptimalSfr( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfrLoc, const Vector3d& vtTool,
double dDepth, double dElev, ISurfFlatRegion* pSfrSpiral, ISurfFlatRegion* pSfrZConst) const
{
// controllo dei parametri
if ( pSfrLoc == nullptr || ! pSfrLoc->IsValid())
return false ;
pSfrSpiral->Clear() ;
pSfrZConst->Clear() ;
#if ENABLE_OPTIMAL_DEBUG
for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vSrfLoc[i]->Clone()) ;
m_pGeomDB->SetMaterial( _a, YELLOW) ;
}
#endif
// versore utensile e di movimento longitudinali in frame locale
Vector3d vtAxL = GetToLoc( vtTool, frSurf) ;
Vector3d vtMoveL = vtAxL ;
// tolleranza angolare
double dSplitAngleTol = 5. ;
// angolo di scelta per divisione dei triangoli
double dSplitAngle = 45. ;
double dLimInfSplitAng = dSplitAngle + dSplitAngleTol ;
double dLimSupSplitAng = dSplitAngle - dSplitAngleTol ;
GetValInNotes( m_Params.m_sUserNotes, UN_SPLITANGLE, dSplitAngle) ;
double dCosClipping = cos( ( dSplitAngle) * DEGTORAD) ;
double dLimInfCosClipping = cos( dLimInfSplitAng * DEGTORAD) ;
double dLimSupCosClipping = cos( dLimSupSplitAng * DEGTORAD) ;
// costanti
const double TOL_SAMPLE = 1. ;
double dExtraXY = 0. ;
if ( m_TParams.m_dSideAng < EPS_ANG_SMALL)
dExtraXY += m_TParams.m_dDiam / 2. ;
else {
double dDeltaRad ;
double dSideAngRad = m_TParams.m_dSideAng * DEGTORAD ;
if ( m_TParams.m_dSideAng > 0) {
if ( m_TParams.m_dCornRad < EPS_SMALL)
dDeltaRad = m_TParams.m_dMaxMat * tan( dSideAngRad) ;
else
dDeltaRad = ( m_TParams.m_dCornRad * cos( dSideAngRad) +
( m_TParams.m_dMaxMat + m_TParams.m_dCornRad * ( sin( dSideAngRad) - 1)) * tan( dSideAngRad)) ;
}
else
dDeltaRad = tan( dSideAngRad) * m_TParams.m_dMaxMat ;
dExtraXY += m_TParams.m_dDiam / 2. + dDeltaRad ;
}
const double EXTRA_XY = dExtraXY + 2.5 * TOL_SAMPLE ;
// frame pianoXY
Frame3d frXY ;
Point3d ptC ; pSfrLoc->GetCentroid( ptC) ;
if ( ! frXY.Set( ptC, pSfrLoc->GetNormVersor()))
return false ;
// considero il frame inverso
Frame3d frXYInv = frXY ; frXYInv.Invert() ;
// calcolo il Box della regione rispetto al frame XY invertito (quindi il box su XY locale alla pSfr)
BBox3d BBoxLoc ;
if ( ! pSfrLoc->GetBBox( frXYInv, BBoxLoc))
return false ;
// lo espendo
BBoxLoc.Expand( EXTRA_XY, EXTRA_XY, 0.) ;
// definisco il numero di punti lungo asse X e Y
int nStepX = int( ceil( BBoxLoc.GetDimX() / TOL_SAMPLE)) ;
int nStepY = int( ceil( BBoxLoc.GetDimY() / TOL_SAMPLE)) ;
frXY.ChangeOrig( GetToGlob( BBoxLoc.GetMin(), frXY)) ;
// definisco una griglia di <punto, movimento, vtN(s)> ( sempre in FrLoc)
PNTUVVECTVECTOR vPntM( ( nStepX + 1) * ( nStepY + 1)) ; // per TestPath con collisioni
INTVECTOR vIndPerimeter ; // indici di bordo
for ( int j = 0 ; j <= nStepY ; ++ j) {
for ( int i = 0 ; i <= nStepX ; ++ i) {
int nInd = i + j * ( nStepX + 1) ;
Point3d ptTest = GetToGlob( Point3d( i * TOL_SAMPLE, j * TOL_SAMPLE, 0.), frXY) ;
if ( i == 0 || j == 0 || i == nStepX || j == nStepY)
vIndPerimeter.push_back( nInd) ;
// controtraslo i punti della lunghezza utensile
ptTest.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
vPntM[nInd] = ( make_tuple( ptTest, 0., VCT3DVECTOR{V_NULL})) ;
}
}
// effettuo verifica Collisione avanzata ( i versori normali sono solo quelli ad alzata massima dalle superfici)
if ( ! pCAvTlStm->TestSeriesAdv( vPntM, vtAxL, vtMoveL))
return false ;
#if ENABLE_OPTIMAL_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "_debug_grid") ;
m_pGeomDB->SetStatus( nGrp, GDB_ST_ON) ;
int nLyS = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLyS, "_spiral") ;
m_pGeomDB->SetStatus( nLyS, GDB_ST_OFF) ;
int nLyZC = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLyZC, "_zconst") ;
m_pGeomDB->SetStatus( nLyZC, GDB_ST_OFF) ;
int nLyBO = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLyBO, "_border") ;
m_pGeomDB->SetStatus( nLyBO, GDB_ST_OFF) ;
int nLyN = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLyN, "_normals") ;
m_pGeomDB->SetStatus( nLyN, GDB_ST_OFF) ;
#endif
// definisco nuovi parametri per marching Square
VECTORCOLLISIONSFR vCollision( vPntM.size()) ;
for ( int j = 0 ; j <= nStepY ; ++ j) {
for ( int i = 0 ; i <= nStepX ; ++ i) {
int nInd = i + j * ( nStepX + 1) ;
get<0>( vCollision[nInd].CollisionInfo) = get<0>( vPntM[nInd]) ;
bool bOnPerimeter = ( find( vIndPerimeter.begin(), vIndPerimeter.end(), nInd) != vIndPerimeter.end()) ;
get<1>( vCollision[nInd].CollisionInfo) = ( bOnPerimeter ? INFINITO : get<1>( vPntM[nInd])) ;
vCollision[nInd].bInSpiral = false ;
vCollision[nInd].bInZConst = false ;
vCollision[nInd].bOnBorder = false ;
for ( int nV = 0 ; nV < int( get<2>( vPntM[nInd]).size()) ; ++ nV) {
if ( ! bOnPerimeter) {
double dAbsCos = abs( get<2>( vPntM[nInd])[nV] * vtAxL) ;
if ( ! vCollision[nInd].bInZConst)
vCollision[nInd].bInZConst = ( dAbsCos < dCosClipping + EPS_ANG_ZERO) ; // theta <= ClippingAng
if ( ! vCollision[nInd].bInSpiral)
vCollision[nInd].bInSpiral = ( dAbsCos > dCosClipping + EPS_ANG_ZERO) ; // theta > ClippingAng
if ( ! vCollision[nInd].bOnBorder)
vCollision[nInd].bOnBorder = ( dAbsCos > dLimInfCosClipping + EPS_ANG_ZERO &&
dAbsCos < dLimSupCosClipping + EPS_ANG_ZERO) ; // LimInfClippingAng <= theta <= LimSupClippingAng
}
get<2>( vCollision[nInd].CollisionInfo).push_back( get<2>( vPntM[nInd])[nV]) ;
}
#if ENABLE_OPTIMAL_DEBUG
PtrOwner<IGeoPoint3d> pt( CreateGeoPoint3d()) ;
pt->Set( get<0>( vCollision[nInd].CollisionInfo) - vtAxL * ( m_TParams.m_dLen - get<1>( vCollision[nInd].CollisionInfo))) ;
int _pS = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLyS, pt->Clone()) ;
int _pZC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLyZC, pt->Clone()) ;
int _pBo = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLyBO, pt->Clone()) ;
Color myColS = ( vCollision[nInd].bInSpiral ? RED : BLUE) ;
Color myColZC = ( vCollision[nInd].bInZConst ? RED : BLUE) ;
Color myColBord = ( vCollision[nInd].bOnBorder ? RED : BLUE) ;
m_pGeomDB->SetMaterial( _pS, myColS) ;
m_pGeomDB->SetMaterial( _pZC, myColZC) ;
m_pGeomDB->SetMaterial( _pBo, myColBord) ;
for ( int nV = 0 ; nV < int( get<2>( vCollision[nInd].CollisionInfo).size()) ; ++ nV) {
PtrOwner<IGeoVector3d> vt( CreateGeoVector3d()) ;
vt->Set( get<2>( vCollision[nInd].CollisionInfo)[nV]) ;
vt->Translate( pt->GetPoint() - ORIG) ;
int _vN = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLyN, vt->Clone()) ;
m_pGeomDB->SetMaterial( _vN, Color( abs( vt->GetVector().x), abs( vt->GetVector().y), abs( vt->GetVector().z))) ;
}
#endif
}
}
return true ;
ICRVCOMPOPOVECTOR vCrvSpiral, vCrvZConst, vCrvAmbiguous ;
int nThreadMax = thread::hardware_concurrency() ;
if ( nThreadMax <= 1) {
// recupero le curve di contorno per la superficie Spiral
ICRVCOMPOPOVECTOR vCrvSpiral ;
if ( ! MarchingSquares( vCollision, 0, TOL_SAMPLE / 2., nStepX, nStepY, dSplitAngle, dLimInfSplitAng,
dLimSupSplitAng, vtAxL, vtMoveL, pCAvTlStm, vCrvSpiral))
return false ;
// recupero le curve di contorno per la superficie ZConst
ICRVCOMPOPOVECTOR vCrvZConst ;
if ( ! MarchingSquares( vCollision, 1, TOL_SAMPLE / 2., nStepX, nStepY, dSplitAngle, dLimInfSplitAng,
dLimSupSplitAng, vtAxL, vtMoveL, pCAvTlStm, vCrvZConst))
return false ;
// recupero le curve di bordo per la superficie Ambigua
if ( ! MarchingSquares( vCollision, 2, TOL_SAMPLE / 2., nStepX, nStepY, dSplitAngle, dLimInfSplitAng,
dLimSupSplitAng, vtAxL, vtMoveL, pCAvTlStm, vCrvAmbiguous))
return false ;
}
else {
future<bool> vRes[3] ;
vRes[0] = async( launch::async, &SurfFinishing::MarchingSquares, this, cref( vCollision), 0,
TOL_SAMPLE / 2., nStepX, nStepY, dSplitAngle, dLimInfSplitAng, dLimSupSplitAng,
cref( vtAxL), cref( vtMoveL), ref( pCAvTlStm), ref( vCrvSpiral)) ;
vRes[1] = async( launch::async, &SurfFinishing::MarchingSquares, this, cref( vCollision), 1,
TOL_SAMPLE / 2., nStepX, nStepY, dSplitAngle, dLimInfSplitAng, dLimSupSplitAng,
cref( vtAxL), cref( vtMoveL), ref( pCAvTlStm), ref( vCrvZConst)) ;
vRes[2] = async( launch::async, &SurfFinishing::MarchingSquares, this, cref( vCollision), 2,
TOL_SAMPLE / 2., nStepX, nStepY, dSplitAngle, dLimInfSplitAng, dLimSupSplitAng,
cref( vtAxL), cref( vtMoveL), ref( pCAvTlStm), ref( vCrvAmbiguous)) ;
int nFin = 0 ;
bool bOk = true ;
while ( nFin < 2) {
for ( int i = 0 ; i < 2 ; ++ i) {
if ( vRes[i].valid() && vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
bOk = vRes[i].get() && bOk ;
++ nFin ;
}
}
}
if ( ! bOk)
return false ;
}
// costruisco la regione ZConst
if ( ! vCrvZConst.empty()) {
SurfFlatRegionByContours SfrMaker ;
for ( int i = 0 ; i < int( vCrvZConst.size()) ; ++ i)
SfrMaker.AddCurve( Release( vCrvZConst[i])) ;
PtrOwner<ISurfFlatRegion> pSfrZC( SfrMaker.GetSurf()) ;
if ( ! IsNull( pSfrZC) && pSfrZC->IsValid()) {
pSfrZConst->CopyFrom( pSfrZC) ;
pSfrZConst->Translate( - vtAxL * ( m_TParams.m_dLen - dDepth)) ;
if ( AreOppositeVectorApprox( pSfrZConst->GetNormVersor(), pSfrLoc->GetNormVersor()))
pSfrZConst->Invert() ;
// Offset di correzione per le regioni ZConst
pSfrZConst->Offset( TOL_SAMPLE + EPS_SMALL, ICurve::OFF_FILLET) ;
// Offset di correzione
#if ENABLE_OPTIMAL_SOFT_DEBUG
int _pSZC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrZConst->Clone()) ;
m_pGeomDB->SetMaterial( _pSZC, Color( 0., 1., 0., .65)) ;
#endif
}
}
// costruisco la regione Spiral
if ( ! vCrvSpiral.empty()) {
SurfFlatRegionByContours SfrMaker ;
for ( int i = 0 ; i < int( vCrvSpiral.size()) ; ++ i)
SfrMaker.AddCurve( Release( vCrvSpiral[i])) ;
PtrOwner<ISurfFlatRegion> pSfrS( SfrMaker.GetSurf()) ;
if ( ! IsNull( pSfrS) && pSfrS->IsValid()) {
pSfrSpiral->CopyFrom( pSfrS) ;
pSfrSpiral->Translate( - vtAxL * ( m_TParams.m_dLen - dDepth)) ;
if ( AreOppositeVectorApprox( pSfrSpiral->GetNormVersor(), pSfrLoc->GetNormVersor()))
pSfrSpiral->Invert() ;
// Offset di correzione per le regioni Spiral
pSfrSpiral->Offset( - TOL_SAMPLE / 10., ICurve::OFF_FILLET) ;
#if ENABLE_OPTIMAL_SOFT_DEBUG
int _pSS = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrSpiral->Clone()) ;
m_pGeomDB->SetMaterial( _pSS, Color( 1., 0., 0., .65)) ;
#endif
}
}
// Costruisco la regine Ambigua
if ( ! vCrvAmbiguous.empty()) {
SurfFlatRegionByContours SfrMaker ;
for ( int i = 0 ; i < int( vCrvAmbiguous.size()) ; ++ i)
SfrMaker.AddCurve( Release( vCrvAmbiguous[i])) ;
PtrOwner<ISurfFlatRegion> pSfrAmb( SfrMaker.GetSurf()) ;
if ( ! IsNull( pSfrAmb) && pSfrAmb->IsValid()) {
pSfrAmb->Translate( - vtAxL * ( m_TParams.m_dLen - dDepth)) ;
if ( AreOppositeVectorApprox( pSfrAmb->GetNormVersor(), pSfrLoc->GetNormVersor()))
pSfrAmb->Invert() ;
// Offset di correzione per le regioni Spiral
pSfrAmb->Offset( - TOL_SAMPLE / 10., ICurve::OFF_FILLET) ;
#if ENABLE_OPTIMAL_SOFT_DEBUG
int _pSS = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrAmb->Clone()) ;
m_pGeomDB->SetMaterial( _pSS, Color( 1., .5, .25, .65)) ;
#endif
#if ENABLE_OPTIMAL_DEBUG
ICURVEPOVECTOR vCrvMedAxis ;
pSfrAmb->CalcMedialAxis( vCrvMedAxis) ;
for ( int i = 0 ; i < int( vCrvMedAxis.size()) ; ++ i) {
int _pSS = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvMedAxis[i]->Clone()) ;
m_pGeomDB->SetMaterial( _pSS, ORANGE) ;
}
int _pSS = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrAmb->Clone()) ;
m_pGeomDB->SetMaterial( _pSS, Color( 1., .5, .25, .65)) ;
#endif
}
}
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, P_INVALID, nullptr, true, INFINITO, GetLeadInType(), m_Params.m_dLiTang, 0.,
GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., 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, 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 ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::CalcOptimalZigZagCurves( const ISurfFlatRegion* pSfrLoc, const Frame3d& frSurf, const Vector3d& vtTool,
double dDepth, ICAvToolSurfTm* pCAvTlStm, VECTORPATHS& vPaths) const
{
// se la superficie non è valida, non restituisco nulla
if ( pSfrLoc == nullptr || ! pSfrLoc->IsValid())
return true ;
// mi assicuro di non uscire dalla superficie originale
PtrOwner<ISurfFlatRegion> pMySfrZigZag( CloneSurfFlatRegion( pSfrLoc)) ;
if ( IsNull( pMySfrZigZag) || ! pMySfrZigZag->IsValid())
return false ;
// imposto i lati chiusi
for ( int nC = 0 ; nC < pMySfrZigZag->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pMySfrZigZag->GetLoopCount( nC) ; ++ nL) {
for ( int nU = 0 ; nU < pMySfrZigZag->GetLoopCurveCount( nC, nL) ; ++ nU)
pMySfrZigZag->SetCurveTempProp( nC, nL, nU, 0, TEMP_PROP_CLOSE_EDGE) ;
}
}
#if ENABLE_OPTIMAL_DEBUG
int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
m_pGeomDB->SetName( nGrp, "ZigZag") ;
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) ;
int nSfrProjId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySfrProj, pMySfrZigZag->Clone()) ;
m_pGeomDB->SetMaterial( nSfrProjId, Color( 1., 0., 0., .5)) ;
#endif
// 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 ;
}
// per ogni Chunk della superficie a ZigZag, calcolo le curve di lavoro
ICRVCOMPOPOVECTOR vCrvCompoZigZag ;
for ( int nC = 0 ; nC < pMySfrZigZag->GetChunkCount() ; ++ nC) {
// recupero il Chunk corrente
PtrOwner<ISurfFlatRegion> pSfrChunk( pMySfrZigZag->CloneChunk( nC)) ;
if ( IsNull( pSfrChunk) || ! pMySfrZigZag->IsValid())
return false ;
// recupero la miglior direzione di orientamento per le curve a ZigZag
// --- approssimo il Loop esterno con una PolyLine
PolyLine PL ;
pSfrChunk->ApproxLoopWithLines( 0, 0, EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL) ;
// --- porto la PolyLine sul piano locale XY
Point3d ptC ; pSfrChunk->GetCentroid( ptC) ;
Frame3d frXY ;
if ( ! frXY.Set( ptC, pSfrChunk->GetNormVersor()))
return false ;
PL.ToLoc( frXY) ;
pSfrChunk->ToGlob( frSurf) ;
// eseguo il calcolo della lavorazione ZigZag
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! CalcPocketing( pSfrChunk, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, m_Params.m_dSideAngle, 5.,
nSubType, false, false, false, true, true, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., vpCrvs)) {
m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
return false ;
}
// memorizzo le curve ricavate
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i)
vCrvCompoZigZag.emplace_back( Release( vpCrvs[i])) ;
}
// porto i dati geometrici in locale alle superfici ( proeittando)
Vector3d vtAxL = vtTool ;
vtAxL.ToLoc( frSurf) ;
Vector3d vtMoveL = vtAxL ;
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( int( vCrvCompoZigZag.size()), 1) ;
for ( int i = 0 ; i < int( vCrvCompoZigZag.size()) ; ++ 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( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL) ||
! PL.AdjustForMaxSegmentLen( dDist))
return false ;
PL.ToLoc( frSurf) ;
// traslo della lunghezza utensile diminuita dell'affondamento
PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
// eseguo CAv
if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( i + 1) * dProgCoeff))
return false ;
// contro-traslo della lunghezza utensile
PL.Translate( - vtAxL * 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::CalcOptimalZConstCurves( const ISurfFlatRegion* pSfrLoc, const SURFLOCALVECTOR& vSrfLoc,
const Frame3d& frSurf, const Vector3d& vtTool, double dAngDegSplit,
double dAngDegTol, double dDepth, ICAvToolSurfTm* pCAvTlStm,
VECTORPATHS& vPaths, ISurfFlatRegion* pSfrProj) const
{
// se la superficie non è valida, non restituisco nulla
if ( pSfrLoc == nullptr || ! pSfrLoc->IsValid())
return true ;
pSfrProj->Clear() ;
// 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 < int( vSrfLoc.size()) ; ++ 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) ;
Vector3d vtMoveL = vtAxL ;
// --- 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 } ;
#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 nLaySfrProj = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
m_pGeomDB->SetName( nLaySfrProj, "SfrProj") ;
m_pGeomDB->SetStatus( nLaySfrProj, GDB_ST_OFF) ;
#endif
// scorro i piani di ZConst ricavati...
for ( int i = 0 ; i < int( vvCrvCompo.size()) ; ++ 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 < int( vvCrvCompo[i].size()) ; ++ 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 ( 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
// NB. Le curve di Silhoette per definizione sono orientate lasciando le vStm alla loro destra
int nPointType = DISCARD ;
double dPar ;
Point3d ptShift ;
Vector3d vtIn ;
VCT3DVECTOR vVtN ;
if ( vvCrvCompo[i][j]->GetParamAtPoint( ptU.first, dPar, 10 * EPS_SMALL) &&
vvCrvCompo[i][j]->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptShift, &vtIn)) {
ptShift.Translate( - vtAxL * m_TParams.m_dLen) ; // per ricavare la colisione
vtIn.Normalize() ;
vtIn.Rotate( vtAxL, ! m_Params.m_bInvert ? ANG_RIGHT : - ANG_RIGHT) ;
const double MAXSHIFT = SILH_SAMPLING ;
const int SAMPLETOL = 10 ;
double dShift = MAXSHIFT / ( 1. * SAMPLETOL) ;
for ( int i = 1 ; i < SAMPLETOL && vVtN.empty() ; ++ i) {
ptShift.Translate( vtIn * ( i * dShift)) ; // leggero spostamento del punto
double dToTDist = 0. ;
// calcolo la collisione
if ( ! pCAvTlStm->TestPositionAdv( ptShift, vtAxL, vtMoveL, dToTDist, vVtN))
return false ;
// classificazione del punto
if ( ! vVtN.empty()) {
for ( Vector3d& vtN : vVtN) {
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 : vVtN) {
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 = int( vTypePL.size()) ;
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, 2 * dDist * dDist)) {
for ( auto& ptU : vTypePL[nPrevInd].second.GetUPointList())
vPL.back().AddUPoint( 0., ptU.first) ;
vTypePL[nPrevInd].first = DISCARD ;
}
}
// aggiungo il tratto corrente e lo rendo invalido
for ( auto& 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, 2 * dDist * dDist)) {
for ( auto& 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 ;
}
}
// dalle PolyLine recupero le curve
vvCrvCompo[i].clear() ;
for ( PolyLine& PL : vPL) {
// se PolyLine troppo corta, non la memorizzo ( < 1/4 circonferenza utensile)
double dLen = 0. ;
PL.GetLength( dLen) ;
if ( dLen < ( PIGRECO / 2.) * ( m_TParams.m_dDiam / 2.))
continue ;
// definisco la curva e la abbellisco
PtrOwner<ICurveComposite> pNewCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pNewCrvCompo) || ! pNewCrvCompo->FromPolyLine( PL))
continue ;
SimplifyCurve( pNewCrvCompo, frSfr) ;
vvCrvCompo[i].emplace_back( Release( pNewCrvCompo)) ;
// 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, GREEN) ;
#endif
}
}
// NB. per determinare la regione da lavavorare a ZigZag, devo prima determinare la regione
// definita dalle curve ZConst.
// --- determino il piano di proiezione dalla regione originale
Plane3d plProj ;
if ( ! plProj.Set( ptC, vtAxL))
return false ;
// --- per ogni curva valida, definisco una regione piana Fat sul piano calcolato
for ( auto& vCrvCompo : vvCrvCompo) {
for ( auto& pCrvCompo : vCrvCompo) {
// se curva non valida, passo alla successiva
if ( IsNull( pCrvCompo) || ! pCrvCompo->IsValid())
continue ;
// proeitto la curva sul piano
PtrOwner<ICurve> pCrvProj( ProjectCurveOnPlane( *pCrvCompo, plProj)) ;
if ( IsNull( pCrvProj) || ! pCrvProj->IsValid())
continue ;
// determino la sua FatRegion
pCrvProj->SetExtrusion( vtAxL) ; // per coprire eventuali regioni fini
PtrOwner<ISurfFlatRegion> pSfrFat( GetSurfFlatRegionFromFatCurve( pCrvProj->Clone(), m_Params.m_dSideStep / dCosLimit, false, false)) ;
if ( IsNull( pSfrFat) || ! pSfrFat->IsValid())
continue ;
if ( AreOppositeVectorApprox( pSfrFat->GetNormVersor(), vtAxL))
pSfrFat->Invert() ;
// aggiungo questa regione a quella complessiva
if ( pSfrProj->IsValid() && pSfrProj->GetChunkCount() > 0)
pSfrProj->Add( *pSfrFat) ;
else
pSfrProj->CopyFrom( pSfrFat) ;
}
}
#if ENABLE_OPTIMAL_DEBUG
int nSfrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySfrProj, pSfrProj->Clone()) ;
m_pGeomDB->SetMaterial( nSfrId, Color( 0., 1., 0., .5)) ;
#endif
// collego tra loro le curve trovate definendo quindi un percorso
ICRVCOMPOPOVECTOR vCrv ;
if ( ! CreateZConstPaths( pCAvTlStm, 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 < int( vCrv.size()) ; ++ i) {
vPaths.resize( vPaths.size() + 1) ;
vPaths.back().pCrvPath.Set( Release( vCrv[i])) ;
vPaths.back().nType = SURFFIN_SUB_Z_CONST ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
const ISurfFlatRegion* pSfrCntZigZag, const ISurfFlatRegion* pSfrCntZConst,
const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{
// vettore dei percorsi da calcolare
VECTORPATHS vPaths ;
// se entrambe le regioni non sono valide, non faccio nulla
if ( ( pSfrCntZigZag == nullptr || ! pSfrCntZigZag->IsValid()) &&
( pSfrCntZConst == nullptr || ! pSfrCntZConst->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) ;
// inizializzo l'area di lavoro determinata dalle curve ZigZag
PtrOwner<ISurfFlatRegion> pSfrZigZagProjLoc ;
if ( pSfrCntZigZag != nullptr && pSfrCntZigZag->IsValid()) {
if ( ! pSfrZigZagProjLoc.Set( CloneSurfFlatRegion( pSfrCntZigZag)) ||
! pSfrCntZigZag->IsValid())
return false ;
pSfrZigZagProjLoc->ToLoc( frSurf) ;
}
else {
if ( ! pSfrZigZagProjLoc.Set( CreateSurfFlatRegion()))
return false ;
}
// se ho una superficie di contorno per ZConst valida
if ( pSfrCntZConst != nullptr && pSfrCntZConst->IsValid()) {
// definizione regione piana di lavoro per curve ZConst
PtrOwner<ISurfFlatRegion> pSfrZConstLoc( CloneSurfFlatRegion( pSfrCntZConst)) ;
if ( IsNull( pSfrZConstLoc) || ! pSfrZConstLoc->IsValid() || ! pSfrZConstLoc->ToLoc( frSurf))
return false ;
// recupero le curve dalla regione ZConst
PtrOwner<ISurfFlatRegion> pSfrZConstProj( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrZConstProj) ||
! CalcOptimalZConstCurves( pSfrZConstLoc, vSrfLoc, frSurf, vtTool, dAngDegSplit, dAngDegTol, dDepth, pCAvTlStm, vPaths, pSfrZConstProj)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
// recupero le curve dalla regione Spiral
if ( pSfrZConstProj->IsValid() && pSfrZConstProj->GetChunkCount() > 0 &&
pSfrZigZagProjLoc->IsValid()) {
PtrOwner<ISurfFlatRegion> pSfrZigZagProjLocClone( CloneSurfFlatRegion( pSfrZigZagProjLoc)) ;
if ( IsNull( pSfrZigZagProjLocClone) || ! pSfrZigZagProjLocClone->IsValid())
return false ;
// alla superficie ZigZag tolgo la regione ZConst
pSfrZigZagProjLoc->Subtract( *pSfrZConstProj) ;
// nei pressi dei tratti in comune lo ZigZag deve lavorare a SideStep
// NB. pSfrZConstProj è ingrandita di SideStep
pSfrZigZagProjLoc->Offset( m_Params.m_dSideStep + m_TParams.m_dDiam / 2., ICurve::OFF_FILLET) ;
// la supercicie ZigZag deve comunque essere sempre contenuta in quella definita in originale
pSfrZigZagProjLoc->Intersect( *pSfrZigZagProjLocClone) ;
}
}
// se ho una superficie di contorno per ZigZag valida
if ( ! IsNull( pSfrZigZagProjLoc) && pSfrZigZagProjLoc->IsValid()) {
if ( ! CalcOptimalZigZagCurves( pSfrZigZagProjLoc, frSurf, vtTool, dDepth, pCAvTlStm, vPaths)) {
m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
return false ;
}
}
// se non ho percorsi, non faccio nulla
if ( vPaths.empty())
return true ;
// porto tutte le curve in globale
for ( auto& path : vPaths) {
if ( IsNull( path.pCrvPath) || ! path.pCrvPath->IsValid())
continue ;
path.pCrvPath->ToGlob( frSurf) ;
}
// ordino i percorsi ricavati
if ( ! OrderOptimalPathsByZLoc( pSfrCntZConst, pSfrCntZigZag, vPaths))
return false ;
#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 < int( vPaths.size()) ; ++ i)
vCrvCompo[i].Set( Release( vPaths[i].pCrvPath)) ;
if ( ! AddFinishing( ( pSfrCntZConst == nullptr || ! pSfrCntZConst->IsValid()) ? pSfrCntZigZag : pSfrCntZConst,
pCAvTlStm, frSurf, vCrvCompo, vtTool, dElev, dDepth, bSplitArcs))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
const ICurveComposite* pCrvCompo, const Vector3d& vtTool, 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, vtTool))
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 < int( vSrfLoc.size()) ; ++ 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 < int( vpStm.size()) ; ++ 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
SurfFlatRegionByContours SfrMaker ;
for ( auto& 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_TOL ;
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))) {
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 = m_TParams.m_dDiam - m_Params.m_dSideStep - m_Params.m_dOverlap ;
pSfrSil->Offset( dPockRadOffs, ICurve::OFF_CHAMFER) ;
// 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 * vtTool) ;
pCrvCompoCL->ToLoc( frLoc) ;
pSfrSil->ToLoc( frLoc) ;
// classifico
CRVCVECTOR ccClass ;
if ( pSfrSil->GetCurveClassification( *pCrvCompoCL, EPS_SMALL, ccClass)) {
for ( int i = 0 ; i < int( ccClass.size()) ; ++ 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, 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 < int( vCrvToProj.size()) ; ++ i) {
ICRVCOMPOPOVECTOR vCrvSingle ;
vCrvSingle.emplace_back( Release( vCrvToProj[i])) ;
if ( ! AddFinishing( nullptr, pCAvTlStm, frSurf, vCrvSingle, vtTool, 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,
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) ;
// 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 ( int( lstPntU.size()) < 2)
return true ; // per sicurezza...
// eseguo controllo collisione
if ( ! pCAvTlStm->TestPath( lstPntU, vtToolL, vtToolL, 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 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) ;
// porto i punti dal tip al naso mandrino
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, vtToolL, 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, vtTool))
return false ;
plZLocMin.Translate( - vtTool * 10 * ( m_TParams.m_dLen + abs( dDepth))) ;
// determino il punto con ZLocale più alta
Point3d ptZMax = ptEnd ;
double dZMax = 0. ;
for ( auto& 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) * vtTool) ;
double dStartElev = dSafeZ + abs( ( ptZMax - ptStart) * vtTool) ;
// definisco il collegamento
pCrvLink->AddPoint( ptEnd) ;
pCrvLink->AddLine( ptEnd + vtTool * dEndElev) ;
pCrvLink->AddLine( ptStart + vtTool * dStartElev) ;
pCrvLink->AddLine( ptStart) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfFinishing::GetSurfaceNormalAtPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
const Point3d& ptTool, const Vector3d& vtTool, Vector3d& vtNorm) const
{
// porto il punto e il versore nel riferimento superficie
Point3d ptToolL = GetToLoc( ptTool, frSurf) ;
Vector3d vtToolL = GetToLoc( vtTool, 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, vtToolL, 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, 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 auto& 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 < int( vCrvCompo.size()) ; ++ 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, vtNorm)) {
Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, 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, 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(), vtTool, 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 == int( vCrvCompo.size()) - 1) {
// determino normale della superficie sul punto finale
Vector3d vtNorm ;
if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, 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, 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, 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 ;
}
Reference in New Issue View Git Blame Copy Permalink