update compile

- in PanelSaw modificato il nome del file esportato

Compile.bat

@@ -4,6 +4,7 @@ REM Per togliere info di debug aggiungere flag -s prima del nome del file di inp
 
 REM Compilazione 32 e 64 bit
 
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\PanelSaw.lua                   -s LuaLibs\PanelSaw.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\Squaring.lua                   -s LuaLibs\Squaring.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\WallExec.lua                   -s LuaLibs\WallExec.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\WallLib.lua                    -s LuaLibs\WallLib.lua

LuaLibs/PanelSaw.lua

@@ -0,0 +1,343 @@
+-- PanelSaw.lua by Egalware s.r.l. 2025/09/02
+-- Creazione lista taglio e/o programmi di taglio per sezionatrici
+
+-- Intestazioni
+require( 'EgtBase')
+
+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'
+      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')
+      -- 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 aggiungere labeling, edgebanding, graindirection, ...
+
+      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 = EgtGetInfo( idBtlInfo, 'PROJECTNAME', 's') or ''
+
+   return ProjectInfo
+end
+
+
+local function BuildCuttingList_Cutty( PanelList, SheetList, ProjectInfo)
+
+   local Lines = {}
+
+   local F0 = {
+      Header = { 'F0'},
+      HeaderPlaceholders = { '%s'},
+      Values = { ' 7.70', '210700', '150300'},
+      ValuesPlaceholders = { '%s', '%s', '%s'}
+   }
+
+   local F0b = {
+      Header = { 'F0b', '""', '""', '""', '""'},
+      HeaderPlaceholders = { '%s', '%s', '%s', '%s', '%s'}
+   }
+
+   local F1 = {
+      Header = { 'F1', PanelList[1].dThickness, 0, 0, 0},
+      HeaderPlaceholders = { '%s', '%.3f', '%.3f', '%.3f', '%.3f'},
+      ValuesList = {},
+      ValuesPlaceholders = { '%.3f', '%.3f', '%d', '%d', '%d', '%d', '%d', '%.3f', '%d', '%d', '%d', '%d'}
+   }
+   for i = 1, #SheetList do
+      F1.ValuesList[i] = { SheetList[i].dLength, SheetList[i].dWidth, 99, 200, 1, 1, 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', '%s', '%d', '%d', '%d', '%d', '%d', '%d', '%d', '%d', '%d', '%d', '%.3f', '%d', '%d', '%d', '%.3f', '%.3f'}
+   }
+   for i = 1, #PanelList do
+      F2.ValuesList[i] = { PanelList[i].dLength, PanelList[i].dWidth, PanelList[i].nQuantity, 0, 0, 0, 0, PanelList[i].nPdn, 0, 0, 0, 0, 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, '')
+
+   return Lines
+end
+
+
+local function BuildCuttingList( PanelList, sOutputType)
+
+   local LinesToWrite = {}
+   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
+         }
+      end
+   end
+
+   -- Casadei
+   if sOutputType == 'CUTTY' then
+
+      LinesToWrite = BuildCuttingList_Cutty( PanelList, ActualSheetList, ProjectInfo)
+      
+   -- Homag Optimat
+   elseif sOutputType == 'HOMAG' then
+
+
+   end
+
+   return LinesToWrite
+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 LinesToWrite = BuildCuttingList( PanelListSingleMaterial, sOutputType)
+         
+         -- scrittura file
+         local sFilename = sCurrentNgePath .. 'CutList-' .. sCurrentNgeName .. '-' .. key .. '.' .. sOutputType
+         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( LinesToWrite, "\n"))
+         hFile:close()
+
+      -- se nessun tipo si deve scrivere un json semplice
+      else
+
+      end
+   end
+
+   return
+end
+
+
+return PanelSaw

LuaLibs/WProcessLapJoint.lua

@@ -2020,11 +2020,13 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
          dStepOri = dStep
          if dStep < GEO.EPS_SMALL then dStep = 0.75 * dMaxMat end
          local nStep = ceil( ( dThick - dMaxMat) / dStep)
-         dStep = max( ( dThick - dMaxMat) / max( nStep, 1), 0)
-         local dMaxElev = max( ( nStep + 1) * dStep - GEO.EPS_SMALL, 0)
-         -- tasca aperta sopra non necessita di MaxElev
+         local dMaxElev
+         -- tasca aperta sopra non necessita di MaxElev e mantiene lo step originale
          if Proc.Fct == 2 and Proc.AffectedFaces.Top then
             dMaxElev = nil
+         else
+            dStep = max( ( dThick - dMaxMat) / max( nStep, 1), 0)
+            dMaxElev = max( ( nStep + 1) * dStep - GEO.EPS_SMALL, 0)
          end
          if nSinglePass and nSinglePass > 0 then
             dStep = 0
@@ -2893,7 +2895,7 @@ local function MakeMoreFaces( Proc, nRawId, b3Raw)
       local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
       local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
       local dMaxSlotThicknessForBlade = 19
-      local bIsSmallSlot = ( Proc.Fct == 3 and ( min( dH, dV) < dMaxSlotThicknessForBlade - 10 * GEO.EPS_SMALL) and ( vtN:getZ() > -0.01) and ( vtN:getZ() < 0.5))
+      local bIsSmallSlot = ( Proc.Fct == 3 and ( min( dH, dV) < dMaxSlotThicknessForBlade - 10 * GEO.EPS_SMALL) and ( vtN:getZ() > -0.01))
       -- se di fianco
       if not bPckt and Proc.Fct >= 3 and ( ( vtN:getZ() < WD.NZ_MINA) or bIsSmallSlot) then
          -- recupero elevazione faccia in feature
@@ -2997,12 +2999,25 @@ local function MakeMoreFaces( Proc, nRawId, b3Raw)
                   end
                end
             end
+
+            -- si tenta sidemill
             if sMilling and dElev < dMaxDepthOnSide then
                return MakeSideGrooveByMill( Proc, nFacInd, nRawId, b3Raw, sMilling, nil, nil, nil, nil, nil, nil, nil, bDoubleMillOnSide)
-            -- altrimenti sega a catena
-            else
-               return MakeByChainSaw( Proc, nFacInd, nRawId, b3Raw, dElev, dH, dV)
             end
+            -- sidemill non possibile: si tenta sega a catena
+            local bOk, sErr = MakeByChainSaw( Proc, nFacInd, nRawId, b3Raw, dElev, dH, dV)
+            if bOk then
+               return bOk, sErr
+            end
+            -- sega a catena fallisce: se possibile si prova con svuotatura
+            local nFacet = EgtIf( bPckt or vtN:getZ() >= WD.NZ_MINA, nFacInd, nFacInd2)
+            if nFacet then
+               return MakeByPocketing( Proc, nFacet, nRawId, b3Raw, true)
+            end
+            -- se nessuna strategia è riuscita, si ritorna errore
+            sErr = 'Side milling not possible'
+            EgtOutLog( sErr)
+            return false, sErr
          end
       end
       local nFacet = EgtIf( bPckt or vtN:getZ() >= WD.NZ_MINA, nFacInd, nFacInd2)

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]
-EgtOutLog( sLog)
-
--- Cancello file di log specifico
-local sLogFile = EgtChangePathExtension( NEST.FILE, '.txt')
-EgtEraseFile( sLogFile) 
+   -- Cancello file di log specifico
+   local sLogFile = EgtChangePathExtension( NEST.FILE, '.txt')
+   EgtEraseFile( sLogFile)
+end
 
 -- 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
@@ -1683,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()
 
@@ -1691,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

UpdateLog.txt

@@ -1,5 +1,14 @@
            ==== Wall Update Log ====
 
+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.

Version.lua

@@ -2,5 +2,5 @@
 -- Gestione della versione di Wall
 
 NAME = 'Wall'
-VERSION = '2.7g2'
+VERSION = '2.7i1'
 MIN_EXE = '2.7f2'