diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua
index cfe4039..88d732d 100644
--- a/LuaLibs/BeamExec.lua
+++ b/LuaLibs/BeamExec.lua
@@ -3,7 +3,9 @@
 -- 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.
 -- 2019/09/25 Aggiunta gestione StepJoint e StepJointNotch
--- 2020/01/21 Aggiunta gestione ScarfJoint.
+-- 2020/01/21 Aggiunta gestione ScarfJoint
+-- 2020/02/10 Aggiunta gestione FrenchRidgeLap
+-- 2020/02/11 Aggiunta gestione BlockHouseFront
 
 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -51,6 +53,10 @@ _G.package.loaded.ProcessChamfer = nil
 local Chamfer = require( 'ProcessChamfer')
 _G.package.loaded.ProcessDrill = nil
 local Drill = require( 'ProcessDrill')
+_G.package.loaded.ProcessFrenchRidgeLap = nil
+local FrenchRidgeLap = require( 'ProcessFrenchRidgeLap')
+_G.package.loaded.ProcessBlockHouseFront = nil
+local BlockHouseFront = require( 'ProcessBlockHouseFront')
 _G.package.loaded.ProcessTenon = nil
 local Tenon = require( 'ProcessTenon')
 _G.package.loaded.ProcessMortise = nil
@@ -224,7 +230,7 @@ local function IsHeadFeature( Proc, b3Raw, dCurrOvmH)
    end
    -- feature sempre di testa o coda nonostante il gruppo
    if ( Proc.Grp == 3 or Proc.Grp == 4) and
-      ( Proc.Prc == 51 or Proc.Prc == 56 or Proc.Prc == 100 or Proc.Prc == 101 or Proc.Prc == 102 or Proc.Prc == 103 or Proc.Prc == 106) then
+      ( Proc.Prc == 38 or Proc.Prc == 51 or Proc.Prc == 56 or Proc.Prc == 100 or Proc.Prc == 101 or Proc.Prc == 102 or Proc.Prc == 103 or Proc.Prc == 106) then
       return ( Proc.Box:getCenter():getX() > b3Raw:getCenter():getX() - 0.5 * dCurrOvmH)
    end
    -- gestioni speciali
@@ -252,7 +258,7 @@ local function IsTailFeature( Proc, b3Raw, dCurrOvmH)
    end
    -- feature sempre di testa o coda nonostante il gruppo
    if ( Proc.Grp == 3 or Proc.Grp == 4) and
-      ( Proc.Prc == 51 or Proc.Prc == 56 or Proc.Prc == 100 or Proc.Prc == 101 or Proc.Prc == 102 or Proc.Prc == 103 or Proc.Prc == 106) then
+      ( Proc.Prc == 38 or Proc.Prc == 51 or Proc.Prc == 56 or Proc.Prc == 100 or Proc.Prc == 101 or Proc.Prc == 102 or Proc.Prc == 103 or Proc.Prc == 106) then
       return ( Proc.Box:getCenter():getX() < b3Raw:getCenter():getX() - 0.5 * dCurrOvmH)
    end
    -- gestioni speciali
@@ -519,6 +525,12 @@ local function ClassifyFeatures( vProc, b3Raw, Stats)
       -- se tenone
       elseif Tenon.Identify( Proc) then
          bOk, bDown = Tenon.Classify( Proc, b3Raw)
+      -- se giunzione francese
+      elseif FrenchRidgeLap.Identify( Proc) then
+         bOk, bDown = FrenchRidgeLap.Classify( Proc)
+      -- se block house front
+      elseif BlockHouseFront.Identify( Proc) then
+         bOk, bDown = BlockHouseFront.Classify( Proc)
       -- se mortasa (anche frontale)
       elseif Mortise.Identify( Proc) then
          bOk, bDown = Mortise.Classify( Proc)
@@ -656,6 +668,7 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, b3
       -- esecuzione mezzo-legno di testa
       bOk, sErr = RidgeLap.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    -- se mezzo-legno ( 3/4-030-X) o scanalatura ( 3/4-016-X) o tacca ( 3/4-020-X)
+   -- o block house ( 4-037-X)
    elseif LapJoint.Identify( Proc) then
       -- esecuzione mezzo-legno o scanalatura
       bOk, sErr = LapJoint.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
@@ -667,6 +680,14 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, b3
    elseif Drill.Identify( Proc) then
       -- esecuzione foratura
       bOk, sErr = Drill.Make( Proc, nPhase, nRawId, nPartId)
+   -- se giunzione francese ( 1/2-035-X)
+   elseif FrenchRidgeLap.Identify( Proc) then
+      -- esecuzione giunzione francese
+      bOk, sErr = FrenchRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+   -- se block house front ( 3/4-038-X)
+   elseif BlockHouseFront.Identify( Proc) then
+      -- esecuzione giunzione francese
+      bOk, sErr = BlockHouseFront.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    -- se tenone ( 1/2-050-X)
    elseif Tenon.Identify( Proc) then
       -- esecuzione tenone
@@ -699,11 +720,11 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, b3
    elseif Scarf.Identify( Proc) then
       -- esecuzione giunto Gerber
       bOk, sErr = Scarf.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-   -- se giunto a gradino
+   -- se giunto a gradino ( 1/2-080-X)
    elseif StepJoint.Identify( Proc) then
       -- esecuzione giunto a gradino
       bOk, sErr = StepJoint.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-   -- se tacca a gradino
+   -- se tacca a gradino ( 3/4-080-X)
    elseif StJoNotch.Identify( Proc) then
       -- esecuzione tacca a gradino
       bOk, sErr = StJoNotch.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
diff --git a/LuaLibs/ProcessBlockHouseFront.lua b/LuaLibs/ProcessBlockHouseFront.lua
new file mode 100644
index 0000000..15ad588
--- /dev/null
+++ b/LuaLibs/ProcessBlockHouseFront.lua
@@ -0,0 +1,303 @@
+-- ProcessBlockHouseFront.lua by Egaltech s.r.l. 2020/02/11
+-- Gestione calcolo giunzione block house in testa
+
+-- Tabella per definizione modulo
+local ProcessBlockHouseFront = {}
+
+-- Include
+require( 'EgtBase')
+local BL  = require( 'BeamLib')
+local DC  = require( 'DiceCut')
+local Cut = require( 'ProcessCut')
+
+EgtOutLog( ' ProcessBlockHouseFront started', 1)
+
+-- Dati
+local BD = require( 'BeamData')
+local ML = require( 'MachiningLib')
+
+---------------------------------------------------------------------
+-- Riconoscimento della feature
+function ProcessBlockHouseFront.Identify( Proc)
+   return (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 38)
+end
+
+---------------------------------------------------------------------
+-- Classificazione della feature
+function ProcessBlockHouseFront.Classify( Proc)
+   -- 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)
+      -- se versore z è preponderante sulle altre componenti del vettore ed è verso il basso, 
+      -- do errore perchè non è ancora gestita la rotazione di 90°
+      -- considerazioni: al momento non è possibile sapere se ci sono due rastremature o una quindi se è rivolta verso il basso
+      -- viene dato errore, altrimenti si porebbe imporre la rotazione di 180 (ovviamente con una sola rastrematura rivolta verso il basso)
+      if abs(vtN:getZ()) > abs(vtN:getX()) and abs(vtN:getZ()) > abs(vtN:getY()) and vtN:getZ() < -0.5 then
+         return false
+      end
+   end
+   return true, false
+end
+
+---------------------------------------------------------------------
+-- Applicazione della lavorazione
+function ProcessBlockHouseFront.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+   -- recupero l'ingombro del grezzo di appartenenza
+   local b3Raw = EgtGetRawPartBBox( nRawId)
+   -- ingombro del pezzo
+   local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
+   local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
+   if not b3Solid then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' part box not found'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- verifico che ci siano almeno due facce (altrimenti non è da lavorare)
+   local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
+   if nFacetCnt < 2 then
+      local sErr = 'Not executed ' .. tostring( Proc.Id) .. ' number of faces not enough'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- dati delle facce
+   local ptC = {}
+   local vtN = {}
+   for i = 1, nFacetCnt do
+      ptC[i], vtN[i] = EgtSurfTmFacetCenter( Proc.Id, i-1, GDB_ID.ROOT)
+   end
+   -- ordino le facce (1=esterna, 2=interna, 3=intermedia)
+   local vFaceOrd = { 0, 0, 0}
+   local dMinZedFace = 1
+   for i = 1, nFacetCnt do
+      if abs( vtN[i]:getX()) < dMinZedFace then
+         dMinZedFace = abs( vtN[i]:getX())
+         vFaceOrd[3] = i
+      end
+   end
+   if vFaceOrd[3] == 0 then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' missing intermediate face'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   for i = 1, nFacetCnt do
+      if i ~= vFaceOrd[3] then
+         local bTouch, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, i - 1, vFaceOrd[3] - 1, GDB_ID.ROOT)
+         if bTouch and dAng > 0 then
+            vFaceOrd[1] = i
+         elseif bTouch and dAng < 0 then
+            vFaceOrd[2] = i
+         end
+      end
+   end
+   -- determino se di testa o di coda
+   local bHead
+   if vtN[vFaceOrd[2]] then
+      bHead = ( vtN[vFaceOrd[2]]:getX() > 0)
+   else
+      bHead = ( vtN[vFaceOrd[1]]:getX() > 0)
+   end
+   -- vettore di riferimento per le facce ortogonali all'asse trave
+   local vtRef = Vector3d( 0, vtN[vFaceOrd[3]]:getY(), vtN[vFaceOrd[3]]:getZ())
+   vtRef:normalize()
+   -- recupero la lavorazione
+   local sCutting = ML.FindCutting( 'HeadSide')
+   if not sCutting then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' cutting not found in library'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- recupero i dati dell'utensile
+   local dSawDiam = 400
+   local dToolThick = 0
+   if EgtMdbSetCurrMachining( sCutting) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
+         dToolThick = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dToolThick
+      end
+   end
+   -- recupero la geometria opzionale
+   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
+   if AuxId then AuxId = AuxId + Proc.Id end
+  -- recupero gruppo per geometria addizionale
+   local nAddGrpId = BL.GetAddGroup( nPartId)
+   if not nAddGrpId then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' missing AddGroup'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- cerco se nelle note del layer c'è già la nota che indica che l'aux è già stato lavorato
+   local bAuxMachined = EgtGetInfo( nAddGrpId, 'AuxId', 'b')
+   -- taglio sulla faccia esterna
+   if AuxId and not bAuxMachined then
+      -- in generale va fatto
+      local bCut = true
+      local ptCAux, vtNAux = EgtSurfTmFacetCenter( AuxId, 0, GDB_ID.ROOT)
+      -- se di testa e coincide con inizio grezzo, non va fatto
+      if bHead and AreSameVectorApprox( vtNAux, X_AX()) and abs( ptCAux: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( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+         bCut = false
+      end
+      -- se va fatto, inserisco la lavorazione
+      if bCut then
+         local CutProc = { Id = AuxId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg, Head = Proc.Head, Tail = Proc.Tail}
+         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, 0)
+         -- se taglio applicato setto la nota al gruppo Mach per non doverla lavorare una seconda volta
+         if bOk then
+            bAuxMachined = true
+            EgtSetInfo( nAddGrpId, 'AuxId', true)
+         else
+            return bOk, sErr 
+         end
+      end
+   end
+   -- calcolo da distanza di arretramento della lama per non incidere nelle superfici di arrivo dei tagli
+   local dTrim = ((dToolThick* vtN[vFaceOrd[3]]) * vtN[vFaceOrd[2]] * vtN[vFaceOrd[2]]):len()
+   local dFinalExtraTrim = 0.1
+   local dMiddleExtraTrim = 0.3
+   local dNullExtraTrim = 0
+   -- 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( EgtGetParent( Proc.Id), b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], false, ptC[vFaceOrd[2]], vtN[vFaceOrd[2]])
+   elseif vFaceOrd[3] ~= 0 then
+      vCuts = DC.GetDice( EgtGetParent( Proc.Id), 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
+            EgtRelocateGlob( vCuts[i][j], nAddGrpId)
+            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
+         local dExtraTrim = 0
+         -- lavoro la faccia
+         for j = 1, #vCuts[i] do
+            -- se ultimo taglio del penultimo gruppo o ultimo taglio dell'ultimo gruppo
+            -- cioè non i tagli intermedi, aggiungo extratrim minimo
+            if ( ( i == (#vCuts-1)) or ( i == #vCuts)) and j == #vCuts[i] then 
+               dExtraTrim = dFinalExtraTrim 
+            -- se tagli non a contatto con le facce o tagli paralleli setto nessun extratrim
+            elseif i < (#vCuts-1) or (i == #vCuts) then 
+               dExtraTrim = dNullExtraTrim
+            -- altrimenti tagli ortogonali a contatto con la faccia aggiungo extratrim
+            else
+               dExtraTrim = dMiddleExtraTrim
+            end
+            local bOk, sErr = BL.MakeOneFaceBySaw( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, nil, -(dTrim+dExtraTrim), BD.CUT_SIC, 0, 0, nil, b3Raw)
+            if not bOk then
+               return bOk, sErr
+            end
+         end
+      end
+   else
+      -- taglio sulla faccia esterna
+      if AuxId and not bAuxMachined then
+         -- in generale va fatto
+         local bCut = true
+         local ptCAux, vtNAux = EgtSurfTmFacetCenter( AuxId, 0, GDB_ID.ROOT)
+         -- se di testa e coincide con inizio grezzo, non va fatto
+         if bHead and AreSameVectorApprox( vtNAux, X_AX()) and abs( ptCAux: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( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+            bCut = false
+         end
+         -- se va fatto, inserisco la lavorazione
+         if bCut then
+            local CutProc = { Id = AuxId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg, Head = Proc.Head, Tail = Proc.Tail}
+            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, 0)
+            -- se taglio applicato setto la nota al gruppo Mach per non doverla lavorare una seconda volta
+            if bOk then
+               bAuxMachined = true
+               EgtSetInfo( nAddGrpId, 'AuxId', true)
+            else
+               return bOk, sErr 
+            end
+         end
+      end
+      -- taglio sulla faccia interna
+      local bIntCut = false
+      if vFaceOrd[2] ~= 0 then
+         -- inserisco la lavorazione
+         local nOrthoOpposite = BL.GetNearestOrthoOpposite( vtRef)
+         local bOk, sNameOrErr = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[2] - 1, sCutting, dSawDiam, nOrthoOpposite, nil, -(dTrim + dFinalExtraTrim), BD.CUT_SIC, 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 = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtRef2, nil, -(dTrim + dFinalExtraTrim), BD.CUT_SIC, 0, 0, nil, b3Raw)
+         if not bOk then return bOk, sErr end
+      end
+   end
+
+   -- aggiornamento ingombro di testa o coda
+   if Proc.Head then
+      local dHCI = 00
+      -- se la feature è orientata sopra o sotto, la componente Z (del versore della faccia intermedia) è preponderante sulle altre 2
+      if ( abs( vtN[vFaceOrd[3]]:getZ()) > abs( vtN[vFaceOrd[3]]:getX())) and ( abs( vtN[vFaceOrd[3]]:getZ()) > abs( vtN[vFaceOrd[3]]:getY())) then
+         local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
+         if b3Fac1 then dHCI = b3Raw:getMax():getX() - dOvmHead - b3Fac1:getMin():getX() end
+      -- altrimenti di fianco
+      else
+         dHCI = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX()
+      end
+      BL.UpdateHCING( nRawId, dHCI)
+   elseif Proc.Tail then
+      local dTCI = 0
+      -- se la feature è orientata sopra o sotto, la componente Z (del versore della faccia intermedia) è preponderante sulle altre 2
+      if ( abs( vtN[vFaceOrd[3]]:getZ()) > abs( vtN[vFaceOrd[3]]:getX())) and ( abs( vtN[vFaceOrd[3]]:getZ()) > abs( vtN[vFaceOrd[3]]:getY())) then
+         local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
+         if b3Fac1 then dTCI = b3Fac1:getMax():getX() - b3Solid:getMin():getX() end
+      -- altrimenti di fianco
+      else
+         dTCI = Proc.Box:getMax():getX() - b3Solid:getMin():getX()
+      end
+      BL.UpdateTCING( nRawId, dTCI)
+   end
+   return true
+end   
+
+---------------------------------------------------------------------
+return ProcessBlockHouseFront
diff --git a/LuaLibs/ProcessChamfer.lua b/LuaLibs/ProcessChamfer.lua
index a36d7a2..06e76e4 100644
--- a/LuaLibs/ProcessChamfer.lua
+++ b/LuaLibs/ProcessChamfer.lua
@@ -1,4 +1,4 @@
--- ProcessChamfer.lua by Egaltech s.r.l. 2018/04/12
+-- ProcessChamfer.lua by Egaltech s.r.l. 2020/02/11
 -- Gestione calcolo profilo libero per Travi
 
 -- Tabella per definizione modulo
@@ -23,6 +23,9 @@ end
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessChamfer.Make( Proc, nPhase, nRawId, nPartId)
+   -- verifico se ha geometria ausiliaria (onde)
+   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
+   if AuxId then AuxId = AuxId + Proc.Id end
    -- recupero la lavorazione
    local sMilling = ML.FindMilling( 'Chamfer')
    if not sMilling then
@@ -38,8 +41,92 @@ function ProcessChamfer.Make( Proc, nPhase, nRawId, nPartId)
       EgtOutLog( sErr)
       return false, sErr
    end
-   -- aggiungo geometria
-   EgtSetMachiningGeometry( {{ Proc.Id, 0}})
+   -- recupero i dati dell'utensile
+   local dMillDiam = 10
+   local dMaxMat = 20
+   if EgtMdbSetCurrMachining( sMilling) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
+         dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxMat
+      end
+   end
+   -- se onde
+   if AuxId then
+      -- impongo lavorazione dall'alto
+      local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
+      if vtExtr:getZ() < 0 then
+         EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+         EgtSetMachiningParam( MCH_MP.INVERT, true)
+      end
+      -- lavoro tenendo l'utensile a sinistra
+      EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+      -- imposto lavorazione a metà tagliente e senza step
+      EgtSetMachiningParam( MCH_MP.DEPTH, dMaxMat / 2)
+      EgtSetMachiningParam( MCH_MP.STEP, 0)
+      -- imposto attacchi e uscite
+      EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0)
+      EgtSetMachiningParam( MCH_MP.LIPERP, 3)
+      EgtSetMachiningParam( MCH_MP.LITANG, 6)
+      EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.TANGENT)
+      EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
+      EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.AS_LI)
+      -- aggiungo geometria
+      EgtSetMachiningGeometry( {{ AuxId, -1}})
+   -- altrimenti smusso standard
+   else
+      -- normale ed elevazione della faccia principale
+      local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
+      local _, dElev = BL.GetPointDirDepth( nPartId, ptC, vtN)
+      -- limitazioni su inizio e fine derivanti da altre facce 
+      local bLimXmin = false
+      local bLimXmax = false
+      if Proc.Fct >= 3 then
+         bLimXmin = true
+         bLimXmax = true
+      elseif Proc.Fct >= 2 then
+         local ptC1, vtN1 = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT)
+         if vtN1:getX() > 0 then
+            bLimXmin = true
+         else
+            bLimXmax = true
+         end
+      end
+      -- calcolo eventuali accorciamenti per facce limitanti
+      local dAllExtr
+      if dElev < dMillDiam / 2 then
+         dAllExtr = -sqrt( dMillDiam * dElev - dElev * dElev)
+      else
+         dAllExtr = -dMillDiam / 2
+      end
+      local dStartAll = 0
+      local dEndAll = 0
+      if vtN:getY() < 0 then
+         if bLimXmax then dStartAll = dAllExtr end
+         if bLimXmin then dEndAll = dAllExtr end
+      else
+         if bLimXmax then dEndAll = dAllExtr end
+         if bLimXmin then dStartAll = dAllExtr end
+      end
+      -- lavoro tenendo l'utensile a sinistra
+      EgtSetMachiningParam( MCH_MP.INVERT, true)
+      EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+      -- imposto lavorazione un poco sotto
+      local sDepth = 'TH+'..EgtNumToString( BD.CUT_EXTRA)
+      EgtSetMachiningParam( MCH_MP.DEPTH_STR, sDepth)
+      EgtSetMachiningParam( MCH_MP.STEP, 0)
+      -- imposto utilizzo faccia
+      EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN)
+      -- imposto attacchi e uscite
+      EgtSetMachiningParam( MCH_MP.STARTADDLEN, dStartAll)
+      EgtSetMachiningParam( MCH_MP.LIPERP, dMillDiam / 4)
+      EgtSetMachiningParam( MCH_MP.LITANG, 0)
+      EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
+      EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEndAll)
+      EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.AS_LI)
+      -- aggiungo geometria
+      EgtSetMachiningGeometry( {{ Proc.Id, 0}})
+   end
    -- eseguo
    if not EgtApplyMachining( true, false) then
       local _, sErr = EgtGetLastMachMgrError()
diff --git a/LuaLibs/ProcessCut.lua b/LuaLibs/ProcessCut.lua
index 9295303..a2b2085 100644
--- a/LuaLibs/ProcessCut.lua
+++ b/LuaLibs/ProcessCut.lua
@@ -144,7 +144,7 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom)
                      vtNewOrthoO = -vtOrthoO
                      dVzLimDwnUp = -0.707
                   end
-                  local bOk, sErr = BL.MakeOneFaceBySaw( vCuts[i][j], 0, sCutting, dSawDiam, vtNewOrthoO, dVzLimDwnUp, 0.1, BD.CUT_SIC, 0, 0, nil, b3Raw)
+                  local bOk, sErr = BL.MakeOneFaceBySaw( vCuts[i][j], 0, sCutting, dSawDiam, vtNewOrthoO, dVzLimDwnUp, BD.CUT_EXTRA_MIN, BD.CUT_SIC, 0, 0, nil, b3Raw)
                   if not bOk then
                      return bOk, sErr
                   end
diff --git a/LuaLibs/ProcessDrill.lua b/LuaLibs/ProcessDrill.lua
index 3b1f4f1..f858f8a 100644
--- a/LuaLibs/ProcessDrill.lua
+++ b/LuaLibs/ProcessDrill.lua
@@ -1,4 +1,4 @@
--- ProcessDrill.lua by Egaltech s.r.l. 2019/10/28
+-- ProcessDrill.lua by Egaltech s.r.l. 2020/02/11
 -- Gestione calcolo forature per Travi
 
 -- Tabella per definizione modulo
@@ -97,7 +97,7 @@ function ProcessDrill.Classify( Proc, b3Raw)
       ptCen = ptCen + vtExtr * dLen
    end
    -- verifico se troppo inclinato e quindi non lavorabile
-   if not ( Proc.Fcs == 5 or Proc.Fcs == 6) and abs( vtExtr:getX()) > COS_SLANT_LIM then
+   if not ( Proc.Fcs == 5 or Proc.Fcs == 6 or Proc.Fce == 5 or Proc.Fce == 6) and abs( vtExtr:getX()) > COS_SLANT_LIM then
       return false, false
    end
    local bOpen = ( Proc.Fce ~= 0)
@@ -123,7 +123,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
    local dLen = abs( EgtCurveThickness( AuxId))
    local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
    if Proc.Flg == -2 then vtExtr = - vtExtr end
-   local bOpen = ( Proc.Fcs ~= 0  and  Proc.Fce  ~= 0)
+   local bOpen = ( Proc.Fcs ~= 0  and  Proc.Fce ~= 0)
    -- verifico che il foro non sia fattibile solo da sotto
    local bToInvert = ( vtExtr:getZ() < BD.DRILL_VZ_MIN)
    if bToInvert  and  ( not bOpen or Proc.Flg ~= 1) then
@@ -131,6 +131,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
       EgtOutLog( sErr)
       return false, sErr
    end
+   if Proc.Fcs == 0 then bToInvert = true end
    if bToInvert then vtExtr = - vtExtr end
    if Proc.Flg == -2 then bToInvert = true end
    -- recupero la lavorazione
@@ -154,7 +155,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
       end
    end
    -- se foro intermedio e inclinato, limito il massimo affondamento
-   if not ( Proc.Fcs == 5 or Proc.Fcs == 6) then
+   if not ( ( Proc.Fcs == 5 or Proc.Fcs == 6) or ( bToInvert and ( Proc.Fce == 5 or Proc.Fce == 6))) then
       local CosB = abs( vtExtr:getX())
       if CosB < COS_SLANT_LIM then
          local TgA = CosB / sqrt( 1 - CosB * CosB)
diff --git a/LuaLibs/ProcessFrenchRidgeLap.lua b/LuaLibs/ProcessFrenchRidgeLap.lua
new file mode 100644
index 0000000..824d3cc
--- /dev/null
+++ b/LuaLibs/ProcessFrenchRidgeLap.lua
@@ -0,0 +1,278 @@
+-- ProcessFrenchRidgeLap.lua by Egaltech s.r.l. 2020/02/11
+-- Gestione calcolo giunzione francese
+
+-- Tabella per definizione modulo
+local ProcessFrenchRidgeLap = {}
+
+-- Include
+require( 'EgtBase')
+local BL = require( 'BeamLib')
+local DC = require( 'DiceCut')
+
+EgtOutLog( ' ProcessFrenchRidgeLap started', 1)
+
+-- Dati
+local BD = require( 'BeamData')
+local ML = require( 'MachiningLib')
+
+---------------------------------------------------------------------
+-- Riconoscimento della feature
+function ProcessFrenchRidgeLap.Identify( Proc)
+   return (( Proc.Grp == 1 or Proc.Grp == 2)  and  Proc.Prc == 35)
+end
+
+---------------------------------------------------------------------
+-- Classificazione della feature
+function ProcessFrenchRidgeLap.Classify( Proc)
+   -- 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
+         return true, true
+      end
+   end
+   return true, false
+end
+
+---------------------------------------------------------------------
+-- Applicazione della lavorazione
+function ProcessFrenchRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+   -- recupero l'ingombro del grezzo di appartenenza
+   local b3Raw = EgtGetRawPartBBox( nRawId)
+   -- ingombro del pezzo
+   local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
+   local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
+   if not b3Solid then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' part box not found'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- verifico che ci siano almeno due facce (altrimenti non è da lavorare)
+   local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
+   if nFacetCnt < 2 then
+      local sErr = 'Not executed ' .. tostring( Proc.Id) .. ' number of faces not enough'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- dati delle facce
+   local ptC = {}
+   local vtN = {}
+   for i = 1, nFacetCnt do
+      ptC[i], vtN[i] = EgtSurfTmFacetCenter( Proc.Id, i-1, GDB_ID.ROOT)
+   end
+   -- ordino le facce (1=esterna, 2=interna, 3=intermedia)
+   local vFaceOrd = { 0, 0, 0}
+   for i = 1, nFacetCnt do
+      if abs( vtN[i]:getX()) > GEO.EPS_SMALL and abs( vtN[i]:getY()) > GEO.EPS_SMALL and abs( vtN[i]:getZ()) > GEO.EPS_SMALL then
+         vFaceOrd[3] = i
+         break
+      end
+   end
+   if vFaceOrd[3] == 0 then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' missing intermediate face'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   for i = 1, nFacetCnt do
+      if i ~= vFaceOrd[3] then
+         local bTouch, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, i - 1, vFaceOrd[3] - 1, GDB_ID.ROOT)
+         if bTouch and dAng > 0 then
+            vFaceOrd[1] = i
+         elseif bTouch and dAng < 0 then
+            vFaceOrd[2] = i
+         end
+      end
+   end
+   -- determino se di testa o di coda
+   local bHead
+   if vtN[vFaceOrd[2]] then
+      bHead = ( vtN[vFaceOrd[2]]:getX() > 0)
+   else
+      bHead = ( vtN[vFaceOrd[1]]:getX() > 0)
+   end
+   -- vettore di riferimento per le facce ortogonali all'asse trave
+   local vtRef = Vector3d( 0, vtN[vFaceOrd[3]]:getY(), vtN[vFaceOrd[3]]:getZ())
+   vtRef:normalize()
+   -- recupero la lavorazione
+   local sCutting = ML.FindCutting( 'HeadSide')
+   if not sCutting then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' cutting not found in library'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- recupero i dati dell'utensile
+   local dSawDiam = 400
+   local dToolThick = 0
+   if EgtMdbSetCurrMachining( sCutting) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
+         dToolThick = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dToolThick
+      end
+   end
+   -- calcolo da distanza di arretramento della lama per non incidere nelle superfici di arrivo dei tagli
+   local dTrim = ((dToolThick* vtN[vFaceOrd[3]]) * vtN[vFaceOrd[2]] * vtN[vFaceOrd[2]]):len()
+   local dFinalExtraTrim = 0.1
+   local dMiddleExtraTrim = 0.3
+   local dNullExtraTrim = 0
+   -- 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( EgtGetParent( Proc.Id), b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], false, ptC[vFaceOrd[2]], vtN[vFaceOrd[2]])
+   elseif vFaceOrd[3] ~= 0 then
+      vCuts = DC.GetDice( EgtGetParent( Proc.Id), b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], true)
+   end
+   if #vCuts > 0 then
+      -- recupero gruppo per geometria addizionale
+      local nAddGrpId = BL.GetAddGroup( nPartId)
+      if not nAddGrpId then
+         local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' missing AddGroup'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- sistemo posizione nel DB e nome
+      for i = 1, #vCuts do
+         for j = 1, #vCuts[i] do
+            EgtRelocateGlob( vCuts[i][j], nAddGrpId)
+            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
+         local dExtraTrim = 0
+         -- lavoro la faccia
+         for j = 1, #vCuts[i] do
+            -- se ultimo taglio del penultimo gruppo o ultimo taglio dell'ultimo gruppo
+            -- cioè non i tagli intermedi, aggiungo extratrim minimo
+            if ( ( i == (#vCuts-1)) or ( i == #vCuts)) and j == #vCuts[i] then 
+               dExtraTrim = dFinalExtraTrim 
+            -- se tagli non a contatto con le facce o tagli paralleli setto nessun extratrim
+            elseif i < (#vCuts-1) or (i == #vCuts) then 
+               dExtraTrim = dNullExtraTrim
+            -- altrimenti tagli ortogonali a contatto con la faccia aggiungo extratrim
+            else
+               dExtraTrim = dMiddleExtraTrim
+            end
+            local bOk, sErr = BL.MakeOneFaceBySaw( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, nil, -(dTrim+dExtraTrim), BD.CUT_SIC, 0, 0, nil, b3Raw)
+            if not bOk then
+               return bOk, sErr
+            end
+         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()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+            bCut = false
+         end
+         -- se va fatto, inserisco la lavorazione
+         if bCut then
+            local vtOrthoO = Vector3d( vtRef)
+            local bOk, sNameOrErr = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, nil, b3Raw)
+            if not bOk then return bOk, sNameOrErr end
+         end
+      end
+   else
+      -- 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()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+            bCut = false
+         end
+         -- se va fatto, inserisco la lavorazione
+         if bCut then
+            local vtOrthoO = Vector3d( vtRef)
+            local bOk, sNameOrErr = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, nil, b3Raw)
+            if not bOk then return bOk, sNameOrErr end
+         end
+      end
+      -- taglio sulla faccia interna
+      local bIntCut = false
+      if vFaceOrd[2] ~= 0 then
+         -- inserisco la lavorazione
+         local nOrthoOpposite = BL.GetNearestOrthoOpposite( vtRef)
+         local bOk, sNameOrErr = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[2] - 1, sCutting, dSawDiam, nOrthoOpposite, nil, -(dTrim + dFinalExtraTrim), BD.CUT_SIC, 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 = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtRef2, nil, -(dTrim + dFinalExtraTrim), BD.CUT_SIC, 0, 0, nil, b3Raw)
+         if not bOk then return bOk, sErr end
+      end
+   end
+
+   -- aggiornamento ingombro di testa o coda
+   if Proc.Head then
+      local dHCI = 00
+      -- se la feature è orientata sopra o sotto, la componente Z (del versore della faccia intermedia) è preponderante sulle altre 2
+      if ( abs( vtN[vFaceOrd[3]]:getZ()) > abs( vtN[vFaceOrd[3]]:getX())) and ( abs( vtN[vFaceOrd[3]]:getZ()) > abs( vtN[vFaceOrd[3]]:getY())) then
+         local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
+         if b3Fac1 then dHCI = b3Raw:getMax():getX() - dOvmHead - b3Fac1:getMin():getX() end
+      -- altrimenti di fianco
+      else
+         dHCI = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX()
+      end
+      BL.UpdateHCING( nRawId, dHCI)
+   elseif Proc.Tail then
+      local dTCI = 0
+      -- se la feature è orientata sopra o sotto, la componente Z (del versore della faccia intermedia) è preponderante sulle altre 2
+      if ( abs( vtN[vFaceOrd[3]]:getZ()) > abs( vtN[vFaceOrd[3]]:getX())) and ( abs( vtN[vFaceOrd[3]]:getZ()) > abs( vtN[vFaceOrd[3]]:getY())) then
+         local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
+         if b3Fac1 then dTCI = b3Fac1:getMax():getX() - b3Solid:getMin():getX() end
+      -- altrimenti di fianco
+      else
+         dTCI = Proc.Box:getMax():getX() - b3Solid:getMin():getX()
+      end
+      BL.UpdateTCING( nRawId, dTCI)
+   end
+   return true
+end   
+
+---------------------------------------------------------------------
+return ProcessFrenchRidgeLap
diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua
index 2b2f330..d1f4d75 100644
--- a/LuaLibs/ProcessLapJoint.lua
+++ b/LuaLibs/ProcessLapJoint.lua
@@ -1,4 +1,4 @@
--- ProcessLapJoint.lua by Egaltech s.r.l. 2020/02/05
+-- ProcessLapJoint.lua by Egaltech s.r.l. 2020/02/10
 -- Gestione calcolo mezzo-legno per Travi
 -- 2019/10/08 Agg. gestione OpenPocket.
 
@@ -605,7 +605,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac,
       end
    end
    -- Se entrambi gli estremi sono aperti e possibile, lavoro con la lama
-   if bOpenStart and bOpenEnd and dElev < dSawMaxDepth then
+   if bOpenStart and bOpenEnd and dElev < dSawMaxDepth + 10 * GEO.EPS_SMALL then
       -- Recupero la lavorazione di lama
       local sCutting = ML.FindCutting( 'HeadSide')
       if not sCutting then
diff --git a/LuaLibs/ProcessMortise.lua b/LuaLibs/ProcessMortise.lua
index e409975..a1825d6 100644
--- a/LuaLibs/ProcessMortise.lua
+++ b/LuaLibs/ProcessMortise.lua
@@ -1,4 +1,4 @@
--- ProcessMortise.lua by Egaltech s.r.l. 2019/11/10
+-- ProcessMortise.lua by Egaltech s.r.l. 2020/01/29
 -- Gestione calcolo mortase per Travi
 
 -- Tabella per definizione modulo
diff --git a/LuaLibs/ProcessStepJointNotch.lua b/LuaLibs/ProcessStepJointNotch.lua
index cf5f914..d1900fd 100644
--- a/LuaLibs/ProcessStepJointNotch.lua
+++ b/LuaLibs/ProcessStepJointNotch.lua
@@ -1,4 +1,4 @@
--- ProcessStepJointNotch.lua by Egaltech s.r.l. 2019/10/23
+-- ProcessStepJointNotch.lua by Egaltech s.r.l. 2020/02/11
 -- Gestione calcolo tacca a gradino per Travi
 
 -- Tabella per definizione modulo
@@ -270,6 +270,9 @@ end
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessStepJointNotch.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+   -- esecuzione eventuale smusso
+   local bOkc, sErrC = MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
+   if not bOkc then return bOkc, sErrC end
    -- se due facce
    if Proc.Fct == 2 then
       local bOk, sErr = MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
@@ -284,8 +287,7 @@ function ProcessStepJointNotch.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
       EgtOutLog( sErr)
       return false, sErr
    end
-   -- esecuzione eventuale smusso
-   return MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
+   return true
 end
 
 ---------------------------------------------------------------------