andrea.villa
397 lines
15 KiB
Lua
397 lines
15 KiB
Lua
-- 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')
|
|
|
|
-- Variabili di modulo
|
|
local dRawW
|
|
local dRawH
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- *** Recupero le travi selezionate ***
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function MyProcessInputData()
|
|
|
|
-- Recupero le travi selezionate
|
|
local nId = EgtGetFirstSelectedObj()
|
|
while nId do
|
|
local nPartId = EgtGetParent( EgtGetParent( nId or GDB_ID.NULL) or GDB_ID.NULL)
|
|
if nPartId then
|
|
local bFound = false
|
|
for i = 1, #PARTS do
|
|
if PARTS[i].id == nPartId then
|
|
bFound = true
|
|
break
|
|
end
|
|
end
|
|
if not bFound then
|
|
table.insert( PARTS, { nInd = #PARTS + 1, id = nPartId, sName = ( EgtGetName( nPartId) or ( 'Id=' .. tonumber( nPartId)))})
|
|
end
|
|
end
|
|
nId = EgtGetNextSelectedObj()
|
|
end
|
|
if #PARTS == 0 then
|
|
EgtOutBox( 'Non sono state selezionate travi', 'Lavora Travi', 'ERROR')
|
|
return false
|
|
else
|
|
local sOut = ''
|
|
for i = 1, #PARTS do
|
|
sOut = sOut .. PARTS[i].sName .. ', '
|
|
end
|
|
sOut = sOut:sub( 1, -3)
|
|
EgtOutLog( 'Travi selezionate : ' .. sOut, 1)
|
|
end
|
|
|
|
-- Ne recupero e verifico le dimensioni
|
|
for i = 1, #PARTS do
|
|
local Ls = EgtGetFirstNameInGroup( PARTS[i].id, 'Box')
|
|
local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
|
|
if not b3Solid then
|
|
EgtOutBox( 'Box non definito per la trave ' .. PARTS[i].sName, 'Lavora Travi', 'ERROR')
|
|
return false
|
|
else
|
|
PARTS[i].b3PartOriginal = b3Solid
|
|
end
|
|
end
|
|
dRawW = PARTS[1].b3PartOriginal:getDimY()
|
|
dRawH = PARTS[1].b3PartOriginal:getDimZ()
|
|
local vBeamErr = {}
|
|
for i = 2, #PARTS do
|
|
local dDimW = PARTS[i].b3PartOriginal:getDimY()
|
|
local dDimH = PARTS[i].b3PartOriginal:getDimZ()
|
|
if ( abs( dDimW - dRawW) > 10 * GEO.EPS_SMALL or abs( dDimH - dRawH) > 10 * GEO.EPS_SMALL) and
|
|
( abs( dDimH - dRawW) > 10 * GEO.EPS_SMALL or abs( dDimW - dRawH) > 10 * GEO.EPS_SMALL) then
|
|
table.insert( vBeamErr, i)
|
|
end
|
|
end
|
|
if #vBeamErr > 0 then
|
|
local sOut = 'Rimosse travi con sezioni diverse dalla prima :\n'
|
|
for i = #vBeamErr, 1, -1 do
|
|
sOut = sOut .. PARTS[vBeamErr[i]].sName .. '\n'
|
|
EgtDeselectPartObjs( PARTS[vBeamErr[i]].id)
|
|
table.remove( PARTS, vBeamErr[i])
|
|
end
|
|
EgtOutLog( sOut, 1)
|
|
EgtOutBox( sOut, 'Lavora Travi', 'INFO')
|
|
EgtDraw()
|
|
return false
|
|
end
|
|
EgtDeselectAll()
|
|
|
|
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()
|
|
-- Determinazione minimo grezzo scaricabile
|
|
BeamExec.CalcMinUnloadableRaw( dRawW, dRawH)
|
|
|
|
-- Lunghezza totale delle travi
|
|
local dTotLen = 0
|
|
for i = 1, #PARTS - 1 do
|
|
dTotLen = dTotLen + PARTS[i].b3PartOriginal:getDimX()
|
|
end
|
|
dTotLen = dTotLen + max( PARTS[#PARTS].b3PartOriginal:getDimX(), BeamData.dMinRaw)
|
|
local dAddLen = BeamData.OVM_HEAD + ( #PARTS - 1) * BeamData.OVM_MID
|
|
EgtOutLog( 'Ltot : '..EgtNumToString( dTotLen, 1) .. ' Lagg : '..EgtNumToString( dAddLen, 1)..' MinUnloadRaw : '.. EgtNumToString( BeamData.dMinRaw + BeamData.OVM_MID, 1), 1)
|
|
|
|
-- Richiedo lunghezza del grezzo, sovramateriale di testa, forzatura verticale e ordinamento automatico secondo la lunghezza
|
|
local vsVal = EgtDialogBox( 'Lavora Travi' .. ' (Ltot='..EgtNumToString( dTotLen + dAddLen + 0.5, 0)..
|
|
', Lmax='..EgtNumToString( BeamData.MAX_RAW, 0)..',MinUlr='..EgtNumToString( BeamData.dMinRaw + BeamData.OVM_MID, 0)..')',
|
|
--{'Lunghezza grezzo', EgtNumToString( BeamData.STD_RAW, 0)}, -- TODO RIPRISTINARE
|
|
{'Lunghezza grezzo', EgtNumToString( 0)},
|
|
{'Sovramateriale di testa', EgtNumToString( BeamData.OVM_HEAD, 0)},
|
|
{'Offset intermedio', EgtNumToString( BeamData.OVM_MID, 0)},
|
|
{'Forza sezione verticale', ' CB:true,*false'},
|
|
{'Ordina per lunghezza', ' CB:true,*false'},
|
|
{'Calcolo Lavorazioni', ' CB:*Da progetto,Ricalcolo standard,Ricalcolo IA'})
|
|
if not vsVal then
|
|
EgtDraw()
|
|
return
|
|
end
|
|
local dRawL = EgtEvalNumExpr( vsVal[1])
|
|
if not dRawL then
|
|
local sOut = 'Lunghezza grezzo errata : ' .. vsVal[1]
|
|
EgtOutLog( sOut)
|
|
EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
|
|
EgtDraw()
|
|
return false
|
|
end
|
|
if dRawL < GEO.EPS_SMALL then dRawL = dTotLen + dAddLen + 0.5 end
|
|
dRawL = min( dRawL, BeamData.MAX_RAW)
|
|
local dOvmHead = EgtEvalNumExpr( vsVal[2])
|
|
if not dOvmHead then
|
|
local sOut = 'Sovramateriale di testa errato : ' .. vsVal[2]
|
|
EgtOutLog( sOut)
|
|
EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
|
|
EgtDraw()
|
|
return false
|
|
end
|
|
local dOvmMid = EgtEvalNumExpr( vsVal[3])
|
|
if not dOvmMid then
|
|
local sOut = 'Offset intermedio : ' .. vsVal[3]
|
|
EgtOutLog( sOut)
|
|
EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
|
|
EgtDraw()
|
|
return false
|
|
end
|
|
|
|
-- Sistemo sezione barra con travi
|
|
local bVert = ( vsVal[4] == 'true')
|
|
if bVert then
|
|
if dRawW > dRawH then dRawW, dRawH = dRawH, dRawW end
|
|
end
|
|
EgtOutLog( 'Lraw : ' .. EgtNumToString( dRawL, 1) .. ' Lovm : '.. EgtNumToString( dOvmHead, 1), 1)
|
|
|
|
-- Verifico sezione barra non troppo grande
|
|
if not BeamData.MAX_WIDTH2 or not BeamData.MAX_HEIGHT2 then
|
|
if ( dRawW > BeamData.MAX_WIDTH + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT + 10 * GEO.EPS_SMALL) then
|
|
local sOut = 'Sezione (' .. EgtNumToString( dRawW, 2) .. ' x ' .. EgtNumToString( dRawH, 2) .. ') ' ..
|
|
'oltre i limiti della macchina (' .. EgtNumToString( BeamData.MAX_WIDTH, 2) .. ' x ' .. EgtNumToString( BeamData.MAX_HEIGHT, 2) .. ') '
|
|
EgtOutLog( sOut)
|
|
EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
|
|
EgtDraw()
|
|
return false
|
|
end
|
|
else
|
|
if ( dRawW > BeamData.MAX_WIDTH + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT + 10 * GEO.EPS_SMALL) and
|
|
( dRawW > BeamData.MAX_WIDTH2 + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT2 + 10 * GEO.EPS_SMALL) then
|
|
local sOut = 'Sezione (' .. EgtNumToString( dRawW, 2) .. ' x ' .. EgtNumToString( dRawH, 2) .. ') ' ..
|
|
'oltre i limiti della macchina (' .. EgtNumToString( BeamData.MAX_WIDTH, 2) .. ' x ' .. EgtNumToString( BeamData.MAX_HEIGHT, 2) .. ') ' ..
|
|
'e (' .. EgtNumToString( BeamData.MAX_WIDTH2, 2) .. ' x ' .. EgtNumToString( BeamData.MAX_HEIGHT2, 2) .. ')'
|
|
EgtOutLog( sOut)
|
|
EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
|
|
EgtDraw()
|
|
return false
|
|
end
|
|
end
|
|
|
|
-- Verifico sezione barra non troppo piccola
|
|
if dRawW < BeamData.MIN_WIDTH - 10 * GEO.EPS_SMALL or dRawH < BeamData.MIN_HEIGHT - 10 * GEO.EPS_SMALL then
|
|
local sOut = 'Sezione (' .. EgtNumToString( dRawW, 2) .. ' x ' .. EgtNumToString( dRawH, 2) .. ') ' ..
|
|
'sotto i limiti della macchina (' .. EgtNumToString( BeamData.MIN_WIDTH, 2) .. ' x ' .. EgtNumToString( BeamData.MIN_HEIGHT, 2) .. ')'
|
|
EgtOutLog( sOut)
|
|
EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
|
|
EgtDraw()
|
|
return false
|
|
end
|
|
|
|
-- Se richiesto, ordino le travi in senso di lunghezza crescente
|
|
local bOrd = ( vsVal[5] == 'true')
|
|
if bOrd then
|
|
table.sort( PARTS, function( B1, B2)
|
|
if abs( B1.b3PartOriginal:getDimX() - B2.b3PartOriginal:getDimX()) < 1 then
|
|
return B1.nInd < B2.nInd
|
|
else
|
|
return B1.b3PartOriginal:getDimX() < B2.b3PartOriginal:getDimX()
|
|
end
|
|
end)
|
|
end
|
|
do
|
|
local sOut = ''
|
|
for i = 1, #PARTS do
|
|
sOut = sOut .. PARTS[i].sName .. ', '
|
|
end
|
|
sOut = sOut:sub( 1, -3)
|
|
EgtOutLog( 'Travi ordinate : ' .. sOut, 1)
|
|
end
|
|
|
|
-- Sistemo le travi nel grezzo
|
|
local bOk, sErr = BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS, nil, false)
|
|
if not bOk then
|
|
EgtOutLog( sErr)
|
|
EgtOutBox( sErr, 'Lavora Travi', 'ERROR')
|
|
return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- *** Inserimento delle lavorazioni nelle travi ***
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function MyProcessFeatures()
|
|
|
|
BeamExec.GetProcessings( PARTS, false)
|
|
BeamExec.GetCombinationMatrix( PARTS, false)
|
|
BeamExec.ProcessMachinings( PARTS, false)
|
|
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
|
|
|
|
-- 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
|
|
|