Merge tag '3.1e1' into develop

3.1e1

LuaLibs/BeamExec.lua

@@ -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)

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)

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)
@@ -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/ProcessDrill.lua

@@ -613,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'
@@ -654,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)
@@ -718,12 +722,12 @@ 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
+            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 idMachiningLastStep = EgtCopyMachining( EgtIf( EgtStartsWith( sType, 'Predrill'), 'Predrill_', 'Drill_') .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)), sName)
             EgtSetCurrMachining( idMachiningLastStep)
-            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) .. ')'
-               dLastStepDepth = dMaxDepth
-            end
             local dMaxElevLastStep = dLastStepDepth - dDepth
             sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxElevLastStep, 1))
             EgtSetMachiningParam( MCH_MP.DEPTH, dLastStepDepth)

LuaLibs/ProcessDtMortise.lua

@@ -229,10 +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)
-   local dForcePrecutBypass = EgtGetInfo( Proc.Id, 'Q01', 'i')
-   if bPocket or dForcePrecutBypass == 1 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

LuaLibs/ProcessLapJoint.lua

@@ -3408,7 +3408,9 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
             bGoFromHead = false
          -- continuo di testa se fessura con tre facce o non è tunnel
          else
-            bGoFromHead = (( bIs3Faces and dMaxElev) or not bOrthoFaces)
+            bGoFromHead = (( bIs3Faces and ( dMaxElev 
+                           or ( Proc.Topology == 'Groove' and Proc.IsThrough and (Proc.AffectedFaces.Left or Proc.AffectedFaces.Right) and not Proc.IsParallel))) 
+                           or not bOrthoFaces)
          end
       end
       -- se continuo a lavorare di testa
@@ -3473,17 +3475,35 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
             -- imposto offset radiale
             local dOffs = ( i - 1) * dStep
             EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
+            local bElevAdj
+            local dToolEntryAngle, _, _, dTanToolEntryAngle = GetToolEntryAngle( Proc, rfFac:getVersZ())
             -- se necessario, avverto limitazione dell'affondamento
-               if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
-               EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth)
-               sWarn = 'Warning in LapJoint : elevation (' .. EgtNumToString( dElev, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-               EgtOutLog( sWarn)
+            if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
+               if Proc.Fct == 3 and Proc.Topology == 'Groove' and Proc.IsThrough and (Proc.AffectedFaces.Left or Proc.AffectedFaces.Right) and not Proc.IsParallel then
+                  local Edges = BL.GetEdgesInfo( Proc, Proc.Face[nFacAdj+1])
+                  local dWorkEdgeWidth
+                  for i = 1, #Edges do 
+                     if Edges[i].AdjacentFaceId == nFacInd then
+                        dWorkEdgeWidth = Edges[i].Length
+                        break
+                     end
+                  end
+                  local dDeltaDepth = dWorkEdgeWidth * cos( dToolEntryAngle)
+                  bElevAdj = true
+                  EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth - dDeltaDepth)
+               else
+                  EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth)
+                  sWarn = 'Warning in LapJoint : elevation (' .. EgtNumToString( dElev, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+                  EgtOutLog( sWarn)
+               end
+               
                --local dDepth = dMaxDepth - dElev
                --EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH '..EgtNumToString( dDepth, 1))
             end
             -- imposto massima elevazione
             local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
-            sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dElev, 2))
+            local dElevAdj = EgtIf( bElevAdj, dElev / sin( dToolEntryAngle), dElev)
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dElevAdj, 2))
             EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
             -- eseguo
             if not ML.ApplyMachining( true, false) then
@@ -4803,7 +4823,7 @@ local function ManageAntiSplintBySaw( Proc, b3Raw, b3Solid, bIsU, vtN, nFacInd,
 end
 
 ---------------------------------------------------------------------
-local function MakePathsOnExtremPoints( nAddGrpId, nIdPath, pPaths, dTDiam)
+local function MakePathsOnExtremePoints( nAddGrpId, nIdPath, pPaths, dTDiam, b3Solid)
 
    local dLength = 2
    if not nIdPath then return pPaths end
@@ -4819,15 +4839,20 @@ local function MakePathsOnExtremPoints( nAddGrpId, nIdPath, pPaths, dTDiam)
    local vtIni = EgtSV( nIdPath, GDB_RT.GLOB)
    local vtEnd = EgtEV( nIdPath, GDB_RT.GLOB)
 
-   local ptIniP = ptIni
-   local ptEndP = ptIniP + (vtIni * dLength)
-   local nAuxId = EgtLine( nAddGrpId, ptIniP, ptEndP, GDB_RT.GLOB)
-   table.insert( pPaths, { nAuxId, 1, ptIniP})
+   -- si costruisce il percorso solo per i punti sui bordi del grezzo
+   if BL.IsPointOnBoxLimits( ptIni, b3Solid) then
+      local ptIniP = ptIni
+      local ptEndP = ptIniP + (vtIni * dLength)
+      local nAuxId = EgtLine( nAddGrpId, ptIniP, ptEndP, GDB_RT.GLOB)
+      table.insert( pPaths, { nAuxId, 1, ptIniP})
+   end
 
-   ptIniP = ptEnd
-   ptEndP = ptEnd - ( vtEnd * dLength)
-   nAuxId = EgtLine( nAddGrpId, ptIniP, ptEndP, GDB_RT.GLOB)
-   table.insert( pPaths, { nAuxId, 2, ptIniP})
+   if BL.IsPointOnBoxLimits( ptEnd, b3Solid) then
+      local ptIniP = ptEnd
+      local ptEndP = ptEnd - ( vtEnd * dLength)
+      local nAuxId = EgtLine( nAddGrpId, ptIniP, ptEndP, GDB_RT.GLOB)
+      table.insert( pPaths, { nAuxId, 2, ptIniP})
+   end
 
    return pPaths
 end
@@ -5081,7 +5106,7 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
             -- creo percorsi antisplint dagli estremi dei percorsi di contorno trovati
             for i = 1, nNumId do
                local nIdPath = nFirstId + i - 1
-               pPaths = MakePathsOnExtremPoints( nAddGrpId, nIdPath, pPaths, dTDiam)
+               pPaths = MakePathsOnExtremePoints( nAddGrpId, nIdPath, pPaths, dTDiam, b3Solid)
             end
          end
       -- alrimenti ho la faccia aggiunta
@@ -5116,7 +5141,7 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
          -- se non ho un percorso chiuso estraggo i percorsi
          if bOpenPath then
             -- creo percorsi antisplint dagli estremi dei percorsi di contorno trovati
-            pPaths = MakePathsOnExtremPoints( nAddGrpId, nFirstId, pPaths, dTDiam)
+            pPaths = MakePathsOnExtremePoints( nAddGrpId, nFirstId, pPaths, dTDiam, b3Solid)
          end
          EgtErase(nFirstId)
       end

UpdateLog.txt

@@ -1,4 +1,14 @@
            ==== Beam Update Log ====
+
+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

Version.lua

@@ -2,5 +2,5 @@
 -- Gestione della versione di Beam
 
 NAME = 'Beam'
-VERSION = '3.1d1'
+VERSION = '3.1e1'
 MIN_EXE = '3.1b1'