- Aggiunto tempo di calcolo delle alternative

- Di default la ricerca delle alternative è disattiva
- Piccole migliorie varie

BatchProcessNew.lua

@@ -214,9 +214,6 @@ end
 local sLog = 'BatchProcess : ' .. BEAM.FILE .. ', ' .. ( BEAM.MACHINE or EgtGetCurrMachineName()) .. ', ' .. sFlag
 EgtOutLog( sLog)
 
--- TODO forzatura calcolo con prerotazioni. Cancellare dopo che è stata aggiunta la gestione corretta
-local bCalcBestPieceUnloadPosition = true or BEAM.FLAG == 10
-
 -- Dati dei file
 -- TODO spostare a quando flag ~= 6 e 9
 local sDir, sTitle = EgtSplitPath( BEAM.FILE)
@@ -551,7 +548,7 @@ if bToProcess then
       end
       
       -- Sistemo le travi nel grezzo
-      local bPbOk, sPbErr = BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, nil, PARTS, BEAM.FLAG ~= 6, bCalcBestPieceUnloadPosition)
+      local bPbOk, sPbErr = BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, nil, PARTS, BEAM.FLAG ~= 6, false)
       if not bPbOk then
          BEAM.ERR = 18
          BEAM.MSG = sPbErr
@@ -640,7 +637,7 @@ if bToProcess then
          BeamExec.GetStrategiesFromJSONinBD( PARTS[i].sAISetupConfig)
          PARTS[i].GeneralParameters = BeamLib.GetPieceGeneralParameters( PARTS[i], GENERAL_PARAMETERS_JSON)
          TIMER:stopElapsed('Json')
-         PARTS[i].CombinationList = BeamExec.GetAvailableCombinations( PARTS[i], bCalcBestPieceUnloadPosition)
+         PARTS[i].CombinationList = BeamExec.GetAvailableCombinations( PARTS[i], false)
 
          -- sovramateriale in testa al pezzo
          local dDeltaS = max( PARTS[i].dPosX - ( dBarLen - dLen), 0)
@@ -693,8 +690,8 @@ if bToProcess then
    -- TODO gestire errori e messaggi di ritorno in questo caso
    if not GetDataConfig() then return end
 
-   BeamExec.GetProcessings( PARTS, bCalcBestPieceUnloadPosition)
-   BeamExec.GetCombinationMatrix( PARTS, bCalcBestPieceUnloadPosition)
+   BeamExec.GetProcessings( PARTS, false)
+   BeamExec.GetCombinationMatrix( PARTS, false)
    BeamExec.ProcessMachinings( PARTS)
 
    -- si cancella gruppo temporaneo contenente entità da cancellare

FlipRot.lua

@@ -0,0 +1,242 @@
+-- Process.lua by Egalware s.r.l. 2024/04/02
+-- Gestione calcolo disposizione e lavorazioni per Travi
+-- Si opera sulla macchina corrente
+-- 2024/04/02 PRIMA VERSIONE
+
+
+-- Intestazioni
+require( 'EgtBase')
+_ENV = EgtProtectGlobal()
+EgtEnableDebug( false)
+
+-- Imposto direttorio libreria specializzata per Travi
+EgtAddToPackagePath( BEAM.BASEDIR .. '\\LuaLibs\\?.lua')
+-- Imposto direttorio strategie. N.B. Le strategie dovranno essere caricate con il nome del direttorio padre
+EgtAddToPackagePath( BEAM.BASEDIR .. '\\Strategies\\Standard\\?.lua')
+EgtAddToPackagePath( BEAM.BASEDIR .. '\\StrategyLibs\\?.lua')
+
+-- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
+local sMachDir = EgtGetCurrMachineDir()
+if not sMachDir then
+   EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Travi', 'ERROR')
+   return
+end
+if not EgtExistsFile( sMachDir .. '\\Beam\\BeamDataNew.lua') then
+   EgtOutBox( 'La macchina corrente non è configurata per lavorare travi', 'Lavora Travi', 'ERROR')
+   return
+end
+
+-- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie
+EgtRemoveBaseMachineDirFromPackagePath()
+EgtAddToPackagePath( sMachDir .. '\\Beam\\?.lua')
+
+-- Segnalazione avvio
+EgtOutLog( '*** Beam Process Start ***', 1)
+
+-- Carico le librerie
+_G.package.loaded.BasicCustomerStrategies = nil
+_G.package.loaded.BeamExec = nil
+_G.package.loaded.BeamLib = nil
+_G.package.loaded.DiceCut = nil
+_G.package.loaded.FaceData = nil
+_G.package.loaded.FeatureLib = nil
+_G.package.loaded.Identity = nil
+_G.package.loaded.Logs = nil
+_G.package.loaded.MachiningLib = nil
+_G.package.loaded.PreSimulationLib = nil
+_G.package.loaded.LeadInOutLib = nil
+-- strategie di base sempre presenti
+_G.package.loaded['HEADCUT\\HEADCUT'] = nil
+_G.package.loaded['TAILCUT\\TAILCUT'] = nil
+-- libreria macchina
+_G.package.loaded.BeamDataNew = 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.
+-- Infatti difficile ci siano 9999 strategie.
+-- reset strategie caricate come librerie
+for i = 1, 9999 do
+   local idSTRTemp = EgtReplaceString( EgtNumToString( i/10000, -4), '0.', '')
+   local sLibraryToReload = "STR" .. idSTRTemp .. "\\STR" .. idSTRTemp
+   if _G.package.loaded[sLibraryToReload] then
+      _G.package.loaded[sLibraryToReload] = nil
+   end
+end
+local vtCoreStrategiesNames = EgtFindAllFiles( BEAM.BASEDIR .. '\\StrategyLibs\\*.lua')
+for i = 1, #vtCoreStrategiesNames do
+   local sCurrentName = EgtSplitString( vtCoreStrategiesNames[i], '.')[1]
+   if _G.package.loaded[sCurrentName] then
+      _G.package.loaded[sCurrentName] = nil
+   end
+end
+
+
+-- Variabili globali
+PARTS = {}          -- tabella contenente tutte le informazioni di ogni pezzo
+
+-- Carico i dati globali
+local BeamData = require( 'BeamDataNew')
+-- carico librerie
+local BeamExec = require( 'BeamExec')
+local BeamLib = require( 'BeamLib')
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Recupero trave (E' SEMPRE E SOLO UNA) ***
+-------------------------------------------------------------------------------------------------------------
+local function MyProcessInputData()
+   -- Recupero il pezzo e i suoi dati
+   local nId = EgtGetFirstPart()
+   if nId then
+      table.insert( PARTS, { nInd = #PARTS + 1, id = nId, sName = ( EgtGetName( nId) or ( 'Id=' .. tonumber( nId)))})
+      local Ls = EgtGetFirstNameInGroup( PARTS[1].id, 'Box')
+      local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
+      if not b3Solid then
+         return false
+      end
+      PARTS[1].b3PartOriginal = b3Solid
+   else
+      return false
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetDataConfig()
+   -- recupero utensili dal magazzino
+   BeamExec.GetToolsFromDB()
+   -- TODO da gestire eventuali errori bloccanti
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Inserimento delle travi nel grezzo ***
+-------------------------------------------------------------------------------------------------------------
+local function MyProcessBeams()
+   -- Lunghezza totale delle travi
+   local dLen = PARTS[1].b3PartOriginal:getDimX()
+   local dRawW = PARTS[1].b3PartOriginal:getDimY()
+   local dRawH = PARTS[1].b3PartOriginal:getDimZ()
+
+   -- Determinazione minimo grezzo scaricabile
+   BeamExec.CalcMinUnloadableRaw( dRawW, dRawH)
+
+   local dOvmHead = BeamData.OVM_HEAD or 10
+   local dOvmMid = BeamData.OVM_MID or 10
+
+   local dRawL = max( dLen + dOvmHead + dOvmMid, BeamData.dMinRaw)
+
+   -- Recupero info pezzi
+   local bOk, sErr = BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS, nil, true)
+   if not bOk then
+      EgtOutLog( sErr)
+      return false
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Inserimento delle lavorazioni nelle travi ***
+-------------------------------------------------------------------------------------------------------------
+local function MyProcessFeatures()
+
+   BeamExec.GetProcessings( PARTS, true)
+   BeamExec.GetCombinationMatrix( PARTS, true)
+   BeamExec.ProcessMachinings( PARTS)
+   local nErrCnt = 0
+   local nWarnCnt = 0
+   local sOutput = ''
+   for i = 1, #RESULT do
+      local sMsg = ''
+      if RESULT[i].sType == 'Feature' then
+         sMsg = RESULT[i].ChosenStrategy.sInfo
+      elseif RESULT[i].sType == 'Part' then
+         sMsg = RESULT[i].sMsg
+      end
+      sMsg = string.gsub( sMsg or '', '\n', ' ', 10)
+      sMsg = string.gsub( sMsg or '', '\r', ' ', 10)
+      -- trovata almeno una strategia e feature lavorata completamente
+      if RESULT[i].sType == 'Feature' and RESULT[i].ChosenStrategy.sStatus == 'Completed' then
+         sOutput = sOutput .. string.format( '[%d,%d] %s\n', RESULT[i].idCut, RESULT[i].idTask, sMsg or '')
+
+      -- trovata almeno una strategia ma nessuna applicabile oppure non trovata alcuna strategia
+      elseif RESULT[i].sType == 'Feature'
+         and ( ( RESULT[i].ChosenStrategy.sStatus == 'Not-Applicable')
+         or ( not RESULT[i].ChosenStrategy.sStrategyName)) then
+
+         nErrCnt = nErrCnt + 1
+         if #sMsg == 0 then
+            sMsg = 'No applicable strategy found'
+         end
+         sOutput = sOutput .. string.format( '[%d,%d] %s\n', RESULT[i].idCut, RESULT[i].idTask, sMsg)
+      else
+         -- segnalazione scarico pezzo standard, incompleto o a caduta
+         if RESULT[i].sType == 'Part' and ( RESULT[i].nErr == -100 or RESULT[i].nErr == -101 or RESULT[i].nErr == -102) then
+            -- nulla da segnalare
+
+         -- feature incompleta e altro
+         elseif RESULT[i].sType == 'Feature' and RESULT[i].ChosenStrategy.sStatus == 'Not-Completed' then
+            nWarnCnt = nWarnCnt + 1
+            sMsg = 'Incomplete : Completion index ' .. RESULT[i].ChosenStrategy.dCompletionIndex .. '/5\n' .. sMsg
+            sOutput = sOutput .. string.format( '[%d,%d] %s\n', RESULT[i].idCut, RESULT[i].idTask, sMsg)
+
+         end
+      end
+   end
+
+   -- si calcolano alternative
+   TIMER:startElapsed('Alternatives')
+   BeamExec.ProcessAlternatives( PARTS)
+   TIMER:stopElapsed('Alternatives')
+
+   -- cancello gruppo temporaneo
+   local idTempGroup = BeamLib.GetTempGroup()
+   EgtErase( idTempGroup)
+
+   if #sOutput > 0 then EgtOutLog( sOutput) end
+   if nErrCnt > 0 then
+      EgtOutBox( sOutput, 'Lavora Travi', 'ERRORS')
+      return false
+   elseif nWarnCnt > 0 then
+      EgtOutBox( sOutput, 'Lavora Travi', 'WARNINGS')
+      return true
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Esecuzione ***
+-------------------------------------------------------------------------------------------------------------
+
+-- calcolo tempo esecuzione
+TIMER:start()
+EgtOutLog( ' Execution timer started')
+
+-- script principale
+
+if not MyProcessInputData() then return end
+
+-- recupero parametri generali da progetto
+BeamExec.GetGeneralParameters()
+
+-- creo un gruppo temporaneo dove finiranno tutte le entità che non bisogna salvare, alla fine lo si cancella
+BeamLib.CreateTempGroup()
+
+if not MyProcessBeams() then return end
+
+if not GetDataConfig() then return end
+
+-- Abilito Vmill
+EgtSetInfo( EgtGetCurrMachGroup(), 'Vm', '1')
+
+MyProcessFeatures()
+
+-- log tempi di esecuzione
+if EgtGetDebugLevel() >= 3 then
+   TIMER:logAllElapsed()
+end
+

LuaLibs/BeamLib.lua

@@ -328,6 +328,18 @@ function BeamLib.RotateRawPart( Part, nNumberOfRotations)
    end
 end
 
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.CreateAddGroup( PartId, sGroupName)
+   AddGrpId = EgtGroup( PartId or GDB_ID.NULL)
+   if not AddGrpId then
+      return false
+   end
+   -- assegno nome, flag di layer per gruppo di lavoro e colore
+   EgtSetName( AddGrpId, sGroupName)
+   EgtSetInfo( AddGrpId, GDB_SI.MGRPONLY, EgtGetCurrMachGroup())
+   EgtSetColor( AddGrpId, Color3d( 80, 160, 160, 25))
+end
+
 -------------------------------------------------------------------------------------------------------------
 function BeamLib.CreateOrEmptyAddGroup( PartId)
    -- recupero i dati del gruppo aggiuntivo
@@ -341,15 +353,9 @@ function BeamLib.CreateOrEmptyAddGroup( PartId)
       EgtSetInfo( AddGrpId, GDB_SI.MGRPONLY, EgtGetCurrMachGroup())
       return EgtEmptyGroup( AddGrpId)
    end
+
    -- altrimenti lo creo
-   AddGrpId = EgtGroup( PartId or GDB_ID.NULL)
-   if not AddGrpId then
-      return false
-   end
-   -- assegno nome, flag di layer per gruppo di lavoro e colore
-   EgtSetName( AddGrpId, sMchGrp)
-   EgtSetInfo( AddGrpId, GDB_SI.MGRPONLY, EgtGetCurrMachGroup())
-   EgtSetColor( AddGrpId, Color3d( 80, 160, 160, 25))
+   BeamLib.CreateAddGroup( PartId, sMchGrp)
 
    return true
 end
@@ -769,6 +775,11 @@ function BeamLib.GetBlockedAxis( nToolIndex, sBlockedAxis, b3Raw, vtTool, vtOut)
    return ''
 end
 
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.StringReplaceChar( sOriginal, nPosition, sChar)
+    return sOriginal:sub( 1, nPosition-1) .. sChar .. sOriginal:sub( nPosition+1)
+end
+
 -------------------------------------------------------------------------------------------------------------
 function BeamLib.BinaryToDecimal( dNumber)
    local sNumberToConvert = tostring( dNumber)

LuaLibs/FeatureLib.lua

@@ -926,8 +926,9 @@ end
 -- funzione che verifica se la feature, lavorata in questa fase, compromette lettura misura laser
 function FeatureLib.CalculateFeatureHindersLaserMeasure( Proc, Part)
    local bFeatureHindersLaserMeasure = false
-   -- se la feature è aperta frontalmente, posteriormente e di testa, allora potrebbe impattare sulla misura laser, controllo caso per caso
-   if Proc.AffectedFaces.bRight and Proc.AffectedFaces.bFront and Proc.AffectedFaces.bBack then
+   -- se la feature è aperta frontalmente, posteriormente, di testa e più bassa di 40mm, allora potrebbe impattare sulla misura laser, controllo caso per caso
+   if Proc.AffectedFaces.bRight and Proc.AffectedFaces.bFront and Proc.AffectedFaces.bBack and
+      ( Proc.b3Box:getMin():getZ() - Part.b3Raw:getMin():getZ()) < 40 then
       bFeatureHindersLaserMeasure = true
    end
    return bFeatureHindersLaserMeasure
@@ -963,13 +964,13 @@ function FeatureLib.CalculateFeatureNotClampableLengths( Proc, Part)
       -- condizioni per limitare pinzaggio testa/coda
       local bUpdateIng = true
       -- se dimensione del box della feature maggiore di metà pinzaggio minimo o metà spessore pezzo
-      bUpdateIng = bUpdateIng and Proc.b3Box:getDimZ() > dMinHIng
+      -- bUpdateIng = bUpdateIng and Proc.b3Box:getDimZ() > dMinHIng
       -- se la feature si trova più in basso del minimo pinzabile in Z o il 35% dello spessore pezzo
       bUpdateIng = bUpdateIng and Proc.b3Box:getMin():getZ() < Part.b3Raw:getMin():getZ() + dMinZ
       -- se feature è al di sotto del pinzaggio massimo
       bUpdateIng = bUpdateIng and Proc.b3Box:getMin():getZ() < dMaxHZ
-      -- se ho le morse verticali, o se la feature è in centro o verso alto, controllo se non prendo abbastanza.
-      if bIsVertClamps or ( Proc.b3Box:getMin():getZ() - Part.b3Raw:getMin():getZ()) > BeamData.MIN_HEIGHT  then
+      -- se ho le morse verticali, o se la feature è in centro o verso alto, controllo se non prendo abbastanza
+      if bIsVertClamps or ( Proc.b3Box:getMin():getZ() - Part.b3Raw:getMin():getZ()) > BeamData.MIN_HEIGHT then
          bUpdateIng = bUpdateIng and dDeltaZClamp < BeamData.VICE_MINH
       end
 
@@ -981,24 +982,14 @@ function FeatureLib.CalculateFeatureNotClampableLengths( Proc, Part)
                dOffs = min( dOffs, BeamData.VICE_MAXH - BeamData.VICE_MINH)
             end
             dNotClampableLengthHead = dOffs
-         elseif Proc.AffectedFaces.bLeft then
+         end
+         if Proc.AffectedFaces.bLeft then
             local dOffs = Proc.b3Box:getMax():getX() - Part.b3Part:getMin():getX()
             -- se pinze a 45° e pinza abbastanza materiale, compenso comunque, ma solo inclinazione morse
             if not bIsVertClamps and dDeltaZClamp > BeamData.VICE_MINH and BeamData.VICE_MAXH then
                dOffs = min( dOffs, BeamData.VICE_MAXH - BeamData.VICE_MINH)
             end
             dNotClampableLengthTail = dOffs
-      -- TODO il controllo sul punto centrale non è corretto, deve essere rivisto.
-      --      Si lascia qui commentato perchè era così anche in quello vecchio, quindi potrebbe essere che in qualche caso potesse funzionare
-      --   elseif Proc.b3Box:getCenter():getX() > Part.b3Part:getCenter():getX() then
-      --      local dOffs = Part.b3Part:getMax():getX() - Proc.b3Box:getMin():getX()
-      --      local dDist = Part.b3Part:getMax():getX() - Proc.b3Box:getMax():getX()
-      --      -- se pinze a 45° e pinza abbastanza materiale, compenso comunque, ma solo inclinazione morse
-      --      if not bIsVertClamps and dDeltaZClamp > BeamData.VICE_MINH and BeamData.VICE_MAXH then
-      --         dOffs = min( dOffs, BeamData.VICE_MAXH - BeamData.VICE_MINH)
-      --      end
-      --      -- dDist serve??
-      --      dNotClampableLengthHead = dOffs
          end
       end
    end

LuaLibs/Logs.lua

@@ -5,7 +5,7 @@
 local Logs = {}
 
 -------------------------------------------------------------------------------------------------------------
-function Logs.WriteFeaturesLog( ProcessingsOnPart, PartInfo)
+function Logs.WriteFeaturesLog( ProcessingsOnPart, PartInfo, nReProcessCycles)
 
    local nCycles = 1
    local nOffsetIndex = 0
@@ -13,15 +13,13 @@ function Logs.WriteFeaturesLog( ProcessingsOnPart, PartInfo)
       nCycles = 2
    end
 
+   EgtOutLog( ' === === === === === === === === === === REPROCESS CYCLES ' .. EgtNumToString( nReProcessCycles) .. ' === === === === === === === === === === === ===')
+   EgtOutLog( ' === === === === === === === === === === FEATURES STRATEGIES === === === === === === === === === === === ===')
    for nCycle = 1, nCycles do
       local nStartIndex = 1 + nOffsetIndex
       local nEndIndex = 4 + nOffsetIndex
-      if nCycle == 1 then
-         EgtOutLog( ' === === === === === === === === === === FEATURES STRATEGIES === === === === === === === === === === === ===')
-      else
-         EgtOutLog( ' === === === === === === === === === === === === === === === === === === === === === === === === === === ===')
-         EgtOutLog( ' === === === === === === === === FEATURES STRATEGIES  PIECE INVERTED === === === === === === === === === ===')
-      end
+      EgtOutLog( ' === === === === === === === === === === === === === === === === === === === === === === === === === === ===')
+      EgtOutLog( ' === === === === === === === === FEATURES STRATEGIES  PIECE INVERTED === === === === === === === === === ===')
       EgtOutLog( '  Feature ID         |             BTL POSITION             |             90 ROTATION              |             180 ROTATION             |             270 ROTATION             |')
       EgtOutLog( '----------------------------------------------------------------------------------------------------------')
 
@@ -74,7 +72,11 @@ function Logs.WriteFeaturesLog( ProcessingsOnPart, PartInfo)
                            ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].Result.sStatus == 'Not-Applicable' then
                            sStatusStrategy = 'N'
                            sRating = '----'
-                           sIndexes = ' (C:---|Q:---|T:---)'
+                           if EgtStartsWith( ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].Result.sInfo, 'REJECTED') then
+                              sIndexes = ' ( --- REJECTED ---)'
+                           else
+                              sIndexes = ' (C:---|Q:---|T:---)'
+                           end
                         else
                            if ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].Result.sStatus == 'Completed' then
                               sStatusStrategy = 'C'
@@ -88,7 +90,7 @@ function Logs.WriteFeaturesLog( ProcessingsOnPart, PartInfo)
                         end
                         -- se c'è una chosen strategy, si aggiunge prefisso '*' per indicare nel log qual è la strategia che è stata scelta 
                         local nIndexBestStrategy = ProcessingsOnPart.Rotation[nRotLog][ProcLog].nIndexBestStrategy or 0
-                        local sLogLineProc = EgtIf( nIndexBestStrategy == nCountStrategies, '*', '') .. sRating .. sIndexes .. ' (' .. 
+                        local sLogLineProc = EgtIf( nIndexBestStrategy == nCountStrategies, '*', '') .. sRating .. sIndexes .. ' (' ..
                                              tostring( ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].sStrategyId) .. ')' .. 
                                              sStatusStrategy .. ' |'
                         while string.len( sLogLineProc) <= 38 do

LuaLibs/MachiningLib.lua

@@ -1141,13 +1141,29 @@ function MachiningLib.AddMachinings( Proc, Machining, AuxiliaryData)
    return bMachiningAdded
 end
 
+
+-------------------------------------------------------------------------------------------------------------
+-- funzione che verifica se ha senso riprocessare tutto dall'inizio,
+--    perchè ci sono buone probabilità che l'errore trovato in fase di applicazione si possa risolvere (escludendo la lavorazione scelta in precedenza)
+local function IsReProcessWorthIt( nError)
+   local bReProcess = false
+
+   -- errori di Extra-corsa
+   if nError == 2110 or nError == 2216 or nError == 2318 or nError == 2424 or nError == 2508 then
+      bReProcess = true
+   end
+
+   return bReProcess
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- funzione per aggiungere una nuova lavorazione
-function MachiningLib.AddOperations( vProc, Part, sRotation)
+function MachiningLib.AddOperations( MACHININGS, Part, sRotation)
    local nErr
    local sErr = ''
    local bAreAllMachiningApplyOk = true
    local bSplitExecuted = false
+   local bTryToReProcess = false
 
    -- parametri generali lavorazione
    local MachiningParameters = {
@@ -1345,6 +1361,15 @@ function MachiningLib.AddOperations( vProc, Part, sRotation)
                   bAreAllMachiningApplyOk = false
                   nErr, sErr = EgtGetLastMachMgrError()
                   EgtSetOperationMode( nOperationId, false)
+                  local CurrProc = PROCESSINGS[MACHININGS[i].Proc.nIndexPartInParts].Rotation[MACHININGS[i].Proc.nIndexRotation][MACHININGS[i].Proc.nIndexInVProc]
+                  -- si annulla la feature scelta, in modo che un successivo ricalcolo non la tenga in considerazione
+                  CurrProc.AvailableStrategies[CurrProc.nIndexBestStrategy].Result.sStatus = 'Not-Applicable'
+                  CurrProc.AvailableStrategies[CurrProc.nIndexBestStrategy].Result.sInfo = 'REJECTED (' .. sErr .. ')'
+                  CurrProc.ChosenStrategy= nil
+                  -- si verifica se vale la pena riprocessare tutto (perchè si pensa possa risolvere il problema)
+                  if IsReProcessWorthIt( nErr) then
+                     bTryToReProcess = true
+                  end
                   -- update risultati
                   -- TODO è corretto mettere non applicabile????? disattivare e dare un'incompleta gialla?
                   RESULT[MACHININGS[i].Proc.nIndexInResult].ChosenStrategy.sStatus = 'Not-Applicable'
@@ -1395,9 +1420,9 @@ function MachiningLib.AddOperations( vProc, Part, sRotation)
                   bSplitExecuted = true
                   MACHININGS.Info.bSplitExecuted = true
 
-                  BeamLib.AddPhaseWithRawParts( MACHININGS[i].Proc.idRaw, BeamData.ptOriXR, BeamData.dPosXR, BeamData.RAW_OFFSET)
+                  BeamLib.AddPhaseWithRawParts( Part.idRaw, BeamData.ptOriXR, BeamData.dPosXR, BeamData.RAW_OFFSET)
                   -- se grezzo successivo senza pezzi e finale, va tolto
-                  local nNextRawId = EgtGetNextRawPart( MACHININGS[i].Proc.idRaw)
+                  local nNextRawId = EgtGetNextRawPart( Part.idRaw)
                   if nNextRawId  and  EgtGetPartInRawPartCount( nNextRawId) == 0  and  EgtGetRawPartBBox( nNextRawId):getDimX() < BeamData.dMinRaw then
                      EgtRemoveRawPartFromCurrPhase( nNextRawId)
                   end
@@ -1429,7 +1454,7 @@ function MachiningLib.AddOperations( vProc, Part, sRotation)
                   EgtSetInfo( idDisp, 'ORD', MACHININGS[i].Proc.nIndexPartInParts)
                end
             else
-               return false, 'UNEXPECTED ERROR: Error on creating machining', bSplitExecuted
+               return false, 'UNEXPECTED ERROR: Error on creating machining', bSplitExecuted, false
             end
          end
       end
@@ -1446,13 +1471,13 @@ function MachiningLib.AddOperations( vProc, Part, sRotation)
       EgtSetInfo( idDisp, 'TCING', Part.NotClampableLength[sRotation].dTail or 0)
    end
 
-   return bAreAllMachiningApplyOk, sErr, bSplitExecuted
+   return bAreAllMachiningApplyOk, sErr, bSplitExecuted, bTryToReProcess
 end
 
 -------------------------------------------------------------------------------------------------------------
 function MachiningLib.ApplyMachining( bRecalc, bApplyPost)
    local bResult = EgtApplyMachining( bRecalc, bApplyPost)
-   
+
    return bResult
 end
 

LuaLibs/PreSimulationLib.lua

@@ -232,7 +232,6 @@ end
 -- check extracorsa da punti sul tip dell'utensile
 function PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool)
 
-   -- check collisione sui punti in centro lama su naso mandrino o aggregato. In base a direzione e punto
    for i = 1, #PointsOnToolTipCenter do
 
       local bOutOfStroke = CheckOutOfStrokePoint( PointsOnToolTipCenter[i], vtHead, nSCC, Tool)

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')
@@ -15,9 +15,6 @@ EgtAddToPackagePath( BEAM.BASEDIR .. '\\LuaLibs\\?.lua')
 EgtAddToPackagePath( BEAM.BASEDIR .. '\\Strategies\\Standard\\?.lua')
 EgtAddToPackagePath( BEAM.BASEDIR .. '\\StrategyLibs\\?.lua')
 
--- TODO forzatura calcolo con prerotazioni. Cancellare dopo che è stata aggiunta la gestione corretta
-local bCalcBestPieceUnloadPosition = true
-
 -- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
 local sMachDir = EgtGetCurrMachineDir()
 if not sMachDir then
@@ -290,7 +287,7 @@ local function MyProcessBeams()
    end
 
    -- Sistemo le travi nel grezzo
-   local bOk, sErr = BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS, nil, bCalcBestPieceUnloadPosition)
+   local bOk, sErr = BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS, nil, false)
    if not bOk then
       EgtOutLog( sErr)
       EgtOutBox( sErr, 'Lavora Travi', 'ERROR')
@@ -305,8 +302,8 @@ end
 -------------------------------------------------------------------------------------------------------------
 local function MyProcessFeatures()
 
-   BeamExec.GetProcessings( PARTS, bCalcBestPieceUnloadPosition)
-   BeamExec.GetCombinationMatrix( PARTS, bCalcBestPieceUnloadPosition)
+   BeamExec.GetProcessings( PARTS, false)
+   BeamExec.GetCombinationMatrix( PARTS, false)
    BeamExec.ProcessMachinings( PARTS)
    local nErrCnt = 0
    local nWarnCnt = 0

Strategies/GeneralParameters.json

@@ -1,10 +1,10 @@
 
 [
    {
-      "nGroup": "MACHINE",
+      "nGroup": "PIECE LOADING",
       "sName": "GEN_sPiecesLoadingPosition",
       "sNameNge": "GEN_PIECES_LOADING",
-      "sValue": "BEST_POSITION",
+      "sValue": "BTL_POSITION",
       "sDescriptionShort": "Part loading position",
       "sDescriptionLong": "",
       "sType": "combo",
@@ -12,24 +12,57 @@
       "Choices": [
          {
             "sValue": "BTL_POSITION",
-            "sDescriptionShort": "Last piece position as BTL",
+            "sDescriptionShort": "Loading position from BTL, no pre-rotation",
             "sDescriptionLong": "",
             "sMessageId": ""
          },
          {
-            "sValue": "BEST_ROTATION",
-            "sDescriptionShort": "Allow piece rotations",
+            "sValue": "STD_PRE_ROTATION",
+            "sDescriptionShort": "Get Best loading position from 0° and 180°",
             "sDescriptionLong": "",
             "sMessageId": ""
          },
          {
-            "sValue": "BEST_POSITION",
-            "sDescriptionShort": "Allow piece rotation and inversion",
+            "sValue": "FULL_PRE_ROTATION",
+            "sDescriptionShort": "Get Best loading position in each piece rotation",
             "sDescriptionLong": "",
             "sMessageId": ""
          }
       ]
    },
+   {
+      "nGroup": "PIECE LOADING",
+      "sName": "GEN_bAllowPieceInversion",
+      "sNameNge": "ADMIT_INVERSION",
+      "sValue": "false",
+      "sDescriptionShort": "Allow piece inversion",
+      "sDescriptionLong": "",
+      "sType": "b",
+      "sMessageId": " ",
+      "sMinUserLevel": "1"
+   },
+   {
+      "nGroup": "PIECE LOADING",
+      "sName": "GEN_bTestAlternative",
+      "sNameNge": "TEST_ALTERNATIVE",
+      "sValue": "false",
+      "sDescriptionShort": "Enable the possibility to load the piece 90° turned",
+      "sDescriptionLong": "",
+      "sType": "b",
+      "sMessageId": " ",
+      "sMinUserLevel": "1"
+   },
+   {
+      "nGroup": "PIECE LOADING",
+      "sName": "GEN_bGetAlternativesNesting2D",
+      "sNameNge": "GET_ALTERNATIVES_NEST2D",
+      "sValue": "false",
+      "sDescriptionShort": "Enable material optimization function in nesting",
+      "sDescriptionLong": "",
+      "sType": "b",
+      "sMessageId": " ",
+      "sMinUserLevel": "1"
+   },
    {
       "nGroup": "MACHINE",
       "sName": "GEN_sPieceRotation",
@@ -90,6 +123,17 @@
          }
       ]
    },
+   {
+      "nGroup": "MACHINING STRATEGY",
+      "sName": "GEN_nMaxReProcessCycles",
+      "sNameNge": "MAX_REPROCESS_CYCLES",
+      "sValue": "1",
+      "sDescriptionShort": "Max number of reprocessing cycles",
+      "sDescriptionLong": "",
+      "sType": "d",
+      "sMessageId": " ",
+      "sMinUserLevel": "10"
+   },
    {
       "nGroup": "MACHINING STRATEGY",
       "sName": "GEN_bReduceBladePath",

Strategies/Standard/STR0008/STR0008.lua

@@ -174,13 +174,13 @@ local function GetBestPocketingStrategy( Proc, Part)
       Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining.Pocketing[2].ToolInfo)
       Machining.Pocketing[1].bIsApplicable = false
    -- solo svuotatura diretta come normale mortasa, incompleta
-   elseif not Machining.Pocketing[2].bIsApplicable then
+   elseif Machining.Pocketing[1].bIsApplicable and not Machining.Pocketing[2].bIsApplicable then
       Machining.sTypeMachining = 'Side1'
       Machining.dResidual = Machining.Pocketing[1].ToolInfo.dResidualDepth
       Machining.Pocketing[1].sDepth = -Machining.dResidual
       Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining.Pocketing[1].ToolInfo)
    -- solo svuotatura diretta come normale mortasa, incompleta
-   elseif not Machining.Pocketing[1].bIsApplicable then
+   elseif Machining.Pocketing[2].bIsApplicable and not Machining.Pocketing[1].bIsApplicable then
       Machining.sTypeMachining = 'Side2'
       Machining.dResidual = Machining.Pocketing[2].ToolInfo.dResidualDepth
       Machining.Pocketing[2].sDepth = Proc.FeatureInfo.dMortiseDepth - Machining.dResidual