Merge branch 'ConsiderHeadTailCutsForElevation' into develop

- in LapJoint se Front Slot sul retro e pezzo lungo si setta di coda

LuaLibs/BeamExec.lua

@@ -442,7 +442,7 @@ local function CalcHeadTailMachBeforeIntersDrillings( vProc, b3Raw)
    local b3TailBox
    for i = 1, #vProc do
       local Proc = vProc[i]
-      if Proc.Box and not Proc.Box:isEmpty() then 
+      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.Head and Proc.Box:getCenter():getX() < dHeadX then
                dHeadX = Proc.Box:getCenter():getX()
@@ -467,6 +467,7 @@ end
 local function AnalyzeHeadFeatures( b3Solid, vProc, dRawW, dRawH)
    local nReplacedFeatureId = nil
    local bHeadFinishingNeeded = true
+   local nCuttingFeatureId = nil
    for i = 1, #vProc do
       local Proc = vProc[i]
       -- controllo se esiste già una feature taglio di testa
@@ -481,15 +482,19 @@ local function AnalyzeHeadFeatures( b3Solid, vProc, dRawW, dRawH)
       if Proc.Head and Proc.Id ~= nReplacedFeatureId and Proc.Prc ~= 340 then
          -- controllo se la feature taglia l'intera sezione; in caso positivo la finitura non è necessaria
          bHeadFinishingNeeded = not BL.IsFeatureCuttingEntireSection( Proc.Box, dRawW, dRawH)
+         if not bHeadFinishingNeeded and ( ( Proc.Grp == 1 or Proc.Grp == 2) and Proc.Prc == 10) and ( Proc.Flg > 0) then
+            nCuttingFeatureId = Proc.Id
+         end
       end
    end
-   return bHeadFinishingNeeded, nReplacedFeatureId
+   return bHeadFinishingNeeded, nReplacedFeatureId, nCuttingFeatureId
 end
 
 -------------------------------------------------------------------------------------------------------------
 local function AnalyzeTailFeatures( b3Solid, vProc, dRawW, dRawH)
    local nReplacedFeatureId = nil
    local bTailFinishingNeeded = true
+   local nCuttingFeatureId = nil
    for i = 1, #vProc do
       local Proc = vProc[i]
       -- controllo se esistè già una feature taglio di coda
@@ -504,9 +509,12 @@ local function AnalyzeTailFeatures( b3Solid, vProc, dRawW, dRawH)
       if Proc.Tail and Proc.Id ~= nReplacedFeatureId and Proc.Prc ~= 350 then
          -- controllo se la feature taglia l'intera sezione; in caso positivo la finitura non è necessaria
          bTailFinishingNeeded = not BL.IsFeatureCuttingEntireSection( Proc.Box, dRawW, dRawH)
+         if not bTailFinishingNeeded and ( ( Proc.Grp == 1 or Proc.Grp == 2) and Proc.Prc == 10) and ( Proc.Flg > 0) then
+            nCuttingFeatureId = Proc.Id
+         end
       end
    end
-   return bTailFinishingNeeded, nReplacedFeatureId
+   return bTailFinishingNeeded, nReplacedFeatureId, nCuttingFeatureId
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -600,6 +608,17 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, vBeam, b
       local b3Part = EgtGetBBoxGlob( Pz or GDB_ID.NULL, GDB_BB.EXACT)
       local b3Solid = vBeam[i].Box
       if b3Part:isEmpty() or b3Solid:isEmpty() then break end
+      -- analizzo le features per valutare l'esistenza di feature head/tail che renderebbero inutili le rispettive finiture o di tagli di testa/coda sostituiti da cui leggere il parametro Q05
+      local vProc = CollectFeatures( Pz, b3Solid, 0)
+      local bSFinishingNeeded, nReplacedHeadCutFeatureId, nHeadCuttingFeatureId = AnalyzeHeadFeatures( b3Solid, vProc, dRawW, dRawH)
+      local bEFinishingNeeded, nReplacedTailCutFeatureId, nTailCuttingFeatureId = AnalyzeTailFeatures( b3Solid, vProc, dRawW, dRawH)
+      -- Scrivo gli di delle facce di taglio custom: serviranno dopo per calcolare l'elevazione rispetto a queste
+      if nHeadCuttingFeatureId then
+         EgtSetInfo( vBeam[i].Id, 'HEADCUTFEATUREID', nHeadCuttingFeatureId)
+      end
+      if nTailCuttingFeatureId then
+         EgtSetInfo( vBeam[i].Id, 'TAILCUTFEATUREID', nTailCuttingFeatureId)
+      end
       if bBigSectionCut then
          -- lascio in coda solo il materiale necessario; il resto verrà tolto nell'head cut successivo
          local lastB3Solid = nil
@@ -612,9 +631,6 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, vBeam, b
                dOffset = dOvmMid
             end
          end
-         -- analizzo le features per valutare l'esistenza di feature head/tail che renderebbero inutili le rispettive finiture o di tagli di testa/coda sostituiti da cui leggere il parametro Q05
-         local vProc = CollectFeatures( Pz, b3Solid, 0)
-         local bSFinishingNeeded, nReplacedHeadCutFeatureId = AnalyzeHeadFeatures( b3Solid, vProc, dRawW, dRawH)
          local iSQ05Value = nil
          if nReplacedHeadCutFeatureId then
             iSQ05Value = EgtGetInfo( nReplacedHeadCutFeatureId, 'Q05', 'i')
@@ -624,7 +640,6 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, vBeam, b
          else
             DeltaSMin = BD.OVM_BLADE_HBEAM
          end
-         local bEFinishingNeeded, nReplacedTailCutFeatureId = AnalyzeTailFeatures( b3Solid, vProc, dRawW, dRawH)
          local iEQ05Value = nil
          if nReplacedTailCutFeatureId then
             iEQ05Value = EgtGetInfo( nReplacedTailCutFeatureId, 'Q05', 'i')
@@ -780,7 +795,82 @@ local function PrintFeatures( vProc, b3Raw)
 end
 
 -------------------------------------------------------------------------------------------------------------
-local function OrderFeatures( vProc, b3Raw)
+-- mi assicuro che i tagli di testa e coda troncanti (usati per ridurre i percorsi utensile in testa e coda) siano sempre fatti per primi
+local function ReorderTruncatingCuts( vProc, nPartId)
+   if not nPartId or #vProc == 0 then return end
+
+   local nHeadCuttingFeatureId = EgtGetInfo( nPartId, 'HEADCUTFEATUREID', 'i')
+   local nTailCuttingFeatureId = EgtGetInfo( nPartId, 'TAILCUTFEATUREID', 'i')
+
+   -- tagli di testa
+   -- 1: si trovano gli indici del taglio di testa e del rispettivo taglio troncante
+   local nHeadCutIndex, nHeadCuttingFeatureIndex
+   for index, value in ipairs( vProc) do
+      if value.Prc == 340 then
+         nHeadCutIndex = index
+      end
+      if value.Id == nHeadCuttingFeatureId then
+         nHeadCuttingFeatureIndex = index
+      end
+   end
+
+   -- 2: se non c'è il taglio di testa, il taglio troncante è il primo. Se c'è il taglio di testa, il taglio troncante lo deve seguire.
+   if not nHeadCutIndex and nHeadCuttingFeatureIndex then
+      local HeadCuttingFeature = vProc[ nHeadCuttingFeatureIndex]
+      table.remove( vProc, nHeadCuttingFeatureIndex)
+      table.insert( vProc, 1, HeadCuttingFeature)
+   elseif nHeadCutIndex and nHeadCuttingFeatureIndex then
+      if abs( nHeadCutIndex - nHeadCuttingFeatureIndex) ~= 1 then
+         local HeadCut = vProc[ nHeadCutIndex]
+         local HeadCuttingFeature = vProc[ nHeadCuttingFeatureIndex]
+
+         table.remove( vProc, nHeadCutIndex)
+         -- rimuovere il primo potrebbe aver cambiato l'indice del secondo
+         if nHeadCutIndex < nHeadCuttingFeatureIndex then
+            nHeadCuttingFeatureIndex = nHeadCuttingFeatureIndex - 1
+         end
+         table.remove( vProc, nHeadCuttingFeatureIndex)
+
+         table.insert( vProc, nHeadCutIndex, HeadCut)
+         table.insert( vProc, nHeadCutIndex + 1, HeadCuttingFeature)
+      end
+   end
+
+   -- tagli di coda
+   -- 1: si trovano gli indici del taglio di coda e del rispettivo taglio troncante
+      local nTailCutIndex, nTailCuttingFeatureIndex
+   for index, value in ipairs( vProc) do
+      if value.Prc == 350 then
+         nTailCutIndex = index
+      end
+      if value.Id == nTailCuttingFeatureId then
+         nTailCuttingFeatureIndex = index
+      end
+   end
+
+   -- 2: il taglio di coda c'è sempre. Il taglio troncante lo deve seguire.
+   if nTailCutIndex and nTailCuttingFeatureIndex then
+      if abs( nTailCutIndex - nTailCuttingFeatureIndex) ~= 1 then
+         local TailCut = vProc[ nTailCutIndex]
+         local TailCuttingFeature = vProc[ nTailCuttingFeatureIndex]
+
+         table.remove( vProc, nTailCutIndex)
+         -- rimuovere il primo potrebbe aver cambiato l'indice del secondo
+         if nTailCutIndex < nTailCuttingFeatureIndex then
+            nTailCuttingFeatureIndex = nTailCuttingFeatureIndex - 1
+         end
+         table.remove( vProc, nTailCuttingFeatureIndex)
+
+         table.insert( vProc, nTailCutIndex, TailCut)
+         table.insert( vProc, nTailCutIndex + 1, TailCuttingFeature)
+      end
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function OrderFeatures( vProc, b3Raw, nPartId)
 
    local dDrillPenalty = EgtIf( BD.PRESS_ROLLER, 200, 100)
    local dSmallDrillRange = EgtIf( b3Raw:getDimX() < BD.LEN_SHORT_PART, BD.DRILL_RANGE_SP or 200, BD.DRILL_RANGE or 600)
@@ -1099,6 +1189,8 @@ local function OrderFeatures( vProc, b3Raw)
          end
       end
    end
+
+   ReorderTruncatingCuts( vProc, nPartId)
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -2021,7 +2113,7 @@ local function AreDrillingsMirrored( Proc, ProcMirror, b3Raw)
 end
 
 -------------------------------------------------------------------------------------------------------------
-function GetFeatureInfoAndDependency( vProc, b3Raw)
+function GetFeatureInfoAndDependency( vProc, b3Raw, nPartId)
    -- ciclo tutte le feature
    for i = 1, #vProc do
       local Proc = vProc[i]
@@ -2062,6 +2154,22 @@ function GetFeatureInfoAndDependency( vProc, b3Raw)
                end
             end
          end
+         -- verifiche per tagli troncanti testa e coda: devono sempre essere subito dopo il taglio di testa e il taglio di coda, rispettivamente
+         local nHeadCuttingFeatureId = EgtGetInfo( nPartId, 'HEADCUTFEATUREID', 'i')
+         local nTailCuttingFeatureId = EgtGetInfo( nPartId, 'TAILCUTFEATUREID', 'i')
+         if Proc.Prc == 340 and ProcB == nHeadCuttingFeatureId then
+            Proc.Dependency = {}
+            Proc.Dependency.ExecBefore = ProcB
+         elseif Proc == nHeadCuttingFeatureId and ProcB.Prc == 340 then
+            ProcB.Dependency = {}
+            ProcB.Dependency.ExecBefore = Proc
+         elseif Proc.Prc == 350 and ProcB == nTailCuttingFeatureId then
+            Proc.Dependency = {}
+            Proc.Dependency.ExecBefore = ProcB
+         elseif Proc == nTailCuttingFeatureId and ProcB.Prc == 350 then
+            ProcB.Dependency = {}
+            ProcB.Dependency.ExecBefore = Proc
+         end
       end
    end
 end
@@ -2103,7 +2211,7 @@ function BeamExec.ProcessFeatures()
       -- recupero le feature di lavorazione della trave
       local vProc = CollectFeatures( nPartId, b3Raw, dCurrOvmH, dCurrOvmT)
       -- recupero informazioni ausiliarie feature e dipendenze tra feature stesse
-      GetFeatureInfoAndDependency( vProc, b3Raw)
+      GetFeatureInfoAndDependency( vProc, b3Raw, nPartId)
 
       -- verifica presenza forature influenzate da lavorazioni di testa o coda
       if BD.IMPROVE_HEAD_TAIL_DRILLINGS then
@@ -2115,7 +2223,7 @@ function BeamExec.ProcessFeatures()
          SetMirroredFeatures( vProc, b3Raw)
       end
       -- le ordino lungo X
-      OrderFeatures( vProc, b3Raw)
+      OrderFeatures( vProc, b3Raw, nPartId)
       -- le classifico
       local bAllOk, bSomeDown, bSomeSide, bSplitRot = ClassifyFeatures( vProc, b3Raw, Stats)
       if not bAllOk then

LuaLibs/BeamLib.lua

@@ -1189,7 +1189,7 @@ end
 -------------------------------------------------------------------------------------------------------------
 -- restituisce vero se la feature con box b3Proc taglia l'intera sezione della barra, rappresentata dalle sue dimensioni W e H
 function BeamLib.IsFeatureCuttingEntireSection( b3Proc, dRawW, dRawH)
-   return ((abs(b3Proc:getDimY() - dRawW) < 10 * GEO.EPS_SMALL or b3Proc:getDimY() > dRawW) and (abs(b3Proc:getDimZ() - dRawH) < 10 * GEO.EPS_SMALL or b3Proc:getDimZ() > dRawH))
+   return ( b3Proc:getDimY() > ( dRawW - 500 * GEO.EPS_SMALL)  and  b3Proc:getDimZ() > ( dRawH - 500 * GEO.EPS_SMALL))
 end
 
 -------------------------------------------------------------------------------------------------------------

LuaLibs/ProcessDrill.lua

@@ -642,8 +642,8 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
       local dStep = EgtGetMachiningParam( MCH_MP.STEP)
       local nNumStep = ceil( dDepth/dStep)
       local dRealStep = dDepth / nNumStep
-      -- Se nel penultimo step le punte si trovano più vicine del minimo ( MinDistX1X2 + Puntina centraggio H1 + puntina centraggio H2) ricalcolo facendo uno step in meno
-      if ( ( dLen / 2)  - ( dRealStep * (nNumStep - 1))) * 2 < ( 40 + 10 + 10) then
+      -- Se foro passante e nel penultimo step le punte si trovano più vicine del minimo ( MinDistX1X2 + Puntina centraggio H1 + puntina centraggio H2) ricalcolo facendo uno step in meno
+      if bOpen and ( nNumStep > 1) and ( ( dLen / 2)  - ( dRealStep * (nNumStep - 1))) * 2 < ( 40 + 10 + 10) then
          dRealStep = ceil( dDepth / (nNumStep - 1))
          EgtSetMachiningParam( MCH_MP.STEP, dRealStep)
          sMyWarn ='Warning in drill-double : step changed to ' .. tostring(dRealStep) .. 'mm'

LuaLibs/ProcessLapJoint.lua

@@ -796,7 +796,8 @@ function ProcessLapJoint.IsTailFeature( Proc, b3Raw)
    if ( dEndDist > BD.MAX_DIST_HTFEA) or bUseBHSideMill then
       if not( BD.BH_MACHINE) and bUseBHSideMill and ( Proc.Box:getMax():getX() - b3Solid:getMin():getX()) < 400 and b3Solid:getDimX() > BD.LEN_VERY_SHORT_PART then
          return true
-      else
+      -- se Front Slot e pezzo abbastanza lungo si rimanda la decisione a più avanti
+      elseif not ( ( Proc.Prc == 17) and ( b3Solid:getDimX() > ( BD.LEN_VERY_SHORT_PART or BD.LEN_SHORT_PART))) then
          return false
       end
    end
@@ -3437,7 +3438,7 @@ local function MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw, nFacInd, bReduceDe
 end
 
 ---------------------------------------------------------------------
-local function MakePocket( Proc, nPartId, b3Solid, ptPs, tvtN, nFaceRef, sMchFind, nUseRoughTool, sMasterPocket, dPrevFaceElev, tDimAndRef, dAng, bOpenOutRaw, bLapJointAngTrasm, nPhase, nRawId)
+local function MakePocket( Proc, nPartId, b3Solid, ptPs, tvtN, nFaceRef, sMchFind, nUseRoughTool, sMasterPocket, dPrevFaceElev, tDimAndRef, dAng, bOpenOutRaw, bLapJointAngTrasm, nPhase, nRawId, dCustomMaxElev)
    -- distanza dal pezzo successivo
    local dDistToNextPiece = BL.GetDistanceToNextPart( nRawId, nPhase)
    -- calcolo l'elevazione dal punto medio
@@ -3540,11 +3541,10 @@ local function MakePocket( Proc, nPartId, b3Solid, ptPs, tvtN, nFaceRef, sMchFin
          end
       end
    end
-   -- eventuale massima elevazione imposta dall'utente
-   local dMaxElev = EgtGetInfo( Proc.Id, Q_MAX_ELEVATION, 'd')
-   if dMaxElev and dMaxElev < 1 then dMaxElev = nil end
+   -- eventuale massima elevazione forzata
+   if dCustomMaxElev and dCustomMaxElev < 1 then dCustomMaxElev = nil end
    -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
-   dElev = dMaxElev or dElev
+   dElev = dCustomMaxElev or dElev
    local sWarn
    local dDepth = dElev
    if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
@@ -3721,7 +3721,7 @@ local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtN, nBas
                EgtOutLog( sErr)
                return false, sErr
             else
-               sWarn = 'Warning : lapjoint chamfer angle machined with different tool'
+               sWarn = 'Warning : lapjoint angled face machined with different tool'
             end
          end
          -- recupero i dati dell'utensile
@@ -3732,6 +3732,15 @@ local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtN, nBas
                dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dTDiam
             end
          end
+         -- se utensile troppo più grande dell'originale salto la lavorazione
+         if sTuuidPk and EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuidPk) or '') then
+            local dTDiamOriginalTool = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0
+            if dTDiam > 2 * dTDiamOriginalTool then
+               sWarn = 'Warning : lapjoint angled face skipped (no compatible tool)'
+               EgtOutLog( sWarn)
+               return true, sWarn
+            end
+         end
          -- Calcolo uso faccia
          local nFaceUse = BL.GetNearestParalOpposite( tDimAndRef[1][3]:getVersZ())
          -- inserisco la lavorazione di fresatura
@@ -5878,6 +5887,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
    if not BD.MAXDIAM_POCK_CORNER then
       BD.MAXDIAM_POCK_CORNER = 30
    end
+   local nMGrpId = EgtGetCurrMachGroup()
    local sWarn
    -- recupero l'ingombro del grezzo di appartenenza
    local b3Raw = EgtGetRawPartBBox( nRawId)
@@ -6464,6 +6474,32 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                dMaxTotLen = BD.GetBottomToolMaxTotLen( vtN)
             end
             local dUserMaxElev = EgtGetInfo( Proc.Id, Q_MAX_ELEVATION, 'd')
+            local dCustomMaxElev
+            -- se esistono tagli troncanti in testa o in coda, si calcola il MaxElev da applicare
+            if not dUserMaxElev then
+               local nTailCutId = EgtGetInfo( nPartId, 'TAILCUTFEATUREID', 'i')
+               local nHeadCutId = EgtGetInfo( nPartId, 'HEADCUTFEATUREID', 'i')
+               if nHeadCutId or nTailCutId then
+                  local nSurfPartId = EgtCopyGlob( EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, 'Box'), nAddGrpId)
+                  if nHeadCutId then
+                     local ptCCutSurf, vtNCutSurf = EgtSurfTmFacetCenter( nHeadCutId, 0, GDB_ID.ROOT)
+                     EgtCutSurfTmPlane( nSurfPartId, ptCCutSurf, vtNCutSurf, false, GDB_RT.GLOB)
+                     local nSurfPartIdOld = nSurfPartId
+                     nSurfPartId = EgtSurfTmBySewing( nAddGrpId, { nSurfPartId, nHeadCutId}, false)
+                     EgtErase( nSurfPartIdOld)
+                  end
+                  -- in coda si usa il troncante solo se la feature è settata da lavorare dopo separazione (Tail), altrimenti si rischia che venga fatta prima del taglio
+                  if nTailCutId and Proc.Tail then
+                     local ptCCutSurf, vtNCutSurf = EgtSurfTmFacetCenter( nTailCutId, 0, GDB_ID.ROOT)
+                     EgtCutSurfTmPlane( nSurfPartId, ptCCutSurf, vtNCutSurf, false, GDB_RT.GLOB)
+                     local nSurfPartIdOld = nSurfPartId
+                     nSurfPartId = EgtSurfTmBySewing( nAddGrpId, { nSurfPartId, nTailCutId}, false)
+                     EgtErase( nSurfPartIdOld)
+                  end
+                  dCustomMaxElev = EgtSurfTmFacetElevationInClosedSurfTm( Proc.Id, nFacInd, nSurfPartId, true) + dCollSic
+                  EgtErase( nSurfPartId)
+               end
+            end
             -- ricerca lavorazione
             local sPocketing
             local _, sMyPocketing, dMyTMaxDepth, dMyTDiam = VerifyPocket( Proc, dDiam, dFacElev + dCollSic, dMaxTotLen, sMchFind, bMillUp, bMillDown)
@@ -6471,14 +6507,20 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                _, sMyPocketing, dMyTMaxDepth, dMyTDiam = VerifyPocket( Proc, dDiam, dFacElev + dCollSic, dMaxTotLen, sMchFind)
                bMillDown = false
             end
-            -- se l'utente ha definito un'elevazione custom dUserMaxElev si lavora sempre la faccia standard
-            if sMyPocketing and
-               ( dMyTMaxDepth > dFacElev + dCollSic - 10 * GEO.EPS_SMALL or ( dMyTMaxDepth > 0.8 * dFacElev + dCollSic and not bIsU) or
-                 ( bIsL and nUseRoughTool == 0) or
-                 ( bIsL and Proc.Prc == 20) or
-                 ( Proc.Prc == 25 and not bIsU and not bIsL)) or
-                 ( dUserMaxElev and dUserMaxElev > 10 * GEO.EPS_SMALL) then
-               sPocketing = sMyPocketing
+            -- se è presente un'elevazione custom dCustomMaxElev si lavora sempre la faccia standard
+            if sMyPocketing then
+               if dUserMaxElev then
+                  dCustomMaxElev = dUserMaxElev
+               elseif dCustomMaxElev and ( dMyTMaxDepth < dCustomMaxElev + dCollSic - 10 * GEO.EPS_SMALL) then
+                  dCustomMaxElev = nil
+               end
+               if ( dMyTMaxDepth > dFacElev + dCollSic - 10 * GEO.EPS_SMALL or ( dMyTMaxDepth > 0.8 * dFacElev + dCollSic and not bIsU) or
+                  ( bIsL and nUseRoughTool == 0) or
+                  ( bIsL and Proc.Prc == 20) or
+                  ( Proc.Prc == 25 and not bIsU and not bIsL)) or
+                  ( dCustomMaxElev and dCustomMaxElev > 10 * GEO.EPS_SMALL) then
+                  sPocketing = sMyPocketing
+               end
             end
             if bMillDown then
                sMchFind = sMchFind ..'_H2'
@@ -6704,7 +6746,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                               dToolMaxDiam = dToolTargetDiam
                            end
                            local _, sPocketing = VerifyPocket( Proc, dToolMaxDiam, dFacElev, nil, sMyMchFind)
-                           bOk, sWarn2, sTuuidPk, dDiamTool, dDepth = MakePocket( Proc, nPartId, b3Solid, ptPs, tvtNx, nFacInd, sMyMchFind, nUseRoughTool, sPocketing, dMachDepth, nil, nil, bAllWithEndCap, nil, nPhase, nRawId)
+                           bOk, sWarn2, sTuuidPk, dDiamTool, dDepth = MakePocket( Proc, nPartId, b3Solid, ptPs, tvtNx, nFacInd, sMyMchFind, nUseRoughTool, sPocketing, dMachDepth, nil, nil, bAllWithEndCap, nil, nPhase, nRawId, dCustomMaxElev)
                            if not bOk then return false, sWarn2 end
                            if sWarn2 then
                               if not sWarn then sWarn = '' end
@@ -6926,7 +6968,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                if ( Proc.Fct == 4 and bTailOnSide) and ( dDistToNextPiece > dToolDiameter + 10 * GEO.EPS_SMALL) then
                   sMchFind = EgtIf( bMillDown, 'OpenPocket_H2', 'OpenPocket')
                end
-               bOk, sWarn2, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, b3Solid, ptC, tvtNx, nFacInd, sMchFind, nUseRoughTool, sPocketing, dMachiningDepth, nil, nil, bAllWithEndCap, bLapJointAngTrasm, nPhase, nRawId)
+               bOk, sWarn2, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, b3Solid, ptC, tvtNx, nFacInd, sMchFind, nUseRoughTool, sPocketing, dMachiningDepth, nil, nil, bAllWithEndCap, bLapJointAngTrasm, nPhase, nRawId, dCustomMaxElev)
                if not bOk then return false, sWarn2 end
                if sWarn2 then
                   if not sWarn then sWarn = '' end
@@ -7477,7 +7519,7 @@ function ProcessLapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    end
    -- se lunghezza richiede spezzatura
    if ( Proc.Box:getDimX() > BD.LONGCUT_MAXLEN) or
-      ( Proc.Box:getDimX() > 0.7 * b3Solid:getDimX() and Proc.Box:getDimX() > BD.LONGCUT_ENDLEN) or
+      ( Proc.Box:getDimX() > 0.7 * b3Solid:getDimX() and ( b3Solid:getDimX() > ( BD.LEN_VERY_SHORT_PART or BD.LEN_SHORT_PART))) or
       ( ( nForceUseBladeOnNotContinueFace and nForceUseBladeOnNotContinueFace > 0) and ( Proc.Box:getDimX() > ( BD.LEN_SHORT_PART or 1000))) then
       -- una faccia
       if Proc.Fct == 1 then

LuaLibs/ProcessStepJointNotch.lua

@@ -13,6 +13,7 @@ local Fbs = require( 'FacesBySaw')
 local DC = require( 'DiceCut')
 local Cut = require( 'ProcessCut')
 local Topology = require( 'FeatureTopology')
+local LapJoint = require( 'ProcessLapJoint')
 
 EgtOutLog( ' ProcessStepJointNotch started', 1)
 
@@ -49,7 +50,7 @@ function ProcessStepJointNotch.Classify( Proc)
    -- numero delle facce
    local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
    -- gestisco solo 2 o 4 facce
-   if nFacetCnt ~= 2 and nFacetCnt ~= 4 and nFacetCnt ~= 6 and nFacetCnt ~= 8 then
+   if nFacetCnt ~= 2 and nFacetCnt ~= 3 and nFacetCnt ~= 4 and nFacetCnt ~= 6 and nFacetCnt ~= 8 then
       return false, false
    end
    -- verifico le normali delle facce
@@ -583,6 +584,9 @@ end
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessStepJointNotch.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+   if Proc.Fct == 3 then
+      return LapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+   end
    -- esecuzione eventuale smusso
    -- ottengo anche il flag che indica che la feature è larga come la trave
    local bOkc, sErrC, nDiffWidth = MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)

UpdateLog.txt

@@ -1,5 +1,13 @@
            ==== Beam Update Log ====
 
+Versione 2.7h2 (19/08/2025)
+- Modif : migliorata ottimizzazione teste
+- Modif : migliorate forature in doppio
+- Modif : in LapJoint migliorate lavorazioni lama + sega a catena
+- Modif : in LapJoint migliorata spezzatura per feature lunghe rispetto al pezzo
+- Modif : in LapJoint tipo BirdsMouth migliorata lavorazione faccia inclinata
+- Modif : in StepJointNotch, se 3 facce si riconduce a LapJoint
+
 Versione 2.7h1 (05/08/2025)
 - Fixed : in Mortise migliorata la lavorazione in caso di feature trimmata
 - Modif : in LapJoint, riduzione massimo materiale lama per lavorazioni antischeggia di lama con direzione verticale

Version.lua

@@ -2,5 +2,5 @@
 -- Gestione della versione di Beam
 
 NAME = 'Beam'
-VERSION = '2.7h1'
+VERSION = '2.7h2'
 MIN_EXE = '2.7f2'