Merge tag '3.1g3' into develop

3.1g3

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 ~= 350 then
+         if Proc.Fct == 1 and ( BL.IsFeatureCuttingEntireSection( Proc.Box, b3Raw:getDimY(), b3Raw:getDimZ()) or Cut.Identify( Proc)) 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
@@ -915,6 +915,22 @@ local function ReorderFeatureWithDependency( vProc)
             table.insert( vProc, nRefIndex, table.remove( vProc, i))
             i = max( nRefIndex - 1, 1)
          end
+      elseif Drill.Identify( vProc[i]) and vProc[i].Dependency and vProc[i].Dependency.ExecAfter and vProc[i].Dependency.ExecAfter.Id then
+         local nRefId = vProc[i].Dependency.ExecAfter.Id
+         local nRefIndex
+
+         for j = 1, #vProc do
+            if i ~= j and vProc[j].Id == nRefId then
+               nRefIndex = j
+               break
+            end
+         end
+
+         -- se il processo deve stare dopo, ma ora è prima
+         if nRefIndex and nRefIndex > i then
+            table.insert( vProc, nRefIndex, table.remove( vProc, i))
+            i = max( nRefIndex - 1, 1)
+         end
       end
       i = i + 1
    end
@@ -980,12 +996,12 @@ local function OrderFeatures( vProc, b3Raw, nPartId)
          return true
       end
       -- se primo è foro e secondo è un ribasso o tenone, il foro va sempre prima a meno che il ribasso non sia di testa
-      if Drill.Identify(B1) and ( LapJoint.Identify(B2) or Mortise.Identify(B2) or Tenon.Identify(B2)) and B2.PassedByHole and
+      if Drill.Identify(B1) and ( LapJoint.Identify(B2) or Mortise.Identify(B2) or Tenon.Identify(B2) or ScarfJoint.Identify(B2)) and B2.PassedByHole and
          B1.Box:getCenter():getX() > B2.Box:getMin():getX() and B1.Box:getCenter():getX() < B2.Box:getMax():getX() then
          return true
       end
       -- se primo è un ribasso e secondo è un foro o tenone, il ribasso va sempre dopo a meno che il ribasso non sia di testa
-      if ( LapJoint.Identify(B1) or Mortise.Identify(B1) or Tenon.Identify(B1)) and B1.PassedByHole and Drill.Identify(B2) and
+      if ( LapJoint.Identify(B1) or Mortise.Identify(B1) or Tenon.Identify(B1) or ScarfJoint.Identify(B1)) and B1.PassedByHole and Drill.Identify(B2) and
          B2.Box:getCenter():getX() > B1.Box:getMin():getX() and B2.Box:getCenter():getX() < B1.Box:getMax():getX() then
          return false
       end
@@ -2211,8 +2227,8 @@ function GetFeatureInfoAndDependency( vProc, b3Raw, nPartId)
                   and DtMortise.SideIdentify( ProcB) and Overlaps( Proc.Box, ProcB.Box)  and DtMortise.IsDeeper( ProcB, b3Raw) then
                   Proc.PassedByDtMortise = true
                end
-               -- se tenone è attraversato da foro allora il foro deve essere fatto prima
+               -- se tenone o ScarfJoint sono attraversati da foro allora il foro deve essere fatto prima
-               if Tenon.Identify( Proc) and Drill.Identify( ProcB) and Overlaps( Proc.Box, ProcB.Box) then
+               if ( Tenon.Identify( Proc) or ScarfJoint.Identify( Proc)) and Drill.Identify( ProcB) and Overlaps( Proc.Box, ProcB.Box) then
                   Proc.PassedByHole = true
                end
                -- se taglio attraversato da foro, si definisce precedenza in base ad angolo

LuaLibs/BeamLib.lua

@@ -1307,29 +1307,46 @@ function BeamLib.GetFacetsInfo( Proc, b3Raw)
 end
 
 ---------------------------------------------------------------------
-function BeamLib.GetEdgesInfo( Proc, Face)
+function BeamLib.GetEdgesInfo( ProcOrId, FaceId)
+
+   -- disambiguazione feature vs id trimesh
+   local Proc = {}
+   if type( ProcOrId) == "table" then
+      Proc = ProcOrId
+   elseif type( ProcOrId) == "number" then
+      Proc.Id = ProcOrId
+   else
+      error( 'GetEdgesInfo : Only feature or trimesh supported')
+   end
+
    local Edges = {}
-   local nFaceType, vEdges = EgtSurfTmGetFacetOutlineInfo( Proc.Id, Face.Id, GDB_ID.ROOT)
+   local nFaceType, vEdges = EgtSurfTmGetFacetOutlineInfo( Proc.Id, FaceId, GDB_ID.ROOT)
 
    if nFaceType < 1 then
-      for j = 1, #vEdges do
+      for i = 1, #vEdges do
-         local nPreviousEdgeIndex = j - 1
+         local nPreviousEdgeIndex = i - 1
-         if j == 1 then
+         if i == 1 then
             nPreviousEdgeIndex = #vEdges
          end
-         local nNextEdgeIndex = j + 1
+         local nNextEdgeIndex = i + 1
-         if j == #vEdges then
+         if i == #vEdges then
             nNextEdgeIndex = 1
          end
 
          local CurrentEdge = {}
-         CurrentEdge.AdjacentFaceId = vEdges[j].Adj
+         CurrentEdge.AdjacentFaceId = vEdges[i].Adj
-         CurrentEdge.ToolDirection = Vector3d( vEdges[j].Norm)
+         CurrentEdge.ToolDirection = Vector3d( vEdges[i].Norm)
-         CurrentEdge.Length = vEdges[j].Len
+         CurrentEdge.Length = vEdges[i].Len
-         CurrentEdge.Elevation = vEdges[j].Elev
+         CurrentEdge.Elevation = vEdges[i].Elev
-         CurrentEdge.IsOpen = vEdges[j].Open
+         CurrentEdge.IsOpen = vEdges[i].Open
          CurrentEdge.IsStartOpen = ( vEdges[nPreviousEdgeIndex].Open)
          CurrentEdge.IsEndOpen = ( vEdges[nNextEdgeIndex].Open)
+         CurrentEdge.ptStart = Point3d( vEdges[i].Start)
+         CurrentEdge.ptEnd = Point3d( vEdges[nNextEdgeIndex].Start)
+         CurrentEdge.vtEdge = CurrentEdge.ptEnd - CurrentEdge.ptStart ; CurrentEdge.vtEdge:normalize()
+         CurrentEdge.Id = i - 1
+         CurrentEdge.PreviousEdgeIndex = nPreviousEdgeIndex
+         CurrentEdge.NextEdgeIndex = nNextEdgeIndex
 
          table.insert( Edges, CurrentEdge)
       end

LuaLibs/MachiningLib.lua

@@ -409,6 +409,7 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead,
                if nActiveHead == 0 then
                   return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
                -- verifico se posso usare lo stesso utensile della testa attiva
+               --TODO - se arrivano altri ticket come 3044, valutare rimozione controllo nActiveHead e usare l'utensile già caricato anche se non è sulla testa attiva (ultima utilizzata)
                elseif ( nActiveHead == 1 and not bH2 and sToolName == H1_TOOL) or ( nActiveHead == 2 and bH2 and sToolName == H2_TOOL) then
                -- se l'utensile sulla testa attiva è molto più piccolo rispetto a quelli salvati non lo scelgo, a meno che non siano entrambi grandi (truciolatori)
                   if ( not sH1Param or not sH1Param.TDiam or ( sH1Param.TDiam < 75 and ToolParams.TDiam < 75 and sH1Param.TDiam < dBiggerToolTolerance * ToolParams.TDiam)) and ( not sH2Param or not sH2Param.TDiam or ( sH2Param.TDiam < 75 and ToolParams.TDiam < 75 and sH2Param.TDiam < 1.25 * ToolParams.TDiam)) then

LuaLibs/ProcessDrill.lua

@@ -667,7 +667,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
             end
          end
       else
-         sUserNotes = EgtSetValInNotes( sUserNotes, 'LastStep', MIRROR_DRILLINGS_MIN_DISTANCE / 2 + 15)
+         sUserNotes = EgtSetValInNotes( sUserNotes, 'LastStep', MIRROR_DRILLINGS_MIN_DISTANCE / 2 + 10)
       end
       if dDepth > Proc.MachDepthDouble + 10 * GEO.EPS_SMALL then
          sMyWarn = 'Warning in double head drilling : depth (' .. EgtNumToString( dDepth, 1) .. ') reduced to (' .. EgtNumToString( Proc.MachDepthDouble, 1) .. ') to match H2 max tool depth'

LuaLibs/ProcessLapJoint.lua

@@ -1004,7 +1004,7 @@ end
 ---------------------------------------------------------------------
 -- Lavorazione con fresa
 ---------------------------------------------------------------------
-local function MakeOneFaceByMill( Proc, nPhase, nRawId, nPartId)
+local function MakeOneFaceByMill( Proc, nPhase, nRawId, nPartId, nForcedFacInd, nSideInd)
    -- recupero l'ingombro del grezzo di appartenenza
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- recupero l'ingombro della trave
@@ -1015,13 +1015,16 @@ local function MakeOneFaceByMill( Proc, nPhase, nRawId, nPartId)
       return false, sErr
    end
    -- verifico il numero di facce della tacca
-   assert( ( Proc.Fct == 1), 'Error : MakeOneFaceByMill in LapJoint with ' .. tostring( Proc.Fct) .. ' faces')
+   if not nForcedFacInd then
+      assert( ( Proc.Fct == 1), 'Error : MakeOneFaceByMill in LapJoint with ' .. tostring( Proc.Fct) .. ' faces')
+      nForcedFacInd = 0
+   end
    -- dati della faccia
-   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
+   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nForcedFacInd, GDB_ID.ROOT)
    -- verifico se orientata verso l'alto
    local bUp = ( vtN:getZ() >= BD.NZ_MINA)
    -- scelta faccia da lavorare
-   local nFacInd = 0
+   local nFacInd = nForcedFacInd
    -- recupero la lavorazione
    local sMilling = ML.FindMilling( 'BirdsMouth')
    if not sMilling then
@@ -1029,6 +1032,16 @@ local function MakeOneFaceByMill( Proc, nPhase, nRawId, nPartId)
       EgtOutLog( sErr)
       return false, sErr
    end
+   local dTDiam = 50
+   local dMaxMat = 0
+   if EgtMdbSetCurrMachining( sMilling) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dTDiam
+         dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxMat
+      end
+   end
+   dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dTDiam
    -- inserisco la lavorazione di fresatura
    local sName = 'Mill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
    local nMchFId = EgtAddMachining( sName, sMilling)
@@ -1039,8 +1052,17 @@ local function MakeOneFaceByMill( Proc, nPhase, nRawId, nPartId)
    end
    -- aggiungo geometria
    EgtSetMachiningGeometry( {{ Proc.Id, nFacInd}})
-   -- imposto uso faccia e lato correzione
+   -- imposto uso faccia e lato correzione se forzate da fuori forzo lavorazione della faccia
-   if vtN:getX() > 0 then
+   if nSideInd and nForcedFacInd then
+      EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.NONE)
+      EgtSetMachiningParam( MCH_MP.ENDADDLEN, -dTDiam / 2)
+      EgtSetMachiningParam( MCH_MP.STARTADDLEN, -dTDiam / 2)
+      local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
+      sUserNotes = EgtSetValInNotes( sUserNotes, 'EdgesFaceUse', EgtNumToString( nSideInd))
+      EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
+      EgtSetMachiningParam( MCH_MP.LIPERP, dTDiam / 2)
+      EgtSetMachiningParam( MCH_MP.LOPERP, dTDiam / 2)
+   elseif vtN:getX() > 0 then
       EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( bUp, MCH_MILL_FU.ORTHO_LEFT, MCH_MILL_FU.PARAL_LEFT))
    else
       EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( bUp, MCH_MILL_FU.ORTHO_RIGHT, MCH_MILL_FU.PARAL_RIGHT))
@@ -3548,7 +3570,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
             -- se necessario, avverto limitazione dell'affondamento
             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 Edges = BL.GetEdgesInfo( Proc, Proc.Face[nFacAdj+1].Id)
                   local dWorkEdgeWidth
                   for i = 1, #Edges do 
                      if Edges[i].AdjacentFaceId == nFacInd then
@@ -3679,7 +3701,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                   EgtSetMachiningParam( MCH_MP.DEPTH, dMachiningDepth)
                   -- si decidono lato di lavoro, inversione e estensione in base al lato aperto
                   local nEdgeIndex = BL.GetEdgeToMachineFromVector( Proc.Id, nFacAdj, vtRef)
-                  local EdgesEgt = BL.GetEdgesInfo( Proc, Proc.Face[nFacAdj+1])
+                  local EdgesEgt = BL.GetEdgesInfo( Proc, Proc.Face[nFacAdj+1].Id)
                   local CurrentEdge = EdgesEgt[nEdgeIndex+1]
                   local dStartAddLen = 0
                   local dEndAddLen = 0
@@ -4030,7 +4052,7 @@ local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtN, nBas
       -- faccia principale e quindi la componente X del versore della faccia potrebbe dare un valore non coerente
       local dDiffFromSqAng = dAng + 90
       -- informazioni sul lato da lavorare
-      local Edges = BL.GetEdgesInfo( Proc, Proc.Face[nSideFace + 1])
+      local Edges = BL.GetEdgesInfo( Proc, Proc.Face[nSideFace + 1].Id)
       local EdgeToMachine = {}
       for i = 1, #Edges do
          local CurrentEdge = Edges[i]
@@ -4767,7 +4789,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
                   end
                end
             end
-            return 1, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId
+            return 1, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, nil, sPocketing
          end
       end
    end
@@ -4801,7 +4823,7 @@ local function ManageAntiSplintBySaw( Proc, b3Raw, b3Solid, bIsU, vtN, nFacInd,
          local dMaxDepth = 200
          local bAdj, dAng, dExtraOffs, sWarn2, nIdMach
          -- Se faccia sulla quale cerca di applicare l'antisplint è chiusa e limitata da altre facce non lo applica
-         local FacetEdge = BL.GetEdgesInfo( Proc, Proc.Face[nFacet+1])
+         local FacetEdge = BL.GetEdgesInfo( Proc, Proc.Face[nFacet+1].Id)
          for nEdge = 1, #FacetEdge do
             if AreSameVectorApprox( FacetEdge[nEdge].ToolDirection, vtN) and ( not FacetEdge[nEdge].IsStartOpen or not FacetEdge[nEdge].IsEndOpen) and not FacetEdge[nEdge].IsOpen then
                sWarn2 = 'Warning : antisplint not applicable on closed face'
@@ -5533,25 +5555,31 @@ function SawPlusChain.GetBottomFaceEdges( Proc, Face)
 
    local nFaceType, vEdges = EgtSurfTmGetFacetOutlineInfo( Proc.Id, Face.Id, GDB_ID.ROOT)
    if nFaceType < 1 then
-      for j = 1, #vEdges do
+      for i = 1, #vEdges do
-         local nPreviousEdgeIndex = j - 1
+         local nPreviousEdgeIndex = i - 1
-         if j == 1 then
+         if i == 1 then
             nPreviousEdgeIndex = #vEdges
          end
-         local nNextEdgeIndex = j + 1
+         local nNextEdgeIndex = i + 1
-         if j == #vEdges then
+         if i == #vEdges then
             nNextEdgeIndex = 1
          end
 
          local CurrentEdge = {}
-         CurrentEdge.AdjacentFaceId = vEdges[j].Adj
+         CurrentEdge.AdjacentFaceId = vEdges[i].Adj
-         CurrentEdge.ToolDirection = Vector3d( vEdges[j].Norm)
+         CurrentEdge.ToolDirection = Vector3d( vEdges[i].Norm)
-         CurrentEdge.Length = vEdges[j].Len
+         CurrentEdge.Length = vEdges[i].Len
-         CurrentEdge.Elevation = vEdges[j].Elev
+         CurrentEdge.Elevation = vEdges[i].Elev
-         CurrentEdge.IsOpen = vEdges[j].Open
+         CurrentEdge.IsOpen = vEdges[i].Open
          CurrentEdge.IsStartOpen = ( vEdges[nPreviousEdgeIndex].Open)
          CurrentEdge.IsEndOpen = ( vEdges[nNextEdgeIndex].Open)
-         CurrentEdge.Id = j - 1
+         CurrentEdge.Id = i - 1
+         CurrentEdge.ptStart = Point3d( vEdges[i].Start)
+         CurrentEdge.ptEnd = Point3d( vEdges[nNextEdgeIndex].Start)
+         CurrentEdge.vtEdge = CurrentEdge.ptEnd - CurrentEdge.ptStart ; CurrentEdge.vtEdge:normalize()
+         CurrentEdge.Id = i - 1
+         CurrentEdge.PreviousEdgeIndex = nPreviousEdgeIndex
+         CurrentEdge.NextEdgeIndex = nNextEdgeIndex
 
          if CurrentEdge.AdjacentFaceId == Proc.MainFaces.LongFace.Id then
             table.insert( Edges.LongEdges, CurrentEdge)
@@ -5579,25 +5607,30 @@ function SawPlusChain.GetLongFaceEdges( Proc, Face)
 
    local nFaceType, vEdges = EgtSurfTmGetFacetOutlineInfo( Proc.Id, Face.Id, GDB_ID.ROOT)
    if nFaceType < 1 then
-      for j = 1, #vEdges do
+      for i = 1, #vEdges do
-         local nPreviousEdgeIndex = j - 1
+         local nPreviousEdgeIndex = i - 1
-         if j == 1 then
+         if i == 1 then
             nPreviousEdgeIndex = #vEdges
          end
-         local nNextEdgeIndex = j + 1
+         local nNextEdgeIndex = i + 1
-         if j == #vEdges then
+         if i == #vEdges then
             nNextEdgeIndex = 1
          end
 
          local CurrentEdge = {}
-         CurrentEdge.AdjacentFaceId = vEdges[j].Adj
+         CurrentEdge.AdjacentFaceId = vEdges[i].Adj
-         CurrentEdge.ToolDirection = Vector3d( vEdges[j].Norm)
+         CurrentEdge.ToolDirection = Vector3d( vEdges[i].Norm)
-         CurrentEdge.Length = vEdges[j].Len
+         CurrentEdge.Length = vEdges[i].Len
-         CurrentEdge.Elevation = vEdges[j].Elev
+         CurrentEdge.Elevation = vEdges[i].Elev
-         CurrentEdge.IsOpen = vEdges[j].Open
+         CurrentEdge.IsOpen = vEdges[i].Open
          CurrentEdge.IsStartOpen = ( vEdges[nPreviousEdgeIndex].Open)
          CurrentEdge.IsEndOpen = ( vEdges[nNextEdgeIndex].Open)
-         CurrentEdge.Id = j - 1
+         CurrentEdge.ptStart = Point3d( vEdges[i].Start)
+         CurrentEdge.ptEnd = Point3d( vEdges[nNextEdgeIndex].Start)
+         CurrentEdge.vtEdge = CurrentEdge.ptEnd - CurrentEdge.ptStart ; CurrentEdge.vtEdge:normalize()
+         CurrentEdge.Id = i - 1
+         CurrentEdge.PreviousEdgeIndex = nPreviousEdgeIndex
+         CurrentEdge.NextEdgeIndex = nNextEdgeIndex
 
          if Proc.Topology == 'Tunnel' then
             if CurrentEdge.AdjacentFaceId > -1 then
@@ -5629,7 +5662,7 @@ function SawPlusChain.GetLongFaceEdges( Proc, Face)
 end
 
 
-function SawPlusChain.CalculateLeadInOut( Machining, EdgeToMachine)
+function SawPlusChain.CalculateLeadInOut( Machining, EdgeToMachine, FaceToMachine, b3Raw)
    -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
 
    -- si determina l'eventuale riduzione da applicare in caso di inizio o fine chiusi
@@ -5680,6 +5713,18 @@ function SawPlusChain.CalculateLeadInOut( Machining, EdgeToMachine)
          LeadIn.StartAddLength = BD.CUT_EXTRA
          LeadOut.EndAddLength = BD.CUT_EXTRA
       end
+      local ptP1 = Point3d( EdgeToMachine.ptStart)
+      local ptP2 = Point3d( EdgeToMachine.ptEnd)
+      
+      local bInvert = Machining.Invert
+      if bInvert then
+         ptP1, ptP2 = ptP2, ptP1
+         vtV1, vtV2 = vtV2, vtV1
+      end
+      local vtTg = ptP2 - ptP1 ;   vtTg:normalize()
+      Machining.vtTg = vtTg
+      Machining.vtV = vtV1
+      
    else
       if Machining.IsStartClosed then
          LeadIn.StartAddLength = -dAddLengthToReduce
@@ -5792,32 +5837,52 @@ function SawPlusChain.ApplyMachining( Machining, b3Raw)
 end
 
 
-function SawPlusChain.Saw.GetSCC( vtMachiningDirection)
+function SawPlusChain.Saw.GetSCC( vtMachiningDirection, vtN, vtTg)
    -- TODO implementare SCC come per FacesBySaw
-   local nSCC = MCH_SCC.NONE
+   if not BD.TURN then
-   if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then
+      -- per ora aggregato usato in verticale solo in split e headcut; Fast non influenzata
-      nSCC = MCH_SCC.ADIR_ZP
+      if BD.C_SIMM and bMaximizeVerticalDepth then
-   elseif AreOppositeVectorApprox( vtMachiningDirection, Z_AX()) then
+         nSCC = MCH_SCC.ADIR_ZM
-      nSCC = MCH_SCC.ADIR_ZM
+      elseif abs( vtMachiningDirection:getX()) > abs( vtMachiningDirection:getY()) - GEO.EPS_SMALL then
-   elseif AreSameVectorApprox( vtMachiningDirection, Y_AX()) then
+         -- se il taglio è orizzontale, si gira aggregato lama per facilitare caduta del legno
-      nSCC = MCH_SCC.ADIR_YP
+         if abs( vtTg:getZ()) < 10 * GEO.EPS_SMALL and not AreSameOrOppositeVectorApprox( vtN, Z_AX()) then
-   elseif AreOppositeVectorApprox( vtMachiningDirection, Y_AX()) then
+            nSCC = EgtIf( ( vtMachiningDirection:getX() > -GEO.EPS_SMALL), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP)
-      nSCC = MCH_SCC.ADIR_YM
+         else
-   elseif AreSameVectorApprox( vtMachiningDirection, X_AX()) then
+            nSCC = EgtIf( ( vtMachiningDirection:getX() > -GEO.EPS_SMALL), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
-      nSCC = MCH_SCC.ADIR_XP
+         end
-   elseif AreOppositeVectorApprox( vtMachiningDirection, X_AX()) then
+      else
-      nSCC = MCH_SCC.ADIR_XM
+         -- se il taglio è orizzontale, si gira aggregato lama per facilitare caduta del legno
+         if abs( vtTg:getZ()) < 10 * GEO.EPS_SMALL and not AreSameOrOppositeVectorApprox( vtN, Z_AX()) then
+            nSCC = EgtIf( ( vtMachiningDirection:getY() > -GEO.EPS_SMALL), MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP)
+         else
+            nSCC = EgtIf( ( vtMachiningDirection:getY() > -GEO.EPS_SMALL), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+         end
+      end
+   else
+      if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then
+         nSCC = MCH_SCC.ADIR_ZP
+      elseif AreOppositeVectorApprox( vtMachiningDirection, Z_AX()) then
+         nSCC = MCH_SCC.ADIR_ZM
+      elseif AreSameVectorApprox( vtMachiningDirection, Y_AX()) then
+         nSCC = MCH_SCC.ADIR_YP
+      elseif AreOppositeVectorApprox( vtMachiningDirection, Y_AX()) then
+         nSCC = MCH_SCC.ADIR_YM
+      elseif AreSameVectorApprox( vtMachiningDirection, X_AX()) then
+         nSCC = MCH_SCC.ADIR_XP
+      elseif AreOppositeVectorApprox( vtMachiningDirection, X_AX()) then
+         nSCC = MCH_SCC.ADIR_XM
+      end
    end
-
    return nSCC
 end
 
 
-function SawPlusChain.Saw.CalculateMachiningParameters( Proc, FaceToMachine, EdgeToMachine)
+function SawPlusChain.Saw.CalculateMachiningParameters( Proc, FaceToMachine, EdgeToMachine, b3Raw)
    local Cutting = {}
    Cutting.CanApply = true
    Cutting.Message = ''
    Cutting.ProcId = Proc.Id
+   EdgeToMachine.FaceId = FaceToMachine.Id
 
    local dPocketHeight = 0
    if Proc.Topology == 'Tunnel' then
@@ -5929,15 +5994,15 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc, FaceToMachine, Edg
       Cutting.Faceuse = BL.GetNearestOrthoOpposite( -EdgeToMachine.ToolDirection)
    end
    Cutting.nEdgeFaceUse = EdgeToMachine.Id
-   -- SCC
-   Cutting.SCC = SawPlusChain.Saw.GetSCC( EdgeToMachine.ToolDirection)
    -- asse bloccato
    Cutting.BlockedAxis = {}
    Cutting.BlockedAxis.Orientation = 'perpendicular'
    Cutting.BlockedAxis.VtN = FaceToMachine.VtN
    Cutting.BlockedAxis.VtOut = EgtIf( FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX())
    -- approccio e retrazione
-   Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.CalculateLeadInOut( Cutting, EdgeToMachine)
+   Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.CalculateLeadInOut( Cutting, EdgeToMachine, FaceToMachine, b3Raw)
+   -- SCC
+   Cutting.SCC = SawPlusChain.Saw.GetSCC( EdgeToMachine.ToolDirection, FaceToMachine.VtN, Cutting.vtTg)
    -- eventuale step orizzontale
    Cutting.HorizontalSteps = {}
    if Cutting.Tool.SideStep then
@@ -5971,10 +6036,10 @@ function SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
    local bIsCuttingOk = false
    local sCuttingOriginalMessage = Cutting.Message or ''
    local sCuttingApplyMessage = ''
-
    local dOriginalRadialOffset = Cutting.RadialOffset
    local dOriginalLeadInPerpDistance = Cutting.LeadIn.PerpDistance
    local dOriginalLeadOutPerpDistance = Cutting.LeadOut.PerpDistance
+   
    for i = Cutting.HorizontalSteps.Count, 1, -1 do
       Cutting.RadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.StepLength * ( i - 1)
       -- update distanza perpendicolare attacco per contemplare l'offset applicato
@@ -6221,9 +6286,9 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
    -- lavorazione di lama - fondo della tasca o fino a massimo materiale se tunnel
    local Cutting = {}
    if Proc.Topology == 'Tunnel' then
-      Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.OppositeEdges[1])
+      Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.OppositeEdges[1], b3Raw)
    else
-      Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.BottomEdge)
+      Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.BottomEdge, b3Raw)
    end
    local bIsCuttingOk = false
    if Cutting.CanApply then
@@ -6235,7 +6300,7 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
    local dBottomDepthToMachine = Cutting.RadialOffset
    -- lato opposto del tunnel
    if Proc.Topology == 'Tunnel' then
-      Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.OppositeEdges[2])
+      Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.OppositeEdges[2], b3Raw)
       bIsCuttingOk = false
       if Cutting.CanApply then
          bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
@@ -6248,7 +6313,7 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
       if Cutting.CanApply and Cutting.RadialOffset > 10 * GEO.EPS_SMALL then
          -- eventuale lavorazione di lama - lato della tasca da cui inizia la lavorazione
          if Proc.MainFaces.LongFace.Edges.BottomEdge.IsStartOpen then
-            Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.SideEdges.StartEdge)
+            Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.SideEdges.StartEdge, b3Raw)
             bIsCuttingOk = false
             if Cutting.CanApply then
                bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
@@ -6259,7 +6324,7 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
          end
          -- eventuale lavorazione di lama - lato della tasca in cui finisce la lavorazione
          if Proc.MainFaces.LongFace.Edges.BottomEdge.IsEndOpen then
-            Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.SideEdges.EndEdge)
+            Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.SideEdges.EndEdge, b3Raw)
             bIsCuttingOk = false
             if Cutting.CanApply then
                bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
@@ -6688,60 +6753,74 @@ local function AddMillCorner( vFace, Proc, dToolDiam, nAddGrpId, nMasterNewProc,
          -- aggiungo geometria
          local j = EgtIf( i < #vFace, i + 1, EgtIf( bClosed, 1, nil))
          if not j then return true end
-         local nFace2 = vFace[j].Fac
+         if vFace[j].PPrev then
-         -- punto in comune tra le due facce (punto precedente della faccia [j])
+            local nFace2 = vFace[j].Fac
-         ptLoc1 = vFace[j].PPrev
+            -- punto in comune tra le due facce (punto precedente della faccia [j])
-         -- punto precedente (punto precedente della faccia [i])
+            ptLoc1 = vFace[j].PPrev
-         if vFace[i].PPrev then
+            -- punto precedente (punto precedente della faccia [i])
-            ptLoc3 = vFace[i].PPrev
+            if vFace[i].PPrev then
-         else
+               ptLoc3 = vFace[i].PPrev
-            if abs( vtN:getZ()) > abs( vtN:getY()) then
+            elseif vFace[i].PNoPrev then
-               ptLoc3 = Point3d( vFace[i].Cen:getX(), vFace[i].Cen:getY(), ptLoc1:getZ())
+               ptLoc3 = vFace[i].PNoPrev
             else
-               ptLoc3 = Point3d( vFace[i].Cen:getX(), ptLoc1:getY(), vFace[i].Cen:getZ())
+               if abs( vtN:getZ()) > abs( vtN:getY()) then
+                  ptLoc3 = Point3d( vFace[i].Cen:getX(), vFace[i].Cen:getY(), ptLoc1:getZ())
+               else
+                  ptLoc3 = Point3d( vFace[i].Cen:getX(), ptLoc1:getY(), vFace[i].Cen:getZ())
+               end
             end
-         end
+            -- punto successivo ( precedente della faccia successiva)
-         -- punto successivo ( precedente della faccia successiva)
+            local k = EgtIf( j < #vFace, j + 1, EgtIf( bClosed, 1, nil))
-         local k = EgtIf( j < #vFace, j + 1, EgtIf( bClosed, 1, nil))
+            -- se è un percorso aperto prendo il punto medio della seconda faccia come punto locale 2
-         -- se è un percorso aperto prendo il punto medio della seconda faccia come punto locale 2
+            if not k then
-         if not k then
+               if vFace[j].PNoSucc then
-            if abs( vtN:getZ()) > abs( vtN:getY()) then
+                  ptLoc2 = vFace[j].PNoSucc
-               ptLoc2 = Point3d( vFace[j].Cen:getX(), vFace[j].Cen:getY(), ptLoc1:getZ())
+               elseif abs( vtN:getZ()) > abs( vtN:getY()) then
+                  ptLoc2 = Point3d( vFace[j].Cen:getX(), vFace[j].Cen:getY(), ptLoc1:getZ())
+               else
+                  ptLoc2 = Point3d( vFace[j].Cen:getX(), ptLoc1:getY(), vFace[j].Cen:getZ())
+               end
             else
-               ptLoc2 = Point3d( vFace[j].Cen:getX(), ptLoc1:getY(), vFace[j].Cen:getZ())
+               if vFace[j].PNoSucc then
+                  ptLoc2 = vFace[j].PNoSucc
+               elseif vFace[k].PPrev then
+                  ptLoc2 = vFace[k].PPrev
+               elseif abs( vtN:getZ()) > abs( vtN:getY()) then
+                  ptLoc2 = Point3d( vFace[j].Cen:getX(), vFace[j].Cen:getY(), ptLoc1:getZ())
+               else
+                  ptLoc2 = Point3d( vFace[j].Cen:getX(), ptLoc1:getY(), vFace[j].Cen:getZ())
+               end
             end
-         else
+            -- ricavo i punti e l'angolo interno
-            ptLoc2 = vFace[k].PPrev
+            local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( nNewProc.Id, nFace1, nFace2, GDB_ID.ROOT)
-         end
+            -- se punti validi e angolo è interno e non è quasi piatto e >= 90 creo istanza
-         -- ricavo i punti e l'angolo interno
+            local tFacAdj = {}
-         local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( nNewProc.Id, nFace1, nFace2, GDB_ID.ROOT)
+            if ptP1 and ptP2 and dAng < 0 and dAng < -6 and dAng > -( 90 + 10 * GEO.EPS_SMALL)  then
-         -- se punti validi e angolo è interno e non è quasi piatto e >= 90 creo istanza
+               local dLen = dist( ptP1, ptP2)
-         local tFacAdj = {}
+               tFacAdj = { nFace1, nFace2, dLen, ptP1, ptP2, dAng, ptLoc1, ptLoc2, ptLoc3}
-         if ptP1 and ptP2 and dAng < 0 and dAng < -6 and dAng > -( 90 + 10 * GEO.EPS_SMALL)  then
+            end
-            local dLen = dist( ptP1, ptP2)
+            -- se ho un elemento creo percorso o percorsi in base al tipo di cono e all'apertura dall'angolo rispetto ai 90°
-            tFacAdj = { nFace1, nFace2, dLen, ptP1, ptP2, dAng, ptLoc1, ptLoc2, ptLoc3}
+            -- con una tolleranza di 2 gradi
-         end
+            if #tFacAdj > 0 then
-         -- se ho un elemento creo percorso o percorsi in base al tipo di cono e all'apertura dall'angolo rispetto ai 90°
+               if (dAng + 90) > 2 then
-         -- con una tolleranza di 2 gradi
+                  local dAngOffs = (dAng + 90) / 2
-         if #tFacAdj > 0 then
+                  -- primo taglio
-            if (dAng + 90) > 2 then
+                  local bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nAddGrpId, 
-               local dAngOffs = (dAng + 90) / 2
+                                                            dToolDiam, sMilling, -dAngOffs,
-               -- primo taglio
+                                                            ToolData, bMakeLocSurf, vFace, vtN)
-               local bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nAddGrpId, 
+                  if not bOk then return bOk, sErr end
-                                                         dToolDiam, sMilling, -dAngOffs,
+                  -- secondo taglio
-                                                         ToolData, bMakeLocSurf, vFace, vtN)
+                  bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nAddGrpId, 
-               if not bOk then return bOk, sErr end
+                                                      dToolDiam, sMilling, dAngOffs,
-               -- secondo taglio
+                                                      ToolData, bMakeLocSurf, vFace, vtN)
-               bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nAddGrpId, 
+                  if not bOk then return bOk, sErr end
-                                                   dToolDiam, sMilling, dAngOffs,
+               -- altrimenti ho un solo percorso
-                                                   ToolData, bMakeLocSurf, vFace, vtN)
+               else
-               if not bOk then return bOk, sErr end
+                  local bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nAddGrpId, 
-            -- altrimenti ho un solo percorso
+                                                            dToolDiam, sMilling, 0,
-            else
+                                                            ToolData, bMakeLocSurf, vFace, vtN)
-               local bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nAddGrpId, 
+                  if not bOk then return bOk, sErr end
-                                                         dToolDiam, sMilling, 0,
+               end
-                                                         ToolData, bMakeLocSurf, vFace, vtN)
-               if not bOk then return bOk, sErr end
             end
          end
       end
@@ -6777,7 +6856,60 @@ local function GetOtherRegions( nPartId)
 end
 
 ---------------------------------------------------------------------
-local function GetFacesData( nNewProc, dToolDiam, dToolMaxDepth, dToolThick, nAddGrpId, nPartId, vtNBottom)
+local function GetCleanCornerFacesData( nNewProc, dToolDiam, dToolMaxDepth, dToolThick, nAddGrpId, nPartId, vtNBottom, Proc)
+
+   local function GetCleanCornerPointIfNoAdj( nNewProc, Proc, nFac, vFace, ptAdjP1, ptAdjP2)
+      local ptPNoPrev
+      local bAdj, ptLocP1, ptLocP2, dAng
+      if not ptAdjP1 and not ptAdjP2 then
+         bAdj, ptLocP1, ptLocP2, dAng = EgtSurfTmFacetsContact( nNewProc, nFac+1, nFac, GDB_ID.ROOT)
+      else
+         bAdj = true
+         ptLocP1 = ptAdjP1
+         ptLocP2 = ptAdjP2
+      end
+      if bAdj then
+         local vEdges = BL.GetEdgesInfo( nNewProc, nFac)
+         for j = 1, #vEdges do
+            if #vEdges == 4 and ( not AreSamePointApprox( vEdges[j].ptStart, ptLocP1) and not AreSamePointApprox( vEdges[j].ptStart, ptLocP2)) and
+               ( not AreSamePointApprox( vEdges[j].ptEnd, ptLocP1) and not AreSamePointApprox( vEdges[j].ptEnd, ptLocP2)) then
+               -- se rivolto verso Z
+               if abs( vtNBottom:getZ()) > abs( vtNBottom:getY()) then
+                  if vEdges[j].ptStart:getZ() < vEdges[j].ptEnd:getZ() then
+                     ptPNoPrev = vEdges[j].ptStart
+                     break
+                  else
+                     ptPNoPrev = vEdges[j].ptEnd
+                     break
+                  end
+               else
+                  if vtNBottom:getY() > 0 then
+                     ptPNoPrev = EgtIf( vEdges[j].ptStart:getY() < vEdges[j].ptEnd:getY(), vEdges[j].ptStart, vEdges[j].ptEnd)
+                     break
+                  else
+                     ptPNoPrev = EgtIf( vEdges[j].ptStart:getY() > vEdges[j].ptEnd:getY(), vEdges[j].ptStart, vEdges[j].ptEnd)
+                     break
+                  end
+               end
+            elseif #vEdges == 3 then
+               if not AreSamePointApprox( vEdges[j].ptStart, ptLocP1) then
+                  ptPNoPrev = vEdges[j].ptStart
+                  break
+               elseif not AreSamePointApprox( vEdges[j].ptStart, ptLocP2) then
+                  ptPNoPrev = vEdges[j].ptStart
+                  break
+               elseif not AreSamePointApprox( vEdges[j].ptEnd, ptLocP1) then
+                  ptPNoPrev = vEdges[j].ptEnd
+                  break
+               elseif not AreSamePointApprox( vEdges[j].ptEnd, ptLocP2) then
+                  ptPNoPrev = vEdges[j].ptEnd
+                  break
+               end
+            end
+         end
+      end
+      return ptPNoPrev
+   end
 
    local nNumFacet = EgtSurfTmFacetCount( nNewProc)
    local vFace = {}
@@ -6794,14 +6926,17 @@ local function GetFacesData( nNewProc, dToolDiam, dToolMaxDepth, dToolThick, nAd
       local _, dLen, dWidth = BL.GetFaceHvRefDim( nNewProc, nFac)
       -- recupero l'angolo con la faccia precedente
       local bAdj, ptLocP1, ptLocP2, dAng =  EgtSurfTmFacetsContact( nNewProc, nPrecFac, nFac, GDB_ID.ROOT)
+      -- salvo i dati
+      vFace[i] = { Fac = nFac, Cen = ptCen, Norm = vtN, Len = dLen, Width = dWidth, AngPrev = EgtIf( bAdj, dAng, 0)}
+      if not bAdj and Proc.Fct > 3 then
+         vFace[i].PNoPrev = GetCleanCornerPointIfNoAdj( nNewProc, Proc, nFac, vFace[i], nil, nil)
+      end
       -- verifico che l'adiacenza sia veramente con il precedente (percorro con normale a destra)
       if bAdj then
          if ( vtN ^ ( ptLocP1 - ptCen)) * vtNBottom > 0 then
             bAdj = false
          end
       end
-      -- salvo i dati
-      vFace[i] = { Fac = nFac, Cen = ptCen, Norm = vtN, Len = dLen, Width = dWidth, AngPrev = EgtIf( bAdj, dAng, 0)}
       if bAdj then
          -- se rivolto verso Z
          if abs( vtNBottom:getZ()) > abs( vtNBottom:getY()) then
@@ -6817,6 +6952,10 @@ local function GetFacesData( nNewProc, dToolDiam, dToolMaxDepth, dToolThick, nAd
                vFace[i].PPrev = EgtIf( ptLocP1:getY() > ptLocP2:getY(), ptLocP1, ptLocP2)
             end
          end
+         local bAdj_2, ptLocP1_2, ptLocP2_2, dAng_2 = EgtSurfTmFacetsContact( nNewProc, nFac, nFac+1, GDB_ID.ROOT)
+         if not bAdj_2 and Proc.Fct > 3 then
+            vFace[i].PNoSucc = GetCleanCornerPointIfNoAdj( nNewProc, Proc, nFac, vFace[i], ptLocP1, ptLocP2)
+         end
       end
    end
    -- analizzo le facce
@@ -7511,14 +7650,34 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                end
                -- provo con contornatura
                local dDiamTool = 20
+               local nChoosenFacInd = nFacInd2
+               local dChoosenFacElev = dFacElev2
                if bIsL then
                   local bOk, sErr
                   bOk, sWarn, dDiamTool = MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV, dFacElev, dCollSic, true, sMilling, nFacInd2, dFacElev2)
                   if not bOk then return bOk, sWarn end
                else
-                  local sErr = 'Error : Impossible mill special LapJoint'
+                  -- provo ancora con la pocketing dell'altra faccia
-                  EgtOutLog( sErr)
+                  local sPocketing = ML.FindPocketing( sMchFind, dDiam, dFacElev + dCollSic)
-                  return false, sErr
+                  if sPocketing then
+                     nChoosenFacInd = nFacInd
+                     dChoosenFacElev = dFacElev
+                     local Edges = BL.GetEdgesInfo( Proc, Proc.Face[nFacInd+1].Id)
+                     local nSideInd
+                     for i = 1, #Edges do 
+                        if Edges[i].AdjacentFaceId == nFacInd2 then
+                           nSideInd = i - 1
+                           break
+                        end
+                     end
+                     -- se pocketing ok forza facet e spigolo di lavoro
+                     bOk, sWarn = MakeOneFaceByMill( Proc, nPhase, nRawId, nPartId, nFacInd2, nSideInd)
+                     if not bOk then return bOk, sWarn end
+                  else
+                     local sErr = 'Error : Impossible mill special LapJoint'
+                     EgtOutLog( sErr)
+                     return false, sErr
+                  end
                end
                -- inserisco la lavorazione di svuotatura
                local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
@@ -7529,7 +7688,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                   return false, sErr
                end
                -- aggiungo geometria
-               EgtSetMachiningGeometry( {{ Proc.Id, nFacInd2}})
+               EgtSetMachiningGeometry( {{ Proc.Id, nChoosenFacInd}})
                -- imposto uso faccia
                EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.ORTHO_CONT)
                -- imposto posizione braccio porta testa
@@ -7544,7 +7703,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                end
                -- imposto elevazione
                local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
-               sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dFacElev2, 1))
+               sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dChoosenFacElev, 1))
                EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
                -- eseguo
                if not ML.ApplyMachining( true, false) then
@@ -8068,7 +8227,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                                  bSetOpenBorders = true
                               end
                               nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, 
-                              bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, bIs3Faces, b3Solid, bOrthoFacesMaster, bMillDown, bSetOpenBorders, bIsU, bIsL)
+                              bOrthoFaces, sPocketing = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, bIs3Faces, b3Solid, bOrthoFacesMaster, bMillDown, bSetOpenBorders, bIsU, bIsL)
                               if nOk == -3 then
                                  bTryWithBlades = true
                               elseif nOk == -2 then
@@ -8102,6 +8261,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                                  end
                                  -- se abilitato dal parametro Q inserisco pulitura spigoli o contorno con fresa più piccola
                                  local nContourSmallTool = EgtGetInfo( Proc.Id, Q_CONTOUR_SMALL_TOOL, 'i') or 0
+                                 local nCleanCorner = EgtGetInfo( Proc.Id, Q_CLEAN_CORNER, 'i') or 0
                                  if nContourSmallTool > 0 then
                                     local bOk, sWarn2 = MakeRoundCleanCornerOrContour( Proc, nPhase, nRawId, nPartId, b3Raw, 
                                                                                        nFacInd, nAddGrpId, dDiamTool, nContourSmallTool, bMillDown, 
@@ -8113,6 +8273,43 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                                        sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2)
                                     end
                                  end
+                                 -- se richiesta pulizia spigoli con fresa a V
+                                 if nCleanCorner > 0 then
+                                    local dMaxToolMaterial = 0
+                                    if EgtMdbSetCurrMachining( sPocketing) then
+                                       local sTuuidPk = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+                                       if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuidPk) or '') then
+                                          dMaxToolMaterial = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxToolMaterial
+                                       end
+                                    end
+                                    local nNewProc
+                                    local vtSpec = vtN
+                                    if not ( Proc.Fct == 3 and bIsU) then
+                                       nNewProc = RemoveBottomFaceAndReorder( Proc, nAddGrpId, nFacInd, vtN)
+                                    -- se U passante ricavo vettore da "sopra" con componente Z forzata in positivo
+                                    else
+                                       nNewProc = EgtCopyGlob( Proc.Id, nAddGrpId) or GDB_ID.NULL
+                                       local nNumFacet = EgtSurfTmFacetCount( nNewProc)
+                                       -- vettore normale ad una delle facce adiacenti
+                                       local vtOther = EgtSurfTmFacetNormVersor( Proc.Id, Proc.Face[nFacInd+1].Adjacencies[1], GDB_ID.ROOT)
+                                       -- ricavo vettore verso l'alto (simulo faccia di fondo)
+                                       vtSpec = vtN ^ vtOther
+                                       -- se negativo in Z forzo positivo
+                                       if vtSpec:getZ() < 0 then
+                                          vtSpec:mirror(vtSpec)
+                                       end
+                                       ReorderFaces( nNewProc, nNumFacet, vtSpec)
+                                       -- normale della lavorazione clean corner
+                                       vtN = vtSpec
+                                    end
+                                    local vFace, dDepth = GetCleanCornerFacesData( nNewProc, dDiamTool, dMaxToolMaterial, ( dDiamTool/2), nAddGrpId, Proc.PartId, vtN, Proc)
+                                    local bCleanCornerOk, sCleanCornerWarn = AddMillCorner( vFace, Proc, dDiamTool, nAddGrpId, nNewProc, vtN)
+                                    if not bCleanCornerOk then return false, sCleanCornerWarn end
+                                    if sCleanCornerWarn then
+                                       if not sWarn then sWarn = '' end
+                                       sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sCleanCornerWarn, sCleanCornerWarn)
+                                    end
+                                 end
                               end
                            end
                            bOk = true
@@ -8328,8 +8525,27 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                -- se richiesta pulizia spigoli con fresa a V
                if nCleanCorner > 0 then
                   local dThElev = dToolThDiameter / 2 * sqrt( vtN:getX() * vtN:getX() + vtN:getY() * vtN:getY())
-                  local nNewProc = RemoveBottomFaceAndReorder( Proc, nAddGrpId, nFacInd, vtN)
+                  local nNewProc
-                  local vFace, dDepth = GetFacesData( nNewProc, dToolDiameter, dMaxToolMaterial, ( dToolDiameter/2), nAddGrpId, Proc.PartId, vtN)
+                  local vtSpec = vtN
+                  if not ( Proc.Fct == 3 and bIsU) then
+                     nNewProc = RemoveBottomFaceAndReorder( Proc, nAddGrpId, nFacInd, vtN)
+                  -- se U passante ricavo vettore da "sopra" con componente Z forzata in positivo
+                  else
+                     nNewProc = EgtCopyGlob( Proc.Id, nAddGrpId) or GDB_ID.NULL
+                     local nNumFacet = EgtSurfTmFacetCount( nNewProc)
+                     -- vettore normale ad una delle facce adiacenti
+                     local vtOther = EgtSurfTmFacetNormVersor( Proc.Id, Proc.Face[nFacInd+1].Adjacencies[1], GDB_ID.ROOT)
+                     -- ricavo vettore verso l'alto (simulo faccia di fondo)
+                     vtSpec = vtN ^ vtOther
+                     -- se negativo in Z forzo positivo
+                     if vtSpec:getZ() < 0 then
+                        vtSpec:mirror(vtSpec)
+                     end
+                     ReorderFaces( nNewProc, nNumFacet, vtSpec)
+                     -- normale della lavorazione clean corner
+                     vtN = vtSpec
+                  end
+                  local vFace, dDepth = GetCleanCornerFacesData( nNewProc, dToolDiameter, dMaxToolMaterial, ( dToolDiameter/2), nAddGrpId, Proc.PartId, vtN, Proc)
                   local bCleanCornerOk, sCleanCornerWarn = AddMillCorner( vFace, Proc, dToolDiameter, nAddGrpId, nNewProc, vtN)
                   if not bCleanCornerOk then return false, sCleanCornerWarn end
                   if sCleanCornerWarn then

UpdateLog.txt

@@ -1,5 +1,21 @@
            ==== Beam Update Log ====
 
+Versione 3.1g3 (24/07/2026)
+- Fixed : in slot con lama corretta scelta SCC
+
+Versione 3.1g2 (17/07/2026)
+- Modif : Diminuito LastStep forature in doppio
+- Modif : ScarfJoint tra le feature da eseguire dopo i fori che la attraversano
+
+Versione 3.1g1 (14/07/2026)
+- Modif : in slot con lama migliorati attacchi inclinati
+- Modif : in CleanCorner migliorie
+
+Versione 3.1f3 (25/06/2026)
+- Modif : LapJoint - migliorata gestione BirdsMouth con più di 3 facce
+- Modif : Per identificare feature di testa, oltre che verificare se sia troncante, si controlla anche la feature taglio
+- Added : LapJoint - CleanCorner per tasche a 3 facce a U
+
 Versione 3.1f2 (18/06/2026)
 - Added : Gestione svuotature in doppio tipo NT
 

Version.lua

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