From cac3224ff887531a0c4a4d71565c86a136a8a2f9 Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Wed, 29 Nov 2023 12:00:25 +0100 Subject: [PATCH] EgtExecutor : - spostate le funzioni EgtPocketing e EgtGetSurfFrZigZagInfill in un documento a parte (EXE_GdbGetPocketing.cpp) - aggiornati i parametri della funzione GetSurfFrZigZagInfill. --- EXE_GdbGetPocketing.cpp | 150 ++++++++++++++++++++ EXE_GdbGetSurf.cpp | 61 -------- EXE_GdbModifyCurve.cpp | 274 ------------------------------------ EgtExecutor.vcxproj | 2 + EgtExecutor.vcxproj.filters | 6 + LUA.h | 5 +- LUA_Base.cpp | 4 + LUA_GdbGetPocketing.cpp | 90 ++++++++++++ LUA_GdbGetSurf.cpp | 30 ---- LUA_GdbModifyCurve.cpp | 32 ----- 10 files changed, 256 insertions(+), 398 deletions(-) create mode 100644 EXE_GdbGetPocketing.cpp create mode 100644 LUA_GdbGetPocketing.cpp diff --git a/EXE_GdbGetPocketing.cpp b/EXE_GdbGetPocketing.cpp new file mode 100644 index 0000000..a9cb888 --- /dev/null +++ b/EXE_GdbGetPocketing.cpp @@ -0,0 +1,150 @@ +//---------------------------------------------------------------------------- +// EgalTech 2023-2023 +//---------------------------------------------------------------------------- +// File : Exe_GdbGetPocketing.cpp Data : 28.11.23 Versione : 2.5k6 +// Contenuto : Funzioni di interrogazione di regioni piane del DBG per EXE. +// +// +// +// Modifiche : 29.11.23 RE Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "EXE.h" +#include "EXE_Macro.h" +#include "/EgtDev/Include/EXeExecutor.h" +#include "/EgtDev/Include/EGkCalcPocketing.h" + +using namespace std ; + +//---------------------------------------------------------------------------- +bool +ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId, + int& nFirstId, int& nCrvCount) +{ + // databse geometrico + IGeomDB* pGeomDB = GetCurrGeomDB() ; + VERIFY_GEOMDB( pGeomDB, false) ; + + // recupero la FlatRegion per i percorsi + const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ; + if ( pSfr == nullptr) + return false ; + + // recupero il suo frame + Frame3d frSfr ; + if ( ! pGeomDB->GetGlobFrame( nId, frSfr)) + return false ; + + // recupero il riferimento del gruppo di destinazione + Frame3d frDest ; + if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest)) + return false ; + + // costruzione vettori di curve per Pocketing + ICRVCOMPOPOVECTOR vCrvCompoRes ; + + // eseguo Pocketing + bool bOk = CalcPocketing( pSfr, dRad, dStep, dAngle, nType, bSmooth, vCrvCompoRes) ; + nFirstId = GDB_ID_NULL ; // primo Id da restituire + nCrvCount = int( vCrvCompoRes.size()) ; + if ( bOk && int( vCrvCompoRes.size()) > 0) { + // scorro le curve di Pocketing ottenute + for ( int u = 0 ; u < int( vCrvCompoRes.size()) ; ++ u) { + vCrvCompoRes[u]->LocToLoc( frSfr, frDest) ; + // inserisco la curva nel DB Geometrico + int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrvCompoRes[u])) ; + if ( nCurrId == GDB_ID_NULL) + return false ; + if ( u == 0) + nFirstId = nCurrId ; // memorizzo il primo Id da restituire + } + ExeSetModified() ; + } + + if ( IsCmdLog()) { + string sLua = "EgtPocketing(" + ToString( nId) + "," + + ToString( dRad) + "," + + ToString( dStep) + "," + + ToString( dAngle) + "," + + ToString( nType) + "," + + ToString( bSmooth) + "," + + ToString( nDestGrpId) + ")" + + " -- Ok=" + ToString( bOk) + " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCrvCount) ; + LOG_INFO( GetCmdLogger(), sLua.c_str()) ; + } + return bOk ; +} + +//---------------------------------------------------------------------------- +int +ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, bool bRemoveOverlapLink, + int* pnCount) +{ + IGeomDB* pGeomDB = GetCurrGeomDB() ; + VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL) + + // recupero la superficie FlatRegion + ISurfFlatRegion* pOrigSrf = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ; + if ( pOrigSrf == nullptr) + return GDB_ID_NULL ; + PtrOwner pSfr( pOrigSrf->Clone()) ; + bool bOk = ( ! IsNull( pSfr)) ; + + // recupero il riferimento della superficie + Frame3d frSurf ; + bOk = bOk && pGeomDB->GetGlobFrame( nId, frSurf) ; + // recupero il riferimento di destinazione + Frame3d frDest ; + bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ; + + // creo il riferimento per il calcolo del percorso a zigzag + Vector3d vtN ; + if ( bOk) + vtN = pSfr->GetNormVersor() ; + bOk = bOk && vtN.ToGlob( frSurf) ; + Frame3d frRef ; + bOk = bOk && frRef.Set( ORIG, vtN) ; + bOk = bOk && frRef.Rotate( ORIG, vtN, dAng) ; + + // calcolo il percorso a zigzag + bOk = bOk && pSfr->LocToLoc( frSurf, frRef) ; + ICRVCOMPOPOVECTOR vpCrvs ; + bOk = bOk && CalcZigZagInfill( pSfr, dStep, bSmooth, bRemoveOverlapLink, vpCrvs) ; + + // inserisco le curve risultanti nel DB + int nFirstId = GDB_ID_NULL ; + int nCount = 0 ; + for ( int i = 0 ; bOk && i < ( int) vpCrvs.size() ; i ++) { + // porto la curva nel riferimento di destinazione + bOk = bOk && vpCrvs[i]->LocToLoc( frRef, frDest) ; + // la inserisco nel DB geometrico + int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vpCrvs[i])) : GDB_ID_NULL) ; + bOk = bOk && ( nNewId != GDB_ID_NULL) ; + // aggiorno contatori + if ( bOk && nFirstId == GDB_ID_NULL) + nFirstId = nNewId ; + if ( bOk) + ++ nCount ; + } + ExeSetModified() ; + + // restituisco risultati + if ( pnCount != nullptr) + *pnCount = nCount ; + + if ( IsCmdLog()) { + string sLua = "EgtGetSurfFrZigZagInfill(" + ToString( nId) + "," + + ToString( dStep) + "," + + ToString( dAng) + "," + + ToString( bSmooth) + "," + + ToString( bRemoveOverlapLink) + "," + + " -- Ok=" + ToString( bOk) + " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCount) ; + LOG_INFO( GetCmdLogger(), sLua.c_str()) ; + } + + return nFirstId ; +} \ No newline at end of file diff --git a/EXE_GdbGetSurf.cpp b/EXE_GdbGetSurf.cpp index b874a41..7f37ae1 100644 --- a/EXE_GdbGetSurf.cpp +++ b/EXE_GdbGetSurf.cpp @@ -309,67 +309,6 @@ ExeExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount) return nFirstId ; } -//---------------------------------------------------------------------------- -int -ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, int* pnCount) -{ - IGeomDB* pGeomDB = GetCurrGeomDB() ; - VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL) - - // recupero la superficie FlatRegion - ISurfFlatRegion * pOrigSrf = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ; - if ( pOrigSrf == nullptr) - return GDB_ID_NULL ; - PtrOwner pSfr( pOrigSrf->Clone()) ; - bool bOk = ( ! IsNull( pSfr)) ; - - // recupero il riferimento della superficie - Frame3d frSurf ; - bOk = bOk && pGeomDB->GetGlobFrame( nId, frSurf) ; - // recupero il riferimento di destinazione - Frame3d frDest ; - bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ; - - // creo il riferimento per il calcolo del percorso a zigzag - Vector3d vtN ; - if ( bOk) - vtN = pSfr->GetNormVersor() ; - bOk = bOk && vtN.ToGlob( frSurf) ; - Frame3d frRef ; - bOk = bOk && frRef.Set( ORIG, vtN) ; - bOk = bOk && frRef.Rotate( ORIG, vtN, dAng) ; - - // calcolo il percorso a zigzag - bOk = bOk && pSfr->LocToLoc( frSurf, frRef) ; - ICRVCOMPOPOVECTOR vpCrvs ; - bOk = bOk && CalcZigZagInfill( pSfr, dStep, bSmooth, vpCrvs) ; - - // inserisco le curve risultanti nel DB - int nFirstId = GDB_ID_NULL ; - int nCount = 0 ; - for ( int i = 0 ; bOk && i < ( int) vpCrvs.size() ; i ++) { - // porto la curva nel riferimento di destinazione - bOk = bOk && vpCrvs[i]->LocToLoc( frRef, frDest) ; - // la inserisco nel DB geometrico - int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vpCrvs[i])) : GDB_ID_NULL) ; - bOk = bOk && ( nNewId != GDB_ID_NULL) ; - // copio il materiale - //if ( ! pGeomDB->CopyMaterial( nId, nNewId)) - // return GDB_ID_NULL ; - // aggiorno contatori - if ( bOk && nFirstId == GDB_ID_NULL) - nFirstId = nNewId ; - if ( bOk) - ++ nCount ; - } - ExeSetModified() ; - - // restituisco risultati - if ( pnCount != nullptr) - *pnCount = nCount ; - return nFirstId ; -} - //---------------------------------------------------------------------------- int ExeSurfTmVertexCount( int nId) diff --git a/EXE_GdbModifyCurve.cpp b/EXE_GdbModifyCurve.cpp index 55fb0c3..bbbe097 100644 --- a/EXE_GdbModifyCurve.cpp +++ b/EXE_GdbModifyCurve.cpp @@ -2357,280 +2357,6 @@ ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int } -//---------------------------------------------------------------------------- -static bool -MyChainCurves( const SELVECTOR vInds, ICURVEPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvCompo) -{ - // preparo i dati per il concatenamento - bool bFirst = true ; - Point3d ptNear = ORIG ; - double dToler = 10 * EPS_SMALL ; - ChainCurves chainC ; - chainC.Init( true, dToler, int( vpCrvs.size())) ; - for ( size_t i = 0 ; i < vpCrvs.size() ; ++ i) { - // recupero la curva e il suo riferimento - ICurve* pCrv = vpCrvs[i] ; - if ( pCrv == nullptr) - continue ; - // recupero i dati della curva necessari al concatenamento e li assegno - Point3d ptStart, ptEnd ; - Vector3d vtStart, vtEnd ; - if ( ! pCrv->GetStartPoint( ptStart) || ! pCrv->GetStartDir( vtStart) || - ! pCrv->GetEndPoint( ptEnd) || ! pCrv->GetEndDir( vtEnd)) - return false ; - if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd)) - return false ; - // se prima curva, assegno inizio della ricerca - if ( bFirst) { - ptNear = ptStart + 10 * EPS_SMALL * vtStart ; - bFirst = false ; - } - } - // recupero i percorsi concatenati - INTVECTOR vnId2 ; - while ( chainC.GetChainFromNear( ptNear, false, vnId2)) { - // creo una curva composita - PtrOwner 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) ; - // aggiorno il nuovo punto vicino - pCrvCompo->GetEndPoint( ptNear) ; - // aggiungo la curva al vettore di curve composite concatenate - vCrvCompo.emplace_back( Release( pCrvCompo)) ; - } - return true ; -} - -//---------------------------------------------------------------------------- -static bool -MyGetCurves( SelData Id, ICURVEPLIST& lstPC, Vector3d& vtN) -{ - // database geometrico - IGeomDB* pGeomDB = GetCurrGeomDB() ; - VERIFY_GEOMDB( pGeomDB, false) ; - // ammessi : curve, testi, facce di trimesh o regioni - const IGeoObj* pGObj = pGeomDB->GetGeoObj( Id.nId) ; - if ( pGObj == nullptr) - return false ; - // ne recupero il riferimento globale - Frame3d frGlob ; - if ( ! pGeomDB->GetGlobFrame( Id.nId, frGlob)) - return false ; - // se curva - if (( pGObj->GetType() & GEO_CURVE) != 0) { - PtrOwner pCurve ; - // se direttamente curva - if ( Id.nSub == SEL_SUB_ALL) { - // recupero la curva - const ICurve* pOriCurve = ::GetCurve( pGObj) ; - if ( pOriCurve == nullptr) - return false ; - pCurve.Set( pOriCurve->Clone()) ; - } - // 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()) ; - } - if ( IsNull( pCurve)) - return false ; - // porto in globale - pCurve->ToGlob( frGlob) ; - // recupero estrusione - Vector3d vtExtr ; - // se estrusione mancante, imposto default - if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall()) - pCurve->SetExtrusion( Z_AX) ; - // corenza con vtTool - if ( ! vtN.IsValid()) - vtN = vtExtr ; - else if ( ! AreSameVectorApprox( vtExtr, vtN)) - return false ; - // verifico sia piana e se necessario la appiattisco - PtrOwner pFlatCrv( FlattenCurve( *pCurve, 50 * EPS_SMALL, 50 * EPS_ANG_SMALL, FLTCRV_USE_EXTR)) ; - if ( IsNull( pFlatCrv)) { - Plane3d plPlane ; - if ( ! pCurve->IsFlat( plPlane, true, 50 * EPS_SMALL)) - ; - else - ; - return false ; - } - // aggiungo alla lista - lstPC.emplace_back( Release( pCurve)) ; - return true ; - } - // se altrimenti testo - else if ( pGObj->GetType() == EXT_TEXT) - return false ; - // se altrimenti superficie - else if ( pGObj->GetType() == SRF_TRIMESH) - return false ; - // se altrimenti regione - else if ( pGObj->GetType() == SRF_FLATRGN) { - // recupero la regione - const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ; - if ( pReg == nullptr) - return false ; - PtrOwner pSfr( CloneSurfFlatRegion( pReg)) ; - if ( IsNull( pSfr)) - return false ; - // porto in globale - pSfr->ToGlob( frGlob) ; - // recupero la normale della regione - Vector3d vtN_sfr = pSfr->GetNormVersor() ; - if ( vtN.IsSmall()) - return false ; - if ( ! vtN.IsValid()) - vtN_sfr = vtN ; - else if ( ! AreSameVectorApprox( vtN, vtN_sfr)) - return false ; - // determino intervallo di chunk - int nCstart = 0 ; - int nCend = pSfr->GetChunkCount() ; - if ( Id.nSub != SEL_SUB_ALL) { - nCstart = Id.nSub ; - nCend = nCstart + 1 ; - } - // ciclo sui chunk - for ( int nC = nCstart ; nC < nCend ; ++ nC) { - // recupero i contorni del chunk - for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) { - PtrOwner pCrvLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ; - if ( IsNull( pCrvLoop)) - return false ; - // unisco le eventuali parti allineate - pCrvLoop->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ; - // aggiungo il loop al vettore di curve - lstPC.emplace_back( Release( pCrvLoop)) ; - } - } - return true ; - } - // altrimenti errore - else - return false ; -} - -//---------------------------------------------------------------------------- -bool -ExePocketing( const INTVECTOR vId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId, - int& nFirstId, int& nCrvCount) -{ - // databse geometrico - IGeomDB* pGeomDB = GetCurrGeomDB() ; - VERIFY_GEOMDB( pGeomDB, false) ; - // vettore puntatori alle curve - ICURVEPOVECTOR vpCrvs ; - vpCrvs.reserve( vId.size()) ; - // vettore selettori delle curve originali - SELVECTOR vInds ; - // scorro le entità selezionate per creare la FlatRegion da svuotare - PtrOwner pSfrPock( CreateSurfFlatRegion()) ; - if ( IsNull( pSfrPock)) - return false ; - Vector3d vtN = V_INVALID ; - for ( auto& Id : vId) { - // vettore contente tutte le curve selezionate - ICURVEPLIST lstPC ; - if ( ! MyGetCurves( Id, lstPC, vtN)) - continue ; - for ( auto pCrv : lstPC) { - vpCrvs.emplace_back( pCrv) ; - vInds.emplace_back( Id) ; - } - } - // recupero i loop per pSfrPock dal concatenamento ( se necessario) - ICRVCOMPOPOVECTOR vCrvCompo ; - if ( ! MyChainCurves( vInds, vpCrvs, vCrvCompo)) - return false ; - SurfFlatRegionByContours sfrBC ; - for ( int u = 0 ; u < int( vCrvCompo.size()) ; ++ u) - sfrBC.AddCurve( Release( vCrvCompo[u])) ; - // aggiorno pSfrPock - pSfrPock.Set( sfrBC.GetSurf()) ; - if ( IsNull( pSfrPock) || ! pSfrPock->IsValid()) - return false ; - // recupero il riferimento del gruppo di destinazione - Frame3d frDest ; - if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest)) - return false ; - // costruzione vettori di curve per Pocketing - ICRVCOMPOPOVECTOR vCrvCompoRes ; - // eseguo Pocketing - bool bOk = CalcPocketing( pSfrPock, dRad, dStep, dAngle, nType, bSmooth, vCrvCompoRes) ; - nFirstId = GDB_ID_NULL ; // primo Id da restituire - nCrvCount = int( vCrvCompoRes.size()) ; - if ( bOk && int( vCrvCompoRes.size()) > 0) { - // scorro le curve di Pocketing ottenute - for ( int u = 0 ; u < int( vCrvCompoRes.size()) ; ++ u) { - vCrvCompoRes[u]->ToLoc( frDest) ; - // inserisco la curva nel DB Geometrico - int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrvCompoRes[u])) ; - if ( nCurrId == GDB_ID_NULL) - return false ; - if ( u == 0) - nFirstId = nCurrId ; // memorizzo il primo Id da restituire - } - ExeSetModified() ; - } - - if ( IsCmdLog()) { - string sLua = "EgtPocketing(" + ToString( vId) + "," + - ToString( dRad) + "," + - ToString( dStep) + "," + - ToString( dAngle) + "," + - ToString( nType) + "," + - ToString( bSmooth) + "," + - ToString( nDestGrpId) + ")" + - " -- Ok=" + ToString( bOk) + " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCrvCount) ; - LOG_INFO( GetCmdLogger(), sLua.c_str()) ; - } - return bOk ; -} - //---------------------------------------------------------------------------- int ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) diff --git a/EgtExecutor.vcxproj b/EgtExecutor.vcxproj index 331a50e..682091e 100644 --- a/EgtExecutor.vcxproj +++ b/EgtExecutor.vcxproj @@ -257,6 +257,7 @@ copy $(TargetPath) \EgtProg\Dll64 + @@ -307,6 +308,7 @@ copy $(TargetPath) \EgtProg\Dll64 + diff --git a/EgtExecutor.vcxproj.filters b/EgtExecutor.vcxproj.filters index aa54c36..aa188a7 100644 --- a/EgtExecutor.vcxproj.filters +++ b/EgtExecutor.vcxproj.filters @@ -395,6 +395,12 @@ File di origine\Optional Dll + + File di origine\EXE + + + File di origine\LUA + diff --git a/LUA.h b/LUA.h index 93e40f9..9088f1f 100644 --- a/LUA.h +++ b/LUA.h @@ -54,6 +54,9 @@ bool LuaInstallGdbModifyVol( LuaMgr& luaMgr) ; //-------------------------- GdbGet ------------------------------------------ bool LuaInstallGdbGet( LuaMgr& luaMgr) ; +//-------------------------- GdbGetPocketing --------------------------------- +bool LuaInstallGdbGetPocketing( LuaMgr& luaMgr) ; + //-------------------------- GdbGetCurve ------------------------------------- bool LuaInstallGdbGetCurve( LuaMgr& luaMgr) ; @@ -62,7 +65,7 @@ bool LuaInstallGdbGetSurf( LuaMgr& luaMgr) ; //-------------------------- GdbGetVol --------------------------------------- bool LuaInstallGdbGetVol( LuaMgr& luaMgr) ; - + //-------------------------- GdbPartLayer ------------------------------------ bool LuaInstallGdbPartLayer( LuaMgr& luaMgr) ; diff --git a/LUA_Base.cpp b/LUA_Base.cpp index 3aa00e4..6846ca4 100644 --- a/LUA_Base.cpp +++ b/LUA_Base.cpp @@ -78,6 +78,10 @@ LuaInstallEgtFunctions( LuaMgr& LuaMgr) LOG_ERROR( GetLogger(), "Error in LuaInstallGdbGet (LuaInstallEgtFunctions)") return false ; } + if ( ! LuaInstallGdbGetPocketing( LuaMgr)) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbGetPocketing (LuaInstallEgtFunctions)") + return false ; + } if ( ! LuaInstallGdbGetCurve( LuaMgr)) { LOG_ERROR( GetLogger(), "Error in LuaInstallGdbGetCurve (LuaInstallEgtFunctions)") return false ; diff --git a/LUA_GdbGetPocketing.cpp b/LUA_GdbGetPocketing.cpp new file mode 100644 index 0000000..5f2bfb9 --- /dev/null +++ b/LUA_GdbGetPocketing.cpp @@ -0,0 +1,90 @@ +//---------------------------------------------------------------------------- +// EgalTech 2023-2023 +//---------------------------------------------------------------------------- +// File : LUA_GdbGetPocketing.cpp Data : 28.11.23 Versione : 2.5k6 +// Contenuto : Funzioni di creazione percorsi di svuotatura o infill per LUA. +// +// +// +// Modifiche : 29.11.23 RE Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "LUA.h" +#include "/EgtDev/Include/EXeExecutor.h" + +using namespace std ; + +//---------------------------------------------------------------------------- +static int +LuaPocketing( lua_State* L) { + // 7 parametri : vId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId + int nId ; + LuaCheckParam( L, 1, nId) ; + double dRad ; + LuaCheckParam( L, 2, dRad) ; + double dStep ; + LuaCheckParam( L, 3, dStep) ; + double dAngle ; + LuaCheckParam( L, 4, dAngle) ; + int nType ; + LuaCheckParam( L, 5, nType) ; + bool bSmooth ; + LuaCheckParam( L, 6, bSmooth) ; + int nDestGrpId ; + LuaCheckParam( L, 7, nDestGrpId) ; + LuaClearStack( L) ; + // calcolo delle curve elementari di svuotatura + int nFirstId = GDB_ID_NULL ; + int nCrvCount = 0 ; + bool bOk = ExePocketing( nId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId, nFirstId, nCrvCount) ; + if ( ! bOk) + LuaSetParam( L) ; + else + LuaSetParam( L, nFirstId) ; + LuaSetParam( L, nCrvCount) ; + return 2 ; +} + +//---------------------------------------------------------------------------- +static int +LuaSurfFrGetZigZagInfill( lua_State* L) +{ + // 6 parametri : nId, nDestGrpId, dSideStep, dAng, bSmooth, bRemoveOverlapLink + int nId ; + LuaCheckParam( L, 1, nId) + int nDestGrpId ; + LuaCheckParam( L, 2, nDestGrpId) + double dStep ; + LuaCheckParam( L, 3, dStep) + double dAng ; + LuaCheckParam( L, 4, dAng) ; + bool bSmooth ; + LuaCheckParam( L, 5, bSmooth) ; + bool bRemoveOverlapLink ; + LuaCheckParam( L, 6, bRemoveOverlapLink) ; + LuaClearStack( L) ; + // recupero i contorni della superficie + int nCount = 0 ; + int nNewId = ExeSurfFrGetZigZagInfill( nId, nDestGrpId, dStep, dAng, bSmooth, bRemoveOverlapLink, &nCount) ; + // restituisco il risultato + if ( nNewId != GDB_ID_NULL) + LuaSetParam( L, nNewId) ; + else + LuaSetParam( L) ; + LuaSetParam( L, nCount) ; + return 2 ; +} + +//------------------------------------------------------------------------------- +bool +LuaInstallGdbGetPocketing( LuaMgr& luaMgr) +{ + bool bOk = ( &luaMgr != nullptr) ; + bOk = bOk && luaMgr.RegisterFunction( "EgtPocketing", LuaPocketing) ; + bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfFrZigZagInfill", LuaSurfFrGetZigZagInfill) ; + return bOk ; +} \ No newline at end of file diff --git a/LUA_GdbGetSurf.cpp b/LUA_GdbGetSurf.cpp index ef3c3f3..4146c4e 100644 --- a/LUA_GdbGetSurf.cpp +++ b/LUA_GdbGetSurf.cpp @@ -237,35 +237,6 @@ LuaSurfFrRotateSimpleNoCollision( lua_State* L) return 1 ; } - -//---------------------------------------------------------------------------- -static int -LuaSurfFrGetZigZagInfill( lua_State* L) -{ - // 5 parametri : nId, nDestGrpId, dSideStep, dAng, bSmooth - int nId ; - LuaCheckParam( L, 1, nId) - int nDestGrpId ; - LuaCheckParam( L, 2, nDestGrpId) - double dStep ; - LuaCheckParam( L, 3, dStep) - double dAng ; - LuaCheckParam( L, 4, dAng) ; - bool bSmooth ; - LuaCheckParam( L, 5, bSmooth) ; - LuaClearStack( L) ; - // recupero i contorni della superficie - int nCount = 0 ; - int nNewId = ExeSurfFrGetZigZagInfill( nId, nDestGrpId, dStep, dAng, bSmooth, &nCount) ; - // restituisco il risultato - if ( nNewId != GDB_ID_NULL) - LuaSetParam( L, nNewId) ; - else - LuaSetParam( L) ; - LuaSetParam( L, nCount) ; - return 2 ; -} - //---------------------------------------------------------------------------- static int LuaSurfTmVertexCount( lua_State* L) @@ -1074,7 +1045,6 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr) bOk = bOk && luaMgr.RegisterFunction( "EgtExtractSurfFrChunkLoops", LuaExtractSurfFrChunkLoops) ; bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrMoveSimpleNoCollision", LuaSurfFrMoveSimpleNoCollision) ; bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrRotateSimpleNoCollision", LuaSurfFrRotateSimpleNoCollision) ; - bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfFrZigZagInfill", LuaSurfFrGetZigZagInfill) ; bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmVertexCount", LuaSurfTmVertexCount) ; bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetCount", LuaSurfTmFacetCount) ; bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmPartCount", LuaSurfTmPartCount) ; diff --git a/LUA_GdbModifyCurve.cpp b/LUA_GdbModifyCurve.cpp index 0866570..8e55001 100644 --- a/LUA_GdbModifyCurve.cpp +++ b/LUA_GdbModifyCurve.cpp @@ -969,37 +969,6 @@ LuaProjectCurveOnSurfTm( lua_State* L) return 1 ; } -//---------------------------------------------------------------------------- -static int -LuaPocketing( lua_State* L) { - // 7 parametri : vId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId - INTVECTOR vId ; - LuaCheckParam( L, 1, vId) ; - double dRad ; - LuaCheckParam( L, 2, dRad) ; - double dStep ; - LuaCheckParam( L, 3, dStep) ; - double dAngle ; - LuaCheckParam( L, 4, dAngle) ; - int nType ; - LuaCheckParam( L, 5, nType) ; - bool bSmooth ; - LuaCheckParam( L, 6, bSmooth) ; - int nDestGrpId ; - LuaCheckParam( L, 7, nDestGrpId) ; - LuaClearStack( L) ; - // calcolo delle curve elementari di svuotatura - int nFirstId = GDB_ID_NULL ; - int nCrvCount = 0 ; - bool bOk = ExePocketing( vId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId, nFirstId, nCrvCount) ; - if ( ! bOk) - LuaSetParam( L) ; - else - LuaSetParam( L, nFirstId) ; - LuaSetParam( L, nCrvCount) ; - return 2 ; -} - //---------------------------------------------------------------------------- static int LuaCurveGetVoronoi( lua_State* L) @@ -1132,7 +1101,6 @@ LuaInstallGdbModifyCurve( LuaMgr& luaMgr) bOk = bOk && luaMgr.RegisterFunction( "EgtChainCurvesInGroup", LuaChainCurvesInGroup) ; bOk = bOk && luaMgr.RegisterFunction( "EgtReorderCurvesInGroup", LuaReorderCurvesInGroup) ; bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfTm", LuaProjectCurveOnSurfTm) ; - bOk = bOk && luaMgr.RegisterFunction( "EgtPocketing", LuaPocketing) ; bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetVoronoi", LuaCurveGetVoronoi) ; bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMedialAxisAdv", LuaCurveMedialAxisAdv) ; bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetFatCurve", LuaCurveGetFatCurve) ;