Se feature respinta per extracorsa, viene salvata nota nel LOG

- Se si deve riprocessare, si riporta il pezzo in posizione originale
- in GetCombinationListFromMatrix si ricalcola la migliore strategia in caso ChosenStrategy non presente (solo se ReProcess)
- Piccole migliorie

BatchProcessNew.lua

@@ -32,7 +32,7 @@ if not sMachDir then
    EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Travi', 'ERROR')
    return
 end
-if not EgtExistsFile( sMachDir .. '\\Beam\\BeamData.lua') then
+if not EgtExistsFile( sMachDir .. '\\Beam\\BeamDataNew.lua') then
    EgtOutBox( 'La macchina corrente non è configurata per lavorare travi', 'Lavora Travi', 'ERROR')
    BEAM.ERR = 12
    BEAM.MSG = 'Error not configured for beams machine : ' .. sMachine
@@ -58,11 +58,15 @@ _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.BeamData = nil
+_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.
@@ -88,7 +92,7 @@ end
 PARTS = {}          -- tabella contenente tutte le informazioni di ogni pezzo
 
 -- Carico i dati globali
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 -- carico librerie
 local BeamExec = require( 'BeamExec')
 local BeamLib = require( 'BeamLib')
@@ -178,6 +182,13 @@ local function WriteResultToJson( RESULT)
 end
 
 -------------------------------------------------------------------------------------------------------------
+
+-- calcolo tempo esecuzione
+TIMER:start()
+EgtOutLog( ' Execution timer started')
+
+-- script principale
+
 local sFlag = ''
 if BEAM.FLAG == 0 then
    sFlag = 'GENERATE'
@@ -200,7 +211,7 @@ elseif BEAM.FLAG == 10 then
 else
    sFlag = 'FLAG='..tostring( BEAM.FLAG)
 end
-local sLog = 'BatchProcess : ' .. BEAM.FILE .. ', ' .. BEAM.MACHINE .. ', ' .. sFlag
+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
@@ -235,7 +246,9 @@ elseif BEAM.FLAG == 9 then
 
       local Part = {}
       Part.id = EgtGetParent( EgtGetParent( BEAM.FEATUREID))
-      Part.b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( Part.id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+      Part.idBoxTm = EgtGetFirstInGroup( EgtGetFirstNameInGroup( Part.id, 'Box') or GDB_ID.NULL)
+      Part.b3Part = EgtGetBBoxGlob( Part.idBoxTm, GDB_BB.STANDARD)
+      Part.idTempGroup = idTempGroup
 
       local Proc = FeatureLib.GetProcFromTrimesh( BEAM.FEATUREID, Part)
       Proc.nGrp = EgtGetInfo( Proc.id, 'GRP', 'i')
@@ -299,6 +312,9 @@ if bToProcess then
          BEAM.MSG = 'Error opening BWE file : ' .. BEAM.FILE
          WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
          PostErrView( BEAM.ERR, BEAM.MSG)
+         BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+         BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+         WriteResultToJson( RESULT)
          return
       end
       -- Faccio copia del file originale
@@ -319,6 +335,9 @@ if bToProcess then
             BEAM.MSG = 'Error no Raw Parts in the file : ' .. BEAM.FILE
             WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
             PostErrView( BEAM.ERR, BEAM.MSG)
+            BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+            BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+            WriteResultToJson( RESULT)
             return
          end
          local b3Raw = EgtGetRawPartBBox( nRawId)
@@ -343,6 +362,9 @@ if bToProcess then
             BEAM.MSG = 'Error no beams in the file : ' .. BEAM.FILE
             WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
             PostErrView( BEAM.ERR, BEAM.MSG)
+            BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+            BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+            WriteResultToJson( RESULT)
             return
          else
             local sOut = ''
@@ -361,6 +383,9 @@ if bToProcess then
                BEAM.MSG = 'Box undefined for beam ' .. PARTS[i].sName
                WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
                PostErrView( BEAM.ERR, BEAM.MSG)
+               BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+               BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+               WriteResultToJson( RESULT)
                return
             else
                PARTS[i].b3PartOriginal = b3Solid
@@ -397,6 +422,9 @@ if bToProcess then
          BEAM.ERR = 14
          BEAM.MSG = 'Error : no beams in the project'
          WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
+         BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+         BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+         WriteResultToJson( RESULT)
          return
       else
          local sOut = ''
@@ -414,6 +442,9 @@ if bToProcess then
             BEAM.ERR = 15
             BEAM.MSG = 'Box undefined for beam ' .. PARTS[i].sName
             WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
+            BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+            BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+            WriteResultToJson( RESULT)
             return
          else
             PARTS[i].b3PartOriginal = b3Solid
@@ -424,6 +455,9 @@ if bToProcess then
    -- 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
+   local idTempGroup = BeamLib.CreateTempGroup()
+
    -- Se devo creare la barra
    if bCreateBar then
       if #PARTS == 0 then
@@ -470,6 +504,9 @@ if bToProcess then
             BEAM.MSG = sOut
             WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
             PostErrView( BEAM.ERR, BEAM.MSG)
+            BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+            BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+            WriteResultToJson( RESULT)
             return
          end
       else
@@ -483,6 +520,9 @@ if bToProcess then
             BEAM.MSG = sOut
             WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
             PostErrView( BEAM.ERR, BEAM.MSG)
+            BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+            BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+            WriteResultToJson( RESULT)
             return
          end
       end
@@ -496,6 +536,9 @@ if bToProcess then
          BEAM.MSG = sOut
          WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
          PostErrView( BEAM.ERR, BEAM.MSG)
+         BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+         BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+         WriteResultToJson( RESULT)
          return
       end
 
@@ -514,6 +557,9 @@ if bToProcess then
          BEAM.MSG = sPbErr
          WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
          PostErrView( BEAM.ERR, BEAM.MSG)
+         BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+         BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+         WriteResultToJson( RESULT)
          return
       else
          -- Scrivo altezza e larghezza barra nel gruppo di lavoro corrente
@@ -573,7 +619,8 @@ if bToProcess then
          PARTS[i].dRawWidth = PARTS[i].b3Raw:getDimY()
          PARTS[i].dRawHeight = PARTS[i].b3Raw:getDimZ()
          -- dimensione pezzo finito
-         PARTS[i].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+         PARTS[i].idBoxTm = EgtGetFirstInGroup( EgtGetFirstNameInGroup( PARTS[i].id, 'Box') or GDB_ID.NULL)
+         PARTS[i].b3Part = EgtGetBBoxGlob( PARTS[i].idBoxTm, GDB_BB.STANDARD)
          PARTS[i].dLength = PARTS[i].b3Part:getDimX()
          PARTS[i].dWidth = PARTS[i].b3Part:getDimY()
          PARTS[i].dHeight = PARTS[i].b3Part:getDimZ()
@@ -582,14 +629,17 @@ if bToProcess then
          PARTS[i].SplittingPoints = BeamLib.GetPartSplittingPoints( PARTS[i])
          PARTS[i].NotClampableLength = { STD = { dHead = 0, dTail = 0}, SIDE = { dHead = 0, dTail = 0}, DOWN = { dHead = 0, dTail = 0}}
          PARTS[i].sBTLInfo = EgtGetInfo( PARTS[i].id, 'PROJ', 's') or nil
+         PARTS[i].idTempGroup = idTempGroup
 
          PARTS[i].sAISetupConfig = EgtGetInfo( PARTS[i].id, 'AISETUP', 's') or
                                    ( GENERAL_PARAMETERS.BTL[PARTS[i].sBTLInfo] and GENERAL_PARAMETERS.BTL[PARTS[i].sBTLInfo].sAISetupConfig) or  -- i parametri BTL potrebbero non esistere
                                    GENERAL_PARAMETERS.PROJECT.sAISetupConfig or nil
 
          -- si carica configurazione lavorazioni
+         TIMER:startElapsed('Json')
          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)
 
          -- sovramateriale in testa al pezzo
@@ -621,6 +671,9 @@ if bToProcess then
          BEAM.ERR = 0
          BEAM.MSG = '---'
          WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
+         BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+         BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+         WriteResultToJson( RESULT)
       end
       EgtOutLog( ' +++ BatchProcess completed')
       return
@@ -637,23 +690,18 @@ if bToProcess then
    EgtImportSetup()
 
    -- Lavoro le features
+   -- TODO gestire errori e messaggi di ritorno in questo caso
    if not GetDataConfig() then return end
 
-   -- creo un gruppo temporaneo dove finiranno tutte le entità che non bisogna salvare, alla fine lo si cancella
-   BeamLib.CreateTempGroup()
-
    BeamExec.GetProcessings( PARTS, bCalcBestPieceUnloadPosition)
    BeamExec.GetCombinationMatrix( PARTS, bCalcBestPieceUnloadPosition)
    BeamExec.ProcessMachinings( PARTS)
 
    -- si cancella gruppo temporaneo contenente entità da cancellare
-   local idTempGroup = BeamLib.GetTempGroup()
    EgtErase( idTempGroup)
 
    local sOutput = ''
 
-   -- Scrittura json risultati
-   WriteResultToJson( RESULT)
    -- scrittura txt risultati
    for i = 1, #RESULT do
       local sMsg = ''
@@ -670,8 +718,13 @@ if bToProcess then
       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
-         BEAM.ERR = 0
-         BEAM.MSG = '---'
+         if #EgtTrim( sMsg) > 0 then
+            BEAM.ERR = -19
+            BEAM.MSG = sMsg
+         else
+            BEAM.ERR = 0
+            BEAM.MSG = '---'
+         end
          BEAM.ROT = -( RESULT[i].nRotation or 1) + 1
          BEAM.CUTID = RESULT[i].idCut
          BEAM.TASKID = RESULT[i].idTask
@@ -700,6 +753,14 @@ if bToProcess then
             BEAM.CUTID = RESULT[i].idCut
             BEAM.FALL = abs( RESULT[i].nErr + 100)
             WriteFallToLogFile( BEAM.ERR, BEAM.MSG, BEAM.CUTID, BEAM.FALL)
+         -- errore da post apply, al momento non specifico
+         elseif RESULT[i].sType == 'Part' and RESULT[i].nErr > 0 then
+            nErrCnt = nErrCnt + 1
+            sOutput = sOutput .. string.format( '[%d,%d] %s\n', RESULT[i].idCut, RESULT[i].idTask, sMsg)
+            BEAM.ERR = 19
+            BEAM.MSG = 'Clamp impossible'
+            WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
+            return
          -- feature incompleta e altro
          elseif RESULT[i].sType == 'Feature' and RESULT[i].ChosenStrategy.sStatus == 'Not-Completed' then
             nWarnCnt = nWarnCnt + 1
@@ -714,6 +775,8 @@ if bToProcess then
       end
    end
 
+   -- TODO: se scarico a caduta (-101, -102) le lavorazioni dopo separazione vanno disattivate. Scrivere info feature incompleta su quelle feature 
+
    -- Salvo il progetto
    EgtSaveFile( sNgeFile)
    -- copio come originale (per dichiarare progetto ricalcolato)
@@ -746,6 +809,11 @@ else
    end
 end
 
+-- log tempi di esecuzione
+if EgtGetDebugLevel() >= 3 then
+   TIMER:logAllElapsed()
+end
+
 -- *** Eseguo simulazione con verifica collisione in cieco ***
 if  ( BEAM.FLAG == 0 and ( bToProcess or bToRecalc)) or BEAM.FLAG == 3 or BEAM.FLAG == 4  then
    EgtOutLog( ' +++ Simulating with collision check >>>')
@@ -759,7 +827,12 @@ if  ( BEAM.FLAG == 0 and ( bToProcess or bToRecalc)) or BEAM.FLAG == 3 or BEAM.F
             sToolsList = sToolsList ..  ", "
          end
       end
-      WriteErrToLogFile( 19, 'Error in setup: tool/s ' .. sToolsList .. ' not found', 0, 0, 0)
+      BEAM.ERR = 19
+      BEAM.MSG = 'Error in setup: tool/s ' .. sToolsList .. ' not found'
+      WriteErrToLogFile( BEAM.ERR, BEAM.MSG, 0, 0, 0)
+      BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+      BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+      WriteResultToJson( RESULT)
       return
    end
    -- lancio simulazione
@@ -794,6 +867,10 @@ if  ( BEAM.FLAG == 0 and ( bToProcess or bToRecalc)) or BEAM.FLAG == 3 or BEAM.F
          end
       end
       WriteErrToLogFile( BEAM.ERR, BEAM.MSG, BEAM.ROT, BEAM.CUTID, BEAM.TASKID)
+      -- TODO gestire collisione su feature specifica!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+      BeamExec.AddApplyResultToGlobalList( BEAM.ERR, BEAM.CUTID, BEAM.MSG)
+      BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+      WriteResultToJson( RESULT)
       return
    end
 end
@@ -813,6 +890,9 @@ if bIsGenerationEnabled and ( BEAM.FLAG == 0 or BEAM.FLAG == 4) then
       BEAM.MSG = 'Error generating NC part program : ' .. sName
       WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
       PostErrView( BEAM.ERR, BEAM.MSG)
+      BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+      BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+      WriteResultToJson( RESULT)
       return
    end
 end
@@ -825,6 +905,9 @@ if not EgtEstimate( '', 'EgtCAM5 - ' .. sNgeFile) then
    BEAM.MSG = 'Error estimating production time : ' .. sName
    WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
    PostErrView( BEAM.ERR, BEAM.MSG)
+   BeamExec.AddApplyResultToGlobalList( BEAM.ERR, 0, BEAM.MSG)
+   BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+   WriteResultToJson( RESULT)
    return
 end
 local Ttot = EgtGetInfo( EgtGetCurrMachGroup(), 'Ttot', 'd')
@@ -847,5 +930,11 @@ end
 
 -- Scrittura tempo totale stimato di lavorazione
 WriteTimeToLogFile( Ttot)
+RESULT[#RESULT+1] = { dTime = Ttot, sType = 'Time'}
+
+-- Riporto risultati in tabella globale BEAM
+BEAM.RESULT = BeamLib.TableCopyDeep( RESULT)
+-- Scrittura json risultati
+WriteResultToJson( RESULT)
 
 EgtOutLog( ' +++ BatchProcess completed')

LuaLibs/BasicCustomerStrategies.lua

@@ -9,7 +9,7 @@ local BasicCustomerStrategies = {}
 require( 'EgtBase')
 
 -- Carico i dati globali
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local BeamLib = require( 'BeamLib')
 local ID = require( 'Identity')
 

LuaLibs/BeamExec.lua

@@ -9,7 +9,7 @@ local BeamExec = {}
 require( 'EgtBase')
 
 -- Carico i dati globali
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
@@ -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,15 +29,18 @@ 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
 MACHININGS = {}         -- tabella contenente le lavorazioni da applicare
 MACHININGS.Info = {}
+DB_MACH_APPLIED = {}    -- tabella contenente informazioni delle lavorazioni create e aggiunte in lista
 PROCESSINGS = {}        -- tabella contenente tutte le informazioni di ogni feature, processate per ogni rotazione
 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 +119,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 = {}
@@ -123,6 +128,7 @@ function BeamExec.GetToolsFromDB()
          Tool.Feeds.dEndFeed = EgtTdbGetCurrToolParam( MCH_TP.ENDFEED)
          Tool.Feeds.dTipFeed = EgtTdbGetCurrToolParam( MCH_TP.TIPFEED)
          Tool.sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+         Tool.nExit = EgtTdbGetCurrToolParam( MCH_TP.EXIT)
          Tool.SetupInfo = {}
          Tool.SetupInfo = BeamData.GetSetupInfo( Tool.sHead)
          if not Tool.SetupInfo.GetMinNzDownUp then
@@ -192,6 +198,7 @@ function BeamExec.GetToolsFromDB()
 
          -- se tutti i dati necessari sono disponibili, inserisco utensile nella lista globale degli utensili disponibili
          if IsToolOk( Tool) then
+            Tool.nIndex = #TOOLS + 1
             table.insert( TOOLS, Tool)
          -- altrimenti scrivo nel log che l'utensile non è conforme
          else
@@ -348,6 +355,9 @@ end
 --    *** funzioni posizionamento pezzi all'interno della barra ***
 -------------------------------------------------------------------------------------------------------------
 function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS, bCreateMachGroup, bCalcBestPieceUnloadPosition)
+   -- gruppo per geometrie temporanee
+   local idTempGroup = BeamLib.GetTempGroup()
+
    -- default per nuove costanti qualora non definite
    BeamData.OVM_BLADE_HBEAM = ( BeamData.OVM_BLADE_HBEAM or 11)
    BeamData.OVM_CHAIN_HBEAM = ( BeamData.OVM_CHAIN_HBEAM or 8)
@@ -477,7 +487,8 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS, b
          PARTS[i].dWidth = PARTS[i].b3Raw:getDimY()
          PARTS[i].dHeight = PARTS[i].b3Raw:getDimZ()
          PARTS[i].bSquareSection = abs( PARTS[i].dWidth - PARTS[i].dHeight) < 100 * GEO.EPS_SMALL
-         PARTS[i].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+         PARTS[i].idBoxTm = EgtGetFirstInGroup( EgtGetFirstNameInGroup( PARTS[i].id, 'Box') or GDB_ID.NULL)
+         PARTS[i].b3Part = EgtGetBBoxGlob( PARTS[i].idBoxTm, GDB_BB.STANDARD)
          PARTS[i].nIndexInParts = i
          PARTS[i].SplittingPoints = BeamLib.GetPartSplittingPoints( PARTS[i])
          PARTS[i].NotClampableLength = { STD = { dHead = 0, dTail = 0}, SIDE = { dHead = 0, dTail = 0}, DOWN = { dHead = 0, dTail = 0}}
@@ -489,9 +500,12 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS, b
                                    GENERAL_PARAMETERS.PROJECT.sAISetupConfig or nil
 
          -- si carica configurazione lavorazioni
+         TIMER:startElapsed('Json')
          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].idTempGroup = idTempGroup
 
       else
          local sOut = 'Error: part L(' .. EgtNumToString( dPartLen, 1) .. ') too big for raw part L(' .. EgtNumToString( dLen - 0.1, 1) .. ')'
@@ -604,6 +618,7 @@ local function CollectFeatures( Part, dRotIndex)
             local nDo = EgtGetInfo( ProcId, 'DO', 'i') or 1
             if nGrp and nPrc and nDo == 1 then
                local Proc = {}
+               Proc.isVirtualProc = nInd == 1  -- feature non presente in lista originale BTL ma aggiunta da automatismo
                Proc.idPart = Part.id
                Proc.idRaw = Part.idRaw
                Proc.nIndexPartInParts = Part.nIndexInParts
@@ -624,6 +639,8 @@ local function CollectFeatures( Part, dRotIndex)
                if Proc.b3Box and not Proc.b3Box:isEmpty() then
                   -- informazioni facce e topologia
                   Proc.AffectedFaces = BeamLib.GetAffectedFaces( Proc, Part)
+                  -- volume feature approssimato
+                  Proc.dVolume = FeatureLib.GetFeatureVolume( Proc, Part)
                   -- calcolo topologia solo se necessario, altrimenti si sfruttano le informazioni della feature BTL
                   local bIsFeatureReadyForProcessing = false
                   if FeatureLib.NeedTopologyFeature( Proc, Part) then
@@ -715,6 +732,7 @@ local function AreDrillingsMirrored( Proc, ProcMirror, Part)
    if AreOppositeVectorApprox( vtExtr, vtExtrMirror) then
       -- fori lungo Y
       -- per macchine tipo PF il foro principale è sul lato back, per macchine tipo PF1250 è sul lato front
+      -- TODO eliminare i riferimenti a DOWN_HEAD e TWO_EQUAL_HEADS e sostituirli con check iniziale sulla disponibilità di teste?
       if ( BeamData.TWO_EQUAL_HEADS and AreSameVectorApprox( vtExtr, Y_AX())) or
       ( BeamData.DOWN_HEAD and AreOppositeVectorApprox( vtExtr, Y_AX())) then
          nDouble = 2
@@ -767,8 +785,8 @@ local function GetFeatureInfoAndDependency( vProcSingleRot, Part)
             local ProcB = vProcSingleRot[j]
             -- non si controlla la feature con se stessa o se feature disabilitata
             if i ~= j  and  ProcB.nFlg ~= 0 then
-               -- verifico se il taglio aggiunto manualmente può essere saltato perchè nella stessa posizione c'è un altro taglio di testa
-               if ID.IsHeadCut( Proc) and ( ID.IsHeadCut( ProcB) and EgtGetInfo( ProcB.id, 'HEAD_ADD_CUT', 'i') == 1) then
+               -- se entrambi tagli di testa, si tiene sempre il primo ( ma non quello aggiunto dall'automatismo)
+               if ( ID.IsHeadCut( Proc) and not EgtGetInfo( Proc.id, 'HEAD_ADD_CUT', 'i')) and ID.IsHeadCut( ProcB) then
                   if not Proc.SlaveProcIndexes then
                      Proc.SlaveProcIndexes = {}
                   end
@@ -776,8 +794,8 @@ local function GetFeatureInfoAndDependency( vProcSingleRot, Part)
                   ProcB.nIndexMasterProc = i
                   ProcB.nFlg = 0
                end
-               -- verifico se il taglio aggiunto manualmente può essere saltato perchè nella stessa posizione c'è un altro taglio di coda
-               if ID.IsTailCut( Proc) and ( ID.IsTailCut( ProcB) and EgtGetInfo( ProcB.id, 'HEAD_ADD_CUT', 'i') == 1) then
+               -- se entrambi tagli di coda, si tiene sempre il primo ( ma non quello aggiunto dall'automatismo)
+               if ( ID.IsTailCut( Proc) and not EgtGetInfo( Proc.id, 'HEAD_ADD_CUT', 'i')) and ID.IsTailCut( ProcB) then
                   if not Proc.SlaveProcIndexes then
                      Proc.SlaveProcIndexes = {}
                   end
@@ -791,6 +809,7 @@ local function GetFeatureInfoAndDependency( vProcSingleRot, Part)
                   Proc.bPassedByHole = true
                end
                -- verifiche per specchiature
+               -- TODO eliminare i riferimenti a DOWN_HEAD e TWO_EQUAL_HEADS e sostituirli con check iniziale sulla disponibilità di teste?
                if BeamData.DOWN_HEAD or BeamData.TWO_EQUAL_HEADS then
                   -- forature
                   if BeamData.DOUBLE_HEAD_DRILLING and ID.IsDrill( Proc) and ID.IsDrill( ProcB) and not Proc.Mirror then
@@ -886,26 +905,34 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 -- funzione che trova la strategia migliore tra quelle disponibili
-local function GetBestStrategy( vProcSingleRot, Part)
+local function GetFeatureBestStrategy( Proc, Part)
+   if Proc.nFlg ~= 0 then
+      local nIndexBestStrategy = 0
+      -- controllo se ci sono strategie disponibili
+      if Proc.AvailableStrategies and #Proc.AvailableStrategies > 0 then
+         -- ciclo tutte le strategie della feature
+         for nIndexCurrentStrategy = 1, #Proc.AvailableStrategies do
+            -- scelgo la migliore strategia tra le due
+            nIndexBestStrategy = GetIndexBestStrategyFromComparison( Proc.AvailableStrategies, Part, nIndexCurrentStrategy, nIndexBestStrategy)
+            -- salvo sulla proc la migliore strategia
+         end
+         if nIndexBestStrategy ~= 0 then
+            Proc.ChosenStrategy = BeamLib.TableCopyDeep( Proc.AvailableStrategies[nIndexBestStrategy])
+            Proc.nIndexBestStrategy = nIndexBestStrategy
+         end
+      end
+   end
+
+   return Proc
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- funzione che trova la strategia migliore tra quelle disponibili
+local function GetBestStrategyFromProcList( vProcSingleRot, Part)
    for i = 1, #vProcSingleRot do
       -- processo tutte le feature attive
       local Proc = vProcSingleRot[i]
-      if Proc.nFlg ~= 0 then
-         local nIndexBestStrategy = 0
-         -- controllo se ci sono strategie disponibili
-         if Proc.AvailableStrategies and #Proc.AvailableStrategies > 0 then
-            -- ciclo tutte le strategie della feature
-            for nIndexCurrentStrategy = 1, #Proc.AvailableStrategies do
-               -- scelgo la migliore strategia tra le due
-               nIndexBestStrategy = GetIndexBestStrategyFromComparison( Proc.AvailableStrategies, Part, nIndexCurrentStrategy, nIndexBestStrategy)
-               -- salvo sulla proc la migliore strategia
-            end
-            if nIndexBestStrategy ~= 0 then
-               Proc.ChosenStrategy = BeamLib.TableCopyDeep( Proc.AvailableStrategies[nIndexBestStrategy])
-               Proc.nIndexBestStrategy = nIndexBestStrategy
-            end
-         end
-      end
+      Proc = GetFeatureBestStrategy( Proc, Part)
    end
    return vProcSingleRot
 end
@@ -1054,6 +1081,7 @@ local function AddFeatureResultToGlobalList( Proc, OptionalParameters)
    local dCompletionIndex
    local dCompositeRating
    local sInfo
+   local sApplyInfo
 
    if not OptionalParameters then
       OptionalParameters = {}
@@ -1061,13 +1089,19 @@ local function AddFeatureResultToGlobalList( Proc, OptionalParameters)
    local nRotation = OptionalParameters.nRotation or 1
 
    if Proc.nIndexMasterProc then
+      -- se è una feature non presente in elenco ed è saltata perchè lavorata da un'altra feature, non si fa passare dai RESULT.
+      -- se non avesse una master associata, allora risulterà come messaggio su pezzo
+      if Proc.isVirtualProc then
+         return
+      end
       local ChosenStrategyTable = PROCESSINGS[Proc.nIndexPartInParts].Rotation[Proc.nIndexRotation][Proc.nIndexMasterProc].ChosenStrategy
       if ChosenStrategyTable then
          sStrategyId = ChosenStrategyTable.sStrategyId
          sStatus = ChosenStrategyTable.Result.sStatus
          dCompletionIndex = ChosenStrategyTable.Result.dCompletionIndex
          dCompositeRating = ChosenStrategyTable.Result.dCompositeRating
-         sInfo = ChosenStrategyTable.Result.sInfo
+         local idFeature  = PROCESSINGS[Proc.nIndexPartInParts].Rotation[Proc.nIndexRotation][Proc.nIndexMasterProc].idFeature
+         sApplyInfo = 'Skipped. Feature machined: ' .. EgtNumToString( idFeature)
       end
    elseif Proc.ChosenStrategy then
       sStrategyId = Proc.ChosenStrategy.sStrategyId
@@ -1091,7 +1125,8 @@ local function AddFeatureResultToGlobalList( Proc, OptionalParameters)
          sStatus = sStatus,
          dCompletionIndex = dCompletionIndex,
          dCompositeRating = dCompositeRating,
-         sInfo = sInfo
+         sInfo = sInfo,
+         sApplyInfo = sApplyInfo
       }
    }
    -- scrivo le strategie disponibili solo se ne esistono
@@ -1106,7 +1141,7 @@ local function AddFeatureResultToGlobalList( Proc, OptionalParameters)
 end
 
 -------------------------------------------------------------------------------------------------------------
-local function AddApplyResultToGlobalList( nErr, idCut, sMsg)
+function BeamExec.AddApplyResultToGlobalList( nErr, idCut, sMsg)
    RESULT[#RESULT+1] = {
       sType = 'Part',
       idCut = idCut,
@@ -1119,7 +1154,6 @@ end
 -------------------------------------------------------------------------------------------------------------
 -- esegue le strategie migliori che ha precedentemente scelto
 local function CalculateMachinings( vProc, Part, nInitialRotation)
-   local bAreAllApplyOk = true
    local n0Rotation = nInitialRotation
    local n90Rotation = nInitialRotation + 1
    if n90Rotation > 4 then n90Rotation = n90Rotation - 4 end
@@ -1139,13 +1173,13 @@ local function CalculateMachinings( vProc, Part, nInitialRotation)
          elseif Proc.bSide and nCurrRotation ~= n90Rotation then
             BeamLib.RotateRawPart( Part, n90Rotation - nCurrRotation)
             nCurrRotation = n90Rotation
-         elseif nCurrRotation ~= n0Rotation and not( Proc.bSide) and not( Proc.bDown) then
+         elseif Proc.bStd and nCurrRotation ~= n0Rotation then
             BeamLib.RotateRawPart( Part, n0Rotation - nCurrRotation)
             nCurrRotation = n0Rotation
          end
          -- aggiorno info pezzo
          Part.b3Raw = EgtGetRawPartBBox( Part.idRaw)
-         Part.b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( Part.id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+         Part.b3Part = EgtGetBBoxGlob( Part.idBoxTm, GDB_BB.STANDARD)
          -- si applicano le strategie
          if Proc.ChosenStrategy then
             -- carico file script strategia (non serve verificare presenza del file perchè già fatto durante scelta strategia)
@@ -1171,9 +1205,9 @@ local function CalculateMachinings( vProc, Part, nInitialRotation)
       BeamLib.RotateRawPart( Part, 1 - nCurrRotation)
       -- aggiorno info pezzo
       Part.b3Raw = EgtGetRawPartBBox( Part.idRaw)
-      Part.b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( Part.id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+      Part.b3Part = EgtGetBBoxGlob( Part.idBoxTm, GDB_BB.STANDARD)
    end
-   return MACHININGS, bAreAllApplyOk
+   return MACHININGS
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -1192,10 +1226,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)
@@ -1204,7 +1234,8 @@ function BeamExec.GetProcessings( PARTS, bCalcBestPieceUnloadPosition)
       if not PARTS[nPart].id  and  PARTS[nPart].b3Raw:getDimX() < BeamData.dMinRaw then break end
       local vProcRot = {}
 
-      local nCycles = EgtIf( bCalcBestPieceUnloadPosition, 2, 1)  -- se è prerotazione, oltre al ciclo normale, si devono verificare anche invertiti
+      -- se è prerotazione, oltre al ciclo normale, si devono verificare anche invertiti
+      local nCycles = EgtIf( bCalcBestPieceUnloadPosition and PARTS[nPart].GeneralParameters.GEN_sPiecesLoadingPosition ~= 'BTL_POSITION', 2, 1)
       -- per ogni inversione
       for nInvertIndex = 1, nCycles do
          -- per ogni rotazione
@@ -1227,14 +1258,14 @@ function BeamExec.GetProcessings( PARTS, bCalcBestPieceUnloadPosition)
             BeamLib.RotateRawPart( PARTS[nPart], 1)
             -- aggiorno info pezzo
             PARTS[nPart].b3Raw = EgtGetRawPartBBox( PARTS[nPart].idRaw)
-            PARTS[nPart].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[nPart].id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+            PARTS[nPart].b3Part = EgtGetBBoxGlob( PARTS[nPart].idBoxTm, GDB_BB.STANDARD)
          end
-         if bCalcBestPieceUnloadPosition then
+         if bCalcBestPieceUnloadPosition and PARTS[nPart].GeneralParameters.GEN_sPiecesLoadingPosition ~= 'BTL_POSITION' then
             -- inversione pezzo testa-coda
             BeamLib.InvertRawPart( PARTS[nPart], 2)
             -- aggiorno info pezzo
             PARTS[nPart].b3Raw = EgtGetRawPartBBox( PARTS[nPart].idRaw)
-            PARTS[nPart].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[nPart].id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+            PARTS[nPart].b3Part = EgtGetBBoxGlob( PARTS[nPart].idBoxTm, GDB_BB.STANDARD)
          end
       end
       local Part = {}
@@ -1242,13 +1273,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
 
@@ -1322,7 +1347,6 @@ local function GetBestCombination( ListToCompare, Part)
                      end
                   end
                end
-
             end
          end
       end
@@ -1366,6 +1390,7 @@ local function GetProcessingListFromCombination( BestCombination)
    -- aggiungo processing da fare in ultima fase
    if #BestCombination.Rot0 > 0 then
       for i = 1, #BestCombination.Rot0 do
+         BestCombination.Rot0[i].bStd = true
          table.insert( vProc, BestCombination.Rot0[i])
       end
    end
@@ -1411,8 +1436,7 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 -- funzione che calcola le combinazioni di rotazione per lavorare la trave e sceglie la migliore
-local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo)
-   local BestCombination = {}
+local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo, bReProcessEmptyChosenStrategy)
    local CombinationsList = { dAllCombinationsTotalTime = 0}
 
    -- calcolo per tutte le combinazioni disponibili precedentemente verificate
@@ -1439,14 +1463,14 @@ local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo)
       -- 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
-         if not ID.IsHeadCut( ProcessingsOnPart.Rotation[1][nProc])  and  not ID.IsTailCut( ProcessingsOnPart.Rotation[1][nProc]) then
-            -- Si controlla sempre la rotazione 1 perchè la dipendenza di una feature da un'altra non dipende dalla rotazione
-            -- se feature disattivata perchè eseguita da master a lei associata dichiaro comunque eseguita
-            if ProcessingsOnPart.Rotation[1][nProc].nFlg == 0 and  ProcessingsOnPart.Rotation[1][nProc].nIndexMasterProc then
-               ProcessingsOnPart.Rotation[1][nProc].nIndexRotation = nUnloadPos
-               table.insert( SingleCombination.Rot0, ProcessingsOnPart.Rotation[1][nProc])
-               SingleCombination.nComplete = SingleCombination.nComplete + 1
-            else
+         -- Si controlla sempre la rotazione 1 perchè la dipendenza di una feature da un'altra non dipende dalla rotazione
+         -- se feature disattivata perchè eseguita da master a lei associata dichiaro comunque eseguita
+         if ProcessingsOnPart.Rotation[1][nProc].nFlg == 0 and  ProcessingsOnPart.Rotation[1][nProc].nIndexMasterProc then
+            ProcessingsOnPart.Rotation[1][nProc].nIndexRotation = nUnloadPos
+            table.insert( SingleCombination.Rot0, ProcessingsOnPart.Rotation[1][nProc])
+            SingleCombination.nComplete = SingleCombination.nComplete + 1
+         else
+            if not ID.IsHeadCut( ProcessingsOnPart.Rotation[1][nProc])  and  not ID.IsTailCut( ProcessingsOnPart.Rotation[1][nProc]) then
                -- ciclo sulle rotazioni
                local nNextRot = nUnloadPos
                local nOffsetIndex = EgtIf( SingleCombination.bPartInCombiIsInverted, 4, 0)
@@ -1454,13 +1478,18 @@ local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo)
                for nRotation = 1, 3 do
                   -- se rotazione abilitata da combinazione
                   if string.sub( PartInfo.CombinationList[i].sBitIndexCombination, nNextRot, nNextRot) == '1' then
+                     local CurrProc = ProcessingsOnPart.Rotation[nNextRot+nOffsetIndex][nProc]
                      -- se è ultima rotazione oppure se feature non impatta su misura laser, allora è valida e può essere effettivamente considerata
-                     if nNextRot == nUnloadPos or not( ProcessingsOnPart.Rotation[nNextRot+nOffsetIndex][nProc].bHindersLaserMeasure) then
+                     if nNextRot == nUnloadPos or not( CurrProc.bHindersLaserMeasure) then
+                        -- se non è settata la ChosenStrtegy, provo a cercare comunque tra quelle disponibili
+                        if not CurrProc.ChosenStrategy and bReProcessEmptyChosenStrategy then
+                           CurrProc = GetFeatureBestStrategy( CurrProc, PartInfo)
+                        end
                         -- controllo se è stata scelta una strategia
-                        if ProcessingsOnPart.Rotation[nNextRot+nOffsetIndex][nProc].ChosenStrategy then
+                        if CurrProc.ChosenStrategy then
                            local Proc = {}
                            Proc.nRotation = nNextRot
-                           table.insert( Proc, ProcessingsOnPart.Rotation[nNextRot+nOffsetIndex][nProc])
+                           table.insert( Proc, CurrProc)
                            table.insert( ResultsList, Proc)
                         end
                      end
@@ -1497,12 +1526,12 @@ local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo)
                   table.insert( SingleCombination.Rot0, ProcessingsOnPart.Rotation[nUnloadPos+nOffsetIndex][nProc])
                   SingleCombination.nNotExecute = SingleCombination.nNotExecute + 1
                end
-            end
-         else
-            if ID.IsHeadCut( ProcessingsOnPart.Rotation[1][nProc]) then
-               SingleCombination.nIndexHeadCutInVProc = nProc
-            elseif ID.IsTailCut( ProcessingsOnPart.Rotation[1][nProc]) then
-               SingleCombination.nIndexTailCutInVProc = nProc
+            else
+               if ID.IsHeadCut( ProcessingsOnPart.Rotation[1][nProc]) then
+                  SingleCombination.nIndexHeadCutInVProc = nProc
+               elseif ID.IsTailCut( ProcessingsOnPart.Rotation[1][nProc]) then
+                  SingleCombination.nIndexTailCutInVProc = nProc
+               end
             end
          end
       end
@@ -1528,7 +1557,7 @@ end
 function BeamExec.GetCombinationMatrix( PARTS, bCalcBestPieceUnloadPosition)
    -- ricerca strategia di lavorazione per ogni pezzo e applicazione lavorazioni
    for nPart = 1, #PARTS do
-      local nCycles = EgtIf( bCalcBestPieceUnloadPosition, 2, 1)
+      local nCycles = EgtIf( bCalcBestPieceUnloadPosition and PARTS[nPart].GeneralParameters.GEN_sPiecesLoadingPosition ~= 'BTL_POSITION', 2, 1)
       -- per ogni inversione
       for nInvertIndex = 1, nCycles do
          -- calcolo della migliore strategia per ogni rotazione del pezzo
@@ -1538,19 +1567,19 @@ function BeamExec.GetCombinationMatrix( PARTS, bCalcBestPieceUnloadPosition)
             -- calcola le strategie applicabili
             PROCESSINGS[nPart].Rotation[nIndex] = CalculateStrategies( PROCESSINGS[nPart].Rotation[nIndex], PARTS[nPart])
             -- tra le calcolate, sceglie la migliore
-            PROCESSINGS[nPart].Rotation[nIndex] = GetBestStrategy( PROCESSINGS[nPart].Rotation[nIndex], PARTS[nPart])
+            PROCESSINGS[nPart].Rotation[nIndex] = GetBestStrategyFromProcList( PROCESSINGS[nPart].Rotation[nIndex], PARTS[nPart])
             -- rotazione pezzo di 90° per volta
             BeamLib.RotateRawPart( PARTS[nPart], 1)
             -- aggiorno info pezzo
             PARTS[nPart].b3Raw = EgtGetRawPartBBox( PARTS[nPart].idRaw)
-            PARTS[nPart].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[nPart].id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+            PARTS[nPart].b3Part = EgtGetBBoxGlob( PARTS[nPart].idBoxTm, GDB_BB.STANDARD)
          end
-         if bCalcBestPieceUnloadPosition then
+         if bCalcBestPieceUnloadPosition and PARTS[nPart].GeneralParameters.GEN_sPiecesLoadingPosition ~= 'BTL_POSITION' then
             -- inversione del pezzo testa-coda
             BeamLib.InvertRawPart( PARTS[nPart], 2)
             -- aggiorno info pezzo
             PARTS[nPart].b3Raw = EgtGetRawPartBBox( PARTS[nPart].idRaw)
-            PARTS[nPart].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[nPart].id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+            PARTS[nPart].b3Part = EgtGetBBoxGlob( PARTS[nPart].idBoxTm, GDB_BB.STANDARD)
          end
       end
    end
@@ -1562,210 +1591,219 @@ function BeamExec.ProcessMachinings( PARTS)
    local nTotErr = 0
    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
-
+   local nMaxReProcessCycles = EgtClamp( GENERAL_PARAMETERS.PROJECT.GEN_nMaxReProcessCycles, 1, 3)
+   local bTryToReProcess = false
 
    -- ricerca strategia di lavorazione per ogni pezzo e applicazione lavorazioni
    for nPart = 1, #PARTS do
+      local nCycles = 1
 
-      -- scrittura nel log del risultato della scelta della strategia migliore tra quelle disponibili
-      if EgtGetDebugLevel() >= 3 then
-         Logs.WriteFeaturesLog( PROCESSINGS[nPart], PARTS[nPart])
-      end
-
-      local bAllStrategiesApplied = false
-
-      -- si ricavano tutte le combinazioni possibili
-      local CombinationListFromMatrix = GetCombinationListFromMatrix( PROCESSINGS[nPart], PARTS[nPart])
-      -- ci deve essere almeno una combinazione, altrimenti errore
-      if #CombinationListFromMatrix < 1 then
-         error( 'UNEXPECTED ERROR: NO combinations available')
-      end
-
-      -- scelta delal migliore combinazione
-      local BestCombination = GetBestCombination( CombinationListFromMatrix, PARTS[nPart])
-      PARTS[nPart].ChosenCombination = BestCombination.sBitIndexCombination
-      PARTS[nPart].bPartInCombiIsInverted = BestCombination.bPartInCombiIsInverted
-
-      -- scrittura nel log delle combinazioni possibili
-      if EgtGetDebugLevel() >= 3 then
-         Logs.WriteCombinationLog( CombinationListFromMatrix, BestCombination)
-      end
-
-      -- compilazione della vProc finale contenente le feature da lavorare nella giusta rotazione
-      local vProc, MatrixResult = GetProcessingListFromCombination( BestCombination)
-
-
-      -- si mette subito il pezzo nella fase
-      if nOrd == 1 then
-         EgtSetCurrPhase( 1)
-      else
-         BeamLib.AddPhaseWithRawParts( PARTS[nPart].idRaw, BeamData.ptOriXR, BeamData.dPosXR, 0)
-      end
-      -- si sposta il pezzo nella posizione originale, di quando è stata fatta la collect. In questo modo tutti i dati calcolati nella collect restano validi.
-      -- Altrimenti bisognava ricalcolare tutto, aumentando tempo di calcolo.
-      local vtRawOffsetPos = PARTS[nPart].b3Raw:getMin() - EgtGetRawPartBBox( PARTS[nPart].idRaw):getMin()
-      local nRawId = PARTS[nPart].idRaw
-      while nRawId and abs( vtRawOffsetPos:len()) > 0 do
-         EgtKeepRawPart( nRawId)
-         EgtMoveRawPart( nRawId, vtRawOffsetPos)
-         nRawId = EgtGetNextRawPart( nRawId)
-      end
-
-      -- se combinazione prevede inversione, si gira il pezzo
-      if PARTS[nPart].bPartInCombiIsInverted then
-         BeamLib.InvertRawPart( PARTS[nPart], 2)
-      end
-
-      -- debug
-      if EgtGetDebugLevel() >= 1 then
-         PrintFeatures( vProc, PARTS[nPart])
-      end
-      EgtOutLog( ' *** AddMachinings ***', 1)
-
-      -- se la posizione iniziale non è calcolata, significa che non ci sono feature da eseguire. Solo taglio testa/coda
-      if not MatrixResult.nInitialPosition then
-         MatrixResult.nInitialPosition = 1
-         MACHININGS.Info.nHeadCutRotation = 1
-         MACHININGS.Info.nSplitCutRotation = 1
-         -- anche se non ci sono feature da eseguire, bisogna comunque scrivrere i risultati
-         for nProc = 1, #vProc do
-            AddFeatureResultToGlobalList( vProc[nProc])
+      -- la parte di applicazione lavorazioni può essere lanciata più volte in caso della presenza di errori
+      local bProcess = true
+      while bProcess do
+         -- scrittura nel log del risultato della scelta della strategia migliore tra quelle disponibili
+         if EgtGetDebugLevel() >= 3 then
+            Logs.WriteFeaturesLog( PROCESSINGS[nPart], PARTS[nPart], nCycles)
          end
-      -- altrimenti si fanno tutti i calcoli
-      else
-         -- ordinamento di base delle feature
-         vProc = OrderFeatures( vProc)
 
-         -- esegue le strategie migliori che ha precedentemente scelto e salva le lavorazioni nella lista globale
-         bAllStrategiesApplied = false
-         MACHININGS, bAllStrategiesApplied = CalculateMachinings( vProc, PARTS[nPart], MatrixResult.nInitialPosition)
-         -- se non sono sono settate le rotazioni di lavorazione di testa e coda, significa che le feature da eseguire non sono state eseguite per qualche problema. Si forza rotazione 1
-         if not MACHININGS.Info.nHeadCutRotation or not MACHININGS.Info.nSplitCutRotation then
+         -- si ricavano tutte le combinazioni possibili
+         local CombinationListFromMatrix = GetCombinationListFromMatrix( PROCESSINGS[nPart], PARTS[nPart], nCycles > 1)
+         -- ci deve essere almeno una combinazione, altrimenti errore
+         if #CombinationListFromMatrix < 1 then
+            error( 'UNEXPECTED ERROR: NO combinations available')
+         end
+
+         -- scelta della migliore combinazione
+         local BestCombination = GetBestCombination( CombinationListFromMatrix, PARTS[nPart])
+         PARTS[nPart].ChosenCombination = BestCombination.sBitIndexCombination
+         PARTS[nPart].bPartInCombiIsInverted = BestCombination.bPartInCombiIsInverted
+
+         -- scrittura nel log delle combinazioni possibili
+         if EgtGetDebugLevel() >= 3 then
+            Logs.WriteCombinationLog( CombinationListFromMatrix, BestCombination)
+         end
+
+         -- compilazione della vProc finale contenente le feature da lavorare nella giusta rotazione
+         local vProc, MatrixResult = GetProcessingListFromCombination( BestCombination)
+
+         -- si mette subito il pezzo nella fase
+         if nOrd == 1 then
+            EgtSetCurrPhase( 1)
+            local nPhase = EgtGetCurrPhase()
+            -- salvo info nuova fase aggiunta
+            local MachExtraInfo = { sType = 'DISP',
+                                    nPhase = nPhase}
+            table.insert( DB_MACH_APPLIED, MachExtraInfo)
+         else
+            BeamLib.AddPhaseWithRawParts( PARTS[nPart].idRaw, BeamData.ptOriXR, BeamData.dPosXR, 0)
+         end
+         -- si sposta il pezzo nella posizione originale, di quando è stata fatta la collect. In questo modo tutti i dati calcolati nella collect restano validi.
+         -- Altrimenti bisognava ricalcolare tutto, aumentando tempo di calcolo.
+         local vtRawOffsetPos = PARTS[nPart].b3Raw:getMin() - EgtGetRawPartBBox( PARTS[nPart].idRaw):getMin()
+         local nRawId = PARTS[nPart].idRaw
+         while nRawId and abs( vtRawOffsetPos:len()) > 0 do
+            EgtKeepRawPart( nRawId)
+            EgtMoveRawPart( nRawId, vtRawOffsetPos)
+            nRawId = EgtGetNextRawPart( nRawId)
+         end
+
+         -- se combinazione prevede inversione, si gira il pezzo
+         if PARTS[nPart].bPartInCombiIsInverted then
+            BeamLib.InvertRawPart( PARTS[nPart], 2)
+         end
+
+         -- debug
+         if EgtGetDebugLevel() >= 1 then
+            PrintFeatures( vProc, PARTS[nPart])
+         end
+         EgtOutLog( ' *** AddMachinings ***', 1)
+
+         -- se la posizione iniziale non è calcolata, significa che non ci sono feature da eseguire. Solo taglio testa/coda
+         if not MatrixResult.nInitialPosition then
+            MatrixResult.nInitialPosition = 1
             MACHININGS.Info.nHeadCutRotation = 1
             MACHININGS.Info.nSplitCutRotation = 1
-         end
-      end
-      -- salvo sul PART la posizione di partenza che è stata scelta
-      PARTS[nPart].nInitialPosition = MatrixResult.nInitialPosition
-
-      local nOffsetIndex = EgtIf( PARTS[nPart].bPartInCombiIsInverted, 4, 0)
-      -- aggiunge tagli testa e coda in fasi opportune
-      local nRotHeadCut = MatrixResult.nInitialPosition + MACHININGS.Info.nHeadCutRotation - 1
-      if nRotHeadCut > 4 then
-         nRotHeadCut = nRotHeadCut - 4
-      end
-      nRotHeadCut = nRotHeadCut + nOffsetIndex
-      local nRotSplitCut = MatrixResult.nInitialPosition + MACHININGS.Info.nSplitCutRotation - 1
-      if nRotSplitCut > 4 then
-         nRotSplitCut = nRotSplitCut - 4
-      end
-      nRotSplitCut = nRotSplitCut + nOffsetIndex
-      -- setto nella Proc l'indice rotazione nella quale deve essere lavorata
-      PROCESSINGS[nPart].Rotation[nRotHeadCut][MatrixResult.nIndexHeadCutInVProc].nIndexRotation = nRotHeadCut
-      PROCESSINGS[nPart].Rotation[nRotSplitCut][MatrixResult.nIndexTailCutInVProc].nIndexRotation = nRotSplitCut
-
-      -- 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])
-
-      bAllStrategiesApplied = false
-      MACHININGS, bAllStrategiesApplied = CalculateMachinings( vProcHeadTail, PARTS[nPart], MatrixResult.nInitialPosition)
-
-      -- cancellazione entità create ma non usate
-      -- TODO funzione?
-      local idAddGroup = BeamLib.GetAddGroup( PARTS[nPart].id)
-      local idCurrentEntity = EgtGetFirstInGroup( idAddGroup or GDB_ID.NULL)
-      while idCurrentEntity do
-         if EgtGetLevel( idCurrentEntity) == GDB_LV.TEMP then
-            local idEntityToDelete = idCurrentEntity
-            idCurrentEntity = EgtGetNext( idCurrentEntity)
-            EgtErase( idEntityToDelete)
+            -- anche se non ci sono feature da eseguire, bisogna comunque scrivrere i risultati
+            for nProc = 1, #vProc do
+               AddFeatureResultToGlobalList( vProc[nProc])
+            end
+         -- altrimenti si fanno tutti i calcoli
          else
-            idCurrentEntity = EgtGetNext( idCurrentEntity)
+            -- TODO serve ancora ordinare le feature con nuovo metodo di calcolo ottimizzazione lavorazioni?
+            -- 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], MatrixResult.nInitialPosition)
+            -- se non sono sono settate le rotazioni di lavorazione di testa e coda, significa che le feature da eseguire non sono state eseguite per qualche problema. Si forza rotazione 1
+            if not MACHININGS.Info.nHeadCutRotation or not MACHININGS.Info.nSplitCutRotation then
+               MACHININGS.Info.nHeadCutRotation = 1
+               MACHININGS.Info.nSplitCutRotation = 1
+            end
          end
-      end
+         -- salvo sul PART la posizione di partenza che è stata scelta
+         PARTS[nPart].nInitialPosition = MatrixResult.nInitialPosition
 
-      -- ordinamento lavorazioni
-      -- TODO completare ordinamento. Mancano le dipendenze.
-      -- TODO la FinalizeSorting andrebbe rimossa e usato un sorting che non viola le dipendenze
-      MACHININGS = MachiningLib.PrepareMachiningsForSorting( PARTS[nPart])
-      MACHININGS = BeamLib.StableSort( MACHININGS, MachiningLib.CompareMachinings)
-      MACHININGS = MachiningLib.FinalizeSorting()
+         local nOffsetIndex = EgtIf( PARTS[nPart].bPartInCombiIsInverted, 4, 0)
+         -- aggiunge tagli testa e coda in fasi opportune
+         local nRotHeadCut = MatrixResult.nInitialPosition + MACHININGS.Info.nHeadCutRotation - 1
+         if nRotHeadCut > 4 then
+            nRotHeadCut = nRotHeadCut - 4
+         end
+         nRotHeadCut = nRotHeadCut + nOffsetIndex
+         local nRotSplitCut = MatrixResult.nInitialPosition + MACHININGS.Info.nSplitCutRotation - 1
+         if nRotSplitCut > 4 then
+            nRotSplitCut = nRotSplitCut - 4
+         end
+         nRotSplitCut = nRotSplitCut + nOffsetIndex
+         -- setto nella Proc l'indice rotazione nella quale deve essere lavorata
+         PROCESSINGS[nPart].Rotation[nRotHeadCut][MatrixResult.nIndexHeadCutInVProc].nIndexRotation = nRotHeadCut
+         PROCESSINGS[nPart].Rotation[nRotSplitCut][MatrixResult.nIndexTailCutInVProc].nIndexRotation = nRotSplitCut
 
-      -- finiti i calcoli di applicazione delle lavorazioni, si riporta il pezzo nello zero della fase
-      nRawId = PARTS[nPart].idRaw
-      while nRawId and abs( vtRawOffsetPos:len()) > 0 do
-         EgtKeepRawPart( nRawId)
-         EgtMoveRawPart( nRawId, -vtRawOffsetPos)
-         nRawId = EgtGetNextRawPart( nRawId)
-      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
+         else
+            PROCESSINGS[nPart].Rotation[nRotHeadCut][MatrixResult.nIndexHeadCutInVProc].bStd = 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
+         else
+            PROCESSINGS[nPart].Rotation[nRotSplitCut][MatrixResult.nIndexTailCutInVProc].bStd = true
+         end
 
-      local bAreAllMachiningApplyOk
-      local sErr
-      local bSplitAlreadyExecuted = false
-      local bSplitExecutedOnRot = false
-      local nPhase = EgtGetCurrPhase()
-      local idDisp = EgtGetPhaseDisposition( nPhase)
-      EgtSetInfo( idDisp, 'TYPE', 'START')
-      EgtSetInfo( idDisp, 'ORD', nOrd)
-      EgtOutLog( ' *** Phase=' .. tostring( nPhase) .. ' Raw=' .. tostring( PARTS[nPart].idRaw) .. ' Part=' .. tostring( PARTS[nPart].id) .. ' ***', 1)
+         local vProcHeadTail = {}
+         table.insert( vProcHeadTail, PROCESSINGS[nPart].Rotation[nRotHeadCut][MatrixResult.nIndexHeadCutInVProc])
+         table.insert( vProcHeadTail, PROCESSINGS[nPart].Rotation[nRotSplitCut][MatrixResult.nIndexTailCutInVProc])
 
-      -- creazione effettiva delle lavorazioni
-      MACHININGS.Info = {}
-      local nCurrPosition = 1
-      local nInitialPosition = MatrixResult.nInitialPosition
-      -- se c'è almeno una lavorazione in posizionamento con trave ribaltata
-      if MatrixResult.bSomeFeatureDown then
-         local nRotation = EgtIf( nInitialPosition + 2 > 4, nInitialPosition + 2 - 4, nInitialPosition + 2)
-         BeamLib.RotateRawPart( PARTS[nPart], nRotation - nCurrPosition)
-         nCurrPosition = nRotation
-         EgtSetInfo( idDisp, 'ROT', -2)
-         bAreAllMachiningApplyOk, sErr, bSplitExecutedOnRot = MachiningLib.AddOperations( MACHININGS, PARTS[nPart], 'DOWN')
-         bSplitAlreadyExecuted = bSplitAlreadyExecuted or bSplitExecutedOnRot
-      end
+         MACHININGS = CalculateMachinings( vProcHeadTail, PARTS[nPart], MatrixResult.nInitialPosition)
 
-      -- se c'è almeno una lavorazione in posizionamento con trave ruotata
-      if MatrixResult.bSomeFeatureSide then
-         -- se ci sono state lavorazioni in rotazione precedente devo creare altra fase. Altrimenti già creata da prima
+         -- si preparano le lavorazioni assegnandole al proprio stage
+         MACHININGS = MachiningLib.PrepareMachiningsForSorting( PARTS[nPart])
+
+      -- TODO queste funzioni andrebbero rimosse e utilizzato algoritmo di sorting dedicato
+      -- #### #### #### #### #### #### #### #### #### #### 
+         -- ordinamento lavorazioni per stage (N.B.: potrebbe compromettere ordine lavorazioni della feature, che non può essere cambiato)
+         MACHININGS = BeamLib.StableSort( MACHININGS, MachiningLib.CompareMachinings)
+         -- dopo il sorting bisogna riverificare che ordine delle lavorazioni della feature non sia compromesso
+         MACHININGS = MachiningLib.FinalizeSorting()
+      -- #### #### #### #### #### #### #### #### #### #### 
+
+         -- finiti i calcoli di applicazione delle lavorazioni, si riporta il pezzo nello zero della fase
+         nRawId = PARTS[nPart].idRaw
+         while nRawId and abs( vtRawOffsetPos:len()) > 0 do
+            EgtKeepRawPart( nRawId)
+            EgtMoveRawPart( nRawId, -vtRawOffsetPos)
+            nRawId = EgtGetNextRawPart( nRawId)
+         end
+
+         local bAreAllMachiningApplyOk
+         local sErr
+         local bSplitAlreadyExecuted = false
+         local bSplitExecutedOnRot = false
+         local nPhase = EgtGetCurrPhase()
+         local idDisp = EgtGetPhaseDisposition( nPhase)
+         EgtSetInfo( idDisp, 'TYPE', 'START')
+         EgtSetInfo( idDisp, 'ORD', nOrd)
+         EgtOutLog( ' *** Phase=' .. tostring( nPhase) .. ' Raw=' .. tostring( PARTS[nPart].idRaw) .. ' Part=' .. tostring( PARTS[nPart].id) .. ' ***', 1)
+
+         -- creazione effettiva delle lavorazioni
+         MACHININGS.Info = {}
+         local nCurrPosition = 1
+         local nInitialPosition = MatrixResult.nInitialPosition
+         -- se c'è almeno una lavorazione in posizionamento con trave ribaltata
          if MatrixResult.bSomeFeatureDown then
+            local nRotation = EgtIf( nInitialPosition + 2 > 4, nInitialPosition + 2 - 4, nInitialPosition + 2)
+            BeamLib.RotateRawPart( PARTS[nPart], nRotation - nCurrPosition)
+            nCurrPosition = nRotation
+            EgtSetInfo( idDisp, 'ROT', -2)
+            bAreAllMachiningApplyOk, sErr, bSplitExecutedOnRot, bTryToReProcess = MachiningLib.AddOperations( MACHININGS, PARTS[nPart], 'DOWN')
+            bSplitAlreadyExecuted = bSplitAlreadyExecuted or bSplitExecutedOnRot
+            bProcess = bProcess or bTryToReProcess
+         end
+
+         -- se c'è almeno una lavorazione in posizionamento con trave ruotata
+         if MatrixResult.bSomeFeatureSide then
+            -- se ci sono state lavorazioni in rotazione precedente devo creare altra fase. Altrimenti già creata da prima
+            if MatrixResult.bSomeFeatureDown then
+               BeamLib.AddPhaseWithRawParts( PARTS[nPart].idRaw, BeamData.ptOriXR, BeamData.dPosXR, EgtIf( bSplitAlreadyExecuted, BeamData.RAW_OFFSET, 0))
+               nPhase = EgtGetCurrPhase()
+               idDisp = EgtGetPhaseDisposition( nPhase)
+               EgtSetInfo( idDisp, 'ORD', nOrd)
+               -- se c'è già stata separazione
+               if bSplitAlreadyExecuted then
+                  EgtSetInfo( idDisp, 'TYPE', 'MID2')
+               else
+                  EgtSetInfo( idDisp, 'TYPE', 'MID')
+               end
+               -- se combinazione prevede inversione, si gira il pezzo
+               if PARTS[nPart].bPartInCombiIsInverted and not PARTS[nPart].bIsInverted then
+                  BeamLib.InvertRawPart( PARTS[nPart], 2)
+               end
+            end
+            local nRotation = EgtIf( nInitialPosition + 1 > 4, nInitialPosition + 1 - 4, nInitialPosition + 1)
+            BeamLib.RotateRawPart( PARTS[nPart], nRotation - nCurrPosition)
+            nCurrPosition = nRotation
+            EgtSetInfo( idDisp, 'ROT', -1)
+            bAreAllMachiningApplyOk, sErr, bSplitExecutedOnRot, bTryToReProcess = MachiningLib.AddOperations( MACHININGS, PARTS[nPart], 'SIDE')
+            bSplitAlreadyExecuted = bSplitAlreadyExecuted or bSplitExecutedOnRot
+            bProcess = bProcess or bTryToReProcess
+         end
+
+         -- se ci sono state lavorazioni in rotazione precedente devo creare altra fase. Altrimenti già creata da prima
+         if MatrixResult.bSomeFeatureDown or MatrixResult.bSomeFeatureSide then
             BeamLib.AddPhaseWithRawParts( PARTS[nPart].idRaw, BeamData.ptOriXR, BeamData.dPosXR, EgtIf( bSplitAlreadyExecuted, BeamData.RAW_OFFSET, 0))
             nPhase = EgtGetCurrPhase()
             idDisp = EgtGetPhaseDisposition( nPhase)
             EgtSetInfo( idDisp, 'ORD', nOrd)
             -- se c'è già stata separazione
             if bSplitAlreadyExecuted then
-               EgtSetInfo( idDisp, 'TYPE', 'MID2')
+               EgtSetInfo( idDisp, 'TYPE', 'END2')
             else
                EgtSetInfo( idDisp, 'TYPE', 'MID')
             end
@@ -1774,40 +1812,42 @@ function BeamExec.ProcessMachinings( PARTS)
                BeamLib.InvertRawPart( PARTS[nPart], 2)
             end
          end
-         local nRotation = EgtIf( nInitialPosition + 1 > 4, nInitialPosition + 1 - 4, nInitialPosition + 1)
-         BeamLib.RotateRawPart( PARTS[nPart], nRotation - nCurrPosition)
-         nCurrPosition = nRotation
-         EgtSetInfo( idDisp, 'ROT', -1)
-         bAreAllMachiningApplyOk, sErr, bSplitExecutedOnRot = MachiningLib.AddOperations( MACHININGS, PARTS[nPart], 'SIDE')
-         bSplitAlreadyExecuted = bSplitAlreadyExecuted or bSplitExecutedOnRot
-      end
 
-      -- se ci sono state lavorazioni in rotazione precedente devo creare altra fase. Altrimenti già creata da prima
-      if MatrixResult.bSomeFeatureDown or MatrixResult.bSomeFeatureSide then
-         BeamLib.AddPhaseWithRawParts( PARTS[nPart].idRaw, BeamData.ptOriXR, BeamData.dPosXR, EgtIf( bSplitAlreadyExecuted, BeamData.RAW_OFFSET, 0))
-         nPhase = EgtGetCurrPhase()
-         idDisp = EgtGetPhaseDisposition( nPhase)
-         EgtSetInfo( idDisp, 'ORD', nOrd)
-         -- se c'è già stata separazione
-         if bSplitAlreadyExecuted then
-            EgtSetInfo( idDisp, 'TYPE', 'END2')
+         BeamLib.RotateRawPart( PARTS[nPart], nInitialPosition - 1)
+
+         -- aggiunta lavorazioni in ultima fase
+         _, _, _, bTryToReProcess = MachiningLib.AddOperations( MACHININGS, PARTS[nPart], 'STD')
+         bProcess = bProcess or bTryToReProcess
+
+         -- se bisogna riprocessare, si annulla tutto
+         nCycles = nCycles + 1
+         if bProcess and nCycles <= nMaxReProcessCycles then
+            -- azzero liste
+            MACHININGS = {}
+            DB_MACH_APPLIED = {}
+            MACHININGS.Info = {}
+            RESULT = {}
+            EgtRemoveAllOperations()
+            -- se combinazione prevedeva inversione, si rigira il pezzo
+            if PARTS[nPart].bPartInCombiIsInverted then
+               BeamLib.InvertRawPart( PARTS[nPart], -2)
+            end
+            -- si ribalta il pezzo in posizione iniziale
+            BeamLib.RotateRawPart( PARTS[nPart], 1 - nInitialPosition)
          else
-            EgtSetInfo( idDisp, 'TYPE', 'MID')
-         end
-         -- se combinazione prevede inversione, si gira il pezzo
-         if PARTS[nPart].bPartInCombiIsInverted and not PARTS[nPart].bIsInverted then
-            BeamLib.InvertRawPart( PARTS[nPart], 2)
+            bProcess = false
          end
       end
 
-      BeamLib.RotateRawPart( PARTS[nPart], nInitialPosition - 1)
-
-      -- aggiunta lavorazioni in ultima fase
-      MachiningLib.AddOperations( MACHININGS, PARTS[nPart], 'STD')
+      -- ottimizzazione con algoritmo ShortestPath
+      TIMER:startElapsed( 'Sorting')
+      MachiningLib.ShortestPathSorting()
+      TIMER:stopElapsed( 'Sorting')
 
       EgtOutLog( ' *** End AddMachinings ***', 1)
       -- azzero lavorazioni per pezzo successivo
       MACHININGS = {}
+      DB_MACH_APPLIED = {}
       MACHININGS.Info = {}
       -- indice pezzo successivo
       nOrd = nOrd + 1
@@ -1837,7 +1877,7 @@ function BeamExec.ProcessMachinings( PARTS)
    -- TODO in caso di lavorazioni di coda saltate, l'informazione va restituita anche sulle singole feature
    if not bApplOk then
       nTotErr = nTotErr + 1
-      AddApplyResultToGlobalList( 1, 0, sApplErrors)
+      BeamExec.AddApplyResultToGlobalList( 1, 0, sApplErrors)
    elseif sApplWarns and #sApplWarns > 0 then
       local vLine = EgtSplitString( sApplWarns, '\r\n')
       for i = 1, #vLine do
@@ -1848,7 +1888,7 @@ function BeamExec.ProcessMachinings( PARTS)
             local nWarn = EgtGetVal( vVal[1] or '', 'WRN', 'i')
             local nCutId = EgtGetVal( vVal[2] or '', 'CUTID', 'i')
             if nWarn and nCutId then
-               AddApplyResultToGlobalList( -nWarn, nCutId, vLine[i])
+               BeamExec.AddApplyResultToGlobalList( -nWarn, nCutId, vLine[i])
             end
          end
       end

LuaLibs/BeamLib.lua

@@ -8,7 +8,7 @@ local BeamLib = {}
 
 -- Include
 require( 'EgtBase')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 
 
 EgtOutLog( ' BeamLib started', 1)
@@ -65,6 +65,64 @@ function BeamLib.AddPartEndFace( PartId, b3Solid)
    return true
 end
 
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.GetPartBoxWithHeadTail( Part, sSide)
+   local _sSide = sSide or ''
+
+   -- si può usare il box del grezzo che contiene sempre il sovramateriale di testa
+   if _sSide == 'Head' then
+
+      local b3WithHead = BBox3d( Part.b3Raw)
+      return b3WithHead
+
+   -- se è l'ultimo pezzo della barra si aggiunge il box dell'eventuale grezzo successivo
+   -- se non lo è, si estende il box del pezzo fino alla fine della barra
+   elseif _sSide == 'Tail' then
+
+      local b3WithTail = BBox3d( Part.b3Part)
+      if Part.bIsLastPart then
+         local nNextRawId = EgtGetNextRawPart( Part.idRaw)
+         if nNextRawId then
+            local b3Tail = EgtGetRawPartBBox( nNextRawId)
+            b3WithTail:Add( b3Tail)
+         end
+      else
+         -- per il punto di inizio barra si parte dal box del grezzo perchè contiene già il sovramateriale spessore lama/catena in coda (la restLength non lo comprende)
+         local ptXMin = Point3d( Part.b3Raw:getMin():getX() - Part.dRestLength, Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
+         b3WithTail:Add( ptXMin)
+      end
+
+      return b3WithTail
+
+   -- per aggiungere entrambi si procede come per la coda ma partendo dal box del grezzo, che già contiene la testa
+   elseif sSide == 'HeadTail' then
+
+      local b3WithHeadTail = BBox3d( Part.b3Raw)
+      if Part.bIsLastPart then
+         local nNextRawId = EgtGetNextRawPart( Part.idRaw)
+         if nNextRawId then
+            local b3Tail = EgtGetRawPartBBox( nNextRawId)
+            b3WithHeadTail:Add( b3Tail)
+         end
+      else
+         -- per il punto di inizio barra si parte dal box del grezzo perchè contiene già il sovramateriale spessore lama/catena in coda (la restLength non lo comprende)
+         local ptXMin = Point3d( Part.b3Raw:getMin():getX() - Part.dRestLength, Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
+         b3WithHeadTail:Add( ptXMin)
+      end
+
+      return b3WithHeadTail
+
+   -- sSide non definito, si restituisce il box del pezzo con l'aggiunta dello spessore lama/catena in coda
+   else
+      local b3WithSplit = BBox3d( Part.b3Part)
+      -- per il punto di inizio barra si parte dal box del grezzo perchè contiene già il sovramateriale spessore lama/catena in coda (la restLength non lo comprende)
+      local ptXMin = Point3d( Part.b3Raw:getMin():getX(), Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
+      b3WithSplit:Add( ptXMin)
+
+      return b3WithSplit
+   end
+end
+
 -------------------------------------------------------------------------------------------------------------
 function BeamLib.GetPartSplittingPoints( Part)
    local PartSplittingPoints = {}
@@ -104,7 +162,7 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 function BeamLib.AddPhaseWithRawParts( idRaw, OriXR, PosXR, dDeltaSucc)
-   EgtAddPhase()
+   local nPhase = EgtAddPhase()
    -- si aprono i limiti tavola per permettere rotazioni di pezzi più larghi della tavola
    EgtSetTableAreaOffset( 2000, 2000, 2000, 2000)
    local dRawMove = 0
@@ -116,6 +174,10 @@ function BeamLib.AddPhaseWithRawParts( idRaw, OriXR, PosXR, dDeltaSucc)
       dRawMove = dRawMove + EgtGetRawPartBBox( idRaw):getDimX()
       idRaw = EgtGetNextRawPart( idRaw)
    end
+   -- salvo info nuova fase aggiunta
+   local MachExtraInfo = { sType = 'DISP',
+                           nPhase = nPhase}
+   table.insert( DB_MACH_APPLIED, MachExtraInfo)
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -299,7 +361,9 @@ function BeamLib.CreateTempGroup()
    if not idTempGroup then
       idTempGroup = EgtGroup( GDB_ID.ROOT)
       EgtSetName( idTempGroup, "#TEMP_GROUP#")
+      EgtSetColor( idTempGroup, Color3d( 80, 160, 160, 1))
       EgtSetLevel( idTempGroup, GDB_LV.TEMP)
+      EgtSetStatus( idTempGroup, GDB_ST.OFF)
    end
    return idTempGroup
 end
@@ -424,6 +488,28 @@ function BeamLib.GetNearestParalOpposite( vtRef, vtNorm)
    return nil
 end
 
+-------------------------------------------------------------------------------------------------------------
+-- TODO gestire anche altri valori
+function BeamLib.GetDirectionFromSCC( nSCC)
+   local vtSCC
+
+   if nSCC == MCH_SCC.ADIR_XP then
+      vtSCC = X_AX()
+   elseif nSCC == MCH_SCC.ADIR_XM then
+      vtSCC = -X_AX()
+   elseif nSCC == MCH_SCC.ADIR_YP then
+      vtSCC = Y_AX()
+   elseif nSCC == MCH_SCC.ADIR_YM then
+      vtSCC = -Y_AX()
+   elseif nSCC == MCH_SCC.ADIR_ZP then
+      vtSCC = Z_AX()
+   elseif nSCC == MCH_SCC.ADIR_ZM then
+      vtSCC = -Z_AX()
+   end
+   
+   return vtSCC
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- Funzione per determinare se la faccia ha lati molto corti (trascurabili) ed è quindi approssimabile ad una 3 facce
 function BeamLib.Is3EdgesApprox( Proc, idFace, nAddGrpId)
@@ -502,7 +588,7 @@ function BeamLib.GetPieceGeneralParameters( Part, DefaultGeneralParamList)
       else
          if GENERAL_PARAMETERS.BTL and GENERAL_PARAMETERS.BTL[Part.sBTLInfo] and GENERAL_PARAMETERS.BTL[Part.sBTLInfo][DefaultGeneralParamList[i].sName] ~= nil then
             GeneralParameters[DefaultGeneralParamList[i].sName] = GENERAL_PARAMETERS.BTL[Part.sBTLInfo][DefaultGeneralParamList[i].sName]
-         elseif GENERAL_PARAMETERS.PROJECT[DefaultGeneralParamList[i].sName] then
+         elseif GENERAL_PARAMETERS.PROJECT[DefaultGeneralParamList[i].sName] ~= nil then
             GeneralParameters[DefaultGeneralParamList[i].sName] = GENERAL_PARAMETERS.PROJECT[DefaultGeneralParamList[i].sName]
          end
       end
@@ -593,18 +679,21 @@ function BeamLib.LoadGeneralParametersInList( DefaultGeneralParamList)
       for i = 1, #DefaultGeneralParamList do
          local sParamNameNGE = DefaultGeneralParamList[i].sNameNge
          local xParameterValue = EgtGetInfo( idProjectInfo, sParamNameNGE, 's') or DefaultGeneralParamList[i].sValue
-         -- salvataggio dato su lista con accesso diretto
-         if DefaultGeneralParamList[i].sType == 'b' then
-            UpdatedParameters.PROJECT[DefaultGeneralParamList[i].sName] = xParameterValue == 'true' or xParameterValue == '1' or xParameterValue == true
-         elseif DefaultGeneralParamList[i].sType == 'd' then
-            if #DefaultGeneralParamList[i].sValue > 0 then
-               UpdatedParameters.PROJECT[DefaultGeneralParamList[i].sName] = tonumber( xParameterValue)
-            -- stringa vuota equivale a non passare alcun valore (deciderà la strategia)
-            else
-               UpdatedParameters.PROJECT[DefaultGeneralParamList[i].sName] = nil
+         -- se parametro non trovato si salta tutto. N.B. = I parametri progetto non dovrebbero mai essere nil
+         if xParameterValue then
+            -- salvataggio dato su lista con accesso diretto
+            if DefaultGeneralParamList[i].sType == 'b' then
+               UpdatedParameters.PROJECT[DefaultGeneralParamList[i].sName] = xParameterValue == 'true' or xParameterValue == '1' or xParameterValue == true
+            elseif DefaultGeneralParamList[i].sType == 'd' then
+               if #DefaultGeneralParamList[i].sValue > 0 then
+                  UpdatedParameters.PROJECT[DefaultGeneralParamList[i].sName] = tonumber( xParameterValue)
+               -- stringa vuota equivale a non passare alcun valore (deciderà la strategia)
+               else
+                  UpdatedParameters.PROJECT[DefaultGeneralParamList[i].sName] = nil
+               end
+            else --DefaultGeneralParamList[i].sType == 's' or DefaultGeneralParamList[i].sType == 'combo'
+               UpdatedParameters.PROJECT[DefaultGeneralParamList[i].sName] = xParameterValue
             end
-         else --DefaultGeneralParamList[i].sType == 's' or DefaultGeneralParamList[i].sType == 'combo'
-            UpdatedParameters.PROJECT[DefaultGeneralParamList[i].sName] = xParameterValue
          end
       end
 
@@ -618,18 +707,21 @@ function BeamLib.LoadGeneralParametersInList( DefaultGeneralParamList)
             for i = 1, #DefaultGeneralParamList do
                local sParamNameNGE = DefaultGeneralParamList[i].sNameNge
                local xParameterValue = EgtGetInfo( BTLInfo[j], sParamNameNGE, 's')
-               -- salvataggio dato su lista con accesso diretto
-               if DefaultGeneralParamList[i].sType == 'b' then
-                  UpdatedParameters.BTL[BTLName][DefaultGeneralParamList[i].sName] = xParameterValue == 'true' or xParameterValue == '1' or xParameterValue == true
-               elseif DefaultGeneralParamList[i].sType == 'd' then
-                  if #DefaultGeneralParamList[i].sValue > 0 then
-                     UpdatedParameters.BTL[BTLName][DefaultGeneralParamList[i].sName] = tonumber( xParameterValue)
-                  -- stringa vuota equivale a non passare alcun valore (deciderà la strategia)
-                  else
-                     UpdatedParameters.BTL[BTLName][DefaultGeneralParamList[i].sName] = nil
+               -- se parametro non trovato si salta tutto
+               if xParameterValue then
+                  -- salvataggio dato su lista con accesso diretto
+                  if DefaultGeneralParamList[i].sType == 'b' then
+                     UpdatedParameters.BTL[BTLName][DefaultGeneralParamList[i].sName] = xParameterValue == 'true' or xParameterValue == '1' or xParameterValue == true
+                  elseif DefaultGeneralParamList[i].sType == 'd' then
+                     if #DefaultGeneralParamList[i].sValue > 0 then
+                        UpdatedParameters.BTL[BTLName][DefaultGeneralParamList[i].sName] = tonumber( xParameterValue)
+                     -- stringa vuota equivale a non passare alcun valore (deciderà la strategia)
+                     else
+                        UpdatedParameters.BTL[BTLName][DefaultGeneralParamList[i].sName] = nil
+                     end
+                  else --DefaultGeneralParamList[i].sType == 's' or DefaultGeneralParamList[i].sType == 'combo'
+                     UpdatedParameters.BTL[BTLName][DefaultGeneralParamList[i].sName] = xParameterValue
                   end
-               else --DefaultGeneralParamList[i].sType == 's' or DefaultGeneralParamList[i].sType == 'combo'
-                  UpdatedParameters.BTL[BTLName][DefaultGeneralParamList[i].sName] = xParameterValue
                end
             end
          end
@@ -852,7 +944,7 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 function BeamLib.GetStrategiesFromList( Proc, StrategyList)
-   -- cerco tra le feature 
+   -- cerco tra le feature
    for i = 1, #StrategyList.FEATURE do
       -- se trovo la feature
       if Proc.nPrc == StrategyList.FEATURE[i].nPrc then
@@ -870,16 +962,25 @@ function BeamLib.GetStrategiesFromList( Proc, StrategyList)
 
          -- si controlla gruppo
          if bGroupIsCompatible then
-            if #StrategyList.FEATURE[i].TopologyList == 1 and StrategyList.FEATURE[i].TopologyList[1].sName == 'Feature' then
-               return BeamLib.TableCopyDeep( StrategyList.FEATURE[i].TopologyList[1].StrategyList)
-            else
-               -- cerco tra le topologie
-               for j = 1, #StrategyList.FEATURE[i].TopologyList do
-                  -- se trovo la topologia
-                  if Proc.Topology.sName == StrategyList.FEATURE[i].TopologyList[j].sName then
-                     -- ritorno le strategie disponibili per la feature che sto analizzando
-                     return BeamLib.TableCopyDeep( StrategyList.FEATURE[i].TopologyList[j].StrategyList)
+            -- cerco tra le topologie
+            for j = 1, #StrategyList.FEATURE[i].TopologyList do
+               -- non si possono mischiare topologie specifiche con topologia 'Feature'. Se presente topologia 'Feature' allora deve essere esclusiva
+               if StrategyList.FEATURE[i].TopologyList[j].sName == 'Feature' and #StrategyList.FEATURE[i].TopologyList > 1 then
+                  error( "UNEXPECTED ERROR: topology 'Feature' can't be mixed with others")
+               end
+               -- se trovo la topologia oppure se è 'Feature'
+               if Proc.Topology.sName == StrategyList.FEATURE[i].TopologyList[j].sName or StrategyList.FEATURE[i].TopologyList[j].sName == 'Feature' then
+                  local ActiveStrategyList = {}
+                  -- aggiungo in lista solo le strategie attive
+                  if StrategyList.FEATURE[i].TopologyList[j].StrategyList then
+                     for k = 1, #StrategyList.FEATURE[i].TopologyList[j].StrategyList do
+                        if ( not StrategyList.FEATURE[i].TopologyList[j].StrategyList[k].nIndexInList) or ( StrategyList.FEATURE[i].TopologyList[j].StrategyList[k].nIndexInList) >= 0 then
+                           table.insert( ActiveStrategyList, BeamLib.TableCopyDeep( StrategyList.FEATURE[i].TopologyList[j].StrategyList[k]))
+                        end
+                     end
                   end
+                  -- ritorno le strategie disponibili per la feature che sto analizzando, altrimenti nil se non ho trovato nulla
+                  return EgtIf( #ActiveStrategyList > 0, ActiveStrategyList, nil)
                end
             end
          end

LuaLibs/DiceCut.lua

@@ -11,12 +11,12 @@ local BeamLib = require( 'BeamLib')
 EgtOutLog( ' DiceCut started', 1)
 
 -- Dati
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 
 ----------------------------------------------------------------------------------------------------------------------------------------------------
 -- creo i piani paralleli
 -- GetParallelPlanes: restituisce un vettore con gli indici delle superfici
---   nAddGrpId: il layer
+--   idAddGroup: il layer
 --   b3BoxDicing: il grezzo della barra
 --   ptC: il punto centrale del piano della feature
 --   vtN: il versore normale del piano della feature
@@ -30,7 +30,7 @@ local BeamData = require( 'BeamData')
 --   vtNCut*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
 --   ptCCut1*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
 --   vtNCut1*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
-local function GetParallelPlanes( nAddGrpId, b3BoxDicing, ptC, vtN, nCopyPlane, dOffset, nStep, Color, dTolerance, bNoTolOnFirstCut, ptCCut, vtNCut, ptCCut1, vtNCut1 )
+local function GetParallelPlanes( idAddGroup, b3BoxDicing, ptC, vtN, nCopyPlane, dOffset, nStep, Color, dTolerance, bNoTolOnFirstCut, ptCCut, vtNCut, ptCCut1, vtNCut1 )
    local ptMyCCut
    local AreaMin = 5*5
    if ptCCut and vtNCut then
@@ -46,7 +46,7 @@ local function GetParallelPlanes( nAddGrpId, b3BoxDicing, ptC, vtN, nCopyPlane,
    local TabellaTmSurfParallel = {}   
    local i = nCopyPlane
    while i < nStep do
-      local SurfId = EgtSurfTmPlaneInBBox( nAddGrpId, ptC + ( i * dOffset) * vtN, vtN, b3BoxDicing, GDB_RT.GLOB) 
+      local SurfId = EgtSurfTmPlaneInBBox( idAddGroup, ptC + ( i * dOffset) * vtN, vtN, b3BoxDicing, GDB_RT.GLOB) 
       local nFacet = EgtSurfTmFacetCount( SurfId or GDB_ID.NULL)
       if nFacet == 0 then
          -- se sono al primo taglio do una possibilità in più di girare
@@ -86,11 +86,11 @@ end
 
 ----------------------------------------------------------------------------------------------------------------------------------------------------
 -- GetOrderedCutTable:
---   nAddGrpId: il layer 
+--   idAddGroup: il layer 
 --   TabParallelPlanes: tabella delle superfici dei piani paralleli
 --   TabOrtoPlanes: tabella delle superfici dei piani ortogonali
 -- stampo l'ordine dei piani di taglio (prima tagli ortogonali piu' esterni poi taglio parallelo collettivo)
-local function GetOrderedCutTable( nAddGrpId, TabParallelPlanes, TabOrtoPlanes)
+local function GetOrderedCutTable( idAddGroup, TabParallelPlanes, TabOrtoPlanes)
    local StepParallel = #TabParallelPlanes
    local StepOrto = #TabOrtoPlanes
    local TabellaOrderParallelCut1 = {}
@@ -99,8 +99,8 @@ local function GetOrderedCutTable( nAddGrpId, TabParallelPlanes, TabOrtoPlanes)
       TabellaOrderParallelCut1[IndexTmP] = {}
       for IndexOrto=1, StepOrto do
          local ptOrtoN, vtNOrtoN = EgtSurfTmFacetCenter( TabOrtoPlanes[IndexOrto ], 0, GDB_ID.ROOT)
-         local Copy1Id = EgtCopySurfTmFacet( TabParallelPlanes[IndexTmP], 0, nAddGrpId)
-         local Copy2Id = EgtCopySurfTmFacet( TabParallelPlanes[IndexTmP], 0, nAddGrpId)
+         local Copy1Id = EgtCopySurfTmFacet( TabParallelPlanes[IndexTmP], 0, idAddGroup)
+         local Copy2Id = EgtCopySurfTmFacet( TabParallelPlanes[IndexTmP], 0, idAddGroup)
          if Copy1Id and ptOrtoN then
             EgtCutSurfTmPlane( Copy1Id, ptOrtoN, -vtNOrtoN, false, GDB_RT.GLOB)
             EgtCutSurfTmPlane( Copy2Id, ptOrtoN, vtNOrtoN, false, GDB_RT.GLOB)
@@ -134,7 +134,7 @@ end
 --   vtO: il versore dei piani ortogonali 
 --   dOffsetEff: offset della distanza dal punto centrale
 -- Verifica se l'asse X del box costruito sopra la superficie è più grande di un certo offset 
-local function GetOrtoCutCenter( FacetId, ptC, vtN, vtO, dOffsetEff, dMinNzDownUp)
+local function GetOrtoCutCenter( FacetId, ptC, vtN, vtO, dOffsetEff)
    local FrameLocal = Frame3d( EgtSurfTmFacetCenter( FacetId, 0, GDB_ID.ROOT))
    EgtSetGridFrame(FrameLocal)
    local IdAuxLocal = EgtGroup(EgtGetParent( FacetId), FrameLocal)
@@ -156,7 +156,7 @@ local function GetOrtoCutCenter( FacetId, ptC, vtN, vtO, dOffsetEff, dMinNzDownU
    -- TODO si può eliminare questo test dato che vengono verificate già volume e dimensione del cubetto??
    local dMaxLen = BeamData.MAX_LEN_DICE or 600
    if dLen < dMaxLen and dWidth < dMaxLen and
-      ( dLen < dOffsetEff + 1.0 or dWidth < dOffsetEff + 1.0) and vtN:getZ() > dMinNzDownUp then
+      ( dLen < dOffsetEff + 1.0 or dWidth < dOffsetEff + 1.0) then
       return nil, nil, nil
    end
 
@@ -261,7 +261,7 @@ end
 --   dOffsetParallel: offset della distanza dal punto centrale
 --   b3BoxDicing: il grezzo della barra
 --   Verifica se l'asse X del box costruito sopra le 2 facce è più piccolo di un certo offset e quindi la faccia O è superflua 
-local function VerifyFirstOrthoCut( CutTable, dOffsetParallel, b3BoxDicing, dMinNzDownUp)
+local function VerifyFirstOrthoCut( CutTable, dOffsetParallel, b3BoxDicing)
 
    if not CutTable[1] or not CutTable[2] then return end
 
@@ -294,9 +294,9 @@ local function VerifyFirstOrthoCut( CutTable, dOffsetParallel, b3BoxDicing, dMin
       -- lunghezza totale faccia
       local dLongSize = x1 + x2
       -- se faccia piccola e non orientata verso il basso, elimino ortogonale e unisco le due parti
-      if dLongSize <= dOffsetParallel + 1.0 and vtN1:getZ() > dMinNzDownUp then
-         local nAddGrpId = EgtGetParent( Cut1Id)
-         local SurfId = EgtSurfTmBySewing( nAddGrpId, { Cut1Id, Cut2Id})
+      if dLongSize <= dOffsetParallel + 1.0 then
+         local idAddGroup = EgtGetParent( Cut1Id)
+         local SurfId = EgtSurfTmBySewing( idAddGroup, { Cut1Id, Cut2Id})
          --EgtSetColor( SurfId, Color3d( FUCHSIA(), 60))
          EgtErase( CutOId)
          table.remove( CutTable[1], 1)
@@ -338,7 +338,7 @@ end
 ----------------------------------------------------------------------------------------------------------------------------------------------------
 -- ricavo l'altezza del BoundingBox assegnati gli estremi del grezzo e la feature
 -- le funzioni commentate permettono di vedere la creazione di BoundingBox
-local function DistanzaMassima( nAddGrpId, ptC1, vtN1, ptC2, vtN2, b3BoxDicing, TPoint)
+local function DistanzaMassima( idAddGroup, ptC1, vtN1, ptC2, vtN2, b3BoxDicing, TPoint)
    -- calcolo il riferimento nel piano 1
    local Frame1 = Frame3d( ptC1, vtN1)
    -- determino l'ingombro in questo riferimento della parte di trave compresa nel o nei piani
@@ -353,7 +353,7 @@ local function DistanzaMassima( nAddGrpId, ptC1, vtN1, ptC2, vtN2, b3BoxDicing,
    end
    -- eventuale altra faccia
    if ptC2 and vtN2 then
-      local IdAux = EgtGroup( nAddGrpId)
+      local IdAux = EgtGroup( idAddGroup)
       local IdSurf2 = EgtSurfTmPlaneInBBox( IdAux, ptC2, vtN2, b3BoxDicing, GDB_RT.GLOB)
       EgtCutSurfTmPlane( IdSurf2, ptC1, -vtN1, false, GDB_RT.GLOB)
       if IdSurf2 then
@@ -394,7 +394,12 @@ end
 ---------------------------------------------------------------------------------------------------------------
 function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
    -- gruppo per geometria addizionale
-   local nAddGrpId = BeamLib.GetAddGroup( Part.id)
+   local idAddGroup
+   if OptionalParameters.bSaveAddedGeometries then
+      idAddGroup = BeamLib.GetAddGroup( Part.id)
+   else
+      idAddGroup = Part.idTempGroup
+   end
 
    -- faccia primaria
    local ptCMainFace
@@ -422,16 +427,12 @@ function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
    local dOffsetParallel = OptionalParameters.dOffsetParallel or BeamData.MAX_DIM_DICE
    -- distanza tra piani ortogonali
    local dOffsetOrthogonal = OptionalParameters.dOffsetOrthogonal or BeamData.MAX_DIM_DICE
-   -- distanza ridotta tra piani ortogonali - usato in tagli orizzontali con affondamento verticale
-   local dOffsetOrthogonalReduced = OptionalParameters.dOffsetOrthogonalReduced or BeamData.MAX_DIM_HTCUT
    -- numero massimo piani paralleli
    local nStepParallel = OptionalParameters.nStepParallel or 100
    -- numero massimo piani perpendicolari
    local nStepOrthogonal = OptionalParameters.nStepOrthogonal or 100
    -- distanza tra piani paralleli e piani di taglio (era sempre 0, serve???)
    local dTolerance = OptionalParameters.dTolerance or 0
-   -- inclinazione limite per taglio da sotto
-   local dMinNzDownUp = OptionalParameters.dMinNzDownUp or -2
 
    --Ricavo le altezze dei BoundingBox contenente feature e estremi del grezzo
    local TBoxPoint = CalcolaPuntiEstremiBox( b3BoxDicing)
@@ -439,18 +440,12 @@ function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
    if ptCSubordinateFace and vtNSubordinateFace then
       TBoxPoint = VerificaEstremiGrezzo( ptCSubordinateFace, vtNSubordinateFace, TBoxPoint)
    end
-   local dElevP = DistanzaMassima( nAddGrpId, ptCMainFace, vtNMainFace, ptCSubordinateFace, vtNSubordinateFace, b3BoxDicing, TBoxPoint)
+   local dElevP = DistanzaMassima( idAddGroup, ptCMainFace, vtNMainFace, ptCSubordinateFace, vtNSubordinateFace, b3BoxDicing, TBoxPoint)
    local dElevO
    if ptCSubordinateFace and vtNSubordinateFace and not AreOppositeVectorApprox( vtNSubordinateFace, vtNMainFace) then
-      dElevO = DistanzaMassima( nAddGrpId, ptCSubordinateFace, vtNSubordinateFace, ptCMainFace, vtNMainFace, b3BoxDicing, TBoxPoint)
+      dElevO = DistanzaMassima( idAddGroup, ptCSubordinateFace, vtNSubordinateFace, ptCMainFace, vtNMainFace, b3BoxDicing, TBoxPoint)
    end
 
-   -- TODO parte sotto da aggiungere???? se sì va passata anche la dimensione cubetto ridotta dOffsetOrthogonalReduced
-   -- se non c'è testa da sotto e normali senza componenti in Y con faccia quasi verticale e trave non alta, uso per offset i limiti dei tagli di testa e coda
-   -- if not BD.TURN and not BD.DOWN_HEAD and abs( vtNPlanes:getY()) < 0.1 and vtNPlanes:getZ() < 0.7071 and ( not vtNBond or abs( vtNBond:getY()) < 0.1) and BBoxRawPart:getDimZ() < BD.MIN_DIM_HBEAM then
-   --    dOffsetOrthogonal = dOffsetOrthogonalReduced
-   -- end
-
    -- aggiungo piccolo extra agli offset
    dOffsetParallel = dOffsetParallel + 10 * GEO.EPS_SMALL
    dOffsetOrthogonal = dOffsetOrthogonal + 10 * GEO.EPS_SMALL
@@ -476,7 +471,7 @@ function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
 
    -- PIANI PARALLELI alla faccia di taglio 
    local TabellaTmSurfP = {}
-   local TabFromIn = GetParallelPlanes( nAddGrpId, b3BoxDicing, ptCMainFace, vtNMainFace, 0, dOffsetParallel, nStepParallel, Color3d( FUCHSIA(), 60), dTolerance, true, ptCSubordinateFace, vtNSubordinateFace)
+   local TabFromIn = GetParallelPlanes( idAddGroup, b3BoxDicing, ptCMainFace, vtNMainFace, 0, dOffsetParallel, nStepParallel, Color3d( FUCHSIA(), 60), dTolerance, true, ptCSubordinateFace, vtNSubordinateFace)
    for i = #TabFromIn, 1, -1 do
       table.insert( TabellaTmSurfP, TabFromIn[i])
    end
@@ -485,12 +480,12 @@ function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
    -- orientamento definito da seconda faccia
    if not bGetOrtoPlanes then
       local TabellaTmSurfOrto = {}
-      local TabFromIn = GetParallelPlanes( nAddGrpId, b3BoxDicing, ptCSubordinateFace, vtNSubordinateFace, 0, dOffsetOrthogonal, nStepOrthogonal, Color3d( GREEN(), 60), dTolerance, false, ptCMainFace, vtNMainFace)
+      local TabFromIn = GetParallelPlanes( idAddGroup, b3BoxDicing, ptCSubordinateFace, vtNSubordinateFace, 0, dOffsetOrthogonal, nStepOrthogonal, Color3d( GREEN(), 60), dTolerance, false, ptCMainFace, vtNMainFace)
       for i = #TabFromIn, 1, -1 do
          table.insert( TabellaTmSurfOrto, TabFromIn[i])
       end
-      local TabellaOrderParallelCut = GetOrderedCutTable( nAddGrpId, TabellaTmSurfP, TabellaTmSurfOrto)   -- Ottiene la tabella dei tagli paralleli ordinati
-      local TabellaOrderOrtoCut = GetOrderedCutTable( nAddGrpId, TabellaTmSurfOrto, TabellaTmSurfP)       -- Ottiene la tabella dei tagli ortogonali da riordinare per strato 
+      local TabellaOrderParallelCut = GetOrderedCutTable( idAddGroup, TabellaTmSurfP, TabellaTmSurfOrto)   -- Ottiene la tabella dei tagli paralleli ordinati
+      local TabellaOrderOrtoCut = GetOrderedCutTable( idAddGroup, TabellaTmSurfOrto, TabellaTmSurfP)       -- Ottiene la tabella dei tagli ortogonali da riordinare per strato 
 
       TabGREEN = SortOrtoCutsByNormalMethod( TabellaOrderParallelCut, TabellaOrderOrtoCut)              -- I tagli ortogonali vengono ordinati per strato  
       TabFUCHSIA = TabellaOrderParallelCut                                                              -- I tagli paralleli sono già ordinati
@@ -508,10 +503,10 @@ function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
          end
          -- calcolo la direzione dei piani ortogonali
          local vtO = VectorFromUprightOrtho( vtNInner)
-         if vtNInner:getZ() > -0.0175 or vtNInner:getZ() < dMinNzDownUp or abs( vtNInner:getY()) > 0.8 then
+         if vtNInner:getZ() > -0.0175 or abs( vtNInner:getY()) > 0.8 then
             vtO:rotate( vtNInner, 90)
             -- se diretto troppo ortogonalmente all'asse trave e taglio non da sotto, lo ruoto ulteriormente
-            if ( abs( vtO:getY()) > 4 * abs( vtO:getX()) or b3BoxDicing:getDimZ() > 620) and vtNInner:getZ() > dMinNzDownUp then
+            if ( abs( vtO:getY()) > 4 * abs( vtO:getX()) or b3BoxDicing:getDimZ() > 620) then
                vtO:rotate( vtNInner, 90)
                -- se faccia principale verso il basso (almeno -3deg), lo inverto per iniziare da sopra
                if vtNInner:getZ() < -0.05 then
@@ -533,16 +528,16 @@ function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
          --   CopyPlane: 0 => crea la prima faccia direttamente sul punto passato
          --   CopyPlane: 1 => crea la prima faccia e tutte le altre con l'offset passato
          --   CopyPlane: 0.5 => crea la prima faccia a metà offset e tutte le altre con l'offest intero
-         local OffsetRel, CopyPlane, dCenOffs, ptCStart = GetOrtoCutCenter( TabellaTmSurfP[PlnInd], ptCInner, vtNInner, vtO, dOffsetOrthogonal, dMinNzDownUp)
+         local OffsetRel, CopyPlane, dCenOffs, ptCStart = GetOrtoCutCenter( TabellaTmSurfP[PlnInd], ptCInner, vtNInner, vtO, dOffsetOrthogonal)
 
          if OffsetRel and CopyPlane and dCenOffs then
             ptCInner = ptCInner + dCenOffs * vtO
-            local TabRight = GetParallelPlanes( nAddGrpId, b3BoxDicing, ptCStart, vtO, CopyPlane, -OffsetRel, nStepOrthogonal, Color3d( GREEN(), 60),
+            local TabRight = GetParallelPlanes( idAddGroup, b3BoxDicing, ptCStart, vtO, CopyPlane, -OffsetRel, nStepOrthogonal, Color3d( GREEN(), 60),
                                                 dTolerance, false, ptCInner, vtNInner, ptCOuter, vtNOuter)
             if CopyPlane == 0 then
                CopyPlane = 1
             end
-            local TabLeft = GetParallelPlanes( nAddGrpId, b3BoxDicing, ptCStart, vtO, CopyPlane, OffsetRel, nStepOrthogonal, Color3d( GREEN(), 60),
+            local TabLeft = GetParallelPlanes( idAddGroup, b3BoxDicing, ptCStart, vtO, CopyPlane, OffsetRel, nStepOrthogonal, Color3d( GREEN(), 60),
                                                dTolerance, false, ptCInner, vtNInner, ptCOuter, vtNOuter)
             -- carico la tabella con gli indici riordinati
             local TempOrtoTab = {}
@@ -553,7 +548,7 @@ function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
                table.insert( TempOrtoTab, TabRight[i])
             end   
             -- creo una tabella per ogni piano per generare i tagli sulla Inner
-            local TempParTab = GetOrderedCutTable( nAddGrpId, {TabellaTmSurfP[PlnInd]}, TempOrtoTab)
+            local TempParTab = GetOrderedCutTable( idAddGroup, {TabellaTmSurfP[PlnInd]}, TempOrtoTab)
             for i = 1, #TempParTab do
                table.insert( TabFUCHSIA, TempParTab[i])
             end
@@ -582,7 +577,7 @@ function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
 
    -- Se esiste la superficie limitante (nFacet == 2) verifica se il taglio più esterno è superfluo e quindi viene eliminato
    if not bGetOrtoPlanes then
-      VerifyFirstOrthoCut( UltimateTable, dOffsetParallelOriginal, b3BoxDicing, dMinNzDownUp)
+      VerifyFirstOrthoCut( UltimateTable, dOffsetParallelOriginal, b3BoxDicing)
       -- se rimangono due sole facce, devono coincidere con le originali e quindi sono superflue
       if #UltimateTable == 2 and #UltimateTable[1] == 1 and #UltimateTable[2] == 1 then
          EgtErase( UltimateTable[1][1])

LuaLibs/FaceData.lua

@@ -136,9 +136,19 @@ function FaceData.GetEdgesInfo( ProcOrId, idFace )
       end
       CurrentEdge.bIsStartOpen = EdgesEgt[nPreviousEdgeIndex].Open
       CurrentEdge.bIsEndOpen = EdgesEgt[nNextEdgeIndex].Open
+      CurrentEdge.ptStart = Point3d( EdgesEgt[i].Start)
+      CurrentEdge.ptEnd = Point3d( EdgesEgt[nNextEdgeIndex].Start)
+      CurrentEdge.vtEdge = CurrentEdge.ptEnd - CurrentEdge.ptStart ; CurrentEdge.vtEdge:normalize()
       CurrentEdge.sType = 'Standard'
       CurrentEdge.id = i - 1
 
+      -- se nella Proc ci sono le adiacenze e il lato ha adiacenza, si salva l'angolo con la faccia adiacente
+      if Proc.AdjacencyMatrix then
+         if CurrentEdge.idAdjacentFace > -1 then
+            CurrentEdge.dAdjacencyAngle = Proc.AdjacencyMatrix[idFace + 1][CurrentEdge.idAdjacentFace + 1]
+         end
+      end
+
       table.insert( Edges, CurrentEdge)
    end
 
@@ -147,7 +157,6 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 function FaceData.GetFacesInfo( Proc, Part, FacesToGet)
-   EgtOutLog( '---Faces START---')
    local Faces = {}
 
    local function FaceIsToGet( nIndex)
@@ -175,10 +184,11 @@ function FaceData.GetFacesInfo( Proc, Part, FacesToGet)
    for i = 1, Proc.nFct do
       Faces[i] = {}
       Faces[i].id = i - 1
+      Faces[i].idTrimesh = Proc.id
       Faces[i].ptCenter, Faces[i].vtN =  EgtSurfTmFacetCenter( Proc.id, i - 1, GDB_ID.ROOT)
       if Proc.nFct < 6  or FaceIsToGet( i) then
          -- frame OCS faccia
-         Faces[i].vtFrameHV = Frame3d( Faces[i].ptCenter, Faces[i].vtN)
+         Faces[i].frFrameHV = Frame3d( Faces[i].ptCenter, Faces[i].vtN)
          -- elevazione calcolata rispetto al box della parte
          Faces[i].dElevation = EgtSurfTmFacetElevationInBBox( Proc.id, i - 1, Part.b3Part, true, GDB_ID.ROOT)
          -- TODO qui sarebbe meglio l'area vera e non quella del rettangolo minimo
@@ -186,78 +196,86 @@ function FaceData.GetFacesInfo( Proc, Part, FacesToGet)
          Faces[i].dArea = dShortDimension * dLongDimension
          Faces[i].dLMinRectangle = dLongDimension
          Faces[i].dWMinRectangle = dShortDimension
+         -- volume approssimato di materiale asportato lavorando questa faccia
+         Faces[i].dMachinedVolumeApprox = Faces[i].dArea * Faces[i].dElevation
 
          local nFaceType, Edges = FaceData.GetEdgesInfo( Proc, i - 1)
          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
 
 -------------------------------------------------------------------------------------------------------------
-function FaceData.IsFaceRectangular( Proc, idFace)
-   local nAddGrpId = BeamLib.GetAddGroup( Proc.idPart)
-   local nContourId, nContourCnt = EgtExtractSurfTmFacetLoops( Proc.id, idFace, nAddGrpId)
+function FaceData.IsFaceRectangle( Face)
+   -- recupero gruppo per geometrie temporanee
+   local idTempGroup = BeamLib.GetTempGroup()
+
+   local nContourId, nContourCnt = EgtExtractSurfTmFacetLoops( Face.idTrimesh, Face.id, idTempGroup)
    if nContourCnt > 1 then
-      error( 'IsFaceRectangular : too many loops')
+      error( 'IsFaceRectangle : too many loops')
    end
 
    local bIsRectangular = EgtCurveIsARectangle( nContourId)
 
-   -- elimino curve create
-   for i = 1, nContourCnt do
-      EgtErase( nContourId + i - 1)
-   end
-
    return bIsRectangular
 end
 
 -------------------------------------------------------------------------------------------------------------
-function FaceData.IsFaceRhomboid( Proc, idFace)
-   local nAddGrpId = BeamLib.GetAddGroup( Proc.idPart)
-   local nContourId, nContourCnt = EgtExtractSurfTmFacetLoops( Proc.id, idFace, nAddGrpId)
+function FaceData.IsFaceParallelogram( Face)
+   -- recupero gruppo per geometrie temporanee
+   local idTempGroup = BeamLib.GetTempGroup()
+
+   local nContourId, nContourCnt = EgtExtractSurfTmFacetLoops( Face.idTrimesh, Face.id, idTempGroup)
    if nContourCnt > 1 then
-      error( 'IsFaceRectangular : too many loops')
+      error( 'IsFaceParallelogram : too many loops')
    end
 
    local bIsTrapezoid = EgtCurveIsATrapezoid( nContourId)
    local bIsRhomboid = false
    -- un parallelogramma è un trapezoide con i lati paralleli a due a due
    if bIsTrapezoid
-      and AreOppositeVectorApprox( Proc.Faces[idFace + 1].Edges[1].vtN, Proc.Faces[idFace + 1].Edges[3].vtN)
-      and AreOppositeVectorApprox( Proc.Faces[idFace + 1].Edges[2].vtN, Proc.Faces[idFace + 1].Edges[4].vtN) then
+      and AreOppositeVectorApprox( Face.Edges[1].vtN, Face.Edges[3].vtN)
+      and AreOppositeVectorApprox( Face.Edges[2].vtN, Face.Edges[4].vtN) then
 
       bIsRhomboid = true
    end
 
-   -- elimino curve create
-   for i = 1, nContourCnt do
-      EgtErase( nContourId + i - 1)
-   end
-
    return bIsRhomboid
 end
 
+-------------------------------------------------------------------------------------------------------------
+local function CompareBottomFaces( FaceA, FaceB)
+   local dMaxVolumeRelativeChange = 0.15
+   -- si prende la faccia con volume lavorato maggiore
+   if FaceA.dMachinedVolumeApprox > ( 1 + dMaxVolumeRelativeChange) * FaceB.dMachinedVolumeApprox + 10 * GEO.EPS_SMALL then
+      return true
+   elseif FaceB.dMachinedVolumeApprox > ( 1 + dMaxVolumeRelativeChange) * FaceA.dMachinedVolumeApprox + 10 * GEO.EPS_SMALL then
+      return false
+   -- se volume lavorato simile, si prende la faccia con minore elevazione
+   else
+      if FaceA.dElevation < FaceB.dElevation - 10 * GEO.EPS_SMALL then
+         return true
+      elseif FaceB.dElevation < FaceA.dElevation - 10 * GEO.EPS_SMALL then
+         return false
+      else
+         return false
+      end
+   end
+end
+
 -------------------------------------------------------------------------------------------------------------
 local function CompareEdgesBottomFace( EdgeA, EdgeB)
    -- prima i lati con facce adiacenti
@@ -379,8 +397,8 @@ local function GetBottomFaces( Proc)
          end
          nCurrentFace = nCurrentFace + 1
       end
-      -- la BottomFace 1 è sempre quella con minor elevazione
-      table.sort( BottomFaces, function (a, b) return a.dElevation < b.dElevation end)
+      -- la BottomFace 1 è quella che permette di asportare il volume maggiore; nei casi ambigui si sceglie quella a minor elevazione
+      table.sort( BottomFaces, CompareBottomFaces)
    end
 
    if #BottomFaces == 0 then
@@ -429,6 +447,10 @@ local function GetBottomFaces( Proc)
       CurrentEdge.dElevation = BottomFaces[1].Edges[i].dElevation
       CurrentEdge.bIsStartOpen = BottomFaces[1].Edges[i].bIsStartOpen
       CurrentEdge.bIsEndOpen = BottomFaces[1].Edges[i].bIsEndOpen
+      CurrentEdge.ptStart = BottomFaces[1].Edges[i].ptStart
+      CurrentEdge.ptEnd = BottomFaces[1].Edges[i].ptEnd
+      CurrentEdge.vtEdge = BottomFaces[1].Edges[i].vtEdge
+      CurrentEdge.id = BottomFaces[1].Edges[i].id
 
       if nFirstLongEdgeIndex then
          if i == nFirstLongEdgeIndex then
@@ -524,6 +546,10 @@ local function GetLongFaces( Proc, MainFaces)
          CurrentEdge.dElevation = LongFaces[i].Edges[j].dElevation
          CurrentEdge.bIsStartOpen = LongFaces[i].Edges[j].bIsStartOpen
          CurrentEdge.bIsEndOpen = LongFaces[i].Edges[j].bIsEndOpen
+         CurrentEdge.ptStart = LongFaces[i].Edges[j].ptStart
+         CurrentEdge.ptEnd = LongFaces[i].Edges[j].ptEnd
+         CurrentEdge.vtEdge = LongFaces[i].Edges[j].vtEdge
+         CurrentEdge.id = LongFaces[i].Edges[j].id
 
          if Proc.Topology.sFamily == 'Tunnel' then
             if CurrentEdge.idAdjacentFace > -1 then
@@ -620,6 +646,10 @@ local function GetSideFaces( Proc, MainFaces)
          CurrentEdge.dElevation = SideFaces[i].Edges[j].dElevation
          CurrentEdge.bIsStartOpen = SideFaces[i].Edges[j].bIsStartOpen
          CurrentEdge.bIsEndOpen = SideFaces[i].Edges[j].bIsEndOpen
+         CurrentEdge.ptStart = SideFaces[i].Edges[j].ptStart
+         CurrentEdge.ptEnd = SideFaces[i].Edges[j].ptEnd
+         CurrentEdge.vtEdge = SideFaces[i].Edges[j].vtEdge
+         CurrentEdge.id = SideFaces[i].Edges[j].id
 
          if Proc.Topology.sFamily == 'Tunnel' then
             if CurrentEdge.idAdjacentFace > -1 then
@@ -653,7 +683,6 @@ end
 -- TODO test iniziale replicato in GetTunnelFaces
 function FaceData.GetMainFaces( Proc, Part)
 
-   EgtOutLog( '---MainFaces START---')
    local MainFaces = {}
 
    -- CASO 1 : Feature tipo LapJoint
@@ -671,16 +700,10 @@ function FaceData.GetMainFaces( Proc, Part)
       MainFaces.LongFaces = GetLongFaces( Proc, MainFaces)
       MainFaces.SideFaces = GetSideFaces( Proc, MainFaces)
 
-      -- scrivo informazioni delle facce nel log
-      if EgtGetDebugLevel() >= 3 then
-         Logs.WriteMainFacesLog( Proc, MainFaces)
-      end
    else
       MainFaces = nil
-      EgtOutLog( '---MainFaces NOT NEEDED---')
    end
 
-   EgtOutLog( '---MainFaces END---')
    return MainFaces
 end
 

LuaLibs/FeatureLib.lua

@@ -6,7 +6,7 @@
 local FeatureLib = {}
 
 -- Carico i dati globali
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
@@ -32,6 +32,10 @@ function FeatureLib.GetProcFromTrimesh( idTrimesh, Part, ProcToCopyFrom)
    Proc.AffectedFaces = BeamLib.GetAffectedFaces( Proc, Part)
    Proc.AdjacencyMatrix = FaceData.GetAdjacencyMatrix( Proc)
    Proc.Faces = FaceData.GetFacesInfo( Proc, Part)
+   Proc.dVolume = FeatureLib.GetFeatureVolume( Proc, Part)
+   if ProcToCopyFrom and Proc.dVolume < 10 * GEO.EPS_SMALL then
+      Proc.dVolume = ProcToCopyFrom.dVolume
+   end
    -- TODO servono anche altri dati raccolti nel collect??
    
    return Proc
@@ -54,7 +58,7 @@ end
 -- restituisce vero se tutti i lati della faccia passata si trovano sul grezzo
 local function AreAllFaceEdgesOnRaw( Part, Proc, idFace)
    local bEdgeOnRaw = true
-   local idTempGroup = BeamLib.GetTempGroup()
+   local idTempGroup = Part.idTempGroup
    local nLoopId, nLoopCnt = EgtExtractSurfTmFacetLoops( Proc.id, idFace, idTempGroup)
    if nLoopCnt > 1 then
       error( 'AreAllFaceEdgesOnRaw : too many loops')
@@ -323,7 +327,7 @@ function FeatureLib.GetAdditionalInfo( Proc, Part)
    elseif ID.IsRidgeLap( Proc) then
       Proc.AdjacencyMatrix = FaceData.GetAdjacencyMatrix( Proc)
       Proc.Faces = FaceData.GetFacesInfo( Proc, Part)
-   elseif ID.IsMarking( Proc) then
+   elseif ID.IsMarking( Proc) or ID.IsText( Proc) then
       Proc.FeatureInfo = FeatureLib.GetMarkTextData( Proc)
    elseif ID.IsHipValleyRafterNotch( Proc) then
       Proc.AdjacencyMatrix = FaceData.GetAdjacencyMatrix( Proc)
@@ -495,6 +499,7 @@ function FeatureLib.GetDTMortiseData( Proc)
 
    -- distanza massima all'imbocco ortogonale all'asse
    local vtDiff = EgtEP( idAux, GDB_RT.GLOB) - EgtSP( idAux, GDB_RT.GLOB)
+
    local vtOrtDiff = vtDiff - vtDiff * vtAx * vtAx
    local dMortiseMaxDist = min( vtOrtDiff:len(), dMortiseWidth)
 
@@ -505,6 +510,9 @@ function FeatureLib.GetDTMortiseData( Proc)
    FeatureExtraInfo.dMortiseDepth = dMortiseDepth
    FeatureExtraInfo.dMortiseMinRadius = dMortiseMinRadius
    FeatureExtraInfo.vtMortiseN = vtMortiseN
+   vtDiff:normalize()
+   FeatureExtraInfo.vtMortisePathStart = EgtSV( idAux, GDB_RT.GLOB) * vtDiff
+   FeatureExtraInfo.vtMortisePathEnd = EgtEV( idAux, GDB_RT.GLOB) * vtDiff
    FeatureExtraInfo.idAddAuxGeom = idAux
 
    return FeatureExtraInfo
@@ -901,23 +909,16 @@ end
 function FeatureLib.GetFeatureVolume( Proc, Part)
    local dProcVolume = 0
 
-   local idAddGroup = BeamLib.GetAddGroup( Part.id)
-   if not idAddGroup then
-      -- TODO gestire meglio questo errore. Non conviene creare e verificare all'inizio se il gruppo esiste?
-      EgtOutLog( 'Error : missing AddGroup')
-      return 0
-   end
+   local idTempGroup = Part.idTempGroup
 
-   local idProcCopy = EgtCopyGlob( Proc.id, idAddGroup) or GDB_ID.NULL
+   local idProcCopy = EgtCopyGlob( Proc.id, idTempGroup) or GDB_ID.NULL
    local b3PartCopy = BBox3d( Part.b3Part)
    b3PartCopy:expand( -100 * GEO.EPS_SMALL)
-   local idPartCopy = EgtSurfTmBBox( idAddGroup, b3PartCopy , false, GDB_RT.GLOB)
+   local idPartCopy = EgtSurfTmBBox( idTempGroup, b3PartCopy , false, GDB_RT.GLOB)
 
    EgtSurfTmSubtract( idPartCopy, idProcCopy)
    dProcVolume = EgtSurfVolume( idPartCopy)
 
-   EgtErase( { idProcCopy, idPartCopy})
-
    return dProcVolume
 end
 
@@ -925,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
@@ -940,6 +942,7 @@ function FeatureLib.CalculateFeatureNotClampableLengths( Proc, Part)
    local dNotClampableLengthTail = 0
 
    -- se il grezzo non è definito, prendo il box del pezzo
+   -- TODO 1- si sta passando b3part per riferimento, 2- non dovrebbe essre sempre definito?
    if not Part.b3Raw then
       Part.b3Raw = Part.b3Part
    end
@@ -961,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
 
@@ -979,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/LeadInOutLib.lua

@@ -0,0 +1,247 @@
+-- LeadInOutLib.lua by Egalware s.r.l. 2025/11/24
+-- Libreria stima collisioni per travi
+
+-- Tabella per definizione modulo
+local LeadInOutLib = {}
+
+-- Include
+require( 'EgtBase')
+local BeamData = require( 'BeamDataNew')
+local FaceData = require( 'FaceData')
+local BeamLib = require( 'BeamLib')
+
+EgtOutLog( ' LeadInOutLib started', 1)
+
+-------------------------------------------------------------------------------------------------------------
+local function GetExtraAddLengthInclinedSides( Face, Edge)
+
+   -- se faccia rettangolare i lati sono tutti a 90deg, inutile fare conti
+   if FaceData.IsFaceRectangle( Face) then
+      return 0, 0
+   end
+
+   local nPreviousEdgeIndex = Edge.id + 1 - 1
+   if nPreviousEdgeIndex < 1 then
+      nPreviousEdgeIndex = #Face.Edges
+   end
+   local nNextEdgeIndex = Edge.id + 1 + 1
+   if nNextEdgeIndex > #Face.Edges then
+      nNextEdgeIndex = 1
+   end
+
+   local vtEdgePrevious = Face.Edges[nPreviousEdgeIndex].vtEdge
+   local vtEdgeNext = Face.Edges[nNextEdgeIndex].vtEdge
+   local dLengthEdgePrevious = Face.Edges[nPreviousEdgeIndex].dLength
+   local dLengthEdgeNext = Face.Edges[nNextEdgeIndex].dLength
+
+   local dExtraPrevious = dLengthEdgePrevious * ( Edge.vtEdge * -vtEdgePrevious)
+   local dExtraNext = dLengthEdgeNext * ( -Edge.vtEdge * vtEdgeNext)
+
+   return dExtraPrevious, dExtraNext
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetPerpendicularLeadInOutDirection( Face, Edge)
+
+   -- informazioni lati adiacenti
+   local nCurrentEdgeIndex = Edge.id + 1
+   local nPreviousEdgeIndex = ( nCurrentEdgeIndex == 1 and #Face.Edges) or nCurrentEdgeIndex - 1
+   local nNextEdgeIndex = ( nCurrentEdgeIndex == #Face.Edges and 1) or nCurrentEdgeIndex + 1
+   local EdgeNext = Face.Edges[nNextEdgeIndex]
+   local EdgePrevious = Face.Edges[nPreviousEdgeIndex]
+
+   -- tra le direzioni dei due lati adiacenti, si sceglie la migliore da cui attaccare, ossia quella più vicina alla perpendicolare al lato di lavoro
+   local dCosAngleStart = -EdgePrevious.vtEdge * Edge.vtN
+   local dCosAngleEnd = EdgeNext.vtEdge * Edge.vtN
+   local vtLeadInOut
+   -- se le due direzioni sono entro i 5° scelgo quella a Z assoluta minore, altrimenti quella più vicino alla perpendicolare
+   -- massima differenza scalare per variazione di 5deg: cos(0) - cos(0 + 5) = 1 - cos(5)
+   local dScalarTolerance = 1 - 0.996
+   if abs( dCosAngleStart - dCosAngleEnd) < dScalarTolerance then
+      if abs( EdgePrevious.vtEdge:getZ()) < abs( EdgeNext.vtEdge:getZ()) then
+         vtLeadInOut = Vector3d( -EdgePrevious.vtEdge)
+      else
+         vtLeadInOut = Vector3d( EdgeNext.vtEdge)
+      end
+   else
+      if dCosAngleStart > dCosAngleEnd then
+         vtLeadInOut = Vector3d( -EdgePrevious.vtEdge)
+      else
+         vtLeadInOut = Vector3d( EdgeNext.vtEdge)
+      end
+   end
+
+   return vtLeadInOut
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function CalculateLeadInOutLength( ptToolCenter, vtNFace, b3Box, vtLeadInOut, Tool)
+
+   -- al momento gestita solo lama
+   if not Tool.sFamily == 'SawBlade' then
+      error(' Tool family not implemented')
+   end
+
+   -- Box del pezzo espansi ortogonalmente alle tre direzioni canoniche X, Y e Z
+   local b3BoxX = BBox3d( b3Box) ; b3BoxX:expand( 0, 1000, 1000)
+   local b3BoxY = BBox3d( b3Box) ; b3BoxY:expand( 1000, 0, 1000)
+   local b3BoxZ = BBox3d( b3Box) ; b3BoxZ:expand( 1000, 1000, 0)
+
+   -- si setta utensile lama per il controllo collisione
+   EgtCAvSetSawTool( Tool.dThickness, Tool.dDiameter, Tool.dThickness, 0, 0)
+
+   -- calcolo distanza di cui retrarre con funzioni Tool Collision Avoidance
+   local dLength = min( EgtCAvToolPosBox( ptToolCenter + Tool.dThickness * vtNFace, vtNFace, b3BoxX, vtLeadInOut),
+                        EgtCAvToolPosBox( ptToolCenter + Tool.dThickness * vtNFace, vtNFace, b3BoxY, vtLeadInOut),
+                        EgtCAvToolPosBox( ptToolCenter + Tool.dThickness * vtNFace, vtNFace, b3BoxZ, vtLeadInOut))
+
+   return dLength
+end
+
+
+-------------------------------------------------------------------------------------------------------------
+function LeadInOutLib.CalculateLeadInOut( sLeadInOutType, Parameters, OptionalParameters)
+
+   -- parametri obbligatori
+   local Face = Parameters.Face
+   local Edge = Parameters.Edge
+   local Part = Parameters.Part
+   local Tool = Parameters.Tool
+   local dDepthToMachine = Parameters.dDepthToMachine
+
+   -- parametri opzionali
+   local sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation or 'Tail'
+   local bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength or false
+
+   local LeadInOut = {}
+   local bIsStartClosed = not Edge.bIsStartOpen
+   local bIsEndClosed = not Edge.bIsEndOpen
+
+   -- accorciamento per lati chiusi
+   LeadInOut.dToolMarkLength = sqrt( dDepthToMachine * Tool.dDiameter - dDepthToMachine * dDepthToMachine)
+   LeadInOut.dExtraAddLengthStart, LeadInOut.dExtraAddLengthEnd = GetExtraAddLengthInclinedSides( Face, Edge)
+   -- allungamento per faccia singola (aperta in tutte le direzioni)
+   LeadInOut.dAddedLengthOpenFace = BeamData.CUT_EXTRA
+
+   local LeadIn = {}
+   local LeadOut = {}
+   LeadIn.dStartAddLength = 0
+   LeadOut.dEndAddLength = 0
+   LeadIn.nType = MCH_MILL_LI.LINEAR
+   LeadOut.nType = MCH_MILL_LI.LINEAR
+   LeadIn.dPerpDistance = 0
+   LeadOut.dPerpDistance = 0
+   LeadIn.dTangentDistance = 0
+   LeadOut.dTangentDistance = 0
+   LeadIn.dElevation = 0
+   LeadOut.dElevation = 0
+   LeadIn.dCompLength = 0
+   LeadOut.dCompLength = 0
+
+   -- calcolo allungamenti / accorciamenti
+   if bIsStartClosed and bIsEndClosed then
+      LeadIn.dStartAddLength = -LeadInOut.dToolMarkLength - LeadInOut.dExtraAddLengthStart
+      LeadOut.dEndAddLength = -LeadInOut.dToolMarkLength - LeadInOut.dExtraAddLengthEnd
+   elseif bIsStartClosed then
+      LeadIn.dStartAddLength = -LeadInOut.dToolMarkLength - LeadInOut.dExtraAddLengthStart
+      -- eventuale correzione per accorciamento maggiore di larghezza tasca
+      LeadOut.dEndAddLength = max( -LeadIn.dStartAddLength - Edge.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
+   elseif bIsEndClosed then
+      LeadOut.dEndAddLength = -LeadInOut.dToolMarkLength - LeadInOut.dExtraAddLengthEnd
+      -- eventuale correzione per accorciamento maggiore di larghezza tasca
+      LeadIn.dStartAddLength = max( -LeadOut.dEndAddLength - Edge.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
+   else
+      LeadIn.dStartAddLength = LeadInOut.dAddedLengthOpenFace
+      LeadOut.dEndAddLength = LeadInOut.dAddedLengthOpenFace
+   end
+
+   -- calcolo punti notevoli della lavorazione
+   -- punti di inizio e fine lavorazione alla profondità di lavoro reale, considerando allungamenti/accorciamenti
+   local ptStartAtDepth = Edge.ptStart - Edge.vtEdge * LeadIn.dStartAddLength + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
+   local ptEndAtDepth = Edge.ptEnd + Edge.vtEdge * LeadOut.dEndAddLength + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
+   -- punti in centro lama
+   local ptStartBladeCenter = ptStartAtDepth + Edge.vtN * Tool.dDiameter / 2
+   local ptEndBladeCenter = ptEndAtDepth + Edge.vtN * Tool.dDiameter / 2
+
+   -- box per calcolo uscita lama
+   -- se è un taglio di testa o coda va aggiunto il sovramateriale
+   local b3BoxPartExpanded = BBox3d( Part.b3Part)
+   if bCannotSplitRestLength then
+      b3BoxPartExpanded = BeamLib.GetPartBoxWithHeadTail( Part, sRestLengthSideForPreSimulation)
+   end
+   -- il box si espande in tutte le direzioni per contemplare la sicurezza CUT_SIC
+   b3BoxPartExpanded:expand( BeamData.CUT_SIC)
+
+   -- calcolo attacco scelto
+   if sLeadInOutType == 'Perpendicular' then
+
+      -- scelta direzione migliore per l'attacco
+      local vtLeadInOut = GetPerpendicularLeadInOutDirection( Face, Edge)
+
+      -- frame solidale al lato di lavoro (X lungo il lato, Y normale al lato)
+      local frEdge = Frame3d( Edge.ptStart, Face.vtN, Edge.vtEdge)
+
+      -- direzione nel frame solidale al lato di lavoro
+      local vtLeadInOuttLoc = Vector3d( vtLeadInOut)
+      vtLeadInOuttLoc:toLoc( frEdge)
+
+      -- calcolo distanza per uscire dal box con questa lama nella direzione vtLeadInOut
+      local dLeadInLength = CalculateLeadInOutLength( ptStartBladeCenter, Face.vtN, b3BoxPartExpanded, vtLeadInOut, Tool)
+      local dLeadOutLength = CalculateLeadInOutLength( ptEndBladeCenter, Face.vtN, b3BoxPartExpanded, vtLeadInOut, Tool)
+
+      -- componenti dell'attacco
+      LeadIn.dPerpDistance = dLeadInLength * vtLeadInOuttLoc:getY()
+      LeadIn.dTangentDistance = dLeadInLength * -vtLeadInOuttLoc:getX()
+      LeadOut.dPerpDistance = dLeadOutLength * vtLeadInOuttLoc:getY()
+      LeadOut.dTangentDistance = dLeadOutLength * vtLeadInOuttLoc:getX()
+
+      -- punti dell'attacco
+      LeadIn.ptPoint = Point3d( ptStartAtDepth + vtLeadInOut * dLeadInLength)
+      LeadOut.ptPoint = Point3d( ptEndAtDepth + vtLeadInOut * dLeadOutLength)
+
+   elseif sLeadInOutType == 'Tangent' then
+
+      -- calcolo distanza per uscire dal box con questa lama nella direzione tangenziale
+      local dLeadInLength = CalculateLeadInOutLength( ptStartBladeCenter, Face.vtN, b3BoxPartExpanded, -Edge.vtEdge, Tool)
+      local dLeadOutLength = CalculateLeadInOutLength( ptEndBladeCenter, Face.vtN, b3BoxPartExpanded, Edge.vtEdge, Tool)
+
+      -- componenti dell'attacco
+      LeadIn.dPerpDistance = 0
+      LeadIn.dTangentDistance = dLeadInLength
+      LeadOut.dPerpDistance = 0
+      LeadOut.dTangentDistance = dLeadOutLength
+
+      -- punti dell'attacco
+      LeadIn.ptPoint = Point3d( ptStartAtDepth - Edge.vtEdge * dLeadInLength)
+      LeadOut.ptPoint = Point3d( ptEndAtDepth + Edge.vtEdge * dLeadOutLength)
+   end
+
+   -- lunghezza totale attacco
+   LeadIn.dTotalLength = sqrt( LeadIn.dPerpDistance ^ 2 + LeadIn.dTangentDistance ^ 2)
+   LeadOut.dTotalLength = sqrt( LeadOut.dPerpDistance ^ 2 + LeadOut.dTangentDistance ^ 2)
+
+   LeadInOut.dTotalLength = LeadIn.dTotalLength + LeadOut.dTotalLength
+   LeadInOut.LeadIn = LeadIn
+   LeadInOut.LeadOut = LeadOut
+
+   return LeadInOut
+end
+
+-------------------------------------------------------------------------------------------------------------
+function LeadInOutLib.InvertLeadInOut( LeadIn, LeadOut)
+
+   local dOriginalStartAddLength = LeadIn.dStartAddLength
+   local dOriginalEndAddLength = LeadOut.dEndAddLength
+
+   LeadIn, LeadOut = LeadOut, LeadIn
+
+   LeadIn.dStartAddLength = dOriginalEndAddLength
+   LeadOut.dEndAddLength = dOriginalStartAddLength
+   LeadIn.dEndAddLength = nil
+   LeadOut.dStartAddLength = nil
+
+   return LeadIn, LeadOut
+end
+
+-------------------------------------------------------------------------------------------------------------
+return LeadInOutLib

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

@@ -9,11 +9,12 @@ local MachiningLib = {}
 require( 'EgtBase')
 
 -- Carico i dati globali
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local BeamLib = require( 'BeamLib')
 local FeatureLib = require( 'FeatureLib')
 local BCS = require( 'BasicCustomerStrategies')
-local FaceData = require ( 'FaceData')
+local PreSimulationLib = require( 'PreSimulationLib')
+local LeadInOutLib = require( 'LeadInOutLib')
 
 EgtOutLog( ' MachiningLib started', 1)
 
@@ -96,15 +97,29 @@ function MachiningLib.CanExtendAfterTail( sCanDamageNextPiece, Part)
 end
 
 -------------------------------------------------------------------------------------------------------------
-function MachiningLib.GetMachiningSteps( dMachiningDepth, dStep)
+function MachiningLib.IsFeatureHinderingClamping( Proc, Part)
+   local bFeatureHindersClamping
+
+   local dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail = FeatureLib.GetFeatureMaxNotClampableLengths( Proc, Part)
+   bFeatureHindersClamping = FeatureLib.IsMachiningLong( max( dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail), Part, { dMaxSegmentLength = BeamData.LONGCUT_ENDLEN})
+
+   return bFeatureHindersClamping
+end
+
+-------------------------------------------------------------------------------------------------------------
+function MachiningLib.GetMachiningSteps( bIsSlot, dMachiningDepth, dStep)
    local MachiningSteps = {}
-   MachiningSteps.dStep = 0
    MachiningSteps.nCount = ceil( ( dMachiningDepth - 50 * GEO.EPS_SMALL) / dStep)
-   if MachiningSteps.nCount > 1 then
-      MachiningSteps.dStep = ( dMachiningDepth - dStep) / ( MachiningSteps.nCount - 1)
+   -- se è una slot, dMachiningDepth è l'altezza della tasca e nel calcolo step si deve considerare lo spessore dell'utensile
+   if bIsSlot then
+      if MachiningSteps.nCount > 1 then
+            MachiningSteps.dStep = ( dMachiningDepth - dStep) / ( MachiningSteps.nCount - 1)
+      else
+         MachiningSteps.dStep = dMachiningDepth
+         MachiningSteps.nCount = 1
+      end
    else
-      MachiningSteps.dStep = dMachiningDepth
-      MachiningSteps.nCount = 1
+      MachiningSteps.dStep = dStep
    end
 
    return MachiningSteps
@@ -267,6 +282,186 @@ local function IsToolInAvailableToolList( AvailableToolList, sTool)
    return bToolFound
 end
 
+-------------------------------------------------------------------------------------------------------------
+-- in base a tipo testa e angolo soglia, verifica se la faccia è troppo inclinata per la lavorazione scelta (per DownUp passare vtNFace opposta)
+function MachiningLib.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
+      return true
+   end
+   -- lama sotto: angolo positivo troppo elevato
+   if Tool.SetupInfo.HeadType.bBottom and vtNFace:getZ() > Tool.SetupInfo.GetMaxNz( vtNFace, Tool) + GEO.EPS_ZERO then
+      return true
+   end
+
+   return false
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function TestEngagement( sBladeEngagement, Parameters, OptionalParameters)
+
+   -- parametri obbligatori (parametri opzionali transitano solamente)
+   local Face = Parameters.Face
+   local Edge = Parameters.Edge
+   local Part = Parameters.Part
+   local Tool = Parameters.Tool
+   local dDepthToMachine = Parameters.dDepthToMachine
+
+   -- il lato della testa cambia in base all'Engagement
+   local vtHead
+   if sBladeEngagement == 'Standard' then
+      vtHead = Face.vtN
+   elseif sBladeEngagement == 'DownUp' then
+      vtHead = -Face.vtN
+   else
+      error( 'TestEngagement : unknown engagement')
+   end
+
+   -- se l'angolo non può essere raggiunto dall'utensile la lavorazione non è fattibile
+   if MachiningLib.IsFaceZOutOfRange( vtHead, Tool) then
+      return false
+   end
+
+   local CheckCollisionParameters = {
+      Edge = Edge,
+      vtNFace = Face.vtN,
+      vtHead = vtHead,
+      Part = Part,
+      Tool = Tool,
+      dDepthToMachine = dDepthToMachine
+   }
+
+   local CheckCollisionOptionalParameters = BeamLib.TableCopyDeep( OptionalParameters or {})
+
+   local nSCC = Tool.SetupInfo.GetSCC( Edge.vtN, Edge.vtEdge, Face.vtN)
+
+   -- check punti lavorazione
+   -- lavorazione oltre le corse: non fattibile
+   local PointsOnToolTipCenter = {
+      PreSimulationLib.GetPointOnToolTipCenter( Edge.ptStart + Edge.vtN * ( Edge.dElevation - dDepthToMachine), vtHead, Face.vtN, Edge.vtN, Tool),
+      PreSimulationLib.GetPointOnToolTipCenter( Edge.ptEnd + Edge.vtN * ( Edge.dElevation - dDepthToMachine), vtHead, Face.vtN, Edge.vtN, Tool)
+   }
+   local bOutOfStroke = PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool)
+   if bOutOfStroke then
+      return false
+   end
+   -- lavorazione in collisione con il pezzo: non fattibile
+   local bCollisionFound, bMoveAfterSplit = PreSimulationLib.CheckCollision( sBladeEngagement, CheckCollisionParameters, CheckCollisionOptionalParameters)
+   if bCollisionFound then
+      return false
+   end
+
+   -- calcolo e check attacchi
+   local LeadInOut = {}
+   local LeadInOutOptionalParameters = {
+      sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation,
+      bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength,
+      bMoveAfterSplit = bMoveAfterSplit
+   }
+
+   -- attacco perpendicolare
+   local PerpendicularLeadInOut = LeadInOutLib.CalculateLeadInOut( 'Perpendicular', Parameters, LeadInOutOptionalParameters)
+   -- check extracorsa nei punti di attacco
+
+   PointsOnToolTipCenter = {
+      PreSimulationLib.GetPointOnToolTipCenter( PerpendicularLeadInOut.LeadIn.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool),
+      PreSimulationLib.GetPointOnToolTipCenter( PerpendicularLeadInOut.LeadOut.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool)
+   }
+   local bOutOfStrokePerpendicular = PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool)
+   -- se non è in extracorsa si aggiunge come attacco possibile
+   if not bOutOfStrokePerpendicular then
+      LeadInOut.Perpendicular = PerpendicularLeadInOut
+      LeadInOut.Perpendicular.bMoveAfterSplit = bMoveAfterSplit
+   end
+   -- se c'è almeno un lato chiuso l'unico attacco possibile è il perpendicolare
+   if not ( Edge.bIsStartOpen and Edge.bIsEndOpen) then
+      if bOutOfStrokePerpendicular then
+         return false
+      else
+         LeadInOut.sChosen = 'Perpendicular'
+         return true, bMoveAfterSplit, LeadInOut
+      end
+   end
+
+   -- attacco tangenziale
+   local TangentLeadInOut = LeadInOutLib.CalculateLeadInOut( 'Tangent', Parameters, LeadInOutOptionalParameters)
+   -- check extracorsa nei punti di attacco
+   PointsOnToolTipCenter = {
+      PreSimulationLib.GetPointOnToolTipCenter( TangentLeadInOut.LeadIn.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool),
+      PreSimulationLib.GetPointOnToolTipCenter( TangentLeadInOut.LeadOut.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool)
+   }
+   local bOutOfStrokeTangent = PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool)
+   -- attacco tangenziale non in extracorsa: si verifica se è in collisione
+   if not bOutOfStrokeTangent then
+      CheckCollisionOptionalParameters.PointsToCheck = {}
+      table.insert( CheckCollisionOptionalParameters.PointsToCheck, TangentLeadInOut.LeadIn.ptPoint)
+      table.insert( CheckCollisionOptionalParameters.PointsToCheck, TangentLeadInOut.LeadOut.ptPoint)
+      local bCollisionFoundTangent, bMoveAfterSplitTangent = PreSimulationLib.CheckCollision( sBladeEngagement, CheckCollisionParameters, CheckCollisionOptionalParameters)
+      -- attacco tangenziale possibile
+      if not bCollisionFoundTangent then
+         LeadInOut.Tangent = TangentLeadInOut
+         LeadInOut.Tangent.bMoveAfterSplit = bMoveAfterSplitTangent
+      end
+   end
+
+   -- se disponibili più attacchi si sceglie il più corto, altrimenti quello possibile
+   if LeadInOut.Perpendicular and LeadInOut.Tangent then
+      if LeadInOut.Perpendicular.dTotalLength > LeadInOut.Tangent.dTotalLength + 10 then
+         LeadInOut.sChosen = 'Tangent'
+      else
+         LeadInOut.sChosen = 'Perpendicular'
+      end
+   elseif LeadInOut.Perpendicular and not LeadInOut.Tangent then
+      LeadInOut.sChosen = 'Perpendicular'
+   elseif LeadInOut.Tangent and not LeadInOut.Perpendicular then
+      LeadInOut.sChosen = 'Tangent'
+   -- nessun attacco possibile
+   -- TODO qui invece di uscire si dovranno provare i due attacchi SpecialTangent e SpecialTangentInverted
+   else
+      return false
+   end
+
+   return true, bMoveAfterSplit, LeadInOut
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- ritorna se la faccia e il lato sono lavorabili e, se sì, il modo di lavorare (standard/DownUp) e i tipi di attacco disponibili
+-- TODO si dovrà decidere come tagliare anche se pezzo corto (il motore non deve ingombrare con il pinzaggio)
+-- TODO da gestire riduzione percorso
+function MachiningLib.GetBladeEngagement( Parameters, OptionalParameters)
+
+   local Engagement
+
+   -- test lavorazione faccia in modo standard (no DownUp)
+   local bIsEngagementOk, bMoveAfterSplit, LeadInOut = TestEngagement( 'Standard', Parameters, OptionalParameters)
+
+   if bIsEngagementOk then
+      
+      Engagement = {
+         sBladeEngagement = 'Standard',
+         bMoveAfterSplit = bMoveAfterSplit,
+         LeadInOut = LeadInOut
+      }
+      return true, Engagement
+   end
+
+   -- faccia non lavorabile in modo standard: si verifica se il DownUp è fattibile
+   bIsEngagementOk, bMoveAfterSplit, LeadInOut = TestEngagement( 'DownUp', Parameters, OptionalParameters)
+
+   if bIsEngagementOk then
+      
+      Engagement = {
+         sBladeEngagement = 'DownUp',
+         bMoveAfterSplit = bMoveAfterSplit,
+         LeadInOut = LeadInOut
+      }
+      return true, Engagement
+   end
+
+   return false
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- funzione per cercare utensile tipo FRESA con certe caratteristiche
 -- TODO qui vtToolDirection è in realtà vtN
@@ -383,14 +578,13 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 -- funzione per cercare utensile tipo LAMA con certe caratteristiche
--- TODO da completare
--- TODO il FindBlade dovrà restituire di utilizzare sempre la lama sopra se l'angolo lo permette, ma avendo un'altezza massima (da macchina) oltre cui il DownUp non sarà fattibile (evita collisioni tra asse e pezzo)
+-- TODO da rivedere/completare
 function MachiningLib.FindBlade( Proc, ToolSearchParameters)
    local ToolInfo = {}
 
    -- parametri obbligatori
-   if type( ToolSearchParameters.vtN) ~= 'table' then
-      error( 'FindBlade : missing tool direction')
+   if type( ToolSearchParameters.FaceToMachine) ~= 'table' then
+      error( 'FindBlade : missing face info')
    end
    if type( ToolSearchParameters.bAllowTopHead) ~= 'boolean' then
       error( 'FindBlade : missing top head info')
@@ -401,32 +595,67 @@ function MachiningLib.FindBlade( Proc, ToolSearchParameters)
    if not ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
       error( 'FindBlade : wrong head info')
    end
+   local FaceToMachine = ToolSearchParameters.FaceToMachine
+   local bAllowTopHead = ToolSearchParameters.bAllowTopHead
+   local bAllowBottomHead = ToolSearchParameters.bAllowBottomHead
 
    -- parametri opzionali
-   ToolSearchParameters.dElevation = ToolSearchParameters.dElevation or 0
-   ToolSearchParameters.bForceLongcutBlade = ToolSearchParameters.bForceLongcutBlade or false
+   local dElevation = ToolSearchParameters.dElevation
+   local bForceLongcutBlade = ToolSearchParameters.bForceLongcutBlade or false
+   local EdgeToMachine = ToolSearchParameters.EdgeToMachine
+   local Part = ToolSearchParameters.Part
+   local bIsDicing = ToolSearchParameters.bIsDicing or false
+   local sRestLengthSideForPreSimulation = ToolSearchParameters.sRestLengthSideForPreSimulation or 'Tail'
+   local bCannotSplitRestLength = ToolSearchParameters.bCannotSplitRestLength or false
 
    local nBestToolIndex
    local dBestToolResidualDepth = 0
+   local CurrentEngagement
+   local BestEngagement
    for i = 1, #TOOLS do
       local bIsToolCompatible = false
 
       if TOOLS[i].sFamily == 'SAWBLADE' then
-         if ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
+         if bAllowTopHead and not bAllowBottomHead then
             bIsToolCompatible = TOOLS[i].SetupInfo.HeadType.bTop
-         elseif ToolSearchParameters.bAllowBottomHead and not ToolSearchParameters.bAllowTopHead then
+         elseif bAllowBottomHead and not bAllowTopHead then
             bIsToolCompatible = TOOLS[i].SetupInfo.HeadType.bBottom
          else
             bIsToolCompatible = true
          end
       end
 
-      -- check angolo limite lama
-      if TOOLS[i].SetupInfo.HeadType.bTop and ToolSearchParameters.vtN:getZ() < TOOLS[i].SetupInfo.GetMinNz( ToolSearchParameters.vtN, TOOLS[i]) - GEO.EPS_ZERO then
-         bIsToolCompatible = false
-      end
-      if TOOLS[i].SetupInfo.HeadType.bBottom and ToolSearchParameters.vtN:getZ() > TOOLS[i].SetupInfo.GetMaxNz( ToolSearchParameters.vtN, TOOLS[i]) + GEO.EPS_ZERO then
-         bIsToolCompatible = false
+      -- se dati sufficienti, si determina se con questo utensile il taglio è fattibile e il modo di lavorare della lama
+      -- TODO corretto il calcolo della dDepthToMachine? è comunque inutile calcolare per una profondità che so già andrà in collisione
+      if bIsToolCompatible then
+         if FaceToMachine and EdgeToMachine and Part and dElevation then
+            local bIsBladeOk = false
+            local BladeEngagementParameters = {
+               Face = FaceToMachine,
+               Edge = EdgeToMachine,
+               Part = Part,
+               Tool = TOOLS[i],
+               dDepthToMachine = min( dElevation, TOOLS[i].dMaxDepth)
+            }
+            local BladeEngagementOptionalParameters = {
+               bIsDicing = bIsDicing,
+               sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
+               bCannotSplitRestLength = bCannotSplitRestLength
+            }
+            TIMER:startElapsed( 'GetBladeEngagement')
+            bIsBladeOk, CurrentEngagement = MachiningLib.GetBladeEngagement( BladeEngagementParameters, BladeEngagementOptionalParameters)
+            TIMER:stopElapsed( 'GetBladeEngagement')
+            -- orientamento non raggiungibile
+            if not bIsBladeOk then
+               bIsToolCompatible = false
+            end
+
+         -- se si ha solo la faccia si può verificare se questa è orientata correttamente
+         elseif FaceToMachine then
+            if MachiningLib.IsFaceZOutOfRange( FaceToMachine.vtN, TOOLS[i]) then
+               bIsToolCompatible = false
+            end
+         end
       end
 
       -- se c'è una lista di utensili disponibili, si verifica che l'utensile attuale sia tra quelli
@@ -436,15 +665,17 @@ function MachiningLib.FindBlade( Proc, ToolSearchParameters)
 
       if bIsToolCompatible then
          -- TODO gestire accorciamento massimo materiale per inclinazione
-         local dCurrentResidualDepth = ToolSearchParameters.dElevation - TOOLS[i].dMaxDepth
+         local dCurrentResidualDepth = ( dElevation or 0) - TOOLS[i].dMaxDepth
          if not nBestToolIndex or ( dBestToolResidualDepth > 0 and dCurrentResidualDepth <= 10 * GEO.EPS_SMALL) then
             nBestToolIndex = i
             dBestToolResidualDepth = dCurrentResidualDepth
+            BestEngagement = CurrentEngagement
          else
-            -- prediligo utensile per tagli lunghi, se richiesto
-            if ToolSearchParameters.bForceLongcutBlade and not TOOLS[nBestToolIndex].bIsUsedForLongCut and TOOLS[i].bIsUsedForLongCut then
+            -- prediligo utensile per tagli lungo vena, se richiesto
+            if bForceLongcutBlade and not TOOLS[nBestToolIndex].bIsUsedForLongCut and TOOLS[i].bIsUsedForLongCut then
                nBestToolIndex = i
                dBestToolResidualDepth = dCurrentResidualDepth
+               BestEngagement = CurrentEngagement
             else
                -- entrambi completi
                if dBestToolResidualDepth <= 10 * GEO.EPS_SMALL and dCurrentResidualDepth <= 10 * GEO.EPS_SMALL then
@@ -455,11 +686,13 @@ function MachiningLib.FindBlade( Proc, ToolSearchParameters)
                         GetIndexToolInAvailableToolList( ToolSearchParameters.AvailableToolList, TOOLS[nBestToolIndex].sName) then
                         nBestToolIndex = i
                         dBestToolResidualDepth = dCurrentResidualDepth
+                        BestEngagement = CurrentEngagement
                      end
                   -- si sceglie quello con le performance migliori
                   elseif TOOLS[i].dPerformanceIndex > TOOLS[nBestToolIndex].dPerformanceIndex + 10 * GEO.EPS_SMALL then
                      nBestToolIndex = i
                      dBestToolResidualDepth = dCurrentResidualDepth
+                     BestEngagement = CurrentEngagement
                   end
                -- entrambi incompleti
                elseif dBestToolResidualDepth > 10 * GEO.EPS_SMALL and dCurrentResidualDepth > 10 * GEO.EPS_SMALL then
@@ -467,6 +700,7 @@ function MachiningLib.FindBlade( Proc, ToolSearchParameters)
                   if dCurrentResidualDepth > dBestToolResidualDepth then
                      nBestToolIndex = i
                      dBestToolResidualDepth = dCurrentResidualDepth
+                     BestEngagement = CurrentEngagement
                   end
                end
             end
@@ -476,6 +710,7 @@ function MachiningLib.FindBlade( Proc, ToolSearchParameters)
 
    ToolInfo.nToolIndex = nBestToolIndex
    ToolInfo.dResidualDepth = dBestToolResidualDepth
+   ToolInfo.Engagement = BestEngagement
    
    return ToolInfo
 end
@@ -492,10 +727,10 @@ function MachiningLib.FindDrill( Proc, ToolSearchParameters)
       ToolSearchParameters.dToolDiameter = Proc.FeatureInfo.dDrillDiam or 0
    end
    if not ToolSearchParameters.dMaxToolDiameter then
-      ToolSearchParameters.dMaxToolDiameter = ToolSearchParameters.dToolDiameter + ( ToolSearchParameters.dDiameterTolerance or ( 100 * GEO.EPS_SMALL))
+      ToolSearchParameters.dMaxToolDiameter = ToolSearchParameters.dToolDiameter + ( ToolSearchParameters.dDiameterTolerance or 0) + ( 10 * GEO.EPS_SMALL)
    end
    if not ToolSearchParameters.dMinToolDiameter then
-      ToolSearchParameters.dMinToolDiameter = ToolSearchParameters.dToolDiameter - ( ToolSearchParameters.dDiameterTolerance or ( 100 * GEO.EPS_SMALL))
+      ToolSearchParameters.dMinToolDiameter = ToolSearchParameters.dToolDiameter - ( ToolSearchParameters.dDiameterTolerance or 0) - ( 10 * GEO.EPS_SMALL)
    end
 
    for i = 1, #TOOLS do
@@ -521,6 +756,8 @@ function MachiningLib.FindDrill( Proc, ToolSearchParameters)
       elseif TOOLS[i].SetupInfo.HeadType.bBottom and
              ToolSearchParameters.vtToolDirection:getZ() > TOOLS[i].SetupInfo.GetMaxNz( ToolSearchParameters.vtToolDirection, TOOLS[i]) + GEO.EPS_ZERO then
          bIsToolCompatible = false
+      elseif PreSimulationLib.CheckOutOfStrokeFromPoints( ToolSearchParameters.ptCheckOutStroke, ToolSearchParameters.vtToolDirection, 0, TOOLS[i]) then
+         bIsToolCompatible = false
       end
 
       -- scelgo il migliore
@@ -843,7 +1080,7 @@ local function AddNewMachining( ProcToAdd, MachiningToAdd, AuxiliaryDataToAdd)
       nHeadCutRotation = 3
    elseif ProcToAdd.bSide then
       nHeadCutRotation = 2
-   else
+   else -- ProcToAdd.bStd
       nHeadCutRotation = 1
    end
    MACHININGS.Info.nHeadCutRotation = max( MACHININGS.Info.nHeadCutRotation or 0, nHeadCutRotation)
@@ -853,7 +1090,7 @@ local function AddNewMachining( ProcToAdd, MachiningToAdd, AuxiliaryDataToAdd)
       nSplitCutRotation = 3
    elseif ProcToAdd.bSide and MachiningToAdd.sStage == 'AfterTail' then
       nSplitCutRotation = 2
-   else
+   else -- ProcToAdd.bStd
       nSplitCutRotation = 1
    end
    MACHININGS.Info.nSplitCutRotation = max( MACHININGS.Info.nSplitCutRotation or 0, nSplitCutRotation)
@@ -904,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 = {
@@ -983,17 +1236,20 @@ function MachiningLib.AddOperations( vProc, Part, sRotation)
 
    for i = 1, #MACHININGS do
       -- si aggiungono solo quelle della fase richiesta
-      if ( sRotation == 'STD' and not MACHININGS[i].Proc.bDown and not MACHININGS[i].Proc.bSide) or
+      if ( MACHININGS[i].Proc.bStd and sRotation == 'STD') or
          ( MACHININGS[i].Proc.bDown and sRotation == 'DOWN') or
          ( MACHININGS[i].Proc.bSide and sRotation == 'SIDE') then
          local nClonesToAdd = 1
          if MACHININGS[i].AuxiliaryData.Clones then
             nClonesToAdd = #MACHININGS[i].AuxiliaryData.Clones
          end
+         -- dati da salvare dopo applicazione della lavorazione
+         MACHININGS[i].Machining.MachStartAxesPos = {}
+         MACHININGS[i].Machining.MachEndAxesPos = {}
+         MACHININGS[i].Machining.nOperationId = {}
          for j = 1, nClonesToAdd do
             -- creazione lavorazione
             local nOperationId = EgtCreateMachining( MACHININGS[i].Machining.sOperationName, MACHININGS[i].Machining.nType, MACHININGS[i].Machining.sToolName)
-
             if nOperationId then
                -- impostazione geometria
                local Geometry
@@ -1091,45 +1347,68 @@ function MachiningLib.AddOperations( vProc, Part, sRotation)
                end
 
                local bIsApplyOk = MachiningLib.ApplyMachining( true, false)
+
+               -- si salva sulla lista info lavorazione applicata
+               local MachExtraInfo = { sType = 'MACH',
+                                       nIndexInMachinings = i,
+                                       nOperationId = nOperationId,
+                                       MachStartAxesPos = EgtGetMachiningStartAxes(),
+                                       MachEndAxesPos = EgtGetMachiningEndAxes()}
+               table.insert( DB_MACH_APPLIED, MachExtraInfo)
+
+               -- se errore in applicazione
                if not bIsApplyOk then
                   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'
                   RESULT[MACHININGS[i].Proc.nIndexInResult].ChosenStrategy.sApplyInfo = sErr
                   RESULT[MACHININGS[i].Proc.nIndexInResult].ChosenStrategy.nApplyError = nErr
-               -- se non deve essere igniorato, si salva ingombro lavorazione attuale e fasi successive
-               elseif not MACHININGS[i].AuxiliaryData.bIgnoreNotClampableLength then
-                  -- salvo ingombro non pinzabile testa/coda
-                  local nCurrRotation = MACHININGS[i].Proc.nIndexRotation
-                  local dNotClampHead, dNotClampTail = FeatureLib.GetFeatureRotationNotClampableLengths( MACHININGS[i].Proc, Part, nCurrRotation)
-                  Part.NotClampableLength[sRotation].dHead = max( Part.NotClampableLength[sRotation].dHead, dNotClampHead)
-                  Part.NotClampableLength[sRotation].dTail = max( Part.NotClampableLength[sRotation].dTail, dNotClampTail)
+               -- se applicazione andata a buon fine
+               else
 
-                  if sRotation == 'DOWN' then
+                  -- se non deve essere igniorato, si salva ingombro lavorazione attuale e fasi successive
+                  if not MACHININGS[i].AuxiliaryData.bIgnoreNotClampableLength then
+                     -- salvo ingombro non pinzabile testa/coda
+                     local nCurrRotation = MACHININGS[i].Proc.nIndexRotation
+                     local dNotClampHead, dNotClampTail = FeatureLib.GetFeatureRotationNotClampableLengths( MACHININGS[i].Proc, Part, nCurrRotation)
+                     Part.NotClampableLength[sRotation].dHead = max( Part.NotClampableLength[sRotation].dHead, dNotClampHead)
+                     Part.NotClampableLength[sRotation].dTail = max( Part.NotClampableLength[sRotation].dTail, dNotClampTail)
+
+                     if sRotation == 'DOWN' then
+                        local nNextRotation = EgtIf( nCurrRotation - 1 < 1, nCurrRotation - 1 + 4, nCurrRotation - 1)
+                        -- se rotazione attiva (SIDE)
+                        if string.sub( Part.ChosenCombination, nNextRotation, nNextRotation) == '1' then
+                           dNotClampHead, dNotClampTail = FeatureLib.GetFeatureRotationNotClampableLengths( MACHININGS[i].Proc, Part, nNextRotation)
+                           Part.NotClampableLength['SIDE'].dHead = max( Part.NotClampableLength['SIDE'].dHead, dNotClampHead)
+                           Part.NotClampableLength['SIDE'].dTail = max( Part.NotClampableLength['SIDE'].dTail, dNotClampTail)
+                        end
+                        nNextRotation = EgtIf( nNextRotation - 1 < 1, nNextRotation - 1 + 4, nNextRotation - 1)
+                        -- se rotazione attiva (STD)
+                        if string.sub( Part.ChosenCombination, nNextRotation, nNextRotation) == '1' then
+                           dNotClampHead, dNotClampTail = FeatureLib.GetFeatureRotationNotClampableLengths( MACHININGS[i].Proc, Part, nNextRotation)
+                           Part.NotClampableLength['STD'].dHead = max( Part.NotClampableLength['STD'].dHead, dNotClampHead)
+                           Part.NotClampableLength['STD'].dTail = max( Part.NotClampableLength['STD'].dTail, dNotClampTail)
+                        end
+                     elseif sRotation == 'SIDE' then
                      local nNextRotation = EgtIf( nCurrRotation - 1 < 1, nCurrRotation - 1 + 4, nCurrRotation - 1)
-                     -- se rotazione attiva (SIDE)
-                     if string.sub( Part.ChosenCombination, nNextRotation, nNextRotation) == '1' then
-                        dNotClampHead, dNotClampTail = FeatureLib.GetFeatureRotationNotClampableLengths( MACHININGS[i].Proc, Part, nNextRotation)
-                        Part.NotClampableLength['SIDE'].dHead = max( Part.NotClampableLength['SIDE'].dHead, dNotClampHead)
-                        Part.NotClampableLength['SIDE'].dTail = max( Part.NotClampableLength['SIDE'].dTail, dNotClampTail)
-                     end
-                     nNextRotation = EgtIf( nNextRotation - 1 < 1, nNextRotation - 1 + 4, nNextRotation - 1)
-                     -- se rotazione attiva (STD)
-                     if string.sub( Part.ChosenCombination, nNextRotation, nNextRotation) == '1' then
-                        dNotClampHead, dNotClampTail = FeatureLib.GetFeatureRotationNotClampableLengths( MACHININGS[i].Proc, Part, nNextRotation)
-                        Part.NotClampableLength['STD'].dHead = max( Part.NotClampableLength['STD'].dHead, dNotClampHead)
-                        Part.NotClampableLength['STD'].dTail = max( Part.NotClampableLength['STD'].dTail, dNotClampTail)
-                     end
-                  elseif sRotation == 'SIDE' then
-                    local nNextRotation = EgtIf( nCurrRotation - 1 < 1, nCurrRotation - 1 + 4, nCurrRotation - 1)
-                     -- se rotazione attiva (STD)
-                     if string.sub( Part.ChosenCombination, nNextRotation, nNextRotation) == '1' then
-                        dNotClampHead, dNotClampTail = FeatureLib.GetFeatureRotationNotClampableLengths( MACHININGS[i].Proc, Part, nNextRotation)
-                        Part.NotClampableLength['STD'].dHead = max( Part.NotClampableLength['STD'].dHead, dNotClampHead)
-                        Part.NotClampableLength['STD'].dTail = max( Part.NotClampableLength['STD'].dTail, dNotClampTail)
+                        -- se rotazione attiva (STD)
+                        if string.sub( Part.ChosenCombination, nNextRotation, nNextRotation) == '1' then
+                           dNotClampHead, dNotClampTail = FeatureLib.GetFeatureRotationNotClampableLengths( MACHININGS[i].Proc, Part, nNextRotation)
+                           Part.NotClampableLength['STD'].dHead = max( Part.NotClampableLength['STD'].dHead, dNotClampHead)
+                           Part.NotClampableLength['STD'].dTail = max( Part.NotClampableLength['STD'].dTail, dNotClampTail)
+                        end
                      end
                   end
                end
@@ -1175,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
@@ -1192,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
 
@@ -1234,7 +1513,19 @@ function MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machining, Part)
    local dToolEndFeed = TOOLS[Machining.nToolIndex].Feeds.dEndFeed
    local dToolFeed = TOOLS[Machining.nToolIndex].Feeds.dFeed
 
-   if Machining.nType == MCH_MY.MILLING then
+   if Machining.nType == MCH_MY.DRILLING then
+      local function fact(n) return n == 0 and 1 or n * fact(n - 1) end
+      local nSteps = ceil( Machining.sDepth / Machining.dStep)
+      local dLenghtEachStep = Machining.sDepth / nSteps
+      -- numero dei movimenti a step, compresi andata e ritorno per scarico truciolo
+      local nTotStepMovement = 2 * fact( nSteps)
+      -- in feed si lavorano solo gli step
+      local dFeedTime = ( ( dLenghtEachStep + Machining.dStartSafetyLength) * nSteps) / dToolFeed
+      -- ritorno per scaricare e approccio al prossimo step seno in feed finale
+      local dEndFeedTime = ( dLenghtEachStep * ( nTotStepMovement - nSteps) + EgtMdbGetGeneralParam( MCH_GP.SAFEZ) * 2) / dToolEndFeed
+      dLengthToMachineAllStepsWithLeadInOut = dLenghtEachStep * nTotStepMovement
+      dTimeToMachineTotal = dFeedTime + dEndFeedTime
+   elseif Machining.nType == MCH_MY.MILLING then
       -- stima LeadIn e LeadOut; se non settati si impostano a valori di default
       if not Machining.LeadIn.dTotalEstimatedDistance then
          Machining.LeadIn.dTotalEstimatedDistance = sqrt( Machining.LeadIn.dPerpDistance ^ 2 + Machining.LeadIn.dTangentDistance ^ 2) + Machining.dStartSafetyLength
@@ -1284,9 +1575,9 @@ function MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machining, Part)
       local ProcTm = FeatureLib.GetProcFromTrimesh( Machining.Geometry[1][1], Part)
       local dDepthToMachine = min( ProcTm.Faces[Machining.Geometry[1][2] + 1].dElevation, ( Machining.dMaxElev or ProcTm.Faces[Machining.Geometry[1][2] + 1].dElevation)) - ( max( 0, Machining.dResidualDepth or 0))
       local nSteps = max( ceil( ( dDepthToMachine - 50 * GEO.EPS_SMALL) / TOOLS[Machining.nToolIndex].dStep), 1)
-      local nAddGroupId = BeamLib.GetAddGroup( Part.id)
+      local idTempGroup = Part.idTempGroup
       -- TODO in futuro creare flatregion (se ci fossero isole il calcolo del percorso non sarebbe corretto)
-      local idFaceContour = EgtExtractSurfTmFacetLoops( ProcTm.id, Machining.Geometry[1][2], nAddGroupId)
+      local idFaceContour = EgtExtractSurfTmFacetLoops( ProcTm.id, Machining.Geometry[1][2], idTempGroup)
       -- si settano i lati aperti della curva derivata dalla superficie
       for i = 1, #ProcTm.Faces[Machining.Geometry[1][2] + 1].Edges do
          if ProcTm.Faces[Machining.Geometry[1][2] + 1].Edges[i].bIsOpen then
@@ -1294,7 +1585,7 @@ function MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machining, Part)
          end
       end
       -- dal momento che la funzione EgtPocketing non considera il grezzo, nei casi ottimizzati si deve correggere l'offset
-      local idTestCurve = EgtCopyGlob( idFaceContour, nAddGroupId )
+      local idTestCurve = EgtCopyGlob( idFaceContour, idTempGroup )
       local bIsOptimizedPocketing = ( TOOLS[Machining.nToolIndex].dDiameter > TOOLS[Machining.nToolIndex].dSideStep - 10 * GEO.EPS_SMALL)
                                     and EgtOffsetCurve( idTestCurve, -TOOLS[Machining.nToolIndex].dDiameter / 2 - 10 * GEO.EPS_SMALL)
       if not bIsOptimizedPocketing then
@@ -1310,7 +1601,7 @@ function MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machining, Part)
          end
       end
       -- calcolo percorso di svuotatura replicando il calcolo che fa la svuotatura
-      local idPocketingPath = EgtPocketing( idFaceContour, TOOLS[Machining.nToolIndex].dDiameter / 2, TOOLS[Machining.nToolIndex].dSideStep, 0, Machining.nSubType, true, nAddGroupId)
+      local idPocketingPath = EgtPocketing( idFaceContour, TOOLS[Machining.nToolIndex].dDiameter / 2, TOOLS[Machining.nToolIndex].dSideStep, 0, Machining.nSubType, true, idTempGroup)
       local dPocketingPathLength = EgtCurveLength( idPocketingPath)
       -- calcolo lunghezze e tempi totali
       if dPocketingPathLength then
@@ -1322,10 +1613,6 @@ function MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machining, Part)
          dLengthToMachineAllStepsWithLeadInOut = 99999 * nSteps
          dTimeToMachineTotal = dLengthToMachineAllStepsWithLeadInOut / dToolFeed
       end
-      -- le geometrie create si settano da cancellare
-      EgtSetLevel( idFaceContour, GDB_LV.TEMP)
-      EgtSetLevel( idPocketingPath, GDB_LV.TEMP)
-      EgtSetLevel( idTestCurve, GDB_LV.TEMP)
    else
       error( 'GetTimeToMachineAllStepsWithLeadInOut : unknown machining type')
    end
@@ -1429,19 +1716,6 @@ end
 -- TODO libreria Sorting??
 -------------------------------------------------------------------------------------------------------------
 local SortingComparisonRules = {
-   -- ordine interno alla feature
-   function( MachiningA, MachiningB)
-      if MachiningA.Proc.id == MachiningB.Proc.id then
-         if MachiningA.Machining.nFeatureInternalIndex < MachiningB.Machining.nFeatureInternalIndex then
-            return 1
-         elseif MachiningA.Machining.nFeatureInternalIndex > MachiningB.Machining.nFeatureInternalIndex then
-            return -1
-         end
-      end
-
-      return 0
-   end,
-
    -- dipendenze solo spostamento stage 2->4
    -- TODO da fare
 
@@ -1455,110 +1729,6 @@ local SortingComparisonRules = {
          return 0
       end
    end,
-
-   -- dipendenze
-   -- TODO da fare
-
-   -- segment
-   function ( MachiningA, MachiningB)
-      if MachiningA.Machining.nPartSegment < MachiningB.Machining.nPartSegment then
-         return 1
-      elseif MachiningA.Machining.nPartSegment > MachiningB.Machining.nPartSegment then
-         return -1
-      else
-         return 0
-      end
-   end,
-
-   -- testa
-   -- TODO da fare
-
-   -- famiglia utensile
-   function ( MachiningA, MachiningB)
-      -- TODO tirare fuori da qua??
-      local ToolFamilyOrder = {
-         SAWBLADE = 1,
-         DRILLBIT = 2,
-         MILL = 3,
-         MORTISE = 4
-      }
-      local nToolFamilyOrderA = ToolFamilyOrder[ TOOLS[ MachiningA.Machining.nToolIndex].sFamily]
-      local nToolFamilyOrderB = ToolFamilyOrder[ TOOLS[ MachiningB.Machining.nToolIndex].sFamily]
-
-      if nToolFamilyOrderA < nToolFamilyOrderB then
-         return 1
-      elseif nToolFamilyOrderA > nToolFamilyOrderB then
-         return -1
-      else
-         return 0
-      end
-   end,
-
-   -- performance utensile
-   function( MachiningA, MachiningB)
-      local dToolPerformanceIndexA = TOOLS[MachiningA.Machining.nToolIndex].dPerformanceIndex
-      local dToolPerformanceIndexB = TOOLS[MachiningB.Machining.nToolIndex].dPerformanceIndex
-
-      if dToolPerformanceIndexA > dToolPerformanceIndexB then
-         return 1
-      elseif dToolPerformanceIndexA < dToolPerformanceIndexB then
-         return -1
-      else
-         return 0
-      end
-   end,
-
-   -- probabilmente arrivati qui significa che gli utensili A e B sono gli stessi
-   -- se così non fosse e tutte le caratteristiche sopra sono uguali, ordine alfabetico
-   function( MachiningA, MachiningB)
-      local sToolNameA = TOOLS[MachiningA.Machining.nToolIndex].sName
-      local sToolNameB = TOOLS[MachiningB.Machining.nToolIndex].sName
-
-      if sToolNameA < sToolNameB then
-         return 1
-      elseif sToolNameA > sToolNameB then
-         return -1
-      else
-         return 0
-      end
-   end,
-
-   -- lato di lavoro
-   -- TODO questo, insieme all'ordinamento X, andrà sostituito dallo shortest path pesato sulla quantità di rotazione della testa
-   function( MachiningA, MachiningB)
-      if MachiningA.Machining.vtToolDirection:getY() < -0.174 and MachiningB.Machining.vtToolDirection:getY() >= 0.174  then
-         return 1
-      elseif MachiningA.Machining.vtToolDirection:getY() >= 0.174 and MachiningB.Machining.vtToolDirection:getY() < -0.174 then
-         return -1
-      else
-         return 0
-      end
-   end,
-
-   -- ordinamento X
-   -- TODO questo andrà sostituito dallo shortest path pesato sulla quantità di rotazione della testa
-   function( MachiningA, MachiningB)
-      local bIsMachiningOnFront = MachiningA.Machining.vtToolDirection:getY() < 10 * GEO.EPS_SMALL
-      local nResult = 0
-      
-      -- se lavorazione davanti ordine testa->coda
-      if bIsMachiningOnFront then
-         if MachiningA.Machining.ptCenter:getX() > MachiningB.Machining.ptCenter:getX() + 10 * GEO.EPS_SMALL then
-            nResult = 1
-         elseif MachiningA.Machining.ptCenter:getX() < MachiningB.Machining.ptCenter:getX() - 10 * GEO.EPS_SMALL then
-            nResult = -1
-         end
-      -- se lavorazione dietro ordine coda->testa
-      else
-         if MachiningA.Machining.ptCenter:getX() < MachiningB.Machining.ptCenter:getX() - 10 * GEO.EPS_SMALL then
-            nResult = 1
-         elseif MachiningA.Machining.ptCenter:getX() > MachiningB.Machining.ptCenter:getX() + 10 * GEO.EPS_SMALL then
-            nResult = -1
-         end
-      end
-
-      return nResult
-   end
 }
 
 -------------------------------------------------------------------------------------------------------------
@@ -1575,5 +1745,150 @@ function MachiningLib.CompareMachinings( MachiningA, MachiningB)
    return false
 end
 
+
+-------------------------------------------------------------------------------------------------------------
+local function OrderMachining( MachiningOptList)
+   -- Recupero l'identificativo del gruppo di lavoro corrente
+   for i = 1, #MachiningOptList - 1 do
+      local idSource = DB_MACH_APPLIED[MachiningOptList[i+1]].nOperationId
+      local idRef = DB_MACH_APPLIED[MachiningOptList[i]].nOperationId
+      EgtRelocateGlob( idSource, idRef, GDB_IN.AFTER)
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+function MachiningLib.ShortestPathSorting()
+   local i = 1
+   while i <= #DB_MACH_APPLIED do
+      local nMachInDisp = 0
+      local MachiningOptList = {}
+      local GroupInfo = {}
+
+      -- se è una lavorazione
+      if DB_MACH_APPLIED[i].sType ~= 'DISP' then
+         -- inizio
+         EgtOptMachInit()
+
+         -- feed dalla macchina
+         -- TODO abbassare per considere accelerazioni??
+         SetupInfo = BeamData.GetSetupInfo()
+         EgtOptMachSetFeeds( SetupInfo.dFeedLinearAxesAverage or 10000, SetupInfo.dFeedRotativeAxesAverage or 1000)
+
+         -- tra gruppi (stage) non si può ottimizzare
+         EgtOptMachSetAllGroupsDependencesAsMandatory( true)
+         EgtOptMachSetOptimizationForGroups( true)
+
+         -- se è una lavorazione
+         while DB_MACH_APPLIED[i] and DB_MACH_APPLIED[i].sType ~= 'DISP' do
+            -- se lavorazione non attiva non va considerata
+            local nOperationId = DB_MACH_APPLIED[i].nOperationId
+            if EgtGetOperationMode( nOperationId) then
+               local ptMinX, ptMaxX
+               -- aggiungo lavorazioni 
+               local nToolIndex = MACHININGS[DB_MACH_APPLIED[i].nIndexInMachinings].Machining.nToolIndex
+               EgtOptMachAddTool( nToolIndex, 2, 2) -- , [ num dTC_X, num dTC_Y, num dTC_Z, num dTC_A, num dTC_B, num dTC_C])
+               -- viene eseguito prima il gruppo con indice più alto, quindi si inverte indice dato che lo stage è dal più piccolo al più grande 
+               local nGroup = 10 - MACHININGS[DB_MACH_APPLIED[i].nIndexInMachinings].Machining.nStage
+               local MachStartAxesPos = DB_MACH_APPLIED[i].MachStartAxesPos
+               local MachEndAxesPos = DB_MACH_APPLIED[i].MachEndAxesPos
+               EgtOptMachAddMachining( i, nToolIndex, nGroup, MachStartAxesPos, MachEndAxesPos)
+               table.insert( MachiningOptList, i)
+
+               -- si salvano i punti minimi e massimi tra tutte le lavorazioni di ogni gruppo
+               if MachStartAxesPos[1] < MachEndAxesPos[1] then
+                  ptMinX = MachStartAxesPos
+                  ptMaxX = MachEndAxesPos
+               else
+                  ptMinX = MachEndAxesPos
+                  ptMaxX = MachStartAxesPos
+               end
+
+               -- si aggiungono le info di gruppo
+               local bFound = false
+               for t = 1, #GroupInfo do
+                  if GroupInfo[t].nGroup == nGroup then
+                     if GroupInfo[t].ptMin[1] > ptMinX[1] then GroupInfo[t].ptMin = ptMinX end
+                     if GroupInfo[t].ptMax[1] < ptMaxX[1] then GroupInfo[t].ptMax = ptMaxX end
+                     bFound = true
+                  end
+               end
+               -- se non ho trovato, si aggiunge in lista
+               if not bFound then
+                  table.insert( GroupInfo, { nGroup = nGroup, nStage = MACHININGS[DB_MACH_APPLIED[i].nIndexInMachinings].Machining.nStage, ptMin = ptMinX, ptMax = ptMaxX})
+               end
+
+               nMachInDisp = nMachInDisp + 1
+            end
+            i = i + 1
+         end
+
+         -- cliclo su tutte le lavorazioni
+         for k = 1, #MachiningOptList do
+            if not DB_MACH_APPLIED[MachiningOptList[k]].Dependances then
+               DB_MACH_APPLIED[MachiningOptList[k]].Dependances = {}
+            end
+            for j = 1, #MachiningOptList do
+               -- se non è stessa lavorazione, imposto dati e dipendenze
+               if k ~= j then
+                  local MachiningK = MACHININGS[DB_MACH_APPLIED[MachiningOptList[k]].nIndexInMachinings]
+                  local MachiningJ = MACHININGS[DB_MACH_APPLIED[MachiningOptList[j]].nIndexInMachinings]
+                  -- se stessa Proc
+                  if MachiningK.Proc.id == MachiningJ.Proc.id then
+                     -- se lavorazioni della stessa feature, obbligatorio rispettare ordine
+                     if MachiningK.Machining.nFeatureInternalIndex < MachiningJ.Machining.nFeatureInternalIndex then
+                        local bOk = EgtOptMachAddDependence( MachiningOptList[k], MachiningOptList[j])
+                        if not bOk then
+                           error( 'Machining sorting : error in dependencies')
+                        end
+                        table.insert( DB_MACH_APPLIED[MachiningOptList[k]].Dependances, MachiningOptList[j])
+                     -- se l'indice interno è uguale, sono cloni: si ordinano in base all'ordine in tabella
+                     elseif MachiningK.Machining.nFeatureInternalIndex == MachiningJ.Machining.nFeatureInternalIndex then
+                        if k < j then
+                           local bOk = EgtOptMachAddDependence( MachiningOptList[k], MachiningOptList[j])
+                           if not bOk then
+                              error( 'Machining sorting : error in dependencies')
+                           end
+                           table.insert( DB_MACH_APPLIED[MachiningOptList[k]].Dependances, MachiningOptList[j])
+                        end
+                     end
+                  -- se tra due Proc diverse
+                  else
+                     -- TODO :
+                     -- se ci sono dipendenze tra due feature diverse, la dipendenza è obbligatoria! ATTENZIONE A DIPENDENZE INCROCIATE A->B, B->C, C->A
+                  end
+               end
+            end
+         end
+
+         -- definisco gruppo per gruppo la direzione preferita di ottimizzazione
+         for t = 1, #GroupInfo do
+            -- se gruppo "Taglio di coda" l'ordinamento è al contrario
+            if GroupInfo[t].nStage == 3 then
+               -- start point
+               EgtOptMachSetOpenBoundForGroups( GroupInfo[t].nGroup, true, SHP_OB.NEAR_PNT, GroupInfo[t].ptMin[1], GroupInfo[t].ptMin[2], GroupInfo[t].ptMin[3])
+               -- end point
+               EgtOptMachSetOpenBoundForGroups( GroupInfo[t].nGroup, false, SHP_OB.NEAR_PNT, GroupInfo[t].ptMax[1], GroupInfo[t].ptMax[2], GroupInfo[t].ptMax[3])
+            -- in tutti gli altri gruppi si ordina sempre dalla testa alla coda
+            else
+               -- start point
+               EgtOptMachSetOpenBoundForGroups( GroupInfo[t].nGroup, true, SHP_OB.NEAR_PNT, GroupInfo[t].ptMax[1], GroupInfo[t].ptMax[2], GroupInfo[t].ptMax[3])
+               -- end point
+               EgtOptMachSetOpenBoundForGroups( GroupInfo[t].nGroup, false, SHP_OB.NEAR_PNT, GroupInfo[t].ptMin[1], GroupInfo[t].ptMin[2], GroupInfo[t].ptMin[3])
+            end
+         end
+
+         -- calcolo ordine lavorazioni
+         MachiningOptList = EgtOptMachCalculate( MachiningOptList)
+
+         OrderMachining( MachiningOptList)
+
+         -- fine
+         EgtOptMachTerminate()
+      end
+      i = i + 1
+   end
+end
+
+
 -------------------------------------------------------------------------------------------------------------
 return MachiningLib

LuaLibs/PreSimulationLib.lua

@@ -0,0 +1,487 @@
+-- PreSimulationLib.lua by Egalware s.r.l. 2025/11/24
+-- Libreria stima collisioni per travi
+
+-- Tabella per definizione modulo
+local PreSimulationLib = {}
+
+-- Include
+require( 'EgtBase')
+local BeamLib = require( 'BeamLib')
+local BeamData = require( 'BeamDataNew')
+
+EgtOutLog( ' PreSimulationLib started', 1)
+
+-------------------------------------------------------------------------------------------------------------
+local function GetMachineAxes()
+
+   local LinearAxes = {}
+   local RotativeAxes = {}
+
+   -- si recuperano tutti gli assi, lineari e rotativi
+   local AxesNames = EgtGetAllCurrAxesNames()
+   for i = 1, #AxesNames do
+      -- EgtGetAxisType restituisce vero se asse lineare, false se asse rotativo
+      if EgtGetAxisType( AxesNames[i]) then
+         LinearAxes[#LinearAxes + 1] = {}
+         LinearAxes[#LinearAxes].sName = AxesNames[i]
+      else
+         RotativeAxes[#RotativeAxes + 1] = {}
+         RotativeAxes[#RotativeAxes].sName = AxesNames[i]
+      end
+   end
+
+   return LinearAxes, RotativeAxes
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function LogOutstroke( ptOnToolTipCenter, vtHead, OptionalParameters)
+
+   -- parametri opzionali
+   OptionalParameters = OptionalParameters or {}
+   local LinearAxes = OptionalParameters.LinearAxes
+   local RotativeAxes = OptionalParameters.RotativeAxes
+
+   -- gruppo per geometrie temporanee
+   local idTempGroup = BeamLib.GetTempGroup()
+
+   -- si disegnano punto e vettore
+   local idPoint = EgtPoint( idTempGroup, ptOnToolTipCenter, GDB_RT.GLOB)
+   local idVector = EgtVector( idTempGroup, vtHead, ptOnToolTipCenter, GDB_RT.GLOB)
+   EgtSetColor( idPoint, RED())
+   EgtSetColor( idVector, RED())
+
+   -- si loggano valori di punto e vettore
+   EgtOutLog( ' Presimulation : OutStroke, Tip Point = ' .. tostring( ptOnToolTipCenter) .. ', id = ' .. idPoint .. ', vtHead = ' .. tostring( vtHead) .. ', id = ' .. idVector)
+
+   -- se disponibili, si loggano anche i valori calcolati degli assi
+   if LinearAxes then
+      EgtOutLog( ' ' .. LinearAxes[1].sName .. ' = ' .. tostring( LinearAxes[1].dValue) .. ', ' .. LinearAxes[2].sName .. ' = ' .. tostring( LinearAxes[2].dValue) .. ', ' .. LinearAxes[3].sName .. ' = ' .. tostring( LinearAxes[3].dValue))
+   end
+   if RotativeAxes then
+      EgtOutLog( ' ' .. RotativeAxes[1].sName .. ' = ' .. tostring( RotativeAxes[1].dValue) .. ', ' .. RotativeAxes[2].sName .. ' = ' .. tostring( RotativeAxes[2].dValue))
+   end
+
+   return
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- costruzione trimesh del grezzo restante in testa o in coda
+local function GetRestlengthSurfTm( Part, sSide)
+
+   -- si costruisce il box in globale
+   local b3RestLength
+   if sSide == 'Head' then
+      local b3PartWithOvermaterial = BeamLib.GetPartBoxWithHeadTail( Part, sSide)
+      local ptStartRestLength = Point3d( Part.b3Part:getMax():getX(), Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
+      local ptEndRestLength = Point3d( b3PartWithOvermaterial:getMax():getX(), Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
+      b3RestLength = BBox3d( ptStartRestLength, ptEndRestLength)
+   elseif sSide == 'Tail' then
+      local b3PartWithOvermaterial = BeamLib.GetPartBoxWithHeadTail( Part, sSide)
+      local dXMin = b3PartWithOvermaterial:getMin():getX()
+      -- si evita sempre di lavorare col motore dietro la coda della barra (potrebbe succedere con barra restante molto corta): in quel caso si deve sempre separare prima
+      dXMin = min( dXMin, Part.b3Part:getMin():getX() - 2000)
+      local ptStartRestLength = Point3d( Part.b3Part:getMin():getX(), Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
+      local ptEndRestLength = Point3d( dXMin, Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
+      b3RestLength = BBox3d( ptStartRestLength, ptEndRestLength)
+   -- caso non testato, non dovrebbe mai finire qui (il default che arriva da fuori è Tail)
+   else
+      return nil
+   end
+
+   -- si crea la trimesh dal box
+   local idRestLengthBoxTm = EgtSurfTmBBox( Part.idTempGroup, b3RestLength , false, GDB_RT.GLOB)
+
+   return idRestLengthBoxTm
+end
+
+-------------------------------------------------------------------------------------------------------------
+function PreSimulationLib.GetPointOnToolTipCenter( ptPointAtDepth, vtHead, vtNFace, vtToolOffset, Tool)
+
+   return ptPointAtDepth + vtToolOffset * Tool.dDiameter / 2 + vtNFace * EgtIf( AreSameVectorApprox( vtHead, vtNFace), 0, Tool.dThickness)
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- calcolo punto sull'uscita testa a partire dal punto di lavorazione o di attacco sul diametro utensile
+local function GetToolExitPoint( ptMachining, vtNEdge, vtHead, Tool, bIsDownUp)
+
+   local ptToolExitPoint = Point3d( ptMachining + vtNEdge * Tool.dDiameter / 2) + vtHead * EgtIf( bIsDownUp, ( Tool.dLength - Tool.dThickness), Tool.dLength)
+
+   return ptToolExitPoint
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- calcolo pivot in riferimento globale, datipunto sull'uscita utensile e direzioni
+local function GetGlobalPivot( ptToolExit, vtC, vtHead, vtMovePivot)
+
+   -- frame solidale all'utensile (lo stesso in cui vtMovePivot è definito)
+   local frTool = Frame3d( ptToolExit, vtHead, vtC)
+   local vtMovePivotGlob = Vector3d( vtMovePivot)
+   vtMovePivotGlob:toGlob( frTool)
+   local ptPivot = ptToolExit + vtMovePivotGlob
+
+   return ptPivot
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- restituisce i punti notevoli della lavorazioni in cui fare il controllo
+local function GetCollisionPointsToCheck( Edge, dDepthToMachine)
+
+   local PointsToCheck = {}
+
+   -- punti notevoli
+   local ptStart = Edge.ptStart + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
+   local ptEnd = Edge.ptEnd + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
+   local ptMid = Point3d( ( ptStart + ptEnd) / 2)
+
+   -- caso ottimizzato: lato parallelo ad una direzione principale
+   local bIsEdgeParallelToMainDirection =
+      AreSameOrOppositeVectorApprox( Edge.vtEdge, X_AX())
+      or AreSameOrOppositeVectorApprox( Edge.vtEdge, Y_AX())
+      or AreSameOrOppositeVectorApprox( Edge.vtEdge, Z_AX())
+
+   -- aggiunta punti
+   table.insert( PointsToCheck, ptStart)
+   if not bIsEdgeParallelToMainDirection then
+      table.insert( PointsToCheck, ptMid)
+   end
+   table.insert( PointsToCheck, ptEnd)
+
+   return PointsToCheck
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function CheckOutOfStrokePoint( ptOnToolTipCenter, vtHead, nSCC, Tool)
+
+   -- impostazione utensile
+   EgtSetCalcTool( Tool.sName, Tool.sHead, Tool.nExit)
+
+   -- settaggio SCC per discriminare soluzioni multiple
+   EgtSetCalcSolCh( nSCC)
+
+   -- assi macchina da calcolare
+   local LinearAxes, RotativeAxes = GetMachineAxes()
+
+   -- se più di 3 assi lineari e 2 assi rotativi, macchina non supportata
+   if #LinearAxes > 3 or #RotativeAxes > 2 then
+
+      error(' CheckOutOfStrokePoint : too many axes')
+   end
+
+   -- calcolo assi rotativi
+   local bOkAngles, nSolutionsAngles, dRot1, dRot2 = EgtGetCalcAngles( vtHead)
+   RotativeAxes[1].dValue = dRot1
+   RotativeAxes[2].dValue = dRot2
+
+   if not bOkAngles then
+      error( ' CheckOutOfStrokePoint : error')
+   end
+
+   -- se nessuna soluzione dagli assi rotativi, è in extracorsa
+   if nSolutionsAngles == 0 then
+
+      if EgtGetDebugLevel() >= 3 then
+         LogOutstroke( ptOnToolTipCenter, vtHead)
+      end
+      return true
+   end
+
+   -- calcolo assi lineari
+   local bOkPositions, _, dLinear1, dLinear2, dLinear3 = EgtGetCalcPositions( ptOnToolTipCenter, RotativeAxes[1].dValue, RotativeAxes[2].dValue)
+   LinearAxes[1].dValue = dLinear1
+   LinearAxes[2].dValue = dLinear2
+   LinearAxes[3].dValue = dLinear3
+
+   if not bOkPositions then
+
+      error( ' CheckOutOfStrokePoint : error')
+   end
+
+   -- verifica finecorsa per tutti gli assi
+   -- siccome non si sa a priori il numero di assi lineari e rotativi, si aggiungono tutti a Args in ordine
+   -- Args viene poi esplosa in modo da passare a EgtVerifyOutstroke i valori separati
+   local Args = {}
+   for i = 1, #LinearAxes do
+      Args[#Args+1] = LinearAxes[i].dValue
+   end
+   for i = 1, #RotativeAxes do
+      Args[#Args+1] = RotativeAxes[i].dValue
+   end
+
+   local bAllAxesInStroke = EgtVerifyOutstroke( table.unpack( Args))
+
+   -- extracorsa
+   if not bAllAxesInStroke then
+
+      if EgtGetDebugLevel() >= 3 then
+         LogOutstroke( ptOnToolTipCenter, vtHead, { LinearAxes = LinearAxes, RotativeAxes = RotativeAxes})
+      end
+      return true
+   end
+
+   -- EgtSetAxisPos( 'T', dT)
+   -- EgtSetAxisPos( 'Y', dY)
+   -- EgtSetAxisPos( 'Z', dZ)
+   -- EgtSetAxisPos( 'C', dC1)
+   -- EgtSetAxisPos( 'A', dA1)
+
+   -- se si arriva qui, il punto non è in finecorsa
+   return false
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- check extracorsa da punti sul tip dell'utensile
+function PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool)
+
+   for i = 1, #PointsOnToolTipCenter do
+
+      local bOutOfStroke = CheckOutOfStrokePoint( PointsOnToolTipCenter[i], vtHead, nSCC, Tool)
+
+      -- se trovato extracorsa inutile procedere con gli altri punti
+      if bOutOfStroke then
+         return true
+      end
+   end
+
+   -- se arrivati qui, nessun extracorsa
+   return false
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- check extracorsa da geometria
+-- TODO da considerare anche gli attacchi
+function PreSimulationLib.CheckOutOfStrokeFromGeometry( idGeometry, vtHead, nSCC, Tool)
+
+   local b3GeomMaxOffset = EgtGetBBoxGlob( idGeometry, GDB_BB.STANDARD)
+   local ptBoxCenter = b3GeomMaxOffset:getCenter()
+   local dBoxDimX = b3GeomMaxOffset:getDimX()
+   local dBoxDimY = b3GeomMaxOffset:getDimY()
+   local dBoxDimZ = b3GeomMaxOffset:getDimZ()
+
+   -- si controlla il finecorsa nei punti al centro delle 6 facce del box
+   local PointsOnToolTipCenter = {}
+   -- X+
+   table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter + dBoxDimX / 2 * X_AX()))
+   -- X-
+   table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter - dBoxDimX / 2 * X_AX()))
+   -- Y+
+   table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter + dBoxDimY / 2 * Y_AX()))
+   -- Y-
+   table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter - dBoxDimY / 2 * Y_AX()))
+   -- Z+
+   table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter + dBoxDimZ / 2 * Z_AX()))
+   -- Z-
+   table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter - dBoxDimZ / 2 * Z_AX()))
+
+   local bOutOfStroke = PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool)
+
+   return bOutOfStroke
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function CheckCollisionPoint( ptToolExitToCheck, vtC, vtHead, PreCollisionData, Part, bCannotSplitRestLength, sRestLengthSideForPreSimulation, bCheckOnlyRestlength)
+
+   local ptPivot = GetGlobalPivot( ptToolExitToCheck, vtC, vtHead, PreCollisionData.vtMovePivot)
+
+   -- orientamento del riferimento locale
+   local vtDirectionX = PreCollisionData.Directions.vtDirectionX
+   local vtDirectionY = PreCollisionData.Directions.vtDirectionY
+   local vtDirectionZ = PreCollisionData.Directions.vtDirectionZ
+
+   -- costruzione trimesh a partire dalla curva di collisione
+   -- recupero punti da macchina per costruire trimesh
+   local CollisionCurvePoints = PreCollisionData.Points
+   -- curva di collisione in riferimento locale
+   local idCollisionCurve = EgtCurveCompoFromPoints( Part.idTempGroup, CollisionCurvePoints)
+   -- curva in riferimento globale
+   local frReference = Frame3d( ptPivot, vtDirectionZ, vtDirectionX)
+   EgtTransform( idCollisionCurve, frReference, GDB_RT.GLOB)
+   -- trimesh di collisione
+   local idCollisionSurfTm
+   if PreCollisionData.bSurfTmByRevolve then
+      idCollisionSurfTm = EgtSurfTmByRevolve( Part.idTempGroup, idCollisionCurve, ptPivot, vtDirectionY, true, 0.05, GDB_RT.GLOB)
+   else
+      local vtPreMove = -vtDirectionZ * ( PreCollisionData.dExtrusionDepth / 2)
+      EgtMove( idCollisionCurve, vtPreMove, GDB_RT.GLOB)
+      local vtExtrusion = vtDirectionZ * PreCollisionData.dExtrusionDepth
+      idCollisionSurfTm = EgtSurfTmByRegionExtrusion( Part.idTempGroup, idCollisionCurve, vtExtrusion, 0.05, GDB_RT.GLOB)
+   end
+
+   -- check collisione con pezzo
+   local bCollisionFoundPiece = false
+   if not bCheckOnlyRestlength then
+      local idCheckCollisionTm = Part.idBoxTm
+      -- se testa o coda attaccate, si considerano nella superficie di collisione
+      if bCannotSplitRestLength then
+         local b3CheckCollision = BeamLib.GetPartBoxWithHeadTail( Part, sRestLengthSideForPreSimulation)
+         idCheckCollisionTm = EgtSurfTmBBox( Part.idTempGroup, b3CheckCollision, false, GDB_RT.GLOB)
+      end
+      bCollisionFoundPiece = EgtCDeSolidSolid( idCheckCollisionTm, idCollisionSurfTm, BeamData.COLL_SIC)
+      if not type( bCollisionFoundPiece) == "boolean" then
+         error( 'Presimulation fail')
+      end
+      if EgtGetDebugLevel() >= 3 and bCollisionFoundPiece then
+         EgtSetColor( idCollisionSurfTm, RED())
+      end
+
+      -- se trovata collisione con pezzo è inutile procedere con il grezzo
+      if bCollisionFoundPiece then
+         return true
+      end
+   end
+
+   -- check collisione con grezzo restante, se con il pezzo non c'è collisione e non è un taglio di testa o coda
+   local bCollisionFoundRestLength = false
+   if not ( bCollisionFoundPiece or bCannotSplitRestLength) then
+      local idRestLengthSurfFr = GetRestlengthSurfTm( Part, sRestLengthSideForPreSimulation)
+      if idRestLengthSurfFr then
+         bCollisionFoundRestLength = EgtCDeSolidSolid( idRestLengthSurfFr, idCollisionSurfTm, BeamData.COLL_SIC)
+         if not type( bCollisionFoundRestLength) == "boolean" then
+            error( 'Presimulation fail')
+         end
+         if EgtGetDebugLevel() >= 3 and bCollisionFoundRestLength then
+            EgtSetColor( idCollisionSurfTm, ORANGE())
+         end
+      end
+   end
+
+   return false, bCollisionFoundRestLength
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- controllo collisione con verifica intersezione trimesh e geometrie da macchina
+local function CheckCollisionWithAxis( sAxis, MachiningParameters, OptionalParameters)
+
+   -- parametri obbligatori
+   local Edge = MachiningParameters.Edge
+   local vtNFace = MachiningParameters.vtNFace
+   local vtHead = MachiningParameters.vtHead
+   local Part = MachiningParameters.Part
+   local Tool = MachiningParameters.Tool
+   local dDepthToMachine = MachiningParameters.dDepthToMachine
+
+   -- parametri opzionali
+   OptionalParameters = OptionalParameters or {}
+   local bCheckOnlyRestlength = OptionalParameters.bCheckOnlyRestlength or false
+   local sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation or 'Tail'
+   local bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength or false
+
+   -- se normale faccia non parallela a direzione testa c'è qualcosa che non va
+   if not AreSameOrOppositeVectorApprox( vtNFace, vtHead) then
+      error( 'CheckCollisionWithAxis : invalid directions')
+   end
+   
+   -- punti notevoli della lavorazione in cui fare il check
+   local PointsToCheck = OptionalParameters.PointsToCheck or GetCollisionPointsToCheck( Edge, 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, #PointsToCheck do
+      ToolExitPoints[i] = GetToolExitPoint( PointsToCheck[i], Edge.vtN, vtHead, Tool, bIsDownUp)
+   end
+
+   -- vtC punta sempre verso il corpo dell'asse C o verso l'aggregato
+   local nSCC = Tool.SetupInfo.GetSCC( Edge.vtN, Edge.vtEdge, vtNFace)
+   local vtSCC = BeamLib.GetDirectionFromSCC( nSCC)
+   local vtC = vtHead ^ Tool.SetupInfo.vtRotationAxisC
+   vtC:normalize()
+   if vtC:isZero() then
+      vtC = vtSCC
+   elseif vtC * vtSCC < GEO.EPS_SMALL then
+      vtC = -vtC
+   end
+
+   -- punti curva collisione e direzioni check da macchina
+   local PreCollisionData = Tool.SetupInfo.GetPreCollisionData( sAxis, vtC, vtHead)
+
+   local bMoveAfterSplit = false
+
+   -- se almeno in un punto c'è collisione con il pezzo si ritorna collisione
+   -- se non si trova collisione si ritorna se è necessario separare prima di effettuare la lavorazione (ossia non c'è collisione con il pezzo ma c'è con il grezzo restante)
+   for i = 1, #ToolExitPoints do
+
+      local bCollisionFoundPiece, bCollisionFoundRestLength = CheckCollisionPoint( ToolExitPoints[i], vtC, vtHead, PreCollisionData, Part, bCannotSplitRestLength, sRestLengthSideForPreSimulation, bCheckOnlyRestlength)
+
+      -- se trovata collisione con pezzo è inutile controllare gli altri punti
+      if bCollisionFoundPiece then
+
+         return true
+
+      -- se trovata collisione con grezzo si setta che la lavorazione è da fare dopo separazione e si prosegue con gli altri punti
+      elseif bCollisionFoundRestLength then
+
+         bMoveAfterSplit = true
+      end
+   end
+
+   -- se si arriva qui significa che non è stata trovata alcuna collisione con pezzo
+   return false, bMoveAfterSplit
+end
+
+-------------------------------------------------------------------------------------------------------------
+function PreSimulationLib.CheckCollision( sBladeEngagement, Parameters, OptionalParameters)
+
+   local bCollisionFound
+   local bMoveAfterSplitZ, bMoveAfterSplitC, bMoveAfterSplitAB
+
+   -- parametri opzionali, in parte da far transitare
+   OptionalParameters = OptionalParameters or {}
+
+   local OptionalParametersCheckCollisionWithAxis = {}
+   OptionalParametersCheckCollisionWithAxis.bCheckOnlyRestlength = false
+   OptionalParametersCheckCollisionWithAxis.PointsToCheck = OptionalParameters.PointsToCheck or nil
+   OptionalParametersCheckCollisionWithAxis.sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation or 'Tail'
+   OptionalParametersCheckCollisionWithAxis.bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength or false
+
+   local bIsDicing = OptionalParameters.bIsDicing or false
+   local bCheckOnlyRestlengthForAxisABC = false
+
+   -- se cubetti in modalità standard (no DownUp) gli assi AB e C si controllano solo con grezzo (ci sarebbe collisione con il materiale già rimosso controllando AB e C con pezzo)
+   if bIsDicing and ( sBladeEngagement == 'Standard') then
+      bCheckOnlyRestlengthForAxisABC = true
+   -- se l'elevazione reale (rispetto al pezzo + eventuale materiale in testa/coda) è maggiore del massimo materiale è sempre collisione
+   -- TODO rifare con funzione
+   else
+      local Edge = Parameters.Edge
+      local vtNFace = Parameters.vtNFace
+      local dDepthToMachine = Parameters.dDepthToMachine
+      local b3BoxForElevationCheck = BBox3d( Parameters.Part.b3Part)
+      -- se è un taglio di testa o coda va aggiunto il sovramateriale
+      if OptionalParametersCheckCollisionWithAxis.bCannotSplitRestLength then
+         b3BoxForElevationCheck = BeamLib.GetPartBoxWithHeadTail( Parameters.Part, OptionalParametersCheckCollisionWithAxis.sRestLengthSideForPreSimulation)
+      end
+      -- trimesh rettangolare con un lato corrispondente al lato da lavorare e larghezza come spessore utensile
+      local idTrimesh = EgtSurfTmRectangle( Parameters.Part.idTempGroup, Edge.ptStart, Edge.ptEnd, Edge.ptEnd + vtNFace * Parameters.Tool.dThickness, GDB_RT.GLOB)
+      local vtNTrimesh = EgtSurfTmFacetNormVersor( idTrimesh, 0, GDB_ID.ROOT)
+      -- se trimesh con normale opposta a quella del lato, si inverte (non si sa a priori che verso avrà)
+      if not AreSameVectorApprox( Edge.vtN, vtNTrimesh) then
+         EgtInvertSurf( idTrimesh)
+      end
+      local dRealElevation = EgtSurfTmFacetElevationInBBox( idTrimesh, 0, b3BoxForElevationCheck, true, GDB_ID.ROOT)
+      local dRealDepthToMachine = ( dRealElevation - Parameters.Edge.dElevation + dDepthToMachine)
+      if dRealDepthToMachine > Parameters.Tool.dMaxDepth + 10 * GEO.EPS_SMALL then
+         return true
+      end
+   end
+
+   -- asse Z si controlla sempre
+   bCollisionFound, bMoveAfterSplitZ = CheckCollisionWithAxis( 'Z', Parameters, OptionalParametersCheckCollisionWithAxis)
+
+   -- assi AB e C: se richiesto si controlla la collisione solo col grezzo
+   OptionalParametersCheckCollisionWithAxis.bCheckOnlyRestlength = bCheckOnlyRestlengthForAxisABC
+
+   if not bCollisionFound then
+      bCollisionFound, bMoveAfterSplitAB = CheckCollisionWithAxis( 'AB', Parameters, OptionalParametersCheckCollisionWithAxis)
+   end
+
+   if not bCollisionFound then
+      bCollisionFound, bMoveAfterSplitC = CheckCollisionWithAxis( 'C', Parameters, OptionalParametersCheckCollisionWithAxis)
+   end
+
+   local bMoveAfterSplit = bMoveAfterSplitZ or bMoveAfterSplitC or bMoveAfterSplitAB
+
+   return bCollisionFound, bMoveAfterSplit
+end
+
+-------------------------------------------------------------------------------------------------------------
+return PreSimulationLib

LuaLibs/TimeLib.lua

@@ -0,0 +1,122 @@
+-- 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 TimeLibInstance = setmetatable({}, TimeLib)
+   TimeLibInstance.dStartTime = os.clock()
+   TimeLibInstance.Measurements = {}
+   return TimeLibInstance
+end
+
+-- reset entire timer
+function TimeLib:start()
+   self.dStartTime = os.clock()
+   self.Measurements = {}
+end
+
+-- start elapsed measurement for a specific name
+function TimeLib:startElapsed(sName)
+   local sMeasurementName = sName or "Default"
+   local dNow = os.clock()
+
+   if not self.Measurements[sMeasurementName] then
+      self.Measurements[sMeasurementName] = {
+         dStart = dNow,
+         dLast = 0,
+         dCumulative = 0,
+         dRecent = 0,
+         nCount = 0
+      }
+   else
+      self.Measurements[sMeasurementName].dStart = dNow
+   end
+end
+
+-- stop elapsed measurement (increments count and updates cumulative)
+function TimeLib:stopElapsed(sName)
+   local sMeasurementName = sName or "Default"
+   local dNow = os.clock()
+   local Measurement = self.Measurements[sMeasurementName]
+
+   if Measurement and Measurement.dStart then
+      local dDuration = dNow - Measurement.dStart
+      Measurement.dRecent = dDuration
+      Measurement.dCumulative = Measurement.dCumulative + dDuration
+      Measurement.dLast = dNow
+      Measurement.nCount = Measurement.nCount + 1
+      Measurement.dStart = nil
+   else
+      -- if stop called without start, initialize with zero
+      self.Measurements[sMeasurementName] = {
+         dStart = nil,
+         dLast = dNow,
+         dCumulative = 0,
+         dRecent = 0,
+         nCount = 0
+      }
+   end
+end
+
+-- reset elapsed for a specific measurement
+function TimeLib:resetElapsed(sName)
+   local sMeasurementName = sName or "Default"
+   self.Measurements[sMeasurementName] = nil
+end
+
+-- return elapsed times: total, cumulative, recent, count
+function TimeLib:getElapsed(sName)
+   local dTotal = os.clock() - self.dStartTime
+   local sMeasurementName = sName or "Default"
+   local Measurement = self.Measurements[sMeasurementName]
+
+   if Measurement then
+      return dTotal, Measurement.dCumulative, Measurement.dRecent, Measurement.nCount
+   else
+      return dTotal, nil, nil, 0
+   end
+end
+
+-- log elapsed times for one measurement
+function TimeLib:logElapsed(sName)
+   local dTotal, dCumulative, dRecent, nCount = self:getElapsed(sName)
+   local sMeasurementName = sName or "Default"
+
+   if dCumulative then
+      EgtOutLog(string.format(
+         "%s(#%d): recent %.3f, cumulative %.3f, total %.3f",
+         sMeasurementName, nCount, dRecent, dCumulative, dTotal))
+   else
+      EgtOutLog(string.format("Total %.3f (no '%s' measurement started)",
+         dTotal, sMeasurementName))
+   end
+end
+
+-- log elapsed times for all measurements
+function TimeLib:logAllElapsed()
+   local dTotal = os.clock() - self.dStartTime
+   if next(self.Measurements) == nil then
+      EgtOutLog(string.format("Total %.3f (no measurements started)", dTotal))
+      return
+   end
+
+   for sMeasurementName, Measurement in pairs(self.Measurements) do
+      local dCumulative = Measurement.dCumulative
+      local dRecent = Measurement.dRecent
+      local nCount = Measurement.nCount
+      EgtOutLog(string.format(
+         "%s(#%d): recent %.3f, cumulative %.3f, total %.3f",
+         sMeasurementName, nCount, dRecent, dCumulative, dTotal))
+   end
+end
+
+return TimeLib

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 = {}

NestProcessNew.lua

@@ -0,0 +1,556 @@
+-- BeamNestProcess.lua by Egaltech s.r.l. 2023/01/15
+-- Gestione nesting automatico travi
+-- 2022/10/05 Piccole modifiche per far funzionare correttamente i compilati.
+-- 2022/10/06 Corretto bug che moltiplicava i pezzi se erano presenti più grezzi della stessa sezione.
+-- 2023/01/15 Piccole correzioni.
+
+-- Intestazioni
+require( 'EgtBase')
+_ENV = EgtProtectGlobal()
+EgtEnableDebug( false)
+
+-- Per test
+--NEST = {}
+--NEST.FILE = 'c:\\TechnoEssetre7\\EgtData\\Prods\\0010\\Bar_10_1.btl'
+--NEST.MACHINE = 'Essetre-90480019_MW'
+--NEST.FLAG = 3
+
+local sLog = ' +++ BeamNestProcess : ' .. NEST.FILE
+EgtOutLog( sLog)
+
+-- flag per abilitare statistiche in log
+local bLogStat = false
+
+-- Cancello file di log specifico
+local sLogFile = EgtChangePathExtension( NEST.FILE, '.txt')
+EgtEraseFile( sLogFile) 
+
+-- Funzioni per scrittura su file di log specifico
+local function WriteErrToLogFile( nErr, sMsg, nRot, nCutId, nTaskId)
+   local hFile = io.open( sLogFile, 'a')
+   hFile:write( 'ERR=' .. tostring( nErr) .. '\n')
+   hFile:write( sMsg .. '\n')
+   hFile:write( 'ROT=' .. tostring( nRot or 0) .. '\n')
+   hFile:write( 'CUTID=' .. tostring( nCutId or 0) .. '\n')
+   hFile:write( 'TASKID=' .. tostring( nTaskId or 0) .. '\n')
+   hFile:close()
+end
+
+local function WriteTimeToLogFile( dTime)
+   local hFile = io.open( sLogFile, 'a')
+   hFile:write( 'TIME=' .. EgtNumToString( dTime) .. '\n')
+   hFile:close()
+end
+
+-- Funzione per gestire visualizzazione dopo errore
+local function PostErrView( nErr, sMsg)
+   if nErr ~= 0 and ( NEST.FLAG == 1 or NEST.FLAG == 2 or NEST.FLAG == 5) then
+      EgtSetView( SCE_VD.ISO_SW, false)
+      EgtZoom( SCE_ZM.ALL)
+      EgtOutBox( sMsg, 'BatchProcess (err=' .. tostring( nErr) .. ')', 'ERRORS')
+   end
+end
+
+-- Funzione per gestire visualizzazione dopo warning
+local function PostWarnView( nWarn, sMsg)
+   if nWarn ~= 0 and ( NEST.FLAG == 1 or NEST.FLAG == 2 or NEST.FLAG == 5) then
+      EgtSetView( SCE_VD.ISO_SW, false)
+      EgtZoom( SCE_ZM.ALL)
+      EgtOutBox( sMsg, 'BatchProcess (wrn=' .. tostring( nWarn) .. ')', 'WARNINGS')
+   end
+end
+
+-- Funzione per aggiornare dati ausiliari
+local function UpdateAuxData( sAuxFile)
+   local bModif = false
+   -- Se definito LOAD90, aggiorno
+   local sLoad90 = EgtGetStringFromIni( 'AuxData', 'LOAD90', '', sAuxFile) 
+   if sLoad90 ~= '' then
+      local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or GDB_ID.NULL
+      EgtSetInfo( BtlInfoId, 'LOAD90', sLoad90)
+      bModif = true
+   end
+   return bModif
+end
+
+local function PartsToFill( Parts)
+   local nToFill = 0
+   for i = 1, #Parts do
+      if Parts[i].Cnt > 0 then
+         nToFill = nToFill + Parts[i].Cnt
+      end
+   end
+   return nToFill
+end
+
+local function ExecMaximumFilling( Raw, Parts)
+   -- Inizializzo maximum filler
+   EgtMaxFillerStart()
+   -- Inserisco i pezzi
+   for i = 1, #Parts do
+      EgtMaxFillerAddPart( i, Parts[i].Len, Parts[i].DispLen or Parts[i].Len, Parts[i].Cnt or 1)
+   end
+   -- Eseguo l'ottimizzazione
+   EgtMaxFillerCompute( Raw.LenToFill, Raw.StartGap, Raw.MidGap, Raw.EndGap, Raw.SortType)
+   -- Recupero i risultati
+   local nFilledParts, nDiffParts, dTotFillRatio = EgtMaxFillerGetResults()
+   local OneRes = {}
+   for i = 0, nDiffParts - 1 do
+      local nPartId, nCount = EgtMaxFillerGetOneResult( i)
+      table.insert( OneRes, { Id=nPartId, Count=nCount})
+   end
+   --return { FilledParts=nFilledParts, DiffParts=nDiffParts, FillRatio=dTotFillRatio, Time=dTime, Data=OneRes}
+   return { FilledParts=nFilledParts, DiffParts=nDiffParts, FillRatio=dTotFillRatio, Data=OneRes}
+end
+
+-- Funzione per trovare nome MachGroup
+local function NewMachGroupName()
+   local nMachGroupId = EgtGetFirstMachGroup()
+   if not nMachGroupId then return 1 end
+   local nMaxMachGroup = 0
+   while nMachGroupId do
+      sMachGroupName = EgtGetMachGroupName(nMachGroupId)
+      local nMachGroupName = tonumber(sMachGroupName)
+      if nMachGroupName > nMaxMachGroup then
+         nMaxMachGroup = nMachGroupName
+      end
+      nMachGroupId = EgtGetNextMachGroup(nMachGroupId)
+   end
+   return nMaxMachGroup + 1
+end
+
+local function TotRawCount(Raws)
+   local nTotRaws = 0
+   for RawIndex = 1, #Raws do
+      nTotRaws = nTotRaws + Raws[RawIndex].Count
+   end
+   return nTotRaws
+end
+
+local function TotPartLen(Parts)
+   local nTotPartLen = 0
+   for PartIndex = 1, #Parts do
+      nTotPartLen = nTotPartLen + ( Parts[PartIndex].Len * Parts[PartIndex].Cnt)
+   end
+   return nTotPartLen
+end
+
+-- Imposto direttorio libreria specializzata per Travi
+EgtAddToPackagePath( NEST.BASEDIR .. '\\LuaLibs\\?.lua')
+
+-- recupero cartella macchine
+local sIniFilePath = EgtGetIniFile()
+local MachineDirPath = EgtGetStringFromIni( 'Mach', 'MachinesDir', '', sIniFilePath)
+-- Verifico che tutte le macchine siano abilitate per la lavorazione delle Travi
+for MachineIndex = 1, #NEST.MACHINELIST do
+   local sMachDir = MachineDirPath .. '\\' .. NEST.MACHINELIST[MachineIndex]
+   if not EgtExistsFile( sMachDir .. '\\Beam\\BeamData.lua') then
+      NEST.ERR = 12
+      NEST.MSG = 'Error not configured for beam machine : ' .. sMachine
+      WriteErrToLogFile( NEST.ERR, NEST.MSG)
+      PostErrView( NEST.ERR, NEST.MSG)
+      return
+   end
+end
+
+---- Imposto la macchina corrente e verifico sia abilitata per la lavorazione delle Travi
+--EgtSetCurrMachine( NEST.MACHINE)
+--local sMachDir = EgtGetCurrMachineDir()
+--if not EgtExistsFile( sMachDir .. '\\Beam\\BeamData.lua') then
+--   NEST.ERR = 12
+--   NEST.MSG = 'Error not configured for beam machine : ' .. sMachine
+--   WriteErrToLogFile( NEST.ERR, NEST.MSG)
+--   PostErrView( NEST.ERR, NEST.MSG)
+--   return
+--end
+
+---- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie
+--EgtRemoveBaseMachineDirFromPackagePath()
+--EgtAddToPackagePath( sMachDir .. '\\Beam\\?.lua')
+
+-- Inizializzo contatori errori e avvisi
+local nErrCnt = 0
+local nWarnCnt = 0
+
+-- Grezzi
+local Raws = {}
+for nRawIndex = 1, #RAWLIST do
+   local Raw = RAWLIST[nRawIndex]
+   table.insert( Raws, {LenToFill = Raw.Len, StartGap = NEST.STARTOFFSET, MidGap = NEST.OFFSET, EndGap = 0, SortType = -1, Count = Raw.Qty})
+end
+-- cerco il grezzo con la lunghezza maggiore, epurata dello start gap
+local maxRawLenToFillNoStartGap = 0
+for RawIndex = 1, #Raws do
+   if Raws[RawIndex].Count > 0 then
+      maxRawLenToFillNoStartGap = max( maxRawLenToFillNoStartGap, Raws[RawIndex].LenToFill - Raws[RawIndex].StartGap)
+   end
+end
+
+-- Pezzi
+local Parts = {}
+-- ciclo su pezzi per aggiungerli al nesting
+local dTotLen = 0
+for nPartId, nCount in pairs( PARTLIST) do
+   -- recupero lunghezza pezzo
+   local Len = EgtGetInfo( nPartId, "L", 'd')
+   local DispLen = EgtIf( Len <= 1000, 2000, 0) --EgtIf( Len <= 2000, max( 2000, 6000 - Len), 0)
+   -- aggiungo il pezzo solo se ci sta nel grezzo più lungo a disposizione
+   if Len < maxRawLenToFillNoStartGap then
+      for nCntIndex = 1 , nCount do
+         table.insert( Parts, {Id = nPartId, Len = Len, DispLen = DispLen, Cnt = 1})
+         dTotLen = dTotLen + Len
+      end
+   end
+end
+
+-- lunghezza totale pezzi
+local dTotPartLen = TotPartLen( Parts)
+-- calcolo media delle barre necessarie
+local NeededRawsForType = {}
+for RawIndex = 1, #Raws do
+   NeededRawsForType[RawIndex] = min( ceil( dTotPartLen / Raws[RawIndex].LenToFill), Raws[RawIndex].Count)
+end
+local RawQtySum = 0
+for NeededRawIndex = 1, #NeededRawsForType do
+   RawQtySum = RawQtySum + NeededRawsForType[NeededRawIndex] 
+end
+local MediumRawQty = ceil( RawQtySum / #NeededRawsForType) 
+if MediumRawQty > 1 then
+   MediumRawQty = MediumRawQty - 1
+end
+
+-- lista dei risultati
+local ResultList = {}
+local BestResult = nil
+local BestResultIndex = nil
+-- riordino lista pezzi per lunghezza
+table.sort( Parts, function( B1, B2) return B1.Len < B2.Len end)
+
+local function NestSolutionByIndex( Index)
+   
+   -- creo copia lista raw
+   local TempRaws = {}
+   for TempRawIndex = 1, #Raws do
+      table.insert(TempRaws, {LenToFill = Raws[TempRawIndex].LenToFill, StartGap = Raws[TempRawIndex].StartGap, MidGap = Raws[TempRawIndex].MidGap, EndGap = Raws[TempRawIndex].EndGap, SortType = Raws[TempRawIndex].SortType, Count = Raws[TempRawIndex].Count})
+   end
+   
+   -- recupero pezzi corti
+   local ShortList = {}
+   local LongList = {}
+
+   for PartIndex = 1, #Parts do
+      if PartIndex <= Index then
+         table.insert( ShortList, Parts[PartIndex])
+      else
+         table.insert( LongList, Parts[PartIndex])
+      end
+      Parts[PartIndex].Cnt = 1
+   end
+   -- numero di pezzi piccoli per barra
+   local ShortCount = Index
+   local ShortForRaw = floor( ShortCount / MediumRawQty)
+   local ExtraShortForRaw = 0
+   if MediumRawQty > 0 then
+      ExtraShortForRaw = fmod( ShortCount, MediumRawQty)
+   end
+   -- creo lista pezzi corti singoli
+   local SingleShortList = {}
+   for ShortIndex = 1, #ShortList do
+      for ShortCount = 1, ShortList[ShortIndex].Cnt do
+         table.insert( SingleShortList, {Id = ShortList[ShortIndex].Id, Len = ShortList[ShortIndex].Len, DispLen = ShortList[ShortIndex].DispLen, Cnt = 1})
+      end
+   end 
+   -- li divido per le barre previste
+   local RawsShortList = {}
+   local RawIndex = 0
+   local ShortRawIndex = 0
+   for ShortIndex = 1, #SingleShortList do
+      if ShortRawIndex > 0 then
+         table.insert( RawsShortList[RawIndex], SingleShortList[ShortIndex])
+         ShortRawIndex = ShortRawIndex - 1
+      else
+         table.insert( RawsShortList, {SingleShortList[ShortIndex]})
+         RawIndex = RawIndex + 1
+         ShortRawIndex = ShortForRaw + EgtIf( RawIndex <= ExtraShortForRaw, 1, 0) - 1
+      end
+   end
+
+   -- Ciclo fino ad esaurimento pezzi o barre
+   local dTotPartInRawLen = 0
+   local nRawTot = 0
+   local dRawTotLen = 0
+   local dTime = 0
+   local nCycle = 1
+   local CurrResult = {}
+   while TotRawCount( TempRaws) > 0 and PartsToFill( Parts) > 0 do
+      
+      -- creo lista con pezzi lunghi e pezzi corti di questo Cycle
+      local PartsToNest = {}
+      for PartIndex = 1, #LongList do
+         table.insert( PartsToNest, LongList[PartIndex])
+      end
+      for CycleIndex = 1, #RawsShortList do
+         if CycleIndex <= nCycle then
+            for PartIndex = 1, #RawsShortList[CycleIndex] do
+               table.insert( PartsToNest, RawsShortList[CycleIndex][PartIndex])
+            end
+         end
+      end
+      
+      -- se non ci sono pezzi da nestare, esco
+      if PartsToFill( PartsToNest) <= 0 then
+         break
+      end
+      -- Eseguo ottimizzazione per ogni lunghezza di barra
+      local Results = {}
+      for RawIndex = 1, #TempRaws do
+         if TempRaws[RawIndex].Count > 0 then
+            Results[RawIndex] = ExecMaximumFilling( TempRaws[RawIndex], PartsToNest)
+         else
+            Results[RawIndex] = { FillRatio = 0.001, LenToFill = 1000, DiffParts = 0}
+         end
+      end
+      -- verifico quale e' quella con meno scarto
+      local nMinWasteRawIndex = GDB_ID.NULL
+      local dMinWaste = 100000
+      for ResultIndex = 1, #Results do
+         if Results[ResultIndex] then
+            local dWaste = (1 - Results[ResultIndex].FillRatio) * TempRaws[ResultIndex].LenToFill
+            if Results[ResultIndex].DiffParts > 0 and dWaste < dMinWaste then
+               dMinWaste = dWaste
+               nMinWasteRawIndex = ResultIndex
+            end
+         end
+      end
+      -- verifico se ci sono pezzi
+      if nMinWasteRawIndex > 0 and Results[nMinWasteRawIndex] and Results[nMinWasteRawIndex].DiffParts > 0 then
+         -- riporto barra e pezzi nel risultato corrente 
+         local CurrBar = { BarLen = TempRaws[nMinWasteRawIndex].LenToFill,  Parts = {}}
+         local CurrX = TempRaws[nMinWasteRawIndex].StartGap
+         local nInfoIndex = 1
+         for i = 1, Results[nMinWasteRawIndex].DiffParts do
+            local PartIndex = Results[nMinWasteRawIndex].Data[i].Id
+            local PartId = PartsToNest[PartIndex].Id
+            local dLen = PartsToNest[PartIndex].Len
+            for j = 1, Results[nMinWasteRawIndex].Data[i].Count do
+               -- creo pezzo copia
+               CurrPart = { Index = nInfoIndex, PartId = PartId, PosX = CurrX}
+               table.insert( CurrBar.Parts, CurrPart)
+               CurrX = CurrX + dLen + TempRaws[nMinWasteRawIndex].MidGap
+               nInfoIndex = nInfoIndex + 1
+            end
+         end
+         table.insert( CurrResult, CurrBar)
+         dTotPartInRawLen = dTotPartInRawLen + ( Results[nMinWasteRawIndex].FillRatio * TempRaws[nMinWasteRawIndex].LenToFill)
+         nRawTot = nRawTot + 1
+         dRawTotLen = dRawTotLen + TempRaws[nMinWasteRawIndex].LenToFill
+         -- Aggiorno per prossima iterazione
+         TempRaws[nMinWasteRawIndex].Count = TempRaws[nMinWasteRawIndex].Count - 1
+         for i = 1, Results[nMinWasteRawIndex].DiffParts do
+            local PartId = Results[nMinWasteRawIndex].Data[i].Id
+            PartsToNest[PartId].Cnt = PartsToNest[PartId].Cnt - Results[nMinWasteRawIndex].Data[i].Count
+         end
+      else
+         -- se non sono riuscito ad inserire alcun pezzo esco dal ciclo perche' non ci sono pezzi inseribili
+         break
+      end
+      nCycle = nCycle + 1
+   end
+   -- riporto risultato in lista
+   ResultList[Index] = dTotPartInRawLen
+   if not BestResult or not BestResultIndex or
+      ( dTotPartInRawLen > ResultList[BestResultIndex] + 0.02 or ( abs( dTotPartInRawLen - ResultList[BestResultIndex]) < 0.02 and dRawTotLen < BestResult.RawTotLen - 0.02)) then
+      BestResult = CurrResult
+      BestResult.RawTotLen = dRawTotLen
+      BestResultIndex = Index
+   end
+end
+
+local CycleCount = 0
+
+local MinTime = 10 + pow( 3, ceil( log10( #Parts)) - 1)
+if bLogStat then EgtOutLog('MinTime: ' .. MinTime ) end
+local MaxTime = 30 + pow( 7, ceil( log10( #Parts)) - 1)
+if bLogStat then EgtOutLog('MaxTime: ' .. MaxTime ) end
+local TargetRatio = 0.98
+local dTargetRatioLen = TargetRatio * dTotLen
+if bLogStat then EgtOutLog('TargetRatioLen: ' .. dTargetRatioLen ) end
+local CurrTime = 0
+
+local function NestSolutionFromSP( StartingPoint, OscillationStep)
+   -- ciclo sulle possibilita' da un punto di origine con uno step fisso
+   local CurrResultIndex = StartingPoint
+   NestSolutionByIndex( StartingPoint)
+   if OscillationStep == 0 then return end
+   local CycleIndex = 1
+   local nOutOfBoundary = 0
+   while nOutOfBoundary ~= 3 do
+      CurrTime = EgtStopCounter() / 1000
+      if bLogStat then EgtOutLog('CurrTime: ' .. CurrTime ) end
+      if bLogStat then EgtOutLog('BestRatio: ' .. dTotLen / BestResult.RawTotLen ) end
+      -- se e' passato il tempo massimo, o e' passato il tempo minimo, ha inserito tutti i pezzi e la percentuale di utilizzo del materiale e' maggiore della soglia
+      if CurrTime > MaxTime or ( CurrTime > MinTime and ResultList[BestResultIndex] > dTotLen - 0.1 and ( dTotLen / BestResult.RawTotLen ) >= TargetRatio) then 
+         if bLogStat then EgtOutLog('Brake') end
+         break
+      end
+      local bCurrOutOfBoundary = false
+      if CurrResultIndex < 0 then
+         bCurrOutOfBoundary = true
+         if nOutOfBoundary == 2 then
+            nOutOfBoundary = 3
+         else
+            nOutOfBoundary = 1
+         end
+      end
+      if CurrResultIndex > #Parts then
+         bCurrOutOfBoundary = true
+         if nOutOfBoundary == 1 then
+            nOutOfBoundary = 3
+         else
+            nOutOfBoundary = 2
+         end
+      end
+      if not bCurrOutOfBoundary and not ResultList[CurrResultIndex] then
+         NestSolutionByIndex( CurrResultIndex)
+         if bLogStat then EgtOutLog('CurrResultIndex: ' .. CurrResultIndex ) end
+         if bLogStat then EgtOutLog('Result: ' .. ResultList[CurrResultIndex]) end
+         CycleCount = CycleCount + 1
+      end
+      CurrResultIndex = StartingPoint + EgtIf( CycleIndex % 2 == 0, (CycleIndex / 2) * OscillationStep, -( ( CycleIndex + 1) / 2) * OscillationStep )
+      CycleIndex = CycleIndex + 1
+   end
+end
+   
+-- lancio calcolo
+EgtStartCounter()
+local StartingResult = floor( #Parts * 0.3)
+if bLogStat then EgtOutLog('StartingResult: ' .. StartingResult ) end
+--local Step = floor( #Parts / 10) * floor( log10( #Parts))
+local nDividendo = pow( 10, floor( log10( #Parts)) - 1)
+nDividendo = EgtIf( nDividendo ~= 1, nDividendo, 10)
+local Step = floor( #Parts / nDividendo) * floor( log10( #Parts))
+if bLogStat then EgtOutLog('Step: ' .. Step ) end
+NestSolutionFromSP( StartingResult, Step)
+if Step > 1 then
+   NestSolutionFromSP( StartingResult, 1)
+end
+
+-- se esiste un MachGorup precedente
+local nPreviousNestIndex = 0
+local nLastMachGroupId = EgtGetLastMachGroup()
+if nLastMachGroupId then
+   nPreviousNestIndex = EgtGetInfo( nLastMachGroupId, "NestIndex", 'i')
+end
+for nMachineIndex = 1, #NEST.MACHINELIST do
+   local sMachineName = NEST.MACHINELIST[nMachineIndex]
+   -- imposto macchina corrente
+   EgtSetCurrMachine( sMachineName)
+   -- elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie
+   local sMachDir = EgtGetCurrMachineDir()
+   EgtRemoveBaseMachineDirFromPackagePath()
+   EgtAddToPackagePath( sMachDir .. '\\Beam\\?.lua')
+   -- creo gruppi di lavorazione per risultato
+   for nMachGroupIndex = 1, #BestResult do
+      local CurrMachGroup = BestResult[nMachGroupIndex]
+      -- creo gruppo di lavorazione
+      local MachGroupName = NewMachGroupName()
+      nMachGroup = EgtAddMachGroup( MachGroupName)
+      EgtSetInfo( nMachGroup, "NestIndex", nPreviousNestIndex + nMachGroupIndex)
+      EgtSetInfo( nMachGroup, "BARLEN", CurrMachGroup.BarLen)
+      EgtSetInfo( nMachGroup, "MATERIAL", NEST.MATERIAL)
+      EgtSetInfo( nMachGroup, "AUTONEST", 1)
+      -- scrivo dati per variabili P di comunicazione con la macchina in gruppo di lavorazione
+      EgtSetInfo( nMachGroup, "PRODID", NEST.PRODID)
+      EgtSetInfo( nMachGroup, "PATTID", nMachGroup)
+      -- Disegno i pezzi
+      for i = 1, #CurrMachGroup.Parts do
+         local CurrPart = CurrMachGroup.Parts[ i]
+         -- creo pezzo copia
+         local nPartDuploId = EgtDuploNew( CurrPart.PartId)
+         EgtSetInfo( nMachGroup, "PART" .. CurrPart.Index, nPartDuploId .. "," .. CurrPart.PosX)
+         -- se esiste lista etichette
+         local sTagList = ''
+         if #NEST.MACHINELIST == 1 then
+            sTagList = EgtGetInfo( CurrPart.PartId, 'LuxTagList')
+         else
+            sTagList = EgtGetInfo( CurrPart.PartId, 'LuxTagList' .. nMachineIndex)
+            if not sTagList or #sTagList <= 0 then
+               sTagList = EgtGetInfo( CurrPart.PartId, 'LuxTagList')
+               EgtSetInfo( CurrPart.PartId, 'LuxTagList' .. nMachineIndex, sTagList)
+            end
+         end
+         if sTagList and #sTagList then
+            -- elimino eventuali liste etichette da duplo
+            EgtRemoveInfo( nPartDuploId, 'LuxTagList')
+            for nRemoveTagMachineIndex = 1, nMachineIndex - 1 do
+               EgtRemoveInfo( nPartDuploId, 'LuxTagList' .. nRemoveTagMachineIndex)
+            end
+            -- recupero liste etichette usate e non
+            local TagTypeList = EgtSplitString( sTagList, ';')
+            local UnusedTagList = {}
+            local UsedTagList = {}
+            if #TagTypeList == 1 then
+               UnusedTagList = EgtSplitString( sTagList, ',')
+            else
+               if TagTypeList[1] and #TagTypeList[1] > 0 then
+                  UnusedTagList = EgtSplitString( TagTypeList[1], ',')
+               end
+               if TagTypeList[2] and #TagTypeList[2] > 0 then
+                  UsedTagList = EgtSplitString( TagTypeList[2], ',')
+               end
+            end
+            local nAssignedTagIndex = #UnusedTagList
+            local sAssignedTag = UnusedTagList[nAssignedTagIndex]
+            -- creo stringa per info etichette aggiornata
+            local sNewTagList = ''
+            for nUnusedTagIndex = 1, nAssignedTagIndex - 1 do
+               sNewTagList = sNewTagList .. UnusedTagList[nUnusedTagIndex] .. EgtIf( nUnusedTagIndex < nAssignedTagIndex - 1, ',', '')
+            end
+            sNewTagList = sNewTagList .. ';' .. UnusedTagList[nAssignedTagIndex] .. EgtIf( #UsedTagList > 0, ',', '')
+            for nUsedTagIndex = 1, #UsedTagList do
+               sNewTagList = sNewTagList .. UsedTagList[nUsedTagIndex] .. EgtIf( nUsedTagIndex < #UsedTagList, ',', '')
+            end
+            -- assegno etichetta a nuovo duplo
+            EgtSetInfo( nPartDuploId, 'LuxTag', sAssignedTag)
+            if #NEST.MACHINELIST == 1 then
+               EgtSetInfo( CurrPart.PartId, 'LuxTagList', sNewTagList)
+            else
+               EgtSetInfo( CurrPart.PartId, 'LuxTagList' .. nMachineIndex, sNewTagList)
+            end
+         end
+      end
+   end
+   EgtResetCurrMachGroup()
+end
+
+-- creo grezzi per ogni gruppo di lavorazione
+local nRawCnt = 0
+local nRawTot = ResultList[BestResultIndex]
+_G.BEAM = {}
+BEAM.FILE = NEST.FILE
+--BEAM.MACHINE = NEST.MACHINE
+BEAM.FLAG = 6    -- CREATE_PANEL
+BEAM.BASEDIR = NEST.BASEDIR
+nMachGroup = EgtGetFirstMachGroup()
+while nMachGroup do
+   local nNextMachGroup = EgtGetNextMachGroup( nMachGroup)
+   EgtSetCurrMachGroup( nMachGroup)
+   if EgtGetInfo( nMachGroup, "AUTONEST",'i') == 1 then
+      EgtRemoveInfo( nMachGroup, "AUTONEST")
+      EgtSetInfo( nMachGroup, "UPDATEUI", 1)
+      local bOk, sErr = pcall( dofile, BEAM.BASEDIR .. "\\BatchProcessNew.lua")
+      if not bOk then
+         EgtOutLog( 'Error in BatchProcessNew.lua call (' .. ( sErr or '') ..')')
+      end
+      nRawCnt = nRawCnt + 1
+      -- aggiorno interfaccia
+      EgtProcessEvents( 200 + ( nRawCnt / nRawTot * 100), 0)
+   end
+   nMachGroup = nNextMachGroup
+end
+
+EgtResetCurrMachGroup()
+
+NEST.ERR = 0
+
+EgtOutLog( ' +++ BeamNestProcess completed')

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')
@@ -24,7 +24,7 @@ if not sMachDir then
    EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Travi', 'ERROR')
    return
 end
-if not EgtExistsFile( sMachDir .. '\\Beam\\BeamData.lua') then
+if not EgtExistsFile( sMachDir .. '\\Beam\\BeamDataNew.lua') then
    EgtOutBox( 'La macchina corrente non è configurata per lavorare travi', 'Lavora Travi', 'ERROR')
    return
 end
@@ -46,11 +46,15 @@ _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.BeamData = nil
+_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.
@@ -76,7 +80,7 @@ end
 PARTS = {}          -- tabella contenente tutte le informazioni di ogni pezzo
 
 -- Carico i dati globali
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 -- carico librerie
 local BeamExec = require( 'BeamExec')
 local BeamLib = require( 'BeamLib')
@@ -300,8 +304,6 @@ end
 --    *** Inserimento delle lavorazioni nelle travi ***
 -------------------------------------------------------------------------------------------------------------
 local function MyProcessFeatures()
-   -- creo un gruppo temporaneo dove finiranno tutte le entità che non bisogna salvare, alla fine lo si cancella
-   local idTempGroup = BeamLib.CreateTempGroup()
 
    BeamExec.GetProcessings( PARTS, bCalcBestPieceUnloadPosition)
    BeamExec.GetCombinationMatrix( PARTS, bCalcBestPieceUnloadPosition)
@@ -320,7 +322,7 @@ local function MyProcessFeatures()
       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
-         -- nulla da segnalare
+         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'
@@ -348,6 +350,7 @@ local function MyProcessFeatures()
    end
 
    -- cancello gruppo temporaneo
+   local idTempGroup = BeamLib.GetTempGroup()
    EgtErase( idTempGroup)
 
    if #sOutput > 0 then EgtOutLog( sOutput) end
@@ -365,11 +368,21 @@ 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
@@ -377,4 +390,10 @@ if not GetDataConfig() then return end
 -- Abilito Vmill
 EgtSetInfo( EgtGetCurrMachGroup(), 'Vm', '1')
 
-if not MyProcessFeatures() then return end
+MyProcessFeatures()
+
+-- log tempi di esecuzione
+if EgtGetDebugLevel() >= 3 then
+   TIMER:logAllElapsed()
+end
+

Strategies/AvailableStrategyList.json

@@ -66,7 +66,7 @@
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010" } ]
          },
          {  "sName": "Bevel-1-Through",
-            "sImage": "ConfigStrategy\\Cut-1-Through.png",
+            "sImage": "ConfigStrategy\\Bevel-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010" } ]
          }
       ]
@@ -227,6 +227,10 @@
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]
+         },
+         {  "sName": "DoubleBevel-2-Through",
+            "sImage": "ConfigStrategy\\DoubleBevel-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          }
       ]
    },
@@ -837,8 +841,8 @@
       "nGrp": 0,
       "TopologyList" : [
          {  "sName": "Feature",
-            "sImage": "",
-            "StrategyList" : [ ]
+            "sImage": "ConfigStrategy\\ProfileHead.png",
+            "StrategyList" : [ { "sStrategyId": "STR0015" } ]
          }
       ]
    },

Strategies/GeneralParameters.json

@@ -90,6 +90,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",
@@ -106,7 +117,7 @@
       "sName": "GEN_dMaxWasteLength",
       "sNameNge": "GEN_MAX_WASTE_LENGTH",
       "sValue": "300",
-      "sDescriptionShort": "Maximum Waste Length for Dice-cut",
+      "sDescriptionShort": "Maximum length for dropped waste",
       "sDescriptionLong": "",
       "sType": "d",
       "sMessageId": " ",
@@ -117,7 +128,18 @@
       "sName": "GEN_dMaxWasteVolume",
       "sNameNge": "GEN_MAX_WASTE_VOLUME",
       "sValue": "6000000",
-      "sDescriptionShort": "Maximum Waste Volume for Dice-cut",
+      "sDescriptionShort": "Maximum volume for dropped waste",
+      "sDescriptionLong": "",
+      "sType": "d",
+      "sMessageId": " ",
+      "sMinUserLevel": "5"
+   },
+   {
+      "nGroup": "MACHINING STRATEGY",
+      "sName": "GEN_dMaxDimDice",
+      "sNameNge": "GEN_MAX_DIM_DICE",
+      "sValue": "150",
+      "sDescriptionShort": "Maximum dice dimension",
       "sDescriptionLong": "",
       "sType": "d",
       "sMessageId": " ",

Strategies/Standard/HEADCUT/HEADCUT.lua

@@ -5,7 +5,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local FeatureLib = require( 'FeatureLib')
 local MachiningLib = require( 'MachiningLib')
 local SPLITCUT = require( 'SPLITCUT')
@@ -34,17 +34,23 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
    Strategy.Result.sInfo = ''
    local OptionalParameters = { bForceChainSaw = Strategy.Parameters.bForceChainSaw, bReduceBladePath = Strategy.Parameters.bReduceBladePath,
                                 dMaxWasteLength = Strategy.Parameters.dMaxWasteLength, dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume }
+   OptionalParameters.sRestLengthSideForPreSimulation = 'Head'
+   OptionalParameters.bCannotSplitRestLength = true
    local bAreAllMachiningsAdded = true
 
-   -- si setta che è taglio di coda
+   -- si setta che è taglio di testa
    Strategy.bIsHeadCut = true
 
    -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
    if Strategy.Parameters.bExecutePreCut then
       Strategy.SplitStrategy, Strategy.Result = SPLITCUT.GetMachining( Proc, Part, OptionalParameters)
       -- se non faccio tagli PRECUT, imposto tabella Result direttamente. Non serve verificare che riesca a rimuovere il materiale extra 
-      if not Strategy.SplitStrategy or #Strategy.SplitStrategy == 0 then
-         Strategy.Result.sInfo = 'PreCut on head not possible'
+      -- if not Strategy.SplitStrategy or #Strategy.SplitStrategy == 0 then
+      --    Strategy.Result.sInfo = 'PreCut on head not possible'
+      -- end
+      if Strategy.Result.sStatus ~= 'Completed' then
+         Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Precut Head not possible')
+         return false, Strategy.Result
       end
    end
 
@@ -54,6 +60,10 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
    -- TODO di quale utensile si deve impostare la qualità qui?
    Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
 
+   -- se coincide con inizio grezzo, non va fatto
+   if abs( Proc.b3Box:getCenter():getX() - Part.b3Raw:getMax():getX()) < 10 * GEO.EPS_SMALL then
+      return true, Strategy.Result
+   end
 
    -- se devo applicare le lavorazioni
    if bAddMachining then
@@ -66,10 +76,11 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       end
 
       local MachiningsToAdd = {}
-      local bExecutePrecutOnly = Part.dHeadOverMaterial < 20
+      local bExecutePrecutOnly = false
       -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
       if Strategy.Parameters.bExecutePreCut then
-
+         bExecutePrecutOnly = Part.dHeadOverMaterial < 20
+         
          if Strategy.SplitStrategy and #Strategy.SplitStrategy > 0 then
             for i = 1, #Strategy.SplitStrategy do
                local TempList = {}
@@ -87,25 +98,35 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       end
 
       if not bExecutePrecutOnly then
-         local OptionalParameters = {}
-         -- si parte dal box della feature e si aggiunge il punto estremo del grezzo
-         -- ATTENZIONE : Proc.b3Box viene modificata dato che il tipo Box è come se fosse una tabella, ma da qui passa solo 1 volta per pezzo quindi non dovrebbero esserci problemi
-         local b3BoxDicing = Proc.b3Box
-         b3BoxDicing:Add( Part.b3Raw:getMax())
-         b3BoxDicing:expand( 1000 * GEO.EPS_SMALL)
-         OptionalParameters.b3BoxDicing = b3BoxDicing
 
-         OptionalParameters.dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume
-         OptionalParameters.dMaxWasteLength = Strategy.Parameters.dMaxWasteLength
-         OptionalParameters.bReduceBladePath = Strategy.Parameters.bReduceBladePath
+         -- si recuperano gli estremi del box del materiale di testa da togliere
+         local b3PartWithHead = BeamLib.GetPartBoxWithHeadTail( Part, 'Head')
+         local ptStartRestLength = Point3d( Part.b3Part:getMax():getX() - 1, Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
+         local ptEndRestLength = Point3d( b3PartWithHead:getMax():getX(), Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
 
-         Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParameters)
+         local OptionalParametersBladeToWaste = {}
+         OptionalParametersBladeToWaste.b3BoxDicing = BBox3d( ptStartRestLength, ptEndRestLength)
+         OptionalParametersBladeToWaste.dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume
+         OptionalParametersBladeToWaste.dMaxWasteLength = Strategy.Parameters.dMaxWasteLength
+         OptionalParametersBladeToWaste.bReduceBladePath = Strategy.Parameters.bReduceBladePath
+         OptionalParametersBladeToWaste.sRestLengthSideForPreSimulation = 'Head'
+         OptionalParametersBladeToWaste.bCannotSplitRestLength = true
+
+         Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
+         -- se taglio non riuscito, si riprova con il riduci percorso forzato (collisione possibile in separazione pezzi alti)
+         if ( not Strategy.Machining) or ( #Strategy.Machining == 0) then
+            OptionalParametersBladeToWaste.bReduceBladePath = true
+            Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
+         end
          if Strategy.Machining and #Strategy.Machining > 0 then
             for i = 1, #Strategy.Machining do
                local TempList = {}
                TempList = Strategy.Machining[i]
                table.insert( MachiningsToAdd, TempList)
             end
+         else
+            Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Head machining not possible')
+            return false, Strategy.Result
          end
       end
 

Strategies/Standard/STR0001/STR0001.lua

@@ -5,9 +5,10 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
+local PreSimulationLib = require( 'PreSimulationLib')
 -- strategie di base
 local BladeToWaste = require('BLADETOWASTE')
 
@@ -183,6 +184,23 @@ local function GetTenonStrategy( Proc, Part)
                   Machining.Milling.AuxiliaryData.Clones[nIndexClones].dRadialOffset = ( i - 1) * dRealSideStep
                end
             end
+
+            -- test finecorsa sulla passata più esterna: se extracorsa, la lavorazione non è fattibile
+            -- TODO sostituire con applicazione della lavorazione?
+            -- TODO funzione per allungare il percorso??????
+            local idGeomMaxOffset = EgtCopyGlob( Proc.FeatureInfo.idAddAuxGeom, Part.idTempGroup)
+            EgtOffsetCurve( idGeomMaxOffset, Machining.Milling.AuxiliaryData.Clones[1].dRadialOffset + TOOLS[Machining.Milling.ToolInfo.nToolIndex].dDiameter / 2, Part.idTempGroup)
+            local vtCurveStart = EgtSV( idGeomMaxOffset, GDB_ID.ROOT)
+            local vtCurveEnd = EgtEV( idGeomMaxOffset, GDB_ID.ROOT)
+            local ptCurveStart = EgtSP( idGeomMaxOffset, GDB_ID.ROOT) + -vtCurveStart * Machining.Milling.LeadIn.dTangentDistance + ( Proc.FeatureInfo.vtTenonN ^ -vtCurveStart) * Machining.Milling.LeadIn.dPerpDistance
+            local ptCurveEnd = EgtEP( idGeomMaxOffset, GDB_ID.ROOT) + vtCurveEnd * Machining.Milling.LeadOut.dTangentDistance + ( vtCurveEnd ^ Proc.FeatureInfo.vtTenonN) * Machining.Milling.LeadOut.dPerpDistance
+            EgtAddCurveCompoArcTg( idGeomMaxOffset, ptCurveStart, false, GDB_RT.GLOB)
+            EgtAddCurveCompoArcTg( idGeomMaxOffset, ptCurveEnd, true, GDB_RT.GLOB)
+            local bOutOfStroke = PreSimulationLib.CheckOutOfStrokeFromGeometry( idGeomMaxOffset, Proc.FeatureInfo.vtTenonN, Machining.Milling.nSCC, TOOLS[Machining.Milling.ToolInfo.nToolIndex])
+            if bOutOfStroke then
+               Machining.Milling.bIsApplicable = false
+            end
+
             -- tempo di svuotatura
             Result.Milling.dTimeToMachine = MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machining.Milling, Part)
          else

Strategies/Standard/STR0002/STR0002.json

@@ -25,7 +25,7 @@
       {
          "sName": "dOpenMinSafe",
          "sNameNge": "OPENMINSAFE",
-         "sValue": "40",
+         "sValue": "10",
          "sDescriptionShort": "Minimum approach distance on open sides",
          "sDescriptionLong": "Minimum approach distance on open sides",
          "sType": "d",

Strategies/Standard/STR0002/STR0002.lua

@@ -16,7 +16,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 
@@ -101,7 +101,7 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 -- TODO va gestita meglio la decisione delle facce da lavorare
-local function GetBestPocketingStrategy( Proc)
+local function GetBestPocketingStrategy( Proc, Part)
    -- imposto parametri di ricerca utensile in base a topologia
    local Machining = {}
    local Milling = {}
@@ -180,6 +180,19 @@ local function GetBestPocketingStrategy( Proc)
       Milling.ToolInfo = {}
       Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
       if Milling.ToolInfo.nToolIndex then
+         -- se faccia singola e feature lavorata in unica lavorazione si può sempre affondare
+         if Proc.Topology.sName == 'Cut-1-Through'
+            or Proc.Topology.sName == 'Bevel-1-Through' then
+            -- eventuali punti di spezzatura
+            local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
+            local bIsSplitFeature = false
+            if #FeatureSplittingPoints > 0 then
+               bIsSplitFeature = true
+            end
+            if not bIsSplitFeature then
+               Milling.ToolInfo.dResidualDepth = 0
+            end
+         end
          Milling.bIsApplicable = true
          local ParametersMRR = {}
          ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
@@ -428,7 +441,12 @@ end
 local function GetSplitSurfaces( Proc, Part, bAddMachining)
    local vAddId = {}
    local vAddIdTunnel = {}
-   local nAddGrpId = BeamLib.GetAddGroup( Part.id)
+   local idAddGroup
+   if bAddMachining then
+      idAddGroup = BeamLib.GetAddGroup( Part.id)
+   else
+      idAddGroup = Part.idTempGroup
+   end
    local nOriginalTmIdTunnel = GDB_ID.NULL
    if Proc.MainFaces.TunnelAddedFaces then
       nOriginalTmIdTunnel = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.id
@@ -438,18 +456,14 @@ local function GetSplitSurfaces( Proc, Part, bAddMachining)
    local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
 
    if #FeatureSplittingPoints == 0 then
-      local nAddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
-      local nAddIdTunnel = EgtCopyGlob( nOriginalTmIdTunnel, nAddGrpId) or GDB_ID.NULL
-      if not bAddMachining then
-         EgtSetLevel( nAddId, GDB_LV.TEMP)
-         EgtSetLevel( nAddIdTunnel, GDB_LV.TEMP)
-      end
+      local nAddId = EgtCopyGlob( Proc.id, idAddGroup) or GDB_ID.NULL
+      local nAddIdTunnel = EgtCopyGlob( nOriginalTmIdTunnel, idAddGroup) or GDB_ID.NULL
       table.insert( vAddId, nAddId)
       table.insert( vAddIdTunnel, nAddIdTunnel)
    else
       for i = 1, #FeatureSplittingPoints do
-         local nAddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
-         local nAddIdTunnel = EgtCopyGlob( nOriginalTmIdTunnel, nAddGrpId) or GDB_ID.NULL
+         local nAddId = EgtCopyGlob( Proc.id, idAddGroup) or GDB_ID.NULL
+         local nAddIdTunnel = EgtCopyGlob( nOriginalTmIdTunnel, idAddGroup) or GDB_ID.NULL
          if i == 1 then
             -- prima superficie, va tagliata solo a sinistra
             local ptSplit = FeatureSplittingPoints[i] + Vector3d( -BeamData.MILL_OVERLAP / 2, 0, 0)
@@ -465,23 +479,15 @@ local function GetSplitSurfaces( Proc, Part, bAddMachining)
             EgtCutSurfTmPlane( nAddId, ptSplit, X_AX(), true, GDB_RT.GLOB)
             EgtCutSurfTmPlane( nAddIdTunnel, ptSplit, X_AX(), true, GDB_RT.GLOB)
          end
-         if not bAddMachining then
-            EgtSetLevel( nAddId, GDB_LV.TEMP)
-            EgtSetLevel( nAddIdTunnel, GDB_LV.TEMP)
-         end
          table.insert( vAddId, nAddId)
          table.insert( vAddIdTunnel, nAddIdTunnel)
       end
       -- taglio ultima superficie, va tagliata solo a destra
-      local nAddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
-      local nAddIdTunnel = EgtCopyGlob( nOriginalTmIdTunnel, nAddGrpId) or GDB_ID.NULL
+      local nAddId = EgtCopyGlob( Proc.id, idAddGroup) or GDB_ID.NULL
+      local nAddIdTunnel = EgtCopyGlob( nOriginalTmIdTunnel, idAddGroup) or GDB_ID.NULL
       local ptSplit = FeatureSplittingPoints[#FeatureSplittingPoints] + Vector3d( BeamData.MILL_OVERLAP / 2, 0, 0)
       EgtCutSurfTmPlane( nAddId, ptSplit, X_AX(), true, GDB_RT.GLOB)
       EgtCutSurfTmPlane( nAddIdTunnel, ptSplit, X_AX(), true, GDB_RT.GLOB)
-      if not bAddMachining then
-         EgtSetLevel( nAddId, GDB_LV.TEMP)
-         EgtSetLevel( nAddIdTunnel, GDB_LV.TEMP)
-      end
       table.insert( vAddId, nAddId)
       table.insert( vAddIdTunnel, nAddIdTunnel)
    end
@@ -501,19 +507,27 @@ function STR0002.Make( bAddMachining, Proc, Part, CustomParameters)
    Strategy.Result = {}
    Strategy.Result.dTimeToMachine = 0
 
+   -- se la lavorazione ostacola il pinzaggio, non posso farla
    if not IsTopologyOk( Proc) then
       local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. StrategyLib.Config.sStrategyId .. ' not implemented'
       EgtOutLog( sErr)
       Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( sErr)
       return false, Strategy.Result
    end
+   -- se la lavorazione ostacola il pinzaggio, non posso farla, serve una lavorazioen che lasci il testimone
+   if MachiningLib.IsFeatureHinderingClamping( Proc, Part) then
+      local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. StrategyLib.Config.sStrategyId .. ' not applicable ( Feature hinders clamping)'
+      EgtOutLog( sErr)
+      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( sErr)
+      return false, Strategy.Result
+   end
 
    local bAreAllMachiningsAdded = true
-   local dFeatureVolume = FeatureLib.GetFeatureVolume( Proc, Part)
+   local dFeatureVolume = Proc.dVolume
    local ToolInfo = {}
    local Pocketing = {}
 
-   Strategy.Machining = GetBestPocketingStrategy( Proc)
+   Strategy.Machining = GetBestPocketingStrategy( Proc, Part)
 
    if Strategy.Result.sStatus ~= 'Not-Applicable' then
       local vAddId = {}

Strategies/Standard/STR0003/STR0003.lua

@@ -15,7 +15,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
@@ -210,7 +210,7 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
    end
 
    -- volume della feature
-   local dFeatureVolume = FeatureLib.GetFeatureVolume( Proc, Part)
+   local dFeatureVolume = Proc.dVolume
 
    -- eventuali punti di spezzatura
    local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
@@ -236,6 +236,7 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
    local BottomEdge = LongFace.MainEdges.BottomEdge
 
    -- TODO funzione separata
+   -- TODO è meglio cercare la lama qui e passarla alla FACEBYBLADE, la scelta è più precisa
    -- lama - calcolo lavorazioni
    local Cutting = {}
    -- parametri comuni a tutte le lavorazioni cutting
@@ -243,8 +244,7 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
       bForceLongcutBlade = Strategy.Parameters.bForceLongcutBlade,
       dExtendAfterTail = dExtendAfterTail,
       dPocketHeight = dPocketHeight,
-      bIsSplitFeature = bIsSplitFeature,
-      dMinNzDownUp = 0
+      bIsSplitFeature = bIsSplitFeature
    }
 
    -- primo lato del tunnel o lato di fondo

Strategies/Standard/STR0004/STR0004.lua

@@ -15,7 +15,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
@@ -118,14 +118,6 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
       return false, Strategy.Result
    end
 
-   -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto)
-   if Proc.AffectedFaces.bBottom and ( Proc.nFct > 3 or not Proc.AffectedFaces.bTop) then
-      local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - pocket on bottom face'
-      EgtOutLog( sErr)
-      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Direction')
-      return false, Strategy.Result
-   end
-
    -- calcolo estensione oltre la coda
    local dExtendAfterTail = Strategy.Parameters.dExtendAfterTail or max( Part.dDistanceToNextPiece - BeamData.CUT_EXTRA, 0)
    if MachiningLib.CanExtendAfterTail( Strategy.Parameters.sCanDamageNextPiece, Part) then
@@ -133,7 +125,7 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
    end
    
    -- volume della feature
-   local dFeatureVolume = FeatureLib.GetFeatureVolume( Proc, Part)
+   local dFeatureVolume = Proc.dVolume
 
    -- eventuali punti di spezzatura
    local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
@@ -167,6 +159,7 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
       bIsSplitFeature = bIsSplitFeature
    }
 
+   -- TODO aggiungere verifica finecorsa e nel caso cambio lato
    if Proc.Topology.sName == 'Groove-4-Blind' or Proc.Topology.sName == 'Pocket-5-Blind' then
 
       -- si lavora tutto il fondo

Strategies/Standard/STR0005/STR0005.json

@@ -110,26 +110,6 @@
          "sMessageId": " ",
          "sMinUserLevel": "1"
       },
-      {
-         "sName": "dMinZAngleTopBlade",
-         "sNameNge": "MIN_Z_ANGLE_TOP_BLADE",
-         "sValue": "",
-         "sDescriptionShort": "Min Z angle top blade",
-         "sDescriptionLong": "",
-         "sType": "d",
-         "sMessageId": " ",
-         "sMinUserLevel": "1"
-      },
-      {
-         "sName": "dMaxYAngleTopBlade",
-         "sNameNge": "MAX_Y_ANGLE_TOP_BLADE",
-         "sValue": "",
-         "sDescriptionShort": "Max Y angle top blade",
-         "sDescriptionLong": "",
-         "sType": "d",
-         "sMessageId": " ",
-         "sMinUserLevel": "1"
-      },
       {
          "sName": "bFinishWithMill",
          "sNameNge": "ALLOW_FINISH_MILL",
@@ -160,6 +140,11 @@
          "sSource": "GEN_dMaxWasteVolume",
          "sMinUserLevel": "5"
       },
+      {
+         "sName": "dMaxDimDice",
+         "sSource": "GEN_dMaxDimDice",
+         "sMinUserLevel": "5"
+      },
       {
          "sName": "bReduceBladePath",
          "sSource": "GEN_bReduceBladePath",

Strategies/Standard/STR0005/STR0005.lua

@@ -5,7 +5,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
@@ -36,7 +36,7 @@ local function IsTwoFacesCommonEdgeTooLong( Proc, Part)
    end
 
    -- se due facce, cubetti troppo lunghi in X non si possono fare
-   local ptEdge1, _, ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, Proc.Faces[1].id, -Proc.Faces[1].Edges[nCommonEdge].vtN, GDB_ID.ROOT)
+   local ptEdge1, ptEdge2 = Proc.Faces[1].Edges[nCommonEdge].ptStart, Proc.Faces[1].Edges[nCommonEdge].ptEnd
    local b3BoxEdge = BBox3d( ptEdge1, ptEdge2)
    local dEdgeLengthOnX = b3BoxEdge:getDimX()
    if FeatureLib.IsMachiningLong( dEdgeLengthOnX, Part) then
@@ -80,9 +80,9 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
    local idAddedTmFace
    local nAddedFace
    if Proc.nFct == 3 and not Proc.Topology.sName == 'Groove-3-Through' then
-      if Proc.AdjacencyMatrix[1][2] > 10 * GEO.EPS_ANG_SMALL and Proc.AdjacencyMatrix[2][3] < 10 * GEO.EPS_ANG_SMALL then
+      if Proc.AdjacencyMatrix[2][3] < 0 then
          nAddedFace = 1 - 1
-      elseif Proc.AdjacencyMatrix[2][3] > 10 * GEO.EPS_ANG_SMALL and Proc.AdjacencyMatrix[3][1] < 10 * GEO.EPS_ANG_SMALL then
+      elseif Proc.AdjacencyMatrix[1][3] < 0 then
          nAddedFace = 2 - 1
       else
          nAddedFace = 3 - 1
@@ -100,8 +100,9 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
    -- considerazioni necessarie a determinare se lavorare con codolo oppure no
    local bKeepWasteAttached = ( Strategy.Parameters.sCuttingStrategy == 'KEEP_WASTE_ATTACHED')
    local bDropWaste = ( Strategy.Parameters.sCuttingStrategy == 'DROP_WASTE')
-   local dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail = FeatureLib.GetFeatureMaxNotClampableLengths( Proc, Part)
-   local bFeatureHindersClamping = FeatureLib.IsMachiningLong( max( dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail), Part, { dMaxSegmentLength = BeamData.LONGCUT_ENDLEN})
+
+   local bFeatureHindersClamping = MachiningLib.IsFeatureHinderingClamping( Proc, Part)
+
    local bIsFeatureLong = FeatureLib.IsMachiningLong( Proc.b3Box:getDimX(), Part, { dMaxSegmentLength = BeamData.LONGCUT_ENDLEN})
    local bIsTwoFacesCommonEdgeTooLong = ( ( Proc.Topology and ( Proc.Topology.sName == 'Rabbet-2-Through' or Proc.Topology.sName == 'Bevel-2-Blind')) and IsTwoFacesCommonEdgeTooLong( Proc, Part))
 
@@ -111,13 +112,14 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
       or bKeepWasteAttached then
 
       local BladeKeepWasteResult
-      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dStripWidth = Strategy.Parameters.dStripWidth}
+      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dStripWidth = Strategy.Parameters.dStripWidth, bForced = bKeepWasteAttached}
       AuxiliaryData.bIgnoreNotClampableLength = true
       Blade.Result, BladeKeepWasteResult = BladeKeepWaste.Make( Proc, Part, OptionalParameters)
       dTimeToMachine = BladeKeepWasteResult.dTimeToMachine
       dMRRBlade = BladeKeepWasteResult.dMRR
       dCompletionPercentage = BladeKeepWasteResult.dCompletionPercentage
       dQuality = BladeKeepWasteResult.dQuality
+      Strategy.Result.sInfo = BladeKeepWasteResult.sInfo or ''
    end
 
    -- lavorazione a cubetti / taglio singolo
@@ -127,20 +129,9 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
       and not bIsTwoFacesCommonEdgeTooLong then
 
       AuxiliaryData.bIgnoreNotClampableLength = false
-      local dMinZTopBlade
-      local dMaxNyTopBlade
       local BladeToWasteResult
-      if Strategy.Parameters.dMinZAngleTopBlade then
-         dMinZTopBlade = sin( Strategy.Parameters.dMinZAngleTopBlade)
-      end
-      if Strategy.Parameters.dMaxYAngleTopBlade then
-         dMaxNyTopBlade = sin( Strategy.Parameters.dMaxYAngleTopBlade)
-      end
-      -- TODO rimuovere dMinNzTopBlade e dMaxNyTopBlade opzionali? non sono gestiti ovunque e probabilmente hanno utilizzo limitato
       local OptionalParameters = { dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume,
                                    dMaxWasteLength = Strategy.Parameters.dMaxWasteLength,
-                                   dMinNzTopBlade = dMinZTopBlade,
-                                   dMaxNyTopBlade = dMaxNyTopBlade,
                                    bSaveAddedGeometries = bAddMachining,
                                    dExtendAfterTail = dExtendAfterTail,
                                    bAllowFastCuts = Strategy.Parameters.bAllowFastCuts,
@@ -172,19 +163,9 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
    -- TODO da completare
    -- TODO va messa per prima????????
    if idAddedTmFace then
-      local dMinZTopBlade
-      local dMaxNyTopBlade
       local BladeToWasteResult
-      if Strategy.Parameters.dMinZAngleTopBlade then
-         dMinZTopBlade = sin( Strategy.Parameters.dMinZAngleTopBlade)
-      end
-      if Strategy.Parameters.dMaxYAngleTopBlade then
-         dMaxNyTopBlade = sin( Strategy.Parameters.dMaxYAngleTopBlade)
-      end
       local OptionalParameters = { dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume,
                                    dMaxWasteLength = Strategy.Parameters.dMaxWasteLength,
-                                   dMinNzTopBlade = dMinZTopBlade,
-                                   dMaxNyTopBlade = dMaxNyTopBlade,
                                    bSaveAddedGeometries = bAddMachining,
                                    dExtendAfterTail = dExtendAfterTail
                                  }

Strategies/Standard/STR0006/STR0006.lua

@@ -5,9 +5,10 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
+local PreSimulationLib = require( 'PreSimulationLib')
 -- strategie di base
 local BladeToWaste = require( 'BLADETOWASTE')
 
@@ -74,6 +75,7 @@ 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
+            -- TODO questo test va sostituito con check collisione asse Z (PreCollision)
             local dTotalLen = TOOLS[Machining.Milling.ToolInfo.nToolIndex].dLength + TOOLS[Machining.Milling.ToolInfo.nToolIndex].SetupInfo.dPivot
             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
@@ -158,6 +160,23 @@ local function GetTenonStrategy( Proc, Part)
                   Machining.Milling.AuxiliaryData.Clones[nIndexClones].dRadialOffset = ( i - 1) * dRealSideStep
                end
             end
+
+            -- test finecorsa sulla passata più esterna: se extracorsa, la lavorazione non è fattibile
+            -- TODO sostituire con applicazione della lavorazione?
+            -- TODO funzione per allungare il percorso??????
+            local idGeomMaxOffset = EgtCopyGlob( Proc.FeatureInfo.idAddAuxGeom, Part.idTempGroup)
+            EgtOffsetCurve( idGeomMaxOffset, Machining.Milling.AuxiliaryData.Clones[1].dRadialOffset + TOOLS[Machining.Milling.ToolInfo.nToolIndex].dDiameter / 2, Part.idTempGroup)
+            local vtCurveStart = EgtSV( idGeomMaxOffset, GDB_ID.ROOT)
+            local vtCurveEnd = EgtEV( idGeomMaxOffset, GDB_ID.ROOT)
+            local ptCurveStart = EgtSP( idGeomMaxOffset, GDB_ID.ROOT) + -vtCurveStart * Machining.Milling.LeadIn.dTangentDistance + ( Proc.FeatureInfo.vtTenonN ^ -vtCurveStart) * Machining.Milling.LeadIn.dPerpDistance
+            local ptCurveEnd = EgtEP( idGeomMaxOffset, GDB_ID.ROOT) + vtCurveEnd * Machining.Milling.LeadOut.dTangentDistance + ( vtCurveEnd ^ Proc.FeatureInfo.vtTenonN) * Machining.Milling.LeadOut.dPerpDistance
+            EgtAddCurveCompoArcTg( idGeomMaxOffset, ptCurveStart, false, GDB_RT.GLOB)
+            EgtAddCurveCompoArcTg( idGeomMaxOffset, ptCurveEnd, true, GDB_RT.GLOB)
+            local bOutOfStroke = PreSimulationLib.CheckOutOfStrokeFromGeometry( idGeomMaxOffset, Proc.FeatureInfo.vtTenonN, Machining.Milling.nSCC, TOOLS[Machining.Milling.ToolInfo.nToolIndex])
+            if bOutOfStroke then
+               Machining.Milling.bIsApplicable = false
+            end
+
             -- tempo di svuotatura
             Result.Milling.dTimeToMachine = MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machining.Milling, Part)
          end

Strategies/Standard/STR0007/STR0007.lua

@@ -5,9 +5,10 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
+local PreSimulationLib = require( 'PreSimulationLib')
 -- strategie di base
 local BladeToWaste = require('BLADETOWASTE')
 
@@ -15,6 +16,19 @@ local BladeToWaste = require('BLADETOWASTE')
 local STR0007 = {}
 local Strategy = {}
 
+-------------------------------------------------------------------------------------------------------------
+local function GetSCC( Machining)
+   local nSCC
+
+   if Machining.vtToolDirection:getX() > 0 then
+      nSCC = MCH_SCC.ADIR_XP
+   else
+      nSCC = MCH_SCC.ADIR_XM
+   end
+
+   return nSCC
+end
+
 -------------------------------------------------------------------------------------------------------------
 function GetMortiseStrategy( Proc, Part)
    local Machining = {}
@@ -94,11 +108,16 @@ function GetMortiseStrategy( Proc, Part)
       ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sMillingList, 'Milling')
       Machining.Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
       if Machining.Milling.ToolInfo.nToolIndex then
-         Machining.Milling.bIsApplicable = true
+         local dToolDiam = TOOLS[Machining.Milling.ToolInfo.nToolIndex].dDiameter
 
+         -- se richiesta passata antischeggia
+         if Strategy.Parameters.bAntiSplint then
+            Machining.AntiSplint = GetMortiseAntiSplint( Proc, Part, Machining.Milling.ToolInfo)
+         end
+
+         Machining.Milling.bIsApplicable = true
          -- calcolo numero passate necessarie
-         if Proc.FeatureInfo.dMortiseMaxDist > TOOLS[Machining.Milling.ToolInfo.nToolIndex].dDiameter * 1.9 then
-            local dToolDiam = TOOLS[Machining.Milling.ToolInfo.nToolIndex].dDiameter
+         if Proc.FeatureInfo.dMortiseMaxDist > dToolDiam * 1.9 then
             local sSideStep = TOOLS[Machining.Milling.ToolInfo.nToolIndex].dSideStep
             Machining.nMillingPathsNeeded = 1 + ceil( ( Proc.FeatureInfo.dMortiseMaxDist - dToolDiam * 1.9) / ( sSideStep * 2))
             -- suddivido step in base al numero passate da fare
@@ -107,6 +126,55 @@ function GetMortiseStrategy( Proc, Part)
             Machining.nMillingPathsNeeded = 1
          end
 
+         -- aggiungo geometria
+         Machining.Milling.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
+         Machining.Milling.nToolIndex = Machining.Milling.ToolInfo.nToolIndex
+         Machining.Milling.nType = MCH_MY.MILLING
+         Machining.Milling.vtToolDirection = Proc.FeatureInfo.vtMortiseN
+         Machining.Milling.sDepth = Strategy.Parameters.dOverMatOnLength
+
+         -- LeadIn / LeadOut
+         Machining.Milling.LeadIn = {}
+         Machining.Milling.LeadOut = {}
+         Machining.Milling.LeadIn.nType = MCH_MILL_LI.TANGENT
+         Machining.Milling.LeadOut.nType = MCH_MILL_LI.TANGENT
+
+         local dDeltaAngledEntry = Proc.FeatureInfo.vtMortisePathStart * dToolDiam / 2
+         local dDeltaAngledExit = Proc.FeatureInfo.vtMortisePathEnd * dToolDiam / 2
+
+         Machining.Milling.LeadIn.dTangentDistance = dToolDiam / 2  + dDeltaAngledEntry + BeamData.COLL_SIC
+         Machining.Milling.LeadIn.dPerpDistance = 0
+         Machining.Milling.LeadOut.dTangentDistance = dToolDiam / 2 + dDeltaAngledExit + BeamData.COLL_SIC
+         Machining.Milling.LeadOut.dPerpDistance = 0
+
+         if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
+            Machining.Milling.sStage = 'AfterTail'
+         end
+
+         -- sistemo il lato e la direzione di lavoro
+         Machining.Milling.bInvert = EgtIf( TOOLS[Machining.Milling.ToolInfo.nToolIndex].bIsCCW, false, true)
+         Machining.Milling.nWorkside = EgtIf( TOOLS[Machining.Milling.ToolInfo.nToolIndex].bIsCCW, MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT)
+
+         Machining.Milling.dMaxElev = Proc.FeatureInfo.dMortiseDepth
+
+         Machining.Milling.nSCC = GetSCC( Machining.Milling)
+
+         -- passate con sovramateriale
+         Machining.Milling.AuxiliaryData = { Clones = {}}
+         for i = Machining.nMillingPathsNeeded, 1, -1 do
+            -- il primo è il passaggio più esterno
+            local nIndexClones = Machining.nMillingPathsNeeded - i + 1
+            -- cambia solo sovrmateriale radiale
+            Machining.Milling.AuxiliaryData.Clones[nIndexClones] = {}
+            -- ultima passata con sovramateriale impostato
+            if i == 1 then
+               Machining.Milling.AuxiliaryData.Clones[nIndexClones].dRadialOffset = Strategy.Parameters.dOverMatOnRadius
+            else
+               -- suddivido step in base al numero passate da fare
+               Machining.Milling.AuxiliaryData.Clones[nIndexClones].dRadialOffset = ( i - 1) * Machining.Milling.dRealSideStep
+            end
+         end
+
          local ParametersMRR = {}
          ParametersMRR.nToolIndex = Machining.Milling.ToolInfo.nToolIndex
          Result.Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
@@ -116,6 +184,17 @@ function GetMortiseStrategy( Proc, Part)
          else
             Machining.Milling.bIsApplicable = false
          end
+
+         -- test finecorsa sulla passata più esterna: se extracorsa, la lavorazione non è fattibile
+         local idGeomMaxOffset = EgtCopyGlob( Proc.FeatureInfo.idAddAuxGeom, Part.idTempGroup)
+         -- TODO funzione per allungare il percorso??????
+         EgtAddCurveCompoLineTg( idGeomMaxOffset, Machining.Milling.LeadIn.dTangentDistance, false)
+         EgtAddCurveCompoLineTg( idGeomMaxOffset, Machining.Milling.LeadOut.dTangentDistance, true)
+         EgtOffsetCurve( idGeomMaxOffset, Machining.Milling.AuxiliaryData.Clones[1].dRadialOffset + TOOLS[Machining.Milling.ToolInfo.nToolIndex].dDiameter / 2, Part.idTempGroup)
+         local bOutOfStroke = PreSimulationLib.CheckOutOfStrokeFromGeometry( idGeomMaxOffset, Proc.FeatureInfo.vtMortiseN, Machining.Milling.nSCC, TOOLS[Machining.Milling.ToolInfo.nToolIndex])
+         if bOutOfStroke then
+            Machining.Milling.bIsApplicable = false
+         end
       end
    end
 
@@ -161,9 +240,9 @@ function GetMortiseMachiningResult( Proc, Result)
       TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
       TotalResult.dMRR =  ( Result.Milling.dMRR + Result.Cutting.dMRR) / 2
       local sQuality
-      if not Strategy.Machining.bCuttingWithMill and Strategy.Machining.bAntiSplint then
+      if not Strategy.Machining.bCuttingWithMill and Strategy.Machining.AntiSplint.bIsApplicable then
          sQuality = 'BEST'
-      elseif Strategy.Machining.bAntiSplint then
+      elseif Strategy.Machining.AntiSplint.bIsApplicable then
          sQuality = 'FINE'
       else
          sQuality = 'STD'
@@ -176,7 +255,7 @@ function GetMortiseMachiningResult( Proc, Result)
       TotalResult.sStatus = Result.Milling.sStatus
       TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
       TotalResult.dMRR = Result.Milling.dMRR
-      local sQuality = EgtIf( Strategy.Parameters.bAntiSplint, 'BEST', 'STD')
+      local sQuality = EgtIf( Strategy.Machining.AntiSplint.bIsApplicable, 'BEST', 'STD')
       TotalResult.dQuality = FeatureLib.GetStrategyQuality( sQuality)
       TotalResult.nFeatureRotationIndex = GetFeatureRotationIndex( Proc)
       TotalResult.sInfo = ''
@@ -233,14 +312,15 @@ local function CalcTopPath( nProcId, AuxId, nAddGrpId, dAltMort, dSideAng, b3Sol
 end
 
 -------------------------------------------------------------------------------------------------------------
-function ApplyMortiseAntiSplint( Proc, Part)
+function GetMortiseAntiSplint( Proc, Part, ToolInfo)
+   local AntiSplint = { bIsApplicable = false}
    -- se il percorso non è chiuso, aggiungo percorso e lavorazione antischeggia
    if not EgtCurveIsClosed( Proc.FeatureInfo.idAddAuxGeom) then
       -- recupero gruppo per geometria addizionale
       local nAddGrpId = BeamLib.GetAddGroup( Part.id)
       -- calcolo il percorso top mortise
-      local dSideAng = TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].dSideAngle
-      local dToolDiam = TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].dDiameter
+      local dSideAng = TOOLS[ToolInfo.nToolIndex].dSideAngle
+      local dToolDiam = TOOLS[ToolInfo.nToolIndex].dDiameter
       local vtExtr = Proc.FeatureInfo.vtMortiseN
       local nAuxId1 = CalcTopPath( Proc.id, Proc.FeatureInfo.idAddAuxGeom, nAddGrpId, Proc.FeatureInfo.dMortiseDepth, dSideAng, Part.b3Part)
       -- se esiste il percorso
@@ -275,48 +355,62 @@ function ApplyMortiseAntiSplint( Proc, Part)
             if not nId1 then
                local sErr = 'Wrong geometry : Error on DtMortise '
                EgtOutLog( sErr)
-               return false, sErr
+               return AntiSplint
             end
             EgtModifyCurveExtrusion( nId1, vtExtr, GDB_RT.GLOB)
 
-            local Machining = {}
-            Machining.nToolIndex = Strategy.Machining.Milling.ToolInfo.nToolIndex
-            Machining.nType = MCH_MY.MILLING
-            Machining.vtToolDirection = Proc.FeatureInfo.vtMortiseN
+            AntiSplint.nToolIndex = ToolInfo.nToolIndex
+            AntiSplint.nType = MCH_MY.MILLING
+            AntiSplint.vtToolDirection = Proc.FeatureInfo.vtMortiseN
 
             -- LeadIn / LeadOut
-            Machining.LeadIn = {}
-            Machining.LeadOut = {}
-            Machining.LeadIn.nType = MCH_MILL_LI.TANGENT
-            Machining.LeadOut.nType = MCH_MILL_LI.TANGENT
-            Machining.LeadIn.dTangentDistance = TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
-            Machining.LeadIn.dPerpDistance = 0
-            Machining.LeadOut.dTangentDistance = TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
-            Machining.LeadOut.dPerpDistance = 0
+            AntiSplint.LeadIn = {}
+            AntiSplint.LeadOut = {}
+            AntiSplint.LeadIn.nType = MCH_MILL_LI.TANGENT
+            AntiSplint.LeadOut.nType = MCH_MILL_LI.TANGENT
+            AntiSplint.LeadIn.dTangentDistance = TOOLS[ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
+            AntiSplint.LeadIn.dPerpDistance = 0
+            AntiSplint.LeadOut.dTangentDistance = TOOLS[ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
+            AntiSplint.LeadOut.dPerpDistance = 0
 
-            Machining.dRadialOffset = dToolRadDelta - 1
-            Machining.sDepth = Proc.FeatureInfo.dMortiseDepth - Strategy.Parameters.dOverMatOnLength
-            Machining.Geometry = {{ nId1, -1}}
-            Machining.bInvert = EgtIf( TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].bIsCCW, false, true)
-            Machining.nWorkside = EgtIf( TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].bIsCCW, MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT)
-            Machining.dMaxElev = Proc.FeatureInfo.dMortiseDepth
+            AntiSplint.dRadialOffset = dToolRadDelta - 1
+            AntiSplint.sDepth = Proc.FeatureInfo.dMortiseDepth - Strategy.Parameters.dOverMatOnLength
+            AntiSplint.Geometry = {{ nId1, -1}}
+            AntiSplint.bInvert = EgtIf( TOOLS[ToolInfo.nToolIndex].bIsCCW, false, true)
+            AntiSplint.nWorkside = EgtIf( TOOLS[ToolInfo.nToolIndex].bIsCCW, MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT)
+            AntiSplint.dMaxElev = Proc.FeatureInfo.dMortiseDepth
+            AntiSplint.nSCC = GetSCC( AntiSplint)
 
             if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
-               Machining.sStage = 'AfterTail'
+               AntiSplint.sStage = 'AfterTail'
+            end
+
+            -- test finecorsa sulla passata più esterna: se extracorsa, la lavorazione non è fattibile
+            local idGeomOffset = EgtCopyGlob( nId1, Part.idTempGroup)
+            EgtOffsetCurve( idGeomOffset, EgtIf( AntiSplint.bInvert, -TOOLS[ToolInfo.nToolIndex].dDiameter / 2, TOOLS[ToolInfo.nToolIndex].dDiameter / 2), Part.idTempGroup)
+            -- trasformo arco in una curva compo per poi allungarla in direzione tangente
+            -- TODO funzione per allungare il percorso??????
+            idGeomOffset = EgtCurveCompo( Part.idTempGroup, idGeomOffset)
+            EgtAddCurveCompoLineTg( idGeomOffset, AntiSplint.LeadIn.dTangentDistance, false)
+            EgtAddCurveCompoLineTg( idGeomOffset, AntiSplint.LeadOut.dTangentDistance, true)
+            local bOutOfStroke = PreSimulationLib.CheckOutOfStrokeFromGeometry( idGeomOffset, Proc.FeatureInfo.vtMortiseN, AntiSplint.nSCC, TOOLS[ToolInfo.nToolIndex])
+            -- se soddisfa tutti i requisiti, posso applicare
+            if bOutOfStroke then
+               AntiSplint.bIsApplicable = false
+            else
+               AntiSplint.bIsApplicable = true
             end
-            MachiningLib.AddMachinings( Proc, Machining)
 
          else
             local sErr = 'Wrong geometry : Error on DtMortise ' .. tostring( Proc.id)
             EgtOutLog( sErr)
-            return false, sErr
          end
       else
          local sErr = 'Wrong geometry : Error on DtMortise ' .. tostring( Proc.id)
          EgtOutLog( sErr)
-         return false, sErr
       end
    end
+   return AntiSplint
 end
 
 
@@ -347,7 +441,7 @@ function STR0007.Make( bAddMachining, Proc, Part, CustomParameters)
       local ptCutC, vtCutN = EgtSurfTmFacetCenter( Proc.id, 1, GDB_ID.ROOT)
       if ptCutC and vtCutN and AreSameVectorApprox( Proc.FeatureInfo.vtMortiseN, vtCutN) then
          -- recupero gruppo per geometria addizionale
-         local nAddGrpId = BeamLib.GetAddGroup( Part.id)
+         local nAddGrpId = Part.idTempGroup
          Strategy.idMortiseCutPlane = EgtSurfTmPlaneInBBox( nAddGrpId, ptCutC, vtCutN, Part.b3Part, GDB_RT.GLOB)
       end
    end
@@ -400,65 +494,19 @@ function STR0007.Make( bAddMachining, Proc, Part, CustomParameters)
       end
 
       -- se richiesta passata antischeggia
-      if Strategy.Parameters.bAntiSplint then
-         ApplyMortiseAntiSplint( Proc, Part)
+      if Strategy.Machining.AntiSplint.bIsApplicable then
+         bAreAllMachiningsAdded = bAreAllMachiningsAdded and MachiningLib.AddMachinings( Proc, Strategy.Machining.AntiSplint)
       end
 
       -- passaggio sul profilo
       if Strategy.Machining.Milling.bIsApplicable then
-         local AuxiliaryData = {}
          -- se molti passaggi richiesti, si fa svuotatura
          -- TODO in attesa delle svuotature, si fanno passaggi senza limiti sul numero massimo. Poi togliere il FALSE nella condizione.
          if false and Strategy.Machining.nMillingPathsNeeded > Strategy.Parameters.nMaxMillingPaths then
             -- TODO. SERVONO NUOVE SVUOTATURE!!!!
          else
-            -- aggiungo geometria
-            Strategy.Machining.Milling.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
-            Strategy.Machining.Milling.nToolIndex = Strategy.Machining.Milling.ToolInfo.nToolIndex
-            Strategy.Machining.Milling.nType = MCH_MY.MILLING
-            Strategy.Machining.Milling.vtToolDirection = Proc.FeatureInfo.vtMortiseN
-            Strategy.Machining.Milling.sDepth = Strategy.Parameters.dOverMatOnLength
-
-            -- LeadIn / LeadOut
-            Strategy.Machining.Milling.LeadIn = {}
-            Strategy.Machining.Milling.LeadOut = {}
-            Strategy.Machining.Milling.LeadIn.nType = MCH_MILL_LI.TANGENT
-            Strategy.Machining.Milling.LeadOut.nType = MCH_MILL_LI.TANGENT
-            Strategy.Machining.Milling.LeadIn.dTangentDistance = TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
-            Strategy.Machining.Milling.LeadIn.dPerpDistance = 0
-            Strategy.Machining.Milling.LeadOut.dTangentDistance = TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
-            Strategy.Machining.Milling.LeadOut.dPerpDistance = 0
-
-            if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
-               Strategy.Machining.Milling.sStage = 'AfterTail'
-            end
-
-            -- sistemo il lato e la direzione di lavoro
-            Strategy.Machining.Milling.bInvert = EgtIf( TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].bIsCCW, false, true)
-            Strategy.Machining.Milling.nWorkside = EgtIf( TOOLS[Strategy.Machining.Milling.ToolInfo.nToolIndex].bIsCCW, MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT)
-
-            Strategy.Machining.Milling.dMaxElev = Proc.FeatureInfo.dMortiseDepth
-
-            -- TODO calcolare SCC
-
-            -- passate con sovramateriale
-            AuxiliaryData.Clones = {}
-            for i = Strategy.Machining.nMillingPathsNeeded, 1, -1 do
-               -- il primo è il passaggio più esterno
-               local nIndexClones = Strategy.Machining.nMillingPathsNeeded - i + 1
-               -- cambia solo sovrmateriale radiale
-               AuxiliaryData.Clones[nIndexClones] = {}
-               -- ultima passata con sovramateriale impostato
-               if i == 1 then
-                  AuxiliaryData.Clones[nIndexClones].dRadialOffset = Strategy.Parameters.dOverMatOnRadius
-               else
-                  -- suddivido step in base al numero passate da fare
-                  AuxiliaryData.Clones[nIndexClones].dRadialOffset = ( i - 1) * Strategy.Machining.Milling.dRealSideStep
-               end
-            end
-
             -- aggiunge lavorazione
-            bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, Strategy.Machining.Milling, AuxiliaryData)
+            bAreAllMachiningsAdded = bAreAllMachiningsAdded and MachiningLib.AddMachinings( Proc, Strategy.Machining.Milling, Strategy.Machining.Milling.AuxiliaryData)
          end
       end
    end

Strategies/Standard/STR0008/STR0008.lua

@@ -6,7 +6,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
@@ -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

Strategies/Standard/STR0009/STR0009.lua

@@ -6,7 +6,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
@@ -188,8 +188,7 @@ function STR0009.Make( bAddMachining, Proc, Part, CustomParameters)
          Strategy.Machinings[i].nType = MCH_MY.MILLING
          Strategy.Machinings[i].dStartSafetyLength = 0
          Strategy.Machinings[i].Steps = {}
-         Strategy.Machinings[i].Steps.dStep = TOOLS[Strategy.Machinings[i].ToolInfo.nToolIndex].dStep
-         Strategy.Machinings[i].Steps = MachiningLib.GetMachiningSteps( tonumber( Strategy.Machinings[i].sDepth), TOOLS[Strategy.Machinings[i].nToolIndex].dStep)
+         Strategy.Machinings[i].Steps = MachiningLib.GetMachiningSteps( false, tonumber( Strategy.Machinings[i].sDepth), TOOLS[Strategy.Machinings[i].nToolIndex].dStep)
 
          -- LeadIn / LeadOut
          Strategy.Machinings[i].LeadIn = {}

Strategies/Standard/STR0010/STR0010.lua

@@ -5,7 +5,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
@@ -83,7 +83,8 @@ end
 -------------------------------------------------------------------------------------------------------------
 local function IsTopologyOk( Proc)
    if Proc.Topology.sFamily == 'Bevel' or Proc.Topology.sFamily == 'DoubleBevel' or
-      Proc.Topology.sName == 'VGroove-2-Through' or Proc.Topology.sName == 'Rabbet-2-Through' then
+      Proc.Topology.sName == 'VGroove-2-Through' or Proc.Topology.sName == 'Rabbet-2-Through' or
+      Proc.Topology.sName == 'Cut-1-Through' then
       return true
    else
       return false
@@ -178,14 +179,24 @@ function STR0010.Make( bAddMachining, Proc, Part, CustomParameters)
       return false, Strategy.Result
    end
 
-   -- controllo dimensioni
-   if not IsPositionOK( Proc, Part) then
-      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Feature not machinable in this position')
+   -- controllo dimensioni solo se non è forzata
+   if not CustomParameters.bForcedStrategy then
+      if not IsPositionOK( Proc, Part) then
+         Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Feature not machinable in this position')
+         return false, Strategy.Result
+      end
+   end
+
+   -- se la lavorazione ostacola il pinzaggio, non posso farla, serve una lavorazioen che lasci il testimone
+   if MachiningLib.IsFeatureHinderingClamping( Proc, Part) then
+      local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. StrategyLib.Config.sStrategyId .. ' not applicable ( Feature hinders clamping)'
+      EgtOutLog( sErr)
+      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( sErr)
       return false, Strategy.Result
    end
 
    -- volume della feature
-   local dFeatureVolume = FeatureLib.GetFeatureVolume( Proc, Part)
+   local dFeatureVolume = Proc.dVolume
 
    -- TODO taglio su eventuali facce di chiusura
 
@@ -253,7 +264,12 @@ function STR0010.Make( bAddMachining, Proc, Part, CustomParameters)
       if bAddMachining and Strategy.Result.sStatus ~= 'Not-Applicable' then
          -- aggiunge lavorazione
          for j = 1, #Strategy.Machinings do
-            bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, Strategy.Machinings[j])
+            local AuxiliaryData = {}
+            -- se strategia forzata non considero area non pinzabile
+            if CustomParameters.bForcedStrategy then
+               AuxiliaryData.bIgnoreNotClampableLength = true
+            end
+            bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, Strategy.Machinings[j], AuxiliaryData)
          end
       end
    else

Strategies/Standard/STR0011/STR0011.lua

@@ -5,7 +5,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
@@ -20,224 +20,159 @@ local Strategy = {}
 local function GetDrillingStrategy( Proc, Part)
    local ToolSearchParameters = {}
    local Machining = {}
-   local sQuality
 
-   -- se lavorazione orizzontale
-   if Proc.FeatureInfo.bIsDrillHorizontal then
-      local bDouble = false
-      local Drilling = MachiningLib.InitMachiningParameters( MCH_MY.DRILLING)
-      Drilling.bIsApplicable = false
+   -- si cerca utensile 1
+   local Drilling = MachiningLib.InitMachiningParameters( MCH_MY.DRILLING)
+   ToolSearchParameters = {}
+   ToolSearchParameters.dElevation = Proc.FeatureInfo.dDrillLen + BeamData.MILL_OVERLAP
+   ToolSearchParameters.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
+   ToolSearchParameters.dToolDiameter = Proc.FeatureInfo.dDrillDiam
+   ToolSearchParameters.dDiameterTolerance = Strategy.Parameters.dDiameterTolerance
+   ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sDrillBitList, 'Drilling')
+   ToolSearchParameters.ptCheckOutStroke = { Proc.FeatureInfo.ptDrillCenter + ( EgtMdbGetGeneralParam( MCH_GP.SAFEZ) * ToolSearchParameters.vtToolDirection)}
+
+   Drilling.ToolInfo = {}
+   Drilling.ToolInfo = MachiningLib.FindDrill( Proc, ToolSearchParameters)
+   -- se trovato utensile si settano i parametri comuni
+   if Drilling.ToolInfo.nToolIndex then
+      Drilling.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
+      Drilling.nToolIndex = Drilling.ToolInfo.nToolIndex
+      Drilling.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
+      Drilling.dStep = TOOLS[Drilling.nToolIndex].dStep
+   end
+
+   -- TODO se utensile 2 che si torverà è il gemello da usare nelle lavorazioni in doppio, allora gestire di conseguenza l'applicazione delle lavorazioni in doppio
+   -- si cerca utensile 2
+   local Drilling2 = MachiningLib.InitMachiningParameters( MCH_MY.DRILLING)
+   Drilling2.ToolInfo = {}
+   if Proc.FeatureInfo.bIsDrillOpen then
       ToolSearchParameters = {}
       ToolSearchParameters.dElevation = Proc.FeatureInfo.dDrillLen + BeamData.MILL_OVERLAP
-      ToolSearchParameters.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
-      ToolSearchParameters.dToolDiameter = Proc.FeatureInfo.dDrillDiam
+      ToolSearchParameters.vtToolDirection = -Proc.FeatureInfo.vtDrillExtrusion
       ToolSearchParameters.dDiameterTolerance = Strategy.Parameters.dDiameterTolerance
       ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sDrillBitList, 'Drilling')
-      Drilling.ToolInfo = {}
-      Drilling.ToolInfo = MachiningLib.FindDrill( Proc, ToolSearchParameters)
-      if Drilling.ToolInfo.nToolIndex then
-         Drilling.nToolIndex = Drilling.ToolInfo.nToolIndex
-         Drilling.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
-         Drilling.dStep = TOOLS[Drilling.ToolInfo.nToolIndex].dStep
-         -- se lavorazione non completa o se si deve forare dai due lati
-         if Proc.FeatureInfo.bIsDrillOpen and
-            ( Drilling.ToolInfo.dResidualDepth > 10 * GEO.EPS_SMALL or Strategy.Parameters.sDrillingMode == 'FORCE_TWO' or Strategy.Parameters.sDrillingMode == 'AUTO') then
-            bDouble = true
-            local dHalfDrill = ( Proc.FeatureInfo.dDrillLen + BeamData.MILL_OVERLAP) / 2
-            Drilling.sDepth = min( dHalfDrill, Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth)
-            Drilling.vtFaceNormal = Proc.FeatureInfo.vtDrillExtrusion
-            Drilling.bInvert = false
-            Drilling.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
-            table.insert( Machining, Drilling)
-            local Drilling2 = BeamLib.TableCopyDeep( Drilling)
-            Drilling2.bInvert = true
-            Drilling2.vtToolDirection = -Proc.FeatureInfo.vtDrillExtrusion
-            table.insert( Machining, Drilling2)
-         else
-            Drilling.sDepth = 'TH'
-            Drilling.vtFaceNormal = Proc.FeatureInfo.vtDrillExtrusion
-            Drilling.bInvert = false
-            Drilling.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
-            table.insert( Machining, Drilling)
-         end
+      ToolSearchParameters.ptCheckOutStroke = { Proc.FeatureInfo.ptDrillCenter + ( ( Proc.FeatureInfo.dDrillLen + EgtMdbGetGeneralParam( MCH_GP.SAFEZ)) * ToolSearchParameters.vtToolDirection)}
 
-         -- voto
-         if Drilling.ToolInfo.dResidualDepth < 0  or  ( Proc.FeatureInfo.dDrillLen + BeamData.MILL_OVERLAP) / 2 > Drilling.ToolInfo.dResidualDepth then
-            Strategy.Result.sStatus = 'Completed'
-            Strategy.Result.dCompletionIndex = 5
-            Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo or Machining[2].ToolInfo)
-            if bDouble or not Proc.FeatureInfo.bIsDrillOpen then
-               sQuality = 'FINE'
-            else
-               sQuality = 'ROUGH'
-            end
-            Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( sQuality)
-            Strategy.Result.sInfo = ''
-         else
-            Strategy.Result.sStatus = 'Not-Completed'
-            local dMachinedLen = EgtIf( bDouble, Machining[1].sDepth * 2, Proc.FeatureInfo.dDrillLen)
-            local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
-            Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
-            Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
-            Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo or Machining[2].ToolInfo)
-            Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE') -- se non completo, anche se fosse foro singolo, comunque non esce dall'altra parte, quindi non scheggia
-         end
-      else
-         local sMessage = 'Drillbit not found'
-         Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( sMessage)
-      end
-   -- se lavorazione verticale
-   else
-      -- si cerca utensile 1
-      local Drilling = MachiningLib.InitMachiningParameters( MCH_MY.DRILLING)
-      ToolSearchParameters = {}
-      ToolSearchParameters.dElevation = Proc.FeatureInfo.dDrillLen + BeamData.MILL_OVERLAP
-      ToolSearchParameters.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
-      ToolSearchParameters.dToolDiameter = Proc.FeatureInfo.dDrillDiam
-      ToolSearchParameters.dDiameterTolerance = Strategy.Parameters.dDiameterTolerance
-      ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sDrillBitList, 'Drilling')
-      Drilling.ToolInfo = {}
-      Drilling.ToolInfo = MachiningLib.FindDrill( Proc, ToolSearchParameters)
-      -- si cerca utensile 2
-      local Drilling2 = MachiningLib.InitMachiningParameters( MCH_MY.DRILLING)
-      Drilling2.ToolInfo = {}
-      if Proc.FeatureInfo.bIsDrillOpen then
-         ToolSearchParameters = {}
-         ToolSearchParameters.dElevation = Proc.FeatureInfo.dDrillLen + BeamData.MILL_OVERLAP
-         ToolSearchParameters.vtToolDirection = -Proc.FeatureInfo.vtDrillExtrusion
-         ToolSearchParameters.dDiameterTolerance = Strategy.Parameters.dDiameterTolerance
-         ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sDrillBitList, 'Drilling')
-         Drilling2.ToolInfo = MachiningLib.FindDrill( Proc, ToolSearchParameters)
-      end
-
-      -- se possono lavorare entrambi e si deve fare lavorazione doppia e si riesce a completare
-      if Drilling.ToolInfo.nToolIndex and Drilling2.ToolInfo.nToolIndex and
-         ( Strategy.Parameters.sDrillingMode == 'FORCE_TWO'  or Strategy.Parameters.sDrillingMode == 'AUTO') and
-         Drilling.ToolInfo.dResidualDepth + Drilling2.ToolInfo.dResidualDepth < Proc.FeatureInfo.dDrillLen then
-
-         local dExtraDrill = ( Proc.FeatureInfo.dDrillLen - BeamData.MILL_OVERLAP - ( Drilling.ToolInfo.dResidualDepth + Drilling2.ToolInfo.dResidualDepth)) / 2
-         Drilling.nToolIndex = Drilling.ToolInfo.nToolIndex
-         Drilling.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
-         Drilling.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
-         Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth - dExtraDrill
-         table.insert( Machining, Drilling)
-
-         Drilling2.nToolIndex = Drilling2.ToolInfo.nToolIndex
+      Drilling2.ToolInfo = MachiningLib.FindDrill( Proc, ToolSearchParameters)
+      -- se trovato utensile si settano i parametri comuni
+      if Drilling2.ToolInfo.nToolIndex then
          Drilling2.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
+         Drilling2.nToolIndex = Drilling2.ToolInfo.nToolIndex
          Drilling2.bInvert = true
          Drilling2.vtToolDirection = -Proc.FeatureInfo.vtDrillExtrusion
-         Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth - dExtraDrill
-         table.insert( Machining, Drilling2)
-
-         -- voto
-         Strategy.Result.sStatus = 'Completed'
-         Strategy.Result.dCompletionIndex = 5
-         Strategy.Result.sInfo = ''
-         Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
-         Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
-
-      -- se utensile 1 esegue completamente
-      elseif Drilling.ToolInfo.nToolIndex and Drilling.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL and
-             ( Strategy.Parameters.sDrillingMode == 'PREFER_ONE' or ( not Drilling2.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode == 'AUTO') or not Proc.FeatureInfo.bIsDrillOpen) then
-         Drilling.sDepth = 'TH'
-         Drilling.nToolIndex = Drilling.ToolInfo.nToolIndex
-         Drilling.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
-         Drilling.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
-         table.insert( Machining, Drilling)
-         -- voto
-         Strategy.Result.sStatus = 'Completed'
-         Strategy.Result.dCompletionIndex = 5
-         Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
-         Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
-         Strategy.Result.sInfo = ''
-      -- se utensile 2 esegue completamente
-      elseif Drilling2.ToolInfo.nToolIndex and Drilling2.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL and
-             ( Strategy.Parameters.sDrillingMode == 'PREFER_ONE' or ( not Drilling.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode == 'AUTO')) then
-         Drilling2.sDepth = 'TH'
-         Drilling2.nToolIndex = Drilling2.ToolInfo.nToolIndex
-         Drilling2.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
-         Drilling2.bInvert = true
-         Drilling2.vtToolDirection = -Proc.FeatureInfo.vtDrillExtrusion
-         table.insert( Machining, Drilling2)
-         -- voto
-         Strategy.Result.sStatus = 'Completed'
-         Strategy.Result.dCompletionIndex = 5
-         Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
-         Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
-         Strategy.Result.sInfo = ''
-      -- se possono lavorare entrambi
-      elseif Drilling.ToolInfo.nToolIndex and Drilling2.ToolInfo.nToolIndex then
-         Drilling.nToolIndex = Drilling.ToolInfo.nToolIndex
-         Drilling.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
-         Drilling.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
-         Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth
-         table.insert( Machining, Drilling)
-
-         Drilling2.nToolIndex = Drilling2.ToolInfo.nToolIndex
-         Drilling2.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
-         Drilling2.bInvert = true
-         Drilling2.vtToolDirection = -Proc.FeatureInfo.vtDrillExtrusion
-         Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth
-         table.insert( Machining, Drilling2)
-         if Drilling.ToolInfo.dResidualDepth + Drilling2.ToolInfo.dResidualDepth < Proc.FeatureInfo.dDrillLen then
-            Strategy.Result.sStatus = 'Not-Completed'
-            local dMachinedLen = Machining[1].sDepth + Machining[2].sDepth
-            local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
-            Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
-            Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
-         else
-            Strategy.Result.sStatus = 'Completed'
-            Strategy.Result.dCompletionIndex = 5
-            Strategy.Result.sInfo = ''
-         end
-         -- voto
-         Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
-         Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
-      -- se utensile 1 non completo
-      elseif Drilling.ToolInfo.nToolIndex and ( Strategy.Parameters.sDrillingMode ~= 'FORCE_TWO' or Proc.FeatureInfo.bIsDrillOpen) then
-         Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth
-         Drilling.nToolIndex = Drilling.ToolInfo.nToolIndex
-         Drilling.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
-         Drilling.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
-         Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth
-         table.insert( Machining, Drilling)
-         -- voto
-         Strategy.Result.sStatus = 'Not-Completed'
-         local dMachinedLen = Machining[1].sDepth
-         local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
-         Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
-         Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
-         Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
-         Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
-         -- se utensile 2 non completo
-      elseif Drilling2.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode ~= 'FORCE_TWO' then
-         Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth
-         Drilling2.nToolIndex = Drilling2.ToolInfo.nToolIndex
-         Drilling2.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
-         Drilling2.bInvert = true
-         Drilling2.vtToolDirection = -Proc.FeatureInfo.vtDrillExtrusion
-         Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth
-         table.insert( Machining, Drilling2)
-         -- voto
-         Strategy.Result.sStatus = 'Not-Completed'
-         local dMachinedLen = Machining[1].sDepth
-         local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
-         Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
-         Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
-         Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
-         Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
-      else
-         local sMessage
-         -- se non sono state trovate punte
-         if not Drilling.ToolInfo.nToolIndex and not Drilling2.ToolInfo.nToolIndex then
-            sMessage = 'Drillbit not found'
-         -- se son state trovate delle punte, ma non è stato possibile forare da entrambe le parti
-         elseif Strategy.Parameters.sDrillingMode == 'FORCE_TWO' then
-            sMessage = "Not possible to force machining from both sides. Please change drilling mode to AUTO"
-         end
-         Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( sMessage)
+         Drilling2.dStep = TOOLS[Drilling2.nToolIndex].dStep
       end
    end
+
+   -- se possono lavorare entrambi e si deve fare lavorazione doppia e si riesce a completare
+   if Drilling.ToolInfo.nToolIndex and Drilling2.ToolInfo.nToolIndex and
+      ( Strategy.Parameters.sDrillingMode == 'FORCE_TWO'  or Strategy.Parameters.sDrillingMode == 'AUTO') and
+      Drilling.ToolInfo.dResidualDepth + Drilling2.ToolInfo.dResidualDepth < Proc.FeatureInfo.dDrillLen then
+
+      local dExtraDrill = ( Proc.FeatureInfo.dDrillLen - BeamData.MILL_OVERLAP - ( Drilling.ToolInfo.dResidualDepth + Drilling2.ToolInfo.dResidualDepth)) / 2
+      Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth - dExtraDrill
+      table.insert( Machining, Drilling)
+
+      Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth - dExtraDrill
+      table.insert( Machining, Drilling2)
+
+      -- voto
+      Strategy.Result.sStatus = 'Completed'
+      Strategy.Result.dCompletionIndex = 5
+      Strategy.Result.sInfo = ''
+      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
+
+   -- se utensile 1 esegue completamente
+   elseif Drilling.ToolInfo.nToolIndex and Drilling.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL and
+            ( Strategy.Parameters.sDrillingMode == 'PREFER_ONE' or ( not Drilling2.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode == 'AUTO') or not Proc.FeatureInfo.bIsDrillOpen) then
+      Drilling.sDepth = Proc.FeatureInfo.dDrillLen
+      table.insert( Machining, Drilling)
+      -- voto
+      Strategy.Result.sStatus = 'Completed'
+      Strategy.Result.dCompletionIndex = 5
+      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
+      Strategy.Result.sInfo = ''
+      -- annullo altra lavorazione
+      Drilling2.ToolInfo.nToolIndex = nil
+   -- se utensile 2 esegue completamente
+   elseif Drilling2.ToolInfo.nToolIndex and Drilling2.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL and
+            ( Strategy.Parameters.sDrillingMode == 'PREFER_ONE' or ( not Drilling.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode == 'AUTO')) then
+      Drilling2.sDepth = Proc.FeatureInfo.dDrillLen
+      table.insert( Machining, Drilling2)
+      -- voto
+      Strategy.Result.sStatus = 'Completed'
+      Strategy.Result.dCompletionIndex = 5
+      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
+      Strategy.Result.sInfo = ''
+      -- annullo altra lavorazione
+      Drilling.ToolInfo.nToolIndex = nil
+   -- se possono lavorare entrambi
+   elseif Drilling.ToolInfo.nToolIndex and Drilling2.ToolInfo.nToolIndex then
+      Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth
+      table.insert( Machining, Drilling)
+
+      Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth
+      table.insert( Machining, Drilling2)
+      if Drilling.ToolInfo.dResidualDepth + Drilling2.ToolInfo.dResidualDepth < Proc.FeatureInfo.dDrillLen then
+         Strategy.Result.sStatus = 'Not-Completed'
+         local dMachinedLen = Machining[1].sDepth + Machining[2].sDepth
+         local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
+         Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
+         Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
+      else
+         Strategy.Result.sStatus = 'Completed'
+         Strategy.Result.dCompletionIndex = 5
+         Strategy.Result.sInfo = ''
+      end
+      -- voto
+      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
+   -- se utensile 1 non completo
+   elseif Drilling.ToolInfo.nToolIndex and ( Strategy.Parameters.sDrillingMode ~= 'FORCE_TWO' or Proc.FeatureInfo.bIsDrillOpen) then
+      Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth
+      table.insert( Machining, Drilling)
+      -- voto
+      Strategy.Result.sStatus = 'Not-Completed'
+      local dMachinedLen = Machining[1].sDepth
+      local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
+      Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
+      Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
+      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
+      -- annullo altra lavorazione
+      Drilling2.ToolInfo.nToolIndex = nil
+      -- se utensile 2 non completo
+   elseif Drilling2.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode ~= 'FORCE_TWO' then
+      Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth
+      table.insert( Machining, Drilling2)
+      -- voto
+      Strategy.Result.sStatus = 'Not-Completed'
+      local dMachinedLen = Machining[1].sDepth
+      local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
+      Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
+      Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
+      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
+      -- annullo altra lavorazione
+      Drilling.ToolInfo.nToolIndex = nil
+   else
+      local sMessage
+      -- se non sono state trovate punte
+      if not Drilling.ToolInfo.nToolIndex and not Drilling2.ToolInfo.nToolIndex then
+         sMessage = 'Drillbit not found'
+      -- se son state trovate delle punte, ma non è stato possibile forare da entrambe le parti
+      elseif Strategy.Parameters.sDrillingMode == 'FORCE_TWO' then
+         sMessage = "Not possible to force machining from both sides. Please change drilling mode to AUTO"
+      end
+      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( sMessage)
+   end
+
+   -- calcolo tempo di lavorazione
+   Strategy.Result.dTimeToMachine = 0
+   if Drilling.ToolInfo.nToolIndex then
+      Strategy.Result.dTimeToMachine = MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Drilling, Part)
+   end
+   if Drilling2.ToolInfo.nToolIndex then
+      Strategy.Result.dTimeToMachine = Strategy.Result.dTimeToMachine + MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Drilling2, Part)
+   end
+
    return Machining, Strategy.Result
 end
 

Strategies/Standard/STR0012/STR0012.json

@@ -70,26 +70,6 @@
             }
          ]
       },
-      {
-         "sName": "dMinZAngleTopBlade",
-         "sNameNge": "MIN_Z_ANGLE_TOP_BLADE",
-         "sValue": "",
-         "sDescriptionShort": "Min Z angle top blade",
-         "sDescriptionLong": "",
-         "sType": "d",
-         "sMessageId": " ",
-         "sMinUserLevel": "1"
-      },
-      {
-         "sName": "dMaxYAngleTopBlade",
-         "sNameNge": "MAX_Y_ANGLE_TOP_BLADE",
-         "sValue": "",
-         "sDescriptionShort": "Max Y angle top blade",
-         "sDescriptionLong": "",
-         "sType": "d",
-         "sMessageId": " ",
-         "sMinUserLevel": "1"
-      },
       {
          "sName": "dMaxWasteLength",
          "sSource": "GEN_dMaxWasteLength",

Strategies/Standard/STR0012/STR0012.lua

@@ -5,7 +5,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
@@ -59,9 +59,9 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
    -- separazione della terza faccia
    local idAddedTmFace
    local nAddedFace
-   if Proc.AdjacencyMatrix[1][2] > 10 * GEO.EPS_ANG_SMALL and Proc.AdjacencyMatrix[2][3] < 10 * GEO.EPS_ANG_SMALL then
+   if Proc.AdjacencyMatrix[2][3] < 0 then
       nAddedFace = 1 - 1
-   elseif Proc.AdjacencyMatrix[2][3] > 10 * GEO.EPS_ANG_SMALL and Proc.AdjacencyMatrix[3][1] < 10 * GEO.EPS_ANG_SMALL then
+   elseif Proc.AdjacencyMatrix[1][3] < 0 then
       nAddedFace = 2 - 1
    else
       nAddedFace = 3 - 1
@@ -73,8 +73,14 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
    if not( AreSameVectorApprox( Proc.Faces[nAddedFace + 1].vtN, X_AX()) and abs( Proc.Faces[nAddedFace + 1].ptCenter:getX() - Part.b3Part:getMax():getX()) < 10 * GEO.EPS_SMALL)
       and not( AreSameVectorApprox( Proc.Faces[nAddedFace + 1].vtN, -X_AX()) and abs( Proc.Faces[nAddedFace + 1].ptCenter:getX() - Part.b3Part:getMin():getX()) < 10 * GEO.EPS_SMALL) then
 
-      -- faccia aggiuntiva da lavorare
-      idAddedTmFace = EgtCopySurfTmFacet( Proc.id, nAddedFace, nAddGrpId)
+      -- faccia aggiuntiva da lavorare: si estende fino al box della parte
+      local idAddGroup
+      if bAddMachining then
+         idAddGroup = BeamLib.GetAddGroup( Part.id)
+      else
+         idAddGroup = Part.idTempGroup
+      end
+      idAddedTmFace = EgtSurfTmPlaneInBBox( idAddGroup, Proc.Faces[nAddedFace + 1].ptCenter, Proc.Faces[nAddedFace + 1].vtN, Part.b3Part, GDB_ID.ROOT)
    end
       
    -- rimozione della terza faccia dalla Proc
@@ -85,17 +91,13 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
    NewProc.NotClampableLength = FeatureLib.CalculateFeatureNotClampableLengths( NewProc, Part)
    NewProc.bHindersLaserMeasure = FeatureLib.CalculateFeatureHindersLaserMeasure( NewProc, Part)
 
-   -- TODO rimuovere??? codolo da implementare o no??
    -- considerazioni necessarie a determinare se lavorare con codolo oppure no
    local bKeepWasteAttached = ( Strategy.Parameters.sCuttingStrategy == 'KEEP_WASTE_ATTACHED')
    local bDropWaste = ( Strategy.Parameters.sCuttingStrategy == 'DROP_WASTE')
-   local dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail = FeatureLib.GetFeatureMaxNotClampableLengths( NewProc, Part)
-   local bFeatureHindersClamping = FeatureLib.IsMachiningLong( max( dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail), Part, { dMaxSegmentLength = BeamData.LONGCUT_ENDLEN})
-   local bIsFeatureLong = FeatureLib.IsMachiningLong( NewProc.b3Box:getDimX(), Part, { dMaxSegmentLength = BeamData.LONGCUT_ENDLEN})
+   local bFeatureHindersClamping = MachiningLib.IsFeatureHinderingClamping( Proc, Part)
 
    -- lavorazione con codolo
-   if ( bIsFeatureLong)
-      or ( bFeatureHindersClamping and not bDropWaste)
+   if ( bFeatureHindersClamping and not bDropWaste)
       or bKeepWasteAttached then
 
       local BladeKeepWasteResult
@@ -109,19 +111,9 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
 
    -- lavorazione a cubetti facce concave
    else
-      local dMinZTopBlade
-      local dMaxNyTopBlade
       local BladeToWasteResult
-      if Strategy.Parameters.dMinZAngleTopBlade then
-         dMinZTopBlade = sin( Strategy.Parameters.dMinZAngleTopBlade)
-      end
-      if Strategy.Parameters.dMaxYAngleTopBlade then
-         dMaxNyTopBlade = sin( Strategy.Parameters.dMaxYAngleTopBlade)
-      end
       local OptionalParameters = { dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume,
                                  dMaxWasteLength = Strategy.Parameters.dMaxWasteLength,
-                                 dMinNzTopBlade = dMinZTopBlade,
-                                 dMaxNyTopBlade = dMaxNyTopBlade,
                                  bSaveAddedGeometries = bAddMachining,
                                  dExtendAfterTail = dExtendAfterTail,
                                  bReduceBladePath = Strategy.Parameters.bReduceBladePath
@@ -138,19 +130,9 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
    -- TODO da completare
    -- TODO va messa per prima????????
    if idAddedTmFace then
-      local dMinZTopBlade
-      local dMaxNyTopBlade
       local BladeToWasteResult
-      if Strategy.Parameters.dMinZAngleTopBlade then
-         dMinZTopBlade = sin( Strategy.Parameters.dMinZAngleTopBlade)
-      end
-      if Strategy.Parameters.dMaxYAngleTopBlade then
-         dMaxNyTopBlade = sin( Strategy.Parameters.dMaxYAngleTopBlade)
-      end
       local OptionalParameters = { dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume,
                                    dMaxWasteLength = Strategy.Parameters.dMaxWasteLength,
-                                   dMinNzTopBlade = dMinZTopBlade,
-                                   dMaxNyTopBlade = dMaxNyTopBlade,
                                    bSaveAddedGeometries = bAddMachining,
                                    dExtendAfterTail = dExtendAfterTail,
                                    bReduceBladePath = Strategy.Parameters.bReduceBladePath

Strategies/Standard/STR0013/STR0013.lua

@@ -5,7 +5,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
@@ -198,6 +198,10 @@ function STR0013.Make( bAddMachining, Proc, Part, CustomParameters)
 
          MachiningToAdd.nToolIndex = nIndexTool
          MachiningToAdd.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
+
+         if Proc.AffectedFaces.bLeft and  not Proc.FeatureInfo.bIsDrillOpen then
+            MachiningToAdd.sStage = 'AfterTail'
+         end
          bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, MachiningToAdd)
       end
    end

Strategies/Standard/STR0014/STR0014.lua

@@ -9,7 +9,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 local ID = require( 'Identity')

Strategies/Standard/STR0015/STR0015.lua

@@ -6,7 +6,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 local FaceData = require( 'FaceData')
@@ -108,15 +108,17 @@ local function GetRoughStrategy( Proc, Part, bSaveAddedGeometries)
    local nMidFacet = Proc.nFct // 2        -- faccia a metà circa
    local vtN = EgtSurfTmFacetNormVersor( Proc.id, nMidFacet, GDB_ID.ROOT)
 
-   local nAddGroupId = BeamLib.GetAddGroup( Part.id)
+   local idAddGroup
+   if bSaveAddedGeometries then
+      idAddGroup = BeamLib.GetAddGroup( Part.id)
+   else
+      idAddGroup = Part.idTempGroup
+   end
    -- aggiungo piano di sgrossatura e lo lavoro
    local ptStart, vtNP = GetSawCutData( Proc, Proc.idAddAuxGeom, vtNF, vtN)
-   local AddId = EgtSurfTmPlaneInBBox( nAddGroupId, ptStart, vtNP, Part.b3Part, GDB_RT.GLOB)
+   local AddId = EgtSurfTmPlaneInBBox( idAddGroup, ptStart, vtNP, Part.b3Part, GDB_RT.GLOB)
    -- se la faccia è stata creata
    if AddId then
-      if not bSaveAddedGeometries then
-         EgtSetLevel( AddId, GDB_LV.TEMP)
-      end
 
       -- creo piano di taglio sulla testa del tenone
       local OptionalParameters = { dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume,
@@ -209,7 +211,7 @@ local function GetEdgeWithCornerStrategy( Proc, Part)
    -- direzioni di lavorazione
    local vtCutDir1
    -- se è diretta verso alto o basso
-   if vtN:getZ() > vtN:getY() then
+   if abs( vtN:getZ()) > abs( vtN:getY()) then
       if vtN:getZ() > 0 then
          vtCutDir1 = Z_AX()
       else
@@ -231,81 +233,99 @@ local function GetEdgeWithCornerStrategy( Proc, Part)
       vtCutDir2 = -X_AX()
    end
 
+   local nMachiningsToAdd
+
    -- AUTO = preferisce lama. Se non è possibile prende fresa
    -- BLADE_FORCED = solo lama, altriemnti non applica nulla (potrebbe essere necessario un ribaltamento)
    -- MILL_FORCED = solo fresa, altriemnti non applica nulla (potrebbe essere necessario un ribaltamento)
    if Strategy.Parameters.sConcaveFaceStrategy == 'AUTO' or Strategy.Parameters.sConcaveFaceStrategy == 'BLADE_FORCED' then
+
+      nMachiningsToAdd = 0
+
       -- TODO c'è una funzione che ritorni l'edge di connessione tra una faccia e un'altra?
       -- lavorazione faccia 1 spigolo finale
       if bLastTrim then
+         nMachiningsToAdd = nMachiningsToAdd + 1
          local EdgeToMachine = GetEdgeToMachine( Proc, nLastFacet+1, vtCutDir1)
          local Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[nLastFacet+1], EdgeToMachine)
          if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
             Cutting.sStage = 'AfterTail'
          end
-         if Cutting then
+         if Cutting.bIsApplicable then
             table.insert( Machining, Cutting)
          end
       end
 
       -- lavorazione faccia 1 spigolo iniziale
       if bFirstTrim then
+         nMachiningsToAdd = nMachiningsToAdd + 1
          local EdgeToMachine = GetEdgeToMachine( Proc, nFirstFacet+2, vtCutDir1)
          local Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[nFirstFacet+2], EdgeToMachine)
          if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
             Cutting.sStage = 'AfterTail'
          end
-         if Cutting then
+         if Cutting.bIsApplicable then
             table.insert( Machining, Cutting)
          end
       end
 
       -- lavorazione faccia 2 spigolo finale
       if bLastTrim then
+         nMachiningsToAdd = nMachiningsToAdd + 1
          EdgeToMachine = GetEdgeToMachine( Proc, nLastFacet, vtCutDir2)
          Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[nLastFacet], EdgeToMachine)
-         if Cutting then
+         if Cutting.bIsApplicable then
             table.insert( Machining, Cutting)
          end
       end
 
       -- lavorazione faccia 2 spigolo iniziale
       if bFirstTrim then
+         nMachiningsToAdd = nMachiningsToAdd + 1
          local EdgeToMachine = GetEdgeToMachine( Proc, nFirstFacet+1, vtCutDir2)
          local Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[nFirstFacet+1], EdgeToMachine)
-         if Cutting then
+         if Cutting.bIsApplicable then
             table.insert( Machining, Cutting)
          end
       end
    end
 
    -- se non ci sono lavorazioni provo a pulire spigoli con fresa, a patto che non sia stato forzato con lama
-   if #Machining == 0  and Strategy.Parameters.sConcaveFaceStrategy ~= 'BLADE_FORCED' then
+   if ( not nMachiningsToAdd or ( #Machining < nMachiningsToAdd)) and Strategy.Parameters.sConcaveFaceStrategy ~= 'BLADE_FORCED' then
+
+      Machining = {}
+      nMachiningsToAdd = 0
+
       -- TODO c'è una funzione che ritorni l'edge di connessione tra una faccia e un'altra?
       -- lavorazione faccia 1 spigolo iniziale
       if bFirstTrim then
+         nMachiningsToAdd = nMachiningsToAdd + 1
          local EdgeToMachine = GetEdgeToMachine( Proc, nFirstFacet+2, vtCutDir1)
          local Milling = FaceByMill.Make( Proc, Part, Proc.Faces[nFirstFacet+2], EdgeToMachine)
          if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
             Milling.sStage = 'AfterTail'
          end
-         if Milling then
+         if Milling.bIsApplicable then
             table.insert( Machining, Milling)
          end
       end
 
       -- lavorazione faccia 2 spigolo finale
       if bLastTrim then
+         nMachiningsToAdd = nMachiningsToAdd + 1
          EdgeToMachine = GetEdgeToMachine( Proc, nLastFacet, vtCutDir2)
          local Milling = FaceByMill.Make( Proc, Part, Proc.Faces[nLastFacet], EdgeToMachine)
          if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
             Milling.sStage = 'AfterTail'
          end
-         if Milling then
+         if Milling.bIsApplicable then
             table.insert( Machining, Milling)
          end
       end
+   end
 
+   if nMachiningsToAdd and ( #Machining < nMachiningsToAdd) then
+      Result = { dCompletionPercentage = ( #Machining / nMachiningsToAdd)}
    end
 
    return Machining, Result
@@ -439,7 +459,7 @@ local function GetArcStrategy( Proc, Part)
 
    local bExecStrip = false
    -- se la lavorazione si trova nella parte inferiore o in battuta dietro, il codolo va sempre lasciato
-   if bIsFeatureDown or bIsFeatureBack or bForceStrip then
+   if ID.IsRoundArch( Proc) and ( bIsFeatureDown or bIsFeatureBack or bForceStrip) then
       if bIsFeatureDown or bIsFeatureBack then
          dDimStrip = dDimStrip or max( BeamData.DIM_STRIP or 5, 5)
       else
@@ -637,7 +657,7 @@ local function GetFeatureResult( Proc)
    -- se richieste anche le altre lavorazioni
    if not Strategy.Parameters.bOnlyChamfer then
       -- per tutti tranne che per feature RoundArc
-      if not ID.IsRoundArch( Proc) then
+      if not ID.IsRoundArch( Proc) and not ID.IsFreeContour( Proc) then
          -- se sgrossatura da eseguire
          if Strategy.Parameters.bExecRough then
             if not Strategy.RoughCut.Machinings or #Strategy.RoughCut.Machinings == 0 then
@@ -698,7 +718,7 @@ function STR0015.Make( bAddMachining, Proc, Part, CustomParameters)
 
    local bAreAllMachiningsAdded = true
 
-   -- calcolo se la lavorazione del tenone può essere spostata dopo taglio di coda
+   -- verifico se la lavorazione può essere spostata dopo taglio di coda
    local dLengthOnX = Proc.b3Box:getDimX()
    Strategy.bCanMoveAfterSplit = MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part)
 
@@ -718,7 +738,7 @@ function STR0015.Make( bAddMachining, Proc, Part, CustomParameters)
    -- se non bisogna fare solo gli smussi, si calcolano le altre lavorazioni
    if not Strategy.Parameters.bOnlyChamfer then
       -- per tutti tranne che per feature RoundArc
-      if not ID.IsRoundArch( Proc) then
+      if not ID.IsRoundArch( Proc) and not ID.IsFreeContour( Proc) then
          -- lavorazione taglio per sgrossare
          if Strategy.Parameters.bExecRough then
             Strategy.RoughCut = {}
@@ -760,7 +780,7 @@ function STR0015.Make( bAddMachining, Proc, Part, CustomParameters)
       end
 
       -- per tutti tranne che per feature RoundArc
-      if not ID.IsRoundArch( Proc) then
+      if not ID.IsRoundArch( Proc) and not ID.IsFreeContour( Proc) then
          -- lavorazione di sgrezzatura di lama
          if Strategy.Parameters.bExecRough and Strategy.RoughCut.Machinings then
             -- se cutting da fare come svuotatura
@@ -797,10 +817,7 @@ function STR0015.Make( bAddMachining, Proc, Part, CustomParameters)
             Strategy.Profile.Machinings[i].Geometry = {{ Proc.idAddAuxGeom, -1}}
             Strategy.Profile.Machinings[i].nToolIndex = Strategy.Profile.Machinings[i].ToolInfo.nToolIndex
             Strategy.Profile.Machinings[i].nType = MCH_MY.MILLING
-            Strategy.Profile.Machinings[i].Steps = {}
-
-            Strategy.Profile.Machinings[i].Steps.dStep = TOOLS[Strategy.Profile.Machinings[i].ToolInfo.nToolIndex].dStep
-            Strategy.Profile.Machinings[i].Steps = MachiningLib.GetMachiningSteps( tonumber( Strategy.Profile.Machinings[i].sDepth), TOOLS[Strategy.Profile.Machinings[i].nToolIndex].dStep)
+            Strategy.Profile.Machinings[i].Steps = MachiningLib.GetMachiningSteps( false, tonumber( Strategy.Profile.Machinings[i].sDepth), TOOLS[Strategy.Profile.Machinings[i].nToolIndex].dStep)
             Strategy.Profile.Machinings[i].Steps.nStepType = MCH_MILL_ST.ONEWAY
 
             -- LeadIn / LeadOut

Strategies/Standard/TAILCUT/TAILCUT.lua

@@ -5,7 +5,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local FeatureLib = require( 'FeatureLib')
 local MachiningLib = require( 'MachiningLib')
 local SPLITCUT = require( 'SPLITCUT')
@@ -34,6 +34,8 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
    Strategy.Result.sInfo = ''
    local OptionalParameters = { bForceChainSaw = Strategy.Parameters.bForceChainSaw, bReduceBladePath = Strategy.Parameters.bReduceBladePath,
                                 dMaxWasteLength = Strategy.Parameters.dMaxWasteLength, dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume }
+   OptionalParameters.sRestLengthSideForPreSimulation = 'Tail'
+   OptionalParameters.bCannotSplitRestLength = true
    local bAreAllMachiningsAdded = true
    local bExecutePrecutOnly = false
 
@@ -49,6 +51,11 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       OptionalParameters.bDisableDicing = true
       Strategy.SplitStrategy, Strategy.Result = SPLITCUT.GetMachining( Proc, Part, OptionalParameters)
 
+      if Strategy.Result.sStatus ~= 'Completed' then
+         Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Split not possible')
+         return false, Strategy.Result
+      end
+
    -- se devo rimuovere tutto il restante
    else
       -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
@@ -58,10 +65,18 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
             OptionalParameters.dOffset = 0
          else
             Strategy.bIsPreCut = true
+            -- TODO questo dOffset è errato, va creata una nuova faccia oppure usare dLongitudinalOffset e farlo transitare per tutti, anche Engagement
+            -- TODO a dRestLength va anche aggiunto lo spessore lama se c'è a fine grezzo?
             OptionalParameters.dOffset = Part.dRestLength
          end
          OptionalParameters.bDisableDicing = true
          Strategy.SplitStrategy, Strategy.Result = SPLITCUT.GetMachining( Proc, Part, OptionalParameters)
+
+         if Strategy.Result.sStatus ~= 'Completed' then
+            Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Precut Tail not possible')
+            return false, Strategy.Result
+         end
+
       -- se non faccio tagli PRECUT, imposto tabella Result direttamente. Non serve verificare che riesca a rimuovere il materiale extra 
       else
          Strategy.Result.sStatus = 'Completed'
@@ -122,21 +137,26 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
          end
 
          if not bExecutePrecutOnly then
-            OptionalParameters = {}
 
-            -- eventuale grezzo custom per dicing (grezzo attuale + grezzo di coda)
-            local nNextRawId = EgtGetNextRawPart( Part.idRaw)
-            if nNextRawId then
-               local b3BoxDicing = EgtGetRawPartBBox( nNextRawId)
-               b3BoxDicing:Add( Part.b3Raw)
-               OptionalParameters.b3BoxDicing = b3BoxDicing
+            -- si recuperano gli estremi del box del materiale di coda da rimuovere
+            local b3PartWithTail = BeamLib.GetPartBoxWithHeadTail( Part, 'Tail')
+            local ptStartRestLength = Point3d( Part.b3Part:getMin():getX() + 1, Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
+            local ptEndRestLength = Point3d( b3PartWithTail:getMin():getX(), Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
+
+            local OptionalParametersBladeToWaste = {}
+            OptionalParametersBladeToWaste.b3BoxDicing = BBox3d( ptStartRestLength, ptEndRestLength)
+            OptionalParametersBladeToWaste.dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume
+            OptionalParametersBladeToWaste.dMaxWasteLength = Strategy.Parameters.dMaxWasteLength
+            OptionalParametersBladeToWaste.bReduceBladePath = Strategy.Parameters.bReduceBladePath
+            OptionalParametersBladeToWaste.sRestLengthSideForPreSimulation = 'Tail'
+            OptionalParametersBladeToWaste.bCannotSplitRestLength = true
+
+            Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
+            -- se taglio non riuscito, si riprova con il riduci percorso forzato (collisione possibile in separazione pezzi alti)
+            if ( not Strategy.Machining) or ( #Strategy.Machining == 0) then
+               OptionalParametersBladeToWaste.bReduceBladePath = true
+               Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
             end
-
-            OptionalParameters.dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume
-            OptionalParameters.dMaxWasteLength = Strategy.Parameters.dMaxWasteLength
-            OptionalParameters.bReduceBladePath = Strategy.Parameters.bReduceBladePath
-
-            Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParameters)
             if Strategy.Machining and #Strategy.Machining > 0 then
                for i = 1, #Strategy.Machining do
                   local TempList = {}
@@ -149,6 +169,9 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
                   end
                   table.insert( MachiningsToAdd, TempList)
                end
+            else
+               Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Tail machining not possible')
+               return false, Strategy.Result
             end
          end
       end

StrategyLibs/BLADEKEEPWASTE.lua

@@ -11,6 +11,7 @@ require( 'EgtBase')
 local FeatureLib = require( 'FeatureLib')
 local FaceData = require( 'FaceData')
 local MachiningLib = require( 'MachiningLib')
+local BeamLib = require('BeamLib')
 -- strategie di base
 local FaceByBlade = require('FACEBYBLADE')
 local FaceByMill = require('FACEBYMILL')
@@ -104,7 +105,7 @@ local function GetStrategyCompletionPercentage( Machinings)
       if nWeightsCount ~= 0  and  nWeightsCount ~= i then
          error( 'GetWeightedCompletionPercentage : inconsistent weights')
       end
-      local dWeightedCompletionPercentage = Machining.dCompletionPercentage / 100 * dWeight
+      local dWeightedCompletionPercentage = ( Machining.dCompletionPercentage or 0) / 100 * dWeight
       if Machining.bIsApplicable then
          dCompletionPercentageNumerator = dCompletionPercentageNumerator + dWeightedCompletionPercentage
       end
@@ -119,8 +120,8 @@ end
 
 function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
    -- TODO verificare funzionamento con lama da sotto
-   -- attenzione perchè se l'inclinazione della faccia la fa finire oltre lo spigolo questo riduce il massimo (come calcolare????)
-   -- il FindBlade dovrà restituire di utilizzare sempre la lama sopra se l'angolo lo permette, ma avendo un'altezza massima (da macchina) oltre cui il DownUp non sarà fattibile (evita collisioni tra asse e pezzo)
+   -- TODO scelta utensile è corretto lasciarla a FaceByBlade?
+   -- TODO aggiungere accorciamento se angolo < 90
    
    local Result = {}
    local Machinings = {}
@@ -137,11 +138,6 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
          Result = FeatureLib.GetStrategyResultNotApplicable( 'BladeKeepWaste : angle between faces must be concave and >= 90deg')
          return Machinings, Result
       end
-      -- Rabbet lungo X non gestito
-      if Proc.Topology.sName == 'Rabbet-2-Through' and Proc.AffectedFaces.bLeft and Proc.AffectedFaces.bRight then
-         Result = FeatureLib.GetStrategyResultNotApplicable( 'BladeKeepWaste : Rabbet along X not managed')
-         return Machinings, Result
-      end
    elseif Proc.nFct == 3 then
       -- caso speciale RidgeLap - per angolo tra le facce >= 90deg (feature convessa) non applicabile
       if Proc.AdjacencyMatrix[1][2] > 10 * GEO.EPS_SMALL or Proc.AdjacencyMatrix[1][2] < -91 then
@@ -171,9 +167,11 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
       bFinishWithMill = OptionalParameters.bFinishWithMill
    end
    local dMillingOffsetFromSide = OptionalParameters.dMillingOffsetFromSide or 1
+   local dStripWidth = OptionalParameters.dStripWidth or 5
+   local bForced = OptionalParameters.bForced or false
 
    -- volume della feature
-   local dFeatureVolume = FeatureLib.GetFeatureVolume( Proc, Part)
+   local dFeatureVolume = Proc.dVolume
 
    -- si trovano le facce da lavorare
    local BottomFace = {}
@@ -206,43 +204,94 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
    end
 
    -- calcolo lavorazioni
-   -- taglio eventuali facce di chiusura
-   for i = 1, #LongFaces do
-      local Cutting = {}
-      local OptionalParametersFaceByBlade = { bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = 9999, nToolIndex = nToolIndex}
-      Cutting = FaceByBlade.Make( Proc, Part, LongFaces[i], LongFaces[i].MainEdges.BottomEdge, OptionalParametersFaceByBlade)
-      Cutting.nInternalSortingPriority = 1
-      Cutting.dResultWeight = 0.15
-      table.insert( CalculatedMachinings, Cutting)
-   end
+   -- taglio eventuali facce di chiusura o seconda faccia
+      for i = 1, #LongFaces do
+         local Cutting = {}
+         local OptionalParametersFaceByBlade = { bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail, nToolIndex = nToolIndex}
+         Cutting = FaceByBlade.Make( Proc, Part, LongFaces[i], LongFaces[i].MainEdges.BottomEdge, OptionalParametersFaceByBlade)
+         Cutting.nInternalSortingPriority = 1
+         Cutting.dResultWeight = 0.15
+         table.insert( CalculatedMachinings, Cutting)
+      end
 
-   -- taglio con codolo faccia di fondo
-   local dDepthToMachine = BottomEdgeToMachine.dElevation - OptionalParameters.dStripWidth
-   local OptionalParametersFaceByBlade = { dDepthToMachine = dDepthToMachine, bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail, nToolIndex = nToolIndex}
+   -- taglio con codolo faccia di fondo; si provano solo i lati a cui si può accedere (lato opposto aperto)
+   -- TODO il check del lato opposto aperto andrà messo nella FaceByBlade
+   -- TODO verificare se il calcolo del completamento (aggiunta lavorazioni applicabili/non) é corretto
+   local dDepthToMachine = BottomEdgeToMachine.dElevation / 2 - dStripWidth / 2
+   local OptionalParametersFaceByBlade1 = { dDepthToMachine = dDepthToMachine, bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail, nToolIndex = nToolIndex}
+   local BottomEdgeToMachineOpposite = BeamLib.FindEdgeBestOrientedAsDirection( BottomFace.Edges, -BottomEdgeToMachine.vtN)
    -- primo lato
-   Cutting1 = FaceByBlade.Make( Proc, Part, BottomFace, BottomEdgeToMachine, OptionalParametersFaceByBlade)
+   if BottomEdgeToMachineOpposite.bIsOpen then
+      Cutting1 = FaceByBlade.Make( Proc, Part, BottomFace, BottomEdgeToMachine, OptionalParametersFaceByBlade1)
+   end
    Cutting1.nInternalSortingPriority = 3
    Cutting1.dResultWeight = 0.3
-   table.insert( CalculatedMachinings, Cutting1)
+
    -- secondo lato
-   OptionalParametersFaceByBlade.OppositeToolDirectionMode = 'Enabled'
-   Cutting2 = FaceByBlade.Make( Proc, Part, BottomFace, BottomEdgeToMachine, OptionalParametersFaceByBlade)
+   local OptionalParametersFaceByBlade2 = BeamLib.TableCopyDeep( OptionalParametersFaceByBlade1)
+   OptionalParametersFaceByBlade2.OppositeToolDirectionMode = 'Enabled'
+   if BottomEdgeToMachine.bIsOpen then
+      Cutting2 = FaceByBlade.Make( Proc, Part, BottomFace, BottomEdgeToMachine, OptionalParametersFaceByBlade2)
+   end
    Cutting2.nInternalSortingPriority = 3
    Cutting2.dResultWeight = 0.3
-   --table.insert( CalculatedMachinings, Cutting2)
-   
+
+   -- se uno dei due lati non è riuscito, si estende il più possibile il lato rimasto
+   if not Cutting1.bIsApplicable and Cutting2.bIsApplicable then
+
+      -- se si lavora il lato in comune con la LongFace significa che la LongFace non é di chiusura ma un'altra faccia vera e propria
+      -- ci si deve quindi fermare piú indietro
+      for i = 1, #LongFaces do
+         if BottomEdgeToMachine.idAdjacentFace == LongFaces[i].id then
+            dStripWidth = TOOLS[Cutting2.nToolIndex].dThickness + 2 * dStripWidth
+            break
+         end
+      end
+      dDepthToMachine = min( TOOLS[Cutting2.nToolIndex].dMaxMaterial, BottomEdgeToMachine.dElevation - dStripWidth)
+      OptionalParametersFaceByBlade2.dDepthToMachine = dDepthToMachine
+
+      Cutting2 = FaceByBlade.Make( Proc, Part, BottomFace, BottomEdgeToMachine, OptionalParametersFaceByBlade2)
+      Cutting2.nInternalSortingPriority = 3
+      Cutting2.dResultWeight = 0.3
+      table.insert( CalculatedMachinings, Cutting2)
+
+   elseif not Cutting2.bIsApplicable and Cutting1.bIsApplicable then
+
+      -- se si lavora il lato in comune con la LongFace significa che la LongFace non é di chiusura ma un'altra faccia vera e propria
+      -- ci si deve quindi fermare piú indietro
+      for i = 1, #LongFaces do
+         if BottomEdgeToMachine.idAdjacentFace == LongFaces[i].id then
+            dStripWidth = TOOLS[Cutting1.nToolIndex].dThickness + 2 * dStripWidth
+            break
+         end
+      end
+      dDepthToMachine = min( TOOLS[Cutting1.nToolIndex].dMaxMaterial, BottomEdgeToMachine.dElevation - dStripWidth)
+      OptionalParametersFaceByBlade1.dDepthToMachine = dDepthToMachine
+
+      Cutting1 = FaceByBlade.Make( Proc, Part, BottomFace, BottomEdgeToMachine, OptionalParametersFaceByBlade1)
+      Cutting1.nInternalSortingPriority = 3
+      Cutting1.dResultWeight = 0.3
+      table.insert( CalculatedMachinings, Cutting1)
+
+   else
+      table.insert( CalculatedMachinings, Cutting1)
+      table.insert( CalculatedMachinings, Cutting2)
+   end
+
    -- fresatura eventuali facce di chiusura
    if bFinishWithMill then
       for i = 1, #LongFaces do
-         local dDepthToMachineMill = BottomFace.MainEdges.LongEdges[i].dElevation - dMillingOffsetFromSide
-         local dToolMarkLength = max( Cutting1.dToolMarkLength, Cutting2.dToolMarkLength)
-         local OptionalParametersFaceByMill = { bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail,
-                                                dRadialStepSpan = dToolMarkLength, dDepthToMachine = dDepthToMachineMill
-                                              }
-         local Milling = FaceByMill.Make( Proc, Part, BottomFace, BottomFace.MainEdges.LongEdges[i], OptionalParametersFaceByMill)
-         Milling.nInternalSortingPriority = 2
-         Milling.dResultWeight = 0.05
-         table.insert( CalculatedMachinings, Milling)
+         if BottomEdgeToMachine.idAdjacentFace ~= LongFaces[i].id then
+            local dDepthToMachineMill = BottomFace.MainEdges.LongEdges[i].dElevation - dMillingOffsetFromSide
+            local dToolMarkLength = max( Cutting1.dToolMarkLength or 0, Cutting2.dToolMarkLength or 0)
+            local OptionalParametersFaceByMill = { bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail,
+                                                   dRadialStepSpan = dToolMarkLength, dDepthToMachine = dDepthToMachineMill
+                                                }
+            local Milling = FaceByMill.Make( Proc, Part, BottomFace, BottomFace.MainEdges.LongEdges[i], OptionalParametersFaceByMill)
+            Milling.nInternalSortingPriority = 2
+            Milling.dResultWeight = 0.05
+            table.insert( CalculatedMachinings, Milling)
+         end
       end
    end
 
@@ -253,8 +302,10 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
       end
    end
 
-   -- calcolo completamento, serve la lista di lavorazioni che comprende le non applicabili
-   Result.dCompletionPercentage = GetStrategyCompletionPercentage( CalculatedMachinings)
+   -- calcolo completamento (non applicabili devono essere incluse)
+   -- se codolo non forzato si ritorna completa max al 94% (completion index 4)
+   local dCalculatedCompletionPercentage = GetStrategyCompletionPercentage( CalculatedMachinings)
+   Result.dCompletionPercentage = bForced and dCalculatedCompletionPercentage or min( 94, dCalculatedCompletionPercentage)
    Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Result.dCompletionPercentage)
 
    -- aggiunta eventuali lavorazioni splittate
@@ -272,6 +323,9 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
       Result.dMRR = ( dFeatureVolume / Result.dTimeToMachine) / pow( 10, 6)
       if Result.dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then
          Result.sStatus = 'Completed'
+         if bForced then
+            Result.sInfo = 'Waste attached. Remove manually.'
+         end
       else
          Result.sStatus = 'Not-Completed'
       end

StrategyLibs/FACEBYBLADE.lua

@@ -4,142 +4,84 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FaceData = require( 'FaceData')
+local LeadInOutLib = require( 'LeadInOutLib')
 
 -- Tabella per definizione modulo
 local FACEBYBLADE = {}
 
 -------------------------------------------------------------------------------------------------------------
-local function GetLeadInOutType( Machining)
-   local sLeadInOutType = ''
+-- i parametri si leggono da LeadInOut (engagement) e si modificano solo se necessario
+local function GetLeadInOut( Machining, EdgeToMachine, bIsSplitFeature)
 
-   if Machining.bIsStartClosed or Machining.bIsEndClosed
-      or Machining.sCutType == 'Guillotine'
-      or Machining.sCutType == 'Reduced' then
-         
-      sLeadInOutType = 'Perpendicular'
-   else
-      -- testa sopra
-      if TOOLS[Machining.nToolIndex].SetupInfo.HeadType.bTop then
-         if abs( Machining.vtToolDirection:getX()) < 0.7 then
-            if Machining.vtToolDirection:getZ() > -0.087
-               or ( abs( Machining.vtToolDirection:getX()) < 0.34202 and abs( Machining.vtToolDirection:getZ()) < 0.7) then
-               sLeadInOutType = 'Perpendicular'
-            else
-               sLeadInOutType = 'Tangent'
-            end
-         elseif abs( Machining.vtEdgeDirection:getZ()) > 0.7 then
-            sLeadInOutType = 'Perpendicular'
-         else
-            -- TODO qui attacco tangenziale speciale tutto da un lato
-            sLeadInOutType = 'Tangent'
-         end
-      -- testa sotto
-      elseif TOOLS[Machining.nToolIndex].SetupInfo.HeadType.bBottom then
-         if abs( Machining.vtToolDirection:getX()) < 0.7 then
-            if Machining.vtToolDirection:getZ() < -GEO.EPS_SMALL
-               or ( abs( Machining.vtToolDirection:getX()) < 0.34202 and abs( Machining.vtToolDirection:getZ()) < 0.7) then
-               sLeadInOutType = 'Perpendicular'
-            else
-               sLeadInOutType = 'Tangent'
-            end
-         elseif abs( Machining.vtEdgeDirection:getZ()) > 0.7 then
-            sLeadInOutType = 'Perpendicular'
-         else
-            -- TODO qui attacco tangenziale speciale tutto da un lato
-            sLeadInOutType = 'Tangent'
-         end
-      -- se testa senza preferenza Top e Bottom si fa sempre attacco tangenziale
-      else
-         sLeadInOutType = 'Tangent'
-      end
-   end
+   local LeadIn
+   local LeadOut
 
-   return sLeadInOutType
-end
-
-
-local function CalculateLeadInOut( Machining, EdgeToMachine, bIsSplitFeature)
-   -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
-
-   -- accorciamento per lati chiusi (è sempre l'impronta utensile)
-   local dToolMarkLength = sqrt( Machining.dDepthToMachine * TOOLS[Machining.nToolIndex].dDiameter - Machining.dDepthToMachine * Machining.dDepthToMachine)
-   -- allungamento per faccia singola (aperta in tutte le direzioni)
-   local dAddedLengthOpenFace = BeamData.CUT_EXTRA
-   if Machining.sCutType == 'Guillotine' then
-      local dGuillotineLengthToMachine = 1
-      dAddedLengthOpenFace = ( - EdgeToMachine.dLength + dGuillotineLengthToMachine) / 2
-   elseif Machining.sCutType == 'Reduced' then
-      dAddedLengthOpenFace = - FACEBYBLADE.GetPathReductionLength( Machining.nToolIndex, Machining.dMaxRadialOffset)
-   end
-
-   if Machining.bInvert then
-      Machining.bIsStartClosed, Machining.bIsEndClosed = Machining.bIsEndClosed, Machining.bIsStartClosed
-   end
-
-   local LeadIn = {}
-   local LeadOut = {}
-   Machining.sLeadInOutType = ''
-   LeadIn.dStartAddLength = 0
-   LeadOut.dEndAddLength = 0
-   LeadIn.nType = MCH_MILL_LI.LINEAR
-   LeadOut.nType = MCH_MILL_LI.LINEAR
-   LeadIn.dPerpDistance = 0
-   LeadOut.dPerpDistance = 0
-   LeadIn.dTangentDistance = 0
-   LeadOut.dTangentDistance = 0
+   -- in certe condizioni si deve forzare attacco perpendicolare
    if Machining.bIsStartClosed
       or Machining.bIsEndClosed
       or Machining.CloneStepsRadial.nCount > 1
       or Machining.Steps.nCount > 1
       or bIsSplitFeature then
-      
-      Machining.sLeadInOutType = 'Perpendicular'
-      if AreSameVectorApprox( Machining.vtToolDirection, EdgeToMachine.vtN) then
-         LeadIn.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC - Machining.dRadialOffset
-         LeadOut.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC - Machining.dRadialOffset
+
+      if Machining.LeadInOut.Perpendicular then
+
+         Machining.sLeadInOutType = 'Perpendicular'
+
+      -- se attacco perpendicolare richiesto ma non disponibile, la lavorazione non è fattibile
       else
-         LeadIn.dPerpDistance = BeamData.CUT_SIC - Machining.dRadialOffset
-         LeadOut.dPerpDistance = BeamData.CUT_SIC - Machining.dRadialOffset
+
+         return
       end
    else
-      Machining.sLeadInOutType = GetLeadInOutType( Machining)
-      if Machining.sLeadInOutType == 'Perpendicular' then
-         LeadIn.dPerpDistance = 1
-         LeadOut.dPerpDistance = 1
-      else
-         -- TODO da rimuovere, già inserito in GetLeadInOutType
-         if abs( Machining.vtEdgeDirection:getZ()) > 0.707 then
-            LeadIn.dPerpDistance = 1
-            LeadOut.dPerpDistance = 1
-         else
-            LeadIn.dTangentDistance = TOOLS[Machining.nToolIndex].dDiameter / 2 + BeamData.CUT_SIC
-            LeadOut.dTangentDistance = TOOLS[Machining.nToolIndex].dDiameter / 2 + BeamData.CUT_SIC
-         end
-      end
+
+      Machining.sLeadInOutType = Machining.LeadInOut.sChosen
    end
-   LeadIn.dElevation = 0
-   LeadOut.dElevation = 0
-   LeadIn.dCompLength = 0
-   LeadOut.dCompLength = 0
-   if Machining.bIsStartClosed and Machining.bIsEndClosed then
-      LeadIn.dStartAddLength = -dToolMarkLength
-      LeadOut.dEndAddLength = -dToolMarkLength
-   elseif Machining.bIsStartClosed then
-      LeadIn.dStartAddLength = -dToolMarkLength
-      -- eventuale correzione per accorciamento maggiore di larghezza tasca
-      LeadOut.dEndAddLength = max( -LeadIn.dStartAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
-   elseif Machining.bIsEndClosed then
-      LeadOut.dEndAddLength = -dToolMarkLength
-      -- eventuale correzione per accorciamento maggiore di larghezza tasca
-      LeadIn.dStartAddLength = max( -LeadOut.dEndAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
-   else
-      LeadIn.dStartAddLength = dAddedLengthOpenFace
-      LeadOut.dEndAddLength = dAddedLengthOpenFace
+
+   -- si prendono i valori che arrivano da LeadInOut (engagement)
+   LeadIn = BeamLib.TableCopyDeep( Machining.LeadInOut[Machining.sLeadInOutType].LeadIn)
+   LeadOut = BeamLib.TableCopyDeep( Machining.LeadInOut[Machining.sLeadInOutType].LeadOut)
+
+   -- se senso di percorrenza invertito si invertono anche gli attacchi
+   if Machining.bInvert then
+      Machining.bIsStartClosed, Machining.bIsEndClosed = Machining.bIsEndClosed, Machining.bIsStartClosed
+      LeadIn, LeadOut = LeadInOutLib.InvertLeadInOut( LeadIn, LeadOut)
    end
+
+   -- in caso di percorso ridotto gli attacchi vanno adeguati
+   if Machining.sEdgeUsage == 'Guillotine' then
+      local dGuillotineLengthToMachine = 1
+      LeadIn.dStartAddLength = ( - EdgeToMachine.dLength + dGuillotineLengthToMachine) / 2
+      LeadOut.dEndAddLength = ( - EdgeToMachine.dLength + dGuillotineLengthToMachine) / 2
+      LeadIn.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC - Machining.dRadialOffset
+      LeadIn.dTangentDistance = 0
+      LeadOut.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC - Machining.dRadialOffset
+      LeadOut.dTangentDistance = 0
+      LeadIn.dTotalLength = sqrt( LeadIn.dPerpDistance ^ 2 + LeadIn.dTangentDistance ^ 2)
+      LeadOut.dTotalLength = sqrt( LeadOut.dPerpDistance ^ 2 + LeadOut.dTangentDistance ^ 2)
+   elseif Machining.sEdgeUsage == 'Reduced' then
+      LeadIn.dStartAddLength = - FACEBYBLADE.GetPathReductionLength( Machining.nToolIndex, Machining.dMaxRadialOffset)
+      LeadOut.dEndAddLength = - FACEBYBLADE.GetPathReductionLength( Machining.nToolIndex, Machining.dMaxRadialOffset)
+      LeadIn.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC - Machining.dRadialOffset
+      LeadIn.dTangentDistance = 0
+      LeadOut.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC - Machining.dRadialOffset
+      LeadOut.dTangentDistance = 0
+      LeadIn.dTotalLength = sqrt( LeadIn.dPerpDistance ^ 2 + LeadIn.dTangentDistance ^ 2)
+      LeadOut.dTotalLength = sqrt( LeadOut.dPerpDistance ^ 2 + LeadOut.dTangentDistance ^ 2)
+   end
+
+   -- se lavorazione con OppositeToolDirection o ridotta l'attacco va corretto
+   if not AreSameVectorApprox( Machining.vtToolDirection, EdgeToMachine.vtN) then
+      LeadIn.dPerpDistance = BeamData.CUT_SIC - Machining.dRadialOffset
+      LeadOut.dPerpDistance = BeamData.CUT_SIC - Machining.dRadialOffset
+      LeadIn.dTangentDistance = 0
+      LeadOut.dTangentDistance = 0
+   end
+
    -- stima lunghezza reale attacchi per calcolo lunghezza lavorata
+   -- TODO sistemare per nuovi attacchi
    local dEstimatedLeadInPerpDistance = 0
    local dEstimatedLeadInTangentDistance = 0
    local dEstimatedLeadOutPerpDistance = 0
@@ -163,8 +105,8 @@ local function CalculateLeadInOut( Machining, EdgeToMachine, bIsSplitFeature)
 end
 
 
--- TODO implementare SCC in funzione macchina
-local function GetSCC( vtMachiningDirection, vtEdgeDirection, vtNFace)
+-- TODO da eliminare, sostituita da funzione macchina
+function FACEBYBLADE.GetSCC( vtMachiningDirection, vtEdgeDirection, vtNFace)
    local nSCC = MCH_SCC.NONE
 
    if abs( vtMachiningDirection:getX()) > abs( vtMachiningDirection:getY()) - GEO.EPS_SMALL then
@@ -259,60 +201,78 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       dLongitudinalOffset = 0
    end
    local dRadialStepSpan = OptionalParameters.dRadialStepSpan
-   local dMinNzDownUp = OptionalParameters.dMinNzDownUp
    local sUserNotes = OptionalParameters.sUserNotes or ''
+   local bIsDicing = OptionalParameters.bIsDicing or false
+   local sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation or 'Tail'
+   local bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength or false
 
    -- lunghezze, direzioni e punti caratteristici della lavorazione e del lato lavorato
    Cutting.dEdgeLength = EdgeToMachine.dLength
-   if OppositeToolDirectionMode == 'Enabled' then
-      Cutting.vtToolDirection = -EdgeToMachine.vtN
-   else
-      Cutting.vtToolDirection = EdgeToMachine.vtN
-   end
-   Cutting.vtEdgeDirection = EdgeToMachine.vtN ^ FaceToMachine.vtN
-   -- TODO conviene spostare questi calcoli nel FaceData?
-   Cutting.ptEdge1, _, Cutting.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -Cutting.vtToolDirection, GDB_ID.ROOT)
-   -- TODO gestire lama da sotto
-   -- se si conosce il limite downUp (utensile forzato o downUp forzato) si decide se invertire (ToolInvert)
-   -- TODO esiste un limite downUp massimo per la lama da sopra??
-   if nToolIndex and not dMinNzDownUp then
-      dMinNzDownUp = TOOLS[nToolIndex].SetupInfo.GetMinNzDownUp( Part.b3Raw, FaceToMachine.vtN, Cutting.vtToolDirection, TOOLS[nToolIndex])
-   end
-   if dMinNzDownUp and FaceToMachine.vtN:getZ() < dMinNzDownUp then
-      Cutting.bToolInvert = true
-   else
-      Cutting.bToolInvert = false
-   end
+   -- TODO questa deve essere ptEnd - ptStart
+   Cutting.vtEdgeDirection = Vector3d( EdgeToMachine.vtEdge)
+   Cutting.vtToolDirection = EdgeToMachine.vtN
+   Cutting.ptEdge1, Cutting.ptEdge2 = EdgeToMachine.ptStart, EdgeToMachine.ptEnd
+   local EdgeToMachineOpposite = BeamLib.FindEdgeBestOrientedAsDirection( FaceToMachine.Edges, -EdgeToMachine.vtN)
 
-   -- ricerca utensile
+   -- l'utensile arriva da fuori: si determina se il taglio è fattibile e il modo di lavorare della lama
    if nToolIndex then
+
       Cutting.nToolIndex = nToolIndex
+      local BladeEngagementParameters = {
+         Face = FaceToMachine,
+         Edge = EdgeToMachine,
+         Part = Part,
+         Tool = TOOLS[Cutting.nToolIndex],
+         dDepthToMachine = dDepthToMachine
+      }
+      local BladeEngagementOptionalParameters = {
+         bIsDicing = bIsDicing,
+         sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
+         bCannotSplitRestLength = bCannotSplitRestLength
+      }
+      local Engagement
+      TIMER:startElapsed( 'GetBladeEngagement')
+      Cutting.bIsApplicable, Engagement = MachiningLib.GetBladeEngagement( BladeEngagementParameters, BladeEngagementOptionalParameters)
+      TIMER:stopElapsed( 'GetBladeEngagement')
+      if Cutting.bIsApplicable then
+         Cutting.sBladeEngagement = Engagement.sBladeEngagement
+         Cutting.bMoveAfterSplit = Engagement.bMoveAfterSplit
+         Cutting.LeadInOut = Engagement.LeadInOut
+      end
+
+   -- utensile da cercare: si prende la lama migliore che può effettuare questo taglio, senza particolari analisi
    else
       local ToolSearchParameters = {}
       ToolSearchParameters.dElevation = dDepthToMachine
-      if Cutting.bToolInvert then
-         ToolSearchParameters.vtN = -FaceToMachine.vtN
-      else
-         ToolSearchParameters.vtN = FaceToMachine.vtN
-      end
       ToolSearchParameters.bAllowTopHead = true
-      -- TODO bisognerà implementare anche la lama da sotto
-      ToolSearchParameters.bAllowBottomHead = false
+      ToolSearchParameters.bAllowBottomHead = true
       ToolSearchParameters.bForceLongcutBlade = bForceLongcutBlade
+      ToolSearchParameters.FaceToMachine = FaceToMachine
+      ToolSearchParameters.EdgeToMachine = EdgeToMachine
+      ToolSearchParameters.Part = Part
+      ToolSearchParameters.sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation
+      ToolSearchParameters.bCannotSplitRestLength = bCannotSplitRestLength
+
       local ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
-      -- ora che l'utensile è scelto, se non era definito l'angolo di DownUp lo verifico per decidere se invertire
-      if ToolInfo.nToolIndex and not dMinNzDownUp then
-         dMinNzDownUp = TOOLS[ToolInfo.nToolIndex].SetupInfo.GetMinNzDownUp( Part.b3Raw, FaceToMachine.vtN, Cutting.vtToolDirection, TOOLS[ToolInfo.nToolIndex])
-         if FaceToMachine.vtN:getZ() < dMinNzDownUp then
-            Cutting.bToolInvert = true
-         end
-      end
       Cutting.nToolIndex = ToolInfo.nToolIndex
+      if Cutting.nToolIndex then
+         Cutting.sBladeEngagement = ToolInfo.Engagement.sBladeEngagement
+         Cutting.bMoveAfterSplit = ToolInfo.Engagement.bMoveAfterSplit
+         Cutting.LeadInOut = ToolInfo.Engagement.LeadInOut
+      end
+
+      -- se non trovato utensile, la lavorazione non è applicabile
+      if not Cutting.nToolIndex then
+         Cutting.bIsApplicable = false
+      end
    end
-   if not TOOLS[Cutting.nToolIndex] or not TOOLS[Cutting.nToolIndex].sName then
+
+   -- orientamento non raggiungibile o lama non trovata: non applicabile
+   if not Cutting.bIsApplicable then
       Cutting.sMessage = 'Blade not found'
       Cutting.bIsApplicable = false
       EgtOutLog( Cutting.sMessage)
+
       return Cutting, EdgeToMachine.dElevation
    end
 
@@ -322,6 +282,7 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       Cutting.sMessage = 'Pocket too narrow for blade thickness'
       Cutting.bIsApplicable = false
       EgtOutLog( Cutting.sMessage)
+
       return Cutting, EdgeToMachine.dElevation
    end
    -- se tasca chiusa da entrambi i lati e più stretta della lama la lavorazione non è applicabile
@@ -330,17 +291,21 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
          Cutting.sMessage = 'Pocket too narrow for blade diameter'
          Cutting.bIsApplicable = false
          EgtOutLog( Cutting.sMessage)
+
          return Cutting, EdgeToMachine.dElevation
       end
    end
 
    -- parametri della lavorazione
+
    -- profondità (parametro DEPTH)
-      Cutting.sDepth = sDepth
+   Cutting.sDepth = sDepth
+
    -- inizio e fine aperti o chiusi
-      Cutting.bIsStartClosed = not EdgeToMachine.bIsStartOpen
-      Cutting.bIsEndClosed = not EdgeToMachine.bIsEndOpen
-   -- lato di lavoro e inversione per avere taglio concorde
+   Cutting.bIsStartClosed = not EdgeToMachine.bIsStartOpen
+   Cutting.bIsEndClosed = not EdgeToMachine.bIsEndOpen
+
+   -- si settano lato di lavoro e inversione per avere concordanza
    if TOOLS[Cutting.nToolIndex].bIsCCW then
       Cutting.nWorkside = MCH_MILL_WS.RIGHT
       Cutting.bInvert = true
@@ -348,37 +313,95 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       Cutting.nWorkside = MCH_MILL_WS.LEFT
       Cutting.bInvert = false
    end
-   -- se OppositeToolDirectionMode è Optimized, se possibile e necessario, si attiva per garantire taglio concorde e verso l'alto (massima qualità)
-   if ( OppositeToolDirectionMode == 'Optimized') and ( Proc.nFct == 1) and ( FaceData.IsFaceRhomboid( Proc, FaceToMachine.id)) then
-      OppositeToolDirectionMode = 'Disabled'
-      -- la direzione di percorrenza del lato deve essere verso l'alto; bInvert va considerata perchè inverte la direzione di percorrenza.
-      if ( Cutting.bInvert and Cutting.vtEdgeDirection:getZ() > 100 * GEO.EPS_SMALL)
-         or ( ( not Cutting.bInvert) and Cutting.vtEdgeDirection:getZ() < -100 * GEO.EPS_SMALL) then
 
-         -- si attiva OppositeToolDirection solo se non cambiano le condizioni di taglio downUp
-         local dNewMinNzDownUp = TOOLS[nToolIndex].SetupInfo.GetMinNzDownUp( Part.b3Raw, FaceToMachine.vtN, -Cutting.vtToolDirection, TOOLS[nToolIndex])
-         if ( FaceToMachine.vtN:getZ() < dMinNzDownUp) == ( FaceToMachine.vtN:getZ() < dNewMinNzDownUp) then
-            OppositeToolDirectionMode = 'Enabled'
-            Cutting.vtToolDirection = -EdgeToMachine.vtN
-            Cutting.ptEdge1, _, Cutting.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -Cutting.vtToolDirection, GDB_ID.ROOT)
-            Cutting.bInvert = not Cutting.bInvert
-         -- se le condizioni downUp cambiano, si setta per tagliare verso l'alto
-         else
-            if Cutting.nWorkside == MCH_MILL_WS.RIGHT then
-               Cutting.nWorkside = MCH_MILL_WS.LEFT
-               Cutting.bInvert = false
-            else
-               Cutting.nWorkside = MCH_MILL_WS.RIGHT
-               Cutting.bInvert = true
-            end
+   -- ToolInvert
+   if Cutting.sBladeEngagement == 'DownUp' then
+      Cutting.bToolInvert = true
+      Cutting.bInvert = not Cutting.bInvert
+   end
+
+   -- TODO al momento commentato per trovare i casi in cui nei riposizionamenti scende sul pezzo; poi valutare se lasciare o togliere
+   -- se dicing, lato di lavoro e inversione per avere taglio sempre verso l'alto
+    if bIsDicing
+       and ( Cutting.bInvert and Cutting.vtEdgeDirection:getZ() > 100 * GEO.EPS_SMALL)
+       or ( ( not Cutting.bInvert) and Cutting.vtEdgeDirection:getZ() < -100 * GEO.EPS_SMALL) then
+       
+       Cutting.bInvert = not Cutting.bInvert
+       if Cutting.nWorkside == MCH_MILL_WS.LEFT then
+          Cutting.nWorkside = MCH_MILL_WS.RIGHT
+       else
+          Cutting.nWorkside = MCH_MILL_WS.LEFT
+       end
+    end
+
+   -- analisi fattibilità lavorazione dal lato opposto
+   if OppositeToolDirectionMode ~= 'Disabled' then
+
+      -- lavorando dalla direzione opposta si verifica come se si lavorasse il lato opposto
+      local BladeEngagementParameters = {
+         Face = FaceToMachine,
+         Edge = EdgeToMachineOpposite,
+         Part = Part,
+         Tool = TOOLS[Cutting.nToolIndex],
+         dDepthToMachine = dDepthToMachine
+      }
+      local BladeEngagementOptionalParameters = {
+         bIsDicing = bIsDicing,
+         sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
+         bCannotSplitRestLength = bCannotSplitRestLength
+      }
+      TIMER:startElapsed( 'GetBladeEngagement')
+      local bIsApplicableOpposite, EngagementOpposite = MachiningLib.GetBladeEngagement( BladeEngagementParameters, BladeEngagementOptionalParameters)
+      TIMER:stopElapsed( 'GetBladeEngagement')
+
+      -- taglio opposto non fattibile
+      if not bIsApplicableOpposite then
+         -- se richiesto, si ritorna non applicabile
+         if OppositeToolDirectionMode == 'Enabled' then
+
+            Cutting.sMessage = 'Orientation not reachable'
+            Cutting.bIsApplicable = false
+
+            return Cutting, EdgeToMachine.dElevation
+         
+         -- se opzionale, si disabilita
+         elseif OppositeToolDirectionMode == 'Optimized' then
+            OppositeToolDirectionMode = 'Disabled'
+         end
+      end
+
+      -- se OppositeToolDirectionMode è Optimized, se possibile e necessario, si attiva la lavorazione dal lato opposto per garantire taglio concorde e verso l'alto (massima qualità)
+      if ( OppositeToolDirectionMode == 'Optimized') and ( Proc.nFct == 1) and ( FaceData.IsFaceRectangle( FaceToMachine)) then
+
+         OppositeToolDirectionMode = 'Disabled'
+
+         -- la direzione di percorrenza del lato deve essere verso l'alto; bInvert va considerata perchè inverte la direzione di percorrenza
+         -- il BladeEngagement non deve cambiare, altrimenti è inutile invertire la direzione
+         if ( EngagementOpposite.sBladeEngagement == Cutting.sBladeEngagement)
+            and ( EngagementOpposite.bMoveAfterSplit == Cutting.bMoveAfterSplit)
+            and ( Cutting.bInvert and Cutting.vtEdgeDirection:getZ() > 100 * GEO.EPS_SMALL)
+            or ( ( not Cutting.bInvert) and Cutting.vtEdgeDirection:getZ() < -100 * GEO.EPS_SMALL) then
+                  
+            OppositeToolDirectionMode = 'Enabled'
+         end
+      end
+
+      if OppositeToolDirectionMode == 'Enabled' then
+         Cutting.vtToolDirection = EdgeToMachineOpposite.vtN
+         Cutting.ptEdge1, Cutting.ptEdge2 = EdgeToMachineOpposite.ptStart, EdgeToMachineOpposite.ptEnd
+         Cutting.bInvert = not Cutting.bInvert
+         -- TODO da migliorare!!!!!!!!!
+         if not EngagementOpposite.LeadInOut.Perpendicular then
+            Cutting.LeadInOut.Perpendicular = nil
+         end
+         if not EngagementOpposite.LeadInOut.Tangent then
+            Cutting.LeadInOut.Tangent = nil
          end
       end
-   elseif OppositeToolDirectionMode == 'Enabled' then
-      Cutting.bInvert = not Cutting.bInvert
-   end
-   if Cutting.bToolInvert then
-      Cutting.bInvert = not Cutting.bInvert
    end
+
+   -- TODO implementare lavorazione in DownUp se non è già DownUp e non si è riusciti a mantenere verso l'alto e concorde (testare solo DownUp))
+
    -- profondità da lavorare e offset radiale
    if OptionalParameters.dPocketHeight then
       if TOOLS[Cutting.nToolIndex].dMaxDepth > dDepthToMachine - 10 * GEO.EPS_SMALL then
@@ -402,36 +425,72 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
    else
       Cutting.dDepthToMachine = dDepthToMachine
       Cutting.dResidualDepth = 0
-      Cutting.sCutType = 'Standard'
+      Cutting.sEdgeUsage = 'Standard'
       if bReduceBladePath
          and ( Proc.nFct == 1)
-         and FaceData.IsFaceRectangular( Proc, FaceToMachine.id) then
+         and FaceData.IsFaceRectangle( FaceToMachine) then
 
-         local bIsTopBlade = TOOLS[nToolIndex].SetupInfo.HeadType.bTop
-         Cutting.dMaxRadialOffset = TOOLS[nToolIndex].dMaxMaterial - Cutting.dDepthToMachine - BeamData.CUT_SIC
-         Cutting.dRadialOffsetGuillotine = FACEBYBLADE.GetRadialOffsetForGuillotine( nToolIndex, EdgeToMachine.dLength)
+         -- TODO la lama sotto deve poter ridurre. Ghigliottina sì o no?
+         local bIsTopBlade = TOOLS[Cutting.nToolIndex].SetupInfo.HeadType.bTop
+         Cutting.dMaxRadialOffset = TOOLS[Cutting.nToolIndex].dMaxMaterial - Cutting.dDepthToMachine - BeamData.CUT_SIC
+         Cutting.dRadialOffsetGuillotine = FACEBYBLADE.GetRadialOffsetForGuillotine( Cutting.nToolIndex, EdgeToMachine.dLength)
          if Cutting.dMaxRadialOffset > 10 * GEO.EPS_SMALL then
             -- taglio a ghigliottina
             if bIsTopBlade and ( Cutting.dRadialOffsetGuillotine < Cutting.dMaxRadialOffset - 10 * GEO.EPS_SMALL) then
+
                dDepthToMachine = Cutting.dDepthToMachine + Cutting.dRadialOffsetGuillotine
-               Cutting.sCutType = 'Guillotine'
+               Cutting.sEdgeUsage = 'Guillotine'
+
             -- taglio ridotto
             else
                dDepthToMachine = Cutting.dDepthToMachine + Cutting.dMaxRadialOffset
-               Cutting.sCutType = 'Reduced'
+               Cutting.sEdgeUsage = 'Reduced'
             end
          end
       end
+      
+      -- se cambiata la profondità dDepthToMachine, si ritesta la fattibilità del taglio
+      if Cutting.sEdgeUsage ~= 'Standard' then
+         local EdgeToMachineForEngagement = EdgeToMachine
+         if OppositeToolDirectionMode == 'Enabled' then
+            EdgeToMachineForEngagement = EdgeToMachineOpposite
+         end
+         local BladeEngagementParameters = {
+            Face = FaceToMachine,
+            Edge = EdgeToMachineForEngagement,
+            Part = Part,
+            Tool = TOOLS[Cutting.nToolIndex],
+            dDepthToMachine = dDepthToMachine
+         }
+         local BladeEngagementOptionalParameters = {
+            bIsDicing = bIsDicing,
+            sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
+            bCannotSplitRestLength = bCannotSplitRestLength
+         }
+         TIMER:startElapsed( 'GetBladeEngagement')
+         local bIsApplicable, CurrentEngagement = MachiningLib.GetBladeEngagement( BladeEngagementParameters, BladeEngagementOptionalParameters )
+         TIMER:stopElapsed( 'GetBladeEngagement')
+         
+         -- se non fattibile o cambiano le condizioni BladeEngagement, non si riduce
+         if not ( bIsApplicable and ( CurrentEngagement.sBladeEngagement == Cutting.sBladeEngagement) and ( CurrentEngagement.bMoveAfterSplit == Cutting.bMoveAfterSplit)) then
+            Cutting.sEdgeUsage = 'Standard'
+            dDepthToMachine = Cutting.dDepthToMachine
+         end
+      end
+
+      -- offset radiale (cambia se taglio opposto)
       if OppositeToolDirectionMode == 'Enabled' then
          Cutting.dRadialOffset = -dDepthToMachine
       else
          Cutting.dRadialOffset = EdgeToMachine.dElevation - dDepthToMachine
       end
    end
+
    -- completamento
    Cutting.dCompletionPercentage = ( 1 - Cutting.dResidualDepth / Cutting.dDepthToMachine) * 100
+
    -- step verticale e offset longitudinale
-   Cutting.Steps = MachiningLib.GetMachiningSteps( dPocketHeight, TOOLS[Cutting.nToolIndex].dThickness)
+   Cutting.Steps = MachiningLib.GetMachiningSteps( true, dPocketHeight, TOOLS[Cutting.nToolIndex].dThickness)
    Cutting.Steps.nStepType = MCH_MILL_ST.ONEWAY
    Cutting.dMaxElev = Cutting.Steps.dStep * Cutting.Steps.nCount - 10 * GEO.EPS_SMALL
    if Cutting.bToolInvert then
@@ -443,10 +502,13 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
    else
       Cutting.dLongitudinalOffset = dLongitudinalOffset
    end
+
    -- distanza di sicurezza
    Cutting.dStartSafetyLength = BeamData.CUT_SIC
+
    -- overlap
    Cutting.dOverlap = 0
+
    -- EdgeUse e frame lavorazione
    if OppositeToolDirectionMode == 'Enabled' then
       Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( -Cutting.vtToolDirection)
@@ -457,23 +519,37 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       --Cutting.vtFaceUse = Cutting.vtToolDirection
       Cutting.nEdgesFaceUse = EdgeToMachine.id
    end
+
    -- SCC
-   Cutting.nSCC = GetSCC( Cutting.vtToolDirection, Cutting.vtEdgeDirection, FaceToMachine.vtN)
+   Cutting.nSCC = TOOLS[Cutting.nToolIndex].SetupInfo.GetSCC( Cutting.vtToolDirection, Cutting.vtEdgeDirection, FaceToMachine.vtN)
+
    -- asse bloccato
    Cutting.sBlockedAxis = BeamLib.GetBlockedAxis( Cutting.nToolIndex, 'perpendicular', Part.b3Raw, FaceToMachine.vtN, EgtIf( FaceToMachine.vtN:getX() > 0, X_AX(), -X_AX()))
+
    -- eventuale step orizzontale
    Cutting.CloneStepsRadial = {}
    if not dRadialStepSpan then
       dRadialStepSpan = Cutting.dDepthToMachine
    end
    if dRadialStepSpan > 10 * GEO.EPS_SMALL and TOOLS[Cutting.nToolIndex].dSideStep then
-      Cutting.CloneStepsRadial = MachiningLib.GetMachiningSteps( dRadialStepSpan, TOOLS[Cutting.nToolIndex].dSideStep)
+      Cutting.CloneStepsRadial = MachiningLib.GetMachiningSteps( true, dRadialStepSpan, TOOLS[Cutting.nToolIndex].dSideStep)
    else
       Cutting.CloneStepsRadial.nCount = 1
       Cutting.CloneStepsRadial.dStep = Cutting.dDepthToMachine
    end
+
    -- approccio e retrazione
-   Cutting.LeadIn, Cutting.LeadOut = CalculateLeadInOut( Cutting, EdgeToMachine, bIsSplitFeature)
+   Cutting.LeadIn, Cutting.LeadOut = GetLeadInOut( Cutting, EdgeToMachine, bIsSplitFeature)
+   -- se il calcolo attacchi fallisce, la lavorazione non è fattibile
+   if not Cutting.LeadIn or not Cutting.LeadOut then
+
+      Cutting.bIsApplicable = false
+      return Cutting
+   end
+
+   -- solo per debug
+   --Cutting.nOutRaw = 3
+
    -- lunghezza lavorata
    -- TODO per il calcolo del dLengthOnX si deve correggere con allungamento / accorciamento percorso
    Cutting.dLengthToMachine = EdgeToMachine.dLength + Cutting.LeadIn.dStartAddLength + Cutting.LeadOut.dEndAddLength
@@ -481,6 +557,7 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
    Cutting.dLengthOnX = b3BoxEdge:getDimX()
    Cutting.dTimeToMachine, Cutting.dLengthToMachineAllStepsWithLeadInOut = MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Cutting, Part)
    -- lunghezza impronta lama
+   -- TODO rimpiazzare con LeadInOut.dToolMarkLength
    if Cutting.bIsStartClosed and Cutting.bIsEndClosed then
       Cutting.dToolMarkLength = abs( min( Cutting.LeadIn.dStartAddLength, Cutting.LeadOut.dEndAddLength))
    elseif Cutting.bIsStartClosed then
@@ -499,8 +576,9 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
 
    -- se lavorazione aperta sulla coda, eventuali aggiustamenti
    -- TODO valutare se fare funzione a parte
-   local bIsTruncatingCutOnTail = Proc.Topology and ( Proc.Topology.sName == 'Cut-1-Through' or Proc.Topology.sName == 'TailCut')  and Proc.AffectedFaces.bLeft
-   if bIsTruncatingCutOnTail then
+   Cutting.bMoveAfterSplit = Cutting.bMoveAfterSplit or Cutting.LeadIn.bMoveAfterSplit or Cutting.LeadOut.bMoveAfterSplit
+   local bIsTruncatingCutOnTail = Proc.Topology and ( Proc.Topology.sName == 'Cut-1-Through' or Proc.Topology.sName == 'TailCut') and Proc.AffectedFaces.bLeft
+   if Cutting.bMoveAfterSplit or bIsTruncatingCutOnTail then
       Cutting.sStage = 'AfterTail'
    elseif Proc.AffectedFaces.bLeft and ( EdgeToMachine.sType == 'Bottom' or ( Cutting.vtToolDirection:getX() < 0.707)) then
       local dLengthOnX = Cutting.dLengthOnX
@@ -517,12 +595,14 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       if not AreSameOrOppositeVectorApprox( EdgeToMachine.vtN, Y_AX()) then
          if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
             Cutting.sStage = 'AfterTail'
+            Cutting.bMoveAfterSplit = true
          else
             Cutting.bIsApplicable = false
          end
       elseif dAddLengthLeftSide + dAddLengthToReduce > dExtendAfterTail then
          if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
             Cutting.sStage = 'AfterTail'
+            Cutting.bMoveAfterSplit = true
          else
             if bStartLeft then
                Cutting.LeadIn.dStartAddLength = - dAddLengthToReduce + dExtendAfterTail

StrategyLibs/FACEBYCHAINSAW.lua

@@ -4,7 +4,7 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 
 -- Tabella per definizione modulo
@@ -82,8 +82,8 @@ function FACEBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
    else
       Mortising.vtToolDirection = EdgeToMachine.vtN
    end
-   Mortising.vtEdgeDirection = EdgeToMachine.vtN ^ FaceToMachine.vtN
-   Mortising.ptEdge1, _, Mortising.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -Mortising.vtToolDirection, GDB_ID.ROOT)
+   Mortising.vtEdgeDirection = Vector3d( EdgeToMachine.vtEdge)
+   Mortising.ptEdge1, Mortising.ptEdge2 = EdgeToMachine.ptStart, EdgeToMachine.ptEnd
 
    -- ricerca utensile
    local ToolSearchParameters = {}
@@ -205,7 +205,7 @@ function FACEBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
       dLongitudinalStepSpan = dPocketHeight
    end
    if dLongitudinalStepSpan > 10 * GEO.EPS_SMALL then
-      Mortising.CloneStepsLongitudinal = MachiningLib.GetMachiningSteps( dLongitudinalStepSpan, TOOLS[Mortising.nToolIndex].dThickness)
+      Mortising.CloneStepsLongitudinal = MachiningLib.GetMachiningSteps( true, dLongitudinalStepSpan, TOOLS[Mortising.nToolIndex].dThickness)
    else
       Mortising.CloneStepsLongitudinal.nCount = 1
       Mortising.CloneStepsLongitudinal.dStep = dPocketHeight

StrategyLibs/FACEBYMILL.lua

@@ -4,8 +4,9 @@
 
 -- carico librerie
 local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
+local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
+local PreSimulationLib = require('PreSimulationLib')
 
 -- Tabella per definizione modulo
 local FACEBYMILL = {}
@@ -119,6 +120,10 @@ local function CalculateLeadInOut( Machining, EdgeToMachine, bIsSplitFeature)
       LeadIn.dStartAddLength = BeamData.CUT_EXTRA
       LeadOut.dEndAddLength = BeamData.CUT_EXTRA
    end
+   -- punti dell'attacco
+   LeadIn.ptPoint = EdgeToMachine.ptStart - EdgeToMachine.vtEdge * ( LeadIn.dStartAddLength + LeadIn.dTangentDistance) + EdgeToMachine.vtN * ( EdgeToMachine.dElevation - Machining.dDepthToMachine + LeadIn.dPerpDistance)
+   LeadOut.ptPoint = EdgeToMachine.ptEnd + EdgeToMachine.vtEdge * ( LeadOut.dEndAddLength + LeadOut.dTangentDistance) + EdgeToMachine.vtN * ( EdgeToMachine.dElevation - Machining.dDepthToMachine + LeadOut.dPerpDistance)
+
    -- stima lunghezza reale attacchi per calcolo lunghezza lavorata
    local dEstimatedLeadInPerpDistance = 0
    local dEstimatedLeadInTangentDistance = 0
@@ -203,9 +208,8 @@ function FACEBYMILL.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPara
    else
       Milling.vtToolDirection = EdgeToMachine.vtN
    end
-   Milling.vtEdgeDirection = EdgeToMachine.vtN ^ FaceToMachine.vtN
-   -- TODO conviene spostare questi calcoli nel FaceData?
-   Milling.ptEdge1, _, Milling.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -Milling.vtToolDirection, GDB_ID.ROOT)
+   Milling.vtEdgeDirection = Vector3d( EdgeToMachine.vtEdge)
+   Milling.ptEdge1, Milling.ptEdge2 = EdgeToMachine.ptStart, EdgeToMachine.ptEnd
    
    -- se si conosce il limite downUp (utensile forzato o downUp forzato) si decide se invertire (ToolInvert)
    if nToolIndex and not dMinNzDownUp then
@@ -251,7 +255,7 @@ function FACEBYMILL.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPara
       Milling.sMessage = 'Mill not found'
       Milling.bIsApplicable = false
       EgtOutLog( Milling.sMessage)
-      return Milling, EdgeToMachine.dElevation
+      return Milling
    end
 
    -- verifica dimensioni tasca compatibili
@@ -260,7 +264,7 @@ function FACEBYMILL.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPara
       Milling.sMessage = 'Pocket too narrow for blade thickness'
       Milling.bIsApplicable = false
       EgtOutLog( Milling.sMessage)
-      return Milling, EdgeToMachine.dElevation
+      return Milling
    end
    -- se tasca chiusa da entrambi i lati e più stretta della fresa la lavorazione non è applicabile
    if not ( EdgeToMachine.bIsStartOpen or EdgeToMachine.bIsEndOpen) then
@@ -268,7 +272,7 @@ function FACEBYMILL.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPara
          Milling.sMessage = 'Pocket too narrow for blade diameter'
          Milling.bIsApplicable = false
          EgtOutLog( Milling.sMessage)
-         return Milling, EdgeToMachine.dElevation
+         return Milling
       end
    end
 
@@ -325,13 +329,11 @@ function FACEBYMILL.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPara
    Milling.dCompletionPercentage = ( 1 - Milling.dResidualDepth / Milling.dDepthToMachine) * 100
    -- step verticale e offset longitudinale
    if OptionalParameters.dPocketHeight then
-      Milling.Steps = MachiningLib.GetMachiningSteps( dPocketHeight, TOOLS[Milling.nToolIndex].dMaxMaterial)
+      Milling.Steps = MachiningLib.GetMachiningSteps( true, dPocketHeight, TOOLS[Milling.nToolIndex].dMaxMaterial)
       Milling.Steps.nStepType = OptionalParameters.nStepType or MCH_MILL_ST.ONEWAY
       Milling.dMaxElev = Milling.Steps.dStep * Milling.Steps.nCount - 10 * GEO.EPS_SMALL
    else
-      Milling.Steps = {}
-      Milling.Steps.dStep = TOOLS[Milling.nToolIndex].dStep
-      Milling.Steps.nCount = ceil( ( FaceToMachine.dElevation - 50 * GEO.EPS_SMALL) / Milling.Steps.dStep)
+      Milling.Steps = MachiningLib.GetMachiningSteps( false, FaceToMachine.dElevation, TOOLS[Milling.nToolIndex].dStep)
       Milling.Steps.nStepType = OptionalParameters.nStepType or MCH_MILL_ST.ZIGZAG
       Milling.dMaxElev = FaceToMachine.dElevation
    end
@@ -368,13 +370,24 @@ function FACEBYMILL.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPara
       dRadialStepSpan = Milling.dDepthToMachine
    end
    if dRadialStepSpan > 10 * GEO.EPS_SMALL and TOOLS[Milling.nToolIndex].dSideStep then
-      Milling.CloneStepsRadial = MachiningLib.GetMachiningSteps( dRadialStepSpan, TOOLS[Milling.nToolIndex].dSideStep)
+      Milling.CloneStepsRadial = MachiningLib.GetMachiningSteps( true, dRadialStepSpan, TOOLS[Milling.nToolIndex].dSideStep)
    else
       Milling.CloneStepsRadial.nCount = 1
       Milling.CloneStepsRadial.dStep = 0
    end
    -- approccio e retrazione
    Milling.LeadIn, Milling.LeadOut = CalculateLeadInOut( Milling, EdgeToMachine, bIsSplitFeature)
+   -- check finecorsa nei punti di attacco
+   PointsOnToolTipCenter = {
+      PreSimulationLib.GetPointOnToolTipCenter( Milling.LeadIn.ptPoint, FaceToMachine.vtN, FaceToMachine.vtN, EdgeToMachine.vtN, TOOLS[Milling.nToolIndex]),
+      PreSimulationLib.GetPointOnToolTipCenter( Milling.LeadOut.ptPoint, FaceToMachine.vtN, FaceToMachine.vtN, EdgeToMachine.vtN, TOOLS[Milling.nToolIndex])
+   }
+   local bOutOfStroke = PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, FaceToMachine.vtN, Milling.nSCC, TOOLS[Milling.nToolIndex])
+   if bOutOfStroke then
+      Milling.sMessage = 'Out of stroke'
+      Milling.bIsApplicable = false
+      return Milling
+   end
    -- lunghezza lavorata
    -- TODO per il calcolo del dLengthOnX si deve correggere con allungamento / accorciamento percorso
    Milling.dLengthToMachine = EdgeToMachine.dLength + Milling.LeadIn.dStartAddLength + Milling.LeadOut.dEndAddLength

StrategyLibs/SPLITCUT.lua

@@ -9,6 +9,7 @@ require( 'EgtBase')
 
 -- Carico i dati globali
 local FeatureLib = require( 'FeatureLib')
+local BeamLib = require( 'BeamLib')
 -- strategie di base
 local BladeToWaste = require('BLADETOWASTE')
 
@@ -31,7 +32,13 @@ function SPLITCUT.GetMachining( Proc, Part, ParametersFromStrategy)
    else
       -- Blade
       Machining, Result = BladeToWaste.Make( Proc, Part, ParametersFromStrategy)
-      if Machining and #Machining > 0 then
+      -- se taglio non riuscito, si riprova con il riduci percorso forzato (collisione possibile in separazione pezzi alti)
+      if ( not Machining) or ( #Machining == 0) then
+         local NewParametersFromStrategy = BeamLib.TableCopyDeep( ParametersFromStrategy)
+         NewParametersFromStrategy.bReduceBladePath = true
+         Machining, Result = BladeToWaste.Make( Proc, Part, NewParametersFromStrategy)
+      end
+      if Machining and ( #Machining > 0) then
          Machining.sTypeMachining = 'Blade'
       end
       -- TODO : casi con motosega da completare

Version.lua

@@ -2,5 +2,5 @@
 -- Gestione della versione di Beam
 
 NAME = 'Beam'
-VERSION = '2.6d1'
-MIN_EXE = '2.6g1'
+VERSION = '2.8a1'
+MIN_EXE = '2.7j2'