Merge branch 'develop' of https://gitlab.steamware.net/egalware-cadcam/lua/DataBeam into develop

- piccoli aggiustamenti
- sistemazioni a DtMortise per macchina Oikos XL.

LuaLibs/BeamExec.lua

@@ -443,7 +443,7 @@ local function CalcHeadTailMachBeforeIntersDrillings( vProc, b3Raw)
    for i = 1, #vProc do
       local Proc = vProc[i]
       if Proc.Box and not Proc.Box:isEmpty() then
-         if Proc.Fct == 1 and BL.IsFeatureCuttingEntireSection( Proc.Box, b3Raw:getDimY(), b3Raw:getDimZ()) and ( Proc.Head or Proc.Tail) and Proc.Prc ~= 340 and Proc.Prc ~= 350 then
+         if Proc.Fct == 1 and BL.IsFeatureCuttingEntireSection( Proc.Box, b3Raw:getDimY(), b3Raw:getDimZ()) and ( Proc.Head or Proc.Tail) and Proc.Prc ~= 350 then
             if Proc.Head and Proc.Box:getCenter():getX() < dHeadX then
                dHeadX = Proc.Box:getCenter():getX()
                nHeadId = Proc.Id
@@ -1991,6 +1991,9 @@ local function VerifyDrillMirrored( Proc, vProc, b3Raw)
    end
    local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd')
    local dToolDoubleMaxDepth = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
+   if ( sType == 'Pocket_AT' or sType == 'Pocket') then
+      dToolDoubleMaxDepth = EgtTdbGetCurrToolMaxDepth()
+   end
    dMachiningDepth = min( dMachiningDepth, dToolDoubleMaxDepth)
    -- recupero la lunghezza della parte inclinata della punta
    local dToolDoubleTipLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) - EgtTdbGetCurrToolParam( MCH_TP.LEN)
@@ -2211,14 +2214,14 @@ function GetFeatureInfoAndDependency( vProc, b3Raw, nPartId)
                   Proc.PassedByHole = true
                end
                -- se taglio attraversato da foro, si definisce precedenza in base ad angolo
-               if Drill.Identify( Proc) and Cut.Identify( ProcB) and Overlaps( Proc.Box, ProcB.Box) then
+               if Drill.Identify( Proc) and ( Cut.Identify( ProcB) or ProcB.Prc == 340 or ProcB.Proc == 350) and Overlaps( Proc.Box, ProcB.Box) then
                   -- recupero e verifico l'entità foro
                   local DrillAuxId = ( EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0) + Proc.Id
                   local vtDrillExtr = EgtCurveExtrusion( DrillAuxId, GDB_RT.GLOB)
                   local bOpen = ( Proc.Fce ~= 0) and ( Proc.Fce ~= Proc.Fcs)
                   local ptCut, vtCutN = EgtSurfTmFacetCenter( ProcB.Id, 0, GDB_ID.ROOT)
                   local dMaxAngleDrillOnCut = BD.MAX_ANGLE_DRILL_CUT or 10
-                  if GetAngle( vtDrillExtr, vtCutN) > dMaxAngleDrillOnCut then
+                  if ( GetAngle( vtDrillExtr, vtCutN) > dMaxAngleDrillOnCut) and not ( ProcB.Prc == 340 or ProcB.Proc == 350) then
                      if bOpen and GetAngle( -vtDrillExtr, vtCutN) < dMaxAngleDrillOnCut then
                         ProcB.Dependency = {}
                         ProcB.Dependency.ExecBefore = Proc

LuaLibs/BeamLib.lua

@@ -883,6 +883,25 @@ function BeamLib.GetBlockedAxis( sMachining, sBlockedAxis, b3Raw, vtTool, vtOut)
    return ''
 end
 
+---------------------------------------------------------------------
+function BeamLib.GetAuxDir( sMachining, sBlockedAxis, b3Raw, vtTool, vtOut)
+   -- informazioni sull'utensile della lavorazione
+   local nToolType, sHead
+   if EgtMdbSetCurrMachining( sMachining) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         nToolType = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
+         sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+      end
+   end
+   -- se presente funzione specifica nella macchina, la richiamo
+   if BD.GetAuxDir then
+      return BD.GetAuxDir( sHead, nToolType, sBlockedAxis, b3Raw, vtTool, vtOut)
+   end
+   -- niente
+   return nil
+end
+
 ---------------------------------------------------------------------
 -- Trova l'Ind (0 based) della faccia meglio orientata come l'asse vtAx. Restituisce anche vtN e ptC della faccia stessa. La faccia di indice (0 based) fctExclude non viene considerata nella ricerca.
 function BeamLib.FindFaceBestOrientedAsAxis( Proc, vtAx, fctExclude)
@@ -1158,6 +1177,31 @@ function BeamLib.Is3EdgesApprox( Proc, nFacet, nAddGrpId)
    return bResult
 end
 
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.IsPointOnBoxLimits( ptPoint, b3Solid)
+    local dTol = 500 * GEO.EPS_SMALL
+
+    local dMinX = b3Solid:getMin():getX()
+    local dMinY = b3Solid:getMin():getY()
+    local dMinZ = b3Solid:getMin():getZ()
+
+    local dMaxX = b3Solid:getMax():getX()
+    local dMaxY = b3Solid:getMax():getY()
+    local dMaxZ = b3Solid:getMax():getZ()
+
+    -- Check di ogni piano limite
+    if abs( ptPoint:getX() - dMinX) < dTol then return true, "Left" end
+    if abs( ptPoint:getX() - dMaxX) < dTol then return true, "Right" end
+ 
+    if abs( ptPoint:getY() - dMinY) < dTol then return true, "Front" end
+    if abs( ptPoint:getY() - dMaxY) < dTol then return true, "Back" end
+ 
+    if abs( ptPoint:getZ() - dMinZ) < dTol then return true, "Bottom" end
+    if abs( ptPoint:getZ() - dMaxZ) < dTol then return true, "Top" end
+
+    return false
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- restituisce le facce della parte interessate dalla feature Proc
 function BeamLib.GetProcessAffectedFaces( Proc)
@@ -1393,6 +1437,11 @@ function BeamLib.GetToolFromMachining( sMachiningName)
             else
                Tool.IsOnAggregate = false
             end
+            Tool.StemDiameter = EgtTdbGetCurrToolParam( MCH_TP.STEMDIAM) or 0
+            Tool.MaxDepth = EgtTdbGetCurrToolMaxDepth() or 0
+            if Tool.StemDiameter > Tool.Diameter + GEO.EPS_SMALL then
+               Tool.MaxDepth = Tool.MaxDepth - BD.COLL_SIC
+            end
          -- altri utensili al momento non previsti
          else
             error( 'Wrong tool type')

LuaLibs/FacesBySaw.lua

@@ -170,6 +170,12 @@ function MakeParallelOne( nSurfId, nFacet, sCutting, dSawDiam, nFaceUse, dVzLimD
    end
    local vtOut = EgtIf( vtN:getX() > 0, X_AX(), -X_AX())
    EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( sCutting, 'perpendicular', b3Raw, vtTool, vtOut))
+   local sAuxDir, sInitAngs = BL.GetAuxDir( sCutting, 'perpendicular', b3Raw, vtTool, vtOut)
+   if sAuxDir then
+      sNotes = EgtSetValInNotes( sNotes, 'VtAuxDir', sAuxDir)
+      EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
+      EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
+   end
    -- eventuali note
    if ( sLeadInOutType == 'PerpendicularOutraw') then
       sNotes = EgtSetValInNotes( sNotes, 'OutRaw', 3)
@@ -231,7 +237,7 @@ local function GetEdgeToMachineFromVector( nSurfId, nFacet, vtOrthO)
 end
 
 ---------------------------------------------------------------------
-function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, bForceInvert, bMaximizeVerticalDepth, bSpecialTangentLeadInOut, sLeadInOutType, Par5Alternative, dActualElevation)
+function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, bForceInvert, bMaximizeVerticalDepth, bSpecialTangentLeadInOut, sLeadInOutType, Par5Alternative, dActualElevation, bForceClimbCut)
    -- se lama con asse parallelo alla faccia, passo alla apposita funzione
    if ( Par5 == MCH_MILL_FU.PARAL_DOWN or
         Par5 == MCH_MILL_FU.PARAL_TOP or
@@ -298,7 +304,7 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
       if not BD.TURN or abs( ptP2:getY() - ptP1:getY()) < 250 then
          local bIsMachiningDownwards = ( ptP2:getZ() < ptP1:getZ() - 100 * GEO.EPS_SMALL)
          local bIsMachiningUpwards = ( ptP2:getZ() > ptP1:getZ() + 100 * GEO.EPS_SMALL)
-         if ( bIsSawCCW ~= bDownUp) and ( bIsMachiningDownwards or not ( bIsMachiningDownwards or bIsMachiningUpwards)) then
+         if ( bIsSawCCW ~= bDownUp) and ( bIsMachiningDownwards or not ( bIsMachiningDownwards or bIsMachiningUpwards) or bForceClimbCut) then
             bInvert = true
          elseif ( ( bIsSawCCW ~= bDownUp) ~= bIsMachiningDownwards) then
             if Par5Alternative then
@@ -631,6 +637,12 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
    -- imposto angolo 3° asse rot
    local sBlockedAxis = EgtIf( bMaximizeVerticalDepth, 'parallel', 'perpendicular')
    EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( sCutting, sBlockedAxis, b3Raw, vtN, vtOrthO))
+   local sAuxDir, sInitAngs = BL.GetAuxDir( sCutting, sBlockedAxis, b3Raw, vtN, vtOrthO)
+   if sAuxDir then
+      sNotes = EgtSetValInNotes( sNotes, 'VtAuxDir', sAuxDir)
+      EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
+      EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
+   end
    -- eventuali note
    if ( sLeadInOutType == 'PerpendicularOutraw') then
       sNotes = EgtSetValInNotes( sNotes, 'OutRaw', 3)

LuaLibs/ProcessCut.lua

@@ -63,6 +63,7 @@ function ProcessCut.Classify( Proc, b3Raw)
    if ( BD.C_SIMM and BD.DOWN_HEAD) or BD.TURN then
       return true
    end
+   local bForceNoBeamRotation = ( EgtGetInfo( Proc.Id, 'Q18', 'i') == 1)
    -- recupero i dati del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- calcolo le massime estensioni lineari orizzontale e verticale della faccia
@@ -73,7 +74,7 @@ function ProcessCut.Classify( Proc, b3Raw)
    then
       -- confronto queste estensioni con la massima dimensione del DiceCut (impossibile lavorare se entrambe maggiori)
       if DimH > BD.MAX_DIM_DICE + 100 * GEO.EPS_SMALL and DimV > BD.MAX_DIM_DICE + 100 * GEO.EPS_SMALL then
-         return true, true
+         return true, not bForceNoBeamRotation
       end
    end
    -- se è un taglio da sotto, lo verifico
@@ -96,7 +97,7 @@ function ProcessCut.Classify( Proc, b3Raw)
       _, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, 0)
       -- confronto questo ingombro con il doppio della massima dimensione del DiceCut (impossibile lavorare sotto da sopra se più di 2 tagli oppure se tipo PF, taglio inclinato in Y e non taglio singolo orizzontale)
       if DimH > 2 * BD.MAX_DIM_DICE  or ( BD.C_SIMM and ( abs( vtN:getY()) > 0.1) and dMaxMat < DimH + BD.CUT_EXTRA) then
-         return true, true
+         return true, not bForceNoBeamRotation
       end
    end
    return true, false

LuaLibs/ProcessDrill.lua

@@ -37,6 +37,7 @@ EgtOutLog( ' ProcessDrill started', 1)
 -- Dati
 local BD = require( 'BeamData')
 local ML = require( 'MachiningLib')
+local FreeContour = require( 'ProcessFreeContour')
 
 ---------------------------------------------------------------------
 -- Riconoscimento della feature
@@ -345,8 +346,6 @@ end
 function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    -- Se forzato contorno foro forzo richiamo a FreeContour e uscita dalla funzione
    if EgtGetInfo( Proc.Id, 'Q04', 'i') == 1 then
-      _G.package.loaded.ProcessFreeContour = nil
-      local FreeContour = require( 'ProcessFreeContour')
       return FreeContour.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    end
    -- default per costanti
@@ -542,11 +541,13 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    if not bToInvert and Proc.Flg == 1 and bOpen and abs( vtExtr:getZ()) < 0.259 and abs( vtExtr:getY()) > 0.966 then
       local Tool = BL.GetToolFromMachining( sDrilling)
       -- lato testa e lato di lavoro devono corrispondere
-      if ( ( Tool.PreferredSide.bFront == true) and vtExtr:getY() > 10 * GEO.EPS_SMALL)
-         or ( ( Tool.PreferredSide.bBack == true) and vtExtr:getY() < - 10 * GEO.EPS_SMALL) then
-         ptCen = ptCen - vtExtr * dLen
-         vtExtr = - vtExtr
-         bToInvert = true
+      if Tool.PreferredSide then
+         if ( ( Tool.PreferredSide.bFront == true) and vtExtr:getY() > 10 * GEO.EPS_SMALL)
+            or ( ( Tool.PreferredSide.bBack == true) and vtExtr:getY() < - 10 * GEO.EPS_SMALL) then
+            ptCen = ptCen - vtExtr * dLen
+            vtExtr = - vtExtr
+            bToInvert = true
+         end
       end
    end
    -- Determino la faccia di inizio del foro e dati correlati 
@@ -612,6 +613,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          end
       end
    end
+   local dDepthOri = dDepth
    -- se foro da saltare per eccessiva inclinazione
    if not bTryDrill then
       sMyWarn = 'Warning in drill : too slant hole'
@@ -653,6 +655,9 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
             local dReduceDepth = MIRROR_POCKETS_MIN_DISTANCE / 2 + 10
             dLastStepDepth = dDepth + dReduceDepth
             dDepth = dDepth - dReduceDepth
+            if ( dLastStepDepth > dMaxDepth + 10 * GEO.EPS_SMALL) and ( dMaxDepth <= ( dLen / 2) - dReduceDepth) and ( dDepthOri ~= dDepth) then
+               dDepth = dMaxDepth
+            end
          end
       else
          sUserNotes = EgtSetValInNotes( sUserNotes, 'LastStep', MIRROR_DRILLINGS_MIN_DISTANCE / 2 + 15)
@@ -717,23 +722,41 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       else
          -- se DrillPocket passante in doppio si fa lavorazione aggiuntiva dell'ultimo step
          if Proc.Double and Proc.Double > 0 and ( sType == 'Pocket_AT' or sType == 'Pocket') and bOpen then
-            local nAddGrpId = BL.GetAddGroup( Proc.PartId)
-            local idProcLastStep = EgtCopyGlob( Proc.Id, nAddGrpId)
-            local idAuxIdLastStep = EgtCopyGlob( AuxId, nAddGrpId)
-            EgtModifyCurveThickness( idAuxIdLastStep, -dLastStepDepth)
-            local ProcLastStep = BL.TableCopyDeep( Proc)
-            ProcLastStep.Id = idProcLastStep
-            ProcLastStep.Flg = 1
-            ProcLastStep.Double = 0
-            ProcLastStep.dCustomMaxElev = dLastStepDepth - dDepth
-            local bOkLastStep, sWarnLastStep = ProcessDrill.Make( ProcLastStep, nPhase, nRawId, nPartId)
-            if not bOkLastStep then
-               sWarnLastStep = 'Drillpocket double : incomplete, last step missing'
+            if dLastStepDepth > dMaxDepth + 10 * GEO.EPS_SMALL then
+               sMyWarn = 'Warning in drill pocket last step: depth (' .. EgtNumToString( dLastStepDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+               return false, sMyWarn
             end
-            local sPreviousWarn = sMyWarn or sWarn
-            if sWarnLastStep then
-               if not sPreviousWarn then sPreviousWarn = '' end
-               sMyWarn = EgtIf( #sPreviousWarn > 0, sPreviousWarn .. '\n' .. sWarnLastStep, sWarnLastStep)
+            local idMachiningLastStep = EgtCopyMachining( EgtIf( EgtStartsWith( sType, 'Predrill'), 'Predrill_', 'Drill_') .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)), sName)
+            EgtSetCurrMachining( idMachiningLastStep)
+            local dMaxElevLastStep = dLastStepDepth - dDepth
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxElevLastStep, 1))
+            EgtSetMachiningParam( MCH_MP.DEPTH, dLastStepDepth)
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'DOUBLE', '')
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'StartZmax', '')
+            EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
+            local bOkLastStep = ML.ApplyMachining( true, false)
+            if not bOkLastStep and bDownDrill and bOpen and abs( Proc.Flg) == 1 then
+               if sType == 'Drill' or sType == 'Drill_H2' or sType == 'AngleDrill' then
+                  EgtSetMachiningParam( MCH_MP.INVERT, true)
+               else
+                  EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+               end
+               bOkLastStep = ML.ApplyMachining( true, false)
+            end
+            if not bOkLastStep then
+               local _, sErr = EgtGetLastMachMgrError()
+               EgtSetOperationMode( nMchId, false)
+               return false, sErr
+            else
+               local _, sWarnLastStep = EgtGetMachMgrWarning( 0)
+               if not bOkLastStep then
+                  sWarnLastStep = 'Drillpocket double : incomplete, last step missing'
+               end
+               local sPreviousWarn = sMyWarn or sWarn
+               if sWarnLastStep then
+                  if not sPreviousWarn then sPreviousWarn = '' end
+                  sMyWarn = EgtIf( #sPreviousWarn > 0, sPreviousWarn .. '\n' .. sWarnLastStep, sWarnLastStep)
+               end
             end
          end
          return true, ( sMyWarn or sWarn)

LuaLibs/ProcessDtMortise.lua

@@ -136,9 +136,11 @@ local function CalcPathAtHeight( nProcId, AuxId, nAddGrpId, dHeight, dSideAng, b
    local vtBoxDiag = b3Solid:getMax() - b3Solid:getMin()
    local nCount
    NewAuxId, nCount = EgtTrimFlatCurveWithBox( NewAuxId, refBox, vtBoxDiag, true, true, GDB_RT.GLOB)
-   -- eseguo traslazione e offset per portarla sul top
+   -- per ogni curva creata, eseguo traslazione e offset per portarla sul top
    local vtMove = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) * ( dHeight - 10 * GEO.EPS_SMALL)
-   EgtMove( NewAuxId, vtMove, GDB_RT.GLOB)
+   for i = 1, nCount do
+      EgtMove( NewAuxId + i - 1, vtMove, GDB_RT.GLOB)
+   end
    -- se divisa in più parti, le unisco congiungendole con segmenti
    if nCount > 1 then
       if EgtGetType( NewAuxId) ~= GDB_TY.CRV_COMPO then
@@ -147,7 +149,7 @@ local function CalcPathAtHeight( nProcId, AuxId, nAddGrpId, dHeight, dSideAng, b
       for i = 2, nCount do
          local CrvId = NewAuxId + i - 1
          local ptStart = EgtSP( CrvId)
-         EgtAddCurveCompoLine( NewAuxId, ptStart) 
+         EgtAddCurveCompoLine( NewAuxId, ptStart)
          EgtAddCurveCompoCurve( NewAuxId, CrvId)
       end
    end
@@ -227,9 +229,10 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    end
    local b3DtMrt = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, rfDtMrt)
    local dAltMort = b3DtMrt:getDimZ()
-   -- verifico se di tipo pocket
+   -- verifico se di tipo pocket o se antischeggia disabilitato
    local bPocket = ( EgtGetInfo( Proc.Id, 'P05', 'i') == 1)
-   if bPocket then bMakeAntiSplitPath = false end
+   local bDisableAntiSplint = ( EgtGetInfo( Proc.Id, 'Q01', 'i') or 0) == 1
+   if bPocket or bDisableAntiSplint then bMakeAntiSplitPath = false end
    -- verifico se frontale
    local bFront = ( Proc.Prc == 56)
    -- se mortasa di fronte, eseguo il taglio della faccia
@@ -359,7 +362,7 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       dMaxMat = 30
       dSideAng = 0
       bCW = true
-      bMillOnAggregate = sMchExt == '_AT'
+      bMillOnAggregate = ( sMchExt == '_AT')
       if EgtMdbSetCurrMachining( sMilling) then
          local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
          if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
@@ -421,8 +424,16 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       end
       -- aggiungo geometria
       EgtSetMachiningGeometry( {{ Aux2Id, -1}})
-      -- dichiaro non si generano sfridi per VMill
+      -- recupero note utente per aggiornarle
       local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
+      -- eventuali impostazioni per 3° asse rot
+      local sAuxDir, sInitAngs = BL.GetAuxDir( sPocketing, "", b3Solid, vtExtr, vtExtr)
+      if sAuxDir then
+         sUserNotes = EgtSetValInNotes( sUserNotes, 'VtAuxDir', sAuxDir)
+         EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
+         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
+      end
+      -- dichiaro non si generano sfridi per VMill
       sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxMat - 0.1, 1))
       sUserNotes = EgtSetValInNotes( sUserNotes, 'VMRS', 0)
       EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
@@ -534,8 +545,16 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
                if nSCC then 
                   EgtSetMachiningParam( MCH_MP.SCC, nSCC)
                end
-               -- dichiaro non si generano sfridi per VMill
+               -- recupero note utente per aggiornarle
                local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
+               -- eventuali impostazioni per 3° asse rot
+               local sAuxDir, sInitAngs = BL.GetAuxDir( sMilling, "", b3Solid, vtExtr, vtExtr)
+               if sAuxDir then
+                  sUserNotes = EgtSetValInNotes( sUserNotes, 'VtAuxDir', sAuxDir)
+                  EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
+                  EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
+               end
+               -- dichiaro non si generano sfridi per VMill
                sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dAltMort, 1))
                sUserNotes = EgtSetValInNotes( sUserNotes, 'VMRS', 0)
                -- se lavorazione in doppio
@@ -694,12 +713,20 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       if nSCC then
          EgtSetMachiningParam( MCH_MP.SCC, nSCC)
       end
+      -- recupero note utente per aggiornarle
+      local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
+      -- eventuali impostazioni per 3° asse rot
+      local sAuxDir, sInitAngs = BL.GetAuxDir( sMilling, "", b3Solid, vtExtr, vtExtr)
+      if sAuxDir then
+         sUserNotes = EgtSetValInNotes( sUserNotes, 'VtAuxDir', sAuxDir)
+         EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
+         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
+      end
       -- dichiaro massima elevazione e assenza sfridi per VMill
       local dMaxElev = dMaxMat
       if bMultipleZPasses then
          dMaxElev = dVerticalStep
       end
-      local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
       sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxElev - 0.1, 1))
       sUserNotes = EgtSetValInNotes( sUserNotes, 'VMRS', 0)
       -- in presenza di pocket dichiaro che non sto entrando e uscendo nel grezzo

LuaLibs/ProcessHeadCut.lua

@@ -162,10 +162,11 @@ end
 ---------------------------------------------------------------------
 -- smussi in testa
 local function MakeHeadChamfer( idProc, nPartId)
+   
    local dDepthHeadChamfer = EgtGetInfo( idProc, 'Q08', 'd') or 0
    -- se non attivo esco subito
    if dDepthHeadChamfer < 100 * GEO.EPS_SMALL then
-      return
+      return true, nil
    end
 
    -- recupero gruppo per geometria aggiuntiva
@@ -254,7 +255,8 @@ local function MakeHeadChamfer( idProc, nPartId)
    EgtSetMachiningParam( MCH_MP.DEPTH, dDepthHeadChamfer + dExtra)
    EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
    -- assegno lato di lavoro
-   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+   EgtSetMachiningParam( MCH_MP.INVERT, true)
    -- eseguo
    if not ML.ApplyMachining( true, false) then
       local _, sErr = EgtGetLastMachMgrError()
@@ -639,11 +641,12 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
    
    local bOk, sErr = MakeStandardCuts( Proc, b3Raw, nCuts, dOffsL, HeadCutType, Cutting1Data, Cutting2Data, nil, dOvmHead)
 
-
    -- alla fine del taglio si aggiungono gli smussi in testa
    local _, sErrHeadChamfer = MakeHeadChamfer( nOriId or Proc.Id, nPartId)
    if sErr then
-      sErr = sErr..'\n'..sErrHeadChamfer
+      if sErrHeadChamfer then
+         sErr = sErr..'\n'..sErrHeadChamfer
+      end
    else
       sErr = sErrHeadChamfer
    end

LuaLibs/ProcessLongDoubleCut.lua

@@ -1151,7 +1151,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
       end
       -- recupero la lavorazione
       local sMilling
-      local bDownHead = ( nSide == -1 and BD.DOWN_HEAD)
+      local bDownHead = ( BD.DOWN_HEAD and ( nSide == -1 or AreSameVectorApprox( vtN[vOrd[1]], -Z_AX())))
       sMilling = ML.FindMilling( 'Long2Cut', dElev, nil, nil, nil, not bDownHead, bDownHead)
 
       if not sMilling then
@@ -1277,31 +1277,35 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
       local dLimitAngle = -0.5 - 20 * GEO.EPS_SMALL
       -- se facce ortogonali (concave), mantengo la lavorazione di testa sulla faccia più grande purchè non superi di 30 gradi il sottosquadra
       if bOrtho then
-         local vtN1 = vtN[vOrd[1]]
-         local vtN2 = vtN[vOrd[2]]
-         if vtN1:getZ() > 0.001 and vtN2:getZ() > 0.001 then
-            if vtN1:getZ() >= vtN2:getZ() then
-               nFin = 1
-            else
-               nIni = 2
-            end
+         if bDownHead and AreSameVectorApprox( vtN[vOrd[1]], -Z_AX()) then
+            nFin = 1
          else
-            if vtN1:getZ() < dLimitAngle then
-               nIni = 2
-            elseif vtN2:getZ() < dLimitAngle then
-               nFin = 1
-            else
+            local vtN1 = vtN[vOrd[1]]
+            local vtN2 = vtN[vOrd[2]]
+            if vtN1:getZ() > 0.001 and vtN2:getZ() > 0.001 then
                if vtN1:getZ() >= vtN2:getZ() then
-                  if vtN1:getZ() < dLimitAngle then
-                     nIni = 2
-                  else
-                     nFin = 1
-                  end
+                  nFin = 1
                else
-                  if vtN1:getZ() < dLimitAngle then
-                     nIni = 2
+                  nIni = 2
+               end
+            else
+               if vtN1:getZ() < dLimitAngle then
+                  nIni = 2
+               elseif vtN2:getZ() < dLimitAngle then
+                  nFin = 1
+               else
+                  if vtN1:getZ() >= vtN2:getZ() then
+                     if vtN1:getZ() < dLimitAngle then
+                        nIni = 2
+                     else
+                        nFin = 1
+                     end
                   else
-                     nFin = 1
+                     if vtN1:getZ() < dLimitAngle then
+                        nIni = 2
+                     else
+                        nFin = 1
+                     end
                   end
                end
             end
@@ -1325,7 +1329,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
             -- valore sovrapposizione tra passate con fresa di fianco
             local dOverLapExtend = 2
             -- Verifico se da fare di fianco perchè normale troppo verso il basso (minore di -30deg)
-            local bSide = ( vtN[vOrd[i]]:getZ() < dLimitAngle and not ( nSide == -1 and ( BD.DOWN_HEAD or BD.TURN)))
+            local bSide = ( vtN[vOrd[i]]:getZ() < dLimitAngle and not ( bDownHead or ( nSide == -1 and ( BD.DOWN_HEAD or BD.TURN))))
             -- Limitazioni della lavorazione
             local nPos = EgtIf( i == 1, j, nC - j + 1)
             local dSal = EgtIf( nPos == 1, - EgtIf( i == nIni, dStartDist, dEndDist), - EgtIf( i == nIni, dStartAccDist, dEndAccDist) - ( nPos - 2) * dC + EgtIf( bSide, dOverLapExtend, 0))
@@ -1470,7 +1474,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
             end
          end
       end
-      if not Proc.bMoveAfterSplit and not bConvex and Proc.AffectedFaces.Left then
+      if not Proc.bMoveAfterSplit and not bConvex and Proc.AffectedFaces.Left and Proc.DistanceToNextPart < ( dToolDiam / 2 + 5) then
          -- recupero gruppo per geometria addizionale
          local nAddGrpId = BL.GetAddGroup( nPartId)
          if not nAddGrpId then
@@ -1503,8 +1507,8 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
          sMilling = ML.FindMilling( sMchType)
          sPrefix = 'L2CS_'
          nExtendMach = nUseMillOnSide
-         if nUseMillOnSide == 2 then 
-            bRemoveToolRadius = true 
+         if nUseMillOnSide == 2 then
+            bRemoveToolRadius = true
          end
          -- se testa da sotto
          if nSide ~= 1 and BD.DOWN_HEAD then

LuaLibs/ProcessSplit.lua

@@ -258,7 +258,8 @@ local function MakeTailChamfer( idProc, nPartId, dDepthTailChamfer)
    EgtSetMachiningParam( MCH_MP.DEPTH, dDepthTailChamfer + dExtra)
    EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
    -- assegno lato di lavoro
-   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+   EgtSetMachiningParam( MCH_MP.INVERT, true)
    -- eseguo
    if not ML.ApplyMachining( true, false) then
       local _, sErr = EgtGetLastMachMgrError()
@@ -834,7 +835,7 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
          -- determinazione materiale da asportare
          local dSawThickCheck = dSawThick
          if dSawThick2 > 0 and bDoubleHorizCut then
-            dSawThickCheck = min( dSawThick, dSawThick2)
+            dSawThickCheck = max( min( dSawThick, dSawThick2), dOvmTail)
          end
          local dMaxElev = 0
          if vtN:getX() > 0 then

LuaLibs/ProcessStepJoint.lua

@@ -140,6 +140,112 @@ local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
    return true
 end
 
+---------------------------------------------------------------------
+local function MakePocket( Proc, nPartId, ptPs, vtN, nFaceRef, nDiffWidth, sMchFind, nUseRoughTool, tBHx)
+
+   -- calcolo il elevazione dal punto medio
+   local dElev
+   local dLenIn, dLedOut = BL.GetPointDirDepth( nPartId, ptPs, vtN[nFaceRef])
+   if dLenIn > 0 then
+      dElev = dLenIn
+   elseif dLedOut then
+      dElev = dLedOut
+   end
+   local dCollSic = 2 * BD.COLL_SIC
+   local sTuuidMstr
+   -- calcolo il diametro utensile
+   local dDiamTool
+   if nUseRoughTool == 1 then
+      -- se feature passante prendo utensile più grande possibile
+      if ( Proc.AffectedFaces.Top and Proc.AffectedFaces.Bottom) or ( Proc.AffectedFaces.Front and Proc.AffectedFaces.Back) then
+         dDiamTool = nil
+      else
+         dDiamTool = max( 80, min( tBHx[nFaceRef][1], tBHx[nFaceRef][2]))
+      end
+   else
+      -- se non uso truciolatore prendo il valore dalle dimensioni minime delle facce
+      dDiamTool = min( tBHx[nFaceRef][1], tBHx[nFaceRef][2])
+   end
+   -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -30deg)
+   local bTopHead = ( BD.DOWN_HEAD and vtN[nFaceRef]:getZ() > -0.1)
+   local bDownHead = ( BD.DOWN_HEAD and vtN[nFaceRef]:getZ() < 0.1)
+   -- recupero la lavorazione
+   local sPocketing, _, _, bDownHead = ML.FindPocketing( sMchFind.. EgtIf( bDownHead, '_H2', ''), dDiamTool, dElev + dCollSic, nil, bTopHead, bDownHead)
+   if not sPocketing then
+      local sErr = 'Error : pocketing not found in library'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- recupero il diametro dell'utensile
+   if EgtMdbSetCurrMachining( sPocketing) then
+      sTuuidMstr = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuidMstr) or '') then
+         dDiamTool = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dDiamTool
+      end
+   end
+   -- inserisco la lavorazione di svuotatura
+   local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. 'F' .. tostring( nFaceRef - 1) 
+   local nMchFId = EgtAddMachining( sName, sPocketing)
+   if not nMchFId then
+      local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- aggiungo geometria
+   EgtSetMachiningGeometry( {{ Proc.Id, (nFaceRef-1)}})
+   -- imposto uso faccia
+   EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.ORTHO_CONT)
+   -- imposto posizione braccio porta testa
+   if vtN[nFaceRef]:getY() < GEO.EPS_SMALL then
+      EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM)
+   else
+      EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP)
+   end
+   -- La tasca ha sempre almeno un lato aperto, imposto opportuno attacco
+   EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN)
+   -- imposto elevazione
+   local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
+   sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dElev, 1))
+   EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
+   if not ML.ApplyMachining( true, false) then
+      -- provo ad allargare leggermente la tasca
+      EgtSetMachiningParam( MCH_MP.OFFSR, -0.1)
+      if not ML.ApplyMachining( true, false) then
+         local _, sErr = EgtGetLastMachMgrError()
+         EgtSetOperationMode( nMchFId, false)
+         return false, sErr
+      end
+   end
+   return true, '', sTuuidMstr
+end
+
+---------------------------------------------------------------------
+local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, ptC, vtN, nBigInd, nSmaInd, ptPs, tBHx, b3Raw, nDiffWidth, nUseRoughTool, dAng)
+
+   local sMchFind = 'Pocket'
+   -- se feature é larga come trave imposto openpocket 
+   if nDiffWidth == 0 then 
+      sMchFind = 'OpenPocket'
+   -- altrimenti se non è passante disabilito il truciolatore
+   else
+      nUseRoughTool = 0
+   end
+   -- applico la svuotatura
+   local bOk, sErr, sTuuidMstr = MakePocket( Proc, nPartId, ptPs, vtN, nBigInd, nDiffWidth, sMchFind, nUseRoughTool, tBHx)
+   if not bOk then 
+      return bOk, sErr
+   end
+   -- se angolo tra le facce maggiore di 90, inserisco la contornatura o svuotatura del lato più corto
+   if dAng > -90 then
+      -- applico la svuotatura
+      local bOk, sErr = MakePocket( Proc, nPartId, ptPs, vtN, nSmaInd, nDiffWidth, sMchFind, nUseRoughTool, tBHx)
+      if not bOk then
+         return bOk, sErr
+      end
+   end
+   return true
+end
+
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione al caso due facce
 local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
@@ -156,6 +262,7 @@ local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
       return false, sErr
    end
    -- dati delle facce
+   local tBHx = {}
    local ptC = {}
    local vtN = {}
    ptC[1], vtN[1] = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
@@ -183,11 +290,13 @@ local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
    end
    -- recupero i dati dell'utensile
    local dSawDiam = 400
+   local dSawThick = 2
    local dMaxDepth = 0
    if EgtMdbSetCurrMachining( sCutting) then
       local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
       if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
          dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
+         dSawThick = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dSawThick
          dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
       end
    end
@@ -239,47 +348,58 @@ local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
       vtRef[2] = vtN[2] ^ vtTg
       if vtRef[2] * vtN[1] < 0 then vtRef[2] = - vtRef[2] end
       -- determino quale faccia è più grande
-      local _, dB1, dH1 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0)
-      local _, dB2, dH2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 1)
+      local rfFac1, dB1, dH1 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0)
+      local rfFac2, dB2, dH2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 1)
       local nBigInd = EgtIf( dB1 * dH1 >= dB2 * dH2, 1, 2)
       local nSmaInd = 3 - nBigInd
-      -- calcolo extra taglio
-      local dCutExtra = dExtraUp
-      if dAng < -90.5 and dAng > -179.5 then
-         dCutExtra = - dSawThick / tan( 180 + dAng) + dExtraUp
-      end
-      -- verifico se necessari tagli supplementari
-      local vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[nBigInd], vtN[nBigInd], false, ptC[nSmaInd], vtN[nSmaInd])
-      --DC.PrintOrderCut( vCuts)
-      if #vCuts > 0 then
-         -- sistemo posizione nel DB e nome
-         for i = 1, #vCuts do
-            for j = 1, #vCuts[i] do
-               EgtSetName( vCuts[i][j], 'AddCut_' .. tostring( Proc.Id))
-               EgtSetInfo( vCuts[i][j], 'TASKID', Proc.TaskId)
-            end
-         end
-         -- eseguo
-         for i = 1, #vCuts do
-            -- assegno il modo di tagliare
-            local vtOrthO = EgtIf( ( i % 2) == 1, vtRef[nSmaInd], vtRef[nBigInd])
-            -- lavoro la faccia
-            for j = 1, #vCuts[i] do
-               local dLocCutExtra = EgtIf( j == #vCuts[i], dCutExtra - dExtraUp, dCutExtra)
-               local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthO, nil, dLocCutExtra, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
-               if not bOk then
-                  return bOk, sErr
-               end
-            end
-         end
-      -- altrimenti, tagli diretti delle facce
-      else
-         local bOk, sErr = Fbs.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, EgtIf( bHead, 'HeadSide', 'TailSide'))
+      tBHx[1] = {dH1, dV1, rfFac1}
+      tBHx[2] = {dH2, dV2, rfFac2}
+      local nUseRoughTool = EgtGetInfo( Proc.Id, 'Q02', 'i')
+      if nUseRoughTool == 1 and dAng < -0.1 and dAng > -90 then
+         local bOk, sErr = MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, ptC, vtN, nBigInd, nSmaInd, ptPs, tBHx, b3Raw, 0, nUseRoughTool, dAng)
          if not bOk then
             return bOk, sErr
          end
+      else
+         -- calcolo extra taglio
+         local dCutExtra = dExtraUp
+         if dAng < -90.5 and dAng > -179.5 then
+            dCutExtra = - dSawThick / tan( 180 + dAng) + dExtraUp
+         end
+         -- verifico se necessari tagli supplementari
+         local vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[nBigInd], vtN[nBigInd], false, ptC[nSmaInd], vtN[nSmaInd])
+         --DC.PrintOrderCut( vCuts)
+         if #vCuts > 0 then
+            -- sistemo posizione nel DB e nome
+            for i = 1, #vCuts do
+               for j = 1, #vCuts[i] do
+                  EgtSetName( vCuts[i][j], 'AddCut_' .. tostring( Proc.Id))
+                  EgtSetInfo( vCuts[i][j], 'TASKID', Proc.TaskId)
+               end
+            end
+            -- eseguo
+            for i = 1, #vCuts do
+               -- assegno il modo di tagliare
+               local vtOrthO = EgtIf( ( i % 2) == 1, vtRef[nSmaInd], vtRef[nBigInd])
+               -- lavoro la faccia
+               for j = 1, #vCuts[i] do
+                  local dLocCutExtra = EgtIf( j == #vCuts[i], dCutExtra - dExtraUp, dCutExtra)
+                  local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthO, nil, dLocCutExtra, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+                  if not bOk then
+                     return bOk, sErr
+                  end
+               end
+            end
+         -- altrimenti, tagli diretti delle facce
+         else
+            local bOk, sErr = Fbs.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, EgtIf( bHead, 'HeadSide', 'TailSide'))
+            if not bOk then
+               return bOk, sErr
+            end
+         end
       end
    end
+
    -- eventuale segnalazione ingombro di testa o coda
    if Proc.Head then
       local dOffs = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX()

UpdateLog.txt

@@ -1,4 +1,34 @@
            ==== Beam Update Log ====
+
+Versione 3.1e2 (01/06/2026)
+- Added : in Cut aggiunta Q18 per evitare di ruotare
+- Modif : gli smussi di testa sono in senso orario
+- Modif : in mortasa coda di rondine piccole correzioni
+
+Versione 3.1e1 (05/05/2026)
+- Modif : in LapJoint migliorate slot con sega a catena
+- Fixed : in DrillPocket in doppio eliminata lavorazione aggiuntiva in caso di utensile non abbastanza lungo
+
+Versione 3.1d2 (10/04/2026)
+- Added : in StepJoint aggiunto Q02=1 per forzare fresa
+- Added : in DtMortise aggiunto Q01=1 per disabilitare antischeggia
+- Fixed : in LapJoint correzione a antischeggia con fresa in caso di feature spezzata
+
+Versione 3.1d1 (08/04/2026)
+- Added : le forature vengono accorciate con massima elevazione anche in presenza di tagli di testa
+- Modif : nelle slot con lama verticali si lavora sempre in concordanza
+- Fixed : in DtMortise correzione a lavorazione antischeggia
+- Fixed : in LapJoint, se lavorazione vuota, si disattiva sempre; in Q02 si lavora sempre prima il lato sotto.
+
+Versione 3.1c2 (18/03/2026)
+- Added : in LapJoint (solo L030) aggiunto Q02 per fare solo contorno per forme a "C" e tunnel; Q17 spessore di eventuale codolo
+- Modif : per LapJoint e simili il Q06 per antischeggia ora contempla il valore 3 per scegliere la strategia in automatico (lama o fresa)
+- Modif : in LapJoint migliorie nella lavorazione delle tasche aperte
+- Modif : in LongDoubleCut e LapJoint lunghe migliorata scelta fresa in caso di tasca che guarda verso il basso
+- Fixed : in forature in doppio con svuotatura corretto ultimo step
+- Fixed : in split correzione in caso di materiale di coda molto sottile e testa sotto
+- Fixed : in LongDoubleCut e LapJoint lunghe eliminata passate finale dopo taglio di coda se non è presente un grezzo successivo
+
 Versione 3.1c1 (04/03/2026)
 - Fixed : correzione in ordinamento (fori vs tagli)
 - Fixed : in drilling rimosso preforo duplicato

Version.lua

@@ -1,6 +1,6 @@
--- Version.lua by Egaltech s.r.l. 2026/02/09
+-- Version.lua by Egaltech s.r.l. 2026/05/31
 -- Gestione della versione di Beam
 
 NAME = 'Beam'
-VERSION = '3.1c1'
+VERSION = '3.1e2'
 MIN_EXE = '3.1b1'