BugFix/ScarfOneFaceReduceToCut:

ora se il giunto Gerber ha una sola faccia viene richiamata la Process.Cut

BatchProcess.lua

@@ -42,7 +42,7 @@ if BEAM.FLAG == 0 then
 elseif BEAM.FLAG == 1 then
    sFlag = 'MODIFY'
 elseif BEAM.FLAG == 2 then
-    sFlag = 'SIMULATE'
+   sFlag = 'SIMULATE'
 elseif BEAM.FLAG == 3 then
    sFlag = 'CHECK'
 elseif BEAM.FLAG == 4 then

BatchProcessNew.lua

@@ -1,4 +1,4 @@
--- BatchProcessNew.lua by Egaltech s.r.l. 2022/04/28
+-- BatchProcessNew.lua by Egaltech s.r.l. 2022/08/01
 -- Gestione calcolo batch disposizione e lavorazioni per Travi
 -- 2021/01/07 Per nuova interfaccia Egt.
 -- 2021/01/15 CREATE_BAR ora FLAG = 6 (prima 5).
@@ -10,6 +10,8 @@
 -- 2022/01/07 Per CUTID/TASKID senza ToProcess si verificano anche eventuali Duplo.
 -- 2022/02/09 Aggiornato come Wall per gestione errori e verifica attrezzaggio utensili.
 -- 2022/04/28 In info generazione aggiunta indicazione se 64bit.
+-- 2022/07/24 Modifica per cancellare lavorazioni con ricalcolo e barra già definita.
+-- 2022/08/01 Tolleranza su sezione portata a 0.1 mm (100 * GEO.EPS_SMALL).
 
 -- Intestazioni
 require( 'EgtBase')
@@ -29,7 +31,7 @@ if BEAM.FLAG == 0 then
 elseif BEAM.FLAG == 1 then
    sFlag = 'MODIFY'
 elseif BEAM.FLAG == 2 then
-    sFlag = 'SIMULATE'
+   sFlag = 'SIMULATE'
 elseif BEAM.FLAG == 3 then
    sFlag = 'CHECK'
 elseif BEAM.FLAG == 4 then
@@ -333,8 +335,8 @@ if bToProcess then
       for i = 2, #vBeam do
          local dDimW = vBeam[i].Box:getDimY()
          local dDimH = vBeam[i].Box:getDimZ()
-         if ( abs( dDimW - dRawW) > 10 * GEO.EPS_SMALL  or  abs( dDimH - dRawH) > 10 * GEO.EPS_SMALL)  and
-            ( abs( dDimH - dRawW) > 10 * GEO.EPS_SMALL  or  abs( dDimW - dRawH) > 10 * GEO.EPS_SMALL) then
+         if ( abs( dDimW - dRawW) > 100 * GEO.EPS_SMALL  or  abs( dDimH - dRawH) > 100 * GEO.EPS_SMALL)  and
+            ( abs( dDimH - dRawW) > 100 * GEO.EPS_SMALL  or  abs( dDimW - dRawH) > 100 * GEO.EPS_SMALL) then
             table.insert( vBeamErr, i)
          end
       end
@@ -435,6 +437,8 @@ if bToProcess then
          -- passo al successivo grezzo
          nRawId = EgtGetNextRawPart( nRawId)
       end
+      -- elimino le lavorazioni
+      EgtRemoveAllOperations() 
    end
 
    -- Se richiesta solo barra, esco

LuaLibs/BeamExec.lua

@@ -1,4 +1,4 @@
--- BeamExec.lua by Egaltech s.r.l. 2022/06/25
+-- BeamExec.lua by Egaltech s.r.l. 2022/08/08
 -- Libreria esecuzione lavorazioni per Travi
 -- 2019/07/11 Aggiunta gestione stato rotazione di feature per TS3.
 -- 2019/09/04 Corretto controllo feature di testa e coda con sovramateriale di testa elevato.
@@ -32,6 +32,8 @@
 --            Create le funzioni AnalyzeHeadFeatures e AnalyzeTailFeatures. Spostate più in alto le funzioni CollectFeatures, isHeadFeature e isTailFeature.
 -- 2022/07/01 Aggiunta la gestione delle forature migliorate in presenza di feature testa/coda ad 1 faccia che tagliano tutta la sezione,
 --            controllata tramite il parametro IMPROVE_HEAD_TAIL_DRILLINGS da BeamData. Attivata di default.
+-- 2022/08/01 Tolleranza su sezione portata a 0.1 mm (100 * GEO.EPS_SMALL).
+-- 2022/08/08 Modifica per macchine senza BD.MAX_WIDTH2 e BD.MAX_HEIGHT2.
 
 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -86,7 +88,7 @@ _G.package.loaded.ProcessTyroleanDovetail = nil
 _G.package.loaded.ProcessDovetail = nil
 _G.package.loaded.ProcessFreeContour = nil
 _G.package.loaded.ProcessDecor = nil
-local BM = require( 'MachiningLib')
+local ML = require( 'MachiningLib')
 local BL = require( 'BeamLib')
 local DC = require( 'DiceCut')
 local Fbs = require( 'FacesBySaw')
@@ -387,6 +389,23 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 --    *** Inserimento delle travi nel grezzo ***
+-------------------------------------------------------------------------------------------------------------
+local function VerifyBigSectionCut( dRawW, dRawH)
+   local sCutting = ML.FindCutting( 'TailSide')
+   local dMaxDepth = 50
+   if EgtMdbSetCurrMachining( sCutting or '') then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid or '') or '') then
+         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
+      end
+   end
+   local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
+   local dDimYRef = EgtIf( dRawH < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, abs( BD.MAX_DIM_HTCUT_HBEAM))
+   local bBigSectionCut = ( dRawW > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and
+                          ( dRawH > EgtIf( BD.DOWN_HEAD or BD.TURN, 2, 1) * dMaxVertDepth - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   return bBigSectionCut
+end
+
 -------------------------------------------------------------------------------------------------------------
 function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam, bMachGroupOk)
 
@@ -426,11 +445,8 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam, bMachGroup
    local DeltaS = dOvmHead
    local DeltaSMin = 0
    local DeltaE = BD.OVM_MID
-   -- controllo sezione larga e alta per considerare taglio con sega
-   local bBigSectionCut = false
-   if BD.MAX_DIM_HTCUT and BD.CUT_EXTRA_MIN and ( dRawW > 2 * BD.MAX_DIM_HTCUT - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and ( dRawH > 2 * BD.MAX_DIM_HTCUT - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) then
-      bBigSectionCut = true
-   end
+   -- controllo sezione larga e alta per considerare taglio con sega a catena
+   local bBigSectionCut = VerifyBigSectionCut( dRawW, dRawH)
    for i = 1, #vBeam do
       -- assegno identificativo pezzo
       local Pz = vBeam[i].Id
@@ -475,8 +491,8 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam, bMachGroup
       local PartWidth = b3Solid:getDimY()
       local PartHeight = b3Solid:getDimZ()
       local NextLen = Len - DeltaS - PartLen - DeltaE
-      if (( abs( PartWidth - dRawW) < 10 * GEO.EPS_SMALL  and  abs( PartHeight - dRawH) < 10 * GEO.EPS_SMALL)  or
-          ( abs( PartHeight - dRawW) < 10 * GEO.EPS_SMALL  and  abs( PartWidth - dRawH) < 10 * GEO.EPS_SMALL))  and
+      if (( abs( PartWidth - dRawW) < 100 * GEO.EPS_SMALL  and  abs( PartHeight - dRawH) < 100 * GEO.EPS_SMALL)  or
+          ( abs( PartHeight - dRawW) < 100 * GEO.EPS_SMALL  and  abs( PartWidth - dRawH) < 100 * GEO.EPS_SMALL))  and
          NextLen + DeltaE >= 0 then
          -- eventuale sovramateriale di testa
          if i > 1 and vBeam[i].PosX then
@@ -515,7 +531,7 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam, bMachGroup
          EgtDeselectPartObjs( Pz)
          local ptPos = b3Part:getMin() - b3Solid:getMin() + Vector3d( Delta, ( dRawW - PartWidth) / 2, ( dRawH - PartHeight) / 2)
          EgtAddPartToRawPart( Pz, ptPos, nRaw)
-         if abs( PartWidth - dRawW) > 10 * GEO.EPS_SMALL then
+         if abs( PartWidth - dRawW) > 100 * GEO.EPS_SMALL then
             -- rotazione attorno a centro geometria complessiva del pezzo
             EgtRotatePartInRawPart( Pz, X_AX(), 90)
             -- correggo per eccentricità solido rispetto a geometria complessiva del pezzo
@@ -582,8 +598,12 @@ local function Verify90DegRotation( nRawId)
    local dRawW = EgtGetRawPartBBox( nRawId):getDimY()
    local dRawH = EgtGetRawPartBBox( nRawId):getDimZ()
    -- verifica dell'altezza rispetto alla massima larghezza
-   return ( dRawH < BD.MAX_WIDTH + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT + 10 * GEO.EPS_SMALL) or
-          ( dRawH < BD.MAX_WIDTH2 + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT2 + 10 * GEO.EPS_SMALL)
+   if not BD.MAX_WIDTH2 or not BD.MAX_HEIGHT2 then
+      return ( dRawH < BD.MAX_WIDTH + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT + 10 * GEO.EPS_SMALL)
+   else
+      return ( dRawH < BD.MAX_WIDTH + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT + 10 * GEO.EPS_SMALL) or
+            ( dRawH < BD.MAX_WIDTH2 + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT2 + 10 * GEO.EPS_SMALL)
+   end
 end
 
 -------------------------------------------------------------------------------------------------------------

LuaLibs/BeamLib.lua

@@ -14,6 +14,8 @@
 -- 2022/05/18 Correzioni e migliorie a PutStartNearestToEdge.
 -- 2022/06/25 Rese globali le funzioni GetChainSawBlockedAxis e GetChainSawInitAngs prima in ProcessLapJpoint.
 -- 2022/07/12 A GetFaceHvRefDim aggiunta possibilità di confronto e limitazione dimensioni con grezzo/pezzo (conta solo la sezione).
+-- 2022/07/26 Aggiunta la funzione FindFaceBestOrientedAsAxis, precedentemente in ProcessLapJoint
+-- 2022/07/26 Alla funzione FindFaceBestOrientedAsAxis aggiunta la possibilità di escludere una faccia dalla ricerca
 
 -- Tabella per definizione modulo
 local BeamLib = {}
@@ -369,17 +371,17 @@ end
 
 ---------------------------------------------------------------------
 function BeamLib.GetVersRef( nOrthoOpposite)
-   if nOrthoOpposite == MCH_MILL_FU.ORTHO_LEFT then
+   if nOrthoOpposite == MCH_MILL_FU.ORTHO_LEFT or nOrthoOpposite == MCH_MILL_FU.ORTUP_LEFT or nOrthoOpposite == MCH_MILL_FU.PARAL_LEFT then
       return X_AX()
-   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_RIGHT then
+   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_RIGHT or nOrthoOpposite == MCH_MILL_FU.ORTUP_RIGHT or nOrthoOpposite == MCH_MILL_FU.PARAL_RIGHT then
       return -X_AX()
-   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_FRONT then
+   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_FRONT or nOrthoOpposite == MCH_MILL_FU.ORTUP_FRONT or nOrthoOpposite == MCH_MILL_FU.PARAL_FRONT then
       return Y_AX()
-   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_BACK then
+   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_BACK or nOrthoOpposite == MCH_MILL_FU.ORTUP_BACK or nOrthoOpposite == MCH_MILL_FU.PARAL_BACK then
       return -Y_AX()
-   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_DOWN then
+   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_DOWN or nOrthoOpposite == MCH_MILL_FU.ORTUP_DOWN or nOrthoOpposite == MCH_MILL_FU.PARAL_DOWN then
       return Z_AX()
-   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_TOP then
+   elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_TOP or nOrthoOpposite == MCH_MILL_FU.ORTUP_TOP or nOrthoOpposite == MCH_MILL_FU.PARAL_TOP then
       return -Z_AX()
    end
    return nil
@@ -703,7 +705,7 @@ function BeamLib.GetNzLimDownUp( b3Raw, vtN, vtOrtho)
    if BD.C_SIMM or BD.TURN then
       return -0.484
    else
-      if vtOrtho and vtOrtho:getZ() > 0.5 then
+      if vtOrtho and vtOrtho:getZ() > 0.35 then
          -- N_HorAng < 15° or N_HorAng > 55°
          if vtN and ( abs( vtN:getY()) < 0.259 or abs( vtN:getY()) > 0.819) then
             return -0.708
@@ -794,5 +796,23 @@ function BeamLib.GetChainSawInitAngs( vtN, vtO, nInd)
    end
 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)
+   local nFaceIndMax = 0
+   local dMaxComp = 0
+   fctExclude = fctExclude or -1
+   for i = 1, Proc.Fct do
+      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT)
+      local dComp = abs( vtN * vtAx)
+      if dComp > dMaxComp and i ~= fctExclude + 1 then
+         nFaceIndMax = i -1
+         dMaxComp = dComp
+      end
+   end
+   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFaceIndMax, GDB_ID.ROOT)
+   return nFaceIndMax, ptC, vtN
+end
+
 -------------------------------------------------------------------------------------------------------------
 return BeamLib

LuaLibs/MachiningLib.lua

@@ -1,6 +1,7 @@
 -- MachiningLib.lua by Egaltech s.r.l. 2022/05/07
 -- Libreria ricerca lavorazioni per Travi
 -- 2022/05/07 ES Profonde modifiche per scelta ottimale lavorazioni in macchine con più teste.
+-- 2022/07/27 Aggiunta la gestione del tipo di foratura "AngleDrill" per fori molto inclinati
 
 -- Tabella per definizione modulo
 local MachiningLib = {}
@@ -110,24 +111,6 @@ local function SetCurrMachiningAndTool( sMachName)
    return bActive, sTool, bH2, bFixed
 end
 
----------------------------------------------------------------------
-local function StartsWith( sStr, sStart)
-   if ( sStart == "" or sStr:sub( 1, #sStart) == sStart) then
-      return true, sStr:sub( 1, #sStr - #sStart)
-   else
-      return false, sStr
-   end
-end
-
----------------------------------------------------------------------
-local function EndsWith( sStr, sEnd)
-   if ( sEnd == "" or sStr:sub(-#sEnd) == sEnd) then
-      return true, sStr:sub(1, #sStr - #sEnd)
-   else
-      return false, sStr
-   end
-end
-
 ---------------------------------------------------------------------
 function VerifyDrill( dDiam, dDepth, bH2)
    local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
@@ -188,9 +171,9 @@ end
 ---------------------------------------------------------------------
 function VerifyTool( MachiningType, sType, Params, bH2)
    if MachiningType == MCH_MY.DRILLING then
-      if StartsWith( sType, 'Drill') then
+      if EgtStartsWith( sType, 'Drill') or EgtStartsWith( sType, 'AngleDrill') then
          return VerifyDrill( Params.Diam, Params.Depth, bH2)
-      elseif StartsWith( sType, 'Pocket') then
+      elseif EgtStartsWith( sType, 'Pocket') then
          return VerifyDrillPocket( Params.Diam, Params.Depth, bH2)
       end
    elseif MachiningType == MCH_MY.SAWING then
@@ -224,8 +207,8 @@ end
 ---------------------------------------------------------------------
 function ReturnParams( MachiningType, MachiningName, sType, ToolParams)
    if MachiningType == MCH_MY.DRILLING then
-      local _, sOrigType = EndsWith( sType, '_H2')
-      return MachiningName, sType, EgtIf( sOrigType == 'Drill', ToolParams.TMaxMat, ToolParams.TMaxDepth), ToolParams.MaxToolLength, ToolParams.ToolDiam, ToolParams.DiamTh, ToolParams.FreeLen
+      local _, sOrigType = EgtEndsWith( sType, '_H2')
+      return MachiningName, sType, EgtIf( sOrigType == 'Drill' or sOrigType == 'AngleDrill' , ToolParams.TMaxMat, ToolParams.TMaxDepth), ToolParams.MaxToolLength, ToolParams.ToolDiam, ToolParams.DiamTh, ToolParams.FreeLen
    elseif MachiningType == MCH_MY.SAWING then
       return MachiningName, ToolParams.H2
    elseif MachiningType == MCH_MY.MILLING then
@@ -266,9 +249,9 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
       ForStep = -1
    end
    if ( BEAM and BEAM.BW) or MachineHeadType == ONE_HEAD or MachineHeadType == TWO_EQUAL_HEADS or ( MachineHeadType == TWO_UP_DOWN_HEADS and not bDownHead) then
-      _, sType = EndsWith( sType, '_H2')
+      _, sType = EgtEndsWith( sType, '_H2')
    elseif ( not BEAM or not BEAM.BW) and MachineHeadType == TWO_UP_DOWN_HEADS and bDownHead then
-      if not EndsWith( sType, '_H2') then
+      if not EgtEndsWith( sType, '_H2') then
          sType = sType .. '_H2'
       end
    end
@@ -284,7 +267,7 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
       local Machining = Machinings[i]
       local sMachiningType = Machining.Type
       if BEAM and BEAM.BW then
-         _, sMachiningType = EndsWith( Machining.Type, '_H2')
+         _, sMachiningType = EgtEndsWith( Machining.Type, '_H2')
       end
       -- recupero dati utensile
       local bToolActive, sToolName, bH2, bFixed = SetCurrMachiningAndTool( Machining.Name)
@@ -355,7 +338,7 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
          end
       end
    end
-   local bH2, sOrigType = EndsWith( sType, '_H2')
+   local bH2, sOrigType = EgtEndsWith( sType, '_H2')
    if ( not BEAM or not BEAM.BW) and MachineHeadType == TWO_UP_DOWN_HEADS and bH2 and bTopHead then
       return FindMachining( MachiningType, sOrigType, Params, true, false)
    end
@@ -377,6 +360,14 @@ function MachiningLib.FindDrilling( dDiam, dDepth, bTopHead, bDownHead)
    end
 end
 
+---------------------------------------------------------------------
+function MachiningLib.FindAngleDrilling( dDiam, dDepth, bTopHead, bDownHead)
+   local MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, 'AngleDrill', { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead)
+   if MachiningName and MachiningName ~= '' then
+      return MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5
+   end
+end
+
 ---------------------------------------------------------------------
 function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bTopHead, bDownHead)
    return FindMachining( MCH_MY.MILLING, sType, { Depth = dDepth, TuuidMstr = sTuuidMstr, MaxDiam = dMaxDiam, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead)

LuaLibs/ProcessCut.lua

@@ -1,4 +1,4 @@
--- ProcessCut.lua by Egaltech s.r.l. 2022/06/28
+-- ProcessCut.lua by Egaltech s.r.l. 2022/07/28
 -- Gestione calcolo singoli tagli di lama per Travi
 -- 2021/05/18 I due tagli con testa da sotto di un cubetto sono fatti di seguito.
 -- 2021/06/06 Correzioni per tagli con testa da sotto.
@@ -11,6 +11,7 @@
 -- 2022/05/31 Alcune modifiche per utilizzare la ProcessCut.Make in ProcessSplit e ProcessHeadCut, per le sezioni alte e larghe.
 -- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe).
 -- 2022/06/28 Modificata determinazione taglio bFromBottom in MakeFromTop.
+-- 2022/07/18 Se Q04=1, aggiunto LongCut anche dal lato per macchine tipo PF1250.
 
 -- Tabella per definizione modulo
 local ProcessCut = {}
@@ -243,9 +244,18 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
    local bLongCut = ( not bDownCut and vtN:getZ() > 0.865 and
                       Proc.Box:getDimY() > b3Solid:getDimY() - 10 * GEO.EPS_SMALL and
                       ( Proc.Box:getDimX() > 0.75 * b3Solid:getDimX() or Proc.Box:getDimX() > 600.000))
+   -- verifico se da considerare taglio lungo dal lato, solo per macchine tipo PF1250, inclinato non più di 30deg
+   local bLongCutFromSide = ( not bDownCut and ( BD.C_SIMM and BD.DOWN_HEAD and ( vtN:getY() > 0.865 or vtN:getY() < -0.865) and
+                              Proc.Box:getDimZ() > b3Solid:getDimZ() - 10 * GEO.EPS_SMALL) and
+                              ( Proc.Box:getDimX() > 0.75 * b3Solid:getDimX() or Proc.Box:getDimX() > 600.000))
    -- se taglio lungo e Q04 = 1 allora lancio il processo dell'L10
-   if bLongCut and EgtGetInfo( Proc.Id, 'Q04', 'i') == 1 then
-      return LongCut.Make( Proc, nPhase, nRawId, nPartId, true)
+   local bNoDicing = EgtGetInfo( Proc.Id, 'Q04', 'i') == 1
+   if bNoDicing then
+      if bLongCut then
+         return LongCut.Make( Proc, nPhase, nRawId, nPartId, true)
+      elseif bLongCutFromSide then
+         return LongCut.Make( Proc, nPhase, nRawId, nPartId, false, 2)
+      end
    end
    -- se pezzo ancora attaccato alla trave, per non rovinare quello successivo
    local bFillAreaPiece
@@ -312,7 +322,8 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
    local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
    -- determino la direzione di taglio preferenziale
    local frFac, dCutH, dCutV = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
-   local bHorizCut = ( dCutV < dMaxVertDepth - BD.CUT_EXTRA and not bDownCut)
+   local bHorizCut = ( dCutV < dMaxVertDepth - BD.CUT_EXTRA and not bDownCut) or
+                     ( dCutV < 0.8 * dMaxVertDepth - BD.CUT_EXTRA and b3Solid:getDimZ() < 0.8 * dMaxVertDepth - BD.CUT_EXTRA)
    local bVertCutOk = ( dCutH < dMaxDepth - BD.CUT_EXTRA)
    -- recupero gruppo per geometria addizionale
    local nAddGrpId = BL.GetAddGroup( nPartId)
@@ -392,14 +403,12 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
             else
                if bHorizCut then
                   vtOrthoO = Z_AX()
-               elseif vtN:getY() > -0.02 then
-                  if not Proc.Head then
-                     vtOrthoO = -Y_AX()
-                  else
-                     vtOrthoO = Y_AX()
-                  end
                else
-                  vtOrthoO = -Y_AX()
+                  if vtN:getZ() < dNzLimDwnUp then
+                     vtOrthoO = EgtIf( vtN:getY() > -0.02, -Y_AX(), Y_AX())
+                  else
+                     vtOrthoO = EgtIf( vtN:getY() > 0.02, Y_AX(), -Y_AX())
+                  end
                end
             end
          end
@@ -457,7 +466,7 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
       local vtOrthoO
       if bFromBottom and dCutV < dMaxVertDepth - BD.CUT_EXTRA and vtN:getZ() > 0 then
          vtOrthoO = -Z_AX()
-      elseif bHorizCut and ( not bVertCutOk or b3Solid:getDimX() > BD.LEN_SHORT_PART or Proc.AdvTail or vtN:getX() > 0) then
+      elseif bHorizCut and ( not bVertCutOk or b3Solid:getDimX() > BD.LEN_SHORT_PART or Proc.AdvTail or vtN:getX() > 0 or ( abs( vtN:getY()) < 0.1 and vtN:getZ() <= 0)) then
          vtOrthoO = Z_AX()
       elseif b3Solid:getDimX() < BD.LEN_SHORT_PART and not Proc.AdvTail and abs( vtN:getY()) > 0.259 and
              vtN:getZ() > -0.174 and abs( vtN:getY()) > abs( vtN:getZ()) and dCutH < dMaxDepth + 10 * GEO.EPS_SMALL then

LuaLibs/ProcessDoubleCut.lua

@@ -272,6 +272,7 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    else
       -- eseguo
       local sCutType = EgtIf( bHead, 'HeadSide', 'TailSide')
+      local bDownHead = ( BD.DOWN_HEAD and vtNm:getZ() < BD.NZ_MINB)
       local bOk, sErr = Fbs.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, sCutType, false, bDownHead)
       if not bOk then return bOk, sErr end
       -- segnalazione ingombro di testa o coda

LuaLibs/ProcessDrill.lua

@@ -10,6 +10,8 @@
 -- 2022/06/22 Nel riconoscimento fori di coda si utilizza ora il reale sovramateriale di coda (dOvmTail) invece di BD.OVM_MID.
 -- 2022/07/01 Aggiunta gestione allungamento percorsi fori in caso di materiale già rimosso da lavorazioni precedenti
 -- 2022/07/07 Aggiunta la gestione delle forature migliorate in presenza di feature testa/coda che tagliano tutta la sezione; gli Id delle feature sono nelle proprietà MachineAfterHeadCutId e MachineAfterTailCutId.
+-- 2022/07/12 Aggiunto un valore minimo (10) per la distanza di sicurezza.
+-- 2022/07/27 Aggiunta la gestione del tipo di foratura "AngleDrill" per fori molto inclinati
 
 -- Tabella per definizione modulo
 local ProcessDrill = {}
@@ -167,9 +169,43 @@ function ProcessDrill.Classify( Proc, b3Raw)
    end
 end
 
+---------------------------------------------------------------------
+-- Funzione per riconoscimento faccia inizio foro e dati correlati
+-- Indice faccia :1=Front, 2=Bottom, 3=Back, 4=Top, 5=Left, 6=Right
+local function GetHoleStartData( ptCen, vtExtr, b3Solid)
+   -- Facce della trave
+   local vFaces = { { Dist = -b3Solid:getMin():getY(), Norm = -Y_AX()},
+                    { Dist = -b3Solid:getMin():getZ(), Norm = -Z_AX()},
+                    { Dist = b3Solid:getMax():getY(), Norm = Y_AX()},
+                    { Dist = b3Solid:getMax():getZ(), Norm = Z_AX()},
+                    { Dist = -b3Solid:getMin():getX(), Norm = -X_AX()},
+                    { Dist = b3Solid:getMax():getX(), Norm = X_AX()}}
+   -- Ricerca della faccia di inizio
+   local nFac = 0
+   local dCosMin = 0.0871
+   for i = 1, 6 do
+      if ( ptCen - ORIG()) * vFaces[i].Norm - vFaces[i].Dist > -2 then
+         local dCos = vtExtr * vFaces[i].Norm
+         if dCos > dCosMin then
+            nFac = i
+            dCosMin = dCos
+            if dCos > 0.7072 then break end
+         end
+      end
+   end
+   -- Coseno angolo dalla faccia
+   local CosB = 0
+   if nFac ~= 0 then
+      CosB = sqrt( 1 - sqr( vtExtr * vFaces[nFac].Norm))
+   end
+   return nFac, CosB, vFaces
+end
+
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
+   -- default per costanti
+   BD.DRILL_VX_MAX_ANGLEDRILL = ( BD.DRILL_VX_MAX_ANGLEDRILL or 0.928)
    -- ingombro del pezzo
    local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
    if not b3Solid then
@@ -188,21 +224,32 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
    -- recupero i dati del foro
    local dDiam = 2 * EgtArcRadius( AuxId)
    local dLen = abs( EgtCurveThickness( AuxId))
+   local ptCen = EgtCP( AuxId, GDB_RT.GLOB)
    local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
-   if Proc.Flg == -2 then vtExtr = - vtExtr end
+   if Proc.Flg == -2 then
+      ptCen = ptCen - vtExtr * dLen
+      vtExtr = - vtExtr
+   end
    local bOpen = ( Proc.Fcs ~= 0  and  Proc.Fce ~= 0)
    -- verifico che il foro non sia fattibile solo da sotto
-   local bToInvert = ( vtExtr:getZ() < BD.DRILL_VZ_MIN) and not BD.DOWN_HEAD
+   local bToInvert = ( vtExtr:getZ() < BD.DRILL_VZ_MIN and not BD.DOWN_HEAD)
    if bToInvert  and  ( not bOpen or Proc.Flg ~= 1) then
       local sErr = 'Error : drilling from bottom impossible'
       EgtOutLog( sErr)
       return false, sErr
    end
-   -- se il foro è cieco o troppo inclinato all'inizio, lo inverto
-   if Proc.Fcs == 0 or ( abs( vtExtr:getX()) > BD.DRILL_VX_MAX and Proc.Fcs ~= 5  and Proc.Fcs ~= 6) then
-      bToInvert = true
+   -- se non già richiesta inversione e invertibile
+   if not bToInvert and Proc.Flg == 1 and ( -vtExtr:getZ() >= BD.DRILL_VZ_MIN or BD.DOWN_HEAD) then
+      -- se il foro è cieco o troppo inclinato all'inizio, lo inverto
+      local _, CosB, _ = GetHoleStartData( ptCen, vtExtr, b3Solid)
+      if Proc.Fcs == 0 or ( CosB > BD.DRILL_VX_MAX and bOpen) then
+         bToInvert = true
+      end
+   end
+   if bToInvert then
+      ptCen = ptCen - vtExtr * dLen
+      vtExtr = - vtExtr
    end
-   if bToInvert then vtExtr = - vtExtr end
    -- se foro è splittato ed è la parte opposta, inverto
    if Proc.Flg == -2 then bToInvert = true end
    -- profondità geometrica del foro
@@ -216,7 +263,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
    local nErrorCode = 0
    -- abilitazione foratura da sotto
    local bDrillDown = ( BD.DOWN_HEAD and ( Proc.Down or vtExtr:getZ() < -0.1 or vtExtr:getZ() < 0.259))
-   local bDrillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.259)
+   local bDrillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.5)
    -- primo gruppo di controlli con lunghezza utensile pari a metà foro se passante
    -- recupero la lavorazione
    local sDrilling, sType, dMaxDepth, dMaxToolLength, dToolDiam, dDiamTh, dToolFreeLen = ML.FindDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown)
@@ -278,6 +325,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
    local bCommonCompare = BD.MAX_TOOL_LEN_BACK_HOR_MACH and bOpen and abs(vtExtr:getX()) < 0.5 and abs(vtExtr:getZ()) < 0.5
    if nErrorCode == 0 and not bToInvert and bCommonCompare and vtExtr:getY() > 0.866 and Proc.Flg == 1 and dMaxToolLength > BD.MAX_TOOL_LEN_BACK_HOR_MACH then
       bToInvert = true
+      ptCen = ptCen - vtExtr * dLen
       vtExtr = - vtExtr
    ---------------------------------------------------------------------------------------------------------------------------------------------------------
    ---------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -296,8 +344,9 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
       dToolFreeLen = dToolFreeLen2
       dDepth       = dDepth2
       if vtExtr:getY() > 0 then
-         bToInvert    = true
-         vtExtr       = - vtExtr
+         bToInvert = true
+         ptCen = ptCen - vtExtr * dLen
+         vtExtr = - vtExtr
       end
    -- se sono al secondo mezzo foro con utensile che supera la lunghezza di riferimento non lo eseguo
    elseif nErrorCode == 0 and bCommonCompare and abs(vtExtr:getY()) > 0.866 and Proc.Flg == -2 and dMaxToolLength2 > BD.MAX_TOOL_LEN_BACK_HOR_MACH then
@@ -312,55 +361,64 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
       EgtOutLog( sErr)
       return false, sErr
    end
-   -- conservo il valore originale di MaxDepth per poter eventualmente bypassare i check successivi
+   -- Determino la faccia di inizio del foro e dati correlati 
+   local nFac, CosB, vFaces = GetHoleStartData( ptCen, vtExtr, b3Solid)
+   -- Calcolo acciorciamento affondamento utile per evitare collisione portautensile con faccia
+   local TgA = CosB / sqrt( 1 - CosB * CosB)
+   local dSubL = ( dDiamTh / 2 + ( Proc.Diam - dToolDiam) / 2 + 2) * TgA
    local dMaxDepthOri = dMaxDepth
-   -- verifico il massimo affondamento
-   local dSubL1 = 0
-   local dSubL2 = 0
-   local dSubL3 = 0
-   local dDeltaRad = ( Proc.Diam - dToolDiam) / 2
-   -- se foro non su testa o coda e inclinato
-   local bInMid = false 
-   local bInvertFcse = ( bToInvert and Proc.Flg ~= -2)
-   if ( not bInvertFcse and Proc.Fcs ~= 5 and Proc.Fcs ~= 6) or ( bInvertFcse and Proc.Fce ~= 5 and Proc.Fce ~= 6) then
-      bInMid = true
-      local CosB = abs( vtExtr:getX())
-      if CosB < BD.DRILL_VX_MAX then
-         local TgA = CosB / sqrt( 1 - CosB * CosB)
-         dSubL1 = ( dDiamTh / 2 + dDeltaRad + 2) * TgA
-      else
-         dMaxDepth = 0
+   dMaxDepth = min( dMaxDepth, dToolFreeLen - dSubL)
+   -- Verifico inclinazione foro nei limiti
+   local bTryDrill = ( CosB < BD.DRILL_VX_MAX)
+   if ( CosB > 0.8 * BD.DRILL_VX_MAX and CosB < BD.DRILL_VX_MAX_ANGLEDRILL) then
+      -- cerco le forature speciali AngleDrill
+      local sDrilling3, sType3, dMaxDepth3 = ML.FindAngleDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown)
+      if sDrilling3 then
+         sDrilling = sDrilling3
+         sType = sType3
+         dMaxDepth = dMaxDepth3
+         bTryDrill = true
       end
    end
-   -- se foro davanti o dietro e inclinato
-   if dMaxDepth > 0 and abs( vtExtr:getY()) > abs( vtExtr:getZ()) then
-      local CosB = abs( vtExtr:getY())
-      if bInMid then
-         CosB = sqrt( vtExtr:getZ() * vtExtr:getZ() + vtExtr:getX() * vtExtr:getX())
-      end
-      if CosB < BD.DRILL_VX_MAX then
-         local TgA = CosB / sqrt( 1 - CosB * CosB)
-         dSubL2 = ( dDiamTh / 2 + dDeltaRad + 2) * TgA
-      else
-         dMaxDepth = 0
+   -- aggiusto affondamento e MaxElev
+   local dMaxElev
+   local sMyWarn
+   -- se c'è un taglio precedente di testa o coda in cui il foro "entra" devo ricalcolare i dati della foratura
+   if (( Proc.MachineAfterHeadCutId and vtExtr:getX() > 0) or ( Proc.MachineAfterTailCutId and vtExtr:getX() < 0)) then
+      local bIntersectionOk, _, vDistance = EgtLineSurfTmInters( ptCen, -vtExtr, Proc.MachineAfterHeadCutId or Proc.MachineAfterTailCutId, GDB_RT.GLOB)
+      if bIntersectionOk then
+         local dHoleToCutDistance = vDistance[1]
+         -- se il taglio accorcia realmente il foro
+         if dHoleToCutDistance > 10 * GEO.EPS_SMALL and dHoleToCutDistance < dLen then
+            dMaxDepth = dMaxDepthOri
+            dMaxElev = dLen - dHoleToCutDistance
+            bTryDrill = true
+            local dToolAddLength = dLen - dMaxElev
+            -- se l'utensile è comunque troppo corto lavoro il massimo possibile
+            if dDepth - dToolAddLength > dMaxDepth + 10 * GEO.EPS_SMALL then
+               sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth - dToolAddLength, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+               dDepth = dLen
+            else
+               -- se è un foro splittato cerco comunque di arrivare alla massima profondità possibile, evitando di sfondare dall'altro lato.
+               if Proc.Flg == 2 or Proc.Flg == -2 then
+                  dDepth = dLen - 10
+               end
+               -- se non lavoro la massima lunghezza disponibile devo correggere MaxElev
+               dMaxElev = dMaxElev - dLen + dDepth
+            end
+         end
       end
    end
-   -- se foro sopra o sotto e inclinato
-   if dMaxDepth > 0 and abs( vtExtr:getZ()) > abs( vtExtr:getY()) then
-      local CosB = abs( vtExtr:getZ())
-      if bInMid then
-         CosB = sqrt( vtExtr:getY() * vtExtr:getY() + vtExtr:getX() * vtExtr:getX())
-      end
-      if CosB < BD.DRILL_VX_MAX then
-         local TgA = CosB / sqrt( 1 - CosB * CosB)
-         dSubL3 = ( dDiamTh / 2 + dDeltaRad + 2) * TgA
-      else
-         dMaxDepth = 0
-      end
-   end
-   local dSubL = max( dSubL1, dSubL2, dSubL3)
-   if dMaxDepth > 0 then
-      dMaxDepth = min( dMaxDepth, dToolFreeLen - dSubL)
+   -- se foro da saltare per eccessiva inclinazione
+   if not bTryDrill then
+      sMyWarn = 'Warning in drill : too slant hole'
+      dDepth = 0
+      return true, sMyWarn
+   -- se non ridotto e affondamento richiesto supera il consentito
+   elseif not dMaxElev and dDepth > dMaxDepth + 10 * GEO.EPS_SMALL then
+      sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+      dDepth = dMaxDepth
+      dMaxElev = dMaxDepth
    end
    -- inserisco la lavorazione
    local sName = 'Drill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
@@ -373,7 +431,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
    -- aggiungo geometria
    EgtSetMachiningGeometry( {{ AuxId, -1}})
    -- eventuale inversione
-   if sType == 'Drill' or sType == 'Drill_H2' then
+   if sType == 'Drill' or sType == 'Drill_H2' or sType == 'AngleDrill' then
       EgtSetMachiningParam( MCH_MP.INVERT, bToInvert)
    else
       EgtSetMachiningParam( MCH_MP.TOOLINVERT, bToInvert)
@@ -395,64 +453,21 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
       nSCC = MCH_SCC.NONE
    end
    EgtSetMachiningParam( MCH_MP.SCC, nSCC)
-   -- aggiusto affondamento e MaxElev
-   local dMaxElev = dDepth
-   local sMyWarn
-   if dDepth > dMaxDepth + 10 * GEO.EPS_SMALL then
-      -- se c'è un taglio precedente di testa o coda posso impostare MaxElev per allungare il percorso
-      -- considero solo i fori "entranti" in testa o coda
-      if (( Proc.MachineAfterHeadCutId and vtExtr:getX() > 0) or ( Proc.MachineAfterTailCutId and vtExtr:getX() < 0)) then
-         local ptCen = EgtCP( AuxId, GDB_RT.GLOB)
-         local bIntersectionOk, _, vDistance = EgtLineSurfTmInters( ptCen, -vtExtr, Proc.MachineAfterHeadCutId or Proc.MachineAfterTailCutId, GDB_RT.GLOB)
-         dHoleToCutDistance = vDistance[1]
-         -- setto MaxElev
-         -- il segno della distanza data dalla funzione di intersezione mi indica dove sia la geometria del foro
-         if bIntersectionOk then
-            -- se MaxDepth era stato settato a 0 per disattivare la lavorazione gli riassegno il valore originale
-            if dMaxDepth == 0 then
-               dMaxDepth = dMaxDepthOri
-            end
-            if dHoleToCutDistance > 0 then
-               dMaxElev = dLen - dHoleToCutDistance
-            elseif dHoleToCutDistance < 0 then
-               dMaxElev = -dHoleToCutDistance
-            end
-            local dToolAddLength = dLen - dMaxElev
-            -- se l'utensile è comunque troppo corto lavoro il massimo possibile
-            if dDepth - dToolAddLength > dMaxDepth + 10 * GEO.EPS_SMALL then
-               sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth - dToolAddLength, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-               dDepth = dLen
-            else
-               -- se è un foro splittato cerco comunque di arrivare alla massima profondità possibile, evitando di sfondare dall'altro lato.
-               if Proc.Flg == 2 or Proc.Flg == -2 then
-                  dDepth = dLen - 10
-               end
-               -- se non lavoro la massima lunghezza disponibile devo correggere MaxElev
-               dMaxElev = dMaxElev - dLen + dDepth
-            end
-         -- se per qualche motivo fallisce l'intersezione torno al caso standard
-         else
-            sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-            dDepth = dMaxDepth
-            dMaxElev = dMaxDepth
-         end
-      -- caso standard
-      else
-         sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-         dDepth = dMaxDepth
-         dMaxElev = dMaxDepth
-      end
-      if sMyWarn then
-         EgtOutLog( sMyWarn)
-      end
-   end
+   -- imposto affondamento
    EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
+   -- imposto il valore della distanza di sicurezza per l'attacco. Se il valore del db utensili è troppo basso lo alzo a 10.
+   local dToolDbStartPos = EgtGetMachiningParam( MCH_MP.STARTPOS)
+   local dMinStartPos = 10
+   local dStartPos = max( dMinStartPos, dToolDbStartPos)
+   EgtSetMachiningParam( MCH_MP.STARTPOS, dStartPos)
    -- Note utente con dichiarazione nessuna generazione sfridi per Vmill
    local sUserNotes = 'VMRS=0;'
    -- aggiungo alle note massima elevazione (coincide con affondamento)
-   sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( dMaxElev, 1) .. ';'
+   if dMaxElev then
+      sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( dMaxElev, 1) .. ';'
+   end
    -- se foro passante, aggiungo questa qualifica alle note
-   if ( sType == 'Drill' or sType == 'Drill_H2') and  bOpen then
+   if ( sType == 'Drill' or sType == 'Drill_H2' or sType == 'AngleDrill') and  bOpen then
       sUserNotes = sUserNotes .. 'Open=1;'
    end
    -- se lavorazione in doppio
@@ -465,7 +480,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
    -- eseguo
    local bOk = ML.ApplyMachining( true, false)
    if not bOk and BD.DOWN_HEAD then
-      if sType == 'Drill' or sType == 'Drill_H2' then
+      if sType == 'Drill' or sType == 'Drill_H2' or sType == 'AngleDrill' then
          EgtSetMachiningParam( MCH_MP.INVERT, true)
       else
          EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)

LuaLibs/ProcessHeadCut.lua

@@ -1,4 +1,4 @@
--- ProcessSplit.lua by Egaltech s.r.l. 2022/06/07
+-- ProcessSplit.lua by Egaltech s.r.l. 2022/07/25
 -- Gestione calcolo tagli di testa per Travi
 -- 2022/05/31 Aggiunta gestione sezioni alte e larghe con taglio di tipo diceCut.
 -- 2022/06/10 Per sezioni alte e larghe aggiunta gestione finitura in base a sovramateriale e a parametro Q05 dell' eventuale lavorazione sostituita.
@@ -174,8 +174,9 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
    end
    local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
    -- caratteristiche taglio
-   local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, BD.MAX_DIM_HTCUT_HBEAM)
-   local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and ( b3Raw:getDimZ() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, abs( BD.MAX_DIM_HTCUT_HBEAM))
+   local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and
+                          ( b3Raw:getDimZ() > EgtIf( BD.DOWN_HEAD or BD.TURN, 2, 1) * dMaxVertDepth - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
    local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA)
    local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
    local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL)

LuaLibs/ProcessLapJoint.lua

@@ -696,8 +696,8 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
       local bDown = ( vtN[1]:getZ() < BD.NZ_MINB and vtN[2]:getZ() < BD.NZ_MINB) or
                     ( vtN[1]:getZ() < BD.NZ_MINA and vtN[2]:getZ() < 0.5 and ( vtN[2]:getZ() < -0.1 or not bSmall)) or
                     ( vtN[2]:getZ() < BD.NZ_MINA and vtN[1]:getZ() < 0.5 and ( vtN[1]:getZ() < -0.1 or not bSmall))
-      -- per L30, se forzata la lavorazione con fresa di lato da parametro Q03=2 oppure Q03=3 non devo ruotare
-      local bForceSideMill = ( Proc.Prc == 30 and ( EgtGetInfo( Proc.Id, 'Q03', 'd') == 2 or EgtGetInfo( Proc.Id, 'Q03', 'd') == 3))
+      -- se forzata la lavorazione con fresa di lato da parametro Q03=2/3 non devo ruotare
+      local bForceSideMill = ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 2 or EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 3)
       bDown = ( bDown and not BD.DOWN_HEAD and not BD.TURN and not bForceSideMill)
       return true, bDown
    -- se più di 2 facce
@@ -797,8 +797,8 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
             -- se verso il basso, verifico se utilizzabile seconda faccia
             if bDown then
                local bIsU = ( Proc.Fct == 3 and not TestElleShape3( Proc))
-               -- per lapjoint proc 30, se forzata la lavorazione con fresa di lato da parametro Q03=2 oppure Q03=3 non devo ruotare
-               local bForceSideMill = ( Proc.Prc == 30 and ( EgtGetInfo( Proc.Id, 'Q03', 'd') == 2 or EgtGetInfo( Proc.Id, 'Q03', 'd') == 3) and ( Proc.Fct == 3 or Proc.Fct == 4))
+               -- se forzata la lavorazione con fresa di lato da parametro Q03=2/3 non devo ruotare
+               local bForceSideMill = ( ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 2 or EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 3) and ( Proc.Fct == 3 or Proc.Fct == 4))
                if bForceSideMill then
                   bDown = false 
                elseif nFacInd2 and dElev2 < 2 * dElev then
@@ -2847,12 +2847,15 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
    local dMaxLen = 0
    for i = 1, #vAdj do
       if vAdj[i] >= 0 then
-         local _, ptP1, ptP2, _ = EgtSurfTmFacetsContact( Proc.Id, nFacInd, vAdj[i], GDB_ID.ROOT)
-         local dLen = dist( ptP1, ptP2)
-         if dLen > dMaxLen then
-            nFacAdj = vAdj[i]
-            dMaxLen = dLen
-            EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, dH, dV), 3)
+         local vtAdjN = EgtSurfTmFacetNormVersor( Proc.Id, vAdj[i], GDB_ID.ROOT)
+         if not bIs3Faces or abs( rfFac:getVersZ():getY()) < 0.174 or abs( rfFac:getVersZ():getY()) > 0.984 or vtAdjN:getY() * rfFac:getVersZ():getY() > 0.1 then
+            local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, nFacInd, vAdj[i], GDB_ID.ROOT)
+            local dLen = dist( ptP1, ptP2)
+            if dLen > dMaxLen then
+               nFacAdj = vAdj[i]
+               dMaxLen = dLen
+               EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, dH, dV), 3)
+            end
          end
       end
    end
@@ -2991,7 +2994,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
       -- se la lunghezza utensile non riesce ad arrivare sul fondo assegno la possibilità di lavorare di fianco (se possibile)
       if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
          -- continuo di testa se fessura con tre facce o non è tunnel
-         bGoFromHead = ( bIs3Faces or not bOrthoFaces)
+         bGoFromHead = (( bIs3Faces and dMaxElev) or not bOrthoFaces)
       end
       -- se continuo a lavorare di testa
       if bGoFromHead then
@@ -3517,7 +3520,7 @@ local function GetUShapeWidth( Proc, nFacInd)
    -- Recupero le facce adiacenti alla principale
    local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacInd)[1]
    -- se non ho facce adiacenti esco subito
-   if not vAdj or #vAdj == 0 then return nil end
+   if not vAdj or #vAdj == 0 then return 0 end
    -- Normale della faccia
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT)
    -- Cerco le facce adiacenti alla principale con angolo concavo >= 90
@@ -3572,13 +3575,24 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
    if bOrthoFaces then
       -- ottengo le dimensioni del tunnel 
       dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId)
-      local nPathInt
+      -- se due facce posso utilizzare utensile con diametro doppio della dimensione minima
+      if Proc.Fct == 2 then
+         dDimMin = 2 * dDimMin
+      -- se tre facce aumento il diametro di quanto possibile
+      elseif Proc.Fct == 3 then
+         local nFacInd = BL.GetFaceWithMostAdj( Proc.Id, nPartId, false)
+         local dWidth = GetUShapeWidth( Proc, nFacInd or -1)
+         if dWidth > dDimMin then
+            dDimMin = min( 2 * dDimMin, dWidth)
+         end
+      end
       -- se devo inserire il chamfer
       if nChamfer > 0 then
          local nOk, sErr = MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)
          if nOk < 0 then return -1, sErr end
       end
       -- se smusso non è esclusivo
+      local nPathInt
       if nChamfer < 2 then
          -- ricalcolo se è lavorabile da sotto
          bMillDown = ( BD.DOWN_HEAD == true)
@@ -4335,23 +4349,6 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
    return true, sMyWarn
 end
 
----------------------------------------------------------------------
--- Trova l'Ind (0 based) della faccia meglio orientata come l'asse vtAx. Restituisce anche vtN e ptC della faccia stessa.
-local function FindFaceBestOrientedAsAxis( Proc, vtAx)
-   local nFaceIndMax = 0
-   local dMaxComp = 0 ;
-   for i = 1, Proc.Fct do
-      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT)
-      local dComp = abs( vtN * vtAx)
-      if dComp > dMaxComp then
-         nFaceIndMax = i -1
-         dMaxComp = dComp
-      end
-   end
-   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFaceIndMax, GDB_ID.ROOT)
-   return nFaceIndMax, ptC, vtN
-end
-
 ---------------------------------------------------------------------
 local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePart, bPrevBhSideMill, bAllWithEndCap)
    if not BD.MAXDIAM_POCK_CORNER then
@@ -4457,6 +4454,16 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
          -- verifico se posso farlo con la sega-catena
          local bMakeChainSaw, sSawing, dMaxMat, dSawCornerRad, dSawThick = VerifyChainSaw( Proc, dDimMin, dDimMax)
          if bMakeChainSaw then
+            -- Ricalcolo l'affondamento tenendo conto di eventuale inclinazione
+            local dSlDepth
+            local frSlDh = Frame3d( Proc.Box:getCenter(), vtOrtho)
+            for i = 1, Proc.Fct do
+               local b3Fac = EgtSurfTmGetFacetBBoxRef( Proc.Id, i - 1, GDB_BB.STANDARD, frSlDh)
+               if b3Fac and ( not dSlDepth or b3Fac:getDimZ() < dSlDepth) then
+                  dSlDepth = b3Fac:getDimZ()
+               end
+            end
+            if dSlDepth then dDepth = dSlDepth end
             -- Verifico se necessarie più passate
             local nStep = ceil( ( dDimMin - 100 * GEO.EPS_SMALL) / dSawThick)
             local dStep = 0
@@ -4476,7 +4483,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                EgtSetMachiningGeometry( {{ Proc.Id, nLundIdFace}})
                -- imposto uso del lato faccia
                -- al momento, dato che la fessura è passante da parte a parte, gestisco solo la lavorazione
-               -- dall'alto e di fronte (da dietro è disabilitata perchè ho exracorsa con la FAST). 
+               -- dall'alto e di fronte (da dietro è disabilitata perchè ho extracorsa con la FAST). 
                -- Questa feature non è applicata su facce di testa e quindi non controllo l'entrata in X
                if abs(vtOrtho:getZ()) >= 0.707 then
                   EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN)
@@ -4527,25 +4534,23 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
       -- dati della faccia
       local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT)
       -- larghezza della faccia
-      local dV = 0
-      local dH = 0
+      local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
+      if Proc.Box:getDimX() > Proc.Box:getDimY() then
+         if dH > dV then dH, dV = dV, dH end
+      else
+         if dH < dV then dH, dV = dV, dH end
+      end
       -- se due o più facce (recupero la larghezza della faccia perpendicolarmente alle altre)
       if Proc.Fct >= 2 then
          local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, EgtIf( nFacInd == 0, 1, 0), GDB_ID.ROOT)
          local vtX = vtN2 ^ vtN
-         local frRef = Frame3d( ptC, ptC + 100 * vtX, ptC + 100 * vtN2)
-         local b3Ref = EgtSurfTmGetFacetBBoxRef( Proc.Id, nFacInd, GDB_BB.STANDARD, frRef)
-         if b3Ref then
-            dH = b3Ref:getDimX()
-            dV = b3Ref:getDimY()
-         end
-      -- altrimenti una sola faccia
-      else
-         _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
-         if Proc.Box:getDimX() > Proc.Box:getDimY() then
-            if dH > dV then dH, dV = dV, dH end
-         else
-            if dH < dV then dH, dV = dV, dH end
+         if not vtX:isSmall() then
+            local frRef = Frame3d( ptC, ptC + 100 * vtX, ptC + 100 * vtN2)
+            local b3Ref = EgtSurfTmGetFacetBBoxRef( Proc.Id, nFacInd, GDB_BB.STANDARD, frRef)
+            if b3Ref then
+               dH = b3Ref:getDimX()
+               dV = b3Ref:getDimY()
+            end
          end
       end
       -- verifico se U
@@ -5136,7 +5141,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                         local bOrthoFacesMaster = nil
                         local bSetOpenBorders = nil
                         -- trovo la faccia con normale più inclinata verso Y
-                        local nFacApproxY, ptCFacApproxY, vtNFacApproxY = FindFaceBestOrientedAsAxis( Proc, Y_AX())
+                        local nFacApproxY, ptCFacApproxY, vtNFacApproxY = BL.FindFaceBestOrientedAsAxis( Proc, Y_AX())
                         -- se Q03 = 2 e
                         -- 3 facce a L, oppure
                         -- 3 facce non a L ma con una faccia favorevole a Y, oppure

LuaLibs/ProcessLongCut.lua

@@ -10,6 +10,7 @@
 -- 2021/11/04 Migliorata gestione sicurezza aggiuntiva in fresate di fianco (distinzione tra larga come tutta la faccia o meno).
 -- 2021/11/08 Se con lama e flag BD.USE_LONGCUT si lavora in direzione contraria allo standard.
 -- 2022/03/07 Razionalizzata gestione casi con fresa di fianco. Aggiunta gestione Long2Cut anche con testa sotto.
+-- 2022/07/14 Aggiunta limitazione lavorazione a sinistra anche se il grezzo successivo non ha lavorazioni (finale barra) ma è abbastanza lungo da poter essere riutilizzato (BD.MinRaw).
 
 -- Tabella per definizione modulo
 local ProcessLongCut = {}
@@ -507,8 +508,9 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
             end
          end
       end
-      -- se la fine (a sinistra) non è limitata e ho un pezzo successivo meno distante di metà raggio. setto la fine come limitata
-      if ( bCanUseBlade or bCanUseUnderBlade) and ( dDistToNextPiece < dToolDiam/2 or dDistToNextPiece < dToolDiamDn/2) and not bLimXmin then
+      local nNextRawId = EgtGetNextRawPart( nRawId)
+      -- se la fine (a sinistra) non è limitata e ho un pezzo successivo meno distante di metà raggio, oppure se grezzo finale della barra di lunghezza sufficiente, setto la fine come limitata
+      if ((( bCanUseBlade or bCanUseUnderBlade) and ( dDistToNextPiece < dToolDiam/2 or dDistToNextPiece < dToolDiamDn/2)) or (nNextRawId and EgtGetPartInRawPartCount( nNextRawId) <= 0 and EgtGetRawPartBBox( nNextRawId):getDimX() >= BD.MinRaw)) and not bLimXmin then
          if bForceUseBladeOnNotThruFace then
             bForcedLim = true
             bLimXmin = true

LuaLibs/ProcessLongDoubleCut.lua

@@ -877,7 +877,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
       -- recupero la lavorazione
       local sMilling
       local bDownHead = ( nSide == -1 and BD.DOWN_HEAD)
-      sMilling = ML.FindMilling( 'Long2Cut_H2', dElev, nil, nil, nil, not bDownHead, bDownHead)
+      sMilling = ML.FindMilling( 'Long2Cut', dElev, nil, nil, nil, not bDownHead, bDownHead)
 
       if not sMilling then
          local sErr = 'Error : Long2Cut not found in library'

LuaLibs/ProcessMortise.lua

@@ -2,6 +2,8 @@
 -- Gestione calcolo mortase per Travi
 -- 2021/07/20 Aggiunta gestione rinvio angolare su FAST.
 -- 2021/12/01 Se frontale aggiungo taglio con Grp e Proc di vero taglio (per aggiornare ingombro di testa /coda).
+-- 2022/07/26 Aggiunta gestione del parametro P04=1 per la pulizia degli angoli con mortasatrice (sega a catena) specifica
+-- 2022/07/29 Nella pulitura angoli aggiunto il check dimensioni tasca vs utensile. Corretta direzione utensile per mortasa frontale.
 
 -- Tabella per definizione modulo
 local ProcessMortise = {}
@@ -79,6 +81,155 @@ function ProcessMortise.GetCutPlane( Proc)
 end
 
 ---------------------------------------------------------------------
+-- Aggiunge la lavorazione di pulizia angoli
+   local function AddCleanCornersMachining( nProcId, sMortising, nWorkFaceInd, vtN, dDepth)
+      -- aggiungo la lavorazione
+      local sName = 'Mort_' .. ( EgtGetName( nProcId) or tostring( nProcId)) .. '_CleanCorners1'
+      local nMchFId = EgtAddMachining( sName, sMortising)
+      if not nMchFId then
+         local sErr = 'Error adding machining ' .. sName .. '-' .. sMortising
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- imposto geometria
+      EgtSetMachiningGeometry( {{ nProcId, nWorkFaceInd}})
+      -- imposto lato di lavoro e inversione
+      local vtFaceN = EgtSurfTmFacetNormVersor( nProcId, nWorkFaceInd, GDB_ID.ROOT)
+      local bInvert = ( vtFaceN:getZ() < -GEO.EPS_SMALL or vtFaceN:getY() > GEO.EPS_SMALL)
+      EgtSetMachiningParam( MCH_MP.WORKSIDE, EgtIf( bInvert, MCH_MORTISE_WS.LEFT, MCH_MORTISE_WS.RIGHT))
+      EgtSetMachiningParam( MCH_MP.INVERT, bInvert)
+      -- se richiesto, imposto affondamento
+      if dDepth then
+         EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
+      end
+      -- imposto uso del lato faccia
+      local nFaceUse = BL.GetNearestParalOpposite( vtN)
+      EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
+      -- applico il parametro plunge, che setta la lavorazione per affondare solamente, senza lavorare tutto il contorno; 1: solo lato iniziale, 2: solo lato finale, 3: entrambi
+      sNotes = 'Plunge=3;'
+      EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
+      -- imposto angolo 3° asse rot
+      local vtOrtho = BL.GetVersRef( nFaceUse)
+      EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 1))
+      EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 1))
+      -- calcolo la lavorazione
+      if not ML.ApplyMachining( true, false) then
+         if EgtGetOutstrokeInfo() then
+            local _, sErr = EgtGetLastMachMgrError()
+            EgtSetOperationMode( nMchFId, false)
+            return false, sErr
+         end
+         -- impostazione alternativa angolo 3° asse rot
+         EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 2))
+         EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 2))
+         if not ML.ApplyMachining( true, false) then
+            local _, sErr = EgtGetLastMachMgrError()
+            EgtSetOperationMode( nMchFId, false)
+            return false, sErr
+         end
+      end
+      if EgtIsMachiningEmpty() then
+         _, sWarn = EgtGetMachMgrWarning( 0)
+         EgtSetOperationMode( nMchFId, false)
+         return false, sWarn
+      end
+      return true, sWarn
+   end
+
+---------------------------------------------------------------------
+-- Pulizia angoli nel caso sia settato il parametro P04=1
+local function CleanCorners( Proc, dMorH, vtN, bDoubleDir, AuxId)
+   -- verifico se è attiva la pulizia e se l'orientamento della feature è adeguato
+   local bCleanCorners = ( EgtGetInfo( Proc.Id, 'P04', 'i') == 1 and
+                           ( AreSameOrOppositeVectorApprox( vtN, X_AX()) or 
+                             AreSameOrOppositeVectorApprox( vtN, Y_AX()) or
+                             AreSameOrOppositeVectorApprox( vtN, Z_AX())))
+   if not bCleanCorners then
+      EgtOutLog( 'Warning: mortising not aligned with XYZ axes, corner cleaning skipped')
+      return
+   end
+   -- cerco la lavorazione adatta
+   local sMortisingCleanCorners = ML.FindSawing( 'Mortising')
+   if not sMortisingCleanCorners then
+      EgtOutLog( 'Warning: mortising tool not found, corner cleaning skipped')
+      return
+   end
+   -- recupero i dati dell'utensile
+   local dSawWidth = 50
+   local dSawThick = 12
+   local dMaxDepth = 200 
+   if EgtMdbSetCurrMachining( sMortisingCleanCorners) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         dSawWidth = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawWidth
+         dSawThick = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dSawThick
+         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
+      end
+   end
+   -- se l'utensile non arriva in fondo, riduco l'affondamento
+   local sWarn
+   local dDepth
+   local bUseDoubleDir
+   if bDoubleDir then
+      if ( 2 * dMorH + dSawWidth / 2) > dMaxDepth + 10 * GEO.EPS_SMALL then
+         bUseDoubleDir = true
+         if ( dMorH + dSawWidth / 2) > dMaxDepth + 10 * GEO.EPS_SMALL then
+            dDepth = dMaxDepth
+            sWarn = 'Warning in corner cleaning with mortise: elevation (' .. EgtNumToString( dMorH + dSawWidth / 2, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+            EgtOutLog( sWarn)
+         else
+            dDepth = dMorH + dSawWidth / 2
+         end
+      else
+         dDepth = 2 * dMorH + dSawWidth / 2
+      end
+   else
+      if dMorH > dMaxDepth + 10 * GEO.EPS_SMALL then
+         dDepth = dMaxDepth
+         sWarn = 'Warning in corner cleaning with mortise: elevation (' .. EgtNumToString( dMorH, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+         EgtOutLog( sWarn)
+      end
+   end
+   -- verifico se la tasca ha dimensioni sufficienti per l'utensile
+   local nFlat = EgtSurfTmByFlatContour( EgtGetParent( AuxId), AuxId, 0.05)
+   local frMor, dMortiseWidth, dMortiseThick = EgtSurfTmFacetMinAreaRectangle( nFlat, 0, GDB_ID.ROOT)
+   if abs( frMor:getVersX() * X_AX()) < abs( frMor:getVersY() * X_AX()) then
+      dMortiseWidth, dMortiseThick = dMortiseThick, dMortiseWidth
+   end
+   EgtErase( nFlat)
+   if dSawWidth >= dMortiseWidth + 10 * GEO.EPS_SMALL or dSawThick >= dMortiseThick + 10 * GEO.EPS_SMALL then
+      sWarn = 'warning in corner cleaning with mortise: pocket too small'
+      EgtOutLog( sWarn)
+      return true, sWarn
+   end
+   -- cerco le due facce migliori da lavorare
+   local nWorkFaceInd, nWorkFaceInd2
+   if AreSameOrOppositeVectorApprox( vtN, X_AX()) then
+      nWorkFaceInd, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ Y_AX())
+      nWorkFaceInd2, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ Y_AX(), nWorkFaceInd)
+   else
+      nWorkFaceInd, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ X_AX())
+      nWorkFaceInd2, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ X_AX(), nWorkFaceInd)
+   end
+   -- lavoro la prima faccia
+   local bOk1, sErr = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd, vtN, dDepth)
+   -- lavoro la seconda faccia
+   local bOk2, sErr2 = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd2, vtN, dDepth)
+   if sErr2 then sErr = ( sErr or '') .. EgtIf( sErr,  '\n', '') .. sErr2 end
+   -- se richiesto di lavorare dall'altra parte
+   if bUseDoubleDir then
+      local bOk3, sErr3 = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd, -vtN, dDepth)
+      if sErr3 then sErr = ( sErr or '') .. EgtIf( sErr,  '\n', '') .. sErr3 end
+      local bOk4, sErr4 = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd2, -vtN, dDepth)
+      if sErr4 then sErr = ( sErr or '') .. EgtIf( sErr,  '\n', '') .. sErr4 end
+   end
+   if not bOk1 or not bOk2 or not bOk3 or not bOk4 then
+      return false, sErr
+   end
+   return true, sWarn
+end
+
+   ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    -- ingombro del pezzo
@@ -157,7 +308,7 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          local dMove = bxMin:getZ()-bxMax:getZ()
          -- se il percorso ausiliario è esterno al grezzo, lo riavvicino
          if abs( dMove) > GEO.EPS_SMALL then
-            AuxId = EgtCopyGlob( AuxId, BL.GetAddGroup(nPartId))
+            AuxId = EgtCopyGlob( AuxId, BL.GetAddGroup( nPartId))
             EgtMove( AuxId, Vector3d(0,0,-dMove))
             EgtMove( nFlat, Vector3d(0,0,-dMove))
             frMor, dL, dW = EgtSurfTmFacetMinAreaRectangle( nFlat, 0, GDB_ID.ROOT)
@@ -286,8 +437,12 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    local nSCC = MCH_SCC.NONE
    if bPockAngTrasm then
       nSCC = MCH_SCC.ADIR_NEAR
-   elseif not BD.C_SIMM then 
-      if vtN:getY() < GEO.EPS_SMALL then
+   elseif not BD.C_SIMM then
+      if abs( vtN:getX()) < GEO.EPS_SMALL and abs( vtN:getY()) < GEO.EPS_SMALL then
+         nSCC = MCH_SCC.ADIR_YM
+      elseif abs( vtN:getX()) < GEO.EPS_SMALL then
+         nSCC = MCH_SCC.ADIR_XP
+      elseif vtN:getY() < GEO.EPS_SMALL then
          nSCC = EgtIf( bRevertSide, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
       else
          nSCC = EgtIf( bRevertSide, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP)
@@ -346,11 +501,19 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       -- sistemo la direzione di lavoro
       EgtSetMachiningParam( MCH_MP.INVERT, EgtIf( bCW, true, false))
       -- imposto posizione braccio porta testa
-      if vtN:getY() < GEO.EPS_SMALL then
-         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP)
-      else
-         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM)
+      local nSCC = MCH_SCC.NONE
+      if not BD.C_SIMM then
+         if abs( vtN:getX()) < GEO.EPS_SMALL and abs( vtN:getY()) < GEO.EPS_SMALL then
+            nSCC = MCH_SCC.ADIR_YM
+         elseif abs( vtN:getX()) < GEO.EPS_SMALL then
+            nSCC = MCH_SCC.ADIR_XP
+         elseif vtN:getY() < GEO.EPS_SMALL then
+            nSCC = MCH_SCC.ADIR_YP
+         else
+            nSCC = MCH_SCC.ADIR_YM
+         end
       end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
       -- se altezza mortasa differente da altezza massima lavorabile
       if abs( dMorH - dMaxDepth) > GEO.EPS_SMALL then
          nDepthMin = -dMorH
@@ -368,6 +531,12 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          return false, sErr
       end
    end
+   -- verifico se necessaria la pulizia degli angoli ( tenone ad angoli non raggiati) e applico nel caso
+   local _, sWarn2 = CleanCorners( Proc, dMorH, vtN, bOpenBtm and not bForceOneSide, AuxId)
+   if sWarn2 then
+      if not sWarn then sWarn = '' end
+      sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2)
+   end
 
    return true, sWarn
 end

LuaLibs/ProcessSawCut.lua

@@ -184,6 +184,9 @@ function ProcessSawCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTail)
    for i = 1, nC do
       -- Posizione braccio portatesta
       local nSCC = EgtIf( ( BD.C_SIMM or i == 1 or i == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
+      if abs( vtDir:getY()) > 0.5 then
+         nSCC = EgtIf( vtDir:getY() > 0, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+      end
       -- ciclo sulle passate
       local dOffset = dWidth - dDepth ;
       local dLioTang = 0

LuaLibs/ProcessScarfJoint.lua

@@ -1,7 +1,8 @@
--- ProcessScarfJoint.lua by Egaltech s.r.l. 2021/06/28
+-- ProcessScarfJoint.lua by Egaltech s.r.l. 2022/07/12
 -- Gestione calcolo giunto Gerber per Travi
 -- 2021/06/28 Aggiunto extra-taglio alle lamate orizzontali.
 -- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
+-- 2022/07/12 Aggiunta gestione PF1250 e TURN.
 
 -- Tabella per definizione modulo
 local ProcessScarfJoint = {}
@@ -27,6 +28,10 @@ end
 ---------------------------------------------------------------------
 -- Classificazione della feature
 function ProcessScarfJoint.Classify( Proc)
+   -- se PF con testa da sotto o TURN, ammessa qualunque orientazione
+   if ( BD.C_SIMM and BD.DOWN_HEAD) or BD.TURN then
+      return true
+   end
    -- verifico le normali delle facce
    local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
    for i = 1, nFacetCnt do
@@ -127,10 +132,10 @@ end
 ---------------------------------------------------------------------
 local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Solid, ptC, vtN, Proc, vtRef, bHead, sCutting, dSawDiam, b3Raw, dNewDiceDim)
 
-   local vCuts = {}
    local bOk = true
    local sErr = ''
 
+   local vCuts = {}
    if nGoodFace1 and nGoodFace4 and nGoodFace1 > 0 and nGoodFace4 > 0 then
       -- lavoro solo la faccia inclinata perché la faccia tappo completa la lavoro successivamente
       -- questo evita di lavorare due volte la faccia tappo
@@ -139,6 +144,8 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
       vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[4]], vtN[vFaceOrd[4]], true, nil, nil, nil, dNewDiceDim)
    end
 
+   local dVzLimDwnUp = EgtIf( vtRef:getZ() < -0.017, -2, nil)
+
    if #vCuts > 0 then
       -- sistemo posizione nel DB e nome
       for i = 1, #vCuts do
@@ -174,7 +181,7 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
          local dExtraCut = EgtIf( i % 2 == 1, 0, BD.CUT_EXTRA)
          -- lavoro la faccia
          for j = 1, #vCuts[i] do
-            bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, nil, dExtraCut, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+            bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
             if not bOk then return bOk, sErr end
          end
       end
@@ -182,14 +189,14 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
       if vFaceOrd[1] ~= 0 then
          -- inserisco la lavorazione
          local vtOrthoO = Vector3d( vtRef)
-         bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+         bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
          if not bOk then return bOk, sErr end
       end
       -- lavoro la faccia opposta (definita dal parametro P11)
       if vFaceOrd[3] ~= 0 then
          -- inserisco la lavorazione
          local vtOrthoO = Vector3d( vtRef)
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
          if not bOk then return bOk, sErr end
       end
    end
@@ -290,8 +297,12 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
    local bOkc, sErrC = MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
    if not bOkc then return bOkc, sErrC end
 
+   -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -20deg)
+   local bDownHead = ( BD.DOWN_HEAD and vtRef:getZ() < -0.01)
+   local bTopHead = ( BD.DOWN_HEAD and ( vtRef:getZ() > -0.01 or not bDownHead))
+
    -- recupero la lavorazione
-   local sCutting = ML.FindCutting( 'HeadSide')
+   local sCutting = ML.FindCutting( 'HeadSide', bTopHead, bDownHead)
    if not sCutting then
       local sErr = 'Error : cutting not found in library'
       EgtOutLog( sErr)
@@ -441,9 +452,9 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
       -- recupero la lavorazione. considerando l dimensione del lato e l'affondamento
       local sPocketing
       if dDistFaces then
-         sPocketing = ML.FindPocketing( 'OpenPocket', dDiamMax, dDistFaces)
+         sPocketing = ML.FindPocketing( 'OpenPocket', dDiamMax, dDistFaces, nil, bTopHead, bDownHead)
       else
-         sPocketing = ML.FindPocketing( 'OpenPocket', dDiamMax)
+         sPocketing = ML.FindPocketing( 'OpenPocket', dDiamMax, nil, nil, bTopHead, bDownHead)
       end
 
       if not sPocketing then

LuaLibs/ProcessSimpleScarf.lua

@@ -1,6 +1,7 @@
 -- ProcessSimpleScarf.lua by Egaltech s.r.l. 2020/06/04
 -- Gestione calcolo giunto Gerber per Travi
 -- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
+-- 2022/08/09 Ora se la feature ha meno di due facce viene richiamata la normale Cut.
 
 -- Tabella per definizione modulo
 local ProcessSimpleScarf = {}
@@ -10,6 +11,7 @@ require( 'EgtBase')
 local BL = require( 'BeamLib')
 local Fbs = require( 'FacesBySaw')
 local DC = require( 'DiceCut')
+local Cut = require( 'ProcessCut')
 
 EgtOutLog( ' ProcessSimpleScarf started', 1)
 
@@ -138,12 +140,11 @@ function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmT
       EgtOutLog( sErr)
       return false, sErr
    end
-   -- verifico che ci siano almeno due facce (altrimenti non è da lavorare)
+   -- se ci sono meno di due facce si riduce a una normale Cut
    local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
    if nFacetCnt < 2 then
-      local sErr = 'Error : number of faces not enough'
-      EgtOutLog( sErr)
-      return false, sErr
+      local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, nil, nil, nil, dOvmTail)
+      return bOk, sErr
    end
    -- dati delle facce
    local ptC = {}

LuaLibs/ProcessSplit.lua

@@ -1,4 +1,4 @@
--- ProcessSplit.lua by Egaltech s.r.l. 2022/06/07
+-- ProcessSplit.lua by Egaltech s.r.l. 2022/07/26
 -- Gestione calcolo tagli di separazione per Travi
 -- 2022/05/31 Aggiunta gestione sezioni alte e larghe con taglio con sega a catena seguito da rifinitura con lama (aggiunta funzione MakeSplitByChainSaw); gestione eventuale creazione nuova fase dall'interno della Make.
 -- 2022/06/10 Per sezioni alte e larghe aggiunta gestione finitura in base a sovramateriale e a parametro Q05 dell' eventuale lavorazione sostituita.
@@ -148,7 +148,7 @@ end
 -- lavorazione con sega a catena per sezioni alte e larghe
 local function MakeSplitByChainSaw( nSurfId, nFaceUse, dDepth, sNotes, dOffs)
    -- Recupero i dati dell'utensile
-   local sSawing = ML.FindSawing('Sawing')
+   local sSawing = ML.FindSawing( 'Sawing')
    local dMaxMat = 0
    local dSawCornerRad = 0
    local dSawThick = 0
@@ -182,10 +182,10 @@ local function MakeSplitByChainSaw( nSurfId, nFaceUse, dDepth, sNotes, dOffs)
    -- imposto uso del lato faccia
    EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
    -- imposto angolo 3° asse rot
-   EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 2))
+   EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 1))
    local _, vtN = EgtSurfTmFacetCenter( nSurfId, 0, GDB_ID.ROOT)
-   vtOrthO = BL.GetVersRef( nFaceUse)
-   EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 2))
+   local vtOrtho = BL.GetVersRef( nFaceUse)
+   EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 1))
    -- imposto offset radiale per mantenere il materiale in coda per la finitura
    EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
    -- imposto allungamento percorso iniziale e finale a zero
@@ -212,8 +212,8 @@ local function MakeSplitByChainSaw( nSurfId, nFaceUse, dDepth, sNotes, dOffs)
          return false, sErr
       end
       -- impostazione alternativa angolo 3° asse rot
-      EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 1))
-      EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 1))
+      EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 2))
+      EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 2))
       if not ML.ApplyMachining( true, false) then
          local _, sErr = EgtGetLastMachMgrError()
          EgtSetOperationMode( nMchFId, false)
@@ -232,9 +232,9 @@ end
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dOvmTail)
-   if not BD.OVM_CHAIN_HBEAM then
-      BD.OVM_CHAIN_HBEAM = 8
-   end
+   -- impostazione default a variabili aggiunte
+   if not BD.OVM_CHAIN_HBEAM then BD.OVM_CHAIN_HBEAM = 8 end
+   if not BD.C_SIMM_ENC then BD.C_SIMM_ENC = 180 end
    -- ingombro del grezzo
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- inserimento smussi
@@ -262,8 +262,9 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
    end
    local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
    -- caratteristiche taglio
-   local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, BD.MAX_DIM_HTCUT_HBEAM)
-   local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and ( b3Raw:getDimZ() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, abs( BD.MAX_DIM_HTCUT_HBEAM))
+   local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and
+                          ( b3Raw:getDimZ() > EgtIf( BD.DOWN_HEAD or BD.TURN, 2, 1) * dMaxVertDepth - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
    local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and ( b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA))
    local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
    local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA  + 10 * GEO.EPS_SMALL)
@@ -293,43 +294,70 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
    if bBigSectionCut then
       local bFinishingNeeded = false
       if bSplit then
-         --taglio sega a catena
-         local cutDepth = 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN
-         local sNotesSplit = 'Presplit;'
+         -- recupero lunghezza massima di lavoro della sega a catena
+         local sSawing = ML.FindSawing( 'Sawing')
+         local dMaxMat = 0
+         local dTlen = 0
+         if EgtMdbSetCurrMachining( sSawing or '') then
+            local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+            if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+               dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxMat
+               dTLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dTLen
+            end
+         end
+         -- assegno offset in  lunghezza
          local dOffs = 0
          if dOvmTail > BD.OVM_CHAIN_HBEAM then
             dOffs = dOvmTail - BD.OVM_CHAIN_HBEAM
             bFinishingNeeded = true
          end
-         local bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_BACK, cutDepth, sNotesSplit, dOffs)
-         if not bOk then return bOk, sErr, nNewPhase end
-         sNotesSplit = 'Split;'
-         bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_FRONT, cutDepth, sNotesSplit, dOffs)
-         if not bOk then return bOk, sErr, nNewPhase end
-         -- creo nuova fase per successiva finitura
-         BL.AddPhaseWithRawParts( nRawId, BD.OriXR, BD.PosXR, BD.RAW_OFFSET)
-         nNewPhase = EgtGetCurrPhase()
-         nDispId = EgtGetPhaseDisposition( nNewPhase)
-         if sDownOrSideOrStd == 'down' then
-            EgtRotateRawPart( nRawId, X_AX(), 180)
-            EgtSetInfo( nDispId, 'TYPE', 'MID2')
-            EgtSetInfo( nDispId, 'ROT', -2)
-         elseif sDownOrSideOrStd == 'side' then
-            if bPreMove then EgtMoveRawPart( nRawId, vtMove) end
-            EgtRotateRawPart( nRawId, X_AX(), EgtIf( BD.RIGHT_LOAD, -90, 90))
-            if not bPreMove then EgtMoveRawPart( nRawId, vtMove) end
-            EgtSetInfo( nDispId, 'TYPE', 'MID2')
-            EgtSetInfo( nDispId, 'ROT', -1)
+         -- se pezzo non troppo alto, taglio singolo da sopra
+         if b3Raw:getDimZ() < dMaxMat - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL then
+            local cutDepth = b3Raw:getDimZ() + BD.CUT_EXTRA_MIN
+            sNotesSplit = 'Split;'
+            bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_TOP, cutDepth, sNotesSplit, dOffs)
+            if not bOk then return bOk, sErr, nNewPhase end
+         -- se pezzo non troppo largo, taglio singolo da davanti
+         elseif b3Raw:getDimY() + BD.CUT_EXTRA_MIN < min( dMaxMat, dTLen - BD.C_SIMM_ENC) + 10 * GEO.EPS_SMALL then
+            local cutDepth = b3Raw:getDimY() + BD.CUT_EXTRA_MIN
+            sNotesSplit = 'Split;'
+            bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_FRONT, cutDepth, sNotesSplit, dOffs)
+            if not bOk then return bOk, sErr, nNewPhase end
+         -- altrimenti tagli dai due fianchi (dietro e davanti)
          else
-            EgtSetInfo( nDispId, 'TYPE', 'END')
+            local cutDepth = 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN
+            local sNotesSplit = 'Presplit;'
+            local bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_BACK, cutDepth, sNotesSplit, dOffs)
+            if not bOk then return bOk, sErr, nNewPhase end
+            sNotesSplit = 'Split;'
+            bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_FRONT, cutDepth, sNotesSplit, dOffs)
+            if not bOk then return bOk, sErr, nNewPhase end
+         end
+         -- se necessaria finitura, creo nuova fase
+         if bFinishingNeeded then
+            BL.AddPhaseWithRawParts( nRawId, BD.OriXR, BD.PosXR, BD.RAW_OFFSET)
+            nNewPhase = EgtGetCurrPhase()
+            nDispId = EgtGetPhaseDisposition( nNewPhase)
+            if sDownOrSideOrStd == 'down' then
+               EgtRotateRawPart( nRawId, X_AX(), 180)
+               EgtSetInfo( nDispId, 'TYPE', 'MID2')
+               EgtSetInfo( nDispId, 'ROT', -2)
+            elseif sDownOrSideOrStd == 'side' then
+               if bPreMove then EgtMoveRawPart( nRawId, vtMove) end
+               EgtRotateRawPart( nRawId, X_AX(), EgtIf( BD.RIGHT_LOAD, -90, 90))
+               if not bPreMove then EgtMoveRawPart( nRawId, vtMove) end
+               EgtSetInfo( nDispId, 'TYPE', 'MID2')
+               EgtSetInfo( nDispId, 'ROT', -1)
+            else
+               EgtSetInfo( nDispId, 'TYPE', 'END')
+            end
+            EgtSetInfo( nDispId, 'ORD', nOrd)
+            -- se grezzo successivo senza pezzi e finale, va tolto
+            local nNextRawId = EgtGetNextRawPart( nRawId)
+            if nNextRawId  and  EgtGetPartInRawPartCount( nNextRawId) == 0  and  EgtGetRawPartBBox( nNextRawId):getDimX() < BD.MinRaw then
+               EgtRemoveRawPartFromCurrPhase( nNextRawId)
+            end
          end
-         EgtSetInfo( nDispId, 'ORD', nOrd)
-         -- se grezzo successivo senza pezzi e finale, va tolto
-         local nNextRawId = EgtGetNextRawPart( nRawId)
-         if nNextRawId  and  EgtGetPartInRawPartCount( nNextRawId) == 0  and  EgtGetRawPartBBox( nNextRawId):getDimX() < BD.MinRaw then
-            EgtRemoveRawPartFromCurrPhase( nNextRawId)
-         end   
-         -- fine creazione nuova fase
       end
       -- se è necessaria la finitura
       if bFinishingNeeded or not bSplit then

LuaLibs/ProcessTenon.lua

@@ -202,7 +202,7 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    local OVERLAP_COEFF = 0.7
    -- porto inizio curva il più possibile sul bordo in alto o in basso
    local dMaxDist = OVERLAP_COEFF * dMillDiam * MAX_PASS
-   local bMyShortPart = ( bShortPart and abs( vtN:getX()) < 0.999)
+   local bMyShortPart = ( bShortPart and abs( vtN:getX()) < 0.999 and abs( vtN:getY()) < 0.259)
    BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, bH2 ~= bMyShortPart)
    -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
    local sWarn

NestProcess.lua

@@ -1,5 +1,5 @@
 -- BeamNestProcess.lua by Egaltech s.r.l. 2021/06/14
--- Gestione nesting automatico pareti
+-- Gestione nesting automatico travi
 
 -- Intestazioni
 require( 'EgtBase')
@@ -257,7 +257,7 @@ while TotRawCount( Raws) > 0 and PartsToFill( Parts) > 0 do
    local Results = {}
    for RawIndex = 1, #Raws do
       if Raws[RawIndex].Count > 0 then
-      Results[RawIndex] = ExecMaximumFilling( Raws[RawIndex], PartsToNest)
+         Results[RawIndex] = ExecMaximumFilling( Raws[RawIndex], PartsToNest)
       else
          Results[RawIndex] = { FillRatio = 0.001, LenToFill = 1000}
       end
@@ -267,10 +267,10 @@ while TotRawCount( Raws) > 0 and PartsToFill( Parts) > 0 do
    local dMinWaste = 100000
    for ResultIndex = 1, #Results do
       if Results[ResultIndex] then
-      local dWaste = (1 - Results[ResultIndex].FillRatio) * Raws[ResultIndex].LenToFill
-      if dWaste < dMinWaste then
-         dMinWaste = dWaste
-         nMinWasteRawIndex = ResultIndex
+         local dWaste = (1 - Results[ResultIndex].FillRatio) * Raws[ResultIndex].LenToFill
+         if dWaste < dMinWaste then
+            dMinWaste = dWaste
+            nMinWasteRawIndex = ResultIndex
          end
       end
    end
@@ -301,11 +301,11 @@ while TotRawCount( Raws) > 0 and PartsToFill( Parts) > 0 do
          end
       end
       nRawTot = nRawTot + 1
-   -- Aggiorno per prossima iterazione
-   Raws[nMinWasteRawIndex].Count = Raws[nMinWasteRawIndex].Count - 1
-   for i = 1, Results[nMinWasteRawIndex].DiffParts do
-      local PartId = Results[nMinWasteRawIndex].Data[i].Id
-      PartsToNest[PartId].Cnt = PartsToNest[PartId].Cnt - Results[nMinWasteRawIndex].Data[i].Count
+      -- Aggiorno per prossima iterazione
+      Raws[nMinWasteRawIndex].Count = Raws[nMinWasteRawIndex].Count - 1
+      for i = 1, Results[nMinWasteRawIndex].DiffParts do
+         local PartId = Results[nMinWasteRawIndex].Data[i].Id
+         PartsToNest[PartId].Cnt = PartsToNest[PartId].Cnt - Results[nMinWasteRawIndex].Data[i].Count
       end
    end
    nCycle = nCycle + 1