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.

Merge branch 'Improvement/DownHeadInFreeContour' into develop
Improvement/DownHeadInFreeContour: - implementazione corretta degli smussi
2022-11-23 19:28:23 +01:00 · 2022-11-23 09:25:19 +01:00 · 2022-11-22 17:53:17 +01:00 · 2022-11-22 14:51:39 +01:00 · 2022-11-22 09:33:22 +01:00 · 2022-11-22 09:02:47 +01:00
24 changed files with 1017 additions and 349 deletions
@@ -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:
@@ -41,4 +41,4 @@ GWD.OVM_MID = BD.OVM_MID
 -- Tutto ok
 GWD.ERR = 0

-EgtOutLog( ' +++ GetWallData completed')
+EgtOutLog( ' +++ GetBeamData completed')
@@ -1,4 +1,4 @@
-- BeamExec.lua by Egaltech s.r.l. 2022/08/18
+-- 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.
@@ -35,6 +35,9 @@
 -- 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 = {}
@@ -258,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
@@ -270,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)
@@ -311,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
@@ -641,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)
@@ -670,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
@@ -1238,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

 -------------------------------------------------------------------------------------------------------------
@@ -1345,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)
@@ -1439,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
@@ -308,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
@@ -703,8 +703,10 @@ 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.35 then
         -- N_HorAng < 15° or N_HorAng > 55°
@@ -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
@@ -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

 ---------------------------------------------------------------------
@@ -2,6 +2,7 @@
 -- 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 = {}
@@ -263,6 +264,8 @@ 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
@@ -284,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
@@ -315,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
@@ -1,4 +1,4 @@
-- ProcessCut.lua by Egaltech s.r.l. 2022/07/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.
@@ -16,6 +16,7 @@
 -- 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 = {}
@@ -249,17 +250,21 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                      Proc.Box:getDimY() > b3Solid:getDimY() - 10 * GEO.EPS_SMALL and
                      ( Proc.Box:getDimX() > 0.75 * b3Solid:getDimX() or Proc.Box:getDimX() > 600.000))
   -- verifico se da considerare taglio lungo dal lato, solo per macchine tipo PF1250, inclinato non più di 30deg
-   local bLongCutFromSide = ( not bDownCut and ( BD.C_SIMM and BD.DOWN_HEAD and ( vtN:getY() > 0.865 or vtN:getY() < -0.865) and
+   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
   local bNoDicing = EgtGetInfo( Proc.Id, 'Q04', 'i') == 1
   if bNoDicing then
      if bLongCut then
-         return LongCut.Make( Proc, nPhase, nRawId, nPartId, true)
+         local bOk, sErr = LongCut.Make( Proc, nPhase, nRawId, nPartId, true)
+         return bOk, sErr, bNoDicing
      elseif bLongCutFromSide then
-         return LongCut.Make( Proc, nPhase, nRawId, nPartId, false, 2)
+         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
@@ -348,9 +353,37 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
         vtExtra = X_AX()
         bAutoCalcSurf = false
      end
+      -- 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 Proc.Box:getDimX() >= dSawThick then
-         vCuts = DC.GetDice( nAddGrpId, EgtIf( bForced, b3Raw, b3Solid), ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA)
+      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())
@@ -430,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
@@ -454,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
@@ -737,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
@@ -747,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
@@ -581,7 +581,7 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
         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.485) or bFace2TooLongForBlade and dFace2Ang < ( BD.CUT_VZ_MIN or -0.485) then
+         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
@@ -13,6 +13,8 @@
 -- 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 = {}
@@ -118,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
@@ -266,7 +268,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   local nErrorCode = 0
   -- abilitazione foratura da sotto
   local bDrillDown = ( bDownDrill and ( Proc.Down or vtExtr:getZ() < -0.1 or vtExtr:getZ() < 0.259))
-   local bDrillUp = ( bDownDrill and vtExtr:getZ() > -0.5)
+   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)
@@ -369,10 +371,14 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   -- 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
-   dMaxDepth = min( dMaxDepth, dToolFreeLen - dSubL)
+   dMaxDepth = min( dMaxDepth, max( dToolFreeLen - dSubL, 0))
   -- Verifico inclinazione foro nei limiti
-   local bTryDrill = ( CosB < BD.DRILL_VX_MAX)
+   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)
@@ -7,6 +7,7 @@
 -- 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 = {}
@@ -39,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)
@@ -1,6 +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 = {}
@@ -117,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)
@@ -157,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)
@@ -234,7 +242,6 @@ 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 and b3Aux:getDimZ() > b3Raw:getDimZ() - 5)
   local bDown = ( b3Aux:getMin():getZ() < b3Raw:getMin():getZ() + 5)
   -- verifico se in testa o coda
   local bHead = Proc.Head
@@ -243,12 +250,14 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- 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 = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, bTopHead, bDownHead)
+   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
@@ -297,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)
@@ -323,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
@@ -339,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)
@@ -355,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)
@@ -378,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)
@@ -387,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)
@@ -426,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)
@@ -492,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
@@ -516,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)
@@ -552,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
@@ -623,7 +700,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
         BL.UpdateTCING( nRawId, dOffs)
      end
   end
-   return true
+   return true, sWarn
 end

 ---------------------------------------------------------------------
@@ -764,6 +841,11 @@ 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
@@ -1,8 +1,11 @@
-- ProcessSplit.lua by Egaltech s.r.l. 2022/08/18
+-- 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 = {}
@@ -166,11 +169,13 @@ 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)
@@ -179,20 +184,22 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
   -- 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, 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 = ( 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 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
@@ -205,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'
@@ -224,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
@@ -249,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
@@ -272,7 +296,7 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
      -- 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
@@ -1,4 +1,4 @@
-- ProcessLapJoint.lua by Egaltech s.r.l. 2022/07/05
+-- ProcessLapJoint.lua by Egaltech s.r.l. 2022/09/27
 -- Gestione calcolo mezzo-legno per Travi
 -- 2019/10/08 Agg. gestione OpenPocket.
 -- 2021/01/24 Con sega a catena ora sempre impostato asse A.
@@ -51,6 +51,11 @@
 -- 2022/07/12 In MakeByChainOrSaw aggiunto check per feature L20 usata in modo improprio e, nel caso, si passa a una lavorazione tasca.
 -- 2022/08/11 Aggiunta lavorazione tunnel splittata con sega a catena per tutte le macchine ad esclusione della Fast.
 -- 2022/09/01 Spostate le funzioni GetTunnelDimension, CalcCollisionSafety, SetOpenSide in BeamLib.
+-- 2022/09/15 Implementata gestione feature Planing L090, gestita come LapJoint
+--            Implementata, in caso di fresatura di lato con altezza tasca molto bassa, la contornatura con unica passata
+--            Migliorata gestione AntiSplint (Mill e Saw)
+-- 2022/09/27 Aggiunta gestione SCC per svuotature con TURN (solo dopo applicazione lavorazione).
+-- 2022/10/20 In MakeByChainOrSaw modificato check per trovare la faccia adiacente sul lato più lungo.

 -- Tabella per definizione modulo
 local ProcessLapJoint = {}
@@ -101,6 +106,7 @@ function ProcessLapJoint.Identify( Proc)
            (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 32) or
            (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 33) or
            (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 34) or
+            (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 90) or
            ( Proc.Grp == 4  and  Proc.Prc == 37) or
            ( Proc.Grp == 4  and  Proc.Prc == 39) or
            ( Proc.Grp == 4  and  Proc.Prc == 120))
@@ -151,6 +157,7 @@ local function AssignQIdent( Proc)
      Q_ANTISPLINT_TYPE     = 'Q06' -- i
   elseif ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 34 then
      Q_CONTOUR_SMALL_TOOL  = 'Q01' -- i
+      Q_USE_MILL            = 'Q02' -- i
      Q_ANTISPLINT_TYPE     = 'Q06' -- i
   elseif ( Proc.Grp == 4)  and  Proc.Prc == 37 then
      Q_ANTISPLINT_TYPE     = 'Q06' -- i
@@ -158,6 +165,9 @@ local function AssignQIdent( Proc)
      Q_CONTOUR_SMALL_TOOL  = 'Q01' -- i
      Q_USE_MILL            = 'Q02' -- i
      Q_ANTISPLINT_TYPE     = 'Q06' -- i
+   elseif ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 90 then
+      Q_ANTISPLINT_TYPE     = 'Q03' -- i
+      Q_SIDE_ROUGH_TOOL     = 'Q04' -- i
   end
   -- le altre features gestite non hanno parametri Q
 end
@@ -2618,7 +2628,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
   for i = 1, #vAdj do
      if vAdj[i] >= 0 then
         local vtAdjN = EgtSurfTmFacetNormVersor( Proc.Id, vAdj[i], GDB_ID.ROOT)
-         if not bIs3Faces or abs( rfFac:getVersZ():getY()) < 0.174 or abs( rfFac:getVersZ():getY()) > 0.984 or vtAdjN:getY() * rfFac:getVersZ():getY() > 0.1 then
+         if not bIs3Faces or abs( rfFac:getVersZ():getY()) < 0.174 or abs( rfFac:getVersZ():getY()) > 0.984 or vtAdjN:getY() * rfFac:getVersZ():getY() > -0.1 then
            local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, nFacInd, vAdj[i], GDB_ID.ROOT)
            local dLen = dist( ptP1, ptP2)
            if dLen > dMaxLen then
@@ -2983,10 +2993,11 @@ local function MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw, nFacInd, bReduceDe
      end
   end
   -- eseguo il taglio
-   local bMadeASbyBld, sWarn, nIdMach = Fbs.MakeOne( Proc.Id, nFacet, sCutting, dSawDiam, vtN, nil, ( -0.5 + dExtraOffs), BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+   local dVzLimDwnUp = EgtIf( BD.TURN, -2, nil)
+   local bMadeASbyBld, sWarn, nIdMach = Fbs.MakeOne( Proc.Id, nFacet, sCutting, dSawDiam, vtN, dVzLimDwnUp, ( -0.5 + dExtraOffs), BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
   if bMadeASbyBld then
      sWarn = nil
-      if abs(dExtraOffs) > 0 then
+      if not bReduceDepth and abs(dExtraOffs) > 0 then
         sWarn = 'Warning : antisplint elevation is bigger than max tool depth'
      end
   end
@@ -2994,7 +3005,7 @@ local function MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw, nFacInd, bReduceDe
 end

 ---------------------------------------------------------------------
-local function MakePocket( Proc, nPartId, ptPs, tvtN, nFaceRef, sMchFind, nUseRoughTool, sMasterPocket, dPrevFaceElev, tDimAndRef, dAng, bOpenOutRaw)
+local function MakePocket( Proc, nPartId, b3Solid, ptPs, tvtN, nFaceRef, sMchFind, nUseRoughTool, sMasterPocket, dPrevFaceElev, tDimAndRef, dAng, bOpenOutRaw)

   -- calcolo l'elevazione dal punto medio
   local dElev
@@ -3088,8 +3099,10 @@ local function MakePocket( Proc, nPartId, ptPs, tvtN, nFaceRef, sMchFind, nUseRo
   end
   -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
   local sWarn
+   local dDepth = dElev
   if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
-      EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth - dElev)
+      dDepth = dMaxDepth - dElev
+      EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
      dElev = dMaxDepth
      sWarn = 'Warning : elevation bigger than max tool depth'
      EgtOutLog( sWarn)
@@ -3110,7 +3123,25 @@ local function MakePocket( Proc, nPartId, ptPs, tvtN, nFaceRef, sMchFind, nUseRo
         return false, sErr
      end
   end
-   return true, sWarn, sTuuidPk, dDiamTool
+   if BD.TURN then
+      -- centro del pezzo
+      local ptCen = ORIG()
+      if b3Solid then ptCen = b3Solid:getCenter() end
+      -- punto inizio lavorazione
+      local ptStart = EgtGetMachiningStartPoint() or ORIG()
+      -- orientamento braccio
+      local nSCC = MCH_SCC.NONE
+      -- se faccia verso alto o basso
+      if abs( tvtN[2]:getZ()) > abs( tvtN[2]:getY()) then
+         nSCC = EgtIf( ptStart:getY() > ptCen:getY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+      -- altrimenti faccia verso davanti o dietro
+      else
+         nSCC = EgtIf( ptStart:getZ() > ptCen:getZ(), MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
+      end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+      ML.ApplyMachining( true, false)
+   end
+   return true, sWarn, sTuuidPk, dDiamTool, dDepth
 end

 ---------------------------------------------------------------------
@@ -3135,7 +3166,7 @@ local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtN, nBas
      -- se l'angolo dalla verticale si discosta di più dell'angolo limite impostato, utilizzo la svuotatura
      if cos( dDiffFromSqAng) < cos( dAngLimit) then
         -- applico la svuotatura
-         local bOk, sWarn, sTuuidPk, dDiamTool, dElev = MakePocket( Proc, nPartId, ptPs, tvtN, nSideFace, sMchFind, nUseRoughTool, sPocketing, dPrevFaceElev, tDimAndRef, dAng)
+         local bOk, sWarn, sTuuidPk, dDiamTool, dElev = MakePocket( Proc, nPartId, b3Solid, ptPs, tvtN, nSideFace, sMchFind, nUseRoughTool, sPocketing, dPrevFaceElev, tDimAndRef, dAng)
         if not bOk then
            -- se ho id utensile e diametro è perchè non ha fatto svuotatura perchè la faccia è più stretta del diametro utensile
            -- e provo ad inserire singola passata di testa
@@ -3262,15 +3293,27 @@ local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtN, nBas
            EgtSetMachiningParam( MCH_MP.STARTADDLEN, dTDiam / 2)
         else
            EgtSetMachiningParam( MCH_MP.STARTADDLEN, -dTDiam / 2)
+            -- forzo attacco lineare
            if dElev > 0 then
+               EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
+               EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR)
+               EgtSetMachiningParam( MCH_MP.LITANG, 0)
+               EgtSetMachiningParam( MCH_MP.LOTANG, 0)
               EgtSetMachiningParam( MCH_MP.LIPERP, dElev)
+               EgtSetMachiningParam( MCH_MP.LOPERP, dElev)
            end
         end
         if bOpenEnd then
            EgtSetMachiningParam( MCH_MP.ENDADDLEN, dTDiam / 2)
         else
            EgtSetMachiningParam( MCH_MP.ENDADDLEN, -dTDiam / 2)
+            -- forzo attacco lineare
            if dElev > 0 then
+               EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
+               EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR)
+               EgtSetMachiningParam( MCH_MP.LITANG, 0)
+               EgtSetMachiningParam( MCH_MP.LOTANG, 0)
+               EgtSetMachiningParam( MCH_MP.LIPERP, dElev)
               EgtSetMachiningParam( MCH_MP.LOPERP, dElev)
            end
         end
@@ -3314,7 +3357,7 @@ local function GetUShapeWidth( Proc, nFacInd)
 end

 ---------------------------------------------------------------------
-local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMchFindMaster, bIs3Faces, b3Solid, bOrthoFacesMaster, bMillDown, bSetOpenBorders)
+local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMchFindMaster, bIs3Faces, b3Solid, bOrthoFacesMaster, bMillDown, bSetOpenBorders, bIsU, bIsL)

   local nFirstMachId
   local bOrthoFaces
@@ -3322,6 +3365,8 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
   local sMchFind = 'Pocket'
   local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt
   local bBadMach = false
+   -- minima altezza della tasca sotto alla quale fa una contornatura invece di una svuotatura
+   local dMinFaceElevForPocket = 20
   if sMchFindMaster and #sMchFindMaster > 0 then
      sMchFind = sMchFindMaster
   end
@@ -3377,7 +3422,31 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
               EgtInvertSurf( nSurfInt)
            end
         end
-         if bMakePocket then
+         local nFacInd, dFacElev = BL.GetFaceWithMostAdj( Proc.Id, nPartId)
+         local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
+         local bMakeContour = false
+         local sMilling
+         if dFacElev < dMinFaceElevForPocket and ( bIsU or bIsL) and ( Proc.Fct == 2 or Proc.Fct == 3) and abs( vtN:getZ()) > 0.996 then
+            bMakeContour = true
+            -- recupero la lavorazione di contornatura
+            sMilling = ML.FindMilling( 'Prof', nil, nil, nil, nil, not bMillDown, bMillDown)
+            if not sMilling then
+               local sMyWarn = 'Warning : Prof not found in library'
+               EgtOutLog( sMyWarn)
+               return true, sMyWarn
+            end
+            -- recupero i dati dell'utensile
+            dDiamTool = 50
+            dMaxDepth = 0
+            if EgtMdbSetCurrMachining( sMilling) then
+               local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+               if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+                  dDiamTool = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
+                  dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dToolMaxDepth
+               end
+            end
+         end
+         if bMakePocket or bMakeContour 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
@@ -3403,7 +3472,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
            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
+               if abs( vtOrtho:getZ()) >= 0.707 and not BD.DOWN_HEAD and not bMakeContour then
                  dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic
                  dElev = dMaxDepth
                  sWarn = 'Warning : elevation bigger than max tool depth'
@@ -3438,29 +3507,49 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
               local sErr = 'Impossible apply perpendicular pocketing: ' .. sPocketing
               return -2, sErr
            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
+            local sName
+            local nMchFId
+            if bMakeContour then
+               -- inserisco la lavorazione di contornatura
+               sName = 'Prof_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+               nMchFId = EgtAddMachining( sName, sMilling)
+               if not nMchFId then
+                  local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
+                  EgtOutLog( sErr)
+                  return -1, sErr
+               end
+            else
+               -- altrimenti inserisco la lavorazione di svuotatura
+               sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+               nMchFId = EgtAddMachining( sName, sPocketing)
+               if not nMchFId then
+                  local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
+                  EgtOutLog( sErr)
+                  return -1, sErr
+               end
            end
            -- prendo l'id della prima lavorazione inserita
            if not nFirstMachId then
               nFirstMachId = nMchFId
            end
-            -- aggiungo geometria
-            EgtSetMachiningGeometry( {{ nPathInt, -1}})
+            if bMakeContour then
+               -- aggiungo geometria per contornatura
+               EgtSetMachiningGeometry( {{ Proc.Id, nFacInd}})
+            else
+               -- altrimenti aggiungo geometria per svuotatura
+               EgtSetMachiningGeometry( {{ nPathInt, -1}})
+            end
            -- 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
+            if not bMakeContour then
+               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
            end
            -- imposto posizione braccio porta testa
            local nSCC = MCH_SCC.NONE
@@ -3481,11 +3570,50 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
               EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN)
            end
            -- inverto il percorso di lavorazione per lavorare sinistro
-            EgtSetMachiningParam( MCH_MP.INVERT, true)
+            if not bMakeContour then
+               EgtSetMachiningParam( MCH_MP.INVERT, true)
+            end
            -- imposto affondamento
-            EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
+            if not bMakeContour then
+               EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
+            end
+            -- se contornatura doppia anticipo la fine della lavorazione a metà trave
+            if bMakeContour and bDoubleSide then
+               EgtSetMachiningParam( MCH_MP.OFFSL, dDepth / 2)
+            end
+            -- se contornatura cerco la direzione di lavoro migliore e setto attacco e allungamenti
+            if bMakeContour then
+               local nFaceUse = BL.GetNearestParalOpposite( vtOrtho)
+               EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
+               -- quantità di cui allargare la contornatura per andare in tangenza con lo spigolo, nel caso di altezza tasca minore di D/2 fresa
+               local dAddWorkWidth = EgtIf( dFacElev < dDiamTool / 2, -sqrt( dFacElev * dDiamTool - dFacElev * dFacElev), -dDiamTool / 2)
+               EgtSetMachiningParam( MCH_MP.LIELEV, 0)
+               EgtSetMachiningParam( MCH_MP.LOELEV, 0)
+               if bIsU then
+                  EgtSetMachiningParam( MCH_MP.STARTADDLEN, dAddWorkWidth)
+                  EgtSetMachiningParam( MCH_MP.ENDADDLEN, dAddWorkWidth)
+                  EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
+                  EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR)
+                  EgtSetMachiningParam( MCH_MP.LITANG, 0)
+                  EgtSetMachiningParam( MCH_MP.LOTANG, 0)
+                  EgtSetMachiningParam( MCH_MP.LIPERP, 30)
+                  EgtSetMachiningParam( MCH_MP.LOPERP, 30)
+               elseif bIsL then
+                  EgtSetMachiningParam( MCH_MP.STARTADDLEN, 30)
+                  EgtSetMachiningParam( MCH_MP.ENDADDLEN, dAddWorkWidth)
+                  EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.TANGENT)
+                  EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR)
+                  EgtSetMachiningParam( MCH_MP.LITANG, 30)
+                  EgtSetMachiningParam( MCH_MP.LOTANG, 0)
+                  EgtSetMachiningParam( MCH_MP.LIPERP, 0)
+                  EgtSetMachiningParam( MCH_MP.LOPERP, 30)
+               end
+            end
            -- imposto elevazione e dichiaro non si generano sfridi per VMill
-            local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
+            local sNotes = ''
+            if not bMakeContour then
+               sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
+            end
            sNotes = sNotes .. 'VMRS=0;'
            EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
            -- eseguo
@@ -3528,20 +3656,36 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
                     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
+               if bMakeContour then
+                  -- inserisco la lavorazione di contornatura
+                  sName = 'ProfOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+                  nMchFId = EgtAddMachining( sName, sMilling)
+                  if not nMchFId then
+                     local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
+                     EgtOutLog( sErr)
+                     return -1, sErr
+                  end
+               else
+                  -- inserisco la lavorazione di svuotatura
+                  sName = 'PockOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+                  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
               end
               -- prendo l'id della prima lavorazione inserita
               if not nFirstMachId then
                  nFirstMachId = nMchFId
               end
-               -- aggiungo geometria
-               EgtSetMachiningGeometry( {{ nPathInt, -1}})
+               if bMakeContour then
+                  -- aggiungo geometria per contornatura
+                  EgtSetMachiningGeometry( {{ Proc.Id, nFacInd}})
+               else
+                  -- altrimenti aggiungo geometria per svuotatura
+                  EgtSetMachiningGeometry( {{ nPathInt, -1}})
+               end
               -- imposto direzione utensile opposta
               EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
               -- imposto posizione braccio porta testa
@@ -3563,11 +3707,49 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
                  EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN)
               end
               -- inverto il percorso di lavorazione per lavorare sinistro
-               EgtSetMachiningParam( MCH_MP.INVERT, true)
-               -- imposo affondamento
-               EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
+                  EgtSetMachiningParam( MCH_MP.INVERT, true)
+               -- imposto affondamento
+               if not bMakeContour then
+                  EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
+               end
+               -- se contornatura doppia anticipo la fine della lavorazione a metà trave
+               if bMakeContour and bDoubleSide then
+                  EgtSetMachiningParam( MCH_MP.OFFSL, dDepth / 2)
+               end
+               -- se contornatura cerco la direzione di lavoro migliore
+               if bMakeContour then
+                  local nFaceUse = BL.GetNearestParalOpposite( vtOrtho)
+                  EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
+                  -- quantità di cui allargare la contornatura per andare in tangenza con lo spigolo, nel caso di altezza tasca minore di D/2 fresa
+                  local dAddWorkWidth = EgtIf( dFacElev < dDiamTool / 2, -sqrt( dFacElev * dDiamTool - dFacElev * dFacElev), -dDiamTool / 2)
+                  EgtSetMachiningParam( MCH_MP.LIELEV, 0)
+                  EgtSetMachiningParam( MCH_MP.LOELEV, 0)
+                  if bIsU then
+                     EgtSetMachiningParam( MCH_MP.STARTADDLEN, dAddWorkWidth)
+                     EgtSetMachiningParam( MCH_MP.STARTADDLEN, dAddWorkWidth)
+                     EgtSetMachiningParam( MCH_MP.ENDADDLEN, dAddWorkWidth)
+                     EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
+                     EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR)
+                     EgtSetMachiningParam( MCH_MP.LITANG, 0)
+                     EgtSetMachiningParam( MCH_MP.LOTANG, 0)
+                     EgtSetMachiningParam( MCH_MP.LIPERP, 30)
+                     EgtSetMachiningParam( MCH_MP.LOPERP, 30)
+                  elseif bIsL then
+                     EgtSetMachiningParam( MCH_MP.STARTADDLEN, dAddWorkWidth)
+                     EgtSetMachiningParam( MCH_MP.ENDADDLEN, 30)
+                     EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
+                     EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.TANGENT)
+                     EgtSetMachiningParam( MCH_MP.LITANG, 0)
+                     EgtSetMachiningParam( MCH_MP.LOTANG, 30)
+                     EgtSetMachiningParam( MCH_MP.LIPERP, 30)
+                     EgtSetMachiningParam( MCH_MP.LOPERP, 0)
+                  end
+               end
               -- imposto elevazione e dichiaro non si generano sfridi per VMill
-               local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
+               sNotes = ''
+               if not bMakeContour then
+                  sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
+               end
               sNotes = sNotes .. 'VMRS=0;'
               EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
               -- eseguo
@@ -4377,7 +4559,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
               end
            end
            -- se lavorazione da sotto e lunga, va divisa in due metà
-            local bDouble = ( vtN:getZ() < -0.5 and dH > ( BD.MAX_LEN_BH_FROM_BOTTOM or 200))
+            local bDouble = ( vtN:getZ() < -0.5 and dH > ( BD.MAX_LEN_BH_FROM_BOTTOM or 200) and not BD.TURN)
            -- inserisco la lavorazione di fresatura
            local sName = 'BHMill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
            local nMchFId = EgtAddMachining( sName, sMilling)
@@ -4407,7 +4589,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
            sNotes = sNotes .. 'VMRS=0;'
            EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
            -- attacchi e uscite
-            if vtN:getZ() > -0.5 then
+            if vtN:getZ() > -0.5 or BD.TURN then
               EgtSetMachiningParam( MCH_MP.LITANG, 0)
               EgtSetMachiningParam( MCH_MP.LIPERP, dFacElev + BD.CUT_SIC)
               EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.AS_LI)
@@ -4428,7 +4610,20 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
            local nStepType = MCH_MILL_ST.ONEWAY
            EgtSetMachiningParam( MCH_MP.STEPTYPE, nStepType)
            -- imposto posizione braccio porta testa
-            local nSCC = EgtIf( ( vtN:getY() > 0.5 or ( bHeadDir and vtN:getZ() > 0.5 ) or ( not bHeadDir and vtN:getZ() < -0.5)), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+            local nSCC = MCH_SCC.NONE
+            if not BD.TURN then
+               nSCC = EgtIf( ( vtN:getY() > 0.5 or ( bHeadDir and vtN:getZ() > 0.5 ) or ( not bHeadDir and vtN:getZ() < -0.5)), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+            else
+               if vtN:getY() > 0.707 then 
+                  nSCC = MCH_SCC.ADIR_YP
+               elseif vtN:getY() < -0.707 then
+                  nSCC = MCH_SCC.ADIR_YM
+               elseif vtN:getZ() > 0.707 then
+                  nSCC = MCH_SCC.ADIR_ZP
+               elseif vtN:getZ() < -0.707 then
+                  nSCC = MCH_SCC.ADIR_ZM
+               end
+            end
            EgtSetMachiningParam( MCH_MP.SCC, nSCC)
            -- eseguo
            if not ML.ApplyMachining( true, false) then
@@ -4918,13 +5113,16 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                     -- 2021.07.16 Per poter eseguire antischeggia di lama su feature che non sono passanti da faccia a faccia
                     -- ma che sono su un angolo (coinvolgono 2 facce contigue) è stato modificato il confronto in:
                     -- esegue antischeggia di lama se forma U o L con feature passante in Y o Z, oppure se feature a furma U e con 3 facce oppore a forma a L e con 2 facce
+                     -- non fa mai antischeggia di lama se la faccia è rivolta verso il basso, a meno che ci sia una testa sotto
                     local bMadeASbyBld = false
                     local bPassThrou = ( Proc.Box:getDimY() > b3Raw:getDimY() - 1 or Proc.Box:getDimZ() > b3Raw:getDimZ() - 1)
                     local bPassEdge = ((( bIsU and Proc.Fct == 3) or ( bIsL and Proc.Fct == 2)) and bSinglePart and Proc.Box:getDimX() < 0.9 * b3Raw:getDimX())
-                     if nChamfer < 2 and nQAntisplintResult == 1 and (( bIsU or bIsL) and ( bPassThrou or bPassEdge)) then
+                     local nFacIndOri = BL.GetFaceWithMostAdj( Proc.Id, nPartId)
+                     local vtNOri = EgtSurfTmFacetNormVersor( Proc.Id, nFacIndOri, GDB_ID.ROOT)
+                     if nChamfer < 2 and nQAntisplintResult == 1 and (( bIsU or bIsL) and ( bPassThrou or bPassEdge)) and ( vtNOri:getZ() > -0.087 or BD.DOWN_HEAD or BD.TURN) then
                        local bOk
                        local bSawDown = ( bMillDown and not bMillUp)
-                        bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtN, nFacInd, sWarn, bSawDown, true)
+                        bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtNOri, nFacIndOri, sWarn, bSawDown, true)
                        if not bOk then return false, sWarn end
                     end
                     -- in base al flag interno e al numero di facce e se ha forma ad U
@@ -4994,7 +5192,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                              dToolMaxDiam = min ( dFacDim1, dFacDim2, dToolTargetDiam)
                           end
                           local _, sPocketing = VerifyPocket( Proc, dToolMaxDiam, dFacElev, nil, sMyMchFind)
-                           bOk, sWarn2, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, ptPs, tvtNx, nFacInd, sMyMchFind, nUseRoughTool, sPocketing, dMachDepth, nil, nil, bAllWithEndCap)
+                           bOk, sWarn2, sTuuidPk, dDiamTool, dDepth = MakePocket( Proc, nPartId, b3Solid, ptPs, tvtNx, nFacInd, sMyMchFind, nUseRoughTool, sPocketing, dMachDepth, nil, nil, bAllWithEndCap)
                           if not bOk then return false, sWarn2 end
                           if sWarn2 then
                              if not sWarn then sWarn = '' end
@@ -5005,8 +5203,8 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                        -- if nChamfer < 2 and nQAntisplintResult == 2 and ( bIsU or bIsL) then
                           if nChamfer < 2 and nQAntisplintResult == 2 then
                              local bOk, sWarn2 = ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw, 
-                                                                        nFacInd, nAddGrpId, bMillDown, dDiamTool, bDoubleSide, 
-                                                                        vtOrtho, nPathInt, nSurfInt, b3Solid, dDepth, 
+                                                                        nFacInd, nAddGrpId, bMillDown, dDiamTool, nil, 
+                                                                        nil, nil, nil, b3Solid, dDepth, 
                                                                        bOneShot, nFirstMachId)
                              if sWarn2 then
                                 if not sWarn then sWarn = '' end
@@ -5035,7 +5233,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                              bSetOpenBorders = true
                           end
                           nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, 
-                           bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, bIs3Faces, b3Solid, bOrthoFacesMaster, bMillDown, bSetOpenBorders)
+                           bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, bIs3Faces, b3Solid, bOrthoFacesMaster, bMillDown, bSetOpenBorders, bIsU, bIsL)
                           if nOk == -2 then
                              if not sMchFind then 
                                 sMchFind = sMchFindBackUp 
@@ -5055,10 +5253,11 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                              sWarn = sErr
                              -- se ho antischeggia con fresa le inserisco
                           -- if nChamfer < 2 and nQAntisplintResult == 2 and ( bIsU or bIsL) then
+                              local nFacIndOri, dFacElevOri = BL.GetFaceWithMostAdj( Proc.Id, nPartId)
                              if nChamfer < 2 and nQAntisplintResult == 2 then
                                 local bOk, sWarn2 = ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw, 
-                                                                           nFacInd, nAddGrpId, bMillDown, dDiamTool, bDoubleSide, 
-                                                                           vtOrtho, nPathInt, nSurfInt, b3Solid, dDepth, 
+                                                                           nFacIndOri, nAddGrpId, bMillDown, dDiamTool, nil, 
+                                                                           nil, nil, nil, b3Solid, dFacElevOri, 
                                                                           bOneShot, nFirstMachId)
                                 if sWarn2 then
                                    if not sWarn then sWarn = '' end
@@ -5151,13 +5350,16 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
            -- 2021.07.16 Per poter eseguire antischeggia di lama su feature che non sono passanti da faccia a faccia
            -- ma che sono su un angolo (coinvolgono 2 facce contigue) è stato modificato il confronto in:
            -- esegue antischeggia di lama se forma U o L con feature passante in Y o Z, oppure se feature a furma U e con 3 facce oppore a forma a L e con 2 facce
+            -- non fa mai antischeggia di lama se la faccia è rivolta verso il basso, a meno che ci sia una testa sotto
            local bMadeASbyBld = false
            local bPassThrou = ( Proc.Box:getDimY() > b3Raw:getDimY() - 1 or Proc.Box:getDimZ() > b3Raw:getDimZ() - 1)
            local bPassEdge = ((( bIsU and Proc.Fct == 3) or ( bIsL and Proc.Fct == 2)) and bSinglePart and Proc.Box:getDimX() < 0.9 * b3Raw:getDimX())
-            if nChamfer < 2 and nQAntisplintResult == 1 and (( bIsU or bIsL) and ( bPassThrou or bPassEdge)) then
+            local nFacIndOri = BL.GetFaceWithMostAdj( Proc.Id, nPartId)
+            local vtNOri = EgtSurfTmFacetNormVersor( Proc.Id, nFacIndOri, GDB_ID.ROOT)
+            if nChamfer < 2 and nQAntisplintResult == 1 and (( bIsU or bIsL) and ( bPassThrou or bPassEdge)) and ( vtNOri:getZ() > -0.087 or BD.DOWN_HEAD or BD.TURN) then
               local bOk
               local bSawDown = ( bMillDown and not bMillUp)
-               bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtN, nFacInd, sWarn, bSawDown)
+               bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtNOri, nFacIndOri, sWarn, bSawDown)
               if not bOk then return false, sWarn end
            end
            if nChamfer < 2 and nQAntisplintResult == 2 then
@@ -5172,7 +5374,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
               local tvtNx = {}
               tvtNx[2] = vtN
               local bOk, sWarn2
-               bOk, sWarn2, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, ptC, tvtNx, nFacInd, sMchFind, nUseRoughTool, sPocketing, dFacElev + dCollSic, nil, nil, bAllWithEndCap)
+               bOk, sWarn2, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, b3Solid, ptC, tvtNx, nFacInd, sMchFind, nUseRoughTool, sPocketing, dFacElev + dCollSic, nil, nil, bAllWithEndCap)
               if not bOk then return false, sWarn2 end
               if sWarn2 then
                  if not sWarn then sWarn = '' end
@@ -5396,7 +5598,7 @@ function ProcessLapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- in base al tipo di feature attribuisco il significato dei parametri Q
   AssignQIdent( Proc)
   -- se non forzate frese, uso la lama
-   local bUseBlade = EgtGetInfo( Proc.Id, Q_USE_ROUGH_TOOL, 'i') ~= 1 and EgtGetInfo( Proc.Id, Q_USE_MILL, 'i') ~= 1
+   local bUseBlade = EgtIf( Proc.Prc == 90, false, EgtGetInfo( Proc.Id, Q_USE_ROUGH_TOOL, 'i') ~= 1 and EgtGetInfo( Proc.Id, Q_USE_MILL, 'i') ~= 1)
   local nForceUseBladeOnNotContinueFace
   -- se ho attivo la lama e ho la feature 30, verifico i parametri Q propri della feature
   if bUseBlade then
@@ -5523,6 +5725,9 @@ function ProcessLapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
         -- se piccola, con fresa
         if not bUseBlade and ( Proc.Box:getDimX() < MAX_MILL_LIN and ( Proc.Box:getDimZ() < MAX_MILL_LIN or Proc.Box:getDimY() < MAX_MILL_LIN)) then
            return MakeOneFaceByMill( Proc, nPhase, nRawId, nPartId)
+         -- se è una spianatura a una faccia richiamo la LongCut
+         elseif Proc.Prc == 90 then
+            return LongCut.Make( Proc, nPhase, nRawId, nPartId)
         -- altrimenti, con lama
         else
            return Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
@@ -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.
@@ -11,6 +11,8 @@
 -- 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 = {}
@@ -436,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
@@ -1024,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
@@ -1041,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
@@ -4,6 +4,8 @@
 -- 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 = {}
@@ -229,6 +231,35 @@ local function CleanCorners( Proc, dMorH, vtN, bDoubleDir, AuxId)
   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)
@@ -309,8 +340,10 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         -- 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))
+            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()
@@ -387,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
@@ -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)
@@ -1,4 +1,4 @@
-- ProcessScarfJoint.lua by Egaltech s.r.l. 2022/07/12
+-- 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)
@@ -173,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
@@ -310,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

@@ -346,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)
@@ -356,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
@@ -378,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
@@ -2,6 +2,7 @@
 -- 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 = {}
@@ -12,6 +13,7 @@ local BL = require( 'BeamLib')
 local Fbs = require( 'FacesBySaw')
 local DC = require( 'DiceCut')
 local Cut = require( 'ProcessCut')
+local FreeContour = require( 'ProcessFreeContour')

 EgtOutLog( ' ProcessSimpleScarf started', 1)

@@ -28,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
@@ -188,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
@@ -3,6 +3,10 @@
 -- 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 = {}
@@ -254,11 +258,13 @@ 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)
@@ -267,20 +273,22 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
   -- 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, 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 = ( 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 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
@@ -339,6 +347,12 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
         -- altrimenti tagli dai due fianchi (dietro e davanti)
         else
            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
@@ -380,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'
@@ -399,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
@@ -425,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
@@ -455,7 +489,7 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
      -- 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
@@ -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)
@@ -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))
@@ -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 and abs( vtN:getY()) < 0.259)
-   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
@@ -1,5 +1,7 @@
 -- BeamNestProcess.lua by Egaltech s.r.l. 2021/06/14
 -- 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
@@ -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
Author	SHA1	Message	Date
luca.mazzoleni	8baf4ad2d6	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.	2022-11-23 19:28:23 +01:00
luca.mazzoleni	3e27651e4c	Merge branch 'Improvement/DownHeadInFreeContour' into develop	2022-11-23 09:25:19 +01:00
luca.mazzoleni	2c5de2516d	Improvement/DownHeadInFreeContour: - implementazione corretta degli smussi	2022-11-22 17:53:17 +01:00
luca.mazzoleni	07dad8f8c2	Improvement/DownHeadInFreeContour: - correzione fresatura per casi in cui si parte dalla testa sotto	2022-11-22 14:51:39 +01:00
luca.mazzoleni	b48fe0da34	Improvement/DownHeadInFreeContour: - fresatura ok, da sistemare funzionamento smussi	2022-11-22 09:33:22 +01:00
luca.mazzoleni	640f77b5f5	Merge remote-tracking branch 'origin/HEAD' into develop	2022-11-22 09:02:47 +01:00
luca.mazzoleni	14afb25783	Merge commit '5bc4e6f24f2d301c22eb2f1c0cb70ce3665a51ef' into Improvement/DownHeadInFreeContour	2022-11-22 09:02:38 +01:00
DarioS	5bc4e6f24f	DataBeam : - modifica alla lavorazione tenoni per favorire in generale l'attacco da sopra.	2022-11-22 08:42:51 +01:00
luca.mazzoleni	ea40658bd3	BugFix/Ticket#802 : - piccolo fix per dovetail in doppio	2022-11-21 12:41:38 +01:00
luca.mazzoleni	ec1a8e711d	Revert "Revert "Merge branch 'Feature/FindMirroredFeatures' of https://gitlab.steamware.net/egaltech/DataBeam into develop"" This reverts commit `182639772d`.	2022-11-18 10:46:50 +01:00
luca.mazzoleni	a0b55b8628	-- 2022/11/10 Corrette finiture lama per BigSection con trave alta	2022-11-16 16:47:39 +01:00
luca.mazzoleni	6e0d6c7ea7	Improvement/Ticket#880 : fix minori	2022-11-15 10:32:58 +01:00
luca.mazzoleni	c3786e0a96	Merge branch 'develop'	2022-11-11 10:06:42 +01:00
luca.mazzoleni	07a66eb132	Merge branch 'master' into develop	2022-11-10 19:05:09 +01:00
luca.mazzoleni	b3fcdcdd6b	Merge branch 'Feature/BigSection' into develop	2022-11-10 19:01:09 +01:00
luca.mazzoleni	86c225305f	Feature/BigSection: -in Split, corrette finiture lama per BigSection con trave alta	2022-11-10 18:59:29 +01:00
DarioS	0c5c1dcfe5	DataBeam : - in LapJoint abilitata variabile Q Q_USE_MILL anche per L34.	2022-11-10 18:48:07 +01:00
luca.mazzoleni	af8532970c	Merge branch 'develop' into Feature/BigSection	2022-11-10 15:57:58 +01:00
luca.mazzoleni	6fb843e4cf	Merge branch 'Improvement/Ticket#880' into develop	2022-11-10 09:27:10 +01:00
luca.mazzoleni	c654bbcd19	Improvement/Ticket#880 : fix minori	2022-11-09 18:13:40 +01:00
luca.mazzoleni	f0ebd5c206	Improvement/Ticket#880 : fix minori	2022-11-09 16:43:40 +01:00
luca.mazzoleni	0e3e6b6174	Improvement/Ticket#880 : piccola modifica	2022-11-09 15:25:45 +01:00
luca.mazzoleni	6487fc3836	Improvement/Ticket#880 : - Per SimpleScarf (T70) implementata forzatura utilizzo fresa di lato tramite parametro Q04. Nel caso, viene richiamata la FreeContour	2022-11-09 12:37:11 +01:00
luca.mazzoleni	59b716daa6	Merge branch 'master' into develop	2022-11-07 15:22:08 +01:00
DarioS	98fcfd9bc1	DataBeam : - correzioni varie per H2 come testa da sopra o da sotto. (PF o PF1250).	2022-11-05 12:38:05 +01:00
luca.mazzoleni	9177fb3c4c	Merge branch 'develop'	2022-11-03 10:40:31 +01:00
luca.mazzoleni	7e21b84bb9	Improvement/Ticket#855 : - in MachiningLib modificata scelta utensile ottimizzata. Ora se c'è un utensile più grande disponibile si dà preferenza a quello.	2022-11-02 18:59:14 +01:00
luca.mazzoleni	fb6dbebdd4	BugFix/Ticket#871 : - in split e headcut corretto accorciamento percorso lama per tagli doppi verticali	2022-11-02 11:58:55 +01:00
luca.mazzoleni	111f11cf92	BugFix/DrillingsWIthSameInOutFace: - in ProcessDrill, nel riconoscimento dei fori da splittare, aggiunta la verifica che le facce in/out del foro siano differenti	2022-10-25 17:41:58 +02:00
luca.mazzoleni	607efa3bef	BugFix/Ticket#859 : - in lapjoint leggera correzione alla ricerca della direzione milgiore di lavorazione	2022-10-20 16:53:33 +02:00
luca.mazzoleni	b79e180da2	Merge remote-tracking branch 'origin/HEAD' into develop	2022-10-20 11:22:23 +02:00
luca.mazzoleni	00c0db39d7	BugFix/Ticket#861 : -In lapjoint L020 ( e altre) sistemato l'attacco per fresature aggiuntive quando l'angolo tra le facce è > 90°	2022-10-20 11:22:00 +02:00
DarioS	8dc1c63b65	DataBeam : - modifiche per TURN.	2022-10-20 10:16:43 +02:00
luca.mazzoleni	3ca4bdde77	Merge branch 'Feature/BigSection' into develop	2022-10-19 17:17:48 +02:00
luca.mazzoleni	af643b1ba5	Feature/BigSection: -modifiche e correzione bug che impedivano il funzionamento corretto di headcut e split	2022-10-19 11:43:37 +02:00
luca.mazzoleni	a9061ecf51	Merge branch 'develop' into Feature/BigSection	2022-10-19 11:40:47 +02:00
luca.mazzoleni	d49cb93e36	- in NestProcess corretto bug che moltiplicava i pezzi se erano presenti più grezzi della stessa sezione	2022-10-06 09:48:11 +02:00
luca.mazzoleni	f620269f31	BugFix/CompiledLua: - in NestProcess fix percorso basedir per avere il funzionamento corretto anche con script compilati - in NestProcess piccolo fix per evitare divisione per 0	2022-10-05 10:50:38 +02:00
luca.mazzoleni	182639772d	Revert "Merge branch 'Feature/FindMirroredFeatures' of https://gitlab.steamware.net/egaltech/DataBeam into develop" This reverts commit `b2a1fc823d`, reversing changes made to `ba51a86239`.	2022-10-04 17:02:09 +02:00
luca.mazzoleni	b2a1fc823d	Merge branch 'Feature/FindMirroredFeatures' of https://gitlab.steamware.net/egaltech/DataBeam into develop	2022-10-04 17:01:22 +02:00
luca.mazzoleni	ba51a86239	Merge remote-tracking branch 'origin/master' into develop	2022-10-04 17:00:58 +02:00
Emmanuele Sassi	26077bcfdf	Merge remote-tracking branch 'origin/master'	2022-10-04 17:00:31 +02:00
luca.mazzoleni	4dbec60558	Merge branch 'develop' into Feature/FindMirroredFeatures	2022-10-04 16:43:25 +02:00
luca.mazzoleni	3bd16304c5	Merge remote-tracking branch 'origin/master' into develop	2022-10-04 16:34:49 +02:00
Emmanuele Sassi	950f7d1992	- correzione Beam in Commento - corretto bug nest che non usciva se pezzo piu' lungo del grezzo	2022-10-04 16:31:00 +02:00
DarioS	bc8fffd075	DataBeam : - modifiche per TURN - sistemato controllo per cubetti su tagli.	2022-10-04 16:01:15 +02:00
luca.mazzoleni	3669787621	Feature/FindMirroredFeatures: - in BeamExec aggiunta la ricerca delle feature specchiate per mortase a coda di rondine	2022-09-29 16:03:02 +02:00
luca.mazzoleni	0c9945a457	Merge branch 'Improvement/BetterMortiseToolSelection' into develop	2022-09-27 16:43:18 +02:00
luca.mazzoleni	8a693a38cc	Improvement/BetterMortiseToolSelection: - Sistemato spostamento geometria se fuori dal grezzo	2022-09-27 15:53:09 +02:00
luca.mazzoleni	e6c173e5a1	Improvement/BetterMortiseToolSelection: -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.	2022-09-27 11:32:26 +02:00
luca.mazzoleni	bd822e9153	Merge branch 'develop' into Improvement/BetterMortiseToolSelection	2022-09-26 17:04:06 +02:00
luca.mazzoleni	cf7322229d	Merge branch 'BugFix/HeadSplitCutOnBigSection' into develop	2022-09-26 16:41:17 +02:00
luca.mazzoleni	706d9efa9d	BugFix/HeadSplitCutOnBigSection: - corretto anche per Split il flag Q05 non inizializzato - ora la gestione dei tagli per BigSection è quella standard (HorizCut, double, etc.)	2022-09-26 16:15:52 +02:00
luca.mazzoleni	4fdafa34c5	Merge remote-tracking branch 'origin/HEAD' into BugFix/HeadSplitCutOnBigSection	2022-09-26 14:51:47 +02:00
DarioS	66541894ea	DataBeam : - modifica in HeadCut per flag Q05 tipo lavorazione con trave grande non inizializzato.	2022-09-26 14:11:59 +02:00
luca.mazzoleni	1198a34cd2	Corretto bug che provocava il calcolo errato della profondità di tasche laterali se maggiore del massimo materiale fresa	2022-09-26 10:12:28 +02:00
luca.mazzoleni	41412b6cca	Merge remote-tracking branch 'origin/master' into develop	2022-09-26 10:10:12 +02:00
luca.mazzoleni	9588ee0def	Merge remote-tracking branch 'origin/HEAD' into Improvement/BetterMortiseToolSelection	2022-09-26 08:52:03 +02:00
DarioS	bef986e453	DataBeam : - modifiche per TURN.	2022-09-26 08:21:23 +02:00
luca.mazzoleni	4ad4638582	Merge branch 'develop' into Improvement/BetterMortiseToolSelection	2022-09-23 17:41:45 +02:00
luca.mazzoleni	5b334d8fa7	Merge branch 'Improvement/Ticket#801' into develop	2022-09-23 17:41:20 +02:00
luca.mazzoleni	edb0f70a27	Improvement/Ticket#801 : sistemati commenti	2022-09-23 17:41:06 +02:00
luca.mazzoleni	808f92fa36	Improvement/Ticket#801 : -ProcessCut: ora nelle lavorazioni laterali, se viene lasciato il cordolo, non si aggiorna il grezzo -ProcessLongCut: ora la lama sotto viene attivata per facce poco più che verticali -mancano dei dettagli da sistemare e i commenti	2022-09-23 15:35:38 +02:00
luca.mazzoleni	6407057400	piccola correzione	2022-09-22 16:25:09 +02:00
luca.mazzoleni	2f63cd84e3	BugFix/Ticket#793 : commenti	2022-09-22 16:14:07 +02:00
luca.mazzoleni	798696a5a6	BugFix/Ticket#793 : in freeContour MakeByMill aggiunto messaggio per elevazione non raggiunta	2022-09-21 18:45:41 +02:00
luca.mazzoleni	8a3b9d4706	Merge branch 'Improvement/Ticket#796' into develop	2022-09-21 15:17:53 +02:00
luca.mazzoleni	0fdc2b8d15	Improvement/Ticket#796 : in BeamExec, per il birdsmouth L020 il foro viene sempre fatto prima della lavorazione	2022-09-21 14:54:29 +02:00
luca.mazzoleni	9915cd2d42	Merge branch 'BugFix/Ticket#792' into develop	2022-09-20 17:05:28 +02:00
luca.mazzoleni	432a8a9347	BugFix/Ticket#792 : in ProcessTenon migliorato calcolo numero di passate laterali (a volte lasciava materiale agli estremi della trave)	2022-09-20 15:32:20 +02:00
luca.mazzoleni	cc6d21baf6	piccola modifica a GetNearestOrthoOpposite per miglior scelta direzione attacco utensile	2022-09-16 18:40:33 +02:00
Samuele Locatelli	bc5d904680	Update x compilazione script LUA	2022-09-16 11:47:58 +02:00
Samuele Locatelli	58905b88ba	Update e fix percorso lua compilati	2022-09-16 11:38:15 +02:00
luca.mazzoleni	68f40aed58	Merge branch 'Feature/AddPlaningL090' into develop	2022-09-15 15:50:37 +02:00
luca.mazzoleni	d91c31974e	Feature/AddPlaningL090: -implementata feature L090 (Planing), gestita come LapJoint -in LapJoint implementata, in caso di fresatura di lato con altezza tasca molto bassa, la contornatura con unica passata -migliorato il funzionamento di AntiSplint (Mill e Saw)	2022-09-15 12:56:02 +02:00
luca.mazzoleni	a217b95c35	Feature/AddPlaningL090: aggiunta gestione feature L090 con parametri Q per antischeggia e forzatura lavorazione di lato	2022-09-09 16:37:46 +02:00
luca.mazzoleni	05aae0b8f3	Merge branch 'Improvement/Ticket#788' into develop	2022-09-08 12:42:51 +02:00
luca.mazzoleni	629dfc1341	Improvement/Ticket#788 : In HeadCut e Split migliorato verso di lavorazione in caso di doubleCut	2022-09-08 11:29:31 +02:00
luca.mazzoleni	e9cb756dc9	Revert "Merge branch 'Improvement/Ticket#788' into develop" This reverts commit `9b888a0a59`, reversing changes made to `7762692597`.	2022-09-08 09:17:16 +02:00
luca.mazzoleni	9b888a0a59	Merge branch 'Improvement/Ticket#788' into develop	2022-09-07 18:32:06 +02:00
luca.mazzoleni	b141a512bb	Improvement/Ticket#788 : in Split migliore scelta del lato di lavorazione in base alla posizione di default della lama	2022-09-07 18:31:51 +02:00
luca.mazzoleni	d13f108dad	Improvement/Ticket#788 : in HeadCut migliore scelta del lato di lavorazione in base alla posizione di default della lama	2022-09-07 14:57:19 +02:00
luca.mazzoleni	7762692597	Merge branch 'Refactoring/MoveSomeFunctionsToBeamLib' into develop	2022-09-01 16:17:51 +02:00