Merge branch 'master' into develop

3.1d1

.gitlab-ci.yml

@@ -24,14 +24,14 @@ variables:
     $FileList = Get-ChildItem("*.lua")
     ForEach ($File in $FileList) {
       $FileName = Split-Path $File -leaf
-      lua54 -o bin\$FileName $FileName
+      lua54 -o bin\$FileName -s $FileName
-      echo "lua54 -o bin\$FileName $FileName"
+      echo "lua54 -o bin\$FileName -s $FileName"
     }
     $FileList = Get-ChildItem("LuaLibs\*.lua")
     ForEach ($File in $FileList) {
       $FileName = Split-Path $File -leaf
-      lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName
+      lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName
-      echo "lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName"
+      echo "lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName"
     }
 
 # helper copia SORGENTI verso cartella di rete X:\ dei SORGENTI

BatchProcess.lua

@@ -1,4 +1,4 @@
--- BatchProcess.lua by Egaltech s.r.l. 2023/04/17
+-- BatchProcess.lua by Egaltech s.r.l. 2025/07/17
 -- Gestione calcolo batch disposizione e lavorazioni per Pareti
 -- 2020/07/24 Nuvola di punti riferita allo Zero Tavola.
 -- 2020/10/28 Corretto spostamento pezzi per rotazioni (0 o 180) e inversioni( 0, 90, 180, o 270).
@@ -92,13 +92,49 @@ end
 -- Funzione per aggiornare dati ausiliari
 local function UpdateAuxData( sAuxFile)
    local bModif = false
+   local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or GDB_ID.NULL
+   -- Se definito PROJID, aggiorno
+   local sProjId = EgtGetStringFromIni( 'AuxData', 'PROJID', '', sAuxFile)
+   if sProjId ~= '' then
+      EgtSetInfo( BtlInfoId, 'PROJECTNUMBER', sProjId)
+      bModif = true
+   end
+   -- Se definito PRODID, aggiorno
+   local sProdId = EgtGetStringFromIni( 'AuxData', 'PRODID', '', sAuxFile)
+   if sProdId ~= '' then
+      EgtSetInfo( BtlInfoId, 'PRODID', sProdId)
+      bModif = true
+   end
    -- 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
+   -- Se definito REFPOS, aggiorno
+   local sRefPos = EgtGetStringFromIni( 'AuxData', 'REFPOS', '', sAuxFile)
+   if sRefPos ~= '' then
+      EgtSetInfo( BtlInfoId, 'REFPOS', sRefPos)
+      bModif = true
+   end
+   -- Se definito PANELDELTAX, aggiorno
+   local sPanelDeltaX = EgtGetStringFromIni( 'AuxData', 'PANELDELTAX', '', sAuxFile)
+   if sPanelDeltaX ~= '' then
+      EgtSetInfo( BtlInfoId, 'PANELDELTAX', sPanelDeltaX)
+      bModif = true
+   end
+   -- Se definito PANELDELTAY, aggiorno
+   local sPanelDeltaY = EgtGetStringFromIni( 'AuxData', 'PANELDELTAY', '', sAuxFile)
+   if sPanelDeltaY ~= '' then
+      EgtSetInfo( BtlInfoId, 'PANELDELTAY', sPanelDeltaY)
+      bModif = true
+   end
+   -- Se definito PANELDELTAZ, aggiorno
+   local sPanelDeltaZ = EgtGetStringFromIni( 'AuxData', 'PANELDELTAZ', '', sAuxFile)
+   if sPanelDeltaZ ~= '' then
+      EgtSetInfo( BtlInfoId, 'PANELDELTAZ', sPanelDeltaZ)
+      bModif = true
+   end
    return bModif
 end
 
@@ -139,7 +175,6 @@ end
 -- Carico le librerie
 _G.package.loaded.WallExec = nil
 local WE = require( 'WallExec')
---local BL = require( 'BeamLib')
 
 -- Carico i dati globali
 local WD = require( 'WallData')
@@ -233,6 +268,9 @@ if bToProcess then
          end
       else
          dExtraW = 10
+         if WD.DEFAULT_RAW_NO_EXTRA_WIDTH then
+            dExtraW = 0
+         end
          dRawW = dRawW + dExtraW
       end
    end
@@ -277,6 +315,11 @@ if bToProcess then
    -- Ne recupero la posizione
    for i = 1, #vWall do
       local PosX = EgtGetInfo( vWall[i].Id, 'POSX', 'd')
+      local PosZ = EgtGetInfo( vWall[i].Id, 'POSZ', 'd')
+      if bProj and WD.DEFAULT_RAW_NO_EXTRA_WIDTH and #vWall == 1 then
+         PosX = 0
+         PosZ = 0
+      end
       vWall[i].PosX = PosX + min( dExtraL, 1200)
       if WD.USE_POSY then
          local PosY = EgtGetInfo( vWall[i].Id, 'POSY', 'd')
@@ -284,7 +327,6 @@ if bToProcess then
       else
          vWall[i].PosY = 0
       end
-      local PosZ = EgtGetInfo( vWall[i].Id, 'POSZ', 'd')
       vWall[i].PosZ = PosZ + dExtraW / 2
    end
 
@@ -365,6 +407,12 @@ if bToProcess then
       PostErrView( WALL.ERR, WALL.MSG)
       return
    end
+
+   -- se impostato flag apposito, in vista il grezzo è uguale al pezzo
+   if bProj and WD.DEFAULT_RAW_NO_EXTRA_WIDTH and #vWall == 1 then
+      dRawL = vWall[1].Box:getDimX()
+      dRawW = vWall[1].Box:getDimY()
+   end
    
    -- Verifico dimensioni massime grezzo
    if dRawL > WD.MAX_LENGTH + 10 * GEO.EPS_SMALL or dRawW > WD.MAX_WIDTH + 10 * GEO.EPS_SMALL or dRawH > WD.MAX_HEIGHT + 10 * GEO.EPS_SMALL then
@@ -495,10 +543,20 @@ else
    end
    -- Aggiorno eventuali dati ausiliari
    UpdateAuxData( sBtmFile)
+
+   -- Anche se non è da riprocessare, imposto nome file CN.
+   -- Se file TS7 importato da altro PC, 'WALL.FILE' è cambiato da un PC all'altro. Di conseguenza si deve aggiornare nome file che si andrà a generare.
+   local _, sName, _ = EgtSplitPath( WALL.FILE)
+   EgtSetInfo( EgtGetLastMachGroup(), 'NcName', sName .. '.cnc')
+
    -- Passo in modalità lavora
    EgtSetCurrMachGroup( EgtGetLastMachGroup())
+   -- Aggiorno posizione del grezzo
+   if WE.MoveRaw() then
+      bToRecalc = true
+   end
    -- Se necessario eseguo aggiornamento con ricalcolo delle lavorazioni
-   if bToRecalc then
+   if bToRecalc or WALL.FLAG == 3 or WALL.FLAG == 4 then
       EgtOutLog( ' +++ Recalculating all dispositions and machinings >>>')
       EgtImportSetup()
       EgtApplyAllMachinings()
@@ -562,7 +620,8 @@ if  ( WALL.FLAG == 0 and ( bToProcess or bToRecalc)) or WALL.FLAG == 3 or WALL.F
 end
 
 -- *** Genero programma CN *** ( se richiesto)
-if WALL.FLAG == 0 or WALL.FLAG == 4 then
+local bIsGenerationEnabled = ( EgtVerifyKeyOption( 110) == false)
+if bIsGenerationEnabled and ( WALL.FLAG == 0 or WALL.FLAG == 4) then
    EgtOutLog( ' +++ Generating NC part program >>>')
    local sInfo = 'EgtCAM5' .. EgtIf( EgtIs64bit(), ' 64bit', '')
    if EgtGetExeVersion then

BatchProcessNew.lua

@@ -275,11 +275,15 @@ if bToProcess then
             dMinY = ( WD.MINRAWY_HOR_DRILL or 2800)
          end
          -- Assegno dimensioni del pannello
-         dPanelLen = vWall[1].Box:getDimX() + 20
+         local dExtraW = 10
-         dPanelWidth = math.max( vWall[1].Box:getDimY() + 20, dMinY)
+         if WD.DEFAULT_RAW_NO_EXTRA_WIDTH then
+            dExtraW = 0
+         end
+         dPanelLen = vWall[1].Box:getDimX() + 2 * dExtraW
+         dPanelWidth = math.max( vWall[1].Box:getDimY() + 2 * dExtraW, dMinY)
          -- Assegno posizione prima ed unica parete
-         vWall[1].PosX = 10
+         vWall[1].PosX = dExtraW
-         vWall[1].PosZ = 10
+         vWall[1].PosZ = dExtraW
          vWall[1].Rot = 0
          vWall[1].Flip = 0
       end
@@ -545,7 +549,7 @@ else
    -- Passo in modalità lavora
    EgtSetCurrMachGroup( EgtGetLastMachGroup())
    -- Se necessario eseguo aggiornamento con setup corrente e ricalcolo delle lavorazioni
-   if bToRecalc then
+   if bToRecalc or WALL.FLAG == 3 or WALL.FLAG == 4  then
       EgtOutLog( ' +++ Recalculating all dispositions and machinings >>>')
       EgtImportSetup()
       EgtApplyAllMachinings()
@@ -609,7 +613,8 @@ if  ( WALL.FLAG == 0 and ( bToProcess or bToRecalc)) or WALL.FLAG == 3 or WALL.F
 end
 
 -- *** Genero programma CN *** ( se richiesto)
-if WALL.FLAG == 0 or WALL.FLAG == 4 then
+local bIsGenerationEnabled = ( EgtVerifyKeyOption( 110) == false)
+if bIsGenerationEnabled and ( WALL.FLAG == 0 or WALL.FLAG == 4) then
    EgtOutLog( ' +++ Generating NC part program >>>')
    local sInfo = 'EgtCAM5' .. EgtIf( EgtIs64bit(), ' 64bit', '')
    if EgtGetExeVersion then

Compile.bat

@@ -1,30 +1,32 @@
 
-REM Compilazione degli script Wall Egaltech                         2023.09.26
+REM Compilazione degli script Wall Egaltech                         2024.03.24
 REM Per togliere info di debug aggiungere flag -s prima del nome del file di input
 
 REM Compilazione 32 e 64 bit
 
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WallExec.lua                      LuaLibs\WallExec.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\PanelSaw.lua                   -s LuaLibs\PanelSaw.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WallLib.lua                       LuaLibs\WallLib.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\Squaring.lua                   -s LuaLibs\Squaring.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WMachiningLib.lua                 LuaLibs\WMachiningLib.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WallExec.lua                   -s LuaLibs\WallExec.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessCut.lua                   LuaLibs\WProcessCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WallLib.lua                    -s LuaLibs\WallLib.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDoubleCut.lua             LuaLibs\WProcessDoubleCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WMachiningLib.lua              -s LuaLibs\WMachiningLib.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDrill.lua                 LuaLibs\WProcessDrill.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessCut.lua                -s LuaLibs\WProcessCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDtMortise.lua             LuaLibs\WProcessDtMortise.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDoubleCut.lua          -s LuaLibs\WProcessDoubleCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WFeatureTopology.lua              LuaLibs\WFeatureTopology.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDrill.lua              -s LuaLibs\WProcessDrill.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessFreeContour.lua           LuaLibs\WProcessFreeContour.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDtMortise.lua          -s LuaLibs\WProcessDtMortise.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessLapJoint.lua              LuaLibs\WProcessLapJoint.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WFeatureTopology.lua           -s LuaLibs\WFeatureTopology.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessMark.lua                  LuaLibs\WProcessMark.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessFreeContour.lua        -s LuaLibs\WProcessFreeContour.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessMortise.lua               LuaLibs\WProcessMortise.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessLapJoint.lua           -s LuaLibs\WProcessLapJoint.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessSawCut.lua                LuaLibs\WProcessSawCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessMark.lua               -s LuaLibs\WProcessMark.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessText.lua                  LuaLibs\WProcessText.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessMortise.lua            -s LuaLibs\WProcessMortise.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessVariant.lua               LuaLibs\WProcessVariant.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessSawCut.lua             -s LuaLibs\WProcessSawCut.lua
-\EgtProg\Dll32\luac54 -o bin\BatchProcess.lua                          BatchProcess.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessText.lua               -s LuaLibs\WProcessText.lua
-\EgtProg\Dll32\luac54 -o bin\BatchProcessNew.lua                       BatchProcessNew.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessVariant.lua            -s LuaLibs\WProcessVariant.lua
-\EgtProg\Dll32\luac54 -o bin\GetWallData.lua                           GetWallData.lua
+\EgtProg\Dll32\luac54 -o bin\BatchProcess.lua                       -s BatchProcess.lua
-\EgtProg\Dll32\luac54 -o bin\NestFlipAndRotate.lua                     NestFlipAndRotate.lua
+\EgtProg\Dll32\luac54 -o bin\BatchProcessNew.lua                    -s BatchProcessNew.lua
-\EgtProg\Dll32\luac54 -o bin\NestProcess.lua                           NestProcess.lua
+\EgtProg\Dll32\luac54 -o bin\GetWallData.lua                        -s GetWallData.lua
-\EgtProg\Dll32\luac54 -o bin\Overturn.lua                              Overturn.lua
+\EgtProg\Dll32\luac54 -o bin\NestFlipAndRotate.lua                  -s NestFlipAndRotate.lua
-\EgtProg\Dll32\luac54 -o bin\Process.lua                               Process.lua
+\EgtProg\Dll32\luac54 -o bin\NestProcess.lua                        -s NestProcess.lua
-\EgtProg\Dll32\luac54 -o bin\Rotate.lua                                Rotate.lua
+\EgtProg\Dll32\luac54 -o bin\Overturn.lua                           -s Overturn.lua
-\EgtProg\Dll32\luac54 -o bin\Version.lua                               Version.lua
+\EgtProg\Dll32\luac54 -o bin\Process.lua                            -s Process.lua
+\EgtProg\Dll32\luac54 -o bin\Rotate.lua                             -s Rotate.lua
+\EgtProg\Dll32\luac54 -o bin\Version.lua                            -s Version.lua

LuaLibs/PanelSaw.lua

@@ -0,0 +1,438 @@
+-- PanelSaw.lua by Egalware s.r.l. 2025/09/02
+-- Creazione lista taglio e/o programmi di taglio per sezionatrici
+
+-- Intestazioni
+require( 'EgtBase')
+
+-- Dati
+local WL = require ( 'WallLib')
+
+local PanelSaw = {}
+
+
+local function GetPanelList()
+
+   local PanelList = {}
+   local idMachGroup = EgtGetFirstMachGroup()
+   local nMachGroupCount = EgtGetMachGroupCount()
+
+   -- nessun MachGroup ossia nessun pannello: si esce subito
+   if ( not idMachGroup) or ( nMachGroupCount == 0) then
+      return nil
+   end
+
+   -- per ogni MachGroup si estraggono le informazioni del pannello
+   for i = 1, nMachGroupCount do
+
+      local vPartInfo = EgtSplitString( EgtGetInfo( idMachGroup, 'PART1', 's'))
+      local idPart = vPartInfo[1]
+
+      table.insert( PanelList, {})
+      PanelList[i].dLength = EgtGetInfo( idMachGroup, 'PANELLEN', 'd')
+      PanelList[i].dWidth = EgtGetInfo( idMachGroup, 'PANELWIDTH', 'd')
+      PanelList[i].dThickness = EgtGetInfo( idMachGroup, 'PANELHEIGHT', 'd')
+      PanelList[i].sMaterialFullName = EgtGetInfo( idMachGroup, 'MATERIAL', 's') or '0000-MATERIAL'
+      PanelList[i].sMaterialPlusThickness = PanelList[i].sMaterialFullName .. '_' .. tostring( string.format( '%.1f', PanelList[i].dThickness))
+      local vMaterialInfo = EgtSplitString( PanelList[i].sMaterialFullName, '-')
+      PanelList[i].idMaterial = vMaterialInfo[1]
+      PanelList[i].idProd = EgtGetInfo( idMachGroup, 'PRODID', 'i')
+      PanelList[i].idPatt = EgtGetInfo( idMachGroup, 'PATTID', 'i')
+      PanelList[i].nPdn = EgtGetInfo( idPart, 'PDN', 'i')
+      PanelList[i].sName = EgtGetInfo( idPart, 'NAM', 's')
+      PanelList[i].sDescription = PanelList[i].sName
+      local sGrainInfo = EgtGetInfo( idPart, "GRAINDIRECTION", 's')
+      PanelList[i].sGrainDirection = 'None'
+      if sGrainInfo then
+         local bUseGrain = ( string.sub( sGrainInfo, 7) == '1')
+         local sGrainDirection = string.sub( sGrainInfo, 1, 5)
+         if bUseGrain then
+            if sGrainDirection == "1,0,0" then
+               PanelList[i].sGrainDirection = 'Length'
+            elseif sGrainDirection == "0,1,0" then
+               PanelList[i].sGrainDirection = 'Width'
+            end
+         end
+      end
+      -- in questa modalità ogni MachGroup è 1 pezzo, non esistono multipli
+      -- TODO valutare se raggruppare i pannelli uguali per la cutting list
+      PanelList[i].nQuantity = 1
+      -- TODO le informazioni di edgebanding devono arrivare dal btl
+      PanelList[i].sEdgeMaterialLeft = ''
+      PanelList[i].sEdgeMaterialRight = ''
+      PanelList[i].sEdgeMaterialTop = ''
+      PanelList[i].sEdgeMaterialBottom = ''
+      -- TODO il barcode deve arrivare dal btl
+      PanelList[i].sBarcode = ''
+
+      idMachGroup = EgtGetNextMachGroup( idMachGroup)
+   end
+
+   return PanelList
+end
+
+
+local function GetSheetList()
+
+   local SheetList = {
+      {
+         dLength = 2800,
+         dWidth = 2070,
+         dThickness = 8,
+      },
+      {
+         dLength = 2800,
+         dWidth = 2070,
+         dThickness = 18,
+      }
+   }
+
+   return SheetList
+end
+
+
+local function GetProjectInfo()
+
+   local ProjectInfo = {}
+   local idBtlInfo = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or GDB_ID.NULL
+
+   _, ProjectInfo.sProjectName = EgtSplitPath( EgtGetInfo( idBtlInfo, 'PROJECTNAME', 's') or '')
+
+   return ProjectInfo
+end
+
+
+local function BuildCuttingList_Cutty( PanelList, SheetList, ProjectInfo)
+
+   -- se il numero di pezzi supera il limite, si devono creare più liste
+   local nMaxPanelsCount = 30
+   local SplittedPanelList = WL.SplitTableInChunks( PanelList, nMaxPanelsCount)
+   local LinesToWriteList = {}
+
+   for nCurrentPanelList = 1, #SplittedPanelList do
+      local Lines = {}
+      local CurrentPanelList = SplittedPanelList[nCurrentPanelList]
+      LinesToWriteList[nCurrentPanelList] = {}
+
+      local F0 = {
+         Header = { 'F0'},
+         HeaderPlaceholders = { '%-53s'},
+         Values = { ' 7.70', '210700', '150300'},
+         ValuesPlaceholders = { '%s', '%s', '%s'}
+      }
+
+      local F0b = {
+         Header = { 'F0b', '""', '""', '""', '""'},
+         HeaderPlaceholders = { '%s', '%s', '%s', '%s', '%s'}
+      }
+
+      local F1 = {
+         Header = { 'F1', CurrentPanelList[1].dThickness, 0, 0, 0, ''},
+         HeaderPlaceholders = { '%s', '%.3f', '%.3f', '%.3f', '%.3f', '%-20s'},
+         ValuesList = {},
+         ValuesPlaceholders = { '%.3f', '%.3f', '%d', '%d', '%d', '%-29d', '%-50s', '%d', '%.3f', '%d', '%d', '%d', '%d'},
+      }
+      for i = 1, #SheetList do
+         F1.ValuesList[i] = { SheetList[i].dLength, SheetList[i].dWidth, 99, 200, 1, 1, CurrentPanelList[1].sMaterialFullName, 0, 1, 0, 0, 0, 0}
+      end
+
+      local F2 = {
+         Header = { 'F2', 0, 0, 0},
+         HeaderPlaceholders = { '%s', '%d', '%d', '%d'},
+         ValuesList = {},
+         ValuesPlaceholders = { '%.3f', '%.3f', '%d', '%d', '%d', '%d', '%d', '%-20s', '%d', '%d', '%d', '%d', '%-50s', '%d', '%d', '%d', '%d', '%d', '%d', '%.3f', '%d', '%d', '%-85d', '%.3f', '%.3f'},
+      }
+      for i = 1, #CurrentPanelList do
+         local nGrain = 0
+         if PanelList[i].sGrainDirection == 'Length' then
+            nGrain = 1
+         elseif PanelList[i].sGrainDirection == 'Width' then
+            nGrain = 1
+            CurrentPanelList[i].dLength, CurrentPanelList[i].dWidth = CurrentPanelList[i].dWidth, CurrentPanelList[i].dLength
+         end
+         F2.ValuesList[i] = { CurrentPanelList[i].dLength, CurrentPanelList[i].dWidth, CurrentPanelList[i].nQuantity, 0, nGrain, 0, 0, CurrentPanelList[i].nPdn, 0, 0, 0, 0, CurrentPanelList[i].sDescription, 0, 0, 0, 0, 1, 0, 1500, 0, 0, 0, 0, 0}
+      end
+
+      local F7 = {
+         Header = { 'F7', 3052, 0},
+         HeaderPlaceholders = { '%s', '%s', '%d'},
+         ValuesList = {
+            { 218, 436},
+            { 167, 669},
+            { 204, 408},
+            { 204, 204},
+            { 204, 204},
+            { 209, 209},
+            { 167, 167},
+            { 213, 213},
+            { 229, 229},
+            { 164, 164},
+            { 150, 150}
+         },
+         ValuesPlaceholders = {
+            { '%s', '%s'},
+            { '%s', '%s'},
+            { '%s', '%s'},
+            { '%s', '%s'},
+            { '%s', '%s'},
+            { '%s', '%s'},
+            { '%s', '%s'},
+            { '%s', '%s'},
+            { '%s', '%s'},
+            { '%s', '%s'},
+            { '%s', '%s'}
+         }
+      }
+
+      local F7b = {
+         Header = { 'F7b', 0, 0, 0, 0},
+         HeaderPlaceholders = { '%s', '%.3f', '%.3f', '%.3f', '%.3f'},
+         Values = {},
+         ValuesPlaceholders = {}
+      }
+
+      local F8 = {
+         Header = { 'F8', 0, 0, 20, 20, 0, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+         HeaderPlaceholders = { '%s', '%.3f', '%.3f', '%d', '%d', '%d', '%d', '%.3f', '%d', '%d', '%d', '%d', '%d', '%d', '%.3f', '%d', '%d', '%d', '%d', '%d', '%d', '%.3f', '%.3f', '%.3f'}
+      }
+
+      local F9 = {
+         Header = { 'F9', 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 4.3, 0, 0, 0, 2, 0, 2450, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+         HeaderPlaceholders = { '%s', '%d', '%.3f', '%d', '%.3f', '%.3f', '%.3f', '%.3f', '%.3f', '%d', '%d', '%.3f', '%d', '%d', '%d', '%d', '%.3f', '%.3f', '%d', '%d', '%.3f', '%.3f', '%.3f', '%.3f', '%d', '%d', '%.3f', '%.3f'}
+      }
+
+      local F3 = {
+         Header = { 'F3'},
+         HeaderPlaceholders = { '%s'}
+      }
+
+      local E0 = {
+         Header = { 'E0'},
+         HeaderPlaceholders = { '%s'}
+      }
+
+      -- F0
+      table.insert( Lines, string.format( table.concat( F0.HeaderPlaceholders, ' '), table.unpack( F0.Header)))
+      table.insert( Lines, string.format( table.concat( F0.ValuesPlaceholders, ' '), table.unpack( F0.Values)))
+
+      -- linea vuota
+      table.insert( Lines, '')
+
+      -- F0b
+      table.insert( Lines, string.format( table.concat( F0b.HeaderPlaceholders, ' '), table.unpack( F0b.Header)))
+
+      -- linea vuota
+      table.insert( Lines, '')
+
+      -- F1 - sheets
+      table.insert( Lines, string.format( table.concat( F1.HeaderPlaceholders, ' '), table.unpack( F1.Header)))
+      for i = 1, #F1.ValuesList do
+         local Values = F1.ValuesList[i]
+         local Placeholders = F1.ValuesPlaceholders
+         table.insert( Lines, string.format( table.concat( Placeholders, ' '), table.unpack( Values)))
+      end
+
+      -- linea vuota
+      table.insert( Lines, '')
+
+      -- F2 - panels
+      table.insert( Lines, string.format( table.concat( F2.HeaderPlaceholders, ' '), table.unpack( F2.Header)))
+      for i = 1, #F2.ValuesList do
+         local Values = F2.ValuesList[i]
+         local Placeholders = F2.ValuesPlaceholders
+         table.insert( Lines, string.format( table.concat( Placeholders, ' '), table.unpack( Values)))
+      end
+
+      -- linea vuota
+      table.insert( Lines, '')
+
+      -- F7
+      table.insert( Lines, string.format( table.concat( F7.HeaderPlaceholders, ' '), table.unpack( F7.Header)))
+      for i = 1, #F7.ValuesList do
+         local Values = F7.ValuesList[i]
+         local Placeholders = F7.ValuesPlaceholders[i]
+         table.insert( Lines, string.format( table.concat( Placeholders, ' '), table.unpack( Values)))
+      end
+
+      -- linea vuota
+      table.insert( Lines, '')
+
+      -- F7b
+      table.insert( Lines, string.format( table.concat( F7b.HeaderPlaceholders, ' '), table.unpack( F7b.Header)))
+
+      -- linea vuota
+      table.insert( Lines, '')
+
+      -- F8
+      table.insert( Lines, string.format( table.concat( F8.HeaderPlaceholders, ' '), table.unpack( F8.Header)))
+
+      -- linea vuota
+      table.insert( Lines, '')
+
+      -- F9
+      table.insert( Lines, string.format( table.concat( F9.HeaderPlaceholders, ' '), table.unpack( F9.Header)))
+
+      -- linea vuota
+      table.insert( Lines, '')
+
+      -- F3
+      table.insert ( Lines, string.format( table.concat( F3.HeaderPlaceholders, ' '), table.unpack( F3.Header)))
+
+      -- E0
+      table.insert( Lines, string.format( table.concat( E0.HeaderPlaceholders, ' '), table.unpack( E0.Header)))
+
+      -- linea vuota
+      table.insert( Lines, '')
+
+      LinesToWriteList[nCurrentPanelList] = Lines
+   end
+
+
+   return LinesToWriteList
+end
+
+
+local function BuildCuttingList_Homag( PanelList, ActualSheetList, ProjectInfo)
+
+   local LinesToWriteList = {}
+   local sExtension = 'csv'
+   local Lines = {}
+
+   local Header = {
+      Values = { 'Description', 'Quantity', 'Length', 'Width', 'Material', 'Grain', 'EdgeLeft', 'EdgeRight', 'EdgeTop', 'EdgeBottom', 'OrderNumber', 'BarCode'},
+      ValuesPlaceholders = { '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s'}
+   }
+
+   local Panels = {
+      ValuesList = {},
+      ValuesPlaceholders = { '%s', '%d', '%.1f', '%.1f', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s' }
+   }
+   for i = 1, #PanelList do
+      local sGrain = PanelList[i].sGrainDirection
+      -- TODO questo dipenderà dalla lingua dell'esportazione; andrà fatto un tipo di esportazione specifica per ogni lingua (es: HOMAG_NL, HOMAG_ENG, ...)
+      if sGrain == 'None' then
+         sGrain = 'Geen'
+      elseif sGrain == 'Length' then
+         sGrain = 'Lengte'
+      elseif sGrain == 'Width' then
+         sGrain = 'Breedte'
+      end
+      Panels.ValuesList[i] = { PanelList[i].sDescription, PanelList[i].nQuantity, PanelList[i].dLength, PanelList[i].dWidth, PanelList[i].sMaterialPlusThickness, sGrain, PanelList[i].sEdgeMaterialLeft, PanelList[i].sEdgeMaterialRight, PanelList[i].sEdgeMaterialTop, PanelList[i].sEdgeMaterialBottom, ProjectInfo.sProjectName, PanelList[i].sBarcode}
+   end
+
+   -- Intestazione
+   table.insert( Lines, string.format( table.concat( Header.ValuesPlaceholders, ','), table.unpack( Header.Values)))
+
+   -- Lista Pannelli
+   for i = 1, #Panels.ValuesList do
+      local Values = Panels.ValuesList[i]
+      local Placeholders = Panels.ValuesPlaceholders
+      table.insert( Lines, string.format( table.concat( Placeholders, ','), table.unpack( Values)))
+   end
+   
+   LinesToWriteList[1] = Lines
+   
+   return LinesToWriteList, sExtension
+end
+
+
+local function BuildCuttingList( PanelList, sOutputType)
+
+   local LinesToWriteList = {}
+   local sExtension = ''
+   local SheetList = GetSheetList()
+   local ProjectInfo = GetProjectInfo()
+   local dRequiredThickness = PanelList[1].dThickness
+
+   -- solo gli sheets dello spessore corretto vanno considerati
+   local ActualSheetList = {}
+   for i = 1, #SheetList do
+      if abs( SheetList[i].dThickness - dRequiredThickness) < 10 * GEO.EPS_SMALL then
+         ActualSheetList[#ActualSheetList+1] = {
+            dLength = SheetList[i].dLength,
+            dWidth = SheetList[i].dWidth,
+            dThickness = SheetList[i].dThickness,
+            sMaterial =  SheetList[i].sMaterial
+         }
+      end
+   end
+
+   -- Casadei
+   if sOutputType == 'CUTTY' then
+
+      LinesToWriteList = BuildCuttingList_Cutty( PanelList, ActualSheetList, ProjectInfo)
+      
+   -- Homag
+   elseif sOutputType == 'HOMAG' then
+
+      LinesToWriteList, sExtension = BuildCuttingList_Homag( PanelList, ActualSheetList, ProjectInfo)
+
+   end
+
+   return LinesToWriteList, sExtension
+end
+
+
+-- restituisce i pannelli raggruppati per coppia materiale-spessore univoca
+local function GroupByMaterial( PanelList)
+   local PanelsGroupedByMaterial = {}
+
+   for i = 1, #PanelList do
+      local idMaterial = PanelList[i].idMaterial
+      local dMaterialThickness = PanelList[i].dThickness
+
+      -- si crea una chiave unica dalla coppia
+      local key = idMaterial .. "_" .. tostring( dMaterialThickness)
+
+      -- se la chiave non esiste già nella tabella, si crea
+      if not PanelsGroupedByMaterial[key] then
+         PanelsGroupedByMaterial[key] = {}
+      end
+
+      -- aggiunta del pezzo corrente al gruppo chiave corrispondente
+      table.insert( PanelsGroupedByMaterial[key], PanelList[i])
+   end
+
+   return PanelsGroupedByMaterial
+end
+
+
+function PanelSaw.GenerateCuttingList( sOutputType)
+
+   local PanelList = GetPanelList()
+   local PanelsGroupedByMaterial = GroupByMaterial( PanelList)
+
+   for key, PanelListSingleMaterial in pairs( PanelsGroupedByMaterial) do
+
+      -- path in cui scrivere i file
+      local sCurrentNgePath, sCurrentNgeName = EgtSplitPath( EgtGetCurrFilePath())
+
+      if sOutputType then
+         -- costruzione lista istruzioni
+         local LinesToWriteList, sExtension = BuildCuttingList( PanelListSingleMaterial, sOutputType)
+         
+         for i = 1, #LinesToWriteList do
+            -- scrittura file
+            local sFilename = sCurrentNgePath .. 'CutList-' .. sCurrentNgeName .. '-' .. key .. '-' .. i .. sOutputType
+            sFilename = sFilename:gsub( '%.', '_')
+            -- aggiunta eventuale estensione
+            sFilename = sFilename .. '.' .. sExtension
+            local hFile, nFileErr = io.open( sFilename, 'w')
+            if not hFile then
+               EgtOutLog( 'Error creating cutting list : IO error ' .. tostring( nFileErr))
+               return false
+            end
+            hFile:write( table.concat( LinesToWriteList[i], "\n"))
+            hFile:close()
+         end
+
+      -- se nessun tipo si deve scrivere un json semplice
+      else
+
+      end
+   end
+
+   return
+end
+
+
+return PanelSaw

LuaLibs/Squaring.lua

@@ -0,0 +1,494 @@
+-- Squaring.lua by Egaltech s.r.l. 2024/10/15
+-- Libreria squadratura pareti
+
+-- Tabella per definizione modulo
+local Squaring = {}
+
+-- Include
+require( 'EgtBase')
+
+EgtOutLog( ' Squaring started', 1)
+
+-- Dati
+local WD = require( 'WallData')
+local WM = require( 'WMachiningLib')
+
+-------------------------------------------------------------------------------------------------------------
+local function IsToolOk( Tool, dRawPartHeight)
+   local bIsToolOk = false
+   local bToolExists = false
+   local bToolCanReachDepth = false
+   local dMaxOvermaterial = 0
+   if type( WD.SQUARING_MAX_OVERMATERIAL) == "number" then
+      dMaxOvermaterial = WD.SQUARING_MAX_OVERMATERIAL
+   end
+
+   bToolExists = ( next( Tool) ~= nil)
+   if bToolExists then
+      if Tool.nType == MCH_TY.MILL_NOTIP then
+         bToolCanReachDepth = ( Tool.dThickness > dMaxOvermaterial - 10 * GEO.EPS_SMALL)
+                          and ( Tool.dSideDepth > dRawPartHeight - 10 * GEO.EPS_SMALL)
+      else
+         bToolCanReachDepth = Tool.dMaxDepth > dRawPartHeight - 10 * GEO.EPS_SMALL
+      end
+   end
+   bIsToolOk = bToolExists and bToolCanReachDepth
+
+   return bIsToolOk
+end
+
+-------------------------------------------------------------------------------------------------------------
+function Squaring.GetTools()
+   -- TODO vedere se questo valore è coerente sulle diverse macchine
+   local dHeadEncumberance = 130
+
+   local Tool = {}
+   local SquaringTools = {}
+   SquaringTools.Blade = {}
+   SquaringTools.Diskmill = {}
+   SquaringTools.Mill = {}
+   SquaringTools.Blade.H1 = {}
+   SquaringTools.Blade.H2 = {}
+   SquaringTools.Blade.H7 = {}
+   SquaringTools.Diskmill.H1 = {}
+   SquaringTools.Diskmill.H7 = {}
+   SquaringTools.Mill.H1 = {}
+   SquaringTools.Mill.H7 = {}
+
+   Tool.sName = EgtTdbGetFirstTool( MCH_TF.SAWBLADE + MCH_TF.MILL + MCH_TF.MORTISE)
+   while Tool.sName ~= '' do
+      EgtTdbSetCurrTool( Tool.sName)
+      local bIsToolLoadedOnSetup = EgtFindToolInCurrSetup( Tool.sName)
+      local bIsSquaringTool = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SQUARING', 'b') or false
+      
+      Tool.nType = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
+      Tool.dDiameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
+      Tool.dMaxMaterial = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
+      Tool.dThickness = EgtIf( ( Tool.nType == MCH_TY.SAW_FLAT or Tool.nType == MCH_TY.SAW_STD), EgtTdbGetCurrToolParam( MCH_TP.THICK), Tool.dMaxMaterial)
+      Tool.dMaxDepth = EgtTdbGetCurrToolMaxDepth() or Tool.dMaxMaterial
+      Tool.sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+      Tool.bIsCcw = EgtTdbGetCurrToolParam( MCH_TP.SPEED) < 0
+      Tool.dFeed = EgtTdbGetCurrToolParam( MCH_TP.FEED)
+      Tool.dStartFeed = EgtTdbGetCurrToolParam( MCH_TP.STARTFEED)
+      Tool.dEndFeed = EgtTdbGetCurrToolParam( MCH_TP.ENDFEED)
+      Tool.dTipFeed = EgtTdbGetCurrToolParam( MCH_TP.TIPFEED)
+      Tool.dMinFeed = EgtTdbGetCurrToolParam( MCH_TP.MINFEED)
+      Tool.dStep = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'STEP', 'd') or EgtIf( ( Tool.nType == MCH_TY.SAW_FLAT or Tool.nType == MCH_TY.SAW_STD), ( Tool.dDiameter / 3), ( Tool.dMaxMaterial / 3))
+      Tool.dSideStep = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDESTEP', 'd') or ( Tool.dDiameter / 3)
+      Tool.dSideDepth = Tool.dDiameter / 2 - dHeadEncumberance
+
+      if bIsToolLoadedOnSetup and Tool.nType and bIsSquaringTool then
+         -- lame
+         if Tool.nType == MCH_TY.SAW_FLAT or Tool.nType == MCH_TY.SAW_STD then
+            SquaringTools.Blade[Tool.sHead] = Tool
+            Tool.bIsPathCw = Tool.bIsCcw
+            Tool.dSideStep = Tool.dStep
+            Tool.dStep = Tool.dThickness
+         -- frese standard
+         elseif Tool.nType == MCH_TY.MILL_STD then
+            SquaringTools.Mill[Tool.sHead] = Tool
+            Tool.bIsPathCw = not Tool.bIsCcw
+         -- truciolatori
+         elseif Tool.nType == MCH_TY.MILL_NOTIP then
+            SquaringTools.Diskmill[Tool.sHead] = Tool
+            Tool.bIsPathCw = Tool.bIsCcw
+         end
+      end
+
+      Tool = {}
+      Tool.sName = EgtTdbGetNextTool( MCH_TF.SAWBLADE + MCH_TF.MILL + MCH_TF.MORTISE)
+   end
+
+   return SquaringTools
+end
+
+-------------------------------------------------------------------------------------------------------------
+function Squaring.AreToolsOk( sSquaringTool, SquaringTools, dRawPartHeight)
+   local bAreToolsOk = false
+
+   if sSquaringTool == 'DoubleDiskmill' then
+      bAreToolsOk = ( IsToolOk( SquaringTools.Blade.H2, dRawPartHeight)
+                      and IsToolOk( SquaringTools.Diskmill.H1, dRawPartHeight)
+                      and IsToolOk( SquaringTools.Diskmill.H7, dRawPartHeight))
+   elseif sSquaringTool == 'DoubleDiskmillAndBlade' then
+      bAreToolsOk = ( IsToolOk( SquaringTools.Blade.H2, dRawPartHeight)
+                      and ( IsToolOk( SquaringTools.Diskmill.H1, dRawPartHeight) or IsToolOk( SquaringTools.Diskmill.H7, dRawPartHeight)))
+   elseif sSquaringTool == 'DoubleBlade' then
+      bAreToolsOk = ( IsToolOk( SquaringTools.Blade.H2, dRawPartHeight)
+                      and ( IsToolOk( SquaringTools.Blade.H1, dRawPartHeight) or IsToolOk( SquaringTools.Blade.H7, dRawPartHeight)))
+   elseif sSquaringTool == 'Diskmill' then
+      bAreToolsOk = IsToolOk( SquaringTools.Diskmill.H1, dRawPartHeight) or IsToolOk( SquaringTools.Diskmill.H7, dRawPartHeight)
+   elseif sSquaringTool == 'Blade' then
+      bAreToolsOk = IsToolOk( SquaringTools.Blade.H2, dRawPartHeight)
+   elseif sSquaringTool == 'DoubleMill' then
+      bAreToolsOk = IsToolOk( SquaringTools.Mill.H1, dRawPartHeight) and IsToolOk( SquaringTools.Mill.H7, dRawPartHeight)
+   elseif sSquaringTool == 'Mill' then
+      bAreToolsOk = IsToolOk( SquaringTools.Mill.H1, dRawPartHeight) or IsToolOk( SquaringTools.Mill.H7, dRawPartHeight)
+   else
+      error( 'Squaring Tool not recognized')
+   end
+
+   return bAreToolsOk
+end
+
+-------------------------------------------------------------------------------------------------------------
+function Squaring.CalculateParameters( sSquaringTool, SquaringTools, RawPart, vPart)
+   local SquaringParameters = {}
+   local sOrigCorner = EgtGetInfo( RawPart.nId, 'ORIGCORNER')
+   local bShrinkToParts = ( WD.SQUARING_TYPE == 2)
+   local bSquaringStartsOnReference = ( type( WD.SQUARING_STARTS_ON_REFERENCE) == "boolean") and ( WD.SQUARING_STARTS_ON_REFERENCE == true)
+   local dOffsetXY = 0
+   local dExtendZ = 0
+   if type( WD.SQUARING_OFFSET_XY) == "number" and ( WD.SQUARING_TYPE < 2) then
+      dOffsetXY = WD.SQUARING_OFFSET_XY
+   end
+   if type( WD.SQUARING_EXTEND_Z) == "number" then
+      dExtendZ = WD.SQUARING_EXTEND_Z
+   end
+
+   local Front = { sSide = 'Front'}
+   local Right = { sSide = 'Right'}
+   local Back = { sSide = 'Back'}
+   local Left = { sSide = 'Left'}
+   local b3Squaring = BBox3d( RawPart.b3)
+   -- se squadratura sui pezzi invece che sul master panel, si costruisce il box minimo che contiene tutti i pezzi
+   if bShrinkToParts then
+      b3Squaring = BBox3d( vPart[1].Box:getCenter())
+      for i = 1, #vPart do
+         b3Squaring:Add( vPart[i].Box)
+      end
+   end
+   local dDimX = b3Squaring:getDimX()
+   local dDimY = b3Squaring:getDimY()
+   local pt1 = b3Squaring:getMin() + Point3d( -dOffsetXY, -dOffsetXY, -dExtendZ)
+   local pt2 = pt1 + Point3d( dDimX + 2 * dOffsetXY, 0, 0)
+   local pt3 = pt2 + Point3d( 0, dDimY + 2 * dOffsetXY,0 )
+   local pt4 = pt3 + Point3d( -dDimX - 2 * dOffsetXY, 0, 0)
+   b3Squaring:Add( pt1)
+   b3Squaring:Add( pt2)
+   b3Squaring:Add( pt3)
+   b3Squaring:Add( pt4)
+   Front.nId = EgtLine( RawPart.nId, pt1, pt2, GDB_RT.GLOB)
+   Right.nId = EgtLine( RawPart.nId, pt2, pt3, GDB_RT.GLOB)
+   Back.nId = EgtLine( RawPart.nId, pt3, pt4, GDB_RT.GLOB)
+   Left.nId = EgtLine( RawPart.nId, pt4, pt1, GDB_RT.GLOB)
+   if not ( sSquaringTool == 'DoubleMill') and not ( sSquaringTool == 'Mill') then
+      EgtModifyCurveExtrusion( Front.nId, -Y_AX(), GDB_RT.GLOB)
+      EgtModifyCurveExtrusion( Right.nId, X_AX(), GDB_RT.GLOB)
+      EgtModifyCurveExtrusion( Back.nId, Y_AX(), GDB_RT.GLOB)
+      EgtModifyCurveExtrusion( Left.nId, -X_AX(), GDB_RT.GLOB)
+   end
+   EgtSetName( Front.nId, 'SquaringGeometry')
+   EgtSetName( Right.nId, 'SquaringGeometry')
+   EgtSetName( Back.nId, 'SquaringGeometry')
+   EgtSetName( Left.nId, 'SquaringGeometry')
+
+   -- in base al caso si assegna l'utensile al lato
+   if sSquaringTool == 'DoubleDiskmill' then
+      Left.Tool = SquaringTools.Diskmill.H1
+      Right.Tool = SquaringTools.Blade.H2
+      Front.Tool = SquaringTools.Diskmill.H1
+      Front.ToolDouble = SquaringTools.Diskmill.H7
+      Front.sSide = 'Front+Back'
+   elseif sSquaringTool == 'DoubleDiskmillAndBlade' then
+      Left.Tool = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
+      Right.Tool = SquaringTools.Blade.H2
+      Front.Tool = SquaringTools.Blade.H2
+      Front.ToolDouble = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
+      Front.sSide = 'Front+Back'
+   elseif sSquaringTool == 'DoubleBlade' then
+      Left.Tool = SquaringTools.Blade.H2
+      Right.Tool = SquaringTools.Blade.H2
+      Front.Tool = SquaringTools.Blade.H2
+      Front.ToolDouble = SquaringTools.Blade.H1 or SquaringTools.Blade.H7
+      Front.sSide = 'Front+Back'
+   elseif sSquaringTool == 'Diskmill' then
+      Left.Tool = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
+      Back.Tool = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
+      Right.Tool = SquaringTools.Blade.H2
+      Front.Tool = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
+   elseif sSquaringTool == 'Blade' then
+      Left.Tool = SquaringTools.Blade.H2
+      Back.Tool = SquaringTools.Blade.H2
+      Right.Tool = SquaringTools.Blade.H2
+      Front.Tool = SquaringTools.Blade.H2
+   elseif sSquaringTool == 'DoubleMill' then
+      Left.Tool = SquaringTools.Mill.H1
+      Right.Tool = SquaringTools.Mill.H1
+      Front.Tool = SquaringTools.Mill.H1
+      Front.ToolDouble = SquaringTools.Mill.H7
+      Front.sSide = 'Front+Back'
+   elseif sSquaringTool == 'Mill' then
+      Left.Tool = SquaringTools.Mill.H1 or SquaringTools.Mill.H7
+      Back.Tool = SquaringTools.Mill.H1 or SquaringTools.Mill.H7
+      Right.Tool = SquaringTools.Mill.H1 or SquaringTools.Mill.H7
+      Front.Tool = SquaringTools.Mill.H1 or SquaringTools.Mill.H7
+   end
+
+   -- l'ordinamento delle linee dipende dal verso di percorrenza e, se attivato, dal riferimento utilizzato
+   -- con doppio l'ordine cambia
+   -- lato lungo lavorato in doppio
+   if not Back.Tool then
+      for i = 1, 3 do
+         SquaringParameters[i] = {}
+      end
+      if Front.Tool.bIsPathCw then
+         if bSquaringStartsOnReference and ( sOrigCorner == 'BL' or sOrigCorner == 'BM') then
+            SquaringParameters[1] = Front
+            SquaringParameters[2] = Left
+            SquaringParameters[3] = Right
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'TR' or sOrigCorner == 'TN') then
+            SquaringParameters[1] = Right
+            SquaringParameters[2] = Front
+            SquaringParameters[3] = Left
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'BR' or sOrigCorner == 'BN') then
+            SquaringParameters[1] = Right
+            SquaringParameters[2] = Front
+            SquaringParameters[3] = Left
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'TL' or sOrigCorner == 'TM') then
+            SquaringParameters[1] = Left
+            SquaringParameters[2] = Front
+            SquaringParameters[3] = Right
+         else
+            SquaringParameters[1] = Right
+            SquaringParameters[2] = Front
+            SquaringParameters[3] = Left
+         end
+      else
+         if bSquaringStartsOnReference and ( sOrigCorner == 'BL' or sOrigCorner == 'BM') then
+            SquaringParameters[1] = Left
+            SquaringParameters[2] = Front
+            SquaringParameters[3] = Right
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'TR' or sOrigCorner == 'TN') then
+            SquaringParameters[1] = Front
+            SquaringParameters[2] = Right
+            SquaringParameters[3] = Left
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'BR' or sOrigCorner == 'BN') then
+            SquaringParameters[1] = Front
+            SquaringParameters[2] = Right
+            SquaringParameters[3] = Left
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'TL' or sOrigCorner == 'TM') then
+            SquaringParameters[1] = Left
+            SquaringParameters[2] = Front
+            SquaringParameters[3] = Right
+         else
+            SquaringParameters[1] = Left
+            SquaringParameters[2] = Front
+            SquaringParameters[3] = Right
+         end
+      end
+   -- doppio non attivo
+   else
+      for i = 1, 4 do
+         SquaringParameters[i] = {}
+      end
+      if Front.Tool.bIsPathCw then
+         if bSquaringStartsOnReference and ( sOrigCorner == 'BL' or sOrigCorner == 'BM') then
+            SquaringParameters[1] = Front
+            SquaringParameters[2] = Left
+            SquaringParameters[3] = Back
+            SquaringParameters[4] = Right
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'TR' or sOrigCorner == 'TN') then
+            SquaringParameters[1] = Back
+            SquaringParameters[2] = Right
+            SquaringParameters[3] = Front
+            SquaringParameters[4] = Left
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'BR' or sOrigCorner == 'BN') then
+            SquaringParameters[1] = Right
+            SquaringParameters[2] = Front
+            SquaringParameters[3] = Left
+            SquaringParameters[4] = Back
+         else
+            SquaringParameters[1] = Left
+            SquaringParameters[2] = Back
+            SquaringParameters[3] = Right
+            SquaringParameters[4] = Front
+         end
+      else
+         if bSquaringStartsOnReference and ( sOrigCorner == 'TL' or sOrigCorner == 'TM') then
+            SquaringParameters[1] = Back
+            SquaringParameters[2] = Left
+            SquaringParameters[3] = Front
+            SquaringParameters[4] = Right
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'TR' or sOrigCorner == 'TN') then
+            SquaringParameters[1] = Right
+            SquaringParameters[2] = Back
+            SquaringParameters[3] = Left
+            SquaringParameters[4] = Front
+         elseif bSquaringStartsOnReference and ( sOrigCorner == 'BR' or sOrigCorner == 'BN') then
+            SquaringParameters[1] = Front
+            SquaringParameters[2] = Right
+            SquaringParameters[3] = Back
+            SquaringParameters[4] = Left
+         else
+            SquaringParameters[1] = Left
+            SquaringParameters[2] = Front
+            SquaringParameters[3] = Right
+            SquaringParameters[4] = Back
+         end
+      end
+   end
+
+   return SquaringParameters, b3Squaring
+end
+
+-------------------------------------------------------------------------------------------------------------
+function Squaring.AddMachinings( SquaringParameters, b3Squaring, nFirstOperationId)
+   local nNotOkCount = 0
+   local sMsgTotal = ''
+   local dSquaringHeight = b3Squaring:getDimZ()
+   local dExtendPath = 0
+   local dMaxOvermaterial = 0
+   if type( WD.SQUARING_MAX_OVERMATERIAL) == "number" then
+      dMaxOvermaterial = WD.SQUARING_MAX_OVERMATERIAL
+   end
+   local bUseZigZagStep = ( type( WD.SQUARING_USE_ZIGZAG) == "boolean") and ( WD.SQUARING_USE_ZIGZAG == true)
+
+   for i = 1, #SquaringParameters do
+      local dToolRadius = SquaringParameters[i].Tool.dDiameter / 2
+      local vtExtr = EgtCurveExtrusion( SquaringParameters[i].nId, GDB_RT.GLOB)
+      local bIsVerticalMilling = false
+      if AreSameVectorApprox( vtExtr, Z_AX()) then
+         bIsVerticalMilling = true
+      end
+      -- calcolo step laterale
+      local MachiningSteps = { nCount = 1, dStep = 0}
+      if not bIsVerticalMilling then
+         MachiningSteps = WM.GetMachiningSteps( dSquaringHeight, SquaringParameters[i].Tool.dSideStep)
+      end
+
+      for j = 1, MachiningSteps.nCount do
+         local nOperationId = EgtCreateMachining( 'SQUARING_' .. SquaringParameters[i].sSide, MCH_OY.MILLING, SquaringParameters[i].Tool.sName)
+         -- geometria
+         EgtSetMachiningGeometry( SquaringParameters[i].nId)
+         -- profondità di lavoro
+         EgtSetMachiningParam( MCH_MP.DEPTH_STR, 0)
+         -- workside e inversione
+         if SquaringParameters[i].Tool.bIsPathCw then
+            if SquaringParameters[i].Tool.nType == MCH_TY.MILL_STD then
+               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+            else
+               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+            end
+            EgtSetMachiningParam( MCH_MP.INVERT, true)
+         else
+            if SquaringParameters[i].Tool.nType == MCH_TY.MILL_STD then
+               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+            else
+               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+            end
+            EgtSetMachiningParam( MCH_MP.INVERT, false)
+         end
+         -- distanza di sicurezza
+         if bIsVerticalMilling then
+            EgtSetMachiningParam( MCH_MP.STARTPOS, WD.CUT_SIC + dSquaringHeight)
+         else
+            EgtSetMachiningParam( MCH_MP.STARTPOS, WD.CUT_SIC)
+         end
+         -- overlap
+         EgtSetMachiningParam( MCH_MP.OVERL, 0)
+         -- tipo di step
+         if bIsVerticalMilling and bUseZigZagStep then
+            EgtSetMachiningParam( MCH_MP.STEPTYPE, MCH_MILL_ST.ZIGZAG)
+         else
+            EgtSetMachiningParam( MCH_MP.STEPTYPE, MCH_MILL_ST.ONEWAY)
+         end
+         -- step
+         if bIsVerticalMilling then
+            EgtSetMachiningParam( MCH_MP.STEP, SquaringParameters[i].Tool.dStep)
+         else
+            EgtSetMachiningParam( MCH_MP.STEP, 0)
+         end
+         -- offset radiale
+         local dRadialOffset = 0
+         if not bIsVerticalMilling then
+            dRadialOffset = ( MachiningSteps.nCount - j) * MachiningSteps.dStep
+         end
+         EgtSetMachiningParam( MCH_MP.OFFSR, dRadialOffset)
+         -- offset longitudinale
+         EgtSetMachiningParam( MCH_MP.OFFSL, 0)
+         -- inversione utensile
+         EgtSetMachiningParam( MCH_MP.TOOLINVERT, false)
+         -- faceuse
+         EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.NONE)
+         -- angoli suggeriti
+         EgtSetMachiningParam( MCH_MP.INITANGS, '')
+         -- asse bloccato
+         EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, '')
+         -- SCC
+         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.NONE)
+         -- calcolo estensione percorso
+         if bIsVerticalMilling then
+            -- per utensili che lavorano di fianco, si deve partire fuori dall'altezza del grezzo
+            dExtendPath = dMaxOvermaterial + dToolRadius + WD.COLL_SIC
+         else
+            -- si calcola l'impronta utensile per uscire quanto basta a garantire il maxOvermaterial, con una distanza di sicurezza
+            dExtendPath = dMaxOvermaterial + WD.COLL_SIC + dToolRadius - ( dToolRadius - sqrt( dToolRadius * dToolRadius - ( ( dToolRadius - dSquaringHeight) * ( dToolRadius - dSquaringHeight))))
+         end
+         -- approccio
+         EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
+         EgtSetMachiningParam( MCH_MP.STARTADDLEN, dExtendPath)
+         EgtSetMachiningParam( MCH_MP.LITANG, 0)
+         if bIsVerticalMilling then
+            EgtSetMachiningParam( MCH_MP.LIPERP, 0)
+         else
+            -- per utensili che lavorano di fianco, si deve partire fuori dall'altezza del grezzo
+            EgtSetMachiningParam( MCH_MP.LIPERP, WD.CUT_SIC + dSquaringHeight)
+         end
+         EgtSetMachiningParam( MCH_MP.LIELEV, 0)
+         EgtSetMachiningParam( MCH_MP.LICOMPLEN, 0)
+         -- retrazione
+         EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.LINEAR)
+         EgtSetMachiningParam( MCH_MP.ENDADDLEN, dExtendPath)
+         EgtSetMachiningParam( MCH_MP.LOTANG, 0)
+         if bIsVerticalMilling then
+            EgtSetMachiningParam( MCH_MP.LOPERP, 0)
+         else
+            -- per utensili che lavorano di fianco, si deve partire fuori dall'altezza del grezzo
+            EgtSetMachiningParam( MCH_MP.LOPERP, WD.CUT_SIC + dSquaringHeight)
+         end
+         EgtSetMachiningParam( MCH_MP.LOELEV, 0)
+         EgtSetMachiningParam( MCH_MP.LOCOMPLEN, 0)
+         -- note utente
+         local sUserNotes = ''
+         sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
+         if SquaringParameters[i].ToolDouble then
+            local dYMirrorAx
+            local b3Tab = EgtGetTableArea()
+            dYMirrorAx = b3Squaring:getCenter():getY() - b3Tab:getMin():getY()
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'DOUBLE', 2)
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'MirrorAx', dYMirrorAx)
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'TOOLDOUBLE', SquaringParameters[i].ToolDouble.sName)
+         end
+         if not bIsVerticalMilling then
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', 0)
+         end
+         EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
+
+         local bOk = EgtApplyMachining( true, false)
+         -- la squadratura va sempre prima delle eventuali altre lavorazioni
+         if nFirstOperationId then
+            EgtRelocateGlob( nOperationId, nFirstOperationId, GDB_IN.BEFORE)
+         end
+         if not bOk then
+            local _, sMsg = EgtGetLastMachMgrError()
+            nNotOkCount = nNotOkCount + 1
+            sMsgTotal = sMsgTotal ..'\n' .. ( sMsg or '')
+         end
+      end
+   end
+
+   return ( nNotOkCount < 1), sMsgTotal
+end
+
+-------------------------------------------------------------------------------------------------------------
+function Squaring.AddScrapRemoval( nFirstOperationId)
+   -- pulizia sfridi alla prima lavorazione dopo la squadratura
+   EgtSetCurrMachining( nFirstOperationId)
+   local sMachiningNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
+   sMachiningNotes = sMachiningNotes .. 'ScrapRemove=1;'
+   EgtSetMachiningParam( MCH_MP.USERNOTES, sMachiningNotes)
+end
+
+-------------------------------------------------------------------------------------------------------------
+return Squaring

LuaLibs/WFeatureTopology.lua

@@ -192,6 +192,7 @@ function WFeatureTopology.Classify( Proc, b3Raw)
       sFamily = 'DRILLING'
    elseif Proc.Fct == 1 and bIsAnyDimensionLongAsPart and bIsFeatureCuttingEntireSection then
       sFamily = 'Cut'
+      bIsThrough = true
    elseif Proc.Fct == 1 and bIsAnyDimensionLongAsPart then
       sFamily = 'Bevel'
       bIsThrough = true

LuaLibs/WMachiningLib.lua

@@ -148,18 +148,27 @@ function WMachiningLib.FindSawing( sType)
 end
 
 ---------------------------------------------------------------------
-function WMachiningLib.FindDrilling( dDiam, dDepth, sHead, bOnlyPockets)
+function WMachiningLib.FindDrilling( dDiam, dDepth, sHead, bOnlyPockets, bUseMultiDrill, DrillingsToAvoid)
    if bOnlyPockets == nil or not bOnlyPockets then
       -- ricerca sulle forature, dal diametro maggiore al minore
       for i = #Drillings, 1, -1 do
          local Drilling = Drillings[i]
-         if Drilling.On and Drilling.Type == 'Drill' and SetCurrMachiningAndTool( Drilling.Name) then
+         if Drilling.On and EgtIf( bUseMultiDrill, Drilling.Type == 'MultiDrill', Drilling.Type == 'Drill') and SetCurrMachiningAndTool( Drilling.Name) then
+            local bIsToAvoid = false
+            if DrillingsToAvoid then
+               for j = 1, #DrillingsToAvoid do
+                  if Drilling.Name == DrillingsToAvoid[j] then
+                     bIsToAvoid = true
+                  end
+               end
+            end
             local nMchType = EgtMdbGetCurrMachiningParam( MCH_MP.TYPE) 
             local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
             local dTMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
             local sMyHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
             if nMchType == MCH_MY.DRILLING and
-               dTDiam < dDiam + 10 * GEO.EPS_SMALL  and  dTDiam > dDiam - WD.DRILL_TOL - 10 * GEO.EPS_SMALL and
+               ( not bIsToAvoid) and
+               ( not dDiam or ( dTDiam < dDiam + 10 * GEO.EPS_SMALL  and  dTDiam > dDiam - WD.DRILL_TOL - 10 * GEO.EPS_SMALL)) and
                ( not dDepth or dTMaxMat > dDepth - GEO.EPS_SMALL) and
                (( not sHead and sMyHead ~= 'H5' and sMyHead ~= 'H6') or sHead == sMyHead) then
                return Drilling.Name, Drilling.Type, dTMaxMat
@@ -167,16 +176,29 @@ function WMachiningLib.FindDrilling( dDiam, dDepth, sHead, bOnlyPockets)
          end
       end
    end
+   -- se MultiDrill non si prova il DrillPocket
+   if bUseMultiDrill then
+      return
+   end
    -- ricerca sulle svuotature, dal diametro maggiore al minore
    for i = #Drillings, 1, -1 do
       local Drilling = Drillings[i]
       if Drilling.On and Drilling.Type == 'Pocket' and SetCurrMachiningAndTool( Drilling.Name) then
+         local bIsToAvoid = false
+         if DrillingsToAvoid then
+            for j = 1, #DrillingsToAvoid do
+               if Drilling.Name == DrillingsToAvoid[j] then
+                  bIsToAvoid = true
+               end
+            end
+         end
          local nMchType = EgtMdbGetCurrMachiningParam( MCH_MP.TYPE)
          local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
          local dTMaxDepth = EgtIf( WD.MILL_MAX_DEPTH_AS_MAT, EgtTdbGetCurrToolParam( MCH_TP.MAXMAT), EgtTdbGetCurrToolMaxDepth())
          local sMyHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
          if nMchType == MCH_MY.POCKETING and
-            dTDiam < dDiam - 10 * GEO.EPS_SMALL and
+            ( not bIsToAvoid) and
+            ( not dDiam or ( dTDiam < dDiam - 10 * GEO.EPS_SMALL)) and
             ( not dDepth or dTMaxDepth > dDepth - GEO.EPS_SMALL) and
             ( ( not sHead and sMyHead ~= 'H5' and sMyHead ~= 'H6') or sHead == sMyHead) then
             return Drilling.Name, Drilling.Type, dTMaxDepth
@@ -192,7 +214,8 @@ function WMachiningLib.FindSurfacing( sType)
       local Surfacing = Surfacings[i]
       if Surfacing.On and Surfacing.Type == sType and SetCurrMachiningAndTool( Surfacing.Name) then
          local nMchType = EgtMdbGetCurrMachiningParam( MCH_MP.TYPE)
-         if nMchType == MCH_MY.SURFFINISHING then
+         if (( sType == 'Roughing' and nMchType == MCH_MY.SURFROUGHING) or
+             ( sType == 'Finishing' and nMchType == MCH_MY.SURFFINISHING)) then
             return Surfacing.Name
          end
       end
@@ -266,5 +289,17 @@ function WMachiningLib.IsMachiningOkForDouble( sMachining)
    return bDoubleOk
 end
 
+-------------------------------------------------------------------------------------------------------------
+function WMachiningLib.GetMachiningSteps( dMachiningDepth, dStep)
+   local MachiningSteps = {}
+   MachiningSteps.dStep = 0
+   MachiningSteps.nCount = ceil( ( dMachiningDepth - 10 * GEO.EPS_SMALL) / dStep)
+   if MachiningSteps.nCount > 1 then
+      MachiningSteps.dStep = ( dMachiningDepth - dStep) / ( MachiningSteps.nCount - 1)
+   end
+
+   return MachiningSteps
+end
+
 -------------------------------------------------------------------------------------------------------------
 return WMachiningLib

LuaLibs/WProcessDoubleCut.lua

@@ -36,14 +36,17 @@ end
 function WPDC.Classify( Proc, b3Raw)
    -- se una faccia, uso la classificazione dei tagli singoli
    if Proc.Fct == 1 then return Cut.Classify( Proc, b3Raw) end
+
    -- se più di due facce non si fa
    if Proc.Fct > 2 then return false end
-   -- dati delle facce
+
+   -- se due facce si verifica solamente se le facce non sono troppo orientate verso il basso (per due facce unite sul lato lungo il check è fatto nella LapJoint)
    local vtN = {}
    vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
    vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT)
-   -- verifico se è lavorabile da sopra o di fianco
+   local bIsMachinable = ( vtN[1]:getZ() >= ( WD.CUT_VZ_MIN or - 0.5)) and ( vtN[2]:getZ() >= ( WD.CUT_VZ_MIN or - 0.5))
-   return ( vtN[1]:getZ() >= - 0.01 or vtN[2]:getZ() >= - 0.01) 
+
+   return bIsMachinable
 end
 
 ----------------------------------------------------------------------
@@ -66,9 +69,8 @@ function WPDC.Make( Proc, nRawId, b3Raw)
    -- se singola faccia, passo a quella lavorazione
    if Proc.Fct == 1 then return Cut.Make( Proc, nRawId, b3Raw) end
    -- altrimenti due facce e passo alla LapJoint
-   local LapProc = { PartId = Proc.PartId, Id = Proc.Id, Grp = Proc.Grp + 2, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
+   Proc.Grp = Proc.Grp + 2
-                     Diam = Proc.Diam, Fcs = Proc.Fcs, Fce = Proc.Fce, CutId = Proc.CutId, TaskId = Proc.TaskId}
+   return LapJoint.Make( Proc, nRawId, b3Raw)
-   return LapJoint.Make( LapProc, nRawId, b3Raw)
 end
 
 ---------------------------------------------------------------------

LuaLibs/WProcessDrill.lua

@@ -27,6 +27,9 @@ local WM = require( 'WMachiningLib')
 -- Parametri Q
 local sContourOnly = 'Q01'       -- 0=no, 1=si
 
+-- Per forature MultiDrill, lista lavorazioni già provate
+local TriedDrillings = {}
+
 
 ---------------------------------------------------------------------
 -- Riconoscimento della feature
@@ -56,7 +59,7 @@ end
 
 ---------------------------------------------------------------------
 -- Classificazione della feature
-function WPD.Classify( Proc, b3Raw)
+function WPD.Classify( Proc, b3Raw, bUseMultiDrill)
  
    -- recupero e verifico l'entità foro
    local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0
@@ -75,6 +78,10 @@ function WPD.Classify( Proc, b3Raw)
       -- è lavorabile se non troppo inclinato
       return ( abs( vtExtr:getZ()) >= WD.DRILL_VZ_MIN)
    end
+   -- multiforatore (cabinet)
+   if bUseMultiDrill then
+      return true
+   end
    -- se con direzione asse Y e macchina con foratore orizzontale del giusto diametro
    if WD.HOR_DRILL_DIAM and abs( dDiam - WD.HOR_DRILL_DIAM) < WD.DRILL_TOL and AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) then
       return true
@@ -255,7 +262,7 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function WPD.Make( Proc, nRawId, b3Raw)
+function WPD.Make( Proc, nRawId, b3Raw, bUseMultiDrill, DrillingsToAvoid)
    -- recupero e verifico l'entità foro
    local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0
    if AuxId then AuxId = AuxId + Proc.Id end
@@ -272,7 +279,7 @@ function WPD.Make( Proc, nRawId, b3Raw)
    local bOpen = ( Proc.Fcs ~= 0  and  Proc.Fce ~= 0)
    -- verifico che il foro non sia fattibile solo da sotto
    local bToInvert = ( vtExtr:getZ() < -0.1)
-   if bToInvert  and  ( not bOpen or Proc.Flg ~= 1) then
+   if bToInvert  and  ( not bOpen or Proc.Flg > 1) then
       local sErr = 'Error : drilling from bottom impossible'
       EgtOutLog( sErr)
       return false, sErr
@@ -299,57 +306,74 @@ function WPD.Make( Proc, nRawId, b3Raw)
          end
       end
    end
-   local bUseDLenToFindDrilling = true
+   local sDrilling, nType
-   local sDrilling, nType = WM.FindDrilling( dDiam, dLen, sHead)
+   if bUseMultiDrill then
-   if not sDrilling then
+      sDrilling, nType = WM.FindDrilling( nil, nil, nil, nil, true, TriedDrillings)
-      bUseDLenToFindDrilling = false
-      sDrilling, nType = WM.FindDrilling( dDiam, nil, sHead)
-   end
-   -- se Proc è settata per essere specchiata cerco la lavorazione adatta e verifico possa essere effettivamente specchiata 
-   if Proc.Double and Proc.Double == 2 then
-      local sDrillingBackup = sDrilling
-      sDrilling = WM.FindDrilling( dDiam, EgtIf( bUseDLenToFindDrilling, dLen, nil), 'H1')
-      if not IsMachiningOkForDouble( sDrilling) then
-         Proc.Double = 0
-         sDrilling = sDrillingBackup
-      end
-   end
-   if sHead and not sDrilling then
-      sDrilling, nType = WM.FindDrilling( dDiam, dLen)
       if not sDrilling then
-         sDrilling, nType = WM.FindDrilling( dDiam)
+         return false
+      end
+   else
+      local bUseDLenToFindDrilling = true
+      sDrilling, nType = WM.FindDrilling( dDiam, dLen, sHead)
+      if not sDrilling then
+         bUseDLenToFindDrilling = false
+         sDrilling, nType = WM.FindDrilling( dDiam, nil, sHead)
+      end
+      -- se Proc è settata per essere specchiata cerco la lavorazione adatta e verifico possa essere effettivamente specchiata 
+      if Proc.Double and Proc.Double == 2 then
+         local sDrillingBackup = sDrilling
+         sDrilling = WM.FindDrilling( dDiam, EgtIf( bUseDLenToFindDrilling, dLen, nil), 'H1')
+         if not IsMachiningOkForDouble( sDrilling) then
+            Proc.Double = 0
+            sDrilling = sDrillingBackup
+         end
+      end
+      if sHead and not sDrilling then
+         sDrilling, nType = WM.FindDrilling( dDiam, dLen)
+         if not sDrilling then
+            sDrilling, nType = WM.FindDrilling( dDiam)
+         end
+         if sDrilling then sHead = '' end
       end
-      if sDrilling then sHead = '' end
    end
    local bAngledContourDrill = false
    local nAngledContourDrillId = GDB_ID.NULL
    local dReduceDepth = 0
+   local bUseTabs = false
    -- se trovata svuotatura, verifico se richiesta invece contornatura
    if nType == 'Pocket' then
       -- recupero eventuale flag per fare sola contornatura
       local nContourOnly = ( EgtGetInfo( Proc.Id, sContourOnly, 'i') or 0)
       if nContourOnly == 1 then
-         -- imposto riduzione profondita' per evitare distacco pezzo interno
+         -- se passante
-         dReduceDepth = 5
+         if Proc.Fcs > 0 and Proc.Fce > 0 then
-         -- se inclinato e passante
+            -- se inclinato
-         if abs( vtExtr:getZ()) >= WD.DRILL_VZ_MIN and abs( vtExtr:getZ()) < 0.999  and Proc.Fcs > 0 and Proc.Fce > 0 then
+            if abs( vtExtr:getZ()) >= WD.DRILL_VZ_MIN and abs( vtExtr:getZ()) < 0.999 then
-            -- gruppo ausiliario per preforo
+               -- gruppo ausiliario per preforo
-            local nAddGrpId = WL.GetAddGroup( Proc.PartId)
+               local nAddGrpId = WL.GetAddGroup( Proc.PartId)
-            -- ricavo contorno inferiore della superficie
+               -- ricavo contorno inferiore della superficie
-            local nAngledCircleId, nAngledCircleCnt = EgtExtractSurfTmLoops( Proc.Id, nAddGrpId)
+               local nAngledCircleId, nAngledCircleCnt = EgtExtractSurfTmLoops( Proc.Id, nAddGrpId)
-            local dMinZ = 10000
+               local dMinZ = 10000
-            local nMinCircleId = GDB_ID.NULL
+               local nMinCircleId = GDB_ID.NULL
-            for Circleindex = 1, nAngledCircleCnt do
+               for Circleindex = 1, nAngledCircleCnt do
-               local b3Circle = EgtGetBBoxGlob( nAngledCircleId + Circleindex -1, GDB_BB.EXACT)
+                  local b3Circle = EgtGetBBoxGlob( nAngledCircleId + Circleindex -1, GDB_BB.EXACT)
-               if b3Circle:getMin():getZ() < dMinZ then
+                  if b3Circle:getMin():getZ() < dMinZ then
-                  nMinCircleId = nAngledCircleId + Circleindex -1
+                     nMinCircleId = nAngledCircleId + Circleindex -1
+                  end
                end
+               -- estrudo
+               EgtModifyCurveExtrusion( nMinCircleId, vtExtr, GDB_RT.GLOB)
+               EgtModifyCurveThickness( nMinCircleId, dLen)
+               bAngledContourDrill = true
+               nAngledContourDrillId = nMinCircleId
+            -- se non inclinato e abbastanza grande uso i tab
+            -- TODO se si risolve il problema dei tabs non funzionanti sotto ai 200 mm rimuovere il check sul diametro
+            elseif dDiam > 100 - 10 * GEO.EPS_SMALL then
+                  bUseTabs = true
+            -- se non inclinato e piccolo non arrivo sul fondo
+            else
+               dReduceDepth = 5
             end
-            -- estrudo
-            EgtModifyCurveExtrusion( nMinCircleId, vtExtr, GDB_RT.GLOB)
-            EgtModifyCurveThickness( nMinCircleId, dLen)
-            bAngledContourDrill = true
-            nAngledContourDrillId = nMinCircleId
          end
          sDrilling = WM.FindMilling( 'FreeContour', dLen, nil, nil, nil, nil, true)
          if sDrilling then
@@ -437,11 +461,29 @@ function WPD.Make( Proc, nRawId, b3Raw)
    -- aggiungo geometria
    if bAngledContourDrill then
       EgtSetMachiningGeometry( nAngledContourDrillId)
+   elseif bUseMultiDrill then
+      if Proc.SkippedGeometries and #Proc.SkippedGeometries > 0 then
+         EgtSetMachiningGeometry( Proc.SkippedGeometries)
+      else
+         local HolesGeometries = {}
+         -- aggiungo foro principale
+         table.insert( HolesGeometries, { AuxId, -1})
+         -- aggiungo eventuali altre geometrie connesse
+         if Proc.OtherGeometries and #Proc.OtherGeometries > 0 then
+            for i = 1, #Proc.OtherGeometries do
+               -- recupero geometria da lavorare
+               local OtherAuxId = Proc.OtherGeometries[i].Id + EgtGetInfo( Proc.OtherGeometries[i].Id, 'AUXID', 'i')
+               local Geometry = { OtherAuxId, -1}
+               table.insert( HolesGeometries, Geometry)
+            end
+         end
+         EgtSetMachiningGeometry( HolesGeometries)
+      end
    else
       EgtSetMachiningGeometry( {{ AuxId, -1}})
    end
    -- eventuale inversione
-   if nType == 'Drill' then
+   if nType == 'Drill' or nType == 'MultiDrill' then
       EgtSetMachiningParam( MCH_MP.INVERT, bToInvert)
    else
       EgtSetMachiningParam( MCH_MP.TOOLINVERT, bToInvert)
@@ -479,7 +521,9 @@ function WPD.Make( Proc, nRawId, b3Raw)
    end
    -- imposto posizione braccio porta testa
    local nSCC = MCH_SCC.ADIR_ZP
-   if AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
+   if bUseMultiDrill then
+      nSCC = MCH_SCC.ADIR_NEAR
+   elseif AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
       nSCC = MCH_SCC.ADIR_YP
    end
    EgtSetMachiningParam( MCH_MP.SCC, nSCC)
@@ -493,8 +537,13 @@ function WPD.Make( Proc, nRawId, b3Raw)
          EgtOutLog( sMyWarn .. ' (process ' .. tostring( Proc.Id) .. ')')
       end
    end
-   EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
+   if bUseMultiDrill then
-   -- leggo eventuali note esistenti della lavorazione
+      local sDepth = 'TH'
+      EgtSetMachiningParam( MCH_MP.DEPTH_STR, sDepth)
+   else
+      EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
+   end
+      -- leggo eventuali note esistenti della lavorazione
    local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
    -- se foratura o svuotatura, dichiarazione nessuna generazione sfridi per Vmill
    if nType == 'Drill' or nType == 'Pocket' then
@@ -515,20 +564,107 @@ function WPD.Make( Proc, nRawId, b3Raw)
       sUserNotes = EgtSetValInNotes( sUserNotes, 'MirrorAx', Proc.MirrorAx)
    end
    EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
+   if bUseTabs then
+      local dStep = EgtGetMachiningParam( MCH_MP.STEP)
+      EgtSetMachiningParam( MCH_MP.STEPTYPE, MCH_MILL_ST.ONEWAY)
+      EgtSetMachiningParam( MCH_MP.LEAVETAB, true)
+      EgtSetMachiningParam( MCH_MP.TABHEIGHT, EgtClamp( dStep, 0.15 * dDepth, 0.25 * dDepth ))
+      EgtSetMachiningParam( MCH_MP.TABLEN, EgtClamp( 2 * dDiamT, 0.1 * dDiam, 0.2 * dDiam ))
+      EgtSetMachiningParam( MCH_MP.TABANGLE, 45)
+      EgtSetMachiningParam( MCH_MP.TABDIST, 100)
+      EgtSetMachiningParam( MCH_MP.TABMIN, 3)
+      EgtSetMachiningParam( MCH_MP.TABMAX, 3)
+   end
    -- eseguo
-   if not EgtApplyMachining( true, false) then
+   local bOk = EgtApplyMachining( true, false)
-      local _, sErr = EgtGetLastMachMgrError()
+   
-      EgtSetOperationMode( nMchId, false) 
+   -- in caso di fori raggruppati vengono restituiti gli eventuali fori saltati
-      return false, sErr
+   local SkippedGeometries = {}
-   else
+   SkippedGeometries = EgtGetMachiningSkippedGeometry()
-      local _, sWarn = EgtGetMachMgrWarning( 0)
+   local sMsgMaster
-      if EgtIsMachiningEmpty() then
+   if bUseMultiDrill and SkippedGeometries and #SkippedGeometries > 0 then
-         EgtSetOperationMode( nMchId, false)
+      if ( Proc.SkippedGeometries and ( #SkippedGeometries == #Proc.SkippedGeometries))
-         return false, sWarn
+         or ( Proc.OtherGeometries and ( #SkippedGeometries == #Proc.OtherGeometries + 1))
-      else
+         or ( not Proc.OtherGeometries and #SkippedGeometries == 1) then
-         sMyWarn = (sMyWarn or sWarn)
+         EgtRemoveOperation( nMchId)
+      end
+      Proc.SkippedGeometries = SkippedGeometries
+      table.insert( TriedDrillings, sDrilling)
+      -- per provare tutte le MultiDrill disponibili si passano quelle già fatte come lavorazioni da ignorare
+      bOk = WPD.Make( Proc, nRawId, b3Raw, true, TriedDrillings)
+      -- non trovata lavorazione, si prova con le lavorazioni singole
+      if not bOk then
+         local bOkMaster = true
+         for i = #Proc.SkippedGeometries, 1, -1 do
+            local sErr
+            if Proc.OtherGeometries then
+               for j = 1, #Proc.OtherGeometries do
+                  local AuxIdOtherGeometry = EgtGetInfo( Proc.OtherGeometries[j].Id, 'AUXID', 'i') or 0
+                  if AuxIdOtherGeometry then AuxIdOtherGeometry = AuxIdOtherGeometry + Proc.OtherGeometries[j].Id end
+                  if Proc.SkippedGeometries[i][1] == AuxIdOtherGeometry then
+                     bOk, sErr = WPD.Make( Proc.OtherGeometries[j], nRawId, b3Raw, false)
+                     if bOk then
+                        Proc.OtherGeometries[j].bOk = true
+                     else
+                        Proc.OtherGeometries[j].bOk = false
+                     end
+                        Proc.OtherGeometries[j].sMsg = sErr
+                     break
+                  end
+               end
+               -- se nelle altre geometrie non è stato trovato, potrebbe essere la principale
+               local AuxIdProc = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0
+               if AuxIdProc then AuxIdProc = AuxIdProc + Proc.Id end
+               if Proc.SkippedGeometries[i][1] == AuxIdProc then
+                  bOk, sErr = WPD.Make( Proc, nRawId, b3Raw, false)
+                  if not bOk then
+                     bOkMaster = false
+                  end
+                  sMsgMaster = sErr
+               end
+            -- se non ci sono altre geometrie quella da fare è sicuramente la Proc principale
+            else
+               bOk, sErr = WPD.Make( Proc, nRawId, b3Raw, false)
+               if not bOk then
+                  bOkMaster = false
+               end
+               sMsgMaster = sErr
+            end
+            if bOk then
+               table.remove( Proc.SkippedGeometries, i)
+            end
+         end
+         bOk = bOkMaster
       end
    end
+   -- se presenti geometrie aggiuntive, aggiunta informazioni per output statistiche
+   if Proc.OtherGeometries and #Proc.OtherGeometries > 0 then
+      for i = 1, #Proc.OtherGeometries do
+         if Proc.OtherGeometries[i].bOk == nil then
+            Proc.OtherGeometries[i].bOk = true
+            Proc.OtherGeometries[i].sMsg = ''
+         end
+      end
+   end
+
+   if not bUseMultiDrill then
+      if not bOk then
+         local _, sErr = EgtGetLastMachMgrError()
+         EgtSetOperationMode( nMchId, false) 
+         return false, sErr
+      else
+         local _, sWarn = EgtGetMachMgrWarning( 0)
+         if EgtIsMachiningEmpty() then
+            EgtSetOperationMode( nMchId, false)
+            return false, sWarn
+         else
+            sMyWarn = (sMyWarn or sWarn)
+         end
+      end
+   else
+      return bOk, sMsgMaster
+   end
+
    -- se preforo inclinato impostato, inclinazione oltre limite impostato e foro non orizzontale
    if WD.PREDRILL_DIAM and WD.PREDRILL_DIAM > 0 and vtExtr:getZ() < ( WD.PREDRILL_MINANGLE or 0.707) and vtExtr:getZ() > 0.1 then
       -- gruppo ausiliario per preforo

LuaLibs/WProcessFreeContour.lua

@@ -1,4 +1,4 @@
--- ProcessFreeContour.lua by Egaltech s.r.l. 2023/10/02
+-- ProcessFreeContour.lua by Egaltech s.r.l. 2026/03/30
 -- Gestione calcolo profilo libero per Pareti
 -- 2021/11/15 Penna e chiodature sono sempre riportate sulla faccia sopra anche se nel progetto sono sotto.
 -- 2021/12/10 In taglio con lama aggiunta gestione SCC per testa Gearbox.
@@ -28,6 +28,7 @@
 -- 2023/11/14 Spostamento di alcune funzioni in WallLib.
 --            Aggiunta dei FreeContour in doppio.
 -- 2023/12/13 In MakeByPocket aggiunta la possibilità di svuotare tasche passanti.
+-- 2024/03/24 Sostituite funzioni di Collision Detection (EgtCDe*) con quelle di verifica interferenza (EgtTest*).
 
 -- Tabella per definizione modulo
 local WPF = {}
@@ -174,6 +175,22 @@ local function IsPointOnRawLongEdges( ptCen, b3Raw)
    return ( abs( ptCen:getY() - b3Raw:getMin():getY()) < 0.1 or abs( ptCen:getY() - b3Raw:getMax():getY()) < 0.1)
 end
 
+---------------------------------------------------------------------
+local function IsFaceOutsideSquaring( Proc, Face, b3Squaring)
+   -- faccia esterna al box di squadratura
+   if b3Squaring then
+      local b3SquaringReduced = BBox3d( b3Squaring)
+      b3SquaringReduced:expand( -0.1)
+      local b3Face = EgtSurfTmGetFacetBBoxGlob( Proc.Id, Face.Fac, GDB_BB.STANDARD)
+      if not OverlapsXY( b3SquaringReduced, b3Face) then
+         EgtOutLog( 'Proc ' .. Proc.Id .. ': skipped face ' .. Face.Fac .. ' outside squaring' )
+         return true
+      end
+   else
+      return false
+   end
+end
+
 ---------------------------------------------------------------------
 local function GetOtherRegions( nPartId)
    local vOthers = {}
@@ -387,9 +404,12 @@ local function GetFacesData( Proc, bOpposite, bCalclForBlade, dToolDiam, dToolMa
          dLen = dLen - EgtIf( bCalclForBlade, dWhisk, 0)
          nType = nType + 2
       end
-      -- se lunghezza non significativa, non va inserito il taglio
+      -- se feature taglio esteremità o longitudinale ed è 1 faccia, non controllo lunghezza minima. Si controlla solo interferenza altri pezzi
-      if dLen < MIN_LEN_CUT then
+      if not( Proc.Prc == 10 and Proc.Fct == 1) then
-         nType = 4
+         -- se lunghezza non significativa, non va inserito il taglio
+         if dLen < MIN_LEN_CUT then
+            nType = 4
+         end
       end
       -- numero dei lati
       local nEdges = #(EgtSurfTmFacetAdjacencies( nNewProc, i - 1)[1])
@@ -697,20 +717,19 @@ local function MakeCustomPath( vGeom, nConeCut, dMillDiam, nAddGrpId, dThick, bC
 end
 
 ---------------------------------------------------------------------
-local function CalcInterference( nNewProc, vtExtr, ptCentr, dDiam1, dDiam2,
+local function CalcInterference( nNewProc, vtExtr, ptCentr,
-                                 dTall1, dTall2, dDiam3, dTall3)
+                                 dDiam1, dTall1, dDiam2, dTall2, dDiam3, dTall3)
-
+   local ptCentrGrid1 = ptCentr + 0.1 * vtExtr
-   local ptCentrGrid1 = ptCentr + ( vtExtr * 0.01)
    local frOriTool = Frame3d( ptCentrGrid1, vtExtr)
-   local bColl1 = EgtCDeConeSolid( frOriTool, dDiam1/2, dDiam2/2, dTall1, nNewProc, 0, GDB_RT.GLOB)
+   local bColl1 = EgtTestConeSurface( frOriTool, dDiam1 / 2, dDiam2 / 2 - 0.1, dTall1, nNewProc, 0, GDB_RT.GLOB)
    if bColl1 then return true end
-   local ptCentrGrid2 = ptCentr + ( vtExtr * ( dTall1 + 0.01))
+   local ptCentrGrid2 = ptCentr + dTall1 * vtExtr
    frOriTool = Frame3d( ptCentrGrid2, vtExtr)
-   local bColl2 = EgtCDeCylSolid( frOriTool, dDiam2/2, (dTall2-dTall1), nNewProc, 0, GDB_RT.GLOB)
+   local bColl2 = EgtTestCylSurface( frOriTool, dDiam2 / 2 - 0.1, dTall2, nNewProc, 0, GDB_RT.GLOB)
    if bColl2 then return true end
-   local ptCentrGrid3 = ptCentr + ( vtExtr * ( dTall2 + 0.01))
+   local ptCentrGrid3 = ptCentr + ( dTall1 + dTall2) * vtExtr
    frOriTool = Frame3d( ptCentrGrid3, vtExtr)
-   local bColl3 = EgtCDeCylSolid( frOriTool, dDiam3/2, (dTall3-dTall2), nNewProc, 0, GDB_RT.GLOB)
+   local bColl3 = EgtTestCylSurface( frOriTool, dDiam3 / 2 - 0.1, dTall3, nNewProc, 0, GDB_RT.GLOB)
    if bColl3 then return true end
    -- restituisco risultato controllo collisioni
    return false
@@ -742,11 +761,32 @@ local function MakeLocalSurf( ptP1, ptP2, ptP3, nAddGrpId)
    return nFaceId
 end
 
+---------------------------------------------------------------------
+local function GetEdgeToMachineFromVector( nSurfId, nFacet, vtOrtho)
+   local _, EdgesEgt = EgtSurfTmGetFacetOutlineInfo( nSurfId, nFacet, GDB_ID.ROOT)
+
+   local nEdgeIndMax = 0
+   local dMaxComp = - GEO.INFINITO
+   for i = 1, #EdgesEgt do
+      local vtN = EdgesEgt[i].Norm
+      if EdgesEgt[i].Open then
+         vtN = -vtN
+      end
+      local dComp = vtN * vtOrtho
+      if dComp > dMaxComp then
+         nEdgeIndMax = i -1
+         dMaxComp = dComp
+      end
+   end
+
+   return nEdgeIndMax
+end
+
 ---------------------------------------------------------------------
 local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTypeConeCut, nAddGrpId, 
                                        dToolDiam, dThick, sMilling, dOffsAng, dDepthMach, 
-                                       bThruThick, dThSurf, dDiam1, dDiam2, dTall1,
+                                       bThruThick, dThSurf, dConeSideAng, dDiam1, dTall1,
-                                       dTall2, dDiam3, dTall3, bMakeLocSurf, vFace)
+                                       dDiam2, dTall2, dDiam3, dTall3, bMakeLocSurf, vFace)
    -- variabili costruzione geometria
    local pAuxId = {}
    local nAuxId
@@ -758,9 +798,9 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
       -- creo superfice locale o esco
       local nSurfToAdd = MakeLocalSurf( tFacAdj[7], tFacAdj[8], tFacAdj[9], nAddGrpId)
       if nSurfToAdd then
-         local nFacCntPre = EgtSurfTmFacetCount( nNewProc)
+         local nFacCntPre = EgtSurfTmFacetCount( nNewProc.Id)
          -- creo copia del percorso principale e gli aggiungo la nuova faccia
-         nNewProcLoc = EgtCopyGlob( nNewProc, nAddGrpId)
+         nNewProcLoc = EgtCopyGlob( nNewProc.Id, nAddGrpId)
          nNewProcLoc = EgtSurfTmBySewing( nAddGrpId, {nNewProcLoc,nSurfToAdd} , true)
          -- riordino le facce
          ReorderFacesFromTab( nNewProcLoc, vFace)
@@ -771,7 +811,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
          return true, ''
       end
    else
-      nNewProcLoc = nNewProc
+      nNewProcLoc = nNewProc.Id
    end
    -- prendo il primo versore
    local _, vtN1 = EgtSurfTmFacetCenter( nNewProcLoc, nFacInd, GDB_ID.ROOT)
@@ -814,23 +854,21 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
       -- sommo i tre versori per avere una direzione media
       vtExtrExit = vtN2 + vtN3
       vtExtrExit:normalize()
-      -- se tipo 1 calcolo angolo tilt di 45°
+      -- calcolo la componente Z dipendente dall'angolo tilt
-      if nTypeConeCut == 1 then
+      local dAlfa = EgtClamp( dConeSideAng, 15, 30)
-         vtExtr = vtExtrExit + Z_AX()
+      local dGamma = 90 - asin( sqrt( 2) * sin( dConeSideAng))
-      -- altrimenti tipo 2, calcolo angolo tilt di 33° (dalla verticale)
+      local dTanGamma = sin( dGamma) / cos( dGamma)
-      else
+      vtExtr = vtExtrExit + Vector3d( 0, 0, dTanGamma)
-         vtExtr = vtExtrExit + Vector3d(0,0,1.539865)
-      end
       vtExtr:normalize()
-      local vtCheck = Vector3d(vtExtr)
+      local vtCheck = Vector3d( vtExtr)
       -- se ho un offset angolare ruoto il percorso
-      if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
+      if abs( dOffsAng) > 100 * GEO.EPS_ANG_SMALL then
          vtCheck:rotate( Z_AX(), dOffsAng)
       end
       -- controllo se c'è collisione con le facce della superfice
-      if nTypeConeCut == 1 and CalcInterference( nNewProc, vtCheck, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), dDiam1, dDiam2,
+      if nTypeConeCut == 1 and CalcInterference( nNewProc.Id, vtCheck, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach),
-                                                 dTall1, dTall2, dDiam3, dTall3) then
+                                                 dDiam1, dTall1, dDiam2, dTall2, dDiam3, dTall3) then
-         local sErr = 'Collision detect from clean corner tool and surface'
+         local sErr = 'Collision detected between clean corner tool and surface'
          EgtOutLog( sErr)
          return true, ''
       end
@@ -925,6 +963,8 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    -- trasformo in percorso
    if #pAuxId > 0 then
       AuxId = EgtCurveCompo( nAddGrpId, pAuxId, true)
+      EgtSetInfo( AuxId, 'TASKID', nNewProc.TaskId)
+      EgtSetInfo( AuxId, 'CUTID', nNewProc.CutId)
    end
    -- se non c'é il percorso do errore
    if not AuxId then
@@ -939,8 +979,8 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
       EgtRotate( AuxId, tFacAdj[nIdEndPoint], Z_AX(), dOffsAng, GDB_RT.GLOB)
    end
    -- inserisco la lavorazione
-   local sName = 'Clean_' .. ( EgtGetName( nNewProc) or tostring( nNewProc))
+   local sName = 'Clean_' .. ( EgtGetName( nNewProc.Id) or tostring( nNewProc.Id))
-   local nMchId = WM.AddMachining( nNewProc, sName, sMilling)
+   local nMchId = WM.AddMachining( nNewProc.Id, sName, sMilling)
    if not nMchId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
       EgtOutLog( sErr)
@@ -1012,47 +1052,51 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
    -- recupero i dati dell'utensile
    local dMillDiam = 20
    local dMillTotDiam = 20
-   local dMillDiamTh = 20
+   local dMillLength = 20
-   local dToolLength = 20
+   local dMillThick = 20
-   local dThickTool = 20
+   local dMillSideAng = 0
-   local dSideAng = 0
+   local dMillStemLength = 10
+   local dMillThDiam = 70
+   local dMillThLength = 20
    if EgtMdbSetCurrMachining( sMilling) then
       local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
       if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-         dMillDiamTh = EgtTdbGetCurrToolThDiam() or dMillDiamTh
+         dMillThDiam = EgtTdbGetCurrToolThDiam() or dMillThDiam
+         dMillThLength = EgtTdbGetCurrToolThLength() or dMillThLength
          dMillTotDiam = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM) or dMillTotDiam
-         dSideAng = EgtTdbGetCurrToolParam( MCH_TP.SIDEANG) or dSideAng
+         dMillSideAng = EgtTdbGetCurrToolParam( MCH_TP.SIDEANG) or dMillSideAng
          dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
-         dThickTool = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dThickTool
+         dMillThick = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dMillThick
-         dToolLength = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dToolLength
+         dMillLength = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dMillLength
-         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth      -- qui è la distanza dal portautensile
+         -- diametro massimo del cono
-         -- calcolo il secondo diametro del cono
+         dMillTotDiam = dMillDiam + ( abs( dMillThick) * tan( dMillSideAng)) * 2
-         dMillTotDiam = dMillDiam + ( abs( dThickTool) * tan( dSideAng)) * 2
+         -- lunghezza del gambo
+         dMillStemLength = dMillLength - abs( dMillThick) - dMillThLength
       end
    end
    -- verifico se ciclo chiuso
    local bClosed = ( abs( vFace[1].PrevAng) > 0.1)
    -- copio la feature nel layer di appoggio
-   local nNewProc
+   local nNewProc = { CutId = Proc.CutId, TaskId = Proc.TaskId}
    if nMasterNewProc then
-      nNewProc = nMasterNewProc
+      nNewProc.Id = nMasterNewProc
    else
-      nNewProc = EgtCopyGlob( Proc.Id, nAddGrpId) or GDB_ID.NULL
+      nNewProc.Id = EgtCopyGlob( Proc.Id, nAddGrpId) or GDB_ID.NULL
    end
-   local nFacCnt = EgtSurfTmFacetCount( nNewProc)
+   local nFacCnt = EgtSurfTmFacetCount( nNewProc.Id)
    local nFacInd, dDepth, nSurfInt
    local bMakeLocSurf
    -- RIMUOVERE
    if false and nFacCnt <= 4 then
       -- recupero profondità e faccia di fondo
-      _, _, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc, Proc.PartId, nAddGrpId, bClosed)
+      _, _, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc.Id, Proc.PartId, nAddGrpId, bClosed)
       if nSurfInt then
          -- aggiungo la faccia di fondo appena calcolata
-         nNewProc = EgtSurfTmBySewing( nAddGrpId, { nNewProc, nSurfInt}, true)
+         nNewProc.Id = EgtSurfTmBySewing( nAddGrpId, { nNewProc.Id, nSurfInt}, true)
          -- riordino le facce
-         ReorderFacesFromTab( nNewProc, vFace)
+         ReorderFacesFromTab( nNewProc.Id, vFace)
          -- aggiorno numero di facce e assegno indice di quella di fondo (sempre ultima)
-         nFacCnt = EgtSurfTmFacetCount( nNewProc)
+         nFacCnt = EgtSurfTmFacetCount( nNewProc.Id)
          nFacInd = nFacCnt - 1
       else
          return true
@@ -1100,7 +1144,7 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
             ptLoc2 = vFace[k].PPrev
          end
          -- ricavo i punti e l'angolo interno
-         local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( nNewProc, nFace1, nFace2, GDB_ID.ROOT)
+         local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( nNewProc.Id, nFace1, nFace2, GDB_ID.ROOT)
          -- se punti validi e angolo è interno e non è quasi piatto e >= 90 creo istanza
          local tFacAdj = {}
          if ptP1 and ptP2 and dAng < 0 and dAng < -6 and dAng > EgtIf( nTypeConeCut == 1, -(90 + 10 * GEO.EPS_SMALL), -(180-dAngleSmall + 10 * GEO.EPS_SMALL))  then
@@ -1115,21 +1159,21 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
                -- primo taglio
                local bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nTypeConeCut, nAddGrpId, 
                                                          dToolDiam, dThick, sMilling, -dAngOffs, dDepthMach, 
-                                                         bThruThick, dDepth, dMillDiam, dMillTotDiam, abs(dThickTool),
+                                                         bThruThick, dDepth, dMillSideAng, dMillDiam, abs( dMillThick),
-                                                         dMaxDepth, dMillDiamTh, dToolLength, bMakeLocSurf, vFace)
+                                                         dMillTotDiam, dMillStemLength, dMillThDiam, dMillThLength, bMakeLocSurf, vFace)
                if not bOk then return bOk, sErr end
                -- secondo taglio
                bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nTypeConeCut, nAddGrpId, 
                                                    dToolDiam, dThick, sMilling, dAngOffs, dDepthMach, 
-                                                   bThruThick, dDepth, dMillDiam, dMillTotDiam, abs(dThickTool), 
+                                                   bThruThick, dDepth, dMillSideAng, dMillDiam, abs( dMillThick), 
-                                                   dMaxDepth, dMillDiamTh, dToolLength, bMakeLocSurf, vFace)
+                                                   dMillTotDiam, dMillStemLength, dMillThDiam, dMillThLength, bMakeLocSurf, vFace)
                if not bOk then return bOk, sErr end
             -- altrimenti ho un solo percorso
             else
                local bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nTypeConeCut, nAddGrpId, 
                                                          dToolDiam, dThick, sMilling, 0, dDepthMach, 
-                                                         bThruThick, dDepth, dMillDiam, dMillTotDiam, abs(dThickTool), 
+                                                         bThruThick, dDepth, dMillSideAng, dMillDiam, abs( dMillThick),
-                                                         dMaxDepth, dMillDiamTh, dToolLength, bMakeLocSurf, vFace)
+                                                         dMillTotDiam, dMillStemLength, dMillThDiam, dMillThLength, bMakeLocSurf, vFace)
                if not bOk then return bOk, sErr end
             end
          end
@@ -1138,8 +1182,8 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
       i = i + 1
    end
    -- cancello la copia della superfice
-   if nNewProc then
+   if nNewProc.Id then
-      EgtErase( nNewProc)
+      EgtErase( nNewProc.Id)
    end
    return true
 end
@@ -1275,6 +1319,11 @@ local function AddMillings( sMilling, vFace, Proc, nRawId, b3Raw, nConeCut, nAdd
          EgtSetMachiningParam( MCH_MP.INVERT, false)
          -- assegno utilizzo faccia
          EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN)
+         local nEdgeFaceUse = GetEdgeToMachineFromVector( Proc.Id, vFace[i].Fac, Z_AX())
+         if nEdgeFaceUse then
+            local sNoteEdgeFaceUse = 'EdgesFaceUse=' .. EgtNumToString( nEdgeFaceUse)  .. ';'
+            EgtSetMachiningParam( MCH_MP.USERNOTES, sNoteEdgeFaceUse)
+         end
          -- assegno affondamento
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
          -- assegno lato di lavoro
@@ -1428,6 +1477,13 @@ local function AddMillings( sMilling, vFace, Proc, nRawId, b3Raw, nConeCut, nAdd
             EgtSetMachiningParam( MCH_MP.INVERT, false)
             -- assegno utilizzo faccia
             EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN)
+            if #vGeom == 1 then
+               local nEdgeFaceUse = GetEdgeToMachineFromVector( Proc.Id, vGeom[1][2], Z_AX())
+               if nEdgeFaceUse then
+                  local sNoteEdgeFaceUse = 'EdgesFaceUse=' .. EgtNumToString( nEdgeFaceUse)  .. ';'
+                  EgtSetMachiningParam( MCH_MP.USERNOTES, sNoteEdgeFaceUse)
+               end
+            end
             -- assegno affondamento
             EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
             -- assegno lato di lavoro
@@ -1452,6 +1508,13 @@ local function AddMillings( sMilling, vFace, Proc, nRawId, b3Raw, nConeCut, nAdd
             EgtSetMachiningParam( MCH_MP.INVERT, false)
             -- assegno utilizzo faccia
             EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN)
+            if #vGeom == 1 then
+               local nEdgeFaceUse = GetEdgeToMachineFromVector( Proc.Id, vGeom[1][2], Z_AX())
+               if nEdgeFaceUse then
+                  local sNoteEdgeFaceUse = 'EdgesFaceUse=' .. EgtNumToString( nEdgeFaceUse)  .. ';'
+                  EgtSetMachiningParam( MCH_MP.USERNOTES, sNoteEdgeFaceUse)
+               end
+            end
             -- assegno affondamento
 --            EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
             if bNotThrou then
@@ -1486,9 +1549,11 @@ local function AddMillings( sMilling, vFace, Proc, nRawId, b3Raw, nConeCut, nAdd
          end
          --scrivo nell'operazione il vettore somma delle normali alle superfici che servirà per il doppio
          local vtNSum = Vector3d( 0, 0, 0)
-         for iGeom = 1, #vGeom do
+         if Proc.Face and #Proc.Face > 0 then
-            local nFace = vGeom[iGeom][2]
+            for iGeom = 1, #vGeom do
-            vtNSum = vtNSum + Proc.Face[ nFace + 1].VtN
+               local nFace = vGeom[iGeom][2]
+               vtNSum = vtNSum + Proc.Face[ nFace + 1].VtN
+            end
          end
          EgtSetInfo( nMchId or GDB_ID.NULL, 'NORM_SUM', vtNSum)
          -- eseguo
@@ -1543,6 +1608,11 @@ local function AddMillings( sMilling, vFace, Proc, nRawId, b3Raw, nConeCut, nAdd
          EgtSetMachiningParam( MCH_MP.INVERT, false)
          -- assegno utilizzo faccia
          EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN)
+         local nEdgeFaceUse = GetEdgeToMachineFromVector( Proc.Id, vFace[i].Fac, Z_AX())
+         if nEdgeFaceUse then
+            local sNoteEdgeFaceUse = 'EdgesFaceUse=' .. EgtNumToString( nEdgeFaceUse)  .. ';'
+            EgtSetMachiningParam( MCH_MP.USERNOTES, sNoteEdgeFaceUse)
+         end
          -- assegno affondamento
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
          -- assegno lato di lavoro
@@ -1616,8 +1686,14 @@ local function AddSawings( sSawing, vFace, Proc, nRawId, b3Raw)
          end
          -- aggiungo geometria
          EgtSetMachiningGeometry( {{ Proc.Id, vFace[i].Fac}})
+         -- si inverte il percorso, se necessario, per evitare che la sega a catena ruoti contro la traversa
+         local bToInvert = vFace[i].Norm:getX() >= 0.018
+         -- allungamento e accorciamento percorso
          local dSal = - dSawDiam / 2
          local dEal = vFace[i].Whisk - vFace[i].Len - dSawDiam / 2
+         if bToInvert then
+            dSal, dEal = dEal, dSal
+         end
          EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
          EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
          -- assegno utilizzo faccia
@@ -1627,12 +1703,12 @@ local function AddSawings( sSawing, vFace, Proc, nRawId, b3Raw)
          -- assegno affondamento
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
          -- assegno lato di lavoro e inversione direzione movimento
-         if vFace[i].Norm:getX() < 0.018 then 
+         if bToInvert then
-            EgtSetMachiningParam( MCH_MP.INVERT, false)
-            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
-         else
             EgtSetMachiningParam( MCH_MP.INVERT, true)
             EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+         else
+            EgtSetMachiningParam( MCH_MP.INVERT, false)
+            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
          end
          -- posizione braccio porta testa
          EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.NONE)
@@ -1664,11 +1740,17 @@ local function AddSawings( sSawing, vFace, Proc, nRawId, b3Raw)
          end
          -- aggiungo geometria
          EgtSetMachiningGeometry( {{ Proc.Id, vFace[i].Fac}})
+         -- si inverte il percorso, se necessario, per evitare che la sega a catena ruoti contro la traversa
+         local bToInvert = vFace[i].Norm:getX() >= 0.018
+         -- allungamento e accorciamento percorso
          local dSal = - dSawDiam / 2
          local dEal = - dSawDiam / 2
          if ( vFace[i].Type & 2) ~= 0 then
             dSal = vFace[i].Whisk - vFace[i].Len - dSawDiam / 2
          end
+         if bToInvert then
+            dSal, dEal = dEal, dSal
+         end
          EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
          EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
          -- assegno utilizzo faccia
@@ -1678,12 +1760,12 @@ local function AddSawings( sSawing, vFace, Proc, nRawId, b3Raw)
          -- assegno affondamento
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
          -- assegno lato di lavoro e inversione direzione movimento
-         if vFace[i].Norm:getX() < 0.018 then
+         if bToInvert then
-            EgtSetMachiningParam( MCH_MP.INVERT, false)
-            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
-         else
             EgtSetMachiningParam( MCH_MP.INVERT, true)
             EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+         else
+            EgtSetMachiningParam( MCH_MP.INVERT, false)
+            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
          end
          -- posizione braccio porta testa
          EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.NONE)
@@ -1703,13 +1785,13 @@ local function AddSawings( sSawing, vFace, Proc, nRawId, b3Raw)
 end
 
 ---------------------------------------------------------------------
-local function AddCuts( sCutting, vFace, Proc, nRawId, b3Raw, dSawThick)
+local function AddCuts( sCutting, vFace, Proc, nRawId, b3Raw, dSawThick, b3Squaring)
    -- verifico se ciclo chiuso
    local bClosed = ( abs( vFace[1].PrevAng) > 0.1)
    -- ciclo di inserimento dei tagli sulle facce del contorno in esame
    for i = 1, #vFace do
-      -- verifico se faccia da saltare, perchè macchina travi e faccia su bordo longitudinale esterno già finito
+      -- verifico se faccia da saltare, perchè macchina travi e faccia su bordo longitudinale esterno già finito oppure se faccia fuori dal box di squadratura
-      local bToSkip = ( WD.BEAM_MACHINE and IsPointOnRawLongEdges( vFace[i].Cen, b3Raw))
+      local bToSkip = ( WD.BEAM_MACHINE and IsPointOnRawLongEdges( vFace[i].Cen, b3Raw)) or IsFaceOutsideSquaring( Proc, vFace[i], b3Squaring)
       -- se non è faccia da saltare, inserisco il taglio di lama
       if not bToSkip and vFace[i].Type ~= 4 then
          -- indice del successivo
@@ -1839,7 +1921,7 @@ local function AddCuts( sCutting, vFace, Proc, nRawId, b3Raw, dSawThick)
 end
 
 ---------------------------------------------------------------------
-local function MakeByCut( Proc, nRawId, b3Raw)
+local function MakeByCut( Proc, nRawId, b3Raw, b3Squaring)
    local sWarn = ''
    -- ingombro del pezzo
    local Ls = EgtGetFirstNameInGroup( Proc.PartId, 'Box')
@@ -1885,9 +1967,9 @@ local function MakeByCut( Proc, nRawId, b3Raw)
    -- gruppo ausiliario
    local nAddGrpId = WL.GetAddGroup( Proc.PartId) 
    -- recupero i dati di tutte le facce
-   local vFace, dMaxWidth, nNewProc = GetFacesData( Proc, bOpposite, true, dSawDiam, dSawMaxDepth, dSawThick, nAddGrpId, b3Raw, nil)
+   local vFace, dMaxWidth, nNewProc = GetFacesData( Proc, bOpposite, true, dSawDiam, dSawMaxDepth, dSawThick, nAddGrpId, b3Raw)
    -- inserimento dei tagli di lama
-   local bCtOk, sCtErr = AddCuts( sCutting, vFace, Proc, nRawId, b3Raw, dSawThick)
+   local bCtOk, sCtErr = AddCuts( sCutting, vFace, Proc, nRawId, b3Raw, dSawThick, b3Squaring)
    if not bCtOk then return bCtOk, sCtErr end
    -- se richiesta solo lama, esco
    local nCntType = EgtGetInfo( Proc.Id, 'CNT_TYPE', 'i') or 0
@@ -2099,6 +2181,12 @@ local function MakeByMill( Proc, nRawId, b3Raw)
       EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
    elseif ( Proc.Grp == 3 and bToolInv) or ( Proc.Grp == 4 and not bToolInv) then
       EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+   elseif ( Proc.Grp == 1 or Proc.Grp == 2) then
+      if bToolInv then
+         EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+      else
+         EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+      end
    end
 
    -- se lamatura affondata speciale (cliente 90480029), setto attacco e stacco al centro
@@ -2424,7 +2512,7 @@ local function MakeByPocket( Proc, nRawId, b3Raw)
       EgtErase( nAddedBottomSurface)
    end
    if not nFacet then
-      return MakeByMill( Proc, nRawId, b3Raw)
+      return MakeByMill( Proc, nRawId, b3Raw, b3Squaring)
    end
    -- se ho creato la faccia di fondo utilizzo quella
    local nSurfId = nProcTmWithAddedBottomSurfaceId or Proc.Id
@@ -2571,7 +2659,7 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function WPF.Make( Proc, nRawId, b3Raw, vNLO)
+function WPF.Make( Proc, nRawId, b3Raw, vNLO, b3Squaring)
    -- recupero la tipologia (contorno o tasca)
    local bPocket = ( EgtGetInfo( Proc.Id, 'PCKT', 'i') == 1)
    -- se svuotatura
@@ -2583,6 +2671,9 @@ function WPF.Make( Proc, nRawId, b3Raw, vNLO)
       ReorderFaces( Proc.Id, EgtSurfTmFacetCount( Proc.Id))
       -- recupero il tipo di lavorazione
       local nCntType = EgtGetInfo( Proc.Id, 'CNT_TYPE', 'i') or 0
+      if WD.FORCE_MILL_CONTOUR == true then
+         nCntType = 2
+      end
       -- se fresatura
       if nCntType == 2 then
          return MakeByMill( Proc, nRawId, b3Raw)
@@ -2594,7 +2685,7 @@ function WPF.Make( Proc, nRawId, b3Raw, vNLO)
          return MakeByNail( Proc, nRawId, b3Raw, vNLO)
       -- altrimenti, taglio con lama e pulizia angoli con fresa
       else
-         return MakeByCut( Proc, nRawId, b3Raw)
+         return MakeByCut( Proc, nRawId, b3Raw, b3Squaring)
       end
    end
 end

LuaLibs/WProcessSawCut.lua

@@ -29,7 +29,11 @@ function WPSC.Classify( Proc, b3Raw)
    if not AuxId then return false end
    AuxId = AuxId + Proc.Id
    local vtDir = EgtSV( AuxId, GDB_ID.ROOT)
-   return ( vtDir:getZ() > 0.5)
+   local vtDirZ = vtDir:getZ()
+   if Proc.IsThrough then
+      vtDirZ = abs( vtDir:getZ())
+   end
+   return ( vtDirZ > 0.5)
 end
 
 ----------------------------------------------------------------------

LuaLibs/WProcessVariant.lua

@@ -52,6 +52,7 @@ end
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 local function MakeCode_1( Proc, nRawId, b3Raw)
+   local sWarn
    -- recupero e verifico l'entità curva associata
    local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
    if AuxId then 
@@ -63,41 +64,54 @@ local function MakeCode_1( Proc, nRawId, b3Raw)
       return false, sErr
    end
    local vtExtr = EgtCurveExtrusion( AuxId or GDB_ID.NULL, GDB_ID.ROOT)
-   -- recupero la lavorazione
+   -- cerco e applico le lavorazioni di superficie opportune
-   local sSurfFin = WM.FindSurfacing( 'Finishing')
+   local sMachIni = EgtGetCurrMachineDir()..'\\'..EgtGetCurrMachineName()..'.ini'
-   if not sSurfFin then
+   local bSurfRough = ( EgtGetNumberFromIni( 'Machinings', 'SurfRoughing', 0, sMachIni) >= 1)
-      local sErr = 'Error : surface finishing not found in library'
+   local SurfLav = { { Type='Roughing', Name='SurfRou_', Err=true}, { Type='Finishing', Name='SurfFin_', Err=true}}
-      EgtOutLog( sErr)
+   local nStart = EgtIf( bSurfRough, 1, 2)
-      return false, sErr
+   for i = nStart, 2 do
+      -- recupero la lavorazione
+      local sSurfLav = WM.FindSurfacing( SurfLav[i].Type)
+      if not sSurfLav then
+         if SurfLav[i].Err then
+            local sErr = 'Error : surface '.. SurfLav[i].Type .. ' not found in library'
+            EgtOutLog( sErr)
+            return false, sErr
+         else
+            sWarn = 'Warning : surface '.. SurfLav[i].Type .. ' not found in library'
+            EgtOutLog( sWarn)
+         end
+      else
+         -- inserisco la lavorazione di superficie
+         local sName = SurfLav[i].Name .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+         local nMchFId = WM.AddMachining( Proc, sName, sSurfLav)
+         if not nMchFId then
+            local sErr = 'Error adding machining ' .. sName .. '-' .. sSurfLav
+            EgtOutLog( sErr)
+            return false, sErr
+         end
+         EgtSetInfo( nMchFId, 'Part', Proc.PartId)
+         -- se lavorazione di fianco setto la nota per spostarla dopo i tagli di lama
+         if vtExtr:getZ() < WD.NZ_MINA then
+            EgtSetInfo( nMchFId, 'MOVE_AFTER', 1)
+         end
+         -- aggiungo geometria
+         EgtSetMachiningGeometry( {{ Proc.Id, -1},{AuxId, -1}})
+         -- imposto posizione braccio porta testa
+         local nSCC = MCH_SCC.ADIR_ZP
+         if AreSameVectorApprox( vtExtr, Z_AX()) then
+            nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
+         end
+         EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+         -- eseguo
+         if not EgtApplyMachining( true, false) then
+            local _, sErr = EgtGetLastMachMgrError()
+            EgtSetOperationMode( nMchFId, false)
+            return false, sErr
+         end
+      end
    end
-   -- inserisco la lavorazione di finitura superficie
+   return true, sWarn
-   local sName = 'SurfFin_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchFId = WM.AddMachining( Proc, sName, sSurfFin)
-   if not nMchFId then
-      local sErr = 'Error adding machining ' .. sName .. '-' .. sSurfFin
-      EgtOutLog( sErr)
-      return false, sErr
-   end
-   EgtSetInfo( nMchFId, 'Part', Proc.PartId)
-   -- se lavorazione di fianco setto la nota per spostarla dopo i tagli di lama
-   if vtExtr:getZ() < WD.NZ_MINA then
-      EgtSetInfo( nMchFId, 'MOVE_AFTER', 1)
-   end
-   -- aggiungo geometria
-   EgtSetMachiningGeometry( {{ Proc.Id, -1},{AuxId, -1}})
-   -- imposto posizione braccio porta testa
-   local nSCC = MCH_SCC.ADIR_ZP
-   if AreSameVectorApprox( vtExtr, Z_AX()) then
-      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
-   end
-   EgtSetMachiningParam( MCH_MP.SCC, nSCC)
-   -- eseguo
-   if not EgtApplyMachining( true, false) then
-      local _, sErr = EgtGetLastMachMgrError()
-      EgtSetOperationMode( nMchFId, false)
-      return false, sErr
-   end
-   return true
 end
 
 ---------------------------------------------------------------------

LuaLibs/WallExec.lua

@@ -9,6 +9,7 @@
 --            In Collect aggiunto il recupero preliminare di varie informazioni sulla feature.
 -- 2023/12/11 In ClassifyTopology si passa ora anche l'Id del grezzo (allineamento Topology con Beam).
 -- 2024/02/20 Aggiunta gestione DeltaX/Y/Z del pannello dall'origine da BTL.
+-- 2024/08/30 Aggiunta nota altezza sottopezzo, per pareti a layer
 
 -- Tabella per definizione modulo
 local WallExec = {}
@@ -44,6 +45,7 @@ _G.package.loaded.WProcessVariant = nil
 local WM = require( 'WMachiningLib')
 local WL = require( 'WallLib')
 local Topology = require( 'WFeatureTopology')
+local Squaring = require( 'Squaring')
 local Cut = require( 'WProcessCut')
 local DoubleCut = require( 'WProcessDoubleCut')
 local SawCut = require( 'WProcessSawCut')
@@ -56,30 +58,13 @@ local Text = require( 'WProcessText')
 local FreeContour = require( 'WProcessFreeContour')
 local Variant = require( 'WProcessVariant')
 
-
 -------------------------------------------------------------------------------------------------------------
 --    *** Inserimento delle pareti nel pannello ***
 -------------------------------------------------------------------------------------------------------------
-function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewProcess, nRawOutlineId)
+local function GetRawOrigAndDeltas()
-
-   -- Creazione nuovo gruppo di lavoro
-   if not bMachGroupOk then
-      local sMgName = EgtGetMachGroupNewName( 'Mach')
-      local NewMgId = EgtAddMachGroup( sMgName)
-      if not NewMgId then
-         local sOut = 'Errore nella creazione del gruppo di lavoro ' .. sMgName
-         return false, sOut
-      end
-   end
-
-   -- Impostazione della tavola
-   EgtSetTable( 'Tab')
-
    -- Area tavola
    local b3Tab = EgtGetTableArea()
    -- Calcolo posizione estremo di riferimento della tavola rispetto a sua origine in BL
-   local OrigOnTab
-   local nCorner
    local sOrigCorner = WD.ORIG_CORNER or 'BR'
    local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or GDB_ID.NULL
    if WD.GetOrigCorner then
@@ -94,6 +79,8 @@ function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewPr
    local DeltaY = EgtIf( dDeltaYFromBtl > 0, dDeltaYFromBtl, WD.DELTA_Y or 0)
    local DeltaZ = EgtIf( dDeltaZFromBtl > 0, dDeltaZFromBtl, WD.DELTA_Z or 0)
 
+   local nCorner
+   local OrigOnTab
    if sOrigCorner == 'TL' then
       nCorner = MCH_CR.TL
       OrigOnTab = Point3d( 0 + abs( DeltaX), b3Tab:getDimY() - abs( DeltaY), DeltaZ)
@@ -119,6 +106,28 @@ function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewPr
       nCorner = MCH_CR.BL
       OrigOnTab = Point3d( WD.NEW_REF + abs( DeltaX), abs( DeltaY), DeltaZ)
    end
+
+   return sOrigCorner, nCorner, OrigOnTab
+end
+
+-------------------------------------------------------------------------------------------------------------
+function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewProcess, nRawOutlineId)
+
+   -- Creazione nuovo gruppo di lavoro
+   if not bMachGroupOk then
+      local sMgName = EgtGetMachGroupNewName( 'Mach')
+      local NewMgId = EgtAddMachGroup( sMgName)
+      if not NewMgId then
+         local sOut = 'Errore nella creazione del gruppo di lavoro ' .. sMgName
+         return false, sOut
+      end
+   end
+
+   -- Impostazione della tavola
+   EgtSetTable( 'Tab')
+
+   -- Recupero dati posizionamento grezzo
+   local sOrigCorner, nCorner, OrigOnTab = GetRawOrigAndDeltas()
    -- Impostazione dell'attrezzaggio di default
    EgtImportSetup()
    -- Impostazione eventuale allargamento area disponibile per grezzo
@@ -131,6 +140,7 @@ function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewPr
       nRaw = EgtAddRawPart( Point3d( 0, 0, 0), dRawL, dRawW, dRawH, WD.RAWCOL)
    end
    EgtMoveToCornerRawPart( nRaw, OrigOnTab, nCorner)
+   EgtSetInfo( nRaw, 'ORIGCORNER', sOrigCorner)
    EgtSetInfo( nRaw, 'ORD', 1)
    -- Inserimento dei pezzi nel grezzo
    for i = 1, #vWall do
@@ -165,6 +175,7 @@ function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewPr
          end
       else
          local dPosH = EgtIf( vWall[i].PosY < 0.1, ( dRawH - PartHeight) / 2, vWall[i].PosY)
+         EgtSetInfo( nRaw, 'SUBPIECE', dPosH)
          ptPos = Point3d( dRawL - vWall[i].PosX - PartLen, vWall[i].PosZ, dPosH) + vtOffs
       end
       EgtAddPartToRawPart( Pz, ptPos, nRaw)
@@ -172,10 +183,27 @@ function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewPr
    return true
 end
 
+-------------------------------------------------------------------------------------------------------------
+function WallExec.MoveRaw()
+   -- Recupero dati posizionamento grezzo
+   local sOrigCorner, nCorner, OrigOnTab = GetRawOrigAndDeltas()
+   -- Recupero identificativo del grezzo
+   local nRaw = EgtGetFirstRawPart() or GDB_ID.NULL
+   -- Posizione iniziale del centro grezzo
+   local ptOriCen = EgtGetRawPartCenter( nRaw)
+   -- Sposto il grezzo
+   EgtMoveToCornerRawPart( nRaw, OrigOnTab, nCorner)
+   EgtSetInfo( nRaw, 'ORIGCORNER', sOrigCorner)
+   -- Posizione finale del centro grezzo
+   local ptNewCen = EgtGetRawPartCenter( nRaw)
+   -- Restituisco flag di movimento
+   return not AreSamePointApprox( ptOriCen, ptNewCen)
+end
+
 -------------------------------------------------------------------------------------------------------------
 --    *** Inserimento delle lavorazioni nelle pareti ***
 -------------------------------------------------------------------------------------------------------------
-function WallExec.CollectFeatures( PartId, b3Raw)
+function WallExec.CollectFeatures( PartId, b3Raw, b3Squaring)
    -- recupero le feature
    local vProc = {}
    local LayerId = {}
@@ -216,12 +244,22 @@ function WallExec.CollectFeatures( PartId, b3Raw)
                   Proc.DistanceToRawPart = WL.GetProcessDistanceToRawPart( Proc, b3Raw)
                   -- recupero informazioni sulle facce della feature
                   Proc.Face = {}
-                  for i = 1, Proc.Fct do
+                  if Proc.Fct < 50 then
-                     Proc.Face[i] = { Id = i - 1, VtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT ), Elevation = WL.GetFaceElevation( Proc.Id, i - 1, PartId)}
+                     for i = 1, Proc.Fct do
+                        Proc.Face[i] = { Id = i - 1, VtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT ), Elevation = WL.GetFaceElevation( Proc.Id, i - 1, PartId)}
+                     end
                   end
                end
                if Proc.Box and not Proc.Box:isEmpty() then
                   table.insert( vProc, Proc)
+                  -- se squadratura sui pezzi, si annullano le lavorazioni esterne al box di squadratura
+                  if b3Squaring then
+                     local b3SquaringReduced = BBox3d( b3Squaring)
+                     b3SquaringReduced:expand( -0.1)
+                     if not OverlapsXY( Proc.Box, b3SquaringReduced) then
+                        Proc.Flag = 0
+                     end
+                  end
                   -- se foro
                   if Drill.Identify( Proc) then
                      -- assegno diametro e facce di ingresso e uscita (dati tabelle sempre per riferimento)
@@ -290,7 +328,8 @@ local function ClassifyFeatures( vProc, b3Raw)
          if not bOk then Proc.Flg = 0 end
       -- se foratura
       elseif Drill.Identify( Proc) then
-         local bOk = Drill.Classify( Proc, b3Raw)
+         local bUseMultiDrill = WD.USE_MULTI_DRILL or false
+         local bOk = Drill.Classify( Proc, b3Raw, bUseMultiDrill)
          if not bOk then Proc.Flg = 0 end
       -- se mortasatura
       elseif Mortise.Identify( Proc) then
@@ -347,7 +386,7 @@ local function PrintFeatures( vProc)
 end
 
 -------------------------------------------------------------------------------------------------------------
-local function AddFeatureMachining( Proc, nRawId, b3Raw, vNLO)
+local function AddFeatureMachining( Proc, nRawId, b3Raw, vNLO, b3Squaring)
    local bOk = true
    local sErr = ''
    EgtOutLog( ' * Process ' .. tostring( Proc.Id) .. ' *', 1)
@@ -370,7 +409,8 @@ local function AddFeatureMachining( Proc, nRawId, b3Raw, vNLO)
    -- se foratura ( 3/4-040-X)
    elseif Drill.Identify( Proc) then
       -- esecuzione foratura
-      bOk, sErr = Drill.Make( Proc, nRawId, b3Raw)
+      local bUseMultiDrill = WD.USE_MULTI_DRILL or false
+      bOk, sErr = Drill.Make( Proc, nRawId, b3Raw, bUseMultiDrill)
    -- se mortasatura (3/4-050-X) o  similari
    elseif Mortise.Identify( Proc) then
       -- esecuzione mortasatura
@@ -390,7 +430,7 @@ local function AddFeatureMachining( Proc, nRawId, b3Raw, vNLO)
    -- se contorno libero, outline o apertura ( 0/3/4-250/251/252-X)
    elseif FreeContour.Identify( Proc) then
       -- esecuzione contorno libero
-      bOk, sErr = FreeContour.Make( Proc, nRawId, b3Raw, vNLO)
+      bOk, sErr = FreeContour.Make( Proc, nRawId, b3Raw, vNLO, b3Squaring)
    -- se feature custom (Variant)
    elseif Variant.Identify( Proc) then
       -- esecuzione
@@ -485,10 +525,8 @@ local function SortMach( nPhase, PrevMch, nPartId, nType, StartNames, bExistName
       if EgtGetOperationPhase( nOperId) == nPhase  and  ( nType & nOperType) == nOperType and
          ( not nPartId or EgtGetInfo( nOperId, 'Part', 'i') == nPartId) and
          ( not nPriority or EgtGetInfo( nOperId, 'PRIORITY', 'i') == nPriority ) and
-         ( not StartNames or ( bExistName and ContainsStartName( nOperId, StartNames)) or
+         ( not StartNames or ( bExistName and ContainsStartName( nOperId, StartNames)) or ( not bExistName and not ContainsStartName( nOperId, StartNames))) and
-           ( not bExistName and not ContainsStartName( nOperId, StartNames))) and
+         ( not sInfo  or ( bExistInfo and EgtGetInfo( nOperId, sInfo, 'i') == 1) or ( not bExistInfo and EgtGetInfo( nOperId, sInfo, 'i') ~= 1)) then
-         ( not sInfo  or ( bExistInfo and EgtGetInfo( nOperId, sInfo, 'i') == 1) or
-           ( not bExistInfo and EgtGetInfo( nOperId, sInfo, 'i') ~= 1)) then
          -- non si deve cambiare lo stato di attivazione della lavorazione (se disabilitata errata)
          EgtSetCurrMachining( nOperId)
          if not EgtIsMachiningEmpty() then
@@ -523,7 +561,7 @@ local function SortMach( nPhase, PrevMch, nPartId, nType, StartNames, bExistName
    end
    
    if bByTool then
-      function ToolCompare(a,b)
+      local function ToolCompare(a,b)
          if a.ToolType < b.ToolType then
             return true
          elseif a.ToolType == b.ToolType then
@@ -566,7 +604,7 @@ local function SortMach( nPhase, PrevMch, nPartId, nType, StartNames, bExistName
          end
       end
 
-      table.sort(TabCut, ToolCompare)
+      table.sort( TabCut, ToolCompare)
 --      table.sort(TabCut, function(a,b) return a.ToolType < b.ToolType and a.ToolDiam > b.ToolDiam and a.Tool < b.Tool end)
       local SupportTabCut = {}
       local nPrevTUUID = 0
@@ -612,13 +650,15 @@ local function SortMachinings( nPhase, PrevMch, nPartId, nPriority)
    PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_OY.POCKETING, { 'PreDrill_'}, true, nil, nil, nil, nil, nil, nPriority)
    -- Forature e Svuotature
    PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_OY.DRILLING + MCH_OY.POCKETING + MCH_OY.MILLING, { 'SideMill_', 'Clean_'}, false, 'MOVE_AFTER', false, false, true, nil, nPriority)
---   -- Forature  ***
+   -- Forature  ***
---   PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_OY.DRILLING, nil, nil, 'MOVE_AFTER', false)
+   PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_OY.DRILLING, nil, nil, nil, false, nil, true, nil, nil)
 --   -- Svuotature  ***
 --   PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_OY.POCKETING, nil, nil, 'MOVE_AFTER', false)
 --   -- Fresature che sono rifiniture di spigoli
 --   PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_OY.MILLING, { 'Clean_'}, false, 'MOVE_AFTER', false, false, true)
-   -- Lavorazioni di superficie
+   -- Lavorazioni di sgrossatura superficie
+   PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_MY.SURFROUGHING, nil, nil, 'MOVE_AFTER', false, nil, nil, nil, nPriority)
+   -- Lavorazioni di finitura superficie
    PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_MY.SURFFINISHING, nil, nil, 'MOVE_AFTER', false, nil, nil, nil, nPriority)
    -- Fresature per gole
    PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_OY.MILLING, { 'Gorge_'}, true, 'MOVE_AFTER', false, nil, nil, nil, nPriority)
@@ -646,7 +686,9 @@ local function SortMachinings( nPhase, PrevMch, nPartId, nPriority)
       PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_OY.DRILLING, nil, nil, 'MOVE_AFTER', true)
       -- Svuotature che vanno fatte dopo i tagli con lama
       PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_OY.POCKETING, nil, nil, 'MOVE_AFTER', true)
-      -- Lavorazioni di superficie che vanno fatte dopo i tagli con lama
+      -- Lavorazioni di sgrossatura superficie che vanno fatte dopo i tagli con lama
+      PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_MY.SURFROUGHING, nil, nil, 'MOVE_AFTER', true)
+      -- Lavorazioni di finitura superficie che vanno fatte dopo i tagli con lama
       PrevMch = SortMach( nPhase, PrevMch, nPartId, MCH_MY.SURFFINISHING, nil, nil, 'MOVE_AFTER', true)
    end
    return PrevMch
@@ -654,7 +696,7 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 -- setto la rimozione sfridi dopo le lavorazioni di outline
-function InsertScrapRemoval( nPhase)
+local function InsertScrapRemoval( nPhase)
    local nCurrentOperationId = EgtGetNextOperation( EgtGetPhaseDisposition( nPhase))
    local nActiveMachiningId = EgtGetCurrMachining()
    while nCurrentOperationId do
@@ -1073,6 +1115,92 @@ local function SetMirroredOperations()
    end
 end
 
+-------------------------------------------------------------------------------------------------------------
+local function GetFeatureInfoAndDependency( vProc)
+   -- ciclo tutte le feature
+   for i = 1, #vProc do
+      local Proc = vProc[i]
+      -- controllo la feature con tutte le altre per recuperare le dipendenze
+      for j = 1, #vProc do
+         local ProcB = vProc[j]
+         -- se non è la stessa feature
+         if Proc.Id ~= ProcB.Id then
+            -- raggruppamento fori per eventuale Multidrill
+            if WD.USE_MULTI_DRILL and Drill.Identify( Proc) and Proc.Flg ~= 0  and  Drill.Identify( ProcB) and ProcB.Flg ~= 0 then
+               if not Proc.OtherGeometries then
+                  Proc.OtherGeometries = {}
+               end
+               table.insert( Proc.OtherGeometries, ProcB)
+               ProcB.Flg = 0
+               ProcB.bGrouped = true
+            end
+         end
+      end
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function CalculateSquaring( sSquaringTool, RawPart, vPart)
+   local dRawPartHeight = RawPart.b3:getDimZ()
+   local bOk
+   local sMsg = ''
+   local SquaringTools = {}
+   local SquaringParameters = {}
+   local b3Squaring
+
+   SquaringTools = Squaring.GetTools()
+   bOk = Squaring.AreToolsOk( sSquaringTool, SquaringTools, dRawPartHeight)
+   if not bOk then
+      sMsg = 'Squaring failed: cannot find matching tools'
+      return false, {}, nil, sMsg
+   end
+
+   SquaringParameters, b3Squaring = Squaring.CalculateParameters( sSquaringTool, SquaringTools, RawPart, vPart)
+   if not SquaringParameters or next( SquaringParameters) == nil then
+      sMsg = 'Squaring failed: cannot calculate parameters'
+      return false, {}, nil, sMsg
+   end
+
+   return true, SquaringParameters, b3Squaring, sMsg
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function AddSquaring( SquaringParameters, b3Squaring)
+   local nFirstOperationId = EgtGetNextOperation( EgtGetPhaseDisposition( 1))
+   local bOk
+   local sMsg = ''
+   local OperationsId = {}
+
+   bOk, sMsg, OperationsId = Squaring.AddMachinings( SquaringParameters, b3Squaring, nFirstOperationId)
+   if not bOk then
+      for i = 1, #OperationsId do
+         EgtRemoveOperation( i)
+      end
+      sMsg = 'Squaring failed: cannot apply machinings'
+      return false, sMsg
+   end
+
+   -- se presenti altre lavorazioni, prima di queste va eseguita la pulizia sfridi
+   if nFirstOperationId then
+      Squaring.AddScrapRemoval( nFirstOperationId)
+   end
+
+   return true, sMsg
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function AddFeatureStats( Stats, bOk, sMsg, nCutId, nTaskId)
+   if not bOk then
+      table.insert( Stats, {Err=1, Msg=sMsg, Rot=0, CutId = nCutId, TaskId = nTaskId})
+   elseif sMsg and #sMsg > 0 then
+      table.insert( Stats, {Err=-1, Msg=sMsg, Rot=0, CutId = nCutId, TaskId = nTaskId})
+   else
+      table.insert( Stats, {Err=0, Msg='', Rot=0, CutId = nCutId, TaskId = nTaskId})
+   end
+
+   return Stats
+end
+
 -------------------------------------------------------------------------------------------------------------
 function WallExec.ProcessFeatures()
    -- errori e stato
@@ -1090,13 +1218,62 @@ function WallExec.ProcessFeatures()
       table.insert( vPart, {Id=nPartId, Box=b3Solid})
       nPartId = EgtGetNextPartInRawPart( nPartId)
    end
+
+   -- calcolo i parametri della squadratura, se richiesta
+   local SquaringParameters = {}
+   local b3Squaring
+   if WD.SQUARING_TYPE and WD.SQUARING_TYPE > 0 then
+      local RawPart = { nId = nRawId, b3 = b3Raw}
+      local bOk, sMsg
+      if type( WD.SQUARING_TOOL) ~= "number" then
+         WD.SQUARING_TOOL = 0
+      end
+
+      if WD.SQUARING_TOOL == 0 or WD.SQUARING_TOOL == 1 then
+         bOk, SquaringParameters, b3Squaring, sMsg = CalculateSquaring( 'DoubleDiskmill', RawPart, vPart)
+      end
+      if not bOk and ( WD.SQUARING_TOOL == 0 or WD.SQUARING_TOOL == 2) then
+         -- attualmente non gestito, va modificata la configurazione macchina e non si sa se sia gestito in macchina (PLC)
+         bOk = false
+         sMsg = 'Squaring not possible : double blade + diskmill not supported'
+         --SquaringParameters, b3Squaring, sMsg = CalculateSquaring( 'DoubleDiskmillAndBlade', RawPart)
+      end
+      if not bOk and ( WD.SQUARING_TOOL == 0 or WD.SQUARING_TOOL == 3) then
+         bOk, SquaringParameters, b3Squaring, sMsg = CalculateSquaring( 'DoubleBlade', RawPart, vPart)
+      end
+      if not bOk and ( WD.SQUARING_TOOL == 0 or WD.SQUARING_TOOL == 4) then
+         bOk, SquaringParameters, b3Squaring, sMsg = CalculateSquaring( 'Diskmill', RawPart, vPart)
+      end
+      if not bOk and ( WD.SQUARING_TOOL == 0 or WD.SQUARING_TOOL == 5) then
+         bOk, SquaringParameters, b3Squaring, sMsg = CalculateSquaring( 'Blade', RawPart, vPart)
+      end
+      if not bOk and ( WD.SQUARING_TOOL == 0 or WD.SQUARING_TOOL == 6) then
+         bOk, SquaringParameters, b3Squaring, sMsg = CalculateSquaring( 'DoubleMill', RawPart, vPart)
+      end
+      if not bOk and ( WD.SQUARING_TOOL == 0 or WD.SQUARING_TOOL == 7) then
+         bOk, SquaringParameters, b3Squaring, sMsg = CalculateSquaring( 'Mill', RawPart, vPart)
+      end
+
+      -- TODO sostituire con funzione
+      if not bOk then
+         nTotErr = nTotErr + 1
+         table.insert( Stats, {Err=1, Msg=sMsg, Rot=0, CutId=0, TaskId=0})
+      elseif sMsg and #sMsg > 0 then
+         table.insert( Stats, {Err=-1, Msg=sMsg, Rot=0, CutId=0, TaskId=0})
+      else
+         table.insert( Stats, {Err=0, Msg='', Rot=0, CutId=0, TaskId=0})
+      end
+   end
+
    -- raccolgo l'elenco delle feature da lavorare, ciclando sui pezzi
    local vProc = {}
    for i = 1, #vPart do
       -- recupero le feature di lavorazione della parete
-      local vPartProc = WallExec.CollectFeatures( vPart[i].Id, b3Raw)
+      local vPartProc = WallExec.CollectFeatures( vPart[i].Id, b3Raw, b3Squaring)
       vProc = EgtJoinTables( vProc, vPartProc)
    end
+   -- recupero informazioni ausiliarie feature e dipendenze tra feature stesse
+   GetFeatureInfoAndDependency( vProc)
    -- classifico topologicamente le feature
    ClassifyTopology( vProc, nRawId)
    -- classifico le feature
@@ -1121,16 +1298,22 @@ function WallExec.ProcessFeatures()
       -- creo la lavorazione
       local Proc = vProc[i]
       if Proc.Flg ~= 0 then
-         local bOk, sMsg = AddFeatureMachining( Proc, nRawId, b3Raw, vNLO)
+         local bOk, sMsg = AddFeatureMachining( Proc, nRawId, b3Raw, vNLO, b3Squaring)
          if not bOk then
             nTotErr = nTotErr + 1
-            table.insert( Stats, {Err=1, Msg=sMsg, Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
-         elseif sMsg and #sMsg > 0 then
-            table.insert( Stats, {Err=-1, Msg=sMsg, Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
-         else
-            table.insert( Stats, {Err=0, Msg='', Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
          end
-      elseif not Proc.Double and not Proc.LockOut then
+         -- output statistiche feature
+         Stats = AddFeatureStats( Stats, bOk, sMsg, Proc.CutId, Proc.TaskId)
+         -- output statistiche in caso di più feature lavorate nella stessa Proc
+         if Proc.OtherGeometries and #Proc.OtherGeometries > 0 then
+            for j = 1, #Proc.OtherGeometries do
+               Stats = AddFeatureStats( Stats, Proc.OtherGeometries[j].bOk, Proc.OtherGeometries[j].sMsg, Proc.OtherGeometries[j].CutId, Proc.OtherGeometries[j].TaskId)
+               if not Proc.OtherGeometries[j].bOk then
+                  nTotErr = nTotErr + 1
+               end
+            end
+         end
+      elseif not Proc.Double and not Proc.LockOut and not Proc.bGrouped then
          local sMsg = 'Feature not machinable by orientation'
          table.insert( Stats, {Err=1, Msg=sMsg, Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
       end
@@ -1144,7 +1327,7 @@ function WallExec.ProcessFeatures()
       if Proc.Double and Proc.Double > 0 then
          for j = 1, #vProc do
             local ProcMirror = vProc[j]
-            if Proc.Mirror.Id == ProcMirror.Id then
+            if Proc.Mirror and ( Proc.Mirror.Id == ProcMirror.Id) then
                -- per i fori l'operazione si basa sulla geometria ausiliaria
                if Proc.TopologyLongName == 'DRILLING' then
                   local AuxId = EgtGetInfo( ProcMirror.Id, 'AUXID', 'i') or 0
@@ -1221,7 +1404,20 @@ function WallExec.ProcessFeatures()
       end
       -- ordinamento standard
       SortMachinings( nPhase, PrevMch)
+      -- squadratura, se richiesta
+      if SquaringParameters and next( SquaringParameters) ~= nil then
+         local bOk, sMsg = AddSquaring( SquaringParameters, b3Squaring)
 
+         -- TODO sostituire con funzione
+         if not bOk then
+            nTotErr = nTotErr + 1
+            table.insert( Stats, {Err=1, Msg=sMsg, Rot=0, CutId=0, TaskId=0})
+         elseif sMsg and #sMsg > 0 then
+            table.insert( Stats, {Err=-1, Msg=sMsg, Rot=0, CutId=0, TaskId=0})
+         else
+            table.insert( Stats, {Err=0, Msg='', Rot=0, CutId=0, TaskId=0})
+         end
+      end
       -- Aggiornamento finale di tutto
       if nGetPriorityFromBtl > 0 then
          InsertScrapRemoval( nPhase)

LuaLibs/WallLib.lua

@@ -552,5 +552,27 @@ function WallLib.IsFeatureCuttingEntireSection( b3Proc, dRawW, dRawH, dRawL)
    return ( ( ( abs( b3Proc:getDimY() - dRawW) < 10 * GEO.EPS_SMALL or b3Proc:getDimY() > dRawW) or ( abs( b3Proc:getDimX() - dRawL) < 10 * GEO.EPS_SMALL or b3Proc:getDimX() > dRawL)) and (abs(b3Proc:getDimZ() - dRawH) < 10 * GEO.EPS_SMALL or b3Proc:getDimZ() > dRawH))
 end
 
+-------------------------------------------------------------------------------------------------------------
+-- Splitta una tabella in tabelle di dimensioni massima nMaxItemsCount
+function WallLib.SplitTableInChunks( Table, nChunkSize)
+    local Result = {}
+    local Chunk = {}
+
+    for i, v in ipairs( Table) do
+        table.insert( Chunk, v)
+        if #Chunk == nChunkSize then
+            table.insert( Result, Chunk)
+            Chunk = {}
+        end
+    end
+
+    -- se rimangono elementi, li aggiungo
+    if #Chunk > 0 then
+        table.insert( Result, Chunk)
+    end
+
+    return Result
+end
+
 -------------------------------------------------------------------------------------------------------------
 return WallLib

NestFlipAndRotate.lua

@@ -157,9 +157,9 @@ local bManualRot = EgtGetInfo( NFAR.PARTID, "MANUALROT", 'b')
 
 -- FLIP
 local FlipFeatureStates, bLapJoints = ClassifyFlip( vPartProc, b3Part)
+local bFlip
 
 if not bManualFlip then
-   local bFlip
    -- analizzo stati flip delle feature
    local nFlip0Min = 100
    local nFlip0Cnt = 0
@@ -440,7 +440,7 @@ if not bManualRot then
    -- setto info nel pezzo
    if nRotate > 0 then
       local nPartRot = EgtGetInfo( NFAR.PARTID, "ROTATED", 'i') or 0
-      local nTotRot = nPartRot - nRotate
+      local nTotRot = nPartRot - EgtIf( bFlip, -nRotate, nRotate)
       nTotRot = EgtIf( nTotRot < 0, nTotRot + 360, nTotRot)
       EgtSetInfo( NFAR.PARTID, "ROTATED", nTotRot)
       EgtSetInfo( NFAR.PARTID, "FLIPROTMODIFIED", 1)

NestProcess.lua

@@ -18,13 +18,14 @@ NEST.MACH_AREA_USE_OTHER_DIAM = 1  -- 0
 NEST.MACH_AREA_OTHER_DIAM = 200
 NEST.MACH_AREA_IGNORE_3rdFACE = 1  -- 0
 
+if NEST.FLAG ~= 11 then
+   local sLog = 'NestProcess : ' .. NEST.FILE .. ', ' .. NEST.MACHINE .. ', ' .. LEN[1] .. ', ' .. WIDTH[1]
+   EgtOutLog( sLog)
 
-local sLog = 'NestProcess : ' .. NEST.FILE .. ', ' .. NEST.MACHINE .. ', ' .. LEN["1"] .. ', ' .. WIDTH["1"]
+   -- Cancello file di log specifico
-EgtOutLog( sLog)
+   local sLogFile = EgtChangePathExtension( NEST.FILE, '.txt')
-
+   EgtEraseFile( sLogFile)
--- Cancello file di log specifico
+end
-local sLogFile = EgtChangePathExtension( NEST.FILE, '.txt')
-EgtEraseFile( sLogFile) 
 
 -- Imposto direttorio libreria specializzata per Travi
 EgtAddToPackagePath( NEST.BASEDIR .. '\\LuaLibs\\?.lua')
@@ -56,6 +57,8 @@ _G.package.loaded.WProcessDoubleCut = nil
 local DoubleCut = require( 'WProcessDoubleCut')
 _G.package.loaded.WProcessFreeContour = nil
 local FreeContour = require( 'WProcessFreeContour')
+_G.package.loaded.PanelSaw = nil
+local PanelSaw = require( 'PanelSaw')
 
 -- Carico i dati globali
 local WD = require( 'WallData')
@@ -65,6 +68,7 @@ local s_dSideMillDiamDown = WD.SIDEMILL_DIAM_DOWN or 350
 local s_dSideMillDiamUp = WD.SIDEMILL_DIAM_UP or 65
 local s_dHorDrillLen = WD.HOR_DRILL_LEN or 1780
 local s_dHorDrillDiam = WD.HOR_DRILL_DIAM or 35
+local s_dHorDrillDiam5Axes = WD.HOR_DRILL_DIAM_5AX or 0
 local s_sOrigCorner = WD.ORIG_CORNER or 'TL'
 local s_dIntRulli = WD.INTRULLI or 1200
 local s_dMinRawYHorDrill = WD.MINRAWY_HOR_DRILL or 2800
@@ -535,7 +539,7 @@ local function ClassifyDrillsOnLateralFaces( nPartId, dMinSheetWidth)
          if not AuxId  or  EgtGetType( AuxId) ~= GDB_TY.CRV_ARC then break end
          -- verifico se diametro compatibile con la punta
          local dDiam = 2 * EgtArcRadius( AuxId)
-         if abs( dDiam - s_dHorDrillDiam) < WD.DRILL_TOL + GEO.EPS_SMALL then
+         if ( abs( dDiam - s_dHorDrillDiam5Axes) < WD.DRILL_TOL + GEO.EPS_SMALL) or ( abs( dDiam - s_dHorDrillDiam) < WD.DRILL_TOL + GEO.EPS_SMALL) then
             local ptDrill = EgtCP( AuxId, GDB_RT.GLOB)
             local dLen = abs( EgtCurveThickness( AuxId))
             local bLong = dLen > s_dHorDrillLen - 1
@@ -1128,9 +1132,10 @@ local function ClassifyAngles( nPartId, RawPart, sRefOrig, bLockedRot, dMinSheet
    if nRotate >= 360 then
       nRotate = nRotate - 360
    end   
-   if nRotate > 0 then 
+   if nRotate > 0 then
+      local bPartFlip = ( ( EgtGetInfo( nPartId, "INVERTED", 'i') or 0) == 180)
       local nPartRot = EgtGetInfo( nPartId, "ROTATED", 'i') or 0
-      local nTotRot = nPartRot - nRotate
+      local nTotRot = nPartRot - EgtIf( bPartFlip, -nRotate, nRotate)
       nTotRot = EgtIf( nTotRot < 0, nTotRot + 360, nTotRot)  
       EgtSetInfo( nPartId, "ROTATED", nTotRot)
       EgtSetInfo( nPartId, "MODIFIEDFORNEST", 1)
@@ -1325,8 +1330,9 @@ local function ComputeRestrictedZones( RawParts)
                            bOnOppositeSide = true 
                            -- aggiorno le info di rotazione
                            if res.nRotate > 0 then
+                              local bPartFlip = ( ( EgtGetInfo( AngleClassification[nInd].PartId, "INVERTED", 'i') or 0) == 180)
                               local nPartRot = EgtGetInfo( AngleClassification[nInd].PartId, "ROTATED", 'i') or 0
-                              local nTotRot = nPartRot - res.nRotate
+                              local nTotRot = nPartRot - EgtIf( bPartFlip, -res.nRotate, res.nRotate)
                               nTotRot = EgtIf( nTotRot < 0, nTotRot + 360, nTotRot)    
                               EgtSetInfo( AngleClassification[nInd].PartId, "ROTATED", nTotRot)
                               EgtSetInfo( AngleClassification[nInd].PartId, "MODIFIEDFORNEST", 1)
@@ -1507,7 +1513,6 @@ local function AddParts(RawParts, vPartsDoneManually)
          bRotNest = false
       elseif EgtExistsInfo( nPartId, "NestRot") then 
          nStepRotNest = EgtGetInfo( nPartId, "NestStepRot", 'i')
-         nRotate = EgtGetInfo( nPartId, "NestRot", 'i')
          bRotNest = EgtGetInfo( nPartId, "NestAllowRot", 'b')
          -- verifico se rotazione è valida (pezzo è contenuto nel grezzo)
          local bValidRotationInRaw = b3Part:getDimX() < RawParts[1].Len - 2 * NEST.KERF + GEO.EPS_SMALL and b3Part:getDimY() < dRawMaxWidth - 2 * NEST.KERF + GEO.EPS_SMALL
@@ -1628,7 +1633,7 @@ local function AddParts(RawParts, vPartsDoneManually)
       if bOnEdge or bOnAngle then 
          local nBoxLayerId = EgtGetFirstNameInGroup( nPartId, "Box")
          local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
-         local b3Part = EgtGetBBoxGlob(nBoxId, GDB_BB.STANDARD)  
+         local b3Part = EgtGetBBoxGlob(nBoxId, GDB_BB.STANDARD)
          
          -- punto di riferimento sul pezzo
          local ptRef 
@@ -1682,6 +1687,124 @@ NEST.ERR = 0
 -- resetto gruppo di lavorazione corrente
 EgtResetCurrMachGroup()
 
+-- modalità nesting utile per cabinet: un grezzo per ogni pezzo, pezzo centrato nel grezzo. Il grezzo non viene preso da magazzino ma creato ad hoc, con un dato sovramateriale.
+-- il numero del MachGroup deve coincidere con il PDN del pezzo originale
+if NEST.FLAG ~= 11 and WD.ENABLE_SIMPLE_NESTING then
+
+   -- sovramateriale richiesto
+   local dOverMaterial = max( 0, NEST.KERF or 2)
+
+   -- inizializzazione parametri per creazione grezzo tramite BatchProcessNew
+   _G.WALL = {}
+   WALL.FILE = NEST.FILE
+   WALL.MACHINE = NEST.MACHINE
+   WALL.BASEDIR = NEST.BASEDIR
+   WALL.FLAG = 6    -- CREATE_PANEL
+   WALL.NESTING_REF = 'BL'
+
+   -- si ricrea la lista pezzi ordinata
+   local PartList = {}
+   local nPartCounter = 0
+   for nPartId, nCount in pairs( PART) do
+      nPartCounter = nPartCounter + 1
+      PartList[nPartCounter] = {}
+      PartList[nPartCounter].nId = nPartId
+      PartList[nPartCounter].nCount = nCount
+      PartList[nPartCounter].nPdn = EgtGetInfo( nPartId, "PDN", 'i')
+      PartList[nPartCounter].bAddCounterToNaming = false
+      -- se presente un pezzo con multipli il PDN sarà seguito da un contatore
+      if nCount > 1 then
+         PartList[nPartCounter].bAddCounterToNaming = true
+      end
+   end
+   -- si riordina in base al PDN
+   table.sort( PartList, function(a, b) return tonumber( a.nPdn) < tonumber( b.nPdn) end)
+
+   -- per ogni singolo pezzo si chiama la fliprot per avere la migliore orientazione
+   -- si creano duplo e machgroup e si settano le note opportune per poi creare i grezzi richiamando la BatchProcessNew (flag 6)
+   for i = 1, #PartList do
+
+      local nPartId = PartList[i].nId
+      local nPartCount = PartList[i].nCount
+      local nPdn = PartList[i].nPdn
+      local bAddCounterToNaming = PartList[i].bAddCounterToNaming
+
+      -- si ruotano e invertono i pezzi per avere la migliore posizione di lavorazione
+      _G.NFAR = {}
+      NFAR.ERR = 0
+      NFAR.MSG = ''
+      NFAR.PARTID = nPartId
+      NFAR.BASEDIR = NEST.BASEDIR
+      dofile( NEST.BASEDIR .. "\\NestFlipAndRotate.lua")
+
+      -- informazioni dalla parte originale
+      -- box e relative dimensioni
+      local nBoxLayerId = EgtGetFirstNameInGroup( nPartId, "Box")
+      local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
+      local b3Part = EgtGetBBoxGlob( nBoxId, GDB_BB.STANDARD)
+      -- inversione e rotazione
+      local nPartFlip = EgtGetInfo( nPartId, "INVERTED", 'i') or 0
+      local nPartRotation = EgtGetInfo( nPartId, "ROTATED", 'i') or 0
+
+      -- dimensioni grezzo, considerando sovramateriale
+      local dRawLength = b3Part:getDimX() + 2 * dOverMaterial
+      local dRawWidth = b3Part:getDimY() + 2 * dOverMaterial
+
+      for j = 1, nPartCount do
+         -- creazione gruppo di lavoro
+         local sMachGroupName = nPdn
+         if bAddCounterToNaming then
+            sMachGroupName = nPdn .. '_' .. string.format("%02d", j)
+         end
+         local nMachGroupId = EgtAddMachGroup( sMachGroupName)
+         if not nMachGroupId then
+            EgtOutLog( "Errore: MachGroup " .. nPdn .. " già presente")
+            EgtOutBox( 'Error : MachGroup ' .. nPdn .. ' already existing', 'Nesting failed')
+            NEST.ERR = 2
+            return
+         end
+         -- settaggio note in gruppo di lavoro
+         EgtSetInfo( nMachGroupId, "PANELLEN", dRawLength)
+         EgtSetInfo( nMachGroupId, "PANELWIDTH", dRawWidth)
+         EgtSetInfo( nMachGroupId, "MATERIAL", NEST.MATERIAL)
+         EgtSetInfo( nMachGroupId, "PRODID", NEST.PRODID)
+         EgtSetInfo( nMachGroupId, "PATTID", nMachGroupId)
+
+         -- creazione duplo
+         local nPartDuploId = EgtDuploNew( nPartId)
+         -- settaggio note in duplo
+         EgtSetInfo( nMachGroupId, "PART" .. 1, nPartDuploId .. "," .. EgtNumToString( dOverMaterial) .. "," .. EgtNumToString( dOverMaterial) .. "," .. 0 .."," .. 0)
+         EgtSetInfo( nPartDuploId, "POSY", dOverMaterial)
+         EgtSetInfo( nPartDuploId, "POSX", dOverMaterial)
+         EgtSetInfo( nPartDuploId, "FLIP", nPartFlip)
+         EgtSetInfo( nPartDuploId, "ROT", nPartRotation)
+
+         -- creazione grezzi tramite BatchProcessNew
+         EgtSetCurrMachGroup( nMachGroupId)
+         EgtSetInfo( nMachGroupId, "UPDATEUI", 1)
+         dofile( NEST.BASEDIR .. "\\BatchProcessNew.lua")
+      end
+   end
+
+   EgtProcessEvents( 200 + 100, 0)
+   EgtResetCurrMachGroup()
+   EgtOutLog( ' +++ NestProcess completed')
+
+   EgtOutLog( ' +++ Generating Cutting List')
+
+   return
+
+elseif NEST.FLAG == 11 then
+
+   local vCuttingListType = EgtSplitString( WD.PANELSAW_TYPE)
+   for i = 1, #vCuttingListType do
+      local sCuttingListType = vCuttingListType[i]
+      PanelSaw.GenerateCuttingList( sCuttingListType)
+   end
+
+   return
+end
+
 -- inizio nesting automatico
 EgtAutoNestStart()
 
@@ -1690,7 +1813,7 @@ local RawParts = {}
 -- creo tabella dei grezzi
 for sIndex, dLen in pairs( LEN) do
    RawParts[tonumber(sIndex)] = { Len = dLen}
-end 
+end
 for sIndex, dWidth in pairs( WIDTH) do
    RawParts[tonumber(sIndex)].Width = dWidth
 end
@@ -1806,40 +1929,39 @@ if bNestingOk then
                end
             end
             
-         -- aggiungo pezzi nestati a mano
+            -- aggiungo pezzi nestati a mano
-         nPartCount = 0 
+            nPartCount = 0 
-         for nInd = 1, #vDoneManually do
+            for nInd = 1, #vDoneManually do
-            if vDoneManually[nInd].SheetId == nId then
+               if vDoneManually[nInd].SheetId == nId then
-               vDoneManually[nInd].Done = 1 
+                  vDoneManually[nInd].Done = 1 
-               for nInd2 = 1, #(vDoneManually[nInd].Parts) do
+                  for nInd2 = 1, #(vDoneManually[nInd].Parts) do
-                  nPartCount = nPartCount + 1
+                     nPartCount = nPartCount + 1
-                  local nPartDuploId = EgtDuploNew( vDoneManually[nInd].Parts[nInd2].Id)  
+                     local nPartDuploId = EgtDuploNew( vDoneManually[nInd].Parts[nInd2].Id)  
-                  
+                     
-                  -- aggiungo le curve corrispondenti alle aree di lavorazione del pezzo 
+                     -- aggiungo le curve corrispondenti alle aree di lavorazione del pezzo 
-                  local sToolOutlines = EgtGetInfo( vDoneManually[nInd].Parts[nInd2].Id, "ToolOutlines", 's')
+                     local sToolOutlines = EgtGetInfo( vDoneManually[nInd].Parts[nInd2].Id, "ToolOutlines", 's')
-                  if sToolOutlines then 
+                     if sToolOutlines then 
-                     -- recupero o creo il gruppo per gli outlines
+                        -- recupero o creo il gruppo per gli outlines
-                     local nToolOutlinesGrp = EgtGetFirstNameInGroup( nPartDuploId, "ToolOutlines")
+                        local nToolOutlinesGrp = EgtGetFirstNameInGroup( nPartDuploId, "ToolOutlines")
-                     if not nToolOutlinesGrp then
+                        if not nToolOutlinesGrp then
-                        nToolOutlinesGrp = EgtGroup( nPartDuploId)
+                           nToolOutlinesGrp = EgtGroup( nPartDuploId)
-                        EgtSetName( nToolOutlinesGrp, "ToolOutlines")
+                           EgtSetName( nToolOutlinesGrp, "ToolOutlines")
-                        EgtSetStatus( nToolOutlinesGrp, GDB_ST.ON)
+                           EgtSetStatus( nToolOutlinesGrp, GDB_ST.ON)
-                     end
+                        end
-                  
+                     
-                     for str in string.gmatch(sToolOutlines, "([^"..",".."]+)") do 
+                        for str in string.gmatch(sToolOutlines, "([^"..",".."]+)") do 
-                        EgtCopyGlob( tonumber(str), nToolOutlinesGrp)
+                           EgtCopyGlob( tonumber(str), nToolOutlinesGrp)
+                        end
                      end
+                     
+                     -- applico flip, rotazione e traslazione pezzo e box da nesting
+                     EgtSetInfo( nMachGroup, "PART" .. nPartCount, nPartDuploId .. "," .. EgtNumToString( vDoneManually[nInd].Parts[nInd2].posX, 3) .. "," .. EgtNumToString( vDoneManually[nInd].Parts[nInd2].posY, 3) .. "," .. 0 .."," .. 0)
+                     EgtSetInfo( nPartDuploId, "POSX", vDoneManually[nInd].Parts[nInd2].posX)
+                     EgtSetInfo( nPartDuploId, "POSY", vDoneManually[nInd].Parts[nInd2].posY)
                   end
-                  
-                  -- applico flip, rotazione e traslazione pezzo e box da nesting
-                  EgtSetInfo( nMachGroup, "PART" .. nPartCount, nPartDuploId .. "," .. EgtNumToString( vDoneManually[nInd].Parts[nInd2].posX, 3) .. "," .. EgtNumToString( vDoneManually[nInd].Parts[nInd2].posY, 3) .. "," .. 0 .."," .. 0)
-                  EgtSetInfo( nPartDuploId, "POSX", vDoneManually[nInd].Parts[nInd2].posX)
-                  EgtSetInfo( nPartDuploId, "POSY", vDoneManually[nInd].Parts[nInd2].posY)
                end
             end
          end
-         
-      end
       
       -- altrimenti pezzo 
       else
@@ -1884,15 +2006,21 @@ if bNestingOk then
                EgtSetInfo( nPartDuploId, "POSX", ptPos:getX() + dXCorr)
                EgtSetInfo( nPartDuploId, "POSY", ptPos:getY() + dYCorr)
                
-               local nPartRot = EgtGetInfo( nId, "ROTATED", 'i') or 0
+               local nPartFlip = EgtGetInfo( nId, "INVERTED", 'i') or 0
-               local nTotRot = dAngRot - nPartRot
-               nTotRot = EgtIf( nTotRot < 0, nTotRot + 360, nTotRot)
-               EgtSetInfo( nPartDuploId, "ROT", nTotRot)
-               
-               local nPartFlip = EgtGetInfo( nId, "INVERTED", 'i')
                nPartFlip = EgtIf( nPartFlip == 180, 1, 0)
                local nTotFlip = EgtIf( nPartFlip ~= nFlag, 180, 0)
                EgtSetInfo( nPartDuploId, "FLIP", nTotFlip)
+               
+               local bPartFlip = ( nTotFlip == 180)
+               local nPartRot = EgtGetInfo( nId, "ROTATED", 'i') or 0
+               local nTotRot = nPartRot - EgtIf( bPartFlip, -dAngRot, dAngRot)
+               if nTotRot < 0 then
+                  nTotRot = nTotRot + 360
+               elseif nTotRot >= 360 then
+                  nTotRot = nTotRot - 360
+               end
+               EgtSetInfo( nPartDuploId, "ROT", nTotRot)
+            
             end
          end
       end

Process.lua

@@ -1,4 +1,4 @@
--- Process.lua by Egaltech s.r.l. 2022/05/09
+-- Process.lua by Egaltech s.r.l. 2026/03/30
 -- Gestione calcolo disposizione e lavorazioni per Pareti
 -- Si opera sulla macchina corrente
 -- 2020/12/09 Come per BatchProcess.lua si gestiscono anche rotazioni di inversione con valori negativi.
@@ -108,6 +108,10 @@ local function MyProcessInputData()
 
    -- Recupero informazione se progetto o produzione
    local bProj = ( EgtGetInfo( EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or GDB_ID.NULL, 'PROJECT', 'i') == 1)
+   
+   -- Verifico se progetto deriva da BeamWall
+   local _, _, sExt = EgtSplitPath( EgtGetCurrFilePath() or '')
+   local bBwProj = ( ( string.upper( sExt or '') == '.BWE'))
 
    -- Eseguo eventuali rotazioni e inversioni testa-coda
    for i = 1, #vWall do
@@ -115,7 +119,7 @@ local function MyProcessInputData()
       -- rotazione
       local dRotAng = EgtGetInfo( vWall[i].Id, 'ROTATED', 'd')
       if dRotAng then
-         if abs( dRotAng) > GEO.EPS_ANG_SMALL and not EgtExistsInfo( vWall[i].Id, 'ROTATED_DONE') then
+         if abs( dRotAng) > GEO.EPS_ANG_SMALL and not bBwProj and not EgtExistsInfo( vWall[i].Id, 'ROTATED_DONE') then
             local ptRotCen = b3Solid:getCenter()
             EgtRotate( vWall[i].Id, ptRotCen, X_AX(), dRotAng, GDB_RT.GLOB)
             b3Solid:rotate( ptRotCen, X_AX(), dRotAng)
@@ -125,7 +129,7 @@ local function MyProcessInputData()
       -- inversione
       local dInvAng = EgtGetInfo( vWall[i].Id, 'INVERTED', 'd')
       if dInvAng then
-         if abs( dInvAng - 180) > GEO.EPS_ANG_SMALL and abs( dInvAng + 180) > GEO.EPS_ANG_SMALL and not EgtExistsInfo( vWall[i].Id, 'INVERTED_DONE') then
+         if abs( dInvAng - 180) > GEO.EPS_ANG_SMALL and abs( dInvAng + 180) > GEO.EPS_ANG_SMALL and not bBwProj and not EgtExistsInfo( vWall[i].Id, 'INVERTED_DONE') then
             local ptInvCen = b3Solid:getCenter()
             EgtRotate( vWall[i].Id, ptInvCen, Z_AX(), dInvAng - 180, GDB_RT.GLOB)
             b3Solid:rotate( ptInvCen, Z_AX(), dInvAng - 180)
@@ -134,7 +138,7 @@ local function MyProcessInputData()
       end
       -- correzioni per rotazioni non centrate di produzioni TS3 (quasi sempre multipli di 90 deg)
       local sType = EgtGetInfo( vWall[i].Id, 'TYPE', 's')
-      if not bProj and dRotAng and dInvAng and sType ~= 'LAYER' then
+      if not bProj and not bBwProj and dRotAng and dInvAng and sType ~= 'LAYER' then
          if abs( dInvAng - 0) < GEO.EPS_ANG_SMALL then
             if abs( dRotAng - 180) < GEO.EPS_ANG_SMALL then
                vWall[i].PosZ = vWall[i].PosZ - vWall[i].Box:getDimY()

UpdateLog.txt

@@ -1,5 +1,130 @@
            ==== Wall Update Log ====
 
+Versione 3.1d2 (23/04/2026)
+- Modif : Tutte le forature vengono ordinate per diametro decrescente
+
+Versione 3.1d1 (08/04/2026)
+- Modif : in LapJoint, svuotature, l'uscita dalla geometria viene limitata della massima quantità che non rovina il pezzo vicino
+- Fixed : correzione per chiodature
+
+Versione 3.1c1 (02/04/2026)
+- Added : in CleanCorner si gestiscono angoli diversi da 30
+- Fixed : in puliture con sega a catena corrett scelta errata del lato
+
+Versione 2.7k1 (20/11/2025)
+- Modif : in LapJoint con Q08=1 ora si fanno con milling anche tasche a L cieche da sopra
+- Fixed : in LapJoint correzione alle lavorazioni inclinate
+
+Versione 2.7j2 (21/10/2025)
+- Modif : in LapJoint i percorsi dei truciolatori sono sempre in concordanza a meno di forzature con apposito flag macchina
+- Modif : in PanelSaw migliorata l'esportazione Cutty
+
+Versione 2.7j1 (08/10/2025)
+- Added : in PanelSaw si gestiscono le esportazioni Homag
+- Added : in PanelSaw si gestisce la direzione fibra
+- Modif : in PanelSaw migliorata l'esportazione Cutty
+
+Versione 2.7i2 (18/09/2025)
+- Modif : in PanelSaw gestione campi a lunghezza fissa
+
+Versione 2.7i1 (16/09/2025)
+- Added : per cabinet aggiunta esportazione cutting list e modalità nesting semplice
+
+Versione 2.7h1 (06/08/2025)
+- Modif : in LapJoint migliorata scelta lavorazione in caso di feature piccola
+
+Versione 2.7g3 (24/07/2025)
+- Fixed : in Lapjoint corretto step in caso due facce verso l'alto
+
+Versione 2.7g2 (17/07/2025)
+- Added : aggiunta gestione origine e offset da questa che non fanno riprocessare l'intero grezzo (ma solo aggiornare)
+- Fixed : corretta BatchProcess per nome file anche se da non riprocessare.
+
+Versione 2.7g1 (09/07/2025)
+- Fixed : in FreeContour corretta scelta del lato da lavorare in caso si abbiano lati inclinati
+
+Versione 2.7f2 (06/06/2025)
+- Fixed : in Lapjoint migliorie alle svuotature
+
+Versione 2.7f1 (05/06/2025)
+- Added : gestita forzatura freecontour di fresa per macchine senza lama (costante WallData FORCE_MILL_CONTOUR)
+- Modif : migliorata DoubleCut
+- Fixed : corretta BatchProcess per caso in cui il nome del file cnc generato non era corretto
+
+Versione 2.7d1 (14/04/2025)
+- Added : in DoubleCut aggiunta Q06 per forzare utilizzo lama
+
+Versione 2.7b1 (03/03/2025)
+- Added : gestione multidrill
+
+Versione 2.7a2 (23/01/2025)
+- Fixed : in Ts7 corretto un problema che portava a rotazioni errate, introdotto con 2.7a1
+- Fixed : in squadratura piccole correzioni
+
+Versione 2.7a1 (21/01/2025)
+- Modif : in Ts7 aggiunta scrittura id progetto e produzione in Btm
+
+Versione 2.6l1 (11/12/2024)
+- Modif : modificato il calcolo feature passante per gorge
+- Modif : in pulizia spigoli si riporta correttamente la collisione sulla feature specifica
+- Fixed : in pulizia spigoli correzioni varie
+- Fixed : in LapJoint correzioni varie
+
+Versione 2.6k3 (27/11/2024)
+- Modif : migliorato calcolo approccio e retrazione in Sidemill/Sidegroove
+
+Versione 2.6k2 (19/11/2024)
+- Modif : in Nesting riportata allo stato precedente la tolleranza posizionamento pannelli sul bordo
+
+Versione 2.6k1 (14/11/2024)
+- Added : aggiunta squadratura master panel
+- Modif : L010 si inseriscono con lama anche se il percorso è breve
+- Fixed : in Nesting corretto errore in posizionamento pannelli che devono stare necessariamente sul bordo della tavola
+
+Versione 2.6j2 (04/11/2024)
+- Modif : Modificato limite dimensione tasca per utilizzo lama come SideGroove
+
+Versione 2.6j1 (29/10/2024)
+- Fixed : in Nesting e Flip/Rot corretto problema in rotazione pezzi che causava ribaltamenti non voluti nella copia grezzo
+
+Versione 2.6i2 (30/09/2024)
+- Modif : aggiunta nota altezza sottopezzo, per pareti a layer
+
+Versione 2.6i1 (25/09/2024)
+- Fixed : in NestProcess correzione in lettura array per cambio dll di lettura
+
+Versione 2.6h2 (28/08/2024)
+- Modif : Aggiunto controllo licenza/chiave per abilitazione generazione PartProgram
+- Fixed : in FreeContour corretto caso in cui si chiedevano informazioni sulla faccia non presenti.
+
+Versione 2.6h1 (20/08/2024)
+- Modif : in LapJoint, se fresa Side trovata ma non applicabile, si considera come se non trovata
+- Modif : in Collect analisi facce limitata a feature che ne hanno meno di 50
+- Modif : aggiunti nuovi parametri alla chiamata della funzione GetChainSawStartAngs da WallData della macchina
+
+Versione 2.6g2 (19/07/2024)
+- Modif : in BatchProcess e BatchProcessNew si forza ricalcolo ogni volta che si è in situazione di CHECK o CHECK + GENERATE
+
+Versione 2.6g1 (17/07/2024)
+- Modif : in ProcessDrill, se foro verticale passante e diametro inferiore a 100 mm, riduzione affondamento di 5 mm sostituito con tab
+- Fixed : correzioni a utilizzo DEFAULT_RAW_NO_EXTRA_WIDTH
+
+Versione 2.6f1 (21/06/2024)
+- Added : in BatchProcess e BatchProcessNew aggiunto DEFAULT_RAW_NO_EXTRA_WIDTH per eliminare il sovramateriale grezzo in vista
+
+Versione 2.6e2 (24/05/2024)
+- Modif : in LapJoint se non si trova una lavorazione di tipo side si cerca una pocketing
+- Fixed : in BatchProcessNew se generazione non abilitata si salta questa fase invece di restituire errore
+- Fixed : piccoli errori in LapJoint e DoubleCut.
+
+Versione 2.6e1 (03/03/5/2024)
+- Fixed : correzione per assegnazione a SawCut di flag passante (bIsThrough).
+
+Versione 2.6c3 (26/03/2024)
+- Modif : modifica per richiamare le nuove funzioni di Test interferenza solidi superfici nel controllo validità lavorazione pulizia spigoli interni
+- Modif : in compilazione vengono eliminate le info di debug
+- Fixed : in processSawCut si ignora verso vettore se taglio passante.
+
 Versione 2.6b2 (21/02/2024)
 - Added : aggiunta gestione spostamento pannello rispetto a origine da dato BTL di TS3v7.
 

Version.lua

@@ -1,6 +1,6 @@
--- Version.lua by Egalware s.r.l. 2024/02/20
+-- Version.lua by Egalware s.r.l. 2026/03/30
 -- Gestione della versione di Wall
 
 NAME = 'Wall'
-VERSION = '2.6b2'
+VERSION = '3.1d2'
-MIN_EXE = '2.5b3'
+MIN_EXE = '3.1c1'