diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index bbae76a..27b80a4 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -31,6 +31,7 @@ EgtMdbSave() TOOLS = {} -- tabella contenente tutti gli utensili STRATEGIES = nil -- tabella contenente le strategie disponibili per ogni feature MACHININGS = {} -- tabella contenente le lavorazioni da applicare +MACHININGS.Info = {} PROCESSINGS = {} -- tabella contenente tutte le informazioni di ogni feature, processate per ogni rotazione ------------------------------------------------------------------------------------------------------------- @@ -995,6 +996,10 @@ local function CalculateMachinings( vProc, Part) BeamLib.RotatePart( Part, 1 - CurrRotation) CurrRotation = 1 end + -- aggiorno info pezzo + Part.b3Raw = EgtGetRawPartBBox( Part.idRaw) + Part.b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( Part.id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD) + -- si applicano le strategie if Proc.nFlg ~= 0 and Proc.ChosenStrategy then -- carico file script strategia (non serve verificare presenza del file perchè già fatto durante scelta strategia) @@ -1005,6 +1010,11 @@ local function CalculateMachinings( vProc, Part) end end + -- ripristino pezzo in posizione originale + if CurrRotation ~= 1 then + BeamLib.RotatePart( Part, 1 - CurrRotation) + CurrRotation = 1 + end return MACHININGS end @@ -1114,13 +1124,18 @@ end -- funzione che decide le combinazioni di rotazione per lavorare la trave local function GetProcessingListFromCombination( BestCombination) local vProc = {} - local bSomeFeatureDown = false - local bSomeFeatureSide = false - local nInitialPosition = BestCombination.nIndexRotation + local ProcessingResult = {} + ProcessingResult.bSomeFeatureDown = false + ProcessingResult.bSomeFeatureSide = false + ProcessingResult.nInitialPosition = BestCombination.nIndexRotation + ProcessingResult.nIndexInCombinationList = BestCombination.nIndexInCombinationList + ProcessingResult.nIndexHeadCutInVProc = BestCombination.nIndexHeadCutInVProc + ProcessingResult.nIndexTailCutInVProc = BestCombination.nIndexTailCutInVProc + -- aggiungo processing da fare in fase ribaltata if #BestCombination.Rot180 > 0 then - bSomeFeatureDown = true + ProcessingResult.bSomeFeatureDown = true for i = 1, #BestCombination.Rot180 do BestCombination.Rot180[i].bDown = true table.insert( vProc, BestCombination.Rot180[i]) @@ -1129,7 +1144,7 @@ local function GetProcessingListFromCombination( BestCombination) -- aggiungo processing da fare in fase ruotata if #BestCombination.Rot90 > 0 then - bSomeFeatureSide = true + ProcessingResult.bSomeFeatureSide = true for i = 1, #BestCombination.Rot90 do BestCombination.Rot90[i].bSide = true table.insert( vProc, BestCombination.Rot90[i]) @@ -1143,7 +1158,7 @@ local function GetProcessingListFromCombination( BestCombination) end end - return vProc, nInitialPosition, bSomeFeatureDown, bSomeFeatureSide + return vProc, ProcessingResult end ------------------------------------------------------------------------------------------------------------- @@ -1183,6 +1198,7 @@ end local function GetBestResultFromCombinationsMatrix( ProcessingsOnPart, PartInfo) local BestCombination = {} local CombinationsList = {} + local HeadTailProc = {} -- scrittura nel log della matrice delle rotazioni if EgtGetDebugLevel() >= 3 then @@ -1209,46 +1225,56 @@ local function GetBestResultFromCombinationsMatrix( ProcessingsOnPart, PartInfo) SingleCombination.Rot90 = {} SingleCombination.Rot180 = {} - -- ciclo su tutte le feature + -- ciclo su tutte le feature, ad eccezione dei tagli testa/coda che dipendono dal risultato delle altre + -- tagli testa e coda vengono aggiunti sempre alla fine for nProc = 1, #ProcessingsOnPart.Rotation[1] do - -- ciclo sulle rotazioni - local nNextRot = nUnloadPos - local ResultsList = {} - for nRotation = 1, 3 do - -- se rotazione abilitata da combinazione - if string.sub( PartInfo.CombinationList[i].sBitIndexCombination, nNextRot, nNextRot) == '1' then - -- controllo se è stata scelta una strategia - if ProcessingsOnPart.Rotation[nNextRot][nProc].ChosenStrategy then - local Proc = {} - Proc.nRotation = nNextRot - table.insert( Proc, ProcessingsOnPart.Rotation[nNextRot][nProc]) - table.insert( ResultsList, Proc) + if ProcessingsOnPart.Rotation[1][nProc].nPrc ~= 340 and ProcessingsOnPart.Rotation[1][nProc].nPrc ~= 350 then + -- ciclo sulle rotazioni + local nNextRot = nUnloadPos + local ResultsList = {} + for nRotation = 1, 3 do + -- se rotazione abilitata da combinazione + if string.sub( PartInfo.CombinationList[i].sBitIndexCombination, nNextRot, nNextRot) == '1' then + -- controllo se è stata scelta una strategia + if ProcessingsOnPart.Rotation[nNextRot][nProc].ChosenStrategy then + local Proc = {} + Proc.nRotation = nNextRot + table.insert( Proc, ProcessingsOnPart.Rotation[nNextRot][nProc]) + table.insert( ResultsList, Proc) + end end + nNextRot = EgtIf( nNextRot + 1 > 4, nNextRot + 1 - 4, nNextRot + 1) end - nNextRot = EgtIf( nNextRot + 1 > 4, nNextRot + 1 - 4, nNextRot + 1) - end - -- se la feature può essere lavorata in almeno una rotazione - if #ResultsList > 0 then - local Proc, Data = GetProcBestMachRotationFromList( ResultsList) - -- inserisco la Proc nell'apposita lista - if Data.nIndexRotation == nUnloadPos then - table.insert( SingleCombination.Rot0, Proc) - elseif Data.nIndexRotation == nUnloadPos + 1 then - table.insert( SingleCombination.Rot90, Proc) - bRot90 = true + -- se la feature può essere lavorata in almeno una rotazione + if #ResultsList > 0 then + local Proc, Data = GetProcBestMachRotationFromList( ResultsList) + -- inserisco la Proc nell'apposita lista + if Data.nIndexRotation == nUnloadPos then + table.insert( SingleCombination.Rot0, Proc) + elseif Data.nIndexRotation == nUnloadPos + 1 then + table.insert( SingleCombination.Rot90, Proc) + bRot90 = true + else + table.insert( SingleCombination.Rot180, Proc) + bRot180 = true + end + + SingleCombination.dTotalRating = SingleCombination.dTotalRating + Data.dCompositeRating + SingleCombination.nComplete = SingleCombination.nComplete + EgtIf( Data.bComplete, 1, 0) + SingleCombination.nNotComplete = SingleCombination.nNotComplete + EgtIf( Data.bNotComplete, 1, 0) + SingleCombination.nNotExecute = SingleCombination.nNotExecute + EgtIf( Data.bNotApplicable, 1, 0) + SingleCombination.nIndexInCombinationList = i + SingleCombination.nIndexRotation = nUnloadPos else - table.insert( SingleCombination.Rot180, Proc) - bRot180 = true + SingleCombination.nNotExecute = SingleCombination.nNotExecute + 1 end - - SingleCombination.dTotalRating = SingleCombination.dTotalRating + Data.dCompositeRating - SingleCombination.nComplete = SingleCombination.nComplete + EgtIf( Data.bComplete, 1, 0) - SingleCombination.nNotComplete = SingleCombination.nNotComplete + EgtIf( Data.bNotComplete, 1, 0) - SingleCombination.nNotExecute = SingleCombination.nNotExecute + EgtIf( Data.bNotApplicable, 1, 0) - SingleCombination.nIndexRotation = nUnloadPos else - SingleCombination.nNotExecute = SingleCombination.nNotExecute + 1 + if ProcessingsOnPart.Rotation[1][nProc].nPrc == 340 then + SingleCombination.nIndexHeadCutInVProc = nProc + elseif ProcessingsOnPart.Rotation[1][nProc].nPrc == 350 then + SingleCombination.nIndexTailCutInVProc = nProc + end end end -- aggiungo rotazioni @@ -1270,9 +1296,9 @@ local function GetBestResultFromCombinationsMatrix( ProcessingsOnPart, PartInfo) Logs.WriteCombinationLog( CombinationsList, BestCombination) end - local vFinalProc, nInitialPosition, bSomeFeatureDown, bSomeFeatureSide = GetProcessingListFromCombination( BestCombination) + local vFinalProc, BestCombinationResult = GetProcessingListFromCombination( BestCombination) - return vFinalProc, nInitialPosition, bSomeFeatureDown, bSomeFeatureSide + return vFinalProc, BestCombinationResult end ------------------------------------------------------------------------------------------------------------- @@ -1327,23 +1353,57 @@ function BeamExec.ProcessMachinings( PARTS) Logs.WriteFeaturesLog( PROCESSINGS[nPart], PARTS[nPart]) end - -- si calcola la combinazione di lavorazione migliore - local vProc, nInitialPosition, bSomeFeatureDown, bSomeFeatureSide = GetBestResultFromCombinationsMatrix( PROCESSINGS[nPart], PARTS[nPart]) - -- salvo sul PART la posizione di partenza che è stata scelta - PARTS[nPart].nInitialPosition = nInitialPosition + local bIsCombinationMachinable = false + local vProc, MatrixResult + while not bIsCombinationMachinable do + -- si calcola la combinazione di lavorazione migliore + vProc, MatrixResult = GetBestResultFromCombinationsMatrix( PROCESSINGS[nPart], PARTS[nPart]) + -- salvo sul PART la posizione di partenza che è stata scelta + PARTS[nPart].nInitialPosition = MatrixResult.nInitialPosition - -- debug - if EgtGetDebugLevel() >= 1 then - PrintFeatures( vProc, PARTS[nPart]) + -- debug + if EgtGetDebugLevel() >= 1 then + PrintFeatures( vProc, PARTS[nPart]) + end + EgtOutLog( ' *** AddMachinings ***', 1) + + -- ordinamento di base delle feature + vProc = OrderFeatures( vProc) + + -- esegue le strategie migliori che ha precedentemente scelto e salva le lavorazioni nella lista globale + MACHININGS = CalculateMachinings( vProc, PARTS[nPart]) + + -- TODO applicare taglio testa e coda. DA COMPLETARE + -- aggiunge tagli testa e coda in fasi opportune + local nRotHeadCut = MatrixResult.nInitialPosition + MACHININGS.Info.nHeadCutRotation - 1 + if nRotHeadCut > 4 then + nRotHeadCut = nRotHeadCut - 4 + end + local nRotSplitCut = MatrixResult.nInitialPosition + MACHININGS.Info.nSplitCutRotation - 1 + if nRotSplitCut > 4 then + nRotSplitCut = nRotSplitCut - 4 + end + + -- si imposta flag rotazione per taglio di testa + if MACHININGS.Info.nHeadCutRotation == 2 then + PROCESSINGS[nPart].Rotation[nRotHeadCut][MatrixResult.nIndexHeadCutInVProc].bSide = true + elseif MACHININGS.Info.nHeadCutRotation == 3 then + PROCESSINGS[nPart].Rotation[nRotHeadCut][MatrixResult.nIndexHeadCutInVProc].bDown = true + end + -- si imposta flag rotazione per taglio di coda + if MACHININGS.Info.nSplitCutRotation == 2 then + PROCESSINGS[nPart].Rotation[nRotSplitCut][MatrixResult.nIndexTailCutInVProc].bSide = true + elseif MACHININGS.Info.nSplitCutRotation == 3 then + PROCESSINGS[nPart].Rotation[nRotSplitCut][MatrixResult.nIndexTailCutInVProc].bDown = true + end + + local vProcHeadTail = {} + table.insert( vProcHeadTail, PROCESSINGS[nPart].Rotation[nRotHeadCut][MatrixResult.nIndexHeadCutInVProc]) + table.insert( vProcHeadTail, PROCESSINGS[nPart].Rotation[nRotSplitCut][MatrixResult.nIndexTailCutInVProc]) + + MACHININGS = CalculateMachinings( vProcHeadTail, PARTS[nPart]) + bIsCombinationMachinable = true end - EgtOutLog( ' *** AddMachinings ***', 1) - - -- ordinamento di base delle feature - vProc = OrderFeatures( vProc) - - -- esegue le strategie migliori che ha precedentemente scelto e salva le lavorazioni nella lista globale - MACHININGS = CalculateMachinings( vProc, PARTS[nPart]) - -- ordinamento lavorazioni MACHININGS = MachiningLib.PrepareMachiningsForSorting( PARTS[nPart]) -- TODO completare ordinamento. Mancano le dipendenze. @@ -1367,8 +1427,9 @@ function BeamExec.ProcessMachinings( PARTS) -- creazione effettiva delle lavorazioni local nCurrPosition = 1 + local nInitialPosition = MatrixResult.nInitialPosition -- se c'è almeno una lavorazione in posizionamento con trave ribaltata - if bSomeFeatureDown then + if MatrixResult.bSomeFeatureDown then local nRotation = EgtIf( nInitialPosition + 2 > 4, nInitialPosition + 2 - 4, nInitialPosition + 2) BeamLib.RotatePart( PARTS[nPart], nRotation - nCurrPosition) nCurrPosition = nRotation @@ -1378,9 +1439,9 @@ function BeamExec.ProcessMachinings( PARTS) end -- se c'è almeno una lavorazione in posizionamento con trave ribaltata - if bSomeFeatureSide then + if MatrixResult.bSomeFeatureSide then -- se ci sono state lavorazioni in rotazione precedente devo creare altra fase. Altrimenti già creata da prima - if bSomeFeatureDown then + if MatrixResult.bSomeFeatureDown then BeamLib.AddPhaseWithRawParts( PARTS[nPart].idRaw, BeamData.ptOriXR, BeamData.dPosXR, 0) nPhase = EgtGetCurrPhase() nDispId = EgtGetPhaseDisposition( nPhase) @@ -1401,7 +1462,7 @@ function BeamExec.ProcessMachinings( PARTS) end -- se ci sono state lavorazioni in rotazione precedente devo creare altra fase. Altrimenti già creata da prima - if bSomeFeatureDown or bSomeFeatureSide then + if MatrixResult.bSomeFeatureDown or MatrixResult.bSomeFeatureSide then BeamLib.AddPhaseWithRawParts( PARTS[nPart].idRaw, BeamData.ptOriXR, BeamData.dPosXR, 0) nPhase = EgtGetCurrPhase() nDispId = EgtGetPhaseDisposition( nPhase) @@ -1422,6 +1483,7 @@ function BeamExec.ProcessMachinings( PARTS) EgtOutLog( ' *** End AddMachinings ***', 1) -- azzero lavorazioni per pezzo successivo MACHININGS = {} + MACHININGS.Info = {} -- indice pezzo successivo nOrd = nOrd + 1 end diff --git a/LuaLibs/BeamLib.lua b/LuaLibs/BeamLib.lua index 15b74cf..e8afb33 100644 --- a/LuaLibs/BeamLib.lua +++ b/LuaLibs/BeamLib.lua @@ -144,11 +144,15 @@ end ------------------------------------------------------------------------------------------------------------- --- funzione che ruota il pezzo, da lanciare per creare la disposizione corretta function BeamLib.RotatePart( Part, nNumberOfRotations) + -- sistemo numero rotazioni in caso sia negativa + if nNumberOfRotations < 0 then + nNumberOfRotations = nNumberOfRotations + 4 + end -- primo posizionamento if nNumberOfRotations == 0 then ; -- il pezzo è già in posizione -- rotazione 90° - elseif abs( nNumberOfRotations) == 1 then + elseif nNumberOfRotations == 1 then local dDeltaYZ = EgtGetRawPartBBox( Part.idRaw):getDimY() - EgtGetRawPartBBox( Part.idRaw):getDimZ() local vtMove = Vector3d( 0, dDeltaYZ / 2 * EgtIf( BeamData.RIGHT_LOAD, -1, 1), dDeltaYZ / 2) local bPreMove = dDeltaYZ < 0 @@ -161,7 +165,7 @@ function BeamLib.RotatePart( Part, nNumberOfRotations) nRId = EgtGetNextRawPart( nRId) end -- rotazione 180° - elseif abs( nNumberOfRotations) == 2 then + elseif nNumberOfRotations == 2 then -- ribalto le travi della fase corrente local nRId = Part.idRaw while nRId do @@ -169,7 +173,7 @@ function BeamLib.RotatePart( Part, nNumberOfRotations) nRId = EgtGetNextRawPart( nRId) end -- rotazione 270° - elseif abs( nNumberOfRotations) == 3 then + elseif nNumberOfRotations == 3 then local dDeltaYZ = EgtGetRawPartBBox( Part.idRaw):getDimY() - EgtGetRawPartBBox( Part.idRaw):getDimZ() local vtMove = Vector3d( 0, dDeltaYZ / 2 * EgtIf( BeamData.RIGHT_LOAD, -1, 1), dDeltaYZ / 2) local bPreMove = dDeltaYZ < 0 diff --git a/LuaLibs/MachiningLib.lua b/LuaLibs/MachiningLib.lua index 1f45f42..52cde7a 100644 --- a/LuaLibs/MachiningLib.lua +++ b/LuaLibs/MachiningLib.lua @@ -501,6 +501,27 @@ function MachiningLib.AddNewMachining( ProcToAdd, MachiningToAdd, AuxiliaryDataT Machining.AuxiliaryData = AuxiliaryDataToAdd or {} table.insert( MACHININGS, Machining) + -- aggiornamento info generiche lavorazioni + local nHeadCutRotation + if ProcToAdd.bDown then + nHeadCutRotation = 3 + elseif ProcToAdd.bSide then + nHeadCutRotation = 2 + else + nHeadCutRotation = 1 + end + MACHININGS.Info.nHeadCutRotation = max( MACHININGS.Info.nHeadCutRotation or 0, nHeadCutRotation) + + local nSplitCutRotation + if ProcToAdd.bDown and MachiningToAdd.sStage == 'AfterTail' then + nSplitCutRotation = 3 + elseif ProcToAdd.bSide and MachiningToAdd.sStage == 'AfterTail' then + nSplitCutRotation = 2 + else + nSplitCutRotation = 1 + end + MACHININGS.Info.nSplitCutRotation = max( MACHININGS.Info.nSplitCutRotation or 0, nSplitCutRotation) + return true end @@ -710,9 +731,11 @@ function MachiningLib.AddOperations( vProc, Part, sRotation) local nDispId = EgtGetPhaseDisposition( nPhase) if sRotation == 'DOWN' then + BeamLib.RotatePart( Part, 2) EgtSetInfo( nDispId, 'ROT', -2) EgtSetInfo( nDispId, 'TYPE', 'MID2') elseif sRotation == 'SIDE' then + BeamLib.RotatePart( Part, 1) EgtSetInfo( nDispId, 'ROT', -1) EgtSetInfo( nDispId, 'TYPE', 'MID2') else