From 06a73a069f1d4f3d6e83ee00159ba34e913cb438 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Mon, 24 Nov 2025 17:30:57 +0100 Subject: [PATCH] =?UTF-8?q?-=20aggiunta=20nuova=20modalit=C3=A0=20di=20pre?= =?UTF-8?q?=20calcolo=20collisioni,=20al=20momento=20lama=20e=20solo=20ass?= =?UTF-8?q?e=20Z=20-=20aggiunta=20libreria=20TimeLib=20per=20calcolare=20i?= =?UTF-8?q?=20tempi=20di=20esecuzione=20(sostituite=20chiamate=20a=20EgtSt?= =?UTF-8?q?artCounter=20e=20Stop)=20-=20rimosse=20chiamate=20a=20EgtOutLog?= =?UTF-8?q?=20deprecate?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- BatchProcessNew.lua | 13 ++- LuaLibs/BeamExec.lua | 35 +----- LuaLibs/FaceData.lua | 12 --- LuaLibs/MachiningLib.lua | 137 ++++++++++++++++++++++-- LuaLibs/TimeLib.lua | 70 ++++++++++++ NestProcess.lua | 2 - Process.lua | 13 ++- Strategies/Standard/STR0006/STR0006.lua | 3 +- StrategyLibs/BLADETOWASTE.lua | 2 + StrategyLibs/FACEBYBLADE.lua | 6 ++ 10 files changed, 238 insertions(+), 55 deletions(-) create mode 100644 LuaLibs/TimeLib.lua diff --git a/BatchProcessNew.lua b/BatchProcessNew.lua index 916d580..fc6df01 100644 --- a/BatchProcessNew.lua +++ b/BatchProcessNew.lua @@ -63,6 +63,8 @@ _G.package.loaded['HEADCUT\\HEADCUT'] = nil _G.package.loaded['TAILCUT\\TAILCUT'] = nil -- libreria macchina _G.package.loaded.BeamData = nil +-- libreria calcolo tempo esecuzione +_G.package.loaded.TimeLib = nil -- TODO controllare se c'è un modo migliore per resettare librerie delle strategie caricate precedentemente -- Per ottimizzare potremmo anche ciclare solo fino al numero di strategie raggiunto per il momento. @@ -178,6 +180,15 @@ local function WriteResultToJson( RESULT) end ------------------------------------------------------------------------------------------------------------- + +-- calcolo tempo esecuzione +if EgtGetDebugLevel() >= 3 then + TIMER:start() + EgtOutLog( ' Execution timer started') +end + +-- script principale + local sFlag = '' if BEAM.FLAG == 0 then sFlag = 'GENERATE' @@ -650,7 +661,7 @@ if bToProcess then -- si cancella gruppo temporaneo contenente entità da cancellare local idTempGroup = BeamLib.GetTempGroup() - EgtErase( idTempGroup) + --EgtErase( idTempGroup) local sOutput = '' diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index bd24d0a..a78a556 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -19,6 +19,7 @@ local FeatureLib = require( 'FeatureLib') local FaceData = require( 'FaceData') local MachiningLib = require( 'MachiningLib') local Logs = require( 'Logs') +local TimeLib = require( 'TimeLib') EgtOutLog( ' BeamExec started', 1) @@ -28,6 +29,7 @@ EgtMdbSave() ------------------------------------------------------------------------------------------------------------- -- *** variabili globali *** ------------------------------------------------------------------------------------------------------------- +-- TODO spostare in file separato TOOLS = {} -- tabella contenente tutti gli utensili STRATEGIES = {} -- tabella contenente le strategie disponibili per ogni feature STRATEGIES_CONFIG = {} -- tabella contenente i parametri di default delle strategie disponibili @@ -37,6 +39,7 @@ PROCESSINGS = {} -- tabella contenente tutte le informazioni di ogni feat RESULT = {} -- tabella contenente il risultato, feature per feature, dell'applicazione della strategia scelta e il resoconto dell'analisi fatta GENERAL_PARAMETERS = {} -- tabella contenente i parametri generali già letti e importati GENERAL_PARAMETERS_JSON = {} -- tabella contenente i parametri generali di default +TIMER = TimeLib.new() -- tabella contenente l'oggetto timer che tiene traccia del tempo di esecuzione ------------------------------------------------------------------------------------------------------------- -- *** COSTANTI *** TODO -> DA SPOSTARE IN BEAMDATA??? @@ -115,6 +118,7 @@ function BeamExec.GetToolsFromDB() Tool.dMaxMaterial = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) Tool.dDiameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM) Tool.dLength = EgtTdbGetCurrToolParam( MCH_TP.LEN) + Tool.dTotalLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) Tool.dSpeed = EgtTdbGetCurrToolParam( MCH_TP.SPEED) Tool.bIsCCW = Tool.dSpeed < 0 Tool.Feeds = {} @@ -1195,10 +1199,6 @@ end ------------------------------------------------------------------------------------------------------------- function BeamExec.GetProcessings( PARTS, bCalcBestPieceUnloadPosition) -- recupero tutti i processing di tutti i pezzi in tutte le rotazioni - -- TODO calcolo tempi da rimuovere o lasciare solo per debug - -- if EgtGetDebugLevel() >= 3 then - -- EgtStartCounter() - -- end -- si aprono i limiti tavola per permettere rotazioni di pezzi più larghi della tavola EgtSetTableAreaOffset( 2000, 2000, 2000, 2000) @@ -1246,13 +1246,7 @@ function BeamExec.GetProcessings( PARTS, bCalcBestPieceUnloadPosition) -- recupero le feature di lavorazione della trave table.insert( PROCESSINGS, Part) end - -- TODO calcolo tempi da rimuovere o lasciare solo per debug - -- if EgtGetDebugLevel() >= 3 then - -- local timeGetProcessings = EgtStopCounter() - -- timeGetProcessings = timeGetProcessings + 0 - -- EgtOutBox( timeGetProcessings, 'GetProcessings calculation time') - -- EgtStartCounter() - -- end + return PROCESSINGS end @@ -1567,25 +1561,6 @@ function BeamExec.ProcessMachinings( PARTS) local Stats = {} local nOrd = 1 --- TODO da rimuovere o lasciare solo per debug ---if EgtGetDebugLevel() >= 3 then --- EgtStartCounter() ---end --- TODO da rimuovere o lasciare solo per debug ---if EgtGetDebugLevel() >= 3 then --- local timeCollect = EgtStopCounter() --- timeCollect = timeCollect + 0 --- EgtOutBox( timeCollect, 'Collect calculation time') --- EgtStartCounter() ---end --- TODO da rimuovere o lasciare solo per debug ---if EgtGetDebugLevel() >= 3 then --- local timeMachining = EgtStopCounter() --- timeMachining = timeMachining + 0 --- EgtOutBox( timeMachining, 'Machining calculation time') ---end - - -- ricerca strategia di lavorazione per ogni pezzo e applicazione lavorazioni for nPart = 1, #PARTS do diff --git a/LuaLibs/FaceData.lua b/LuaLibs/FaceData.lua index 3013d82..18bf947 100644 --- a/LuaLibs/FaceData.lua +++ b/LuaLibs/FaceData.lua @@ -149,7 +149,6 @@ end ------------------------------------------------------------------------------------------------------------- function FaceData.GetFacesInfo( Proc, Part, FacesToGet) - EgtOutLog( '---Faces START---') local Faces = {} local function FaceIsToGet( nIndex) @@ -194,26 +193,18 @@ function FaceData.GetFacesInfo( Proc, Part, FacesToGet) Faces[i].bIsOkForMachining = nFaceType < 1 Faces[i].Edges = Edges - -- TODO valutare se fare un output unico alla fine o gestire log in altro modo - EgtOutLog( 'Facet ' .. Faces[i].id .. ' of ' .. Proc.nFct - 1) - EgtOutLog( ' vtN: ' .. tostring( Faces[i].vtN)) - -- adiacenze della faccia -- TODO chiamarle in modo che si capisca che sono solo gli id e non l'intero oggetto faccia Faces[i].Adjacencies = {} for j = 1, Proc.nFct do if vAdj[i][j] and vAdj[i][j] ~= 0 and ( i ~= j) then table.insert( Faces[i].Adjacencies, j - 1) - if EgtGetDebugLevel() >= 3 then - EgtOutLog( ' Adjacent to facet: ' .. j - 1) - end end end end end - EgtOutLog( '---Faces END---') return Faces end @@ -656,7 +647,6 @@ end -- TODO test iniziale replicato in GetTunnelFaces function FaceData.GetMainFaces( Proc, Part) - EgtOutLog( '---MainFaces START---') local MainFaces = {} -- CASO 1 : Feature tipo LapJoint @@ -676,10 +666,8 @@ function FaceData.GetMainFaces( Proc, Part) else MainFaces = nil - EgtOutLog( '---MainFaces NOT NEEDED---') end - EgtOutLog( '---MainFaces END---') return MainFaces end diff --git a/LuaLibs/MachiningLib.lua b/LuaLibs/MachiningLib.lua index 0752e39..afdbd35 100644 --- a/LuaLibs/MachiningLib.lua +++ b/LuaLibs/MachiningLib.lua @@ -269,7 +269,7 @@ end ------------------------------------------------------------------------------------------------------------- -- in base a tipo testa e angolo soglia, verifica se la faccia è troppo inclinata per la lavorazione scelta (per DownUp passare vtNFace opposta) -local function IsFaceZOutOfRange ( vtNFace, Tool) +local function IsFaceZOutOfRange( vtNFace, Tool) -- lama sopra: angolo negativo troppo basso if Tool.SetupInfo.HeadType.bTop and vtNFace:getZ() < Tool.SetupInfo.GetMinNz( vtNFace, Tool) - GEO.EPS_ZERO then @@ -284,12 +284,128 @@ local function IsFaceZOutOfRange ( vtNFace, Tool) end ------------------------------------------------------------------------------------------------------------- --- si controlla la collisione con il carro Z nei 2 piani globali X e Y (si considera infinitamente alto in Z). Se c'è collisione in entrambi i piani, il carro sarà in collisione. +-- +local function CheckCollisionAxisC( Edge, vtNFace, vtHead, Part, Tool, dDepthToMachine) +end + +------------------------------------------------------------------------------------------------------------- +-- si controlla la collisione con il carro Z nei 3 piani globali X, Y e Z. Se c'è collisione in tutti i piani, il carro sarà in collisione. +local function CheckCollisionAxisZ( Edge, vtNFace, vtHead, Part, Tool, dDepthToMachine) + + -- se faccia non parallela a direzione testa c'è qualcosa che non va + if not AreSameOrOppositeVectorApprox( vtNFace, vtHead) then + error( 'CheckCollisionAxisZ : invalid directions') + end + + -- TODO rimettere + -- se direzione utensile parallela ad uno degli assi principali non serve alcuna verifica + -- if AreSameOrOppositeVectorApprox( Edge.vtN, X_AX()) + -- or AreSameOrOppositeVectorApprox( Edge.vtN, Y_AX()) + -- or AreSameOrOppositeVectorApprox( Edge.vtN, Z_AX()) then + + -- return false + -- end + + local idTempGroup = BeamLib.GetTempGroup() + + -- punti notevoli della lavorazione in cui fare il check + -- TODO aggiungere anche ptMid? + local MachiningPoints = { + Point3d( Edge.ptStart) + Edge.vtN * ( Edge.dElevation - dDepthToMachine), + Point3d( Edge.ptEnd) + Edge.vtN * ( Edge.dElevation - dDepthToMachine) + } + + -- punti in centro lama su naso mandrino o aggregato. In base a direzione e punto + local bIsDownUp = AreOppositeVectorApprox( vtNFace, vtHead) + local ToolExitPoints = {} + for i = 1, #MachiningPoints do + ToolExitPoints[i] = Point3d( MachiningPoints[i] + Edge.vtN * Tool.dDiameter / 2) + vtHead * EgtIf( bIsDownUp, ( Tool.dLength - Tool.dThickness), Tool.dLength) + end + + -- direzioni in cui fare il check + -- TODO queste cambieranno in base all'asse da controllare + local CheckDirections = { + { vtDirectionX = X_AX(), vtDirectionY = Z_AX(), vtDirectionZ = -Y_AX(), sDirectionName = 'X'}, + { vtDirectionX = Y_AX(), vtDirectionY = Z_AX(), vtDirectionZ = X_AX(), sDirectionName = 'Y'}, + { vtDirectionX = X_AX(), vtDirectionY = Y_AX(), vtDirectionZ = Z_AX(), sDirectionName = 'Z'} + } + + -- TEST + local Color = Color3d( math.random(0, 255), math.random(0, 255), math.random(0, 255)) + -- TEST + + for i = 1, #CheckDirections do + + local vtDirectionX = CheckDirections[i].vtDirectionX + local vtDirectionZ = CheckDirections[i].vtDirectionZ + local sDirectionName = CheckDirections[i].sDirectionName + + -- costruzione flat region del pezzo nel piano scelto + -- si estrae prima la silhouette nel piano + local idFirstCurve, nCurveCount = EgtGetSurfTmSilhouette( Part.idBoxTm, vtDirectionZ, 10 * GEO.EPS_SMALL, idTempGroup, GDB_RT.GLOB) + -- se più curve c'è qualcosa che non va: errore + if nCurveCount > 1 then + error( 'CheckCollisionAxisZ : error in part box') + end + -- creazione flat region dalla silhouette + local idPartSurfFr = EgtSurfFlatRegion( idTempGroup, idFirstCurve) + + -- costruzione flat region del grezzo restante nel piano scelto (con leggera sovrapposizione) + -- si costruisce il box in globale + local ptRestLengthMax = Point3d( Part.b3Part:getMin()) + X_AX() * 500 * GEO.EPS_SMALL + local ptRestLengthMin = Point3d( Part.b3Part:getMin():getX() - 2000, Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ()) + local b3RestLength = BBox3d( ptRestLengthMin, ptRestLengthMax) + -- si crea la trimesh dal box + local idRestLengthBoxTm = EgtSurfTmBBox( idTempGroup, b3RestLength , false, GDB_RT.GLOB) + -- si estrae la silhouette nel piano + idFirstCurve, nCurveCount = EgtGetSurfTmSilhouette( idRestLengthBoxTm, vtDirectionZ, 10 * GEO.EPS_SMALL, idTempGroup, GDB_RT.GLOB) + -- se più curve c'è qualcosa che non va: errore + if nCurveCount > 1 then + error( 'CheckCollisionAxisZ : error in part box') + end + -- creazione flat region dalla silhouette + local idRestLengthSurfFr = EgtSurfFlatRegion( idTempGroup, idFirstCurve) + + -- costruzione flat region del carro Z nel piano scelto, tra punto iniziale e finale lavorazione + -- recupero punti da macchina per costruire flat region + local ZAxisPoints = Tool.SetupInfo.GetAxisZPoints( sDirectionName) + -- per ogni punto in cui controllare si crea una flat region (al momento solo 2, altrimenti la ruled) + local CollisionCurves = {} + for j = 1, #ToolExitPoints do + -- curva di collisione in riferimento locale + local idCollisionCurve = EgtCurveCompoFromPoints( idTempGroup, ZAxisPoints) + table.insert( CollisionCurves, idCollisionCurve) + + -- TEST + EgtSetColor( idCollisionCurve, Color) + -- TEST + + -- calcolo pivot in riferimento globale + local ptRef = ToolExitPoints[j] + local frTool = Frame3d( ptRef, vtHead, Edge.vtN) + -- TODO vtPivotGlob dovrà arrivare da funzione perchè può cambiare con SCC (es: aggregato) + local vtPivotGlob = Vector3d( Tool.SetupInfo.vtPivot) + vtPivotGlob:toGlob( frTool) + local ptPivot = ptRef + vtPivotGlob + EgtPoint( idTempGroup, ptPivot, 0) + + -- curva in riferimento globale + local frReference = Frame3d( ptPivot, vtDirectionZ, vtDirectionX) + EgtTransform( idCollisionCurve, frReference, GDB_RT.GLOB ) + end + -- TODO serve fare la ruled o basta controllare nei punti estremi? + --EgtSurfTmRuled( idTempGroup, CollisionCurves[1], CollisionCurves[2]) + end + + +end + ------------------------------------------------------------------------------------------------------------- -- nel piano perpendicolare alla direzione di taglio, se c'è intersezione tra motore e trave c'è collisione -local function Check2DBladeCollision( Edge, vtNFace, vtHead, Part, Tool, dDepthToMachine) +-- TODO da integrare in funzione sopra +local function CheckCollisionAxisAB( Edge, vtNFace, vtHead, Part, Tool, dDepthToMachine) -- se direzione utensile parallela ad uno degli assi principali non serve alcuna verifica if AreSameOrOppositeVectorApprox( Edge.vtN, X_AX()) @@ -316,7 +432,7 @@ local function Check2DBladeCollision( Edge, vtNFace, vtHead, Part, Tool, dDepthT -- creazione flat region dalla silhouette local idPartSurfFr = EgtSurfFlatRegion( idTempGroup, idFirstCurve) - -- costruzione flat region del grezzo restante nel piano perpendicolare al taglio + -- costruzione flat region del grezzo restante nel piano perpendicolare al taglio (con leggera sovrapposizione) -- si costruisce il box in globale local ptRestLengthMax = Point3d( Part.b3Part:getMin() + X_AX() * 500 * GEO.EPS_SMALL) local ptRestLengthMin = Point3d( Part.b3Part:getMin():getX() - 2000, Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ()) @@ -381,7 +497,7 @@ end ------------------------------------------------------------------------------------------------------------- -- ritorna se la faccia e il lato sono lavorabili e, se sì, il modo di lavorare (standard/DownUp) --- TODO si dovrà decidere come tagliare anche in base a lavorazione di coda (spostare dopo separazione?) o pezzo corto (il motore non deve ingombrare con il pinzaggio) +-- TODO si dovrà decidere come tagliare anche se pezzo corto (il motore non deve ingombrare con il pinzaggio) -- valutare se restituire, se disponibili, entrambe le soluzioni e demandare la decisione alla FaceByBlade function MachiningLib.GetBladeEngagement( Face, Edge, Part, Tool, dDepthToMachine, bCollisionCheckForDownUpOnly) local sBladeEngagement = 'Standard' @@ -389,8 +505,11 @@ function MachiningLib.GetBladeEngagement( Face, Edge, Part, Tool, dDepthToMachin -- la normale della faccia permette di lavorare in modo standard, ma potrebbero esserci altre condizioni che fanno fallire il taglio if not IsFaceZOutOfRange( Face.vtN, Tool) then - -- TODO verifica collisione carro Z, collisione traversa PF, collisione 'C' Fast... La riduzione percorso cambia questo test? - local bCollisionFound, bMoveAfterSplit = Check2DBladeCollision( Edge, Face.vtN, Face.vtN, Part, Tool, dDepthToMachine) + -- TODO La riduzione percorso cambia questo test? + -- TODO da completare questo test + local bCollisionFoundZ, bMoveAfterSplitZ = CheckCollisionAxisZ( Edge, Face.vtN, Face.vtN, Part, Tool, dDepthToMachine) + + local bCollisionFound, bMoveAfterSplit = CheckCollisionAxisAB( Edge, Face.vtN, Face.vtN, Part, Tool, dDepthToMachine) if bCollisionCheckForDownUpOnly or not bCollisionFound then return true, sBladeEngagement, bMoveAfterSplit @@ -416,7 +535,7 @@ function MachiningLib.GetBladeEngagement( Face, Edge, Part, Tool, dDepthToMachin end -- orientamento faccia / utensile compatibili con DownUp: lavorabile - local bCollisionFound, bMoveAfterSplit = Check2DBladeCollision( Edge, Face.vtN, -Face.vtN, Part, Tool, dDepthToMachine) + local bCollisionFound, bMoveAfterSplit = CheckCollisionAxisAB( Edge, Face.vtN, -Face.vtN, Part, Tool, dDepthToMachine) if not bCollisionFound then sBladeEngagement = 'DownUp' @@ -595,7 +714,9 @@ function MachiningLib.FindBlade( Proc, ToolSearchParameters) if bIsToolCompatible then if FaceToMachine and EdgeToMachine and Part and dElevation then local bIsBladeOk = false + TIMER:setCheckpoint( 'GetBladeEngagement') bIsBladeOk, sCurrentBladeEngagement, bCurrentMoveAfterSplit = MachiningLib.GetBladeEngagement( FaceToMachine, EdgeToMachine, Part, TOOLS[i], dElevation, bCollisionCheckForDownUpOnly) + TIMER:logElapsed( 'GetBladeEngagement') -- orientamento non raggiungibile if not bIsBladeOk then bIsToolCompatible = false diff --git a/LuaLibs/TimeLib.lua b/LuaLibs/TimeLib.lua new file mode 100644 index 0000000..96f8f62 --- /dev/null +++ b/LuaLibs/TimeLib.lua @@ -0,0 +1,70 @@ +-- BeamLib.lua by Egalware s.r.l. 2025/11/24 +-- Libreria calcolo tempo automatismo + + +-- Tabella per definizione modulo +local TimeLib = {} + + +EgtOutLog( ' TimeLib started', 1) + + +TimeLib.__index = TimeLib + +function TimeLib.new() + local self = setmetatable({}, TimeLib) + self.dStartTime = os.clock() + self.Checkpoints = {} -- each checkpoint stores first and last timestamps + return self +end + +-- reset timer +function TimeLib:start() + self.dStartTime = os.clock() + self.Checkpoints = {} +end + +-- setta un checkpoint con nome (default se non specificato) +function TimeLib:setCheckpoint( sName) + local sCpName = sName or "default" + local dNow = os.clock() + + if not self.Checkpoints[sCpName] then + self.Checkpoints[sCpName] = { dFirst = dNow, dLast = dNow } + else + self.Checkpoints[sCpName].dLast = dNow + end +end + +-- ritorna il tempo trascorso +-- se settato un checkpoint, ritorna anche il tempo di quel checkpoint, cumulativo (dal primo checkpoint settato con quel nome) e recente (dall'ultimo checkpoint settato) +function TimeLib:elapsed( sCheckpointName) + local dTotal = os.clock() - self.dStartTime + local sCpName = sCheckpointName or "default" + local Checkpoint = self.Checkpoints[sCpName] + + if Checkpoint then + local dCumulative = os.clock() - Checkpoint.dFirst + local dRecent = os.clock() - Checkpoint.dLast + return dTotal, dCumulative, dRecent + else + return dTotal, nil, nil + end +end + +-- log del tempo trascorso, come sopra +function TimeLib:logElapsed( sCheckpointName) + local dTotal, dCumulative, dRecent = self:elapsed( sCheckpointName) + local sCpName = sCheckpointName or "default" + + if dCumulative then + EgtOutLog( string.format( + "%s time: recent %.3f, cumulative %.3f, total %.3f", + sCpName, dRecent, dCumulative, dTotal)) + else + EgtOutLog( string.format("Total %.3f (no checkpoint '%s' set)", + dTotal, sCpName)) + end +end + +return TimeLib diff --git a/NestProcess.lua b/NestProcess.lua index d3fd807..aaace66 100644 --- a/NestProcess.lua +++ b/NestProcess.lua @@ -91,9 +91,7 @@ local function ExecMaximumFilling( Raw, Parts) EgtMaxFillerAddPart( i, Parts[i].Len, Parts[i].DispLen or Parts[i].Len, Parts[i].Cnt or 1) end -- Eseguo l'ottimizzazione - --EgtStartCounter() EgtMaxFillerCompute( Raw.LenToFill, Raw.StartGap, Raw.MidGap, Raw.EndGap, Raw.SortType) - --local dTime = EgtStopCounter() -- Recupero i risultati local nFilledParts, nDiffParts, dTotFillRatio = EgtMaxFillerGetResults() local OneRes = {} diff --git a/Process.lua b/Process.lua index f89550b..961be4f 100644 --- a/Process.lua +++ b/Process.lua @@ -7,7 +7,7 @@ -- Intestazioni require( 'EgtBase') _ENV = EgtProtectGlobal() -EgtEnableDebug( true) +EgtEnableDebug( false) -- Imposto direttorio libreria specializzata per Travi EgtAddToPackagePath( BEAM.BASEDIR .. '\\LuaLibs\\?.lua') @@ -51,6 +51,8 @@ _G.package.loaded['HEADCUT\\HEADCUT'] = nil _G.package.loaded['TAILCUT\\TAILCUT'] = nil -- libreria macchina _G.package.loaded.BeamData = nil +-- libreria calcolo tempo esecuzione +_G.package.loaded.TimeLib = nil -- TODO controllare se c'è un modo migliore per resettare librerie delle strategie caricate precedentemente -- Per ottimizzare potremmo anche ciclare solo fino al numero di strategie raggiunto per il momento. @@ -365,6 +367,15 @@ end ------------------------------------------------------------------------------------------------------------- -- *** Esecuzione *** ------------------------------------------------------------------------------------------------------------- + +-- calcolo tempo esecuzione +if EgtGetDebugLevel() >= 3 then + TIMER:start() + EgtOutLog( ' Execution timer started') +end + +-- script principale + if not MyProcessInputData() then return end -- recupero parametri generali da progetto diff --git a/Strategies/Standard/STR0006/STR0006.lua b/Strategies/Standard/STR0006/STR0006.lua index 1be5fe3..08648d7 100644 --- a/Strategies/Standard/STR0006/STR0006.lua +++ b/Strategies/Standard/STR0006/STR0006.lua @@ -74,7 +74,8 @@ local function GetTenonStrategy( Proc, Part) local bMachIsOk = true if ( Proc.FeatureInfo.vtTenonN:getZ() < 0 and TOOLS[Machining.Milling.ToolInfo.nToolIndex].SetupInfo.HeadType.bTop) or ( Proc.FeatureInfo.vtTenonN:getZ() > 0 and TOOLS[Machining.Milling.ToolInfo.nToolIndex].SetupInfo.HeadType.bBottom) then - local dTotalLen = TOOLS[Machining.Milling.ToolInfo.nToolIndex].dLength + TOOLS[Machining.Milling.ToolInfo.nToolIndex].SetupInfo.dPivot + -- TODO questo test va sostituito con check collisione asse Z + local dTotalLen = TOOLS[Machining.Milling.ToolInfo.nToolIndex].dLength + TOOLS[Machining.Milling.ToolInfo.nToolIndex].SetupInfo.vtPivot:len() local dHorizSpace = dTotalLen * sqrt( 1 - ( Proc.FeatureInfo.vtTenonN:getZ() * Proc.FeatureInfo.vtTenonN:getZ())) if dHorizSpace - ( TOOLS[Machining.Milling.ToolInfo.nToolIndex].SetupInfo.dCAxisSideEncumbrance / 2) < Proc.b3Box:getDimX() then bMachIsOk = false diff --git a/StrategyLibs/BLADETOWASTE.lua b/StrategyLibs/BLADETOWASTE.lua index 8226c12..00f5e15 100644 --- a/StrategyLibs/BLADETOWASTE.lua +++ b/StrategyLibs/BLADETOWASTE.lua @@ -561,7 +561,9 @@ local function GetDualSideCutStrategy( Proc, Part, OptionalParameters) -- lavorando dalla direzione opposta si verifica come se si lavorasse il lato opposto local EdgeToMachineOpposite = BeamLib.FindEdgeBestOrientedAsDirection( FaceToMachine.Edges, -EdgeToMachine.vtN) + TIMER:setCheckpoint( 'GetBladeEngagement') local bIsApplicableOpposite = MachiningLib.GetBladeEngagement( FaceToMachine, EdgeToMachineOpposite, Part, TOOLS[ToolInfo.nToolIndex], dDepthToMachine) + TIMER:logElapsed( 'GetBladeEngagement') if not bIsApplicableOpposite then return CuttingParametersList, EdgeToMachine end diff --git a/StrategyLibs/FACEBYBLADE.lua b/StrategyLibs/FACEBYBLADE.lua index 0d3b71c..3a51f6f 100644 --- a/StrategyLibs/FACEBYBLADE.lua +++ b/StrategyLibs/FACEBYBLADE.lua @@ -273,7 +273,9 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar if nToolIndex then Cutting.nToolIndex = nToolIndex + TIMER:setCheckpoint( 'GetBladeEngagement') Cutting.bIsApplicable, Cutting.sBladeEngagement, Cutting.bMoveAfterSplit = MachiningLib.GetBladeEngagement( FaceToMachine, EdgeToMachine, Part, TOOLS[Cutting.nToolIndex], dDepthToMachine, bCollisionCheckForDownUpOnly) + TIMER:logElapsed( 'GetBladeEngagement') -- utensile da cercare: si prende la lama migliore che può effettuare questo taglio, senza particolari analisi else @@ -354,7 +356,9 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar if OppositeToolDirectionMode ~= 'Disabled' then -- lavorando dalla direzione opposta si verifica come se si lavorasse il lato opposto + TIMER:setCheckpoint( 'GetBladeEngagement') local bIsApplicableOpposite, sBladeEngagementOpposite, bMoveAfterSplit = MachiningLib.GetBladeEngagement( FaceToMachine, EdgeToMachineOpposite, Part, TOOLS[Cutting.nToolIndex], dDepthToMachine, bCollisionCheckForDownUpOnly) + TIMER:logElapsed( 'GetBladeEngagement') -- taglio opposto non fattibile if not bIsApplicableOpposite then @@ -449,7 +453,9 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar if OppositeToolDirectionMode == 'Enabled' then EdgeToMachineForEngagement = EdgeToMachineOpposite end + TIMER:setCheckpoint( 'GetBladeEngagement') local bIsApplicable, sBladeEngagement, bMoveAfterSplit = MachiningLib.GetBladeEngagement( FaceToMachine, EdgeToMachineForEngagement, Part, TOOLS[Cutting.nToolIndex], dDepthToMachine) + TIMER:logElapsed( 'GetBladeEngagement') -- se non fattibile o cambiano le condizioni BladeEngagement, non si riduce if not ( bIsApplicable and ( sBladeEngagement == Cutting.sBladeEngagement) and ( bMoveAfterSplit == Cutting.bMoveAfterSplit)) then