- in LapJoint -> CalcInterference ora si usano le stesse funzioni della FreeContour

- in FreeContour eLapJoint ->CleanCorner si scrivono ora TASKID e CUTID per riportare le collisioni sulla feature specifica
- in LapJoint modifica al calcolo feature passante per gorge
2024-12-02 18:11:47 +01:00 · 2024-12-02 11:47:48 +01:00 · 2024-11-29 17:52:11 +01:00 · 2024-11-29 17:21:17 +01:00 · 2024-11-27 17:45:13 +01:00 · 2024-11-27 17:44:49 +01:00
17 changed files with 975 additions and 211 deletions
@@ -24,14 +24,14 @@ variables:
    $FileList = Get-ChildItem("*.lua")
    ForEach ($File in $FileList) {
      $FileName = Split-Path $File -leaf
-      lua54 -o bin\$FileName $FileName
-      echo "lua54 -o bin\$FileName $FileName"
+      lua54 -o bin\$FileName -s $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
-      echo "lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName"
+      lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName
+      echo "lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName"
    }

 # helper copia SORGENTI verso cartella di rete X:\ dei SORGENTI
@@ -233,6 +233,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 +280,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 +292,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 +372,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
@@ -498,7 +511,7 @@ else
   -- Passo in modalità lavora
   EgtSetCurrMachGroup( EgtGetLastMachGroup())
   -- 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 +575,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
@@ -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
-         dPanelWidth = math.max( vWall[1].Box:getDimY() + 20, dMinY)
+         local dExtraW = 10
+         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].PosZ = 10
+         vWall[1].PosX = dExtraW
+         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
@@ -1,30 +1,31 @@

-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\WallLib.lua                       LuaLibs\WallLib.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WMachiningLib.lua                 LuaLibs\WMachiningLib.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessCut.lua                   LuaLibs\WProcessCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDoubleCut.lua             LuaLibs\WProcessDoubleCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDrill.lua                 LuaLibs\WProcessDrill.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDtMortise.lua             LuaLibs\WProcessDtMortise.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WFeatureTopology.lua              LuaLibs\WFeatureTopology.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessFreeContour.lua           LuaLibs\WProcessFreeContour.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessLapJoint.lua              LuaLibs\WProcessLapJoint.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessMark.lua                  LuaLibs\WProcessMark.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessMortise.lua               LuaLibs\WProcessMortise.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessSawCut.lua                LuaLibs\WProcessSawCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessText.lua                  LuaLibs\WProcessText.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessVariant.lua               LuaLibs\WProcessVariant.lua
-\EgtProg\Dll32\luac54 -o bin\BatchProcess.lua                          BatchProcess.lua
-\EgtProg\Dll32\luac54 -o bin\BatchProcessNew.lua                       BatchProcessNew.lua
-\EgtProg\Dll32\luac54 -o bin\GetWallData.lua                           GetWallData.lua
-\EgtProg\Dll32\luac54 -o bin\NestFlipAndRotate.lua                     NestFlipAndRotate.lua
-\EgtProg\Dll32\luac54 -o bin\NestProcess.lua                           NestProcess.lua
-\EgtProg\Dll32\luac54 -o bin\Overturn.lua                              Overturn.lua
-\EgtProg\Dll32\luac54 -o bin\Process.lua                               Process.lua
-\EgtProg\Dll32\luac54 -o bin\Rotate.lua                                Rotate.lua
-\EgtProg\Dll32\luac54 -o bin\Version.lua                               Version.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
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WMachiningLib.lua              -s LuaLibs\WMachiningLib.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessCut.lua                -s LuaLibs\WProcessCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDoubleCut.lua          -s LuaLibs\WProcessDoubleCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDrill.lua              -s LuaLibs\WProcessDrill.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDtMortise.lua          -s LuaLibs\WProcessDtMortise.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WFeatureTopology.lua           -s LuaLibs\WFeatureTopology.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessFreeContour.lua        -s LuaLibs\WProcessFreeContour.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessLapJoint.lua           -s LuaLibs\WProcessLapJoint.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessMark.lua               -s LuaLibs\WProcessMark.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessMortise.lua            -s LuaLibs\WProcessMortise.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessSawCut.lua             -s LuaLibs\WProcessSawCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessText.lua               -s LuaLibs\WProcessText.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessVariant.lua            -s LuaLibs\WProcessVariant.lua
+\EgtProg\Dll32\luac54 -o bin\BatchProcess.lua                       -s BatchProcess.lua
+\EgtProg\Dll32\luac54 -o bin\BatchProcessNew.lua                    -s BatchProcessNew.lua
+\EgtProg\Dll32\luac54 -o bin\GetWallData.lua                        -s GetWallData.lua
+\EgtProg\Dll32\luac54 -o bin\NestFlipAndRotate.lua                  -s NestFlipAndRotate.lua
+\EgtProg\Dll32\luac54 -o bin\NestProcess.lua                        -s NestProcess.lua
+\EgtProg\Dll32\luac54 -o bin\Overturn.lua                           -s Overturn.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
@@ -0,0 +1,491 @@
+-- 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)
+         EgtRelocateGlob( nOperationId, nFirstOperationId, GDB_IN.BEFORE)
+         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
@@ -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
@@ -266,5 +266,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
@@ -66,9 +66,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,
-                     Diam = Proc.Diam, Fcs = Proc.Fcs, Fce = Proc.Fce, CutId = Proc.CutId, TaskId = Proc.TaskId}
-   return LapJoint.Make( LapProc, nRawId, b3Raw)
+   Proc.Grp = Proc.Grp + 2
+   return LapJoint.Make( Proc, nRawId, b3Raw)
 end

 ---------------------------------------------------------------------
@@ -324,32 +324,41 @@ function WPD.Make( Proc, nRawId, b3Raw)
   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
-         dReduceDepth = 5
-         -- se inclinato e passante
-         if abs( vtExtr:getZ()) >= WD.DRILL_VZ_MIN and abs( vtExtr:getZ()) < 0.999  and Proc.Fcs > 0 and Proc.Fce > 0 then
-            -- gruppo ausiliario per preforo
-            local nAddGrpId = WL.GetAddGroup( Proc.PartId)
-            -- ricavo contorno inferiore della superficie
-            local nAngledCircleId, nAngledCircleCnt = EgtExtractSurfTmLoops( Proc.Id, nAddGrpId)
-            local dMinZ = 10000
-            local nMinCircleId = GDB_ID.NULL
-            for Circleindex = 1, nAngledCircleCnt do
-               local b3Circle = EgtGetBBoxGlob( nAngledCircleId + Circleindex -1, GDB_BB.EXACT)
-               if b3Circle:getMin():getZ() < dMinZ then
-                  nMinCircleId = nAngledCircleId + Circleindex -1
+         -- se passante
+         if Proc.Fcs > 0 and Proc.Fce > 0 then
+            -- se inclinato
+            if abs( vtExtr:getZ()) >= WD.DRILL_VZ_MIN and abs( vtExtr:getZ()) < 0.999 then
+               -- gruppo ausiliario per preforo
+               local nAddGrpId = WL.GetAddGroup( Proc.PartId)
+               -- ricavo contorno inferiore della superficie
+               local nAngledCircleId, nAngledCircleCnt = EgtExtractSurfTmLoops( Proc.Id, nAddGrpId)
+               local dMinZ = 10000
+               local nMinCircleId = GDB_ID.NULL
+               for Circleindex = 1, nAngledCircleCnt do
+                  local b3Circle = EgtGetBBoxGlob( nAngledCircleId + Circleindex -1, GDB_BB.EXACT)
+                  if b3Circle:getMin():getZ() < dMinZ then
+                     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
@@ -515,6 +524,17 @@ 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 _, sErr = EgtGetLastMachMgrError()
@@ -1,4 +1,4 @@
-- ProcessFreeContour.lua by Egaltech s.r.l. 2023/10/02
+-- ProcessFreeContour.lua by Egaltech s.r.l. 2024/03/24
 -- 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
-      if dLen < MIN_LEN_CUT then
-         nType = 4
+      -- se feature taglio esteremità o longitudinale ed è 1 faccia, non controllo lunghezza minima. Si controlla solo interferenza altri pezzi
+      if not( Proc.Prc == 10 and Proc.Fct == 1) then
+         -- 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])
@@ -699,18 +719,17 @@ end
 ---------------------------------------------------------------------
 local function CalcInterference( nNewProc, vtExtr, ptCentr, dDiam1, dDiam2,
                                 dTall1, dTall2, dDiam3, dTall3)
-
   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, dTall1, nNewProc, 0, GDB_RT.GLOB)
   if bColl1 then return true end
   local ptCentrGrid2 = ptCentr + ( vtExtr * ( dTall1 + 0.01))
   frOriTool = Frame3d( ptCentrGrid2, vtExtr)
-   local bColl2 = EgtCDeCylSolid( frOriTool, dDiam2/2, (dTall2-dTall1), nNewProc, 0, GDB_RT.GLOB)
+   local bColl2 = EgtTestCylSurface( frOriTool, dDiam2/2, (dTall2-dTall1), nNewProc, 0, GDB_RT.GLOB)
   if bColl2 then return true end
   local ptCentrGrid3 = ptCentr + ( vtExtr * ( dTall2 + 0.01))
   frOriTool = Frame3d( ptCentrGrid3, vtExtr)
-   local bColl3 = EgtCDeCylSolid( frOriTool, dDiam3/2, (dTall3-dTall2), nNewProc, 0, GDB_RT.GLOB)
+   local bColl3 = EgtTestCylSurface( frOriTool, dDiam3/2, (dTall3-dTall2), nNewProc, 0, GDB_RT.GLOB)
   if bColl3 then return true end
   -- restituisco risultato controllo collisioni
   return false
@@ -758,9 +777,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 +790,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)
@@ -828,7 +847,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
         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), dDiam1, dDiam2,
                                                 dTall1, dTall2, dDiam3, dTall3) then
         local sErr = 'Collision detect from clean corner tool and surface'
         EgtOutLog( sErr)
@@ -925,6 +944,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 +960,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 nMchId = WM.AddMachining( nNewProc, sName, sMilling)
+   local sName = 'Clean_' .. ( EgtGetName( nNewProc.Id) or tostring( nNewProc.Id))
+   local nMchId = WM.AddMachining( nNewProc.Id, sName, sMilling)
   if not nMchId then
      local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
      EgtOutLog( sErr)
@@ -1033,26 +1054,26 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
   -- 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 +1121,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
@@ -1138,8 +1159,8 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
      i = i + 1
   end
   -- cancello la copia della superfice
-   if nNewProc then
-      EgtErase( nNewProc)
+   if nNewProc.Id then
+      EgtErase( nNewProc.Id)
   end
   return true
 end
@@ -1486,9 +1507,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
-            local nFace = vGeom[iGeom][2]
-            vtNSum = vtNSum + Proc.Face[ nFace + 1].VtN
+         if Proc.Face and #Proc.Face > 0 then
+            for iGeom = 1, #vGeom do
+               local nFace = vGeom[iGeom][2]
+               vtNSum = vtNSum + Proc.Face[ nFace + 1].VtN
+            end
         end
         EgtSetInfo( nMchId or GDB_ID.NULL, 'NORM_SUM', vtNSum)
         -- eseguo
@@ -1703,13 +1726,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
-      local bToSkip = ( WD.BEAM_MACHINE and IsPointOnRawLongEdges( vFace[i].Cen, b3Raw))
+      -- 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)) 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 +1862,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 +1908,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
@@ -2424,7 +2447,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 +2594,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
@@ -2594,7 +2617,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
@@ -34,6 +34,7 @@
 --            Miglioramenti sostanziali nella gestione delle tasche.
 -- 2023/11/16 Fresature a salire estese a groove cieche.
 -- 2024/02/20 Piccola correzione ai casi in cui si utilizza il SIDESTEP.
+-- 2024/08/09 In MakeByMill, se fresa Side trovata ma non applicabile, si considera come se non trovata

 -- Tabella per definizione modulo
 local WPL = {}
@@ -691,15 +692,15 @@ local function CalcInterference( nNewProc, vtExtr, ptCentr, dDiam1, dDiam2,

   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, dTall1, nNewProc, 0, GDB_RT.GLOB)
   if bColl1 then return true end
   local ptCentrGrid2 = ptCentr + ( vtExtr * ( dTall1 + 0.01))
   frOriTool = Frame3d( ptCentrGrid2, vtExtr)
-   local bColl2 = EgtCDeCylSolid( frOriTool, dDiam2/2, (dTall2-dTall1), nNewProc, 0, GDB_RT.GLOB)
+   local bColl2 = EgtTestCylSurface( frOriTool, dDiam2/2, (dTall2-dTall1), nNewProc, 0, GDB_RT.GLOB)
   if bColl2 then return true end
   local ptCentrGrid3 = ptCentr + ( vtExtr * ( dTall2 + 0.01))
   frOriTool = Frame3d( ptCentrGrid3, vtExtr)
-   local bColl3 = EgtCDeCylSolid( frOriTool, dDiam3/2, (dTall3-dTall2), nNewProc, 0, GDB_RT.GLOB)
+   local bColl3 = EgtTestCylSurface( frOriTool, dDiam3/2, (dTall3-dTall2), nNewProc, 0, GDB_RT.GLOB)
   if bColl3 then return true end
   -- restituisco risultato controllo collisioni
   return false
@@ -759,9 +760,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
         nNewProcLoc = ReorderFacesFromTab( nNewProcLoc, vFace)
@@ -774,7 +775,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)
@@ -828,7 +829,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
         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), dDiam1, dDiam2, 
                                                 dTall1, dTall2, dDiam3, dTall3) then
         local sErr = 'Collision detect from clean corner tool and surface'
         EgtOutLog( sErr)
@@ -925,6 +926,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 +942,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 nMchId = WM.AddMachining( nNewProc, sName, sMilling)
+   local sName = 'Clean_' .. ( EgtGetName( nNewProc.Id) or tostring( nNewProc.Id))
+   local nMchId = WM.AddMachining( nNewProc.Id, sName, sMilling)
   if not nMchId then
      local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
      EgtOutLog( sErr)
@@ -1034,27 +1037,27 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
      end
   end
   -- 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, dDimMin, dDimMax, dDepth, nSurfInt
   local bMakeLocSurf
   -- RIMUOVERE
   if false and nFacCnt <= 4 then
      -- ottengo le dimensioni apertura, la normale e la faccia inferiore
-      dDimMin, dDimMax, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc, Proc.PartId, nAddGrpId)
+      dDimMin, dDimMax, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc.Id, Proc.PartId, nAddGrpId)
      if nSurfInt then
         -- uso la dimensione minima anche nel caso che la cava sborda perchè la lavorazione potrebbe collidere con un pezzo limitrofo
         local dMinWidth = dDimMin
-         nNewProc = EgtSurfTmBySewing( nAddGrpId, {nNewProc,nSurfInt} , true)
+         nNewProc.Id = EgtSurfTmBySewing( nAddGrpId, {nNewProc.Id,nSurfInt} , true)
         -- riordino le facce
-         nNewProc = ReorderFacesFromTab( nNewProc, vFace)
+         nNewProc.Id = ReorderFacesFromTab( nNewProc.Id, vFace)
         -- acquisisco il numero della faccia   
-         nFacCnt = EgtSurfTmFacetCount( nNewProc)
+         nFacCnt = EgtSurfTmFacetCount( nNewProc.Id)
         nFacInd = nFacCnt - 1
      else
         local sErr = 'Error : cannot create base surface'
@@ -1106,7 +1109,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
@@ -1144,8 +1147,8 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
      i = i + 1
   end
   -- cancello la copia della superfice
-   if nNewProc then
-      EgtErase(nNewProc)
+   if nNewProc.Id then
+      EgtErase( nNewProc.Id)
   end
   return true
 end
@@ -1218,7 +1221,7 @@ local function MakeByChainSaw( Proc, nFacet, nRawId, b3Raw, dElev, dH, dV)
   local sStartAngs
   if WD.GetChainSawStartAngs then
      local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nFacAdj, GDB_ID.ROOT)
-      sStartAngs = WD.GetChainSawStartAngs( vtN2)
+      sStartAngs = WD.GetChainSawStartAngs( vtN2, vtN, ptC)
   end
   -- Lati chiusi
   local bOpenStart = false
@@ -1351,7 +1354,7 @@ local function MakeByMill( Proc, nFacet, nOthFac, nRawId, b3Raw, dSideDist)
   if not sMilling then
      local sErr = 'Error : Side not found in library'
      EgtOutLog( sErr)
-      return false, sErr
+      return false, sErr, true
   end
   -- recupero i dati dell'utensile
   local dMillDiam = 20
@@ -1372,13 +1375,13 @@ local function MakeByMill( Proc, nFacet, nOthFac, nRawId, b3Raw, dSideDist)
   if dMillDiam < dDiam or dMaxDepth < dElev then
      local sErr = 'Error : Side Elevation too big'
      EgtOutLog( sErr)
-      return false, sErr
+      return false, sErr, true
   end
   local dMillExtra = dMillTotLen - dMillLen
   if Proc.Box:getMin():getZ() - dMillExtra < b3Raw:getMin():getZ() - 10 * GEO.EPS_SMALL then
      local sErr = 'Error : Tool collide with table'
      EgtOutLog( sErr)
-      return false, sErr
+      return false, sErr, true
   end
   -- inserisco la lavorazione di contornatura
   local sName = 'Mill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
@@ -1690,13 +1693,7 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
      dExtraLongEnd = 0
   end
   -- se ho abilitato la lavorazione di fresatura per garantire passaggio gambo utensile, inserisco la lavorazione
-   local bThroughRaw = false
   if bEnablePreMill then
-      -- verifico se feature e' passante
-      if ((Proc.Box:getMin():getX() < ( b3Raw:getMin():getX() + 50)) and (Proc.Box:getMax():getX() > ( b3Raw:getMax():getX() - 50))) or
-         ((Proc.Box:getMin():getY() < ( b3Raw:getMin():getY() + 50)) and (Proc.Box:getMax():getY() > ( b3Raw:getMax():getY() - 50))) then
-         bThroughRaw = true
-      end
      
      -- recupero la lavorazione di taglio
      local sCuttingGorge = WM.FindCutting( 'Standard')
@@ -1744,7 +1741,7 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
      local bSawInvertSE = false
      
      -- se non passante, aggiungo fresatura area della fresa
-      if not bThroughRaw and nNumStep - 1 > 0 then
+      if not Proc.IsThrough and nNumStep - 1 > 0 then
         local SquareId    -- Id della composita da fresare
         local dSawShortening = sqrt( b3Raw:getDimZ() * ( dSawDiam - b3Raw:getDimZ())) -- da calcolare in base a raggio lama e spessore grezzo
         -- gruppo ausiliario
@@ -2014,6 +2011,10 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
         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
+         if Proc.Fct == 2 and Proc.AffectedFaces.Top then
+            dMaxElev = nil
+         end
         if nSinglePass and nSinglePass > 0 then
            dStep = 0
            if nSinglePass == 1 then
@@ -2027,7 +2028,9 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
         -- leggo eventuali note esistenti della lavorazione
         local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
         -- aggiungo alle note massima elevazione
-         sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxElev, 3))
+         if dMaxElev then
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxElev, 3))
+         end
         -- se lavorazione in doppio aggiungo le rispettive note
         if Proc.Double and Proc.Double == 2 then
            sUserNotes = EgtSetValInNotes( sUserNotes, 'DOUBLE', Proc.Double)
@@ -2101,15 +2104,9 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
            -- setto allungamenti iniziali e finali
            EgtSetMachiningParam( MCH_MP.STARTADDLEN, dExtraLongIni)
            EgtSetMachiningParam( MCH_MP.ENDADDLEN, dExtraLongEnd)
-            -- se ho passate orizzontali riduco l'eventuale allungamento settato dall'utente
-            local dLiPerp = EgtGetMachiningParam( MCH_MP.LIPERP)
-            local dLoPerp = EgtGetMachiningParam( MCH_MP.LOPERP)
-            if dLiPerp > 0 then
-               dLiPerp = dLiPerp - dRadialOffset
-            end
-            if dLoPerp > 0 then
-               dLoPerp = dLoPerp - dRadialOffset
-            end
+            -- tutte le passate partono dalla stessa distanza
+            local dLiPerp = dElev + WD.CUT_SIC - dRadialOffset
+            local dLoPerp = dElev + WD.CUT_SIC - dRadialOffset
            EgtSetMachiningParam( MCH_MP.LIPERP, dLiPerp)
            EgtSetMachiningParam( MCH_MP.LOPERP, dLoPerp)
            -- se richiesto, setto la nota per spostare la lavorazione alla fine
@@ -2755,7 +2752,10 @@ local function MakeTwoFaces( Proc, nRawId, b3Raw)
            bLikeAsMakeFirstGroove = false
            return MakeSideGrooveByMill( Proc, nFacetVert, nRawId, b3Raw, EgtIf( bEnableMillOnSide and dMaxDepthOnSide, sMillOnSide, nil), dMaxDepthOnSide, bMakeFirstGroove, bMachFromDn, dAng, bLikeAsMakeFirstGroove, nil, nil, bDoubleMillOnSide)
         else
-            local bOk, sErr = MakeByMill( Proc, nFacet, 1 - nFacet, nRawId, b3Raw, dSideDist)
+            local bOk, sErr, bSideMachiningNotFound = MakeByMill( Proc, nFacet, 1 - nFacet, nRawId, b3Raw, dSideDist)
+            if not bOk and bSideMachiningNotFound then
+               bOk, sErr = MakeByPocketing( Proc, nFacet, nRawId, b3Raw)
+            end
            -- se angolo ottuso riprendo il lato quasi verticale
            if bOk and dAng and dAng > -90 + 10 * GEO.EPS_SMALL then
               local bOk2, sErr2 = MakeSideGrooveByMill( Proc, nFacetVert, nRawId, b3Raw, EgtIf( bEnableMillOnSide and dMaxDepthOnSide, sMillOnSide, nil), dMaxDepthOnSide, bMakeFirstGroove, bMachFromDn, dAng, false, nil, true)
@@ -2859,8 +2859,8 @@ local function MakeMoreFaces( Proc, nRawId, b3Raw)
      end
      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
      local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
-      local dMaxSlotThicknessForBlade = 25
-      local bIsSmallSlot = ( Proc.Fct == 3 and ( min( dH, dV) < dMaxSlotThicknessForBlade + 10 * GEO.EPS_SMALL) and vtN:getZ() > -0.01)
+      local dMaxSlotThicknessForBlade = 19
+      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
@@ -2882,13 +2882,15 @@ local function MakeMoreFaces( Proc, nRawId, b3Raw)
         -- se ho abilitata lavorazione di fresa di fianco
         if Proc.Fct >= 3 and sMillOnSide and nUseMillOnSide >= 1 and not bIsSmallSlot then
            -- cerco nei parametri utensili la nota di affondamento di fianco SIDEDEPTH
-            local dMaxDepthOnSide = 0
+            local dMaxDepthOnSide = 999
            local dMillDiam = 0
+            local dMillDiamTh = EgtTdbGetCurrToolThDiam() or 60
            if EgtMdbSetCurrMachining( sMillOnSide) then
               local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
               if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
                  dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
-                  dMaxDepthOnSide = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDEDEPTH', 'd') or dMaxDepthOnSide
+                  dMillDiamTh = EgtTdbGetCurrToolThDiam() or dMillDiamTh
+                  dMaxDepthOnSide = min( EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDEDEPTH', 'd') or dMaxDepthOnSide, 0.5 * ( dMillDiam - dMillDiamTh))
               end
            end
            local bMakeFirstGroove
@@ -2922,7 +2924,7 @@ local function MakeMoreFaces( Proc, nRawId, b3Raw)
            end
         else
            -- fresatura (se definita); se disponibile, cerco di usare un utensile che non lavori al limite della capacità di sottosquadro
-            local dSideElevMultiplier = 1.2
+            local dSideElevMultiplier = 1.1
            local sMilling = WM.FindMilling( 'SideGroove', nil, nil, nil, nil, min( dH, dV), nil, dSideElevMultiplier * dSideElev)
            -- se non ho trovato un utensile un po' più grande del sottosquadro richiesto, passo alla ricerca standard
            if not sMilling then
@@ -2977,7 +2979,7 @@ local function MakeMoreFaces( Proc, nRawId, b3Raw)
      else
         local sErr = 'Side milling not possible'
         EgtOutLog( sErr)
-         return true, sErr
+         return false, sErr
      end
   -- fessura verticale
   elseif Proc.Stype == 3 then
@@ -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

 ----------------------------------------------------------------------
@@ -1,4 +1,4 @@
-- WallExec.lua by Egaltech s.r.l. 2023/10/16
+-- WallExec.lua by Egaltech s.r.l. 2024/02/20
 -- Libreria esecuzione lavorazioni per Pareti
 -- 2023/05/25 Aggiunto ordinamento in base a priorità da btl.
 -- 2023/06/07 Nel caso di outline con priorità aggiunta la rimozione degli sfridi nella lavorazione successiva.
@@ -8,6 +8,8 @@
 -- 2023/11/14 Modifiche sostanziali per l'aggiunta delle lavorazioni in doppio.
 --            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 = {}
@@ -43,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')
@@ -55,7 +58,6 @@ local Text = require( 'WProcessText')
 local FreeContour = require( 'WProcessFreeContour')
 local Variant = require( 'WProcessVariant')

-
 -------------------------------------------------------------------------------------------------------------
 --    *** Inserimento delle pareti nel pannello ***
 -------------------------------------------------------------------------------------------------------------
@@ -80,33 +82,43 @@ function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewPr
   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
-      sOrigCorner = WD.GetOrigCorner( EgtGetInfo( EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or GDB_ID.NULL, 'REFPOS', 'i') or 0)
-   end 
+      sOrigCorner = WD.GetOrigCorner( EgtGetInfo( BtlInfoId, 'REFPOS', 'i') or 0)
+   end
+   -- offset da interfaccia
+   local dDeltaXFromBtl = EgtGetInfo( BtlInfoId, 'PANELDELTAY', 'd') or 0
+   local dDeltaYFromBtl = EgtGetInfo( BtlInfoId, 'PANELDELTAX', 'd') or 0
+   local dDeltaZFromBtl = EgtGetInfo( BtlInfoId, 'PANELDELTAZ', 'd') or 0
+   -- se da interfaccia arriva un valore > 0 si usa quello, altrimenti si legge da WallData (default 0)
+   local DeltaX = EgtIf( dDeltaXFromBtl > 0, dDeltaXFromBtl, WD.DELTA_X or 0)
+   local DeltaY = EgtIf( dDeltaYFromBtl > 0, dDeltaYFromBtl, WD.DELTA_Y or 0)
+   local DeltaZ = EgtIf( dDeltaZFromBtl > 0, dDeltaZFromBtl, WD.DELTA_Z or 0)
+
   if sOrigCorner == 'TL' then
      nCorner = MCH_CR.TL
-      OrigOnTab = Point3d( 0 + abs( WD.DELTA_X or 0), b3Tab:getDimY() - abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+      OrigOnTab = Point3d( 0 + abs( DeltaX), b3Tab:getDimY() - abs( DeltaY), DeltaZ)
   elseif sOrigCorner == 'BL' then
      nCorner = MCH_CR.BL
-      OrigOnTab = Point3d( 0 + abs( WD.DELTA_X or 0), abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+      OrigOnTab = Point3d( 0 + abs( DeltaX), abs( DeltaY), DeltaZ)
   elseif sOrigCorner == 'TR' then
      nCorner = MCH_CR.TR
-      OrigOnTab = Point3d( b3Tab:getDimX() - abs( WD.DELTA_X or 0), b3Tab:getDimY() - abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+      OrigOnTab = Point3d( b3Tab:getDimX() - abs( DeltaX), b3Tab:getDimY() - abs( DeltaY), DeltaZ)
   elseif sOrigCorner == 'BR' then
      nCorner = MCH_CR.BR
-      OrigOnTab = Point3d( b3Tab:getDimX() - abs( WD.DELTA_X or 0), abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+      OrigOnTab = Point3d( b3Tab:getDimX() - abs( DeltaX), abs( DeltaY), DeltaZ)
   elseif sOrigCorner == 'TM' then
      nCorner = MCH_CR.TR
-      OrigOnTab = Point3d( WD.MID_REF - abs( WD.DELTA_X or 0), b3Tab:getDimY() - abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+      OrigOnTab = Point3d( WD.MID_REF - abs( DeltaX), b3Tab:getDimY() - abs( DeltaY), DeltaZ)
   elseif sOrigCorner == 'BM' then
      nCorner = MCH_CR.BR
-      OrigOnTab = Point3d( WD.MID_REF - abs( WD.DELTA_X or 0), abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+      OrigOnTab = Point3d( WD.MID_REF - abs( DeltaX), abs( DeltaY), DeltaZ)
   elseif sOrigCorner == 'TN' then
      nCorner = MCH_CR.TL
-      OrigOnTab = Point3d( WD.NEW_REF + abs( WD.DELTA_X or 0), b3Tab:getDimY() - abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+      OrigOnTab = Point3d( WD.NEW_REF + abs( DeltaX), b3Tab:getDimY() - abs( DeltaY), DeltaZ)
   elseif sOrigCorner == 'BN' then
      nCorner = MCH_CR.BL
-      OrigOnTab = Point3d( WD.NEW_REF + abs( WD.DELTA_X or 0), abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+      OrigOnTab = Point3d( WD.NEW_REF + abs( DeltaX), abs( DeltaY), DeltaZ)
   end
   -- Impostazione dell'attrezzaggio di default
   EgtImportSetup()
@@ -120,6 +132,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
@@ -154,6 +167,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)
@@ -164,7 +178,7 @@ end
 -------------------------------------------------------------------------------------------------------------
 --    *** Inserimento delle lavorazioni nelle pareti ***
 -------------------------------------------------------------------------------------------------------------
-function WallExec.CollectFeatures( PartId, b3Raw)
+function WallExec.CollectFeatures( PartId, b3Raw, b3Squaring)
   -- recupero le feature
   local vProc = {}
   local LayerId = {}
@@ -205,12 +219,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
-                     Proc.Face[i] = { Id = i - 1, VtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT ), Elevation = WL.GetFaceElevation( Proc.Id, i - 1, PartId)}
+                  if Proc.Fct < 50 then
+                     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)
@@ -336,7 +360,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)
@@ -379,7 +403,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
@@ -1062,6 +1086,52 @@ local function SetMirroredOperations()
   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
+
+   Squaring.AddScrapRemoval( nFirstOperationId)
+
+   return true, sMsg
+end
+
 -------------------------------------------------------------------------------------------------------------
 function WallExec.ProcessFeatures()
   -- errori e stato
@@ -1079,11 +1149,57 @@ 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
+
+      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
   -- classifico topologicamente le feature
@@ -1110,7 +1226,7 @@ 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})
@@ -1210,7 +1326,19 @@ 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)

+         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)
@@ -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)
@@ -19,7 +19,7 @@ NEST.MACH_AREA_OTHER_DIAM = 200
 NEST.MACH_AREA_IGNORE_3rdFACE = 1  -- 0


-local sLog = 'NestProcess : ' .. NEST.FILE .. ', ' .. NEST.MACHINE .. ', ' .. LEN["1"] .. ', ' .. WIDTH["1"]
+local sLog = 'NestProcess : ' .. NEST.FILE .. ', ' .. NEST.MACHINE .. ', ' .. LEN[1] .. ', ' .. WIDTH[1]
 EgtOutLog( sLog)

 -- Cancello file di log specifico
@@ -1128,9 +1128,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 +1326,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 +1509,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 +1629,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 
@@ -1806,40 +1807,39 @@ if bNestingOk then
               end
            end
            
-         -- aggiungo pezzi nestati a mano
-         nPartCount = 0 
-         for nInd = 1, #vDoneManually do
-            if vDoneManually[nInd].SheetId == nId then
-               vDoneManually[nInd].Done = 1 
-               for nInd2 = 1, #(vDoneManually[nInd].Parts) do
-                  nPartCount = nPartCount + 1
-                  local nPartDuploId = EgtDuploNew( vDoneManually[nInd].Parts[nInd2].Id)  
-                  
-                  -- aggiungo le curve corrispondenti alle aree di lavorazione del pezzo 
-                  local sToolOutlines = EgtGetInfo( vDoneManually[nInd].Parts[nInd2].Id, "ToolOutlines", 's')
-                  if sToolOutlines then 
-                     -- recupero o creo il gruppo per gli outlines
-                     local nToolOutlinesGrp = EgtGetFirstNameInGroup( nPartDuploId, "ToolOutlines")
-                     if not nToolOutlinesGrp then
-                        nToolOutlinesGrp = EgtGroup( nPartDuploId)
-                        EgtSetName( nToolOutlinesGrp, "ToolOutlines")
-                        EgtSetStatus( nToolOutlinesGrp, GDB_ST.ON)
-                     end
-                  
-                     for str in string.gmatch(sToolOutlines, "([^"..",".."]+)") do 
-                        EgtCopyGlob( tonumber(str), nToolOutlinesGrp)
+            -- aggiungo pezzi nestati a mano
+            nPartCount = 0 
+            for nInd = 1, #vDoneManually do
+               if vDoneManually[nInd].SheetId == nId then
+                  vDoneManually[nInd].Done = 1 
+                  for nInd2 = 1, #(vDoneManually[nInd].Parts) do
+                     nPartCount = nPartCount + 1
+                     local nPartDuploId = EgtDuploNew( vDoneManually[nInd].Parts[nInd2].Id)  
+                     
+                     -- aggiungo le curve corrispondenti alle aree di lavorazione del pezzo 
+                     local sToolOutlines = EgtGetInfo( vDoneManually[nInd].Parts[nInd2].Id, "ToolOutlines", 's')
+                     if sToolOutlines then 
+                        -- recupero o creo il gruppo per gli outlines
+                        local nToolOutlinesGrp = EgtGetFirstNameInGroup( nPartDuploId, "ToolOutlines")
+                        if not nToolOutlinesGrp then
+                           nToolOutlinesGrp = EgtGroup( nPartDuploId)
+                           EgtSetName( nToolOutlinesGrp, "ToolOutlines")
+                           EgtSetStatus( nToolOutlinesGrp, GDB_ST.ON)
+                        end
+                     
+                        for str in string.gmatch(sToolOutlines, "([^"..",".."]+)") do 
+                           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 +1884,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 nTotRot = dAngRot - nPartRot
-               nTotRot = EgtIf( nTotRot < 0, nTotRot + 360, nTotRot)
-               EgtSetInfo( nPartDuploId, "ROT", nTotRot)
-               
-               local nPartFlip = EgtGetInfo( nId, "INVERTED", 'i')
+               local nPartFlip = EgtGetInfo( nId, "INVERTED", 'i') or 0
               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
@@ -1,5 +1,63 @@
           ==== Wall Update Log ====

+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.
+
 Versione 2.6b1 (20/02/2024)
 - Modif : In BatchProcess tolleranza su altezza pannello in grezzo portata a 0.1 mm
 - Fixed : in LapJoint piccola correzione ai casi in cui si utilizza il SIDESTEP.
@@ -1,6 +1,6 @@
-- Version.lua by Egalware s.r.l. 2023/12/13
+-- Version.lua by Egalware s.r.l. 2024/08/20
 -- Gestione della versione di Wall

 NAME = 'Wall'
-VERSION = '2.6b1'
-MIN_EXE = '2.5b3'
+VERSION = '2.6k3'
+MIN_EXE = '2.6k1'
Author	SHA1	Message	Date
luca.mazzoleni	e844d761f9	- in LapJoint -> CalcInterference ora si usano le stesse funzioni della FreeContour	2024-12-02 18:11:47 +01:00
luca.mazzoleni	6a86f7798e	- in FreeContour eLapJoint ->CleanCorner si scrivono ora TASKID e CUTID per riportare le collisioni sulla feature specifica	2024-12-02 11:47:48 +01:00
luca.mazzoleni	6a6a194df6	- in LapJoint modifica al calcolo feature passante per gorge	2024-11-29 17:52:11 +01:00
luca.mazzoleni	dcd600af01	- in LapJoint correzioni varie	2024-11-29 17:21:17 +01:00
luca.mazzoleni	854fafddf2	Merge tag '2.6k3' into develop 2.6k3	2024-11-27 17:45:13 +01:00
luca.mazzoleni	ef6cbc35df	Merge branch 'hotfix/2.6k3'	2024-11-27 17:44:49 +01:00
luca.mazzoleni	2887591da4	update version e log	2024-11-27 17:44:41 +01:00
luca.mazzoleni	3d75344652	Merge branch 'develop' into hotfix/2.6k2	2024-11-27 17:42:25 +01:00
luca.mazzoleni	1952c937b0	- in LapJoint -> MakeSideGrooveByMill corretto e modificato calcolo leadin/out perpendicolare	2024-11-27 17:41:23 +01:00
luca.mazzoleni	99baaa6320	Merge tag 'NestingSilhouetteTolerance' into develop 2.6k2	2024-11-19 12:20:13 +01:00
luca.mazzoleni	3ac752861b	Merge branch 'hotfix/NestingSilhouetteTolerance'	2024-11-19 12:19:52 +01:00
luca.mazzoleni	d690906180	- in NestProcess tolleranza silhouette riportata al valore pre modifiche DLL	2024-11-19 12:19:27 +01:00
luca.mazzoleni	1bf70aaf27	Merge branch 'master' into develop	2024-11-15 18:12:01 +01:00
luca.mazzoleni	e5a2a7e5a9	- modificato compile per contemplare Squaring.lua	2024-11-15 18:05:38 +01:00
luca.mazzoleni	b726fbc2cc	Merge tag '2.6k1' into develop 2.6k1	2024-11-14 15:22:29 +01:00
luca.mazzoleni	0771665282	Merge branch 'release/2.6k1'	2024-11-14 15:21:43 +01:00
luca.mazzoleni	6ba42d19e9	update version e log	2024-11-14 15:21:12 +01:00
luca.mazzoleni	374021ad13	- in NestProcess corretta creazione outline che in precedenza funzionava (modificata la gestione tolleranza nella funzione EgtGetSurfTmSilhouette con aggiornamenti DLL recenti)	2024-11-14 14:49:36 +01:00
luca.mazzoleni	dfe405f3b0	- in NestProcess corretta indentazione	2024-11-13 17:17:12 +01:00
andrea.villa	bd7885d245	Se feature taglio, si controlla solo interferenza altri pezzi e non lunghezza minima	2024-11-08 12:32:31 +01:00
luca.mazzoleni	1c19c48e55	Merge branch 'SquaringMasterPanel' into develop	2024-11-04 16:57:12 +01:00
luca.mazzoleni	9a40887d05	Merge branch 'develop' into SquaringMasterPanel	2024-11-04 15:40:23 +01:00
luca.mazzoleni	02e1bc7881	Merge branch 'master' into develop	2024-11-04 15:40:12 +01:00
luca.mazzoleni	5791bea4b5	in Squaring modifiche a lettura parametri utensili	2024-11-04 15:35:15 +01:00
andrea.villa	5b39d1a4ac	Update Version	2024-11-04 15:23:04 +01:00
andrea.villa	62e00e8854	Update Version e Log	2024-11-04 15:22:35 +01:00
andrea.villa	349f0cb879	Merge branch 'hotfix/SideGrooveBladeLimitWidth'	2024-11-04 15:19:12 +01:00
andrea.villa	a53a6f3e63	Modificato limite dimensione tasca per utilizzo lama come SideGroove	2024-11-04 15:18:45 +01:00
luca.mazzoleni	4f2ffec3ab	- in Squaring migliorie varie - aggiunta rimozione lavorazioni fuori dall'area di squadratura - in WallExec squadratura suddivisa prima e dopo le altre lavorazioni - in FreeContour aggiunta funzione IsFaceOutsideSquaring per evitare di lavorare le facce che finiscono fuori dall'area di squadratura	2024-10-31 16:04:15 +01:00
luca.mazzoleni	b1dd887899	- in Squaring implementata modalità ShrinkToParts; manca la rimozione delle lavorazioni fuori dall'area squadrata	2024-10-29 17:38:31 +01:00
luca.mazzoleni	b325ebcd32	- in MachiningLib aggiunta funzione GetMachiningSteps per il calcolo degli stepdi lavorazione - in Squaring aggiunti step verticali con lavorazioni aggiuntive - in WallExec gestito default per parametro di squadratura TOOL	2024-10-29 13:14:00 +01:00
luca.mazzoleni	f17411326b	Merge branch 'develop' into SquaringMasterPanel	2024-10-29 09:17:58 +01:00
luca.mazzoleni	4752ffcfb4	Merge tag '2.6j1' into develop release	2024-10-29 09:16:42 +01:00
luca.mazzoleni	dbf17d942c	Merge branch 'release/2.6j1'	2024-10-29 09:16:33 +01:00
luca.mazzoleni	72020a8874	update version e log	2024-10-29 09:16:24 +01:00
luca.mazzoleni	5d422b6edc	- in NestProcess corretta rotazione in caso di flip deciso da nesting	2024-10-29 09:10:57 +01:00
luca.mazzoleni	d2b3c32b61	- in Squaring aggiunt creazione lavorazione al momento e settaggio parametri - in Squaring gestito allungamento e attacco verticale per contemplare overmaterial e altezza pezzo	2024-10-29 09:09:19 +01:00
luca.mazzoleni	b4b3df0f5e	- in Squaring modifiche a GetTools e CreateGeometry per contemplare tutti i casi specifici	2024-10-23 12:13:39 +02:00
luca.mazzoleni	fdd114a8cd	- in WallExec -> squadratura aggiunta funzione AddSquaring che verifica e aggiunge la squadratura in base al caso specifico - in Squaring aggiunte funzioni per ricerca e controllo correttezza utensili in base al caso specifico	2024-10-21 12:43:28 +02:00
luca.mazzoleni	d5e47c06fa	Merge branch 'develop' into SquaringMasterPanel	2024-10-16 17:22:58 +02:00
luca.mazzoleni	abc61f53ba	- in nesting e flipRotate correzioni a rotazione pezzi	2024-10-16 17:01:45 +02:00
luca.mazzoleni	6e7c4ffda1	- modifiche parziali a squadratura per contemplare casi in doppio	2024-10-16 16:59:17 +02:00
luca.mazzoleni	bfaa85bbf2	- in squadratura aggiunta gestione truciolatore e ritorno errori	2024-10-14 14:26:58 +02:00
luca.mazzoleni	5c9e199c5a	- in squadratura aggiunta gestione della direzione di percorrenza delle geometrie in base a rotazione utensile e riferimento; altri miglioramenti	2024-10-11 11:36:24 +02:00
luca.mazzoleni	09127ce576	- in WallExec aggiunta squadratura, da completare	2024-10-09 18:09:02 +02:00
luca.mazzoleni	87cd31bef7	Merge branch 'develop' into SquaringMasterPanel	2024-09-30 12:38:22 +02:00
luca.mazzoleni	32fdaf5096	Merge tag '2.6i2' into develop release	2024-09-30 12:29:49 +02:00
luca.mazzoleni	2ea09e3ebc	Merge branch 'release/2.6i2'	2024-09-30 12:29:34 +02:00
luca.mazzoleni	ce8072ad1b	update version e log	2024-09-30 12:29:23 +02:00
luca.mazzoleni	896c0296a4	Merge branch 'develop' into SquaringMasterPanel	2024-09-25 12:35:10 +02:00
luca.mazzoleni	88fd8d525c	Merge branch 'master' into develop	2024-09-25 12:34:57 +02:00
luca.mazzoleni	01c5037d77	update version e log	2024-09-25 12:33:03 +02:00
luca.mazzoleni	34e7befc10	Merge remote-tracking branch 'origin/master' into develop	2024-09-10 15:13:35 +02:00
Emmanuele Sassi	846d96b967	- correzione in lettura array per cambio dll di lettura	2024-09-10 09:09:51 +02:00
luca.mazzoleni	cfd3379c98	Merge branch 'develop' of https://gitlab.steamware.net/egaltech/DataWall into develop	2024-09-02 10:52:47 +02:00
andrea.villa	6f06755539	Aggiunta nota altezza sottopezzo, per pareti a layer	2024-08-30 09:13:33 +02:00
andrea.villa	a0af959c9f	Merge remote-tracking branch 'origin/master' into develop	2024-08-30 09:13:20 +02:00
luca.mazzoleni	f397b66e26	Merge branch 'master' into develop	2024-08-28 10:12:53 +02:00
luca.mazzoleni	31782b904e	Merge commit '93fe741f8439bf0abf51c0ab2e086e07fc77a58d'	2024-08-28 10:11:38 +02:00
luca.mazzoleni	93fe741f84	update log e version	2024-08-28 10:11:26 +02:00
luca.mazzoleni	ba2158a909	- in FreeContour corretto caso in cui si chiedevano informazioni sulla faccia non presenti	2024-08-28 10:09:40 +02:00
Dario Sassi	6e0758218c	Aggiunto controllo licenza/chiave per abilitazione generazione PartProgram.	2024-08-21 11:52:59 +02:00
luca.mazzoleni	401108ce56	Merge branch 'master' into develop	2024-08-20 16:53:05 +02:00
luca.mazzoleni	b7973541e4	update log	2024-08-20 16:52:11 +02:00
Dario Sassi	bf1e9065ae	Wall 2.6h1 : - aggiunti nuovi parametri alla chiamata della funzione GetChainSawStartAngs da WallData della macchina.	2024-08-20 14:43:45 +02:00
luca.mazzoleni	1faa9e2075	Merge branch 'master' into develop	2024-08-19 16:11:51 +02:00
Dario Sassi	ceef5b78f3	Merge commit '66e2bd6e45d6990a8b30ecf39791437618ca85cd'	2024-08-19 15:04:00 +02:00
luca.mazzoleni	66e2bd6e45	- in Collect analisi facce limitata a feature che ne hanno meno di 50	2024-08-09 12:40:59 +02:00
andrea.villa	0508f12673	In ProcessLapJoint, se fresa Side trovata ma non applicabile, si considera come se non trovata	2024-08-09 11:46:43 +02:00
luca.mazzoleni	2bbfe1f3ce	Merge branch 'master' into develop	2024-07-19 18:13:35 +02:00
luca.mazzoleni	4a67fdeeff	Merge branch 'develop'	2024-07-19 18:13:18 +02:00
luca.mazzoleni	1c86ed925a	in BatchProcess e BatchProcessNew bToRecalc forzato se flag 3 o 4	2024-07-19 18:13:07 +02:00
luca.mazzoleni	3f8540b3df	Merge tag '2.6g1' into develop i	2024-07-17 15:51:11 +02:00
luca.mazzoleni	c92327641c	Merge branch 'release/2.6g1'	2024-07-17 15:50:55 +02:00
luca.mazzoleni	499e49f4f6	- update log e version - piccola modifica in ProcessDrill	2024-07-17 15:50:41 +02:00
luca.mazzoleni	099e81cbfd	- in ProcessDrill aggiunti, se foro verticale passante, riduzione affondamento di 5 mm sostituito con tab. Attualmente limite dal diametro di 200 mm, da verificare	2024-07-17 11:25:17 +02:00
luca.mazzoleni	0f38de8f58	Merge branch 'DefaultRawNoExtraWidth' into develop	2024-06-27 16:39:42 +02:00
luca.mazzoleni	d5e30baf06	- ulteriori correzioni per DEFAULT_RAW_NO_EXTRA_WIDTH	2024-06-27 16:38:45 +02:00
luca.mazzoleni	4531434e79	- correzioni a DEFAULT_RAW_NO_EXTRA_WIDTH	2024-06-27 15:50:24 +02:00
luca.mazzoleni	e56074f662	modifiche ulteriori per parametro DEFAULT_RAW_NO_EXTRA_WIDTH	2024-06-27 14:56:37 +02:00
luca.mazzoleni	5866566ebe	- in BatchProcess, in caso di DEFAULT_RAW_NO_EXTRA_WIDTH, azzerati eventuali PosX e PosZ in arrivo sul pezzo	2024-06-24 09:57:21 +02:00
luca.mazzoleni	c4272d917e	Merge tag '2.6f1' into develop a	2024-06-21 12:23:02 +02:00
luca.mazzoleni	52a10eeb9f	Merge branch 'release/2.6f1'	2024-06-21 12:22:51 +02:00
luca.mazzoleni	1d5689c007	update log e versione	2024-06-21 12:22:36 +02:00
luca.mazzoleni	f402590534	- in BatchProcess e BatchProcessNew aggiunto DEFAULT_RAW_NO_EXTRA_WIDTH per eliminare il sovramateriale grezzo in vista	2024-06-18 15:17:15 +02:00
luca.mazzoleni	b3289195f4	Merge branch 'master' into develop	2024-05-24 15:36:24 +02:00
luca.mazzoleni	f0a07554b2	update log	2024-05-24 15:36:15 +02:00
luca.mazzoleni	1ed45a8569	Merge branch 'develop'	2024-05-24 15:33:56 +02:00
luca.mazzoleni	43482f5a6d	- in LapJoint se non si trova una lavorazione di tipo side si cerca una pocketing	2024-05-24 15:33:36 +02:00
luca.mazzoleni	e66831d223	Merge branch 'develop'	2024-05-24 12:09:05 +02:00
luca.mazzoleni	548bc7bc6c	- ora per verificare se la gerenazione è abilitata si controlla il valore NoPartProgram nella sezione Mach del file ini del Cam5; se 0 o non esiste tutto è come prima	2024-05-24 12:08:42 +02:00
luca.mazzoleni	3f7a2c016d	Merge tag '2.6e2' into develop release	2024-05-24 11:21:02 +02:00
luca.mazzoleni	3763338bb3	Merge branch 'release/2.6e2'	2024-05-24 11:20:54 +02:00
luca.mazzoleni	767acf2579	update log e version	2024-05-24 11:20:23 +02:00
luca.mazzoleni	4da70c0d3c	- ora se la licenza non è abilitata alla generazione questa fase si salta invece di restituire errore bloccante	2024-05-24 11:17:16 +02:00
luca.mazzoleni	d939e07fd3	- piccole correzioni LapJoint e DoubleCut per errori cliente Belga	2024-05-24 10:44:28 +02:00
luca.mazzoleni	67bf77fe19	Merge tag '2.6e1' into develop release	2024-05-03 12:16:12 +02:00
luca.mazzoleni	384d72eb13	Merge branch 'release/2.6e1'	2024-05-03 12:15:42 +02:00
luca.mazzoleni	22541cfc9b	update log e version	2024-05-03 12:15:21 +02:00
luca.mazzoleni	1dac9716e7	Merge branch 'master' into develop	2024-05-03 12:13:11 +02:00
Dario Sassi	68464cf5b1	DataWall : - correzione per assegnazione a SawCut di flag passante (bIsThrough).	2024-05-03 11:31:53 +02:00
luca.mazzoleni	78bf456326	Merge tag '2.6c3' into develop release	2024-03-26 18:12:23 +01:00
luca.mazzoleni	cb4d597369	Merge branch 'release/2.6c3'	2024-03-26 18:12:00 +01:00
luca.mazzoleni	7bcd159db0	- in processSawCut si ignora verso vettore se taglio passante	2024-03-26 18:11:21 +01:00
luca.mazzoleni	abed970b7a	Merge remote-tracking branch 'origin/master' into develop	2024-03-26 14:54:34 +01:00
Dario Sassi	96760ac284	DataWall : - tolte info di debug anche in compilazione automatica su commit.	2024-03-25 09:10:57 +01:00
Dario Sassi	392040f8d6	DataWall 2.6c2 : - modifica per richiamare le nuove funzioni di Test interferenza solidi superfici nel controllo validità lavorazione pulizia spigoli interni - in compilazione vengono eliminate le info di degìbug.	2024-03-25 09:08:24 +01:00
luca.mazzoleni	56dc61a9d6	Merge branch 'master' into develop	2024-03-12 14:16:37 +01:00
luca.mazzoleni	ea5e62222c	Merge branch 'develop'	2024-03-12 14:15:27 +01:00
luca.mazzoleni	3b098e1541	- update yml per rimuovere simboli di debug da compilazione	2024-03-12 14:15:14 +01:00
luca.mazzoleni	354cbe85b9	Merge tag '2.6b2' into develop 2.6b2	2024-02-21 15:23:10 +01:00
luca.mazzoleni	25779abb81	Merge branch 'release/2.6b2'	2024-02-21 15:20:05 +01:00
luca.mazzoleni	1a4baaf1be	update log	2024-02-21 15:19:37 +01:00
luca.mazzoleni	20fccb24af	correzione a lettura Delta X Y Z da btl	2024-02-21 15:11:08 +01:00
luca.mazzoleni	aa94102b28	Merge branch 'master' into develop	2024-02-21 13:15:51 +01:00
Dario Sassi	a2d89cd98d	DataWall 2.6b2 : - aggiunta gestione spostamento pannello rispetto a origine da dato BTL di TS3v7.	2024-02-20 19:32:53 +01:00