Improvement/DrillingsUnder30Deg: - Aggiunta la gestione dei fori con angolo < 30 gradi, per i quali si usa la testa della macchina per accorciare l'utile di lavoro. Fast esclusa.

- modifica alla lavorazione tenoni per favorire in generale l'attacco da sopra.

.gitlab-ci.yml

@@ -2,9 +2,8 @@ variables:
  VERS_MAIN: '1.0'
  APP_NAME: 'Beam'
  NEW_REL: ''
- NET_SHARE_R: '\\10.74.82.201\Artifacts\EGT_SRV\EgtTech'
- NET_USER: '10.74.82.50\Server'
- NET_SHARE_Z: '\\10.74.82.200\Artifacts'
+ NET_SHARE_R: '\\10.74.82.201\EgwTech'
+ NET_SHARE_Z: '\\10.74.82.201\Artifacts'
  NET_USERQ: 'steamw\egalware'
 
 #Note compilazione LUA:

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

GetBeamData.lua

@@ -41,4 +41,4 @@ GWD.OVM_MID = BD.OVM_MID
 -- Tutto ok
 GWD.ERR = 0
 
-EgtOutLog( ' +++ GetWallData completed')
+EgtOutLog( ' +++ GetBeamData completed')

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/09/28
 -- 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,12 @@
 --            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.
+-- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata.
+-- 2022/09/28 I fori vengono sempre fatti prima delle tacche.
+-- 2022/09/29 Aggiunta la ricerca di feature specchiate, al momento solo per DtMortise, con le relative funzioni.
+
 
 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -86,7 +92,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')
@@ -255,6 +261,9 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
             local nDo = EgtGetInfo( ProcId, 'DO', 'i') or 1
             local nCutId = EgtGetInfo( EgtGetParent( EgtGetParent( ProcId)), 'CUTID', 'i') or 0
             local nTaskId = EgtGetInfo( ProcId, 'TASKID', 'i') or 0
+            -- leggo se ci sono feature collegate
+            local nAddAdjId = EgtGetInfo( ProcId, 'ADJID', 'i')
+            local nAddMainId = EgtGetInfo( ProcId, 'MAINID', 'i')
             if nGrp and nPrc and nDo == 1 then
                local Proc = {}
                Proc.Id = ProcId
@@ -267,6 +276,12 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
                Proc.Fce = 0
                Proc.CutId = nCutId
                Proc.TaskId = nTaskId
+               -- se ci sono feature collegate ne scrivo il riferimento nella Proc
+               if nAddAdjId then
+                  Proc.AdjId = Proc.Id + nAddAdjId
+               elseif nAddMainId then
+                  Proc.MainId = Proc.Id + nAddMainId
+               end
                Proc.Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD)
                if Proc.Box and not Proc.Box:isEmpty() then 
                   Proc.Head = IsHeadFeature( Proc, b3Raw, dCurrOvmH)
@@ -308,6 +323,8 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
                         Proc2.Fce = Proc.Fcs
                         Proc2.CutId = Proc.CutId
                         Proc2.TaskId = Proc.TaskId
+                        Proc2.AdjId = Proc.AdjId
+                        Proc2.MainId = Proc.MainId
                         table.insert( vProc, Proc2)
                      end
                   -- se BlockHaus HalfLap
@@ -387,6 +404,34 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 --    *** Inserimento delle travi nel grezzo ***
+-------------------------------------------------------------------------------------------------------------
+local function VerifyBigSectionCut( dRawW, dRawH)
+   -- lama principale
+   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)
+   -- eventuale lama su testa sotto
+   local sCutting2 = ML.FindCutting( 'TailSide_H2', false, true)
+   local dMaxDepth2 = 0
+   if sCutting2 and EgtMdbSetCurrMachining( sCutting2) then
+      local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then
+         dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2
+      end
+   end
+   -- verifiche
+   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.TURN, 2 * dMaxVertDepth, dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   return bBigSectionCut
+end
+
 -------------------------------------------------------------------------------------------------------------
 function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam, bMachGroupOk)
 
@@ -426,11 +471,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 +517,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 +557,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 +624,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
 
 -------------------------------------------------------------------------------------------------------------
@@ -609,7 +655,7 @@ end
 local function OrderFeatures( vProc, b3Raw)
 
    local dDrillPenalty = EgtIf( BD.PRESS_ROLLER, 200, 100)
-   local dSmallDrillRange = EgtIf( b3Raw:getDimX() < BD.LEN_SHORT_PART, 200, 600)
+   local dSmallDrillRange = EgtIf( b3Raw:getDimX() < BD.LEN_SHORT_PART, BD.DRILL_RANGE_SP or 200, BD.DRILL_RANGE or 600)
 
    -- funzione di confronto
    -- secondo centro box in X (taglio di intestazione prima di altri tagli di testa e taglio di separazione però prima di altri tagli di coda)
@@ -638,6 +684,16 @@ local function OrderFeatures( vProc, b3Raw)
       if B1.Head ~= B2.Head then
          return B1.Head
       end
+      -- se primo è foro e secondo è un ribasso, il foro va sempre prima
+      if Drill.Identify(B1) and LapJoint.Identify(B2) 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, il ribasso va sempre dopo
+      if LapJoint.Identify(B1) 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
       -- se entrambi tenoni e si intersecano, metto prima tenone vero e poi base tenone
       if ( Tenon.Identify( B1) or DtTenon.Identify( B1)) and ( Tenon.Identify( B2) or DtTenon.Identify( B2)) and
          B1.Box:getMin():getX() < B2.Box:getMax():getX() + 100 * GEO.EPS_SMALL and B2.Box:getMin():getX() < B1.Box:getMax():getX() + 100 * GEO.EPS_SMALL then
@@ -1206,7 +1262,7 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bN
       EgtOutLog( sErr)
       bOk = false
    end
-   return bOk, sErr, nNewPhase
+   return bOk, sErr, ( nNewPhase or -1)
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -1313,6 +1369,108 @@ local function MoveDrillsOnTenon( vProc)
    end
 end
 
+-------------------------------------------------------------------------------------------------------------
+-- Estrazione parametri P da lavorazioni di tipo DtMortise
+local function GetPParametersDtMortise( Proc)
+   local vPParameters = {
+      { 'P01', 'd'},
+      { 'P02', 'd'},
+      { 'P03', 'd'},
+      { 'P04', 'i'},
+      { 'P05', 'i'},
+      { 'P06', 'd'},
+      { 'P07', 'd'},
+      { 'P09', 'd'},
+      { 'P10', 'd'},
+      { 'P11', 'd'},
+      { 'P12', 'd'},
+      { 'P13', 'd'},
+      { 'P14', 'd'},
+      { 'P15', 'd'}
+   }
+   for i = 1, #vPParameters do
+      vPParameter = vPParameters[i]
+      vPParameter[3] = EgtGetInfo( Proc.Id, vPParameter[1], vPParameter[2])
+   end
+   return vPParameters
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- Controlla se la feature ProcMirror è la specchiata di Proc, per feature di tipo DtMortise
+local function CheckMirrorDtMortise( Proc, ProcMirror, dHBeam)
+   local bIsMirror = true
+   local vPParametersProc = GetPParametersDtMortise( Proc)
+   local vPParametersMirror = GetPParametersDtMortise( ProcMirror)
+   local nP02, nP06 = 2, 6
+   -- controllo che i parametri P delle due feature, tranne P02 e P06, siano uguali
+   for i = 1, #vPParametersProc do
+      local vPParameterProc = vPParametersProc[i]
+      local vPParameterMirror = vPParametersMirror[i]
+      if vPParameterProc[1] ~= 'P02' and vPParameterProc[1] ~= 'P06'then
+         bIsMirror = ( abs( vPParameterProc[3] - vPParameterMirror[3]) < 100 * GEO.EPS_SMALL)
+         if bIsMirror == false then break end
+      elseif vPParameterProc[1] == 'P02' then
+         nP02 = i
+      elseif vPParameterProc[1] == 'P06' then
+         nP06 = i
+      end
+   end
+   -- se gli altri parametri P sono uguali, verifico che P02 e P06 siano compatibili con feature specchiate
+   if bIsMirror == true then
+      bIsMirror = ( ( vPParametersProc[nP02][3] == 0 and abs( vPParametersMirror[nP02][3] - dHBeam) < 100 * GEO.EPS_SMALL) and
+                  ( vPParametersProc[nP06][3] == 90 and vPParametersMirror[nP06][3] == -90)) or
+                  ( ( vPParametersMirror[nP02][3] == 0 and abs( vPParametersProc[nP02][3] - dHBeam) < 100 * GEO.EPS_SMALL) and
+                  ( vPParametersMirror[nP06][3] == 90 and vPParametersProc[nP06][3] == -90))
+   end
+   return bIsMirror
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- Cerca se esiste una feature specchiata di Proc e nel caso ne restituisce la posizione in vProc
+local function FindMirrorFeature( vProc, Proc, sFeatureType, dHBeam)
+   local nProcMirror
+   -- se mortasa a coda di rondine
+   if sFeatureType == 'DtMortise' then
+      Proc.Side = EgtGetInfo( Proc.Id, 'SIDE', 'i')
+         for i = 1, #vProc do
+            local ProcMirror = vProc[i]
+            if DtMortise.SideIdentify(ProcMirror) then
+               ProcMirror.Side = EgtGetInfo( ProcMirror.Id, 'SIDE', 'i')
+               if ( Proc.Side == 1 and ProcMirror.Side == 3) or ( Proc.Side == 3 and ProcMirror.Side == 1) or
+                  ( Proc.Side == 2 and ProcMirror.Side == 4) or ( Proc.Side == 4 and ProcMirror.Side == 2) then
+                  local bIsMirror = CheckMirrorDtMortise( Proc, ProcMirror, dHBeam)
+                  if bIsMirror then nProcMirror = i end
+               end
+            end
+         end
+   end
+   -- se foratura (da implementare)
+   return nProcMirror
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- Cerca in vProc la presenza di feature specchiate. Se le trova scrive in Proc e nelle info l'Id della specchiata.
+local function SetMirroredFeatures( vProc, dHBeam)
+   for i = 1, #vProc do
+      local Proc = vProc[i]
+      local sFeatureType
+      if DtMortise.SideIdentify(Proc) then
+         sFeatureType = 'DtMortise'
+      elseif Drill.Identify(Proc) then
+         sFeatureType = 'Drill'
+      end
+      if ( sFeatureType == 'DtMortise' or sFeatureType == 'Drill') and not Proc.MirrorId then
+         local nProcMirror = FindMirrorFeature( vProc, Proc, sFeatureType, dHBeam)
+         if nProcMirror then
+            Proc.MirrorId = vProc[nProcMirror].Id
+            vProc[nProcMirror].MirrorId = Proc.Id
+            EgtSetInfo( Proc.Id, 'MIRRORID', vProc[nProcMirror].Id)
+            EgtSetInfo( vProc[nProcMirror].Id, 'MIRRORID', Proc.Id)
+         end
+      end
+   end
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- verifica se ci sono forature da lavorare dopo tagli di testa o coda e nel caso le classifica come Head o Tail e gli assegna l'Id della rispettiva feature di taglio
 local function SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeIntersectingDrillings)
@@ -1407,6 +1565,11 @@ function BeamExec.ProcessFeatures()
       if BD.IMPROVE_HEAD_TAIL_DRILLINGS then
          SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeIntersectingDrillings)
       end
+      -- verifica presenza di feature specchiate per eventuali lavorazioni simultanee
+      local bConcurrentDoubleHead = BD.DOUBLE_HEAD_MIRRORED_FEATURES and ( BD.TWO_EQUAL_HEADS or BD.TWO_UP_DOWN_HEADS)
+      if bConcurrentDoubleHead then
+         SetMirroredFeatures( vProc, EgtGetRawPartBBox( nRawId):getDimZ())
+      end
       -- le ordino lungo X
       OrderFeatures( vProc, b3Raw)
       -- le classifico

LuaLibs/BeamLib.lua

@@ -14,6 +14,9 @@
 -- 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
+-- 2022/09/01 Aggiunte le funzioni GetTunnelDimension, CalcCollisionSafety, SetOpenSide, precedentemente in ProcessLapJoint.
 
 -- Tabella per definizione modulo
 local BeamLib = {}
@@ -305,7 +308,7 @@ function BeamLib.GetNearestOrthoOpposite( vtRef, vtNorm)
       vtMyRef:normalize()
    end
    -- se prevalente una componente orizzontale (con piccolissimo vantaggio)
-   if abs( vtMyRef:getX()) > 0.95 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.95 * abs( vtMyRef:getZ()) then
+   if abs( vtMyRef:getX()) > 0.91 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.91 * abs( vtMyRef:getZ()) then
       -- se prevale la componente destra/sinistra
       if abs( vtMyRef:getX()) > 0.95 * abs( vtMyRef:getY()) then
          if vtMyRef:getX() > -GEO.EPS_SMALL then
@@ -369,17 +372,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
@@ -700,10 +703,12 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 function BeamLib.GetNzLimDownUp( b3Raw, vtN, vtOrtho)
-   if BD.C_SIMM or BD.TURN then
+   if BD.C_SIMM then
       return -0.484
+   elseif BD.TURN then
+      return -2
    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 +799,255 @@ 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
+
+---------------------------------------------------------------------
+function BeamLib.GetTunnelDimension( Proc, nPartId)
+   -- sono necessarie almeno due facce
+   if Proc.Fct < 2 then return 0, 0, 0 end
+   -- recupero l'ingombro della trave
+   local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+   -- recupero centro e normale delle facce
+   local ptC = {}
+   local vtN = {}
+   for i = 1, Proc.Fct do
+      ptC[i], vtN[i] = EgtSurfTmFacetCenter( Proc.Id, i - 1, GDB_ID.ROOT)
+   end
+   -- calcolo l'orientamento del tunnel
+   local vtOrtho
+   local bAdj = EgtSurfTmFacetsContact( Proc.Id, 0, 1)
+   if bAdj then
+      vtOrtho = vtN[1] ^ vtN[2]
+   else
+      if Proc.Fct >= 3 then
+         vtOrtho = vtN[1] ^ vtN[3]
+      else
+         return 0, 0, 0
+      end
+   end
+   -- ottengo il boundingBox e prendo le dimensioni lungo la direzione (Z locale) che rappresenta la profondità della fessura
+   local frFc = Frame3d( ptC[1], vtOrtho) ;
+   local b3BoxLoc = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, frFc)
+   local dDepth = b3BoxLoc:getDimZ()
+   -- recupero gruppo per geometria addizionale
+   local nAddGrpId = BeamLib.GetAddGroup( nPartId)
+   if not nAddGrpId then
+      EgtOutLog( 'Error : missing AddGroup')
+      return 0, 0, 0
+   end
+   -- centro del bounding box locale
+   local ptCen = b3BoxLoc:getCenter()
+   ptCen:toGlob( frFc)
+   -- creo superficie intermedia
+   local nSurfInt = EgtSurfTmPlaneInBBox( nAddGrpId, ptCen, vtOrtho, b3Solid, GDB_ID.ROOT)
+   if not nSurfInt then return 0, 0, 0 end
+   -- ritaglio la superficie con le facce della fessura
+   for i = 1, Proc.Fct do
+      EgtCutSurfTmPlane( nSurfInt, ptC[i], -vtN[i], false, GDB_ID.ROOT)
+   end
+   local frSurfInt, dDimMax, dDimMin = EgtSurfTmFacetMinAreaRectangle( nSurfInt, 0, GDB_ID.ROOT)
+   -- cerco la faccia con larghezza pari a dimensione massima della fessura
+   local nLongIdFace = 0
+   for i = 1, Proc.Fct do
+      if abs( vtN[i] * frSurfInt:getVersX()) < 0.5 then
+         nLongIdFace = i - 1
+         break
+      end
+   end
+   return dDimMin, dDimMax, dDepth, vtOrtho, nLongIdFace, nSurfInt
+end
+
+---------------------------------------------------------------------
+function BeamLib.CalcCollisionSafety( vtDir)
+   local dCollSic = 10 * BD.COLL_SIC
+   if abs( vtDir:getX()) > 0.999 or abs( vtDir:getY()) > 0.999 or abs( vtDir:getZ()) > 0.999 then
+      dCollSic = 0
+   elseif abs( vtDir:getX()) > 0.996 or abs( vtDir:getY()) > 0.996 or abs( vtDir:getZ()) > 0.996 then
+      dCollSic = 1 * BD.COLL_SIC
+   elseif abs( vtDir:getX()) > 0.89 or abs( vtDir:getY()) > 0.89 or abs( vtDir:getZ()) > 0.89 then
+      dCollSic = 2.5 * BD.COLL_SIC
+   elseif abs( vtDir:getX()) > 0.86 or abs( vtDir:getY()) > 0.86 or abs( vtDir:getZ()) > 0.86 then
+      dCollSic = 4 * BD.COLL_SIC
+   elseif abs( vtDir:getX()) > 0.707 or abs( vtDir:getY()) > 0.707 or abs( vtDir:getZ()) > 0.707 then
+      dCollSic = 5.5 * BD.COLL_SIC
+   end
+   return dCollSic
+end
+
+---------------------------------------------------------------------
+function BeamLib.SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId, nStartPoint)
+
+   -- fondo tra loro le curve compatibili
+   EgtMergeCurvesInCurveCompo( nPathInt)
+   local nStartIdEnt, nNumEnt = EgtCurveDomain( nPathInt) 
+   local pLastPIni, pLastPEnd
+
+   -- faccio una copia della curva e la esplodo
+   if nStartIdEnt then
+      -- prendo i punti 
+      for i = 1, nNumEnt do
+         local pPini = EgtUP( nPathInt, (i-1), GDB_RT.GLOB) 
+         local pPend = EgtUP( nPathInt, EgtIf( i == nNumEnt, 0, i), GDB_RT.GLOB)
+         -- Se normale lungo la Z considero il box in X e Y
+         if abs(vtOrtho:getZ()) > 0.999 then
+            -- se corrisponde a X
+            if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or
+               ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) then
+               -- setto l'entità open
+               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+               if #sActInfo > 0 then
+                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+               else
+                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+               end
+               -- prendo i punti per eventuale modifica del punto di inizio percorso
+               pLastPIni = pPini
+               pLastPEnd = pPend
+            -- altrimenti se corrisponde a Y
+            elseif ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
+                   ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then
+               -- setto l'entità open
+               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+               if #sActInfo > 0 then
+                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+               else
+                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+               end
+               -- prendo i punti per eventuale modifica del punto di inizio percorso
+               pLastPIni = pPini
+               pLastPEnd = pPend
+            end
+         -- altrimenti se normale lungo la Y considero il box in X e Z
+         elseif abs(vtOrtho:getZ()) < 0.001 and abs(vtOrtho:getY()) > 0.999 then 
+            -- se corrisponde a X
+            if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or
+               ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) then
+               -- setto l'entità open
+               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+               if #sActInfo > 0 then
+                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+               else
+                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+               end
+               -- prendo i punti per eventuale modifica del punto di inizio percorso
+               pLastPIni = pPini
+               pLastPEnd = pPend
+            -- altrimenti se corrisponde a Z
+            elseif ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
+                   ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
+               -- setto l'entità open
+               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+               if #sActInfo > 0 then
+                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+               else
+                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+               end
+               -- prendo i punti per eventuale modifica del punto di inizio percorso
+               pLastPIni = pPini
+               pLastPEnd = pPend
+            end
+         -- caso che non dovrebbe mai capitare ma gestito per completezza
+         -- altrimenti se normale lungo la X considero il box in Y e Z 
+         elseif abs(vtOrtho:getZ()) < 0.001 and abs(vtOrtho:getX()) > 0.999 then 
+            -- se corrisponde a Y
+            if ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
+               ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then
+               -- setto l'entità open
+               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+               if #sActInfo > 0 then
+                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+               else
+                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+               end
+               -- prendo i punti per eventuale modifica del punto di inizio percorso
+               pLastPIni = pPini
+               pLastPEnd = pPend
+            -- altrimenti se corrisponde a Z
+            elseif ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
+                   ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
+               -- setto l'entità open
+               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+               if #sActInfo > 0 then
+                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+               else
+                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+               end
+               -- prendo i punti per eventuale modifica del punto di inizio percorso
+               pLastPIni = pPini
+               pLastPEnd = pPend
+            end
+         -- se asse Z orizzontale verifico se si avvicina piú a Y
+         elseif abs(vtOrtho:getZ()) < 0.001 then 
+            if abs(vtOrtho:getY()) > 0.75 then 
+               -- se corrisponde a Z
+               if ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
+                  ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
+                  -- setto l'entità open
+                  local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+                  if #sActInfo > 0 then
+                     EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+                  else
+                     EgtSetInfo( nPathInt, 'OPEN', (i-1))
+                  end
+                  -- prendo i punti per eventuale modifica del punto di inizio percorso
+                  pLastPIni = pPini
+                  pLastPEnd = pPend
+               end
+            end
+         -- se asse Y a 0 (fresa ne davanti ne dietro) verifico se si avvicina piú a Z+
+         elseif abs(vtOrtho:getY()) < 0.001 then 
+            if abs(vtOrtho:getZ()) > 0.75 then 
+               -- se corrisponde a Y
+               if ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
+                  ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then
+                  -- setto l'entità open
+                  local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+                  if #sActInfo > 0 then
+                     EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+                  else
+                     EgtSetInfo( nPathInt, 'OPEN', (i-1))
+                  end
+                  -- prendo i punti per eventuale modifica del punto di inizio percorso
+                  pLastPIni = pPini
+                  pLastPEnd = pPend
+               end
+            end
+         end
+      end
+      -- se devo cambiare il punto di partenza
+      if nStartPoint then
+         if pLastPIni and pLastPEnd then
+            -- calcolo il punto medio con gli ultimi punti utilizzati
+            local ptPs = ( pLastPIni + pLastPEnd) / 2
+            EgtChangeClosedCurveStartPoint( nPathInt, ptPs, GDB_RT.GLOB)
+            -- se devo eliminare la parte open
+            if nStartPoint == 2 then
+               EgtRemoveCurveCompoCurve( nPathInt, true)
+               EgtRemoveCurveCompoCurve( nPathInt, false)
+               return true
+            end
+         end
+      end
+   end
+
+   return false
+end
+
 -------------------------------------------------------------------------------------------------------------
 return BeamLib

LuaLibs/DiceCut.lua

@@ -377,12 +377,13 @@ end
 --   ptCBond*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
 --   vtNBond*: il versore normale della superfice limitante (se non esistono altre superfici può essere omesso)
 --   dOrthoMaxDim : massima profondità taglio se faccia singola perpendicolare facce laterali trave
---   dCustMaxDimDice: dimensione massima customizzata, sostituisce il parametro BD.MAX_DIM_DICE
+--   dCustMaxDimDice: dimensione massima customizzata, sostituisce il parametro BD.MAX_DIM_DICE (se negativa qualunque, se positiva deve stare nel MAX)
 --   bDownHead : taglio con testa da sotto
 ----------------------------------------------------------------------------------------------------------------------------------------------------
 function DiceCut.GetDice( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, bGetOrtoPlanes, ptCBond, vtNBond, dOrthoMaxDim, dCustMaxDimDice, bDownHead)
 
-   local dMaxDimDice = EgtIf( dCustMaxDimDice and dCustMaxDimDice < BD.MAX_DIM_DICE, dCustMaxDimDice, BD.MAX_DIM_DICE)
+   local dMaxDimDice = BD.MAX_DIM_DICE 
+   if dCustMaxDimDice and dCustMaxDimDice < BD.MAX_DIM_DICE then dMaxDimDice = abs( dCustMaxDimDice) end
    local dTolerance = 0                      -- distanza di sicurezza per i tagli ortogonali
    local OffsetP = dMaxDimDice               -- distanza tra i piani paralleli
    local StepP = 100                         -- numero massimo di piani paralleli da generare
@@ -496,6 +497,12 @@ function DiceCut.GetDice( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, bGetOrtoPl
          if bDownHead and vtO:getZ() > 0.05 then
             vtO = -vtO
          end
+         -- per macchina TURN
+         if BD.TURN then
+            if vtO:getY() > 0.707 then
+               vtO = -vtO
+            end
+         end
          -- calcolo le dimensioni dell'offset e dove posizionare la prima faccia:
          --   CopyPlane: 0 => crea la prima faccia direttamente sul punto passato
          --   CopyPlane: 1 => crea la prima faccia e tutte le altre con l'offset passato

LuaLibs/FacesBySaw.lua

@@ -1,4 +1,4 @@
--- FacesBySaw.lua by Egaltech s.r.l. 2022/06/29
+-- FacesBySaw.lua by Egaltech s.r.l. 2022/09/24
 -- Gestione taglio con lama di feature con una o due facce
 -- 2021/01/06 Cambiato limite per attacco Tg con lama e CalcLeadInOutGeom rinominata in CalcLeadInOutPerpGeom.
 -- 2021/02/03 In taglio lama si accettano anche due lati con deviazione minore di 20deg.
@@ -12,6 +12,7 @@
 -- 2021/11/26 DS Spostate qui MakeOneFaceBySaw (ora MakeOne), CalcLeadInOutPerpGeom e CalcLeadInOutTangGeom.
 -- 2022/04/12 DS Aggiunta gestione speciale cubetti con fresa da sotto.
 -- 2022/06/29 DS In MakeTwo modificato controllo facce dirette verso il basso.
+-- 2022/09/08 In MakeOne aggiunto argomento bForceInvert per poter forzare l'inversione del percorso.
 
 -- Tabella per definizione modulo
 local FacesBySaw = {}
@@ -28,7 +29,7 @@ local BD = require( 'BeamData')
 local ML = require( 'MachiningLib')
 
 ---------------------------------------------------------------------
-function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw)
+function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, bForceInvert)
    -- dati della faccia
    local ptC, vtN = EgtSurfTmFacetCenter( nSurfId, nFacet, GDB_ID.ROOT)
    -- risolvo parametro ambiguo
@@ -51,7 +52,10 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
       return true, ''
    end
    vtV1 = - vtV1
-   local bInvert = ( ptP2:getZ() < ptP1:getZ() - 100 * GEO.EPS_SMALL)
+   local bInvert = bForceInvert
+   if bInvert == nil then
+      bInvert = ( ptP2:getZ() < ptP1:getZ() - 100 * GEO.EPS_SMALL)
+   end
    if bInvert then
       ptP1, ptP2 = ptP2, ptP1
       vtV1, vtV2 = vtV2, vtV1
@@ -122,7 +126,7 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
    local ptP1act = ptP1 + vtN * dCutOffset
    local ptP2act = ptP2 + vtN * dCutOffset
    -- attacco perpendicolare
-   local dLiTang, dLiPerp, dLoTang, dLoPerp = FacesBySaw.CalcLeadInOutPerpGeom( ptP1act, ptP2act, vtV1, vtV2, vtN, dSawDiam/2, vtRef, dCutExtra, b3Box)
+   local dLiTang, dLiPerp, dLoTang, dLoPerp, vtLio = FacesBySaw.CalcLeadInOutPerpGeom( ptP1act, ptP2act, vtV1, vtV2, vtN, dSawDiam/2, vtRef, dCutExtra, b3Box)
    local dLenLi = sqrt( dLiTang * dLiTang + dLiPerp * dLiPerp)
    local dLenLo = sqrt( dLoTang * dLoTang + dLoPerp * dLoPerp)
    -- attacco tangente
@@ -156,11 +160,26 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
          nSCC = EgtIf( ( vtAux:getY() > -GEO.EPS_SMALL), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
       end
    else
-      local vtTest = EgtIf( bTurnTang, EgtIf( bInvert, vtTg, -vtTg), vtOut)
-      if abs( vtTest:getY()) > abs( vtTest:getZ()) then
-         nSCC = EgtIf( vtTest:getY() > 0, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+      if bTurnTang then
+         local vtTest = EgtIf( bInvert, vtTg, -vtTg)
+         if abs( vtTest:getY()) > abs( vtTest:getZ()) then
+            nSCC = EgtIf( vtTest:getY() > 0, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+         else
+            nSCC = EgtIf( vtTest:getZ() > 0, MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
+         end
       else
-         nSCC = EgtIf( vtTest:getZ() > 0, MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
+         local vtTest = vtOut   -- vtLio
+         if abs( vtN:getY()) < 0.174 and abs( vtN:getZ()) < 0.174 then
+            if abs( vtTest:getY()) > abs( vtTest:getZ()) then
+               nSCC = EgtIf( vtTest:getY() > 0, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+            else
+               nSCC = EgtIf( vtTest:getZ() > 0, MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
+            end
+         elseif abs( vtN:getZ()) < 0.174 then
+            nSCC = EgtIf( vtTest:getZ() > -0.017, MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
+         else
+            nSCC = EgtIf( vtTest:getY() > 0, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+         end
       end
    end
    -- inserisco la lavorazione di taglio
@@ -460,29 +479,24 @@ function FacesBySaw.CalcLeadInOutPerpGeom( ptP1, ptP2, vtV1, vtV2, vtN, dRad, vt
    local vtX = vtTg ^ vtN
    local frFace = Frame3d( ptP1, vtX, vtTg, vtN)
    EgtOutLog( 'Vref=' .. tostring( vtRef) .. ' V1=' .. tostring( vtV1) .. ' V2=' .. tostring( vtV2), 3)
-   -- Versori di attacco e uscita
+   -- Versore di attacco e uscita
    local dCos1 = vtV1 * vtRef
    local dCos2 = vtV2 * vtRef
-   local vtLi, vtLo
+   local vtLio
    if abs( dCos1 - dCos2) < 0.001 then
       if abs( vtV1:getZ()) < abs( vtV2:getZ()) then
-         vtLi = vtV1
-         vtLo = vtV1
+         vtLio = vtV1
       else
-         vtLi = vtV2
-         vtLo = vtV2
+         vtLio = vtV2
       end
    elseif dCos1 > dCos2 then
-      vtLi = vtV1
-      vtLo = vtV1
+      vtLio = vtV1
    else
-      vtLi = vtV2
-      vtLo = vtV2
+      vtLio = vtV2
    end
-   local bRight = ( vtX * vtLi > 0)
-   -- Versori di attacco e uscita nel riferimento intrinseco al taglio
-   local vtLiL = Vector3d( vtLi) ;   vtLiL:toLoc( frFace)
-   local vtLoL = Vector3d( vtLo) ;   vtLoL:toLoc( frFace)
+   local bRight = ( vtX * vtLio > 0)
+   -- Versore di attacco e uscita nel riferimento intrinseco al taglio
+   local vtLioL = Vector3d( vtLio) ;   vtLioL:toLoc( frFace)
    -- Spostamento punti per effetto dell'extra o della deficienza di taglio
    ptP1 = ptP1 + vtX * ( EgtIf( bRight, - dCutExtra, dCutExtra))
    ptP2 = ptP2 + vtX * ( EgtIf( bRight, - dCutExtra, dCutExtra))
@@ -492,30 +506,30 @@ function FacesBySaw.CalcLeadInOutPerpGeom( ptP1, ptP2, vtV1, vtV2, vtN, dRad, vt
    -- Attacco
    local dLiTang = 10000
    local dLiPerp = 10000
-   local bLiOk, _, vLiPar = EgtLineBoxInters( ptP1, vtLi, b3MyBox)
+   local bLiOk, _, vLiPar = EgtLineBoxInters( ptP1, vtLio, b3MyBox)
    if bLiOk and #vLiPar > 0 then
       -- con la prima faccia di uscita
       local dLen = vLiPar[#vLiPar]
-      local ptInt = ptP1 + vtLi * dLen
-      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLi)
+      local ptInt = ptP1 + vtLio * dLen
+      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLio)
       EgtOutLog( 'LiFaceNorm=' .. tostring( vtFN), 3)
-      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLi * vtFN)
+      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLio * vtFN)
       local dLiLen = dLen + dAddLen
       EgtOutLog( 'LeadIn Dist=' .. EgtNumToString( dLiLen), 3)
-      dLiTang = - dLiLen * vtLiL:getY()
-      dLiPerp = EgtIf( bRight, dLiLen, - dLiLen) * vtLiL:getX()
+      dLiTang = - dLiLen * vtLioL:getY()
+      dLiPerp = EgtIf( bRight, dLiLen, - dLiLen) * vtLioL:getX()
       -- verifico se miglioro calcolando con faccia successiva
       local b3Mod = BBox3d( b3MyBox) ;  b3Mod:Add( ptInt + 1000 * vtFN)
-      local bLiOk2, _, vLiPar2 = EgtLineBoxInters( ptP1, vtLi, b3Mod)
+      local bLiOk2, _, vLiPar2 = EgtLineBoxInters( ptP1, vtLio, b3Mod)
       if bLiOk2 and #vLiPar2 > 0 then
          local dLen2 = vLiPar2[#vLiPar2]
-         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP1 + vtLi * dLen2, vtLi)
+         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP1 + vtLio * dLen2, vtLio)
          EgtOutLog( 'LiFaceNorm2=' .. tostring( vtFN2), 3)
-         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLi * vtFN2)
+         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLio * vtFN2)
          local dLiLen2 = dLen2 + dAddLen2
          EgtOutLog( 'LeadIn Dist2=' .. EgtNumToString( dLiLen2), 3)
-         local dLiTang2 = - dLiLen2 * vtLiL:getY()
-         local dLiPerp2 = EgtIf( bRight, dLiLen2, - dLiLen2) * vtLiL:getX()
+         local dLiTang2 = - dLiLen2 * vtLioL:getY()
+         local dLiPerp2 = EgtIf( bRight, dLiLen2, - dLiLen2) * vtLioL:getX()
          if dLiLen2 < dLiLen then
             dLiTang = dLiTang2
             dLiPerp = dLiPerp2
@@ -525,37 +539,37 @@ function FacesBySaw.CalcLeadInOutPerpGeom( ptP1, ptP2, vtV1, vtV2, vtN, dRad, vt
    -- Lunghezza di uscita
    local dLoTang = 10000
    local dLoPerp = 10000
-   local bLoOk, _, vLoPar = EgtLineBoxInters( ptP2, vtLo, b3MyBox)
+   local bLoOk, _, vLoPar = EgtLineBoxInters( ptP2, vtLio, b3MyBox)
    if bLoOk and #vLoPar > 0 then
       -- con la prima faccia di uscita
       local dLen = vLoPar[#vLoPar]
-      local ptInt = ptP2 + vtLo * dLen
-      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLo)
+      local ptInt = ptP2 + vtLio * dLen
+      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLio)
       EgtOutLog( 'LoFaceNorm=' .. tostring( vtFN), 3)
-      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLo * vtFN)
+      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLio * vtFN)
       local dLoLen = dLen + dAddLen
       EgtOutLog( 'LeadOut Dist=' .. EgtNumToString( dLoLen), 3)
-      dLoTang = dLoLen * vtLoL:getY()
-      dLoPerp = EgtIf( bRight, dLoLen, - dLoLen) * vtLoL:getX()
+      dLoTang = dLoLen * vtLioL:getY()
+      dLoPerp = EgtIf( bRight, dLoLen, - dLoLen) * vtLioL:getX()
       -- verifico se miglioro calcolando con faccia successiva
       local b3Mod = BBox3d( b3MyBox) ;  b3Mod:Add( ptInt + 1000 * vtFN)
-      local bLoOk2, _, vLoPar2 = EgtLineBoxInters( ptP2, vtLo, b3Mod)
+      local bLoOk2, _, vLoPar2 = EgtLineBoxInters( ptP2, vtLio, b3Mod)
       if bLoOk2 and #vLoPar2 > 0 then
          local dLen2 = vLoPar2[#vLoPar2]
-         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP2 + vtLo * dLen2, vtLo)
+         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP2 + vtLio * dLen2, vtLio)
          EgtOutLog( 'LoFaceNorm2=' .. tostring( vtFN2), 3)
-         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLo * vtFN2)
+         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLio * vtFN2)
          local dLoLen2 = dLen2 + dAddLen2
          EgtOutLog( 'LeadOut Dist2=' .. EgtNumToString( dLoLen2), 3)
-         local dLoTang2 = dLoLen2 * vtLoL:getY()
-         local dLoPerp2 = EgtIf( bRight, dLoLen2, - dLoLen2) * vtLoL:getX()
+         local dLoTang2 = dLoLen2 * vtLioL:getY()
+         local dLoPerp2 = EgtIf( bRight, dLoLen2, - dLoLen2) * vtLioL:getX()
          if dLoLen2 < dLoLen then
             dLoTang = dLoTang2
             dLoPerp = dLoPerp2
          end
       end
    end
-   return dLiTang, dLiPerp, dLoTang, dLoPerp
+   return dLiTang, dLiPerp, dLoTang, dLoPerp, vtLio
 end
 
 ---------------------------------------------------------------------

LuaLibs/MachiningLib.lua

@@ -1,6 +1,8 @@
 -- 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
+-- 2022/11/02 Modificata scelta utensile ottimizzata. Ora se c'è un utensile più grande disponibile si dà preferenza a quello.
 
 -- Tabella per definizione modulo
 local MachiningLib = {}
@@ -110,24 +112,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 +172,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 +208,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 +250,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
@@ -280,11 +264,13 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
       -- se posso usare entrambe le teste, la gestisco come una macchina a due teste da sopra
       MachineHeadUse = TWO_EQUAL_HEADS
    end
+   --  variabile che definisce quando un utensile ha un diametro sostanzialmente più grande di un altro
+   local dBiggerToolTolerance = 1.25
    for i = ForStart, ForEnd, ForStep do
       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)
@@ -301,22 +287,24 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
                   return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
                -- verifico se posso usare lo stesso utensile della testa attiva
                elseif ( nActiveHead == 1 and not bH2 and sToolName == H1_TOOL) or ( nActiveHead == 2 and bH2 and sToolName == H2_TOOL) then
-                  SetNextMachining( sToolName, nActiveHead, bFixed)
-                  return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
+               -- se l'utensile sulla testa attiva è molto più piccolo rispetto a quelli salvati non lo scelgo
+                  if ( not sH1Param or not sH1Param.TDiam or sH1Param.TDiam < dBiggerToolTolerance * ToolParams.TDiam) and ( not sH2Param or not sH2Param.TDiam or sH2Param.TDiam < 1.25 * ToolParams.TDiam) then
+                     SetNextMachining( sToolName, nActiveHead, bFixed)
+                     return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
+                  end
+               end
+               -- segno le lavorazioni disponibili per entrambe le teste
+               if bH2 then
+                  if not sH2Mach or sH2Mach == '' then
+                     sH2Mach = Machining.Name
+                     sH2Tool = sToolName
+                     sH2Param = ToolParams
+                  end
                else
-                  -- segno le lavorazioni disponibili per entrambe le teste
-                  if bH2 then
-                     if not sH2Mach or sH2Mach == '' then
-                        sH2Mach = Machining.Name
-                        sH2Tool = sToolName
-                        sH2Param = ToolParams
-                     end
-                  else
-                     if not sH1Mach or sH1Mach == '' then
-                        sH1Mach = Machining.Name
-                        sH1Tool = sToolName
-                        sH1Param = ToolParams
-                     end
+                  if not sH1Mach or sH1Mach == '' then
+                     sH1Mach = Machining.Name
+                     sH1Tool = sToolName
+                     sH1Param = ToolParams
                   end
                end
             elseif MachineHeadUse == TWO_UP_DOWN_HEADS then
@@ -332,6 +320,16 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
       end
    end
    if MachineHeadUse == TWO_EQUAL_HEADS then
+      -- se uno dei due utensili è molto più grande dell'altro scelgo quello senza fare altre analisi
+      if sH1Mach ~= "" and sH1Param.TDiam and sH2Mach ~= "" and sH2Param.TDiam then
+         if sH1Param.TDiam > dBiggerToolTolerance * sH2Param.TDiam then
+            SetNextMachining( sH1Tool, 1, bFixed)
+            return ReturnParams( MachiningType, sH1Mach, sType, sH1Param)
+         elseif sH2Param.TDiam > dBiggerToolTolerance * sH1Param.TDiam then 
+            SetNextMachining( sH2Tool, 2, bFixed)
+            return ReturnParams( MachiningType, sH2Mach, sType, sH2Param)
+         end
+      end
       -- verifico se cambiare testa o cambiare utensile su quella corrente
       if nActiveHead == 1 then
          if sH2Mach ~= "" then
@@ -355,7 +353,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 +375,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/09/30
 -- 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,12 @@
 -- 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.
+-- 2022/08/12 I tagli di lama inclinati in coda ora partono dal centro e non dall'esterno.
+-- 2022/08/24 Disabilitato il dicing per i tagli meno spessi della lama.
+-- 2022/08/25 In caso di AdvTail con taglio lungo Y la profondità di lavorazione è opportunamente diminuita.
+-- 2022/08/30 Modificata la condizione che determina l'utilizzo della testa da sotto. Ora controlla se la trave è più grande del doppio della massima larghezza del cubetto.
+-- 2022/09/23 Corretta la condizione per cui è richiesto l'aggiornamento del grezzo.
 
 -- Tabella per definizione modulo
 local ProcessCut = {}
@@ -243,9 +249,22 @@ 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 ( abs(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
+         local bOk, sErr = LongCut.Make( Proc, nPhase, nRawId, nPartId, true)
+         return bOk, sErr, bNoDicing
+      elseif bLongCutFromSide then
+         local bOk, sErr = LongCut.Make( Proc, nPhase, nRawId, nPartId, false, 2)
+         return bOk, sErr, bNoDicing
+      end
+      -- se non passa dal LongCut rimetto a false perchè ha fatto un taglio standard
+      bNoDicing = false
    end
    -- se pezzo ancora attaccato alla trave, per non rovinare quello successivo
    local bFillAreaPiece
@@ -312,7 +331,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)
@@ -333,10 +353,41 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
          vtExtra = X_AX()
          bAutoCalcSurf = false
       end
-      vCuts = DC.GetDice( nAddGrpId, EgtIf( bForced, b3Raw, b3Solid), ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA)
-      -- se taglio sborda in coda e non è stato inserito nessun taglio a cubetti, lo rilancio con le dimensioni customizzate
-      if ( bFillTail or bCustDiceCut) and #vCuts == 0 then
-         vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA, Proc.Box:getDimY())
+      -- verifico elevazione max del materiale tagliato
+      local dMaxElev
+      if vtN:getX() > 0 then
+         if bForced then
+            dMaxElev = b3Raw:getMax():getX() - Proc.Box:getMin():getX()
+         else
+            dMaxElev = b3Solid:getMax():getX() - Proc.Box:getMin():getX()
+         end
+      else
+         if bForced then
+            dMaxElev = Proc.Box:getMax():getX() - b3Raw:getMin():getX()
+         else
+            dMaxElev = Proc.Box:getMax():getX() - b3Solid:getMin():getX()
+         end
+      end
+      -- per macchina TURN aggiusto massima dimensione cubetto
+      local dNewDiceDim
+      if BD.TURN then
+         local dDimRef = GEO.INFINITO
+         if abs( vtN:getZ()) < 0.003 then
+            dDimRef = b3Raw:getDimZ()
+         elseif abs( vtN:getY()) < 0.003 then
+            dDimRef = b3Raw:getDimY()
+         end
+         if dDimRef + BD.CUT_EXTRA < dMaxDepth then
+            dNewDiceDim = - ( dMaxDepth - BD.CUT_EXTRA)
+         end
+      end
+      -- se il taglio è più spesso della lama abilito il dicing, altrimenti no
+      if dMaxElev > dSawThick then
+         vCuts = DC.GetDice( nAddGrpId, EgtIf( bForced, b3Raw, b3Solid), ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA, dNewDiceDim)
+         -- se taglio sborda in coda e non è stato inserito nessun taglio a cubetti, lo rilancio con le dimensioni customizzate
+         if ( bFillTail or bCustDiceCut) and #vCuts == 0 then
+            vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA, Proc.Box:getDimY())
+         end
       end
    end
    -- se il ProcessCut viene lanciato dal ProcessSawCut e non ci sono tagli a cubetti, esco
@@ -392,14 +443,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
@@ -414,7 +463,7 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                   local dVzLimDwnUp = dNzLimDwnUp
                   if j ~= 1 then
                      vtNewOrthoO = -vtOrthoO
-                     if not BD.C_SIMM and abs( vtN:getY()) > 0.05 then dVzLimDwnUp = -0.707 end
+                     if not BD.C_SIMM and not BD.TURN and abs( vtN:getY()) > 0.05 then dVzLimDwnUp = -0.708 end
                   end
                   local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtNewOrthoO, dVzLimDwnUp, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
                   if not bOk then return bOk, sErr end
@@ -438,7 +487,7 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                   end
                end
                local dVzLimDwnUp = dNzLimDwnUp
-               if not BD.C_SIMM and vtN:getZ() > 0.707 then dVzLimDwnUp = -0.708 end
+               if not BD.C_SIMM and not BD.TURN and vtN:getZ() > 0.707 then dVzLimDwnUp = -0.708 end
                local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, sNotes, b3Raw)
                if not bOk then return bOk, sErr end
             end
@@ -457,7 +506,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
@@ -472,14 +521,17 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
          else
             vtOrthoO = -X_AX()
          end
-      elseif Proc.Head then
-         vtOrthoO = EgtIf( vtN:getY() > -0.02, -Y_AX(), Y_AX())
       else
-         if vtN:getZ() < dVzLimDwnUp then
+         if vtN:getZ() < dVzLimDwnUp or Proc.Head or Proc.Tail then
             vtOrthoO = EgtIf( vtN:getY() > -0.02, -Y_AX(), Y_AX())
          else
             vtOrthoO = EgtIf( vtN:getY() > 0.02, Y_AX(), -Y_AX())
          end
+         -- se è una lavorazione da anticipare diminuisco la profondità del taglio per evitare collisioni con l'albero della lama
+         if Proc.AdvTail then
+            local _, dH = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
+            dCutExtra = min( -BD.ADVANCE_TAIL_OFFS, -dH + dMaxDepth)
+         end
       end
       -- taglio
       local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
@@ -704,9 +756,9 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom,
          return true
       end
    end
-   -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -20deg e sbandato oltre 1deg oppure sezione larga o pezzo corto)
+   -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -20deg e sbandato oltre 1deg oppure sezione più larga di 2 cubetti o pezzo corto)
    local bDownHead = ( BD.DOWN_HEAD and vtN:getZ() < -0.341 and
-                       ( abs( vtN:getY()) > 0.017 or b3Raw:getDimY() > 2 * ( BD.MAX_DIM_HTCUT - BD.CUT_EXTRA_MIN) or b3Raw:getDimX() < BD.LEN_SHORT_PART))
+                       ( abs( vtN:getY()) > 0.017 or b3Raw:getDimY() > 2 * ( BD.MAX_DIM_DICE - BD.CUT_EXTRA_MIN) or b3Raw:getDimX() < BD.LEN_SHORT_PART))
    local bDownTurn = ( BD.TURN and vtN:getZ() < -0.017)
    local bTopHead = ( BD.DOWN_HEAD and ( vtN:getZ() > -0.342 or not bDownHead))
    -- recupero la lavorazione
@@ -718,9 +770,11 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom,
       EgtOutLog( sErr)
       return false, sErr
    end
+   local bNoDicing = false
    -- se taglio con testa da sopra
    if not bDownHead and not bDownTurn then
-      local bOk, sErr = MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bForced, b3Raw, sNotes)
+      local bOk, sErr, bNoDicing2 = MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bForced, b3Raw, sNotes)
+      bNoDicing = bNoDicing2
       if not bOk then return false, sErr end
    -- altrimenti taglio con testa da sotto
    else
@@ -728,7 +782,8 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom,
       if not bOk then return false, sErr end
    end
    -- Aggiornamento ingombro (se vero taglio o richiesto)
-   if ProcessCut.Identify( Proc) or bUpdateIng then
+   -- Se lascio il cordolo (bNoDicing) non aggiorno il grezzo perchè lo scarto rimane attaccato
+   if ( ProcessCut.Identify( Proc) or bUpdateIng) and not bNoDicing then
       UpdateEncumbrance( Proc, vtN, dOvmHead, nRawId, b3Solid, b3Raw)
    end
    return true

LuaLibs/ProcessDoubleCut.lua

@@ -1,5 +1,6 @@
 -- ProcessDoubleCut.lua by Egaltech s.r.l. 2022/07/11
 -- Gestione calcolo doppi tagli di lama per Travi
+-- 2022/08/29 Implementata la fresatura dal lato per tagli problematici per PF1250
 
 -- Tabella per definizione modulo
 local ProcessDoubleCut = {}
@@ -188,6 +189,293 @@ local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
    return true
 end
 
+---------------------------------------------------------------------
+local function VerifyPocket( Proc, dDiam, dDepth, dMaxTotLen, sMchFindMaster, bPocketDown)
+   -- tipo di svuotatura
+   local sMchFind = EgtIf( sMchFindMaster and #sMchFindMaster > 0, sMchFindMaster, 'Pocket')
+   -- ricerca della svuotatura
+   local sPocketing
+   if dDepth then
+      sPocketing = ML.FindPocketing( sMchFind, dDiam, dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sMchFind, dDiam, 0.8 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sMchFind, dDiam, 0.6 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sMchFind, dDiam, 0.4 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sMchFind, dDiam, 0, dMaxTotLen)
+   else
+      sPocketing = ML.FindPocketing( sMchFind, dDiam, 0, dMaxTotLen)
+   end
+   if not sPocketing then
+      return false
+   end
+   -- recupero i dati dell'utensile
+   local bUsePocketing = false
+   local dMaxDepth = 0
+   local dToolDiam = 0
+   if EgtMdbSetCurrMachining( sPocketing) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
+         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
+      end
+      bUsePocketing = true
+   end
+   return bUsePocketing, sPocketing, dMaxDepth, dToolDiam
+end
+
+---------------------------------------------------------------------
+local function SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId)
+   -- fondo tra loro le curve compatibili
+   EgtMergeCurvesInCurveCompo( nPathInt)
+   local nStartIdEnt, nNumEnt = EgtCurveDomain( nPathInt) 
+   local pLastPIni, pLastPEnd
+   -- faccio una copia della curva e la esplodo
+   if nStartIdEnt then
+      -- ciclo i lati della curva e controllo per ognuno se giace in uno dei piani limite del pezzo: se sì allora il lato è aperto 
+      for i = 1, nNumEnt do
+         local pPini = EgtUP( nPathInt, (i-1), GDB_RT.GLOB) 
+         local pPend = EgtUP( nPathInt, EgtIf( i == nNumEnt, 0, i), GDB_RT.GLOB)
+         if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
+            -- scrivo nelle proprietà della curva quali sono i lati aperti
+            local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+            if #sActInfo > 0 then
+               -- se ci sono già altri lati aperti
+               EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+            else
+               -- se è l'unico
+               EgtSetInfo( nPathInt, 'OPEN', (i-1))
+            end
+         end
+      end
+   end
+   return false
+end
+
+---------------------------------------------------------------------
+local function MakeBySidePocket( Proc, nPhase, nRawId, nPartId, nAddGrpId, b3Solid)
+   local nFirstMachId
+   local sWarn
+   local sMchFind = 'OpenPocket'
+   local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt
+   local bBadMach = false
+   -- ottengo le dimensioni del tunnel 
+   dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
+   -- posso utilizzare utensile con diametro doppio della dimensione minima
+   dDimMin = min( 2 * dDimMin, BD.MAXDIAM_POCK_CORNER)
+   local nPathInt
+   -- verifico se è presente la testa da sotto e se è necessario usarla
+   bMillDown = ( BD.DOWN_HEAD == true and abs( vtOrtho:getZ()) >= 0.707)
+   -- cerco l'utensile di svuotatura per la testa sopra
+   local bMakePocket, sPocketing, dMaxDepth, dDiamTool = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind)
+   local bMakePocketDn, sPocketingDn, dMaxDepthDn, dDiamToolDn
+   -- cerco anche l'utensile per la testa sotto, nel caso servisse
+   if bMillDown then
+      bMakePocketDn, sPocketingDn, dMaxDepthDn, dDiamToolDn = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind, true)
+      -- se è negativo inverto il versore e la faccia
+      if vtOrtho:getZ() < 0 then 
+         vtOrtho = -vtOrtho
+         EgtInvertSurf( nSurfInt)
+      end
+   end
+   if bMakePocket then
+      -- gestione svuotatura da un solo lato o anche dal lato opposto (se non verticale)
+      -- estraggo il contorno dalla superfice per evitare i problemi con la svuotatura
+      -- e assegno l'estrusione
+      nPathInt = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId)
+      EgtModifyCurveExtrusion( nPathInt, vtOrtho, GDB_RT.GLOB)
+      SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId)
+      -- variabili per parametri lavorazione
+      local dMachDepth
+      local dElev = 0
+      local bDoubleSide
+      local bOneShot
+      local bComplete = true
+      -- imposto altezza aggiuntiva di elevazione
+      local dCollSic = BL.CalcCollisionSafety( vtOrtho)
+      -- se possibile svuotare completamente da una sola parte
+      if dMaxDepth > ( dDepth + BD.CUT_EXTRA + dCollSic) then
+         dMachDepth = ( dDepth / 2) + BD.CUT_EXTRA
+         dElev = dDepth + BD.CUT_EXTRA
+         bOneShot = true
+      else
+         -- se direzione verso la verticale setto max affondamento possibile ed
+         -- emetto messaggio di warning perché non lavorabile interamente
+         if abs( vtOrtho:getZ()) >= 0.707 and not BD.DOWN_HEAD then
+            dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic
+            dElev = dMaxDepth
+            sWarn = 'Warning : elevation bigger than max tool depth'
+            EgtOutLog( sWarn)
+            bComplete = false
+         -- altrimenti setto il flag per fare la svuotatura da due parti 
+         else
+            -- se l'altezza utensile riesce a lavorare completamente da due parti
+            if dMaxDepth > ( dDepth / 2) + dCollSic + BD.CUT_EXTRA_MIN then
+               dMachDepth = BD.CUT_EXTRA_MIN
+               dElev = ( dDepth / 2) + BD.CUT_EXTRA_MIN
+            -- altrimenti non si riesce in due passate, limito la profondità e setto l'elevazione 
+            else
+               dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic
+               dElev = dMaxDepth
+               -- se molto inclinato rispetto alla normale della faccia di riferimento, lavorazione non idonea per probabili collisioni
+               local vtRef = Y_AX()
+               if abs( vtOrtho:getX()) > abs( vtOrtho:getY()) and abs( vtOrtho:getX()) > abs( vtOrtho:getZ()) then
+                  vtRef = X_AX()
+               elseif abs( vtOrtho:getZ()) > abs( vtOrtho:getX()) and abs( vtOrtho:getZ()) > abs( vtOrtho:getY()) then
+                  vtRef = Z_AX()
+               end
+               if abs( vtOrtho * vtRef) < 0.5 then
+                  bBadMach = true
+               end
+            end
+            bDoubleSide = true
+         end
+      end
+      -- inserisco la lavorazione di svuotatura
+      local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+      local nMchFId = EgtAddMachining( sName, sPocketing)
+      if not nMchFId then
+         local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
+         EgtOutLog( sErr)
+         return -1, sErr
+      end
+      -- prendo l'id della prima lavorazione inserita
+      if not nFirstMachId then
+         nFirstMachId = nMchFId
+      end
+      -- aggiungo geometria
+      EgtSetMachiningGeometry( {{ nPathInt, -1}})
+      -- verifico se devo invertire direzione utensile (in caso di direzione verso la verticale)
+      local bInvertMach
+      if vtOrtho:getZ() < BD.NZ_MINA and abs(vtOrtho:getZ()) >= 0.707 and not BD.DOWN_HEAD then
+         EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+         bInvertMach = true
+      -- altrimenti se da fare in una sola volta e direzionato verso Y+ lo inverto per lavorarlo davanti
+      elseif not bDoubleSide and vtOrtho:getY() > GEO.EPS_SMALL and not ( -(vtOrtho:getZ()) < BD.NZ_MINA) then
+         EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+         bInvertMach = true
+      end
+      -- imposto posizione braccio porta testa
+      local nSCC = MCH_SCC.NONE
+      if not BD.C_SIMM then
+         if AreSameOrOppositeVectorApprox( vtOrtho, Z_AX()) then
+            nSCC = MCH_SCC.ADIR_YM
+         elseif abs( vtOrtho:getX()) < 0.1 then
+            nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP)
+         elseif vtOrtho:getY() < GEO.EPS_SMALL then
+            nSCC = EgtIf( bInvertMach, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+         else
+            nSCC = EgtIf( bInvertMach, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP)
+         end
+      end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+      EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN)
+      -- inverto il percorso di lavorazione per lavorare sinistro
+      EgtSetMachiningParam( MCH_MP.INVERT, true)
+      -- imposto affondamento
+      EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
+      -- imposto elevazione e dichiaro non si generano sfridi per VMill
+      local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
+      sNotes = sNotes .. 'VMRS=0;'
+      EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
+      -- eseguo
+      if not ML.ApplyMachining( true, false) then
+         -- provo ad allargare leggermente la tasca
+         EgtSetMachiningParam( MCH_MP.OFFSR, -0.1)
+         if not ML.ApplyMachining( true, false) then
+            local _, sErr = EgtGetLastMachMgrError()
+            EgtSetOperationMode( nMchFId, false)
+            return -1, sErr
+         end
+      end
+      -- se posso applicare la svuotatura sul lato opposto
+      if bDoubleSide then
+         -- se ho la lavorazione da sotto ricalcolo in base a questa lavorazione
+         if bMakePocketDn then
+            -- sPocketing = sPocketingDn
+            -- dMaxDepth = dMaxDepthDn
+            -- dDiamTool = dDiamToolDn
+            -- se l'altezza utensile riesce a lavorare completamente da due parti
+            if dMaxDepthDn > ( dDepth / 2) + dCollSic + BD.CUT_EXTRA_MIN then
+               dMachDepth = BD.CUT_EXTRA_MIN
+               dElev = ( dDepth / 2) + BD.CUT_EXTRA_MIN
+            -- altrimenti non si riesce in due passate, limito la profondità e setto l'elevazione 
+            else
+               dMachDepth = dMaxDepthDn - ( dDepth / 2) - dCollSic
+               dElev = dMaxDepthDn
+               bComplete = false
+               sWarn = 'Warning : elevation bigger than max tool depth'
+               EgtOutLog( sWarn)
+            end
+         else
+            -- se anche lavorando dal lato opposto non riesco a svuotare completamente la fessura 
+            -- setto i parametri affondamento ed emetto warning
+            if dMaxDepth < ( dDepth / 2) + BD.CUT_EXTRA + dCollSic then
+               dMachDepth = dMaxDepth - (dDepth / 2) - dCollSic
+               dElev = dMaxDepth
+               bComplete = false
+               sWarn = 'Warning : elevation bigger than max tool depth'
+               EgtOutLog( sWarn)
+            end
+         end
+         -- inserisco la lavorazione di svuotatura
+         local sName = 'PockOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+         local nMchFId = EgtAddMachining( sName, EgtIf( bMakePocketDn, sPocketingDn, sPocketing))
+         if not nMchFId then
+            local sErr = 'Error adding machining ' .. sName .. '-' .. EgtIf( bMakePocketDn, sPocketingDn, sPocketing)
+            EgtOutLog( sErr)
+            return -1, sErr
+         end
+         -- prendo l'id della prima lavorazione inserita
+         if not nFirstMachId then
+            nFirstMachId = nMchFId
+         end
+         -- aggiungo geometria
+         EgtSetMachiningGeometry( {{ nPathInt, -1}})
+         -- imposto direzione utensile opposta
+         EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+         -- imposto posizione braccio porta testa
+         local nSCC = MCH_SCC.NONE
+         if not BD.C_SIMM then
+            if AreSameVectorApprox( vtOrtho, Z_AX()) then
+               nSCC = MCH_SCC.ADIR_YM
+            elseif abs( vtOrtho:getX()) < 0.1 then
+               nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP)
+            elseif vtOrtho:getY() < GEO.EPS_SMALL then
+               nSCC = MCH_SCC.ADIR_YP
+            else
+               nSCC = MCH_SCC.ADIR_YM
+            end
+         end
+         EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+         EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN)
+         -- inverto il percorso di lavorazione per lavorare sinistro
+         EgtSetMachiningParam( MCH_MP.INVERT, true)
+         -- imposo affondamento
+         EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
+         -- imposto elevazione e dichiaro non si generano sfridi per VMill
+         local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
+         sNotes = sNotes .. 'VMRS=0;'
+         EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
+         -- eseguo
+         if not ML.ApplyMachining( true, false) then
+            -- provo ad allargare leggermente la tasca
+            EgtSetMachiningParam( MCH_MP.OFFSR, -0.1)
+            if not ML.ApplyMachining( true, false) then
+               local _, sErr = EgtGetLastMachMgrError()
+               EgtSetOperationMode( nMchFId, false)
+               return -1, sErr
+            end
+         end
+      end
+      return 1, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId
+   end
+   return 0, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, bOrthoFaces
+end
+
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
@@ -272,6 +560,32 @@ 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)
+      -- per tutte le macchine tranne la Fast, controllo se ci sono tagli troppo inclinati e troppo profondi per la lama
+      -- in tal caso richiamo la lavorazione con fresa dal lato
+      if BD.C_SIMM and not bDownHead then
+         local sCutting = ML.FindCutting( sCutType, nil, bDownHead)
+            if not sCutting then
+            local sErr = 'Error : cutting not found in library'
+            EgtOutLog( sErr)
+            return false, sErr
+         end
+         local dMaxDepth = 0
+         if EgtMdbSetCurrMachining( sCutting) then
+            local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+            if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+               dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
+            end
+         end
+         local _, _, dDimV1 = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
+         local _, _, dDimV2 = BL.GetFaceHvRefDim( Proc.Id, 1, b3Raw)
+         local bFace1TooLongForBlade, bFace2TooLongForBlade = ( dDimV1 >= dMaxDepth), ( dDimV2 >= dMaxDepth)
+         local dFace1Ang, dFace2Ang = vtN[1]:getZ(), vtN[2]:getZ()
+         if bFace1TooLongForBlade and dFace1Ang < ( BD.CUT_VZ_MIN or -0.484) or bFace2TooLongForBlade and dFace2Ang < ( BD.CUT_VZ_MIN or -0.484) then
+            local bOk, sErr = MakeBySidePocket(  Proc, nPhase, nRawId, nPartId, nAddGrpId, b3Solid)
+            return bOk, sErr
+         end
+      end
       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

@@ -1,4 +1,4 @@
--- ProcessDrill.lua by Egaltech s.r.l. 2022/04/21
+-- ProcessDrill.lua by Egaltech s.r.l. 2022/08/18
 -- Gestione calcolo forature per Travi
 -- 2021/04/14 DS Corretta gestione Invert con testa da sotto. Migliorato calcolo ingombro portautensile.
 -- 2021/05/03 DS Su macchina con testa da sotto aggiunta possibilità di fare fori verticali metà sopra e l'altra sotto.
@@ -10,6 +10,11 @@
 -- 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
+-- 2022/08/18 Aggiunta gestione macchine con testa da sotto e punta disabilitata.
+-- 2022/10/25 Nella funzione Split aggiunto il controllo che le facce di ingresso e uscita siano differenti (potrebbe succedere per fori molto corti). Modifica importatore in futuro.
+-- 2022/11/23 Aggiunta la gestione dei fori con angolo < 30 gradi, per i quali si usa la testa della macchina per accorciare l'utile di lavoro.
 
 -- Tabella per definizione modulo
 local ProcessDrill = {}
@@ -115,7 +120,7 @@ function ProcessDrill.Split( Proc, b3Raw)
    local dDiam = 2 * EgtArcRadius( AuxId)
    local dLen = abs( EgtCurveThickness( AuxId))
    local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
-   local bOpen = ( Proc.Fce ~= 0)
+   local bOpen = ( Proc.Fce ~= 0) and ( Proc.Fce ~= Proc.Fcs)
    -- recupero flag abilitazione split (0=auto,1=no)
    local bTrySplit = ( EgtGetInfo( Proc.Id, 'Q02', 'i') ~= 1)
    if not bTrySplit then
@@ -167,9 +172,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 +227,34 @@ 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 possibilità di foratura da sotto
+   local bDownDrill = ( BD.DOWN_HEAD and ML.FindDrilling( dDiam, nil, false, true))
    -- 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 bDownDrill)
    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 bDownDrill) 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
@@ -215,8 +267,8 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
    local dCheckDepth2 = dDepth2
    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 bDrillDown = ( bDownDrill and ( Proc.Down or vtExtr:getZ() < -0.1 or vtExtr:getZ() < 0.259))
+   local bDrillUp = ( bDownDrill and vtExtr:getZ() > -0.421)
    -- 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 +330,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 +349,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 +366,68 @@ 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
+   -- Per fori molto inclinati ( < 30 gradi) si usa la testa della macchina per l'accorciamento. Fast esclusa
+   if BD.C_SIMM and CosB > 0.866  then
+      dSubL = ( 190 / 2 + ( Proc.Diam - dToolDiam) / 2 + 2) * TgA - 96
+   end
    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, max( dToolFreeLen - dSubL, 0))
+   -- Verifico inclinazione foro nei limiti
+   local bTryDrill = EgtIf( dMaxDepth > 0, ( CosB < BD.DRILL_VX_MAX), false)
+   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 +440,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 +462,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
@@ -464,8 +488,8 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
    EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
    -- eseguo
    local bOk = ML.ApplyMachining( true, false)
-   if not bOk and BD.DOWN_HEAD then
-      if sType == 'Drill' or sType == 'Drill_H2' then
+   if not bOk and bDownDrill then
+      if sType == 'Drill' or sType == 'Drill_H2' or sType == 'AngleDrill' then
          EgtSetMachiningParam( MCH_MP.INVERT, true)
       else
          EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)

LuaLibs/ProcessDtMortise.lua

@@ -1,4 +1,4 @@
--- ProcessDtMortise.lua by Egaltech s.r.l. 2022/06/07
+-- ProcessDtMortise.lua by Egaltech s.r.l. 2022/08/18
 -- Gestione calcolo mortase a coda di rondine per Travi
 -- 2021/04/08 Aggiunto controllo massimo materiale lavorabile dalla fresa.
 -- 2021/04/08 Miglioria scelta lavorazione in presenza di testa da sotto.
@@ -6,6 +6,8 @@
 -- 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/06/01 Modifiche per evitare di entrare nel legno con mortase parziali.
+-- 2022/08/18 Migliorato calcolo dello step.
+-- 2022/09/29 Aggiunto riconoscimento della sola feature laterale.
 
 -- Tabella per definizione modulo
 local ProcessDtMortise = {}
@@ -38,6 +40,12 @@ function ProcessDtMortise.FrontIdentify( Proc)
    return (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 56)
 end
 
+---------------------------------------------------------------------
+-- Riconoscimento della sola feature laterale
+function ProcessDtMortise.SideIdentify( Proc)
+   return (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 55)
+end
+
 ---------------------------------------------------------------------
 -- Verifica se feature di coda
 function ProcessDtMortise.IsTailFeature( Proc, b3Raw)
@@ -430,7 +438,8 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    local dDist = min( vtOrtDiff:len(), dWidthMrt)
    -- calcolo le passate
    local nPass = ceil( dDist / ( 1.9 * dToolDiam))
-   local dStep = ( dDist - 0.95 * dToolDiam) / ( 2 * nPass)
+   local dStep = 0
+   if nPass > 1 then dStep = max( ( dDist - 2 * dToolDiam) / ( 2 * nPass - 2), 0.25 * dToolDiam) end
    for i = nPass, 1, -1 do
       -- inserisco la lavorazione di contornatura
       local sNameF = 'DtMt_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nPass)

LuaLibs/ProcessFreeContour.lua

@@ -1,5 +1,10 @@
--- ProcessFreeContour.lua by Egaltech s.r.l. 2021/10/07
+-- ProcessFreeContour.lua by Egaltech s.r.l. 2022/11/03
 -- Gestione calcolo profilo libero per Travi
+-- 2022/08/23 Aggiunta la funzione MakeByMark per la gestione del caso P13=10
+-- 2022/09/21 In MakeByMill aggiunto messaggio per elevazione non raggiunta.
+-- 2022/11/03 In MakeByMill migliorata gestione lavorazione con fresa su testa da sotto.
+-- 2022/11/09 Aggiunta la gestione della chiamata della FreeContour da parte della SimpleScarf.
+
 
 -- Tabella per definizione modulo
 local ProcessFreeContour = {}
@@ -116,7 +121,7 @@ function ProcessFreeContour.Classify( Proc, b3Raw)
 end
 
 ---------------------------------------------------------------------
-local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham)
+local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham, bDownHead)
    local nChamfer = 0
    -- ingombro del grezzo
    local b3Raw = EgtGetRawPartBBox( nRawId)
@@ -156,7 +161,11 @@ local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham)
    -- recupero la lavorazione
    local sMilling
    if nChamfer > 0 then
-      sMilling = ML.FindMilling( 'Mark')
+      if bDownHead then
+         sMilling = ML.FindMilling( 'Mark_H2', nil, nil, nil, nil, false, true)
+      else
+         sMilling = ML.FindMilling( 'Mark')
+      end
       if not sMilling then
          local sErr = 'Error : Mark not found in library'
          EgtOutLog( sErr)
@@ -233,19 +242,22 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
    local dDepth = abs( EgtCurveThickness( AuxId))
    local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
    local b3Aux = EgtGetBBoxGlob( AuxId, GDB_BB.STANDARD)
-   local bToolInv = ( vtExtr:getZ() < -0.1)
    local bDown = ( b3Aux:getMin():getZ() < b3Raw:getMin():getZ() + 5)
    -- verifico se in testa o coda
    local bHead = Proc.Head
    -- verifico i parametri Q per profondità smusso e per eseguirlo in esclusiva
    local nChamfer, dDepthCham, sChamfer = VerifyChamfer( Proc, AuxId, nRawId, true)
-      -- recupero la lavorazione
-   local sMilling = ML.FindMilling( 'FreeContour')
+   -- recupero la lavorazione
+   local bTopHead = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.1)
+   local bDownHead = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.1)
+   local sMilling, _, _, bH2 = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, bTopHead, bDownHead)
    if not sMilling then
       local sErr = 'Error : FreeContour not found in library'
       EgtOutLog( sErr)
       return false, sErr
    end
+   bDownHead = ( bDownHead and bH2)
+   local bToolInv = ( not bDownHead and vtExtr:getZ() < -0.1 and b3Aux:getDimZ() > b3Raw:getDimZ() - 5)
    -- recupero i dati dell'utensile
    local dToolDiam = 10
    local dMaxDepth = 0
@@ -294,24 +306,29 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
    end
    local dOriDepth = dDepth
    local nDouble = 1
-   local bCanDouble = ( abs( vtExtr:getY()) > abs( vtExtr:getZ()) and bCross)
+   local bCanDouble = ( abs( vtExtr:getY()) > abs( vtExtr:getZ()) and bCross) or ( BD.DOWN_HEAD and bCross)
    local dDimStrip = BD.DIM_STRIP
    if dDimStrip < 0 then
       dDimStrip = EgtGetInfo( Proc.Id, Q_DIM_STRIP, 'd') or 0
    end
    local bStripOnSide = false
    if bCross then
-      if dDimStrip > 10 * GEO.EPS_SMALL and ( nStep > 1 or ( bDown and b3Aux:getDimX() > 0.5 * b3Raw:getDimX())) then
+      -- se chiamata da SimpleScarf il codolo è sempre attivo
+      if dDimStrip > 10 * GEO.EPS_SMALL and ( nStep > 1 or ( bDown and b3Aux:getDimX() > 0.5 * b3Raw:getDimX()) or Proc.Prc == 70) then
          -- devo lasciare un codolo
-         dDepth = dDepth - dDimStrip
+         local dExtraCham = EgtIf( nChamfer > 0, 2, 0)
+         dDepth = EgtIf( Proc.Prc == 70, dDepth - dDimStrip - dDepthCham - dExtraCham, dDepth - dDimStrip)
          bStripOnSide = true
       else
          -- devo affondare un poco oltre
          dDepth = dDepth + BD.CUT_EXTRA
       end
    end
+   local bIsDepthReduced = false
    -- se parametro beamdata forza codolo in centro e lavorazione orizzontale e se larghezza trave è sufficientemente larga
-   if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and nStep > 1 and
+   -- se chiamata da SimpleScarf il codolo è sempre attivo
+   local dDepthWork = dDepth
+   if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and ( nStep > 1 or Proc.Prc == 70) and
       bCanDouble and b3Raw:getDimY() > BD.DIM_TO_CENTER_STRIP - 0.1 then
       nDouble = 2
       dDepth = min( ( b3Raw:getDimY() - dDimStrip) * 0.5, dMaxDepth)
@@ -320,12 +337,23 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
       if dDepth > dMaxDepth then
          if bCanDouble then
             nDouble = 2
-            dDepth = min( 0.5 * dDepth, dMaxDepth)
+            dDepthWork = 0.5 * dDepth
+            dDepth = min( dDepthWork, dMaxDepth)
+            if dDepth < dDepthWork - 10 * GEO.EPS_SMALL then
+               bIsDepthReduced = true
+            end
          else
             dDepth = dMaxDepth
+            bIsDepthReduced = true
          end
       end
    end
+   local sWarn = ''
+   -- se ho ridotto l'altezza emetto warning
+   if bIsDepthReduced then
+      sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' (Free Contour) : depth (' .. EgtNumToString( dDepthWork, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+      EgtOutLog( sWarn)
+   end
    -- se utensile orizzontale verso Y+, non in doppio e codolo da lasciare, devo invertire per lavorare sempre da Y-
    if vtExtr:getY() > 0.707 and  nDouble == 1 and bStripOnSide then
       bToolInv = true
@@ -336,14 +364,33 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
    local dEndAddSpec = 0
    if Proc.Grp ~= 0 then dEndAddSpec = CalcSpecialAdd( AuxId, false, dToolDiam) end
    -- se devo inserire il chamfer
-   if nChamfer > 0 and Proc.Grp ~= 0 and dOriDepth > dDepthCham then
+   if nChamfer > 0 and Proc.Grp ~= 0 and dOriDepth > dDepthCham and Proc.Prc ~= 70 then
       local bDoubleCham = false
       local dExtra = 2
+   local sChamferDown, sChamferUp
+   if nDouble > 1 and bCanDouble then
+      if nSide == 0  then
+         if BD.DOWN_HEAD then               
+            -- recupero la lavorazione
+            _, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, true)
+            if not sChamferDown then
+               sWarn = 'Warning : chamfer from bottom not found in library'
+               EgtOutLog( sWarn)
+            end
+         end
+         _, _, sChamferUp = VerifyChamfer( Proc, AuxId, nRawId, true, false)
+         if not sChamferUp then
+            sWarn = 'Warning : milling not found in library'
+            EgtOutLog( sWarn)
+         end
+      end
+   end
       -- eseguo
       for i = 1, nStep do
          -- inserisco la lavorazione
          local sNameCh = 'Cham_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-         local nMchId = EgtAddMachining( sNameCh, sChamfer)
+         local sChamferSide1 = EgtIf( bDownHead, sChamferDown, sChamfer)
+         local nMchId = EgtAddMachining( sNameCh, sChamferSide1)
          if not nMchId then
             local sErr = 'Error adding machining ' .. sNameCh .. '-' .. sChamfer
             EgtOutLog( sErr)
@@ -352,15 +399,12 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
          -- aggiungo geometria
          EgtSetMachiningGeometry( {{ AuxId, -1}})
          -- se lavorazione da sopra o da sotto
-         if nSide ~= 0 then
-            bDoubleCham = true
-         end
          if Proc.Grp == 3 then
             if not bToolInv then
                EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
                EgtSetMachiningParam( MCH_MP.INVERT, true)
             else
-               if vtExtr:getZ() < 0 then
+               if not bDownHead and vtExtr:getZ() < 0 then
                   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
                   EgtSetMachiningParam( MCH_MP.INVERT, true)
                   EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
@@ -375,7 +419,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
                EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
                EgtSetMachiningParam( MCH_MP.INVERT, true)
             else
-               if vtExtr:getZ() < 0 then
+               if not bDownHead and vtExtr:getZ() < 0 then
                   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
                   EgtSetMachiningParam( MCH_MP.INVERT, true)
                   EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
@@ -384,6 +428,11 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
                end
             end
          end
+         if nSide == 0 then
+            bDoubleCham = BD.DOWN_HEAD
+         else
+            bDoubleCham = true
+         end
          -- assegno affondamento e offset radiale
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra)
          EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
@@ -423,12 +472,19 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
             EgtSetOperationMode( nMchId, false)
             return false, sErr
          end
-
          -- se lavorazione da due parti, aggiungo la seconda
          if bDoubleCham then
             -- inserisco la lavorazione
             local sName = 'ChamB_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-            local nMchId = EgtAddMachining( sName, sChamfer)
+            local sChamferSide2
+            if EgtEndsWith( sChamferSide1, 'H2') then
+               sChamferSide2 = sChamferUp
+            elseif nSide == 0 then
+               sChamferSide2 = sChamferDown
+            else
+               sChamferSide2 = sChamfer
+            end
+            nMchId = EgtAddMachining( sName, sChamferSide2)
             if not nMchId then
                local sErr = 'Error adding machining ' .. sName .. '-' .. sChamfer
                EgtOutLog( sErr)
@@ -489,6 +545,26 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
    end
    -- verifico se devo fare sgrossatura più finitura
    local dOffsetPar = EgtGetInfo( Proc.Id, Q_OVERMAT_FOR_FINISH, 'i') or 0
+   local sMillingDown, sMillingUp
+   if nDouble > 1 and bCanDouble then
+      if nSide == 0  then
+         if BD.DOWN_HEAD then               
+            -- recupero la lavorazione
+            sMillingDown = ML.FindMilling( 'FreeContour_H2', nil, nil, nil, nil, false, true)
+            if not sMillingDown then
+               sWarn = 'Warning : milling from bottom not found in library'
+               EgtOutLog( sWarn)
+            end
+         end
+         if EgtEndsWith( sMilling, '_H2') then
+            sMillingUp = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, true, false)
+            if not sMillingUp then
+               sWarn = 'Warning : milling not found in library'
+               EgtOutLog( sWarn)
+            end
+         end
+      end
+   end
    -- eseguo
    for i = 1, nStep do
       for j = 1, nDouble do
@@ -513,7 +589,11 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
          else
             -- inserisco la lavorazione
             sName = 'Free_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-            nMchId = EgtAddMachining( sName, sMilling)
+            if EgtEndsWith( sMilling, '_H2') then
+               nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingUp, sMilling))
+            else
+               nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingDown, sMilling))
+            end
             if not nMchId then
                local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
                EgtOutLog( sErr)
@@ -549,9 +629,9 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
          -- assegno lato di lavoro
          if Proc.Grp == 0 then
             EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.CENTER)
-         elseif ( Proc.Grp == 3 and not bToolInv) or ( Proc.Grp == 4 and bToolInv) then
+         elseif ( Proc.Grp == 3 and not bToolInv) or ( Proc.Grp == 4 and bToolInv) or ( Proc.Grp == 1 and bToolInv) or ( Proc.Grp == 2 and bToolInv) then
             EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
-         elseif ( Proc.Grp == 3 and bToolInv) or ( Proc.Grp == 4 and not bToolInv) then
+         elseif ( Proc.Grp == 3 and bToolInv) or ( Proc.Grp == 4 and not bToolInv) or ( Proc.Grp == 1 and not bToolInv) or ( Proc.Grp == 2 and not bToolInv) then
             EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
          end
          -- posizione braccio porta testa
@@ -620,7 +700,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
          BL.UpdateTCING( nRawId, dOffs)
       end
    end
-   return true
+   return true, sWarn
 end
 
 ---------------------------------------------------------------------
@@ -688,9 +768,84 @@ local function MakeByPocket( Proc, nPhase, nRawId, nPartId, dOvmHead)
    return true
 end
 
+---------------------------------------------------------------------
+local function MakeByMark( Proc, nRawId, b3Raw, nPartId)
+   -- ingombro del pezzo
+   local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
+   local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
+   if not b3Solid then
+      local sErr = 'Error : part box not found'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- recupero e verifico l'entità curva
+   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0
+   if AuxId then AuxId = AuxId + Proc.Id end
+   if not AuxId  or  ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then
+      local sErr = 'Error : missing profile geometry'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- recupero i dati della curva e del profilo
+   local dDepth = abs( EgtCurveThickness( AuxId))
+   local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
+   local bToolInv = ( vtExtr:getZ() < -0.1 and b3Aux:getDimZ() > b3Raw:getDimZ() - 5)
+   -- verifico che la marcatura non sia orientata verso il basso (-5 deg)
+   if vtExtr:getZ() < - 0.1 and not BD.DOWN_HEAD and not BD.TURN then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Mark from bottom impossible'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- abilitazione lavorazione da sotto
+   local bMillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.259)
+   local bMillDown = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.174)
+   -- recupero la lavorazione
+   local sMillType = 'Text'
+   --local sMchExt = EgtIf( bMillDown, '_H2', '')
+   local sMilling = ML.FindMilling( sMillType, nil, nil, nil, nil, bMillUp, bMillDown)
+   if not sMilling then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- inserisco la lavorazione
+   local sName = 'FreeMark_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+   local nMchId = EgtAddMachining( sName, sMilling)
+   if not nMchId then
+      local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   EgtSetInfo( nMchId, 'Part', Proc.PartId)
+   -- aggiungo geometria
+   EgtSetMachiningGeometry( {{ AuxId, -1}})
+   -- se estrusione da sotto, inverto direzione fresa
+   if bToolInv then
+      EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+   end
+   -- posizione braccio porta testa
+   local nSCC = MCH_SCC.ADIR_ZP
+   if AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
+      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
+   end
+   EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+   -- eseguo
+   if not EgtApplyMachining( true, false) then
+      local _, sErr = EgtGetLastMachMgrError()
+      EgtSetOperationMode( nMchId, false)
+      return false, sErr
+   end
+   return true
+end
+
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessFreeContour.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+   -- riassegno Q nel caso la funzione sia richiamata da un'altra make
+   if Proc.Prc == 70 then
+      Q_DEPTH_CHAMFER = 'Q01'
+      Q_DIM_STRIP = 'Q02'
+   end
    -- recupero la tipologia
    local bPocket = ( EgtGetInfo( Proc.Id, 'PCKT', 'i') == 1)
    -- se svuotatura
@@ -698,7 +853,15 @@ function ProcessFreeContour.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
       return MakeByPocket( Proc, nPhase, nRawId, nPartId, dOvmHead)
    -- altrimenti contornatura
    else
-      return MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
+      -- recupero il tipo di lavorazione
+      local nCntType = EgtGetInfo( Proc.Id, 'CNT_TYPE', 'i') or 0
+      -- se marcatura
+      if nCntType == 10 then
+         return MakeByMark( Proc, nRawId, b3Raw, nPartId)
+      -- se fresatura
+      else
+         return MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
+      end
    end
 end
 

LuaLibs/ProcessHeadCut.lua

@@ -1,7 +1,11 @@
--- ProcessSplit.lua by Egaltech s.r.l. 2022/06/07
+-- ProcessSplit.lua by Egaltech s.r.l. 2022/09/26
 -- 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.
+-- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata.
+-- 2022/09/08 Migliorato verso di lavorazione in caso di DoubleCut
+-- 2022/11/02 Corretti accorciamenti per DoubleCut
+-- 2022/11/10 Corrette finiture lama per BigSection con trave alta
 
 -- Tabella per definizione modulo
 local ProcessHeadCut = {}
@@ -165,20 +169,37 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
    -- recupero i dati dell'utensile
    local dSawDiam = 400
    local dMaxDepth = 50
+   local dSawThick = 2
    if EgtMdbSetCurrMachining( sCutting) then
       local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
       if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
          dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
          dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
+         dSawThick = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick
       end
    end
    local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
+   -- recupero la eventuale lavorazione con lama da sotto
+   local sCutting2 = ML.FindCutting( 'HeadSide_H2', false, true)
+   -- recupero i dati della eventuale seconda lama
+   local dSawDiam2 = 0
+   local dMaxDepth2 = 0
+   local dSawThick2 = 0
+   if sCutting2 and EgtMdbSetCurrMachining( sCutting2) then
+      local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then
+         dSawDiam2 = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam2
+         dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2
+         dSawThick2 = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick2
+      end
+   end
    -- 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 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)
+   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.TURN, 2 * dMaxVertDepth, dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bHorizCut = ( ( 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 bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL)
    -- dati geometrici del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- se non obbligatorio e coincide con inizio grezzo, non va fatto
@@ -191,12 +212,26 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
    -- se taglio per sezioni alte e larghe
    if bBigSectionCut then
       if dOvmHead > 0 then
+         local nQ05 = EgtGetInfo( nOriId or GDB_ID.NULL, 'Q05', 'i') or 0
          -- se finitura con lama
-         if not nOriId or EgtGetInfo( nOriId, 'Q05', 'i') == 1 or EgtGetInfo( nOriId, 'Q05', 'i') == 0 then
-            local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT)
-            if not bOk then return bOk, sErr end
+         if nQ05 == 1 or nQ05 == 0 then
+            local dSawThickCheck = dSawThick
+            if dSawThick2 > 0 and bDoubleHorizCut then
+               dSawThickCheck = min( dSawThick, dSawThick2)
+            end
+            local dMaxElev = 0
+            if vtN:getX() > 0 then
+               dMaxElev = b3Raw:getMax():getX() - Proc.Box:getMin():getX()
+            else
+               dMaxElev = Proc.Box:getMax():getX() - b3Raw:getMin():getX()
+            end
+            -- controllo se è necessario un taglio con dicing o si deve proseguire ai casi standard
+            if dMaxElev > dSawThickCheck then
+               local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT)
+               return bOk, sErr
+            end
          -- se finitura con truciolatore
-         elseif EgtGetInfo( nOriId, 'Q05', 'i') == 2 then
+         elseif nQ05 == 2 then
             local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
             if not b3Solid then
                local sErr = 'Error : part box not found'
@@ -210,11 +245,12 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
                return false, sErr
             end
             local bOk, sErr = Pocket.Make( Proc, Proc.Id, 0, sPocketing, nPartId, b3Solid)
-            if not bOk then return bOk, sErr end
+            return bOk, sErr
          end
       end
+   end
    -- se tagli standard
-   elseif not bDoubleHorizCut then
+   if not bDoubleHorizCut then
       -- flag di lavorazione faccia
       local nOrthoOpposite = EgtIf( bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_FRONT)
       -- calcolo extra taglio ed accorciamento
@@ -235,9 +271,11 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
       end
       -- se necessari tagli in doppio, eseguo gli opposti
       if bDoubleCut then
+         -- gli accorciamenti vanno invertiti per il taglio opposto
+         local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
          for i = nCuts, 1, -1 do
             local dCutOffset = ( i - 1) * dOffsL
-            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_BACK, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, '', b3Raw)
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_BACK, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStartDoubleCut, dAccEndDoubleCut, '', b3Raw, true)
             if not bOk then return false, sErr end
          end
       end
@@ -249,27 +287,16 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
       end
    -- altrimenti necessari tagli da sopra e sotto con testa opportuna
    else
-      -- recupero la lavorazione con lama da sotto
-      local sCutting2 = ML.FindCutting( 'HeadSide_H2', false, true)
+      -- verifico esistenza della lavorazione con lama da sotto
       if not sCutting2 then
          local sErr = 'Error : cutting H2 not found in library'
          EgtOutLog( sErr)
          return false, sErr
       end
-      -- recupero i dati della seconda lama
-      local dSawDiam2 = 400
-      local dMaxDepth2 = 50
-      if EgtMdbSetCurrMachining( sCutting2) then
-         local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then
-            dSawDiam2 = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam2
-            dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2
-         end
-      end
       -- verifico che le due lame riescano a lavorare la sezione
       local dDimZ = b3Raw:getDimZ()
       local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ
-      if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then
+      if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not bBigSectionCut then
          local sErr = 'Error : section too big for head cut'
          EgtOutLog( sErr)
          return false, sErr
@@ -278,16 +305,18 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
       local dCutExtra = -dMaxDepth2 + dExtra / 2 + BD.CUT_EXTRA_MIN
       local dCutExtra2 = -dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
       local dAccStart = 0
+      local dVzLimDwnUp
+      if BD.TURN then dVzLimDwnUp = -2 end
       -- eseguo i tagli da sotto necessari
       for i = nCuts, 1, -1 do
          local dCutOffset = ( i - 1) * dOffsL
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, nil, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
          if not bOk then return false, sErr end
       end
       -- eseguo i tagli da sopra necessari
       for i = nCuts, 1, -1 do
          local dCutOffset = ( i - 1) * dOffsL
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
          if not bOk then return false, sErr end
       end
    end

LuaLibs/ProcessLongCut.lua

@@ -1,4 +1,4 @@
--- ProcessLongCut.lua by Egaltech s.r.l. 2022/03/07
+-- ProcessLongCut.lua by Egaltech s.r.l. 2022/11/04
 -- Gestione calcolo taglio longitudinale per Travi
 -- 2021/02/03 Corretto FaceUse con fresa orizzontale su taglio orizzontale.
 -- 2021/05/18 Possibile taglio con lama anche di fianco su macchina con testa da sotto.
@@ -10,6 +10,9 @@
 -- 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).
+-- 2022/09/23 Modificato l'angolo per l'abilitazione della lama da sotto: ora interviene anche per facce verticali.
+-- 2022/11/04 Aggiunto passaggio parametro bDownHead (Testa da Sotto) nelle chiamate a MakeSideFace.
 
 -- Tabella per definizione modulo
 local ProcessLongCut = {}
@@ -435,8 +438,8 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
       if ( nSide == -1 or abs(nSide) == 2) and vtN:getZ() <= -0.5 then
          bCanUseUnderBlade = true
       end
-      -- se faccia da sotto o di lato ma con versore Z negativo abilito la lavorazione con lame mixate 
-      if ( nSide == -1 or abs(nSide) == 2) and vtN:getZ() <= -0.0175 then
+      -- se faccia da sotto o di lato ma con versore Z sotto l'orizzontale abilito la lavorazione con lame mixate 
+      if ( nSide == -1 or abs(nSide) == 2) and vtN:getZ() <= 0.0175 then
          bCanUseUnderBlade = true
       end
       -- se faccia da sopra o di lato ma con versore Z negativo verifico che abbia un angolo compatibile (28deg) per non avere extracorsa
@@ -507,8 +510,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
@@ -1022,12 +1026,12 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
             for j = 1, Proc.Fct - 1 do
                local _, vtN = EgtSurfTmFacetCenter( Proc.Id, j, GDB_ID.ROOT)
                if vtIni * vtN > 0 and nCountMilHead < 2 then
-                  MakeSideFace( Proc.Id, j, nSide, sMilling, dToolDiam)
+                  MakeSideFace( Proc.Id, j, nSide, sMilling, dToolDiam, nil, nil, bDownHead)
                   nCountMilHead = nCountMilHead + 1
                end
             end
             if bForcedLim and nCountMilHead < 1 then
-               MakeSideFace( Proc.Id, 0, nSide, sMilling, dToolDiam, bForcedLim)
+               MakeSideFace( Proc.Id, 0, nSide, sMilling, dToolDiam, bForcedLim, nil, bDownHead)
                nCountMilHead = nCountMilHead + 1
             end
          end
@@ -1039,12 +1043,12 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
          for j = 1, Proc.Fct - 1 do
             local _, vtN = EgtSurfTmFacetCenter( Proc.Id, j, GDB_ID.ROOT)
             if vtFin * vtN > 0  and nCountMilHead < 2 then
-               MakeSideFace( Proc.Id, j, nSide, sMilling, dToolDiam)
+               MakeSideFace( Proc.Id, j, nSide, sMilling, dToolDiam, nil, nil, bDownHead)
                nCountMilHead = nCountMilHead + 1
             end
          end
          if bForcedLim  and nCountMilHead < 2 then
-            MakeSideFace( Proc.Id, 0, nSide, sMilling, dToolDiam, bForcedLim)
+            MakeSideFace( Proc.Id, 0, nSide, sMilling, dToolDiam, bForcedLim, nil, bDownHead)
             nCountMilHead = nCountMilHead + 1
          end
       end

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,10 @@
 -- 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.
+-- 2022/09/27 Migliorata la scelta utensile. Se c'è almeno una lavorazione 'mortise' si cerca di usare quelle, riducendo l'elevazione se necessario.
+--            Se non c'è nemmeno una lavorazione 'mortise' si passa alle pocket.
 
 -- Tabella per definizione modulo
 local ProcessMortise = {}
@@ -79,6 +83,184 @@ 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
+
+---------------------------------------------------------------------
+local function VerifyMortiseOrPocket( Proc, dDiam, dDepth, dMaxTotLen, sType, bPocketDown)
+   -- ricerca della svuotatura
+   local sPocketing
+   if dDepth then
+      sPocketing = ML.FindPocketing( sType, dDiam, dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sType, dDiam, 0.8 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sType, dDiam, 0.6 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sType, dDiam, 0.4 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sType, dDiam, 0, dMaxTotLen)
+   else
+      sPocketing = ML.FindPocketing( sType, dDiam, 0, dMaxTotLen)
+   end
+   if not sPocketing then
+      return false
+   end
+   -- recupero i dati dell'utensile
+   local dMaxDepth = 0
+   local dToolDiam = 0
+   if EgtMdbSetCurrMachining( sPocketing) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
+         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
+      end
+   end
+   return sPocketing, dMaxDepth, dToolDiam
+end
+
+   ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    -- ingombro del pezzo
@@ -157,9 +339,11 @@ 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))
-            EgtMove( AuxId, Vector3d(0,0,-dMove))
-            EgtMove( nFlat, Vector3d(0,0,-dMove))
+            AuxId = EgtCopyGlob( AuxId, BL.GetAddGroup( nPartId))
+            local vtMove = Vector3d(0,0,dMove)
+            vtMove:toGlob(frMor)
+            EgtMove( AuxId, vtMove, GDB_RT.GLOB)
+            EgtMove( nFlat, vtMove, GDB_RT.GLOB)
             frMor, dL, dW = EgtSurfTmFacetMinAreaRectangle( nFlat, 0, GDB_ID.ROOT)
             ptC = frMor:getOrigin()
             vtN = frMor:getVersZ()
@@ -172,8 +356,8 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    EgtOutLog( 'ptC=' .. tostring( ptC) ..' vtN=' .. tostring( vtN), 3)
    -- Se mortasa chiusa
    if not bOpenBtm then
-      -- verifico che la mortasa non sia orientata verso il basso (limite -5 deg) o che ci sia una testa da sotto o un rinvio angolare
-      if vtN:getZ() < -0.1 and not BD.DOWN_HEAD and not BD.ANG_TRASM then
+      -- verifico che la mortasa non sia orientata verso il basso (limite -5 deg) o che ci sia una testa da sotto o un rinvio angolare o macchina Turn
+      if vtN:getZ() < -0.1 and not BD.DOWN_HEAD and not BD.ANG_TRASM and not BD.TURN then
          local sErr = 'Error : Mortise from bottom impossible'
          EgtOutLog( sErr)
          return false, sErr
@@ -236,16 +420,16 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    end
    local sPocketing
    if Proc.Prc ~= 53 then
-      sPocketing = ML.FindPocketing( sPockType..sMchExt, dW, nil, nil, not bPockDown, bPockDown)
+      sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown)
       if not sPocketing and bPockUp then
-         sPocketing = ML.FindPocketing( sPockType, dW)
+         sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt)
       end
    end
    if not sPocketing then
       sPockType = 'Pocket'
-      sPocketing = ML.FindPocketing( sPockType..sMchExt, dW, nil, nil, not bPockDown, bPockDown)
+      sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown)
       if not sPocketing and bPockUp then
-         sPocketing = ML.FindPocketing( sPockType, dW)
+         sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt)
       end
    end
    if not sPocketing then
@@ -286,8 +470,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 +534,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 +564,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/ProcessProfCamb.lua

@@ -1,4 +1,4 @@
--- ProcessProfCamb.lua by Egaltech s.r.l. 2022/05/28
+-- ProcessProfCamb.lua by Egaltech s.r.l. 2022/11/03
 -- Gestione calcolo profilo caudato per Travi
 -- 2021/05/03 Aggiunta gestione smusso da sopra e sotto per macchina con testa da sotto.
 -- 2021/06/28 Per macchine con testa sotto, smussi di lato con questa testa se non c'è lav.ne da sopra.
@@ -8,6 +8,7 @@
 -- 2022/02/02 Aggiunta funzione OnlyChamfer.
 -- 2022/05/24 Aggiunta fresatura da sotto su macchine con testa da sotto.
 -- 2022/05/28 Aggiunto calcolo svuotatura da modulo di libreria.
+-- 2022/11/03 Correzione per riconoscimento testa da sotto su fresatura.
 
 -- Tabella per definizione modulo
 local ProcessProfCamb = {}
@@ -315,12 +316,14 @@ function ProcessProfCamb.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       -- leggo anticipatamente i parametri utensile fresa per dare un valore opportuno all'elevazione della lama
       -- recupero la lavorazione di fresatura
       local sMillType = 'Prof'
-      sMilling, _, _, bMillDown = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bMillDown)
+      local bH2
+      sMilling, _, _, bH2 = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bMillDown)
       if not sMilling then
          local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library'
          EgtOutLog( sErr)
          return false, sErr
       end
+      bMillDown = ( bMillDown and bH2)
       -- Recupero i dati dell'utensile
       if EgtMdbSetCurrMachining( sMilling) then
          local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)

LuaLibs/ProcessProfConcave.lua

@@ -440,7 +440,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       local sMillingDown
       if bDouble then
          if nSide == 0  then
-            if BD.DOWN_HEAD then               
+            if BD.DOWN_HEAD then
                -- recupero la lavorazione
                sMillingDown = ML.FindMilling( 'Prof_H2', nil, nil, nil, nil, false, true)
                if not sMillingDown then
@@ -448,7 +448,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
                   EgtOutLog( sWarn)
                   bDouble = false
                end
-            else
+            elseif not BD.TURN then
                sWarn = 'Warning in profiling : depth (' .. EgtNumToString( dProfDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dToolMaxDepth, 1) .. ')'
                EgtOutLog( sWarn)
                bDouble = false
@@ -489,7 +489,9 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          -- imposto l'affondamento
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
          -- posizione braccio porta testa
-         EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
+         local nSCC = EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
+         if BD.TURN then nSCC = MCH_SCC.ADIR_ZP end
+         EgtSetMachiningParam( MCH_MP.SCC, nSCC)
          -- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
          local bFinish
          local dOriOffset = 0
@@ -588,7 +590,9 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
       end
       -- posizione braccio porta testa
-      EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
+      local nSCC = EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
+      if BD.TURN then nSCC = MCH_SCC.ADIR_ZP end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
       -- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
       local bFinish
       local dOriOffset = 0
@@ -633,7 +637,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       -- se parametro Q disabilitato, e consentito anche in alcuni casi lavorarlo con la feature da sotto 
       -- inserisco eventuale finitura faccia finale (ortogonale alla trave o, se da sotto, parallela)
       if EgtGetInfo( Proc.Id, sEnableExtraMillUpperFace, 'i') ~= 1 and bLastTrim and
-         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD))) then
+         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD or BD.TURN))) then
          sName = 'ProfV_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
          local nMchVId = EgtAddMachining( sName, sMilling)
          if not nMchVId then
@@ -659,6 +663,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH')
          EgtSetMachiningParam( MCH_MP.STEP, 0)
          EgtSetMachiningParam( MCH_MP.OFFSR, 0)
+         if BD.TURN then EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_ZP) end
          -- eseguo
          if not ML.ApplyMachining( true, false) then
             local _, sErr = EgtGetLastMachMgrError()
@@ -669,7 +674,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       -- se parametro Q disabilitato, e consentito anche in alcuni casi lavorarlo con la feature da sotto 
       -- inserisco eventuale finitura faccia finale (ortogonale alla trave o, se da sotto, parallela)
       if EgtGetInfo( Proc.Id, sEnableExtraMillUpperFace, 'i') ~= 1 and bFirstTrim and
-         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD))) then
+         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD or BD.TURN))) then
          sName = 'ProfV2_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
          local nMchV2Id = EgtAddMachining( sName, sMilling)
          if not nMchV2Id then
@@ -692,6 +697,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          EgtSetMachiningParam( MCH_MP.STEP, 0)
          EgtSetMachiningParam( MCH_MP.OFFSR, 0)
          EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dWidth, 1))
+         if BD.TURN then EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_ZP) end
          -- eseguo
          if not ML.ApplyMachining( true, false) then
             local _, sErr = EgtGetLastMachMgrError()

LuaLibs/ProcessProfConvex.lua

@@ -440,7 +440,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       local sMillingDown
       if bDouble then
          if nSide == 0  then
-            if BD.DOWN_HEAD then               
+            if BD.DOWN_HEAD then
                -- recupero la lavorazione
                sMillingDown = ML.FindMilling( 'Prof_H2', nil, nil, nil, nil, false, true)
                if not sMillingDown then
@@ -448,7 +448,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
                   EgtOutLog( sWarn)
                   bDouble = false
                end
-            else
+            elseif not BD.TURN then
                sWarn = 'Warning in profiling : depth (' .. EgtNumToString( dProfDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dToolMaxDepth, 1) .. ')'
                EgtOutLog( sWarn)
                bDouble = false
@@ -489,7 +489,9 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          -- imposto l'affondamento
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
          -- posizione braccio porta testa
-         EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
+         local nSCC = EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
+         if BD.TURN then nSCC = MCH_SCC.ADIR_ZP end
+         EgtSetMachiningParam( MCH_MP.SCC, nSCC)
          -- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
          local bFinish
          local dOriOffset = 0
@@ -588,7 +590,9 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
       end
       -- posizione braccio porta testa
-      EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
+      local nSCC = EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
+      if BD.TURN then nSCC = MCH_SCC.ADIR_ZP end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
       -- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
       local bFinish
       local dOriOffset = 0
@@ -633,7 +637,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       -- se parametro Q disabilitato, e consentito anche in alcuni casi lavorarlo con la feature da sotto 
       -- inserisco eventuale finitura faccia finale (ortogonale alla trave o, se da sotto, parallela)
       if EgtGetInfo( Proc.Id, sEnableExtraMillUpperFace, 'i') ~= 1 and bLastTrim and
-         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD))) then
+         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD or BD.TURN))) then
          sName = 'ProfV_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
          local nMchVId = EgtAddMachining( sName, sMilling)
          if not nMchVId then
@@ -659,6 +663,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH')
          EgtSetMachiningParam( MCH_MP.STEP, 0)
          EgtSetMachiningParam( MCH_MP.OFFSR, 0)
+         if BD.TURN then EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_ZP) end
          -- eseguo
          if not ML.ApplyMachining( true, false) then
             local _, sErr = EgtGetLastMachMgrError()
@@ -669,7 +674,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       -- se parametro Q disabilitato, e consentito anche in alcuni casi lavorarlo con la feature da sotto 
       -- inserisco eventuale finitura faccia finale (ortogonale alla trave o, se da sotto, parallela)
       if EgtGetInfo( Proc.Id, sEnableExtraMillUpperFace, 'i') ~= 1 and bFirstTrim and
-         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD))) then
+         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD or BD.TURN))) then
          sName = 'ProfV2_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
          local nMchV2Id = EgtAddMachining( sName, sMilling)
          if not nMchV2Id then
@@ -692,6 +697,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          EgtSetMachiningParam( MCH_MP.STEP, 0)
          EgtSetMachiningParam( MCH_MP.OFFSR, 0)
          EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dWidth, 1))
+         if BD.TURN then EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_ZP) end
          -- eseguo
          if not ML.ApplyMachining( true, false) then
             local _, sErr = EgtGetLastMachMgrError()
@@ -701,12 +707,13 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       end
    end
    -- aggiorno ingombro testa o coda per presa
-   if nSide ~= 1 then
+   if nSide ~= 1 then -- se feature di fianco o da sotto
       if bHead then
          BL.UpdateHCING( nRawId, b3Raw:getMax():getX() - dCurrOvmH - Proc.Box:getMin():getX())
       else
          BL.UpdateTCING( nRawId, Proc.Box:getMax():getX() - b3Solid:getMin():getX())
       end
+   -- altrimenti feature da sopra
    else
       if bHead then
          BL.UpdateHCING( nRawId, b3Raw:getMax():getX() - dCurrOvmH - Proc.Box:getMax():getX())

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/09/30
 -- 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
@@ -166,7 +173,11 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
                if vtO then
                   vtOrthoO = Vector3d( vtO)
                else
-                  vtOrthoO = Y_AX()
+                  if vtN[vFaceOrd[4]]:getZ() < 0.1 then
+                     vtOrthoO = Z_AX()
+                  else
+                     vtOrthoO = Y_AX()
+                  end
                end
             end
          end
@@ -174,7 +185,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 +193,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 +301,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)
@@ -299,10 +314,12 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
    end
    -- recupero i dati dell'utensile
    local dSawDiam = 400
+   local dMaxDepth = 0
    if EgtMdbSetCurrMachining( sCutting) then
       local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
       if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
          dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
+         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
       end
    end
 
@@ -335,7 +352,6 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
          EgtOutLog( sErr)
          return false, sErr
       end
-
       -- se esistono faccia interna ed intermedia, verifico se richiedono taglio a cubetti
       nGoodFace1 = EgtSurfTmFacetCount( nFace1)
       nGoodFace4 = EgtSurfTmFacetCount( nFace4)
@@ -345,21 +361,27 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
       nGoodFace1 = EgtSurfTmFacetCount( nFace1)
    end
 
-   local bOkd, sErrD, vCuts = ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Solid, ptC, vtN, Proc, vtRef, bHead, sCutting, dSawDiam, b3Raw) 
+   -- per macchina TURN aggiusto massima dimensione cubetto
+   local dNewDiceDim
+   if BD.TURN and nGoodFace4 and nGoodFace4 > 0 then
+      local dDimRef = EgtIf( abs( vtN[vFaceOrd[4]]:getZ()) < 0.1, b3Raw:getDimZ(), b3Raw:getDimY())
+      if dDimRef + BD.CUT_EXTRA < dMaxDepth then
+         dNewDiceDim = - ( dMaxDepth - BD.CUT_EXTRA)
+      end
+   end
+
+   local bOkd, sErrD, vCuts = ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Solid, ptC, vtN, Proc, vtRef, bHead, sCutting, dSawDiam, b3Raw, dNewDiceDim) 
    if not bOkd then return bOkd, sErrD end
 
    if #vCuts == 0 then
       -- se ho la faccia intermedia, per prima cosa verifico se ho intersezione con la faccia tappo
       if nGoodFace4 ~= 0 then
-         -- taglio sulla faccia interna
-         if vFaceOrd[1] ~= 0 then
-            -- inserisco la lavorazione
-            local vtOrthoO = Vector3d( vtRef)
-            bOkd, sErrD = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
-            if not bOkd then return bOkd, sErrD end
-         end
          -- se non ho intersezione con la faccia tappo posso fare il taglio sul fianco
          if not nGoodFace1 or nGoodFace1 == 0 then
+            -- inserisco la lavorazione
+            local vtRef2 = EgtIf( abs(vtRef:getZ()) < GEO.EPS_SMALL, Z_AX(), EgtIf( bHead, Y_AX(), -Y_AX()))
+            bOkd, sErrD = Fbs.MakeOne( nFace4, nGoodFace4 - 1, sCutting, dSawDiam, vtRef2, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+            if not bOkd then return bOkd, sErrD end
             -- lavoro la faccia opposta (definita dal parametro P11)
             if vFaceOrd[3] ~= 0 then
                -- inserisco la lavorazione
@@ -367,16 +389,20 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
                bOkd, sErrD = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
                if not bOkd then return bOkd, sErrD end
             end
-            -- inserisco la lavorazione
-            local vtRef2 = EgtIf( abs(vtRef:getZ()) < GEO.EPS_SMALL, Z_AX(), EgtIf( bHead, Y_AX(), -Y_AX()))
-            bOkd, sErrD = Fbs.MakeOne( nFace4, nGoodFace4 - 1, sCutting, dSawDiam, vtRef2, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
-            if not bOkd then return bOkd, sErrD end
-         else -- altrimenti se ho intersezione forzo il DiceCut ad essere eseguito con distanze più piccole
+         -- altrimenti se ho intersezione forzo il DiceCut ad essere eseguito con distanze più piccole
+         else
             -- definisco la nuova dimensione massima del dice cut
             local dNewDiceDim = EgtIf( abs(vtRef:getZ()) < GEO.EPS_SMALL, b3Raw:getDimZ(), b3Raw:getDimY())
             bOkd, sErrD = ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Solid, ptC, vtN, Proc, vtRef, bHead, sCutting, dSawDiam, b3Raw, dNewDiceDim)
             if not bOkd then return bOkd, sErrD end
          end
+         -- taglio sulla faccia interna
+         if vFaceOrd[1] ~= 0 then
+            -- inserisco la lavorazione
+            local vtOrthoO = Vector3d( vtRef)
+            bOkd, sErrD = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+            if not bOkd then return bOkd, sErrD end
+         end
       else
          -- taglio sulla faccia interna
          if vFaceOrd[1] ~= 0 then
@@ -441,9 +467,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
@@ -489,20 +515,20 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
       if abs( vtRef:getZ()) > 0.1 then
          local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
          if b3Fac1 then dHCI = b3Raw:getMax():getX() - dOvmHead - b3Fac1:getMin():getX() end
+         dHCI = 0.75 * dHCI
       else
          dHCI = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX()
       end
-      dHCI = 0.75 * dHCI
       BL.UpdateHCING( nRawId, dHCI)
    elseif Proc.Tail then
       local dTCI = 0
       if abs( vtRef:getZ()) > 0.1 then
          local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
          if b3Fac1 then dTCI = b3Fac1:getMax():getX() - b3Solid:getMin():getX() end
+         dTCI = 0.75 * dTCI
       else
          dTCI = Proc.Box:getMax():getX() - b3Solid:getMin():getX()
       end
-      dTCI = 0.75 * dTCI
       BL.UpdateTCING( nRawId, dTCI)
    end
 

LuaLibs/ProcessSimpleScarf.lua

@@ -1,6 +1,8 @@
 -- 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.
+-- 2022/11/09 Aggiunta gestione parametro Q04 per forzare utilizzo fresa di lato e lavorare come FreeContour.
 
 -- Tabella per definizione modulo
 local ProcessSimpleScarf = {}
@@ -10,6 +12,8 @@ require( 'EgtBase')
 local BL = require( 'BeamLib')
 local Fbs = require( 'FacesBySaw')
 local DC = require( 'DiceCut')
+local Cut = require( 'ProcessCut')
+local FreeContour = require( 'ProcessFreeContour')
 
 EgtOutLog( ' ProcessSimpleScarf started', 1)
 
@@ -26,11 +30,13 @@ end
 ---------------------------------------------------------------------
 -- Classificazione della feature
 function ProcessSimpleScarf.Classify( Proc)
+   -- se forzato utilizzo fresa non ruoto la trave
+   local bForceSideMill = ( EgtGetInfo( Proc.Id, 'Q04', 'd') or 0) > 0
    -- verifico le normali delle facce
    local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
    for i = 1, nFacetCnt do
       local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i-1, GDB_ID.ROOT)
-      if vtN:getZ() < - 0.5 and Proc.Box:getDimX() / abs( vtN:getZ()) > BD.MAX_DIM_DICE then
+      if vtN:getZ() < - 0.5 and Proc.Box:getDimX() / abs( vtN:getZ()) > BD.MAX_DIM_DICE and not bForceSideMill then
          return true, true
       end
    end
@@ -138,12 +144,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 = {}
@@ -187,117 +192,126 @@ function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmT
    -- inserimento smussi
    local bOkc, sErrC = MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
    if not bOkc then return bOkc, sErrC end
-   -- recupero la lavorazione
-   local sCutting = ML.FindCutting( 'HeadSide')
-   if not sCutting then
-      local sErr = 'Error : cutting not found in library'
-      EgtOutLog( sErr)
-      return false, sErr
-   end
-   -- recupero i dati dell'utensile
-   local dSawDiam = 400
-   if EgtMdbSetCurrMachining( sCutting) then
-      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-         dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
-      end
-   end
-   -- taglio sulla faccia esterna
-   if vFaceOrd[1] ~= 0 then
-      -- in generale va fatto
-      local bCut = true
-      -- se di testa e coincide con inizio grezzo, non va fatto
-      if bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], X_AX()) and abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMax():getX() + dOvmHead) < 10 * GEO.EPS_SMALL then
-         bCut = false
-      end
-      -- se di coda e coincide con taglio di separazione, non va fatto
-      if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX())  and  abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
-         bCut = false
-      end
-      -- se va fatto, inserisco la lavorazione
-      if bCut then
-         local vtOrthoO = Vector3d( vtRef)
-         local bOk, sNameOrErr = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
-         if not bOk then return bOk, sNameOrErr end
-      end
-   end
-   -- recupero gruppo per geometria addizionale
-   local nAddGrpId = BL.GetAddGroup( nPartId)
-   if not nAddGrpId then
-      local sErr = 'Error : missing AddGroup'
-      EgtOutLog( sErr)
-      return false, sErr
-   end
-   -- se esistono faccia interna ed intermedia, verifico se richiedono taglio a cubetti
-   local vCuts = {}
-   if vFaceOrd[2] ~= 0 and vFaceOrd[3] ~= 0 then
-      vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], false, ptC[vFaceOrd[2]], vtN[vFaceOrd[2]])
-   elseif vFaceOrd[3] ~= 0 then
-      vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], true)
-   end
-   if #vCuts > 0 then
-      -- sistemo posizione nel DB e nome
-      for i = 1, #vCuts do
-         for j = 1, #vCuts[i] do
-            EgtSetName( vCuts[i][j], 'AddCut_' .. tostring( Proc.Id))
-            EgtSetInfo( vCuts[i][j], 'TASKID', Proc.TaskId)
-         end
-      end
-      -- calcolo secondo riferimento per testa o coda
-      local vtRef2 = EgtIf( bHead, X_AX(), -X_AX())
-      -- eseguo
-      for i = 1, #vCuts do
-         local vtOrthoO
-         if i % 2 == 1 then
-            vtOrthoO = Vector3d( vtRef)
-         else
-            if #vCuts[i-1] > 0 then
-               vtOrthoO = Vector3d( EgtIf( vtRef2, vtRef2, vtRef))
-            else
-               local vtO
-               for j = 1, #vCuts[i-1] do
-                  _, vtO = EgtSurfTmFacetCenter( vCuts[i-1][j], 0, GDB_ID.ROOT)
-                  break
-               end
-               if vtO then
-                  vtOrthoO = Vector3d( vtO)
-               else
-                  vtOrthoO = Y_AX()
-               end
-            end
-         end
-         -- lavoro la faccia
-         for j = 1, #vCuts[i] do
-            local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
-            if not bOk then
-               return bOk, sErr
-            end
-         end
-      end
+   -- se forzato utilizzo fresa richiamo la freecontour
+   local bForceSideMill = EgtGetInfo( Proc.Id, 'Q04', 'd') == 1 or
+                        ( EgtGetInfo( Proc.Id, 'Q04', 'd') == 2 and abs( vtN[vFaceOrd[3]]:getY()) < 0.1) or
+                        ( EgtGetInfo( Proc.Id, 'Q04', 'd') == 3 and abs( vtN[vFaceOrd[3]]:getY()) < 0.1 and vtN[vFaceOrd[3]]:getZ() < 0.1)
+   if bForceSideMill then
+      bOk, sErr = FreeContour.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+      if not bOk then return bOk, sErr end
    else
-      -- taglio sulla faccia interna
-      local bIntCut = false
-      if vFaceOrd[2] ~= 0 then
-         -- inserisco la lavorazione
-         local nOrthoOpposite = BL.GetNearestOrthoOpposite( vtRef)
-         local bOk, sNameOrErr = Fbs.MakeOne( Proc.Id, vFaceOrd[2] - 1, sCutting, dSawDiam, nOrthoOpposite, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
-         if not bOk then return bOk, sNameOrErr end
-         if #sNameOrErr > 0 then bIntCut = true end
+      -- recupero la lavorazione
+      local sCutting = ML.FindCutting( 'HeadSide')
+      if not sCutting then
+         local sErr = 'Error : cutting not found in library'
+         EgtOutLog( sErr)
+         return false, sErr
       end
-      -- taglio sulla faccia intermedia
-      if vFaceOrd[3] ~= 0 then
-         -- calcolo secondo testa o coda
-         local vtRef2 = EgtIf( bHead, X_AX(), -X_AX())
-         -- se non ho il taglio sulla faccia interna
-         if not bIntCut then
-            local frHV, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, vFaceOrd[3] - 1)
-            if DimV > DimH then
-               vtRef2 = Vector3d( frHV:getVersX())
+      -- recupero i dati dell'utensile
+      local dSawDiam = 400
+      if EgtMdbSetCurrMachining( sCutting) then
+         local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+            dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
+         end
+      end
+      -- taglio sulla faccia esterna
+      if vFaceOrd[1] ~= 0 then
+         -- in generale va fatto
+         local bCut = true
+         -- se di testa e coincide con inizio grezzo, non va fatto
+         if bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], X_AX()) and abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMax():getX() + dOvmHead) < 10 * GEO.EPS_SMALL then
+            bCut = false
+         end
+         -- se di coda e coincide con taglio di separazione, non va fatto
+         if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX())  and  abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
+            bCut = false
+         end
+         -- se va fatto, inserisco la lavorazione
+         if bCut then
+            local vtOrthoO = Vector3d( vtRef)
+            local bOk, sNameOrErr = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+            if not bOk then return bOk, sNameOrErr end
+         end
+      end
+      -- recupero gruppo per geometria addizionale
+      local nAddGrpId = BL.GetAddGroup( nPartId)
+      if not nAddGrpId then
+         local sErr = 'Error : missing AddGroup'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- se esistono faccia interna ed intermedia, verifico se richiedono taglio a cubetti
+      local vCuts = {}
+      if vFaceOrd[2] ~= 0 and vFaceOrd[3] ~= 0 then
+         vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], false, ptC[vFaceOrd[2]], vtN[vFaceOrd[2]])
+      elseif vFaceOrd[3] ~= 0 then
+         vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], true)
+      end
+      if #vCuts > 0 then
+         -- sistemo posizione nel DB e nome
+         for i = 1, #vCuts do
+            for j = 1, #vCuts[i] do
+               EgtSetName( vCuts[i][j], 'AddCut_' .. tostring( Proc.Id))
+               EgtSetInfo( vCuts[i][j], 'TASKID', Proc.TaskId)
             end
          end
-         -- inserisco la lavorazione
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtRef2, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
-         if not bOk then return bOk, sErr end
+         -- calcolo secondo riferimento per testa o coda
+         local vtRef2 = EgtIf( bHead, X_AX(), -X_AX())
+         -- eseguo
+         for i = 1, #vCuts do
+            local vtOrthoO
+            if i % 2 == 1 then
+               vtOrthoO = Vector3d( vtRef)
+            else
+               if #vCuts[i-1] > 0 then
+                  vtOrthoO = Vector3d( EgtIf( vtRef2, vtRef2, vtRef))
+               else
+                  local vtO
+                  for j = 1, #vCuts[i-1] do
+                     _, vtO = EgtSurfTmFacetCenter( vCuts[i-1][j], 0, GDB_ID.ROOT)
+                     break
+                  end
+                  if vtO then
+                     vtOrthoO = Vector3d( vtO)
+                  else
+                     vtOrthoO = Y_AX()
+                  end
+               end
+            end
+            -- lavoro la faccia
+            for j = 1, #vCuts[i] do
+               local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+               if not bOk then
+                  return bOk, sErr
+               end
+            end
+         end
+      else
+         -- taglio sulla faccia interna
+         local bIntCut = false
+         if vFaceOrd[2] ~= 0 then
+            -- inserisco la lavorazione
+            local nOrthoOpposite = BL.GetNearestOrthoOpposite( vtRef)
+            local bOk, sNameOrErr = Fbs.MakeOne( Proc.Id, vFaceOrd[2] - 1, sCutting, dSawDiam, nOrthoOpposite, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+            if not bOk then return bOk, sNameOrErr end
+            if #sNameOrErr > 0 then bIntCut = true end
+         end
+         -- taglio sulla faccia intermedia
+         if vFaceOrd[3] ~= 0 then
+            -- calcolo secondo testa o coda
+            local vtRef2 = EgtIf( bHead, X_AX(), -X_AX())
+            -- se non ho il taglio sulla faccia interna
+            if not bIntCut then
+               local frHV, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, vFaceOrd[3] - 1)
+               if DimV > DimH then
+                  vtRef2 = Vector3d( frHV:getVersX())
+               end
+            end
+            -- inserisco la lavorazione
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtRef2, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+            if not bOk then return bOk, sErr end
+         end
       end
    end
    -- aggiornamento ingombro di testa o coda

LuaLibs/ProcessSplit.lua

@@ -1,7 +1,12 @@
--- ProcessSplit.lua by Egaltech s.r.l. 2022/06/07
+-- ProcessSplit.lua by Egaltech s.r.l. 2022/08/18
 -- 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.
+-- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata.
+-- 2022/09/08 Migliorato verso di lavorazione in caso di DoubleCut
+-- 2022/11/02 Corretti accorciamenti per DoubleCut
+-- 2022/11/10 Corrette finiture lama per BigSection con trave alta
+-- 2022/11/16 Correzioni per travi larghe
 
 -- Tabella per definizione modulo
 local ProcessSplit = {}
@@ -148,7 +153,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 +187,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 +217,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 +237,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
@@ -253,20 +258,37 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
    -- recupero i dati dell'utensile
    local dSawDiam = 400
    local dMaxDepth = 50
+   local dSawThick = 2
    if EgtMdbSetCurrMachining( sCutting) then
       local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
       if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
          dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
          dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
+         dSawThick = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick
       end
    end
    local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
+   -- recupero la eventuale lavorazione con lama da sotto
+   local sCutting2 = ML.FindCutting( 'TailSide_H2', false, true)
+   -- recupero i dati della eventuale seconda lama
+   local dSawDiam2 = 0
+   local dMaxDepth2 = 0
+   local dSawThick2 = 0
+   if sCutting2 and EgtMdbSetCurrMachining( sCutting2) then
+      local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then
+         dSawDiam2 = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam2
+         dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2
+         dSawThick2 = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick2
+      end
+   end
    -- 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 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)
+   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.TURN, 2 * dMaxVertDepth,  dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bHorizCut = ( ( 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 bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA  + 10 * GEO.EPS_SMALL)
    -- dati geometrici del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- flag di lavorazione faccia
@@ -293,43 +315,76 @@ 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
+            -- se la sega a catena non può completare lo split esco
+            if cutDepth >= min( dMaxMat, dTLen - BD.C_SIMM_ENC) + 10 * GEO.EPS_SMALL then
+               sErr = 'Error : section too big for splitting'
+               EgtOutLog( sErr)
+               return false, sErr, -1
+            end
+            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
@@ -339,12 +394,29 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
             sNotes = 'Precut;'
             sNotesFinal = 'Cut;'
          end
+         local nQ05 = EgtGetInfo( nOriId or GDB_ID.NULL, 'Q05', 'i') or 0
          -- se finitura con lama
-         if not nOriId or EgtGetInfo( nOriId, 'Q05', 'i') == 1 or EgtGetInfo( nOriId, 'Q05', 'i') == 0 or not bSplit then
-            local bOk, sErr = Cut.Make( Proc, nNewPhase, nRawId, nPartId, dLenEndRaw, nil, false, true, b3Raw, sNotes, dCurrOvmT)
-            if not bOk then return bOk, sErr, nNewPhase end
+         if nQ05 == 1 or nQ05 == 0 or not bSplit then
+            local dSawThickCheck = dSawThick
+            if dSawThick2 > 0 and bDoubleHorizCut then
+               dSawThickCheck = min( dSawThick, dSawThick2)
+            end
+            local dMaxElev = 0
+            if vtN:getX() > 0 then
+               dMaxElev = b3Raw:getMax():getX() - Proc.Box:getMin():getX()
+            else
+               dMaxElev = Proc.Box:getMax():getX() - b3Raw:getMin():getX()
+            end
+            -- controllo se è necessario un taglio con dicing o si deve proseguire ai casi standard
+            if bSplit or dMaxElev > dSawThickCheck then
+               local bOk, sErr = Cut.Make( Proc, nNewPhase, nRawId, nPartId, dLenEndRaw, nil, false, true, b3Raw, sNotes, dCurrOvmT)
+               if sNotesFinal then
+                  EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesFinal)
+               end
+               return bOk, sErr, nNewPhase
+            end
          -- se finitura con truciolatore
-         elseif EgtGetInfo( nOriId, 'Q05', 'i') == 2 then
+         elseif nQ05 == 2 then
             local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
             if not b3Solid then
                local sErr = 'Error : part box not found'
@@ -358,14 +430,15 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
                return false, sErr
             end
             local bOk, sErr = Pocket.Make( Proc, Proc.Id, 0, sPocketing, nPartId, b3Solid)
-            if not bOk then return bOk, sErr, nNewPhase end
-         end
-         if sNotesFinal then
-            EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesFinal)
+            if sNotesFinal then
+               EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesFinal)
+            end
+            return bOk, sErr, nNewPhase
          end
       end
+   end
    -- se tagli standard
-   elseif not bDoubleHorizCut then
+   if not bDoubleHorizCut then
       -- calcolo extra taglio ed accorciamento
       local dCutExtra = 0
       local dAccStart = 0
@@ -384,10 +457,12 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
       end
       -- se necessari tagli in doppio, eseguo gli opposti
       if bDoubleCut then
+         -- gli accorciamenti vanno invertiti per il taglio opposto
+         local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
          for i = nCuts, 1, -1 do
             local dCutOffset = ( i - 1) * dOffsL
             local sNotes = EgtIf( bSplit, 'Presplit;', 'Precut;')
-            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_FRONT, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw)
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_FRONT, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStartDoubleCut, dAccEndDoubleCut, sNotes, b3Raw, true)
             if not bOk then return false, sErr end
          end
       end
@@ -405,27 +480,16 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
       end
    -- altrimenti necessari tagli da sopra e sotto con testa opportuna
    else
-      -- recupero la lavorazione con lama da sotto
-      local sCutting2 = ML.FindCutting( 'TailSide_H2', false, true)
+      -- verifico esistenza della lavorazione con lama da sotto
       if not sCutting2 then
          local sErr = 'Error : cutting H2 not found in library'
          EgtOutLog( sErr)
          return false, sErr
       end
-      -- recupero i dati della seconda lama
-      local dSawDiam2 = 400
-      local dMaxDepth2 = 50
-      if EgtMdbSetCurrMachining( sCutting2) then
-         local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then
-            dSawDiam2 = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam2
-            dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2
-         end
-      end
       -- verifico che le due lame riescano a lavorare la sezione
       local dDimZ = b3Raw:getDimZ()
       local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ
-      if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then
+      if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not bBigSectionCut then
          local sErr = 'Error : section too big for tail cut'
          EgtOutLog( sErr)
          return false, sErr
@@ -434,11 +498,14 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
       local dCutExtra = -dMaxDepth2 + dExtra / 2 + BD.CUT_EXTRA_MIN
       local dCutExtra2 = -dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
       local dAccStart = 0
+      -- limiti da sotto
+      local dVzLimDwnUp
+      if BD.TURN then dVzLimDwnUp = -2 end
       -- eseguo i tagli da sotto necessari
       for i = nCuts, 1, -1 do
          local dCutOffset = ( i - 1) * dOffsL
          local sNotes = EgtIf( bSplit, 'Presplit;', 'Precut;')
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, nil, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
          if not bOk then return false, sErr end
       end
       -- eseguo i tagli da sopra necessari
@@ -450,7 +517,7 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
          else
             sNotes = EgtIf( i == 1, 'Cut;', 'Precut;')
          end
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
          if not bOk then return false, sErr end
       end
    end

LuaLibs/ProcessStepJoint.lua

@@ -1,5 +1,6 @@
--- ProcessStepJoint.lua by Egaltech s.r.l. 2022/01/26
+-- ProcessStepJoint.lua by Egaltech s.r.l. 2022/11/03
 -- Gestione calcolo giunto a gradino per Travi
+-- 2022/11/03 Correzione per riconoscimento testa da sotto su fresatura.
 
 -- Tabella per definizione modulo
 local ProcessStepJoint = {}
@@ -83,13 +84,14 @@ local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
    -- recupero la lavorazione
    local sMillType = 'Mark'
    local bDownHead = ( BD.DOWN_HEAD and abs( vtExtr:getZ()) < 0.1)
-   local sMilling
-   sMilling, _, _, bDownHead = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bDownHead)
+   local sMilling, bH2
+   sMilling, _, _, bH2 = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bDownHead)
    if not sMilling then
       local sErr = 'Error : milling not found in library'
       EgtOutLog( sErr)
       return false, sErr
    end
+   bDownHead = ( bDownHead and bH2)
    -- Inserisco la lavorazione del lato standard
    local sName1 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
    local nMch1Id = EgtAddMachining( sName1, sMilling)

LuaLibs/ProcessStepJointNotch.lua

@@ -1,5 +1,6 @@
--- ProcessStepJointNotch.lua by Egaltech s.r.l. 2022/01/25
+-- ProcessStepJointNotch.lua by Egaltech s.r.l. 2022/11/03
 -- Gestione calcolo tacca a gradino per Travi
+-- 2022/11/03 Correzione per riconoscimento testa da sotto su fresatura.
 
 -- Tabella per definizione modulo
 local ProcessStepJointNotch = {}
@@ -523,13 +524,14 @@ local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
    -- recupero la lavorazione
    local sMillType = 'Mark'
    local bDownHead = ( BD.DOWN_HEAD and abs( vtExtr:getZ()) < 0.1)
-   local sMilling
-   sMilling, _, _, bDownHead = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bDownHead)
+   local sMilling, bH2
+   sMilling, _, _, bH2 = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bDownHead)
    if not sMilling then
       local sErr = 'Error : milling not found in library'
       EgtOutLog( sErr)
       return false, sErr
    end
+   bDownHead = ( bDownHead and bH2)
    if bExeNormal then
       -- Inserisco la lavorazione del lato standard
       local sName1 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))

LuaLibs/ProcessTenon.lua

@@ -1,9 +1,11 @@
--- ProcessTenon.lua by Egaltech s.r.l. 2022/05/28
+-- ProcessTenon.lua by Egaltech s.r.l. 2022/11/03
 -- Gestione calcolo tenone per Travi
 -- 2021/10/04 Corretto calcolo HCING per pezzi piccoli.
 -- 2022/02/15 Aggiornata VerifyOrientation per macchine con testa da sotto.
 -- 2022/05/18 Migliorata gestione attacco.
 -- 2022/05/28 Spostato calcolo svuotatura in modulo di libreria.
+-- 2022/09/20 Migliorato il calcolo delle passate laterali; ora considera la reale distanza tra contorno del tenone e estremi della faccia
+-- 2022/11/03 Corretto uso di bH2 (da sotto solo se anche bMillDown vero).
 
 -- Tabella per definizione modulo
 local ProcessTenon = {}
@@ -120,11 +122,32 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    local vtN = vtExtr
    local ptC = ptBC + vtN * dTenH
    EgtOutLog( 'ptC=' .. tostring( ptC) ..' vtN=' .. tostring( vtN), 3)
-   -- determino larghezza massima di svuotatura
-   local b3Aux = EgtGetBBoxRef( AuxId, GDB_BB.STANDARD, frTen)
-   local dPockX = max( b3Ten:getMax():getX() - b3Aux:getMax():getX(), b3Aux:getMin():getX() - b3Ten:getMin():getX())
-   local dPockY = max( b3Ten:getMax():getY() - b3Aux:getMax():getY(), b3Aux:getMin():getY() - b3Ten:getMin():getY())
-   local dPockL = sqrt( dPockX * dPockX + dPockY * dPockY)
+   -- determino larghezza svuotatura per calcolare il numero di passate laterali
+   -- ricavo i contorni della faccia principale
+   local nLoopId, nLoopCnt = EgtExtractSurfTmFacetLoops( Proc.Id, 0, EgtGetParent( Proc.Id))
+   local dPockL = 0
+   -- ricavo la massima distanza tra gli estremi della faccia e la curva del tenone
+   if nLoopId then
+      local dUmin, dUmax = EgtCurveDomain( nLoopId)
+      for dU = dUmin, dUmax do
+         local ptP = EgtUP( nLoopId, dU, GDB_ID.ROOT)
+         local ptNear = EgtNP( AuxId, ptP, GDB_ID.ROOT)
+         local dDist = dist( ptP, ptNear)
+         if dDist > dPockL then
+            dPockL = dDist
+         end
+      end
+      -- cancello i contorni dopo averli analizzati
+      for i = 1, nLoopCnt do
+         EgtErase( nLoopId + i - 1)
+      end
+   else
+      -- se il metodo sopra non funziona uso il metodo semplice (distanza tra gli angoli retti della curva tenone e faccia principale)
+      local b3Aux = EgtGetBBoxRef( AuxId, GDB_BB.STANDARD, frTen)
+      local dPockX = max( b3Ten:getMax():getX() - b3Aux:getMax():getX(), b3Aux:getMin():getX() - b3Ten:getMin():getX())
+      local dPockY = max( b3Ten:getMax():getY() - b3Aux:getMax():getY(), b3Aux:getMin():getY() - b3Ten:getMin():getY())
+      dPockL = sqrt( dPockX * dPockX + dPockY * dPockY)
+   end
    -- abilitazione lavorazione da sotto
    local bMillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.259)
    local bMillDown = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.1)
@@ -202,8 +225,8 @@ 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)
-   BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, bH2 ~= bMyShortPart)
+   local bMyShortPart = ( bShortPart and vtN:getX() < 0 and abs( vtN:getX()) < 0.999 and abs( vtN:getY()) < 0.259)
+   BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, ( bH2 and bMillDown) ~= bMyShortPart)
    -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
    local sWarn
    local dDepth = 0

LuaLibs/ProcessText.lua

@@ -46,7 +46,7 @@ function ProcessText.Make( Proc, nPhase, nRawId, nPartId)
       return false, sErr
    end
    -- verifico che il testo non sia orientato verso il basso (-5 deg)
-   if vtN:getZ() < - 0.1 and not BD.DOWN_HEAD then
+   if vtN:getZ() < - 0.1 and not BD.DOWN_HEAD and not BD.TURN then
       local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Text from bottom impossible'
       EgtOutLog( sErr)
       return false, sErr

NestProcess.lua

@@ -1,5 +1,7 @@
 -- BeamNestProcess.lua by Egaltech s.r.l. 2021/06/14
--- Gestione nesting automatico pareti
+-- Gestione nesting automatico travi
+-- 2022/10/05 Piccole modifiche per far funzionare correttamente i compilati
+-- 2022/10/06 Corretto bug che moltiplicava i pezzi se erano presenti più grezzi della stessa sezione
 
 -- Intestazioni
 require( 'EgtBase')
@@ -168,12 +170,20 @@ end
 -- Pezzi
 local Parts = {}
 
+-- cerco il grezzo con la lunghezza maggiore, epurata dello start gap
+local maxRawLenToFillNoStartGap = 0
+for RawIndex = 1, #Raws do
+   maxRawLenToFillNoStartGap = max( maxRawLenToFillNoStartGap, Raws[RawIndex].LenToFill - Raws[RawIndex].StartGap)
+end
 -- ciclo su pezzi per aggiungerli al nesting
 for nPartId, nCount in pairs( PART) do
    -- recupero lunghezza pezzo
    local Len = EgtGetInfo( nPartId, "L", 'd')
    local DispLen = EgtIf( Len <= 1000, 2000, 0) --EgtIf( Len <= 2000, max( 2000, 6000 - Len), 0)
-   table.insert( Parts, {Id = nPartId, Len = Len, DispLen = DispLen, Cnt = nCount})
+   -- aggiungo il pezzo solo se ci sta nel grezzo più lungo a disposizione
+   if Len < maxRawLenToFillNoStartGap then
+      table.insert( Parts, {Id = nPartId, Len = Len, DispLen = DispLen, Cnt = nCount})
+   end
 end
 
 -- lunghezza totale pezzi
@@ -207,7 +217,10 @@ for ShortIndex = 1, #ShortList do
    ShortCount = ShortCount + ShortList[ShortIndex].Cnt
 end
 local ShortForRaw = floor( ShortCount / MediumRawQty)
-local ExtraShortForRaw = fmod( ShortCount, MediumRawQty)
+local ExtraShortForRaw = 0
+if MediumRawQty > 0 then
+   ExtraShortForRaw = fmod( ShortCount, MediumRawQty)
+end
 -- creo lista pezzi corti singoli
 local SingleShortList = {}
 for ShortIndex = 1, #ShortList do
@@ -257,7 +270,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 +280,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 +314,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
@@ -325,7 +338,7 @@ while nMachGroup do
    if EgtGetInfo( nMachGroup, "AUTONEST",'i') == 1 then
       EgtRemoveInfo( nMachGroup, "AUTONEST")
       EgtSetInfo( nMachGroup, "UPDATEUI", 1)
-      local bOk, sErr = pcall( dofile, EgtGetSourceDir() .. "BatchProcessNew.lua")
+      local bOk, sErr = pcall( dofile, BEAM.BASEDIR .. "\\BatchProcessNew.lua")
       if not bOk then
          EgtOutLog( 'Error in BatchProcessNew.lua call (' .. ( sErr or '') ..')')
       end