Merge branch 'develop' into BugFix/ProcessLapJointThreeFacesLOpenPocket

2022-08-26 12:44:09 +02:00 · 2022-08-23 08:54:45 +02:00 · 2022-08-12 09:58:54 +02:00 · 2022-08-12 09:34:38 +02:00 · 2022-08-09 10:28:00 +02:00 · 2022-07-29 10:07:59 +02:00
24 changed files with 628 additions and 1645 deletions
@@ -2,8 +2,9 @@ variables:
 VERS_MAIN: '1.0'
 APP_NAME: 'Beam'
 NEW_REL: ''
- NET_SHARE_R: '\\10.74.82.201\EgwTech'
- NET_SHARE_Z: '\\10.74.82.201\Artifacts'
+ 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_USERQ: 'steamw\egalware'

 #Note compilazione LUA:
@@ -41,4 +41,4 @@ GWD.OVM_MID = BD.OVM_MID
 -- Tutto ok
 GWD.ERR = 0

-EgtOutLog( ' +++ GetBeamData completed')
+EgtOutLog( ' +++ GetWallData completed')
@@ -1,4 +1,4 @@
-- BeamExec.lua by Egaltech s.r.l. 2022/09/28
+-- BeamExec.lua by Egaltech s.r.l. 2022/08/18
 -- 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,9 +35,6 @@
 -- 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 = {}
@@ -261,9 +258,6 @@ 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
@@ -276,12 +270,6 @@ 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)
@@ -323,8 +311,6 @@ 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
@@ -655,7 +641,7 @@ end
 local function OrderFeatures( vProc, b3Raw)

   local dDrillPenalty = EgtIf( BD.PRESS_ROLLER, 200, 100)
-   local dSmallDrillRange = EgtIf( b3Raw:getDimX() < BD.LEN_SHORT_PART, BD.DRILL_RANGE_SP or 200, BD.DRILL_RANGE or 600)
+   local dSmallDrillRange = EgtIf( b3Raw:getDimX() < BD.LEN_SHORT_PART, 200, 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)
@@ -684,16 +670,6 @@ 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
@@ -1262,7 +1238,7 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bN
      EgtOutLog( sErr)
      bOk = false
   end
-   return bOk, sErr, ( nNewPhase or -1)
+   return bOk, sErr, nNewPhase
 end

 -------------------------------------------------------------------------------------------------------------
@@ -1369,108 +1345,6 @@ 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)
@@ -1565,11 +1439,6 @@ 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
@@ -16,7 +16,6 @@
 -- 2022/07/12 A GetFaceHvRefDim aggiunta possibilità di confronto e limitazione dimensioni con grezzo/pezzo (conta solo la sezione).
 -- 2022/07/26 Aggiunta la funzione FindFaceBestOrientedAsAxis, precedentemente in ProcessLapJoint
 -- 2022/07/26 Alla funzione FindFaceBestOrientedAsAxis aggiunta la possibilità di escludere una faccia dalla ricerca
-- 2022/09/01 Aggiunte le funzioni GetTunnelDimension, CalcCollisionSafety, SetOpenSide, precedentemente in ProcessLapJoint.

 -- Tabella per definizione modulo
 local BeamLib = {}
@@ -308,7 +307,7 @@ function BeamLib.GetNearestOrthoOpposite( vtRef, vtNorm)
      vtMyRef:normalize()
   end
   -- se prevalente una componente orizzontale (con piccolissimo vantaggio)
-   if abs( vtMyRef:getX()) > 0.91 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.91 * abs( vtMyRef:getZ()) then
+   if abs( vtMyRef:getX()) > 0.95 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.95 * 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,10 +702,8 @@ end

 -------------------------------------------------------------------------------------------------------------
 function BeamLib.GetNzLimDownUp( b3Raw, vtN, vtOrtho)
-   if BD.C_SIMM then
+   if BD.C_SIMM or BD.TURN 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°
@@ -817,237 +814,5 @@ function BeamLib.FindFaceBestOrientedAsAxis( Proc, vtAx, fctExclude)
   return nFaceIndMax, ptC, vtN
 end

---------------------------------------------------------------------
-function BeamLib.GetTunnelDimension( Proc, nPartId)
-   -- sono necessarie almeno due facce
-   if Proc.Fct < 2 then return 0, 0, 0 end
-   -- recupero l'ingombro della trave
-   local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
-   -- recupero centro e normale delle facce
-   local ptC = {}
-   local vtN = {}
-   for i = 1, Proc.Fct do
-      ptC[i], vtN[i] = EgtSurfTmFacetCenter( Proc.Id, i - 1, GDB_ID.ROOT)
-   end
-   -- calcolo l'orientamento del tunnel
-   local vtOrtho
-   local bAdj = EgtSurfTmFacetsContact( Proc.Id, 0, 1)
-   if bAdj then
-      vtOrtho = vtN[1] ^ vtN[2]
-   else
-      if Proc.Fct >= 3 then
-         vtOrtho = vtN[1] ^ vtN[3]
-      else
-         return 0, 0, 0
-      end
-   end
-   -- ottengo il boundingBox e prendo le dimensioni lungo la direzione (Z locale) che rappresenta la profondità della fessura
-   local frFc = Frame3d( ptC[1], vtOrtho) ;
-   local b3BoxLoc = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, frFc)
-   local dDepth = b3BoxLoc:getDimZ()
-   -- recupero gruppo per geometria addizionale
-   local nAddGrpId = BeamLib.GetAddGroup( nPartId)
-   if not nAddGrpId then
-      EgtOutLog( 'Error : missing AddGroup')
-      return 0, 0, 0
-   end
-   -- centro del bounding box locale
-   local ptCen = b3BoxLoc:getCenter()
-   ptCen:toGlob( frFc)
-   -- creo superficie intermedia
-   local nSurfInt = EgtSurfTmPlaneInBBox( nAddGrpId, ptCen, vtOrtho, b3Solid, GDB_ID.ROOT)
-   if not nSurfInt then return 0, 0, 0 end
-   -- ritaglio la superficie con le facce della fessura
-   for i = 1, Proc.Fct do
-      EgtCutSurfTmPlane( nSurfInt, ptC[i], -vtN[i], false, GDB_ID.ROOT)
-   end
-   local frSurfInt, dDimMax, dDimMin = EgtSurfTmFacetMinAreaRectangle( nSurfInt, 0, GDB_ID.ROOT)
-   -- cerco la faccia con larghezza pari a dimensione massima della fessura
-   local nLongIdFace = 0
-   for i = 1, Proc.Fct do
-      if abs( vtN[i] * frSurfInt:getVersX()) < 0.5 then
-         nLongIdFace = i - 1
-         break
-      end
-   end
-   return dDimMin, dDimMax, dDepth, vtOrtho, nLongIdFace, nSurfInt
-end
-
---------------------------------------------------------------------
-function BeamLib.CalcCollisionSafety( vtDir)
-   local dCollSic = 10 * BD.COLL_SIC
-   if abs( vtDir:getX()) > 0.999 or abs( vtDir:getY()) > 0.999 or abs( vtDir:getZ()) > 0.999 then
-      dCollSic = 0
-   elseif abs( vtDir:getX()) > 0.996 or abs( vtDir:getY()) > 0.996 or abs( vtDir:getZ()) > 0.996 then
-      dCollSic = 1 * BD.COLL_SIC
-   elseif abs( vtDir:getX()) > 0.89 or abs( vtDir:getY()) > 0.89 or abs( vtDir:getZ()) > 0.89 then
-      dCollSic = 2.5 * BD.COLL_SIC
-   elseif abs( vtDir:getX()) > 0.86 or abs( vtDir:getY()) > 0.86 or abs( vtDir:getZ()) > 0.86 then
-      dCollSic = 4 * BD.COLL_SIC
-   elseif abs( vtDir:getX()) > 0.707 or abs( vtDir:getY()) > 0.707 or abs( vtDir:getZ()) > 0.707 then
-      dCollSic = 5.5 * BD.COLL_SIC
-   end
-   return dCollSic
-end
-
---------------------------------------------------------------------
-function BeamLib.SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId, nStartPoint)
-
-   -- fondo tra loro le curve compatibili
-   EgtMergeCurvesInCurveCompo( nPathInt)
-   local nStartIdEnt, nNumEnt = EgtCurveDomain( nPathInt) 
-   local pLastPIni, pLastPEnd
-
-   -- faccio una copia della curva e la esplodo
-   if nStartIdEnt then
-      -- prendo i punti 
-      for i = 1, nNumEnt do
-         local pPini = EgtUP( nPathInt, (i-1), GDB_RT.GLOB) 
-         local pPend = EgtUP( nPathInt, EgtIf( i == nNumEnt, 0, i), GDB_RT.GLOB)
-         -- Se normale lungo la Z considero il box in X e Y
-         if abs(vtOrtho:getZ()) > 0.999 then
-            -- se corrisponde a X
-            if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or
-               ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) then
-               -- setto l'entità open
-               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
-               if #sActInfo > 0 then
-                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
-               else
-                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
-               end
-               -- prendo i punti per eventuale modifica del punto di inizio percorso
-               pLastPIni = pPini
-               pLastPEnd = pPend
-            -- altrimenti se corrisponde a Y
-            elseif ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
-                   ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then
-               -- setto l'entità open
-               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
-               if #sActInfo > 0 then
-                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
-               else
-                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
-               end
-               -- prendo i punti per eventuale modifica del punto di inizio percorso
-               pLastPIni = pPini
-               pLastPEnd = pPend
-            end
-         -- altrimenti se normale lungo la Y considero il box in X e Z
-         elseif abs(vtOrtho:getZ()) < 0.001 and abs(vtOrtho:getY()) > 0.999 then 
-            -- se corrisponde a X
-            if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or
-               ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) then
-               -- setto l'entità open
-               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
-               if #sActInfo > 0 then
-                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
-               else
-                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
-               end
-               -- prendo i punti per eventuale modifica del punto di inizio percorso
-               pLastPIni = pPini
-               pLastPEnd = pPend
-            -- altrimenti se corrisponde a Z
-            elseif ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
-                   ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
-               -- setto l'entità open
-               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
-               if #sActInfo > 0 then
-                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
-               else
-                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
-               end
-               -- prendo i punti per eventuale modifica del punto di inizio percorso
-               pLastPIni = pPini
-               pLastPEnd = pPend
-            end
-         -- caso che non dovrebbe mai capitare ma gestito per completezza
-         -- altrimenti se normale lungo la X considero il box in Y e Z 
-         elseif abs(vtOrtho:getZ()) < 0.001 and abs(vtOrtho:getX()) > 0.999 then 
-            -- se corrisponde a Y
-            if ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
-               ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then
-               -- setto l'entità open
-               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
-               if #sActInfo > 0 then
-                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
-               else
-                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
-               end
-               -- prendo i punti per eventuale modifica del punto di inizio percorso
-               pLastPIni = pPini
-               pLastPEnd = pPend
-            -- altrimenti se corrisponde a Z
-            elseif ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
-                   ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
-               -- setto l'entità open
-               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
-               if #sActInfo > 0 then
-                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
-               else
-                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
-               end
-               -- prendo i punti per eventuale modifica del punto di inizio percorso
-               pLastPIni = pPini
-               pLastPEnd = pPend
-            end
-         -- se asse Z orizzontale verifico se si avvicina piú a Y
-         elseif abs(vtOrtho:getZ()) < 0.001 then 
-            if abs(vtOrtho:getY()) > 0.75 then 
-               -- se corrisponde a Z
-               if ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
-                  ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
-                  -- setto l'entità open
-                  local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
-                  if #sActInfo > 0 then
-                     EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
-                  else
-                     EgtSetInfo( nPathInt, 'OPEN', (i-1))
-                  end
-                  -- prendo i punti per eventuale modifica del punto di inizio percorso
-                  pLastPIni = pPini
-                  pLastPEnd = pPend
-               end
-            end
-         -- se asse Y a 0 (fresa ne davanti ne dietro) verifico se si avvicina piú a Z+
-         elseif abs(vtOrtho:getY()) < 0.001 then 
-            if abs(vtOrtho:getZ()) > 0.75 then 
-               -- se corrisponde a Y
-               if ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
-                  ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then
-                  -- setto l'entità open
-                  local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
-                  if #sActInfo > 0 then
-                     EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
-                  else
-                     EgtSetInfo( nPathInt, 'OPEN', (i-1))
-                  end
-                  -- prendo i punti per eventuale modifica del punto di inizio percorso
-                  pLastPIni = pPini
-                  pLastPEnd = pPend
-               end
-            end
-         end
-      end
-      -- se devo cambiare il punto di partenza
-      if nStartPoint then
-         if pLastPIni and pLastPEnd then
-            -- calcolo il punto medio con gli ultimi punti utilizzati
-            local ptPs = ( pLastPIni + pLastPEnd) / 2
-            EgtChangeClosedCurveStartPoint( nPathInt, ptPs, GDB_RT.GLOB)
-            -- se devo eliminare la parte open
-            if nStartPoint == 2 then
-               EgtRemoveCurveCompoCurve( nPathInt, true)
-               EgtRemoveCurveCompoCurve( nPathInt, false)
-               return true
-            end
-         end
-      end
-   end
-
-   return false
-end
-
 -------------------------------------------------------------------------------------------------------------
 return BeamLib
@@ -377,13 +377,12 @@ 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 (se negativa qualunque, se positiva deve stare nel MAX)
+--   dCustMaxDimDice: dimensione massima customizzata, sostituisce il parametro BD.MAX_DIM_DICE
 --   bDownHead : taglio con testa da sotto
 ----------------------------------------------------------------------------------------------------------------------------------------------------
 function DiceCut.GetDice( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, bGetOrtoPlanes, ptCBond, vtNBond, dOrthoMaxDim, dCustMaxDimDice, bDownHead)

-   local dMaxDimDice = BD.MAX_DIM_DICE 
-   if dCustMaxDimDice and dCustMaxDimDice < BD.MAX_DIM_DICE then dMaxDimDice = abs( dCustMaxDimDice) end
+   local dMaxDimDice = EgtIf( dCustMaxDimDice and dCustMaxDimDice < BD.MAX_DIM_DICE, dCustMaxDimDice, BD.MAX_DIM_DICE)
   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
@@ -497,12 +496,6 @@ 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/09/24
+-- FacesBySaw.lua by Egaltech s.r.l. 2022/06/29
 -- 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,7 +12,6 @@
 -- 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 = {}
@@ -29,7 +28,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, bForceInvert)
+function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw)
   -- dati della faccia
   local ptC, vtN = EgtSurfTmFacetCenter( nSurfId, nFacet, GDB_ID.ROOT)
   -- risolvo parametro ambiguo
@@ -52,10 +51,7 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
      return true, ''
   end
   vtV1 = - vtV1
-   local bInvert = bForceInvert
-   if bInvert == nil then
-      bInvert = ( ptP2:getZ() < ptP1:getZ() - 100 * GEO.EPS_SMALL)
-   end
+   local bInvert = ( ptP2:getZ() < ptP1:getZ() - 100 * GEO.EPS_SMALL)
   if bInvert then
      ptP1, ptP2 = ptP2, ptP1
      vtV1, vtV2 = vtV2, vtV1
@@ -126,7 +122,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, vtLio = FacesBySaw.CalcLeadInOutPerpGeom( ptP1act, ptP2act, vtV1, vtV2, vtN, dSawDiam/2, vtRef, dCutExtra, b3Box)
+   local dLiTang, dLiPerp, dLoTang, dLoPerp = 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
@@ -160,26 +156,11 @@ 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
-      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
+      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)
      else
-         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
+         nSCC = EgtIf( vtTest:getZ() > 0, MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
      end
   end
   -- inserisco la lavorazione di taglio
@@ -479,24 +460,29 @@ 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)
-   -- Versore di attacco e uscita
+   -- Versori di attacco e uscita
   local dCos1 = vtV1 * vtRef
   local dCos2 = vtV2 * vtRef
-   local vtLio
+   local vtLi, vtLo
   if abs( dCos1 - dCos2) < 0.001 then
      if abs( vtV1:getZ()) < abs( vtV2:getZ()) then
-         vtLio = vtV1
+         vtLi = vtV1
+         vtLo = vtV1
      else
-         vtLio = vtV2
+         vtLi = vtV2
+         vtLo = vtV2
      end
   elseif dCos1 > dCos2 then
-      vtLio = vtV1
+      vtLi = vtV1
+      vtLo = vtV1
   else
-      vtLio = vtV2
+      vtLi = vtV2
+      vtLo = vtV2
   end
-   local bRight = ( vtX * vtLio > 0)
-   -- Versore di attacco e uscita nel riferimento intrinseco al taglio
-   local vtLioL = Vector3d( vtLio) ;   vtLioL:toLoc( frFace)
+   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)
   -- 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))
@@ -506,30 +492,30 @@ function FacesBySaw.CalcLeadInOutPerpGeom( ptP1, ptP2, vtV1, vtV2, vtN, dRad, vt
   -- Attacco
   local dLiTang = 10000
   local dLiPerp = 10000
-   local bLiOk, _, vLiPar = EgtLineBoxInters( ptP1, vtLio, b3MyBox)
+   local bLiOk, _, vLiPar = EgtLineBoxInters( ptP1, vtLi, b3MyBox)
   if bLiOk and #vLiPar > 0 then
      -- con la prima faccia di uscita
      local dLen = vLiPar[#vLiPar]
-      local ptInt = ptP1 + vtLio * dLen
-      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLio)
+      local ptInt = ptP1 + vtLi * dLen
+      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLi)
      EgtOutLog( 'LiFaceNorm=' .. tostring( vtFN), 3)
-      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLio * vtFN)
+      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLi * vtFN)
      local dLiLen = dLen + dAddLen
      EgtOutLog( 'LeadIn Dist=' .. EgtNumToString( dLiLen), 3)
-      dLiTang = - dLiLen * vtLioL:getY()
-      dLiPerp = EgtIf( bRight, dLiLen, - dLiLen) * vtLioL:getX()
+      dLiTang = - dLiLen * vtLiL:getY()
+      dLiPerp = EgtIf( bRight, dLiLen, - dLiLen) * vtLiL:getX()
      -- verifico se miglioro calcolando con faccia successiva
      local b3Mod = BBox3d( b3MyBox) ;  b3Mod:Add( ptInt + 1000 * vtFN)
-      local bLiOk2, _, vLiPar2 = EgtLineBoxInters( ptP1, vtLio, b3Mod)
+      local bLiOk2, _, vLiPar2 = EgtLineBoxInters( ptP1, vtLi, b3Mod)
      if bLiOk2 and #vLiPar2 > 0 then
         local dLen2 = vLiPar2[#vLiPar2]
-         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP1 + vtLio * dLen2, vtLio)
+         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP1 + vtLi * dLen2, vtLi)
         EgtOutLog( 'LiFaceNorm2=' .. tostring( vtFN2), 3)
-         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLio * vtFN2)
+         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLi * vtFN2)
         local dLiLen2 = dLen2 + dAddLen2
         EgtOutLog( 'LeadIn Dist2=' .. EgtNumToString( dLiLen2), 3)
-         local dLiTang2 = - dLiLen2 * vtLioL:getY()
-         local dLiPerp2 = EgtIf( bRight, dLiLen2, - dLiLen2) * vtLioL:getX()
+         local dLiTang2 = - dLiLen2 * vtLiL:getY()
+         local dLiPerp2 = EgtIf( bRight, dLiLen2, - dLiLen2) * vtLiL:getX()
         if dLiLen2 < dLiLen then
            dLiTang = dLiTang2
            dLiPerp = dLiPerp2
@@ -539,37 +525,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, vtLio, b3MyBox)
+   local bLoOk, _, vLoPar = EgtLineBoxInters( ptP2, vtLo, b3MyBox)
   if bLoOk and #vLoPar > 0 then
      -- con la prima faccia di uscita
      local dLen = vLoPar[#vLoPar]
-      local ptInt = ptP2 + vtLio * dLen
-      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLio)
+      local ptInt = ptP2 + vtLo * dLen
+      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLo)
      EgtOutLog( 'LoFaceNorm=' .. tostring( vtFN), 3)
-      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLio * vtFN)
+      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLo * vtFN)
      local dLoLen = dLen + dAddLen
      EgtOutLog( 'LeadOut Dist=' .. EgtNumToString( dLoLen), 3)
-      dLoTang = dLoLen * vtLioL:getY()
-      dLoPerp = EgtIf( bRight, dLoLen, - dLoLen) * vtLioL:getX()
+      dLoTang = dLoLen * vtLoL:getY()
+      dLoPerp = EgtIf( bRight, dLoLen, - dLoLen) * vtLoL:getX()
      -- verifico se miglioro calcolando con faccia successiva
      local b3Mod = BBox3d( b3MyBox) ;  b3Mod:Add( ptInt + 1000 * vtFN)
-      local bLoOk2, _, vLoPar2 = EgtLineBoxInters( ptP2, vtLio, b3Mod)
+      local bLoOk2, _, vLoPar2 = EgtLineBoxInters( ptP2, vtLo, b3Mod)
      if bLoOk2 and #vLoPar2 > 0 then
         local dLen2 = vLoPar2[#vLoPar2]
-         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP2 + vtLio * dLen2, vtLio)
+         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP2 + vtLo * dLen2, vtLo)
         EgtOutLog( 'LoFaceNorm2=' .. tostring( vtFN2), 3)
-         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLio * vtFN2)
+         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLo * vtFN2)
         local dLoLen2 = dLen2 + dAddLen2
         EgtOutLog( 'LeadOut Dist2=' .. EgtNumToString( dLoLen2), 3)
-         local dLoTang2 = dLoLen2 * vtLioL:getY()
-         local dLoPerp2 = EgtIf( bRight, dLoLen2, - dLoLen2) * vtLioL:getX()
+         local dLoTang2 = dLoLen2 * vtLoL:getY()
+         local dLoPerp2 = EgtIf( bRight, dLoLen2, - dLoLen2) * vtLoL:getX()
         if dLoLen2 < dLoLen then
            dLoTang = dLoTang2
            dLoPerp = dLoPerp2
         end
      end
   end
-   return dLiTang, dLiPerp, dLoTang, dLoPerp, vtLio
+   return dLiTang, dLiPerp, dLoTang, dLoPerp
 end

 ---------------------------------------------------------------------
@@ -2,8 +2,6 @@
 -- 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.
-- 2022/11/25 Per FindMilling implementata la possibilità di escludere la testa H3 dalla ricerca utensile.

 -- Tabella per definizione modulo
 local MachiningLib = {}
@@ -109,9 +107,8 @@ local function SetCurrMachiningAndTool( sMachName)
   local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
   local nHead = tonumber( sHead:sub( 2, #sHead))
   local bH2 = ( nHead >= 21 and nHead <= 29)
-   local bH3 = ( nHead >= 31 and nHead <= 39) 
   local bFixed = ( vFixedHeads[nHead])
-   return bActive, sTool, bH2, bFixed, bH3
+   return bActive, sTool, bH2, bFixed
 end

 ---------------------------------------------------------------------
@@ -224,7 +221,7 @@ function ReturnParams( MachiningType, MachiningName, sType, ToolParams)
 end

 ---------------------------------------------------------------------
-local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead, bExcludeH3)
+local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
   if bTopHead == nil and bDownHead == nil then
      bTopHead = true
      bDownHead = false
@@ -266,8 +263,6 @@ 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
@@ -275,8 +270,8 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead,
         _, sMachiningType = EgtEndsWith( Machining.Type, '_H2')
      end
      -- recupero dati utensile
-      local bToolActive, sToolName, bH2, bFixed, bH3 = SetCurrMachiningAndTool( Machining.Name)
-      if Machining.On and sMachiningType == sType and bToolActive and ( not bH3 or bH3 == not bExcludeH3) then
+      local bToolActive, sToolName, bH2, bFixed = SetCurrMachiningAndTool( Machining.Name)
+      if Machining.On and sMachiningType == sType and bToolActive then
         local bOk, ToolParams = VerifyTool( MachiningType, sType, Params, bH2)
         if bOk then
            if MachineHeadUse == ONE_HEAD then
@@ -289,24 +284,22 @@ 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
-               -- 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
+                  SetNextMachining( sToolName, nActiveHead, bFixed)
+                  return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
               else
-                  if not sH1Mach or sH1Mach == '' then
-                     sH1Mach = Machining.Name
-                     sH1Tool = sToolName
-                     sH1Param = ToolParams
+                  -- 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
                  end
               end
            elseif MachineHeadUse == TWO_UP_DOWN_HEADS then
@@ -322,16 +315,6 @@ 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
@@ -386,8 +369,8 @@ function MachiningLib.FindAngleDrilling( dDiam, dDepth, bTopHead, bDownHead)
 end

 ---------------------------------------------------------------------
-function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bTopHead, bDownHead, bExcludeH3)
-   return FindMachining( MCH_MY.MILLING, sType, { Depth = dDepth, TuuidMstr = sTuuidMstr, MaxDiam = dMaxDiam, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead, bExcludeH3)
+function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bTopHead, bDownHead)
+   return FindMachining( MCH_MY.MILLING, sType, { Depth = dDepth, TuuidMstr = sTuuidMstr, MaxDiam = dMaxDiam, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead)
 end

 ---------------------------------------------------------------------
@@ -1,4 +1,4 @@
-- ProcessCut.lua by Egaltech s.r.l. 2022/09/30
+-- ProcessCut.lua by Egaltech s.r.l. 2022/07/28
 -- Gestione calcolo singoli tagli di lama per Travi
 -- 2021/05/18 I due tagli con testa da sotto di un cubetto sono fatti di seguito.
 -- 2021/06/06 Correzioni per tagli con testa da sotto.
@@ -14,9 +14,7 @@
 -- 2022/07/18 Se Q04=1, aggiunto LongCut anche dal lato per macchine tipo PF1250.
 -- 2022/08/12 I tagli di lama inclinati in coda ora partono dal centro e non dall'esterno.
 -- 2022/08/24 Disabilitato il dicing per i tagli meno spessi della lama.
-- 2022/08/25 In caso di AdvTail con taglio lungo Y la profondità di lavorazione è opportunamente diminuita.
-- 2022/08/30 Modificata la condizione che determina l'utilizzo della testa da sotto. Ora controlla se la trave è più grande del doppio della massima larghezza del cubetto.
-- 2022/09/23 Corretta la condizione per cui è richiesto l'aggiornamento del grezzo.
+-- 2022/08/25 In caso di AdvTail con taglio lungo Y la profondità di lavorazione è opportunamente diminuita. 

 -- Tabella per definizione modulo
 local ProcessCut = {}
@@ -250,21 +248,17 @@ 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 ( abs(vtN:getY()) > 0.865) and
+   local bLongCutFromSide = ( not bDownCut and ( BD.C_SIMM and BD.DOWN_HEAD and ( vtN:getY() > 0.865 or vtN:getY() < -0.865) and
                              Proc.Box:getDimZ() > b3Solid:getDimZ() - 10 * GEO.EPS_SMALL) and
                              ( Proc.Box:getDimX() > 0.75 * b3Solid:getDimX() or Proc.Box:getDimX() > 600.000))
   -- se taglio lungo e Q04 = 1 allora lancio il processo dell'L10
   local bNoDicing = EgtGetInfo( Proc.Id, 'Q04', 'i') == 1
   if bNoDicing then
      if bLongCut then
-         local bOk, sErr = LongCut.Make( Proc, nPhase, nRawId, nPartId, true)
-         return bOk, sErr, bNoDicing
+         return LongCut.Make( Proc, nPhase, nRawId, nPartId, true)
      elseif bLongCutFromSide then
-         local bOk, sErr = LongCut.Make( Proc, nPhase, nRawId, nPartId, false, 2)
-         return bOk, sErr, bNoDicing
+         return LongCut.Make( Proc, nPhase, nRawId, nPartId, false, 2)
      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
@@ -353,37 +347,9 @@ 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 dMaxElev > dSawThick then
-         vCuts = DC.GetDice( nAddGrpId, EgtIf( bForced, b3Raw, b3Solid), ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA, dNewDiceDim)
+      if Proc.Box:getDimX() >= dSawThick then
+         vCuts = DC.GetDice( nAddGrpId, EgtIf( bForced, b3Raw, b3Solid), ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA)
         -- se taglio sborda in coda e non è stato inserito nessun taglio a cubetti, lo rilancio con le dimensioni customizzate
         if ( bFillTail or bCustDiceCut) and #vCuts == 0 then
            vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA, Proc.Box:getDimY())
@@ -463,7 +429,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 not BD.TURN and abs( vtN:getY()) > 0.05 then dVzLimDwnUp = -0.708 end
+                     if not BD.C_SIMM and abs( vtN:getY()) > 0.05 then dVzLimDwnUp = -0.707 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
@@ -487,7 +453,7 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                  end
               end
               local dVzLimDwnUp = dNzLimDwnUp
-               if not BD.C_SIMM and not BD.TURN and vtN:getZ() > 0.707 then dVzLimDwnUp = -0.708 end
+               if not BD.C_SIMM 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
@@ -756,9 +722,9 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom,
         return true
      end
   end
-   -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -20deg e sbandato oltre 1deg oppure sezione più larga di 2 cubetti o pezzo corto)
+   -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -20deg e sbandato oltre 1deg oppure sezione larga o pezzo corto)
   local bDownHead = ( BD.DOWN_HEAD and vtN:getZ() < -0.341 and
-                       ( abs( vtN:getY()) > 0.017 or b3Raw:getDimY() > 2 * ( BD.MAX_DIM_DICE - BD.CUT_EXTRA_MIN) or b3Raw:getDimX() < BD.LEN_SHORT_PART))
+                       ( abs( vtN:getY()) > 0.017 or b3Raw:getDimY() > 2 * ( BD.MAX_DIM_HTCUT - BD.CUT_EXTRA_MIN) or b3Raw:getDimX() < BD.LEN_SHORT_PART))
   local bDownTurn = ( BD.TURN and vtN:getZ() < -0.017)
   local bTopHead = ( BD.DOWN_HEAD and ( vtN:getZ() > -0.342 or not bDownHead))
   -- recupero la lavorazione
@@ -770,11 +736,9 @@ 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, bNoDicing2 = MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bForced, b3Raw, sNotes)
-      bNoDicing = bNoDicing2
+      local bOk, sErr = MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bForced, b3Raw, sNotes)
      if not bOk then return false, sErr end
   -- altrimenti taglio con testa da sotto
   else
@@ -782,8 +746,7 @@ 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)
-   -- Se lascio il cordolo (bNoDicing) non aggiorno il grezzo perchè lo scarto rimane attaccato
-   if ( ProcessCut.Identify( Proc) or bUpdateIng) and not bNoDicing then
+   if ProcessCut.Identify( Proc) or bUpdateIng then
      UpdateEncumbrance( Proc, vtN, dOvmHead, nRawId, b3Solid, b3Raw)
   end
   return true
@@ -1,6 +1,5 @@
 -- ProcessDoubleCut.lua by Egaltech s.r.l. 2022/07/11
 -- Gestione calcolo doppi tagli di lama per Travi
-- 2022/08/29 Implementata la fresatura dal lato per tagli problematici per PF1250

 -- Tabella per definizione modulo
 local ProcessDoubleCut = {}
@@ -189,293 +188,6 @@ local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
   return true
 end

---------------------------------------------------------------------
-local function VerifyPocket( Proc, dDiam, dDepth, dMaxTotLen, sMchFindMaster, bPocketDown)
-   -- tipo di svuotatura
-   local sMchFind = EgtIf( sMchFindMaster and #sMchFindMaster > 0, sMchFindMaster, 'Pocket')
-   -- ricerca della svuotatura
-   local sPocketing
-   if dDepth then
-      sPocketing = ML.FindPocketing( sMchFind, dDiam, dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
-                   ML.FindPocketing( sMchFind, dDiam, 0.8 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
-                   ML.FindPocketing( sMchFind, dDiam, 0.6 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
-                   ML.FindPocketing( sMchFind, dDiam, 0.4 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
-                   ML.FindPocketing( sMchFind, dDiam, 0, dMaxTotLen)
-   else
-      sPocketing = ML.FindPocketing( sMchFind, dDiam, 0, dMaxTotLen)
-   end
-   if not sPocketing then
-      return false
-   end
-   -- recupero i dati dell'utensile
-   local bUsePocketing = false
-   local dMaxDepth = 0
-   local dToolDiam = 0
-   if EgtMdbSetCurrMachining( sPocketing) then
-      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-         dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
-         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
-      end
-      bUsePocketing = true
-   end
-   return bUsePocketing, sPocketing, dMaxDepth, dToolDiam
-end
-
---------------------------------------------------------------------
-local function SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId)
-   -- fondo tra loro le curve compatibili
-   EgtMergeCurvesInCurveCompo( nPathInt)
-   local nStartIdEnt, nNumEnt = EgtCurveDomain( nPathInt) 
-   local pLastPIni, pLastPEnd
-   -- faccio una copia della curva e la esplodo
-   if nStartIdEnt then
-      -- ciclo i lati della curva e controllo per ognuno se giace in uno dei piani limite del pezzo: se sì allora il lato è aperto 
-      for i = 1, nNumEnt do
-         local pPini = EgtUP( nPathInt, (i-1), GDB_RT.GLOB) 
-         local pPend = EgtUP( nPathInt, EgtIf( i == nNumEnt, 0, i), GDB_RT.GLOB)
-         if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or
-            ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) or
-            ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
-            ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) or
-            ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
-            ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
-            -- scrivo nelle proprietà della curva quali sono i lati aperti
-            local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
-            if #sActInfo > 0 then
-               -- se ci sono già altri lati aperti
-               EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
-            else
-               -- se è l'unico
-               EgtSetInfo( nPathInt, 'OPEN', (i-1))
-            end
-         end
-      end
-   end
-   return false
-end
-
---------------------------------------------------------------------
-local function MakeBySidePocket( Proc, nPhase, nRawId, nPartId, nAddGrpId, b3Solid)
-   local nFirstMachId
-   local sWarn
-   local sMchFind = 'OpenPocket'
-   local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt
-   local bBadMach = false
-   -- ottengo le dimensioni del tunnel 
-   dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
-   -- posso utilizzare utensile con diametro doppio della dimensione minima
-   dDimMin = min( 2 * dDimMin, BD.MAXDIAM_POCK_CORNER)
-   local nPathInt
-   -- verifico se è presente la testa da sotto e se è necessario usarla
-   bMillDown = ( BD.DOWN_HEAD == true and abs( vtOrtho:getZ()) >= 0.707)
-   -- cerco l'utensile di svuotatura per la testa sopra
-   local bMakePocket, sPocketing, dMaxDepth, dDiamTool = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind)
-   local bMakePocketDn, sPocketingDn, dMaxDepthDn, dDiamToolDn
-   -- cerco anche l'utensile per la testa sotto, nel caso servisse
-   if bMillDown then
-      bMakePocketDn, sPocketingDn, dMaxDepthDn, dDiamToolDn = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind, true)
-      -- se è negativo inverto il versore e la faccia
-      if vtOrtho:getZ() < 0 then 
-         vtOrtho = -vtOrtho
-         EgtInvertSurf( nSurfInt)
-      end
-   end
-   if bMakePocket then
-      -- gestione svuotatura da un solo lato o anche dal lato opposto (se non verticale)
-      -- estraggo il contorno dalla superfice per evitare i problemi con la svuotatura
-      -- e assegno l'estrusione
-      nPathInt = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId)
-      EgtModifyCurveExtrusion( nPathInt, vtOrtho, GDB_RT.GLOB)
-      SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId)
-      -- variabili per parametri lavorazione
-      local dMachDepth
-      local dElev = 0
-      local bDoubleSide
-      local bOneShot
-      local bComplete = true
-      -- imposto altezza aggiuntiva di elevazione
-      local dCollSic = BL.CalcCollisionSafety( vtOrtho)
-      -- se possibile svuotare completamente da una sola parte
-      if dMaxDepth > ( dDepth + BD.CUT_EXTRA + dCollSic) then
-         dMachDepth = ( dDepth / 2) + BD.CUT_EXTRA
-         dElev = dDepth + BD.CUT_EXTRA
-         bOneShot = true
-      else
-         -- se direzione verso la verticale setto max affondamento possibile ed
-         -- emetto messaggio di warning perché non lavorabile interamente
-         if abs( vtOrtho:getZ()) >= 0.707 and not BD.DOWN_HEAD then
-            dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic
-            dElev = dMaxDepth
-            sWarn = 'Warning : elevation bigger than max tool depth'
-            EgtOutLog( sWarn)
-            bComplete = false
-         -- altrimenti setto il flag per fare la svuotatura da due parti 
-         else
-            -- se l'altezza utensile riesce a lavorare completamente da due parti
-            if dMaxDepth > ( dDepth / 2) + dCollSic + BD.CUT_EXTRA_MIN then
-               dMachDepth = BD.CUT_EXTRA_MIN
-               dElev = ( dDepth / 2) + BD.CUT_EXTRA_MIN
-            -- altrimenti non si riesce in due passate, limito la profondità e setto l'elevazione 
-            else
-               dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic
-               dElev = dMaxDepth
-               -- se molto inclinato rispetto alla normale della faccia di riferimento, lavorazione non idonea per probabili collisioni
-               local vtRef = Y_AX()
-               if abs( vtOrtho:getX()) > abs( vtOrtho:getY()) and abs( vtOrtho:getX()) > abs( vtOrtho:getZ()) then
-                  vtRef = X_AX()
-               elseif abs( vtOrtho:getZ()) > abs( vtOrtho:getX()) and abs( vtOrtho:getZ()) > abs( vtOrtho:getY()) then
-                  vtRef = Z_AX()
-               end
-               if abs( vtOrtho * vtRef) < 0.5 then
-                  bBadMach = true
-               end
-            end
-            bDoubleSide = true
-         end
-      end
-      -- inserisco la lavorazione di svuotatura
-      local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-      local nMchFId = EgtAddMachining( sName, sPocketing)
-      if not nMchFId then
-         local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
-         EgtOutLog( sErr)
-         return -1, sErr
-      end
-      -- prendo l'id della prima lavorazione inserita
-      if not nFirstMachId then
-         nFirstMachId = nMchFId
-      end
-      -- aggiungo geometria
-      EgtSetMachiningGeometry( {{ nPathInt, -1}})
-      -- verifico se devo invertire direzione utensile (in caso di direzione verso la verticale)
-      local bInvertMach
-      if vtOrtho:getZ() < BD.NZ_MINA and abs(vtOrtho:getZ()) >= 0.707 and not BD.DOWN_HEAD then
-         EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
-         bInvertMach = true
-      -- altrimenti se da fare in una sola volta e direzionato verso Y+ lo inverto per lavorarlo davanti
-      elseif not bDoubleSide and vtOrtho:getY() > GEO.EPS_SMALL and not ( -(vtOrtho:getZ()) < BD.NZ_MINA) then
-         EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
-         bInvertMach = true
-      end
-      -- imposto posizione braccio porta testa
-      local nSCC = MCH_SCC.NONE
-      if not BD.C_SIMM then
-         if AreSameOrOppositeVectorApprox( vtOrtho, Z_AX()) then
-            nSCC = MCH_SCC.ADIR_YM
-         elseif abs( vtOrtho:getX()) < 0.1 then
-            nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP)
-         elseif vtOrtho:getY() < GEO.EPS_SMALL then
-            nSCC = EgtIf( bInvertMach, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
-         else
-            nSCC = EgtIf( bInvertMach, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP)
-         end
-      end
-      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
-      EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN)
-      -- inverto il percorso di lavorazione per lavorare sinistro
-      EgtSetMachiningParam( MCH_MP.INVERT, true)
-      -- imposto affondamento
-      EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
-      -- imposto elevazione e dichiaro non si generano sfridi per VMill
-      local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
-      sNotes = sNotes .. 'VMRS=0;'
-      EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
-      -- eseguo
-      if not ML.ApplyMachining( true, false) then
-         -- provo ad allargare leggermente la tasca
-         EgtSetMachiningParam( MCH_MP.OFFSR, -0.1)
-         if not ML.ApplyMachining( true, false) then
-            local _, sErr = EgtGetLastMachMgrError()
-            EgtSetOperationMode( nMchFId, false)
-            return -1, sErr
-         end
-      end
-      -- se posso applicare la svuotatura sul lato opposto
-      if bDoubleSide then
-         -- se ho la lavorazione da sotto ricalcolo in base a questa lavorazione
-         if bMakePocketDn then
-            -- sPocketing = sPocketingDn
-            -- dMaxDepth = dMaxDepthDn
-            -- dDiamTool = dDiamToolDn
-            -- se l'altezza utensile riesce a lavorare completamente da due parti
-            if dMaxDepthDn > ( dDepth / 2) + dCollSic + BD.CUT_EXTRA_MIN then
-               dMachDepth = BD.CUT_EXTRA_MIN
-               dElev = ( dDepth / 2) + BD.CUT_EXTRA_MIN
-            -- altrimenti non si riesce in due passate, limito la profondità e setto l'elevazione 
-            else
-               dMachDepth = dMaxDepthDn - ( dDepth / 2) - dCollSic
-               dElev = dMaxDepthDn
-               bComplete = false
-               sWarn = 'Warning : elevation bigger than max tool depth'
-               EgtOutLog( sWarn)
-            end
-         else
-            -- se anche lavorando dal lato opposto non riesco a svuotare completamente la fessura 
-            -- setto i parametri affondamento ed emetto warning
-            if dMaxDepth < ( dDepth / 2) + BD.CUT_EXTRA + dCollSic then
-               dMachDepth = dMaxDepth - (dDepth / 2) - dCollSic
-               dElev = dMaxDepth
-               bComplete = false
-               sWarn = 'Warning : elevation bigger than max tool depth'
-               EgtOutLog( sWarn)
-            end
-         end
-         -- inserisco la lavorazione di svuotatura
-         local sName = 'PockOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-         local nMchFId = EgtAddMachining( sName, EgtIf( bMakePocketDn, sPocketingDn, sPocketing))
-         if not nMchFId then
-            local sErr = 'Error adding machining ' .. sName .. '-' .. EgtIf( bMakePocketDn, sPocketingDn, sPocketing)
-            EgtOutLog( sErr)
-            return -1, sErr
-         end
-         -- prendo l'id della prima lavorazione inserita
-         if not nFirstMachId then
-            nFirstMachId = nMchFId
-         end
-         -- aggiungo geometria
-         EgtSetMachiningGeometry( {{ nPathInt, -1}})
-         -- imposto direzione utensile opposta
-         EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
-         -- imposto posizione braccio porta testa
-         local nSCC = MCH_SCC.NONE
-         if not BD.C_SIMM then
-            if AreSameVectorApprox( vtOrtho, Z_AX()) then
-               nSCC = MCH_SCC.ADIR_YM
-            elseif abs( vtOrtho:getX()) < 0.1 then
-               nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP)
-            elseif vtOrtho:getY() < GEO.EPS_SMALL then
-               nSCC = MCH_SCC.ADIR_YP
-            else
-               nSCC = MCH_SCC.ADIR_YM
-            end
-         end
-         EgtSetMachiningParam( MCH_MP.SCC, nSCC)
-         EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN)
-         -- inverto il percorso di lavorazione per lavorare sinistro
-         EgtSetMachiningParam( MCH_MP.INVERT, true)
-         -- imposo affondamento
-         EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
-         -- imposto elevazione e dichiaro non si generano sfridi per VMill
-         local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
-         sNotes = sNotes .. 'VMRS=0;'
-         EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
-         -- eseguo
-         if not ML.ApplyMachining( true, false) then
-            -- provo ad allargare leggermente la tasca
-            EgtSetMachiningParam( MCH_MP.OFFSR, -0.1)
-            if not ML.ApplyMachining( true, false) then
-               local _, sErr = EgtGetLastMachMgrError()
-               EgtSetOperationMode( nMchFId, false)
-               return -1, sErr
-            end
-         end
-      end
-      return 1, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId
-   end
-   return 0, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, bOrthoFaces
-end
-
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
@@ -561,31 +273,6 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
      -- eseguo
      local sCutType = EgtIf( bHead, 'HeadSide', 'TailSide')
      local bDownHead = ( BD.DOWN_HEAD and vtNm:getZ() < BD.NZ_MINB)
-      -- per tutte le macchine tranne la Fast, controllo se ci sono tagli troppo inclinati e troppo profondi per la lama
-      -- in tal caso richiamo la lavorazione con fresa dal lato
-      if BD.C_SIMM and not bDownHead then
-         local sCutting = ML.FindCutting( sCutType, nil, bDownHead)
-            if not sCutting then
-            local sErr = 'Error : cutting not found in library'
-            EgtOutLog( sErr)
-            return false, sErr
-         end
-         local dMaxDepth = 0
-         if EgtMdbSetCurrMachining( sCutting) then
-            local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-            if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-               dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
-            end
-         end
-         local _, _, dDimV1 = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
-         local _, _, dDimV2 = BL.GetFaceHvRefDim( Proc.Id, 1, b3Raw)
-         local bFace1TooLongForBlade, bFace2TooLongForBlade = ( dDimV1 >= dMaxDepth), ( dDimV2 >= dMaxDepth)
-         local dFace1Ang, dFace2Ang = vtN[1]:getZ(), vtN[2]:getZ()
-         if bFace1TooLongForBlade and dFace1Ang < ( BD.CUT_VZ_MIN or -0.484) or bFace2TooLongForBlade and dFace2Ang < ( BD.CUT_VZ_MIN or -0.484) then
-            local bOk, sErr = MakeBySidePocket(  Proc, nPhase, nRawId, nPartId, nAddGrpId, b3Solid)
-            return bOk, sErr
-         end
-      end
      local bOk, sErr = Fbs.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, sCutType, false, bDownHead)
      if not bOk then return bOk, sErr end
      -- segnalazione ingombro di testa o coda
@@ -13,8 +13,6 @@
 -- 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 = {}
@@ -120,7 +118,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) and ( Proc.Fce ~= Proc.Fcs)
+   local bOpen = ( Proc.Fce ~= 0)
   -- recupero flag abilitazione split (0=auto,1=no)
   local bTrySplit = ( EgtGetInfo( Proc.Id, 'Q02', 'i') ~= 1)
   if not bTrySplit then
@@ -268,7 +266,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.421)
+   local bDrillUp = ( bDownDrill and vtExtr:getZ() > -0.5)
   -- primo gruppo di controlli con lunghezza utensile pari a metà foro se passante
   -- recupero la lavorazione
   local sDrilling, sType, dMaxDepth, dMaxToolLength, dToolDiam, dDiamTh, dToolFreeLen = ML.FindDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown)
@@ -371,14 +369,10 @@ 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, max( dToolFreeLen - dSubL, 0))
+   dMaxDepth = min( dMaxDepth, dToolFreeLen - dSubL)
   -- Verifico inclinazione foro nei limiti
-   local bTryDrill = EgtIf( dMaxDepth > 0, ( CosB < BD.DRILL_VX_MAX), false)
+   local bTryDrill = ( CosB < BD.DRILL_VX_MAX)
   if ( CosB > 0.8 * BD.DRILL_VX_MAX and CosB < BD.DRILL_VX_MAX_ANGLEDRILL) then
      -- cerco le forature speciali AngleDrill
      local sDrilling3, sType3, dMaxDepth3 = ML.FindAngleDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown)
@@ -7,7 +7,6 @@
 -- 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 = {}
@@ -40,12 +39,6 @@ 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,12 +1,6 @@
-- ProcessFreeContour.lua by Egaltech s.r.l. 2022/11/03
+-- ProcessFreeContour.lua by Egaltech s.r.l. 2021/10/07
 -- 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.
-- 2022/11/24 In MakeByMill aggiunta la lavorazione sopra/sotto nel caso di testa sotto
--            In MakeByMill se BeamData forza lettura codolo da Q questo viene sempre fatto indipendentemente dalle dimensioni della feature
-

 -- Tabella per definizione modulo
 local ProcessFreeContour = {}
@@ -123,7 +117,7 @@ function ProcessFreeContour.Classify( Proc, b3Raw)
 end

 ---------------------------------------------------------------------
-local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham, bDownHead)
+local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham)
   local nChamfer = 0
   -- ingombro del grezzo
   local b3Raw = EgtGetRawPartBBox( nRawId)
@@ -163,11 +157,7 @@ local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham, bDownHead)
   -- recupero la lavorazione
   local sMilling
   if nChamfer > 0 then
-      if bDownHead then
-         sMilling = ML.FindMilling( 'Mark_H2', nil, nil, nil, nil, false, true)
-      else
-         sMilling = ML.FindMilling( 'Mark')
-      end
+      sMilling = ML.FindMilling( 'Mark')
      if not sMilling then
         local sErr = 'Error : Mark not found in library'
         EgtOutLog( sErr)
@@ -244,6 +234,7 @@ 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
@@ -252,14 +243,12 @@ 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, _, _, bH2 = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, bTopHead, bDownHead)
+   local sMilling = 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
@@ -308,29 +297,24 @@ 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) or ( BD.DOWN_HEAD and bCross)
+   local bCanDouble = ( abs( vtExtr:getY()) > abs( vtExtr:getZ()) 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
-      -- se forzata da parametro Q il codolo è sempre attivo
-      if dDimStrip > 10 * GEO.EPS_SMALL and ( BD.DIM_STRIP < 0 or nStep > 1 or ( bDown and b3Aux:getDimX() > 0.5 * b3Raw:getDimX())) then
+      if dDimStrip > 10 * GEO.EPS_SMALL and ( nStep > 1 or ( bDown and b3Aux:getDimX() > 0.5 * b3Raw:getDimX())) then
         -- devo lasciare un codolo
-         local dExtraCham = EgtIf( nChamfer > 0, 2, 0)
-         dDepth = EgtIf( Proc.Prc == 70, dDepth - dDimStrip - dDepthCham - dExtraCham, dDepth - dDimStrip)
+         dDepth = 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
-   -- se forzata da parametro Q il codolo è sempre attivo
-   local dDepthWork = dDepth
-   if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and ( BD.DIM_STRIP < 0 or nStep > 1) and
+   if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and nStep > 1 and
      bCanDouble and b3Raw:getDimY() > BD.DIM_TO_CENTER_STRIP - 0.1 then
      nDouble = 2
      dDepth = min( ( b3Raw:getDimY() - dDimStrip) * 0.5, dMaxDepth)
@@ -339,23 +323,12 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
      if dDepth > dMaxDepth then
         if bCanDouble then
            nDouble = 2
-            dDepthWork = 0.5 * dDepth
-            dDepth = min( dDepthWork, dMaxDepth)
-            if dDepth < dDepthWork - 10 * GEO.EPS_SMALL then
-               bIsDepthReduced = true
-            end
+            dDepth = min( 0.5 * dDepth, dMaxDepth)
         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
@@ -366,37 +339,14 @@ 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 and Proc.Prc ~= 70 then
+   if nChamfer > 0 and Proc.Grp ~= 0 and dOriDepth > dDepthCham 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
-            local nChamferDown
-            nChamferDown, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, true)
-            if nChamferDown < 0 then
-               sWarn = 'Warning : chamfer from bottom not found in library'
-               sChamferDown = nil
-               EgtOutLog( sWarn)
-            end
-         end
-         local nChamferUp
-         nChamferUp, _, sChamferUp = VerifyChamfer( Proc, AuxId, nRawId, true, false)
-         if nChamferUp < 0 then
-            sWarn = 'Warning : chamfer from bottom not found in library'
-            sChamferUp = nil
-            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 sChamferSide1 = EgtIf( bDownHead, sChamferDown, sChamfer)
-         local nMchId = EgtAddMachining( sNameCh, sChamferSide1)
+         local nMchId = EgtAddMachining( sNameCh, sChamfer)
         if not nMchId then
            local sErr = 'Error adding machining ' .. sNameCh .. '-' .. sChamfer
            EgtOutLog( sErr)
@@ -405,12 +355,15 @@ 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 not bDownHead and vtExtr:getZ() < 0 then
+               if vtExtr:getZ() < 0 then
                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
                  EgtSetMachiningParam( MCH_MP.INVERT, true)
                  EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
@@ -425,7 +378,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
               EgtSetMachiningParam( MCH_MP.INVERT, true)
            else
-               if not bDownHead and vtExtr:getZ() < 0 then
+               if vtExtr:getZ() < 0 then
                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
                  EgtSetMachiningParam( MCH_MP.INVERT, true)
                  EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
@@ -434,11 +387,6 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
               end
            end
         end
-         if nSide == 0 then
-            bDoubleCham = EgtIf( sChamferDown and BD.DOWN_HEAD, true, false)
-         else
-            bDoubleCham = true
-         end
         -- assegno affondamento e offset radiale
         EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra)
         EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
@@ -478,19 +426,12 @@ 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 sChamferSide2
-            if EgtEndsWith( sChamferSide1, 'H2') then
-               sChamferSide2 = sChamferUp
-            elseif nSide == 0 then
-               sChamferSide2 = sChamferDown
-            else
-               sChamferSide2 = sChamfer
-            end
-            nMchId = EgtAddMachining( sName, sChamferSide2)
+            local nMchId = EgtAddMachining( sName, sChamfer)
            if not nMchId then
               local sErr = 'Error adding machining ' .. sName .. '-' .. sChamfer
               EgtOutLog( sErr)
@@ -551,31 +492,6 @@ 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
-   -- nel caso di lavorazioni sopra/sotto cerco lavorazioni specifiche
-   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
-               nDouble = 1
-               dDepth = min( dOriDepth, dMaxDepth)
-               sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' (Free Contour) : milling from bottom not found in library' .. '\n' .. 
-               '; depth (' .. EgtNumToString( dOriDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-               EgtOutLog( sWarn)
-            elseif sMillingDown and not bDownHead then
-               bToolInv = true
-               sMilling = sMillingDown
-            end
-         end
-         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
   -- eseguo
   for i = 1, nStep do
      for j = 1, nDouble do
@@ -600,13 +516,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
         else
            -- inserisco la lavorazione
            sName = 'Free_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-            if EgtEndsWith( sMilling, '_H2') then
-               nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingUp, sMilling))
-            elseif sMillingDown then
-               nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingDown, sMilling))
-            else
-               nMchId = EgtAddMachining( sName, sMilling)
-            end
+            nMchId = EgtAddMachining( sName, sMilling)
            if not nMchId then
               local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
               EgtOutLog( sErr)
@@ -642,9 +552,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) or ( Proc.Grp == 1 and bToolInv) or ( Proc.Grp == 2 and bToolInv) then
+         elseif ( Proc.Grp == 3 and not bToolInv) or ( Proc.Grp == 4 and bToolInv) then
            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
-         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
+         elseif ( Proc.Grp == 3 and bToolInv) or ( Proc.Grp == 4 and not bToolInv) then
            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
         end
         -- posizione braccio porta testa
@@ -713,7 +623,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
         BL.UpdateTCING( nRawId, dOffs)
      end
   end
-   return true, sWarn
+   return true
 end

 ---------------------------------------------------------------------
@@ -854,11 +764,6 @@ 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,11 +1,8 @@
-- ProcessSplit.lua by Egaltech s.r.l. 2022/09/26
+-- ProcessSplit.lua by Egaltech s.r.l. 2022/08/18
 -- 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 = {}
@@ -169,13 +166,11 @@ 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)
@@ -184,22 +179,20 @@ 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 = ( ( 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)
+   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)
   -- 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
@@ -212,26 +205,12 @@ 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 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
+         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
         -- se finitura con truciolatore
-         elseif nQ05 == 2 then
+         elseif EgtGetInfo( nOriId, 'Q05', 'i') == 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'
@@ -245,12 +224,11 @@ 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)
-            return bOk, sErr
+            if not bOk then return bOk, sErr end
         end
      end
-   end
   -- se tagli standard
-   if not bDoubleHorizCut then
+   elseif 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
@@ -271,11 +249,9 @@ 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, dAccStartDoubleCut, dAccEndDoubleCut, '', b3Raw, true)
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_BACK, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, '', b3Raw)
            if not bOk then return false, sErr end
         end
      end
@@ -296,7 +272,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) and not bBigSectionCut then
+      if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 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/09/27
+-- ProcessLapJoint.lua by Egaltech s.r.l. 2022/07/05
 -- Gestione calcolo mezzo-legno per Travi
 -- 2019/10/08 Agg. gestione OpenPocket.
 -- 2021/01/24 Con sega a catena ora sempre impostato asse A.
@@ -49,13 +49,8 @@
 -- 2022/06/29 Migliorate lavorazioni con fresatura di lato per L30 se parametro Q03=2. Ora con 4 facce / 3 facce a L può entrare una fresa grande fino al doppio dell'altezza della tasca / doppio della dimensione minima.
 -- 2022/07/05 Modifiche per sega a catena di testa e relativa MaxElev.
 -- 2022/07/12 In MakeByChainOrSaw aggiunto check per feature L20 usata in modo improprio e, nel caso, si passa a una lavorazione tasca.
+-- 2022/07/19 Profondamente semplificata la funzione SetOpenSide. Modificata la MakeMoreFaces per cercare sempre OpenPocket in determinate condizioni.
 -- 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 = {}
@@ -106,7 +101,6 @@ 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))
@@ -157,7 +151,6 @@ 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
@@ -165,9 +158,6 @@ 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
@@ -455,6 +445,62 @@ local function VerifyBHSideMill( Proc, bIsU, bIsL, bSinglePart, bPrevBhSideMill)
   return bUseBHSideMill, bHead, bHeadDir, sMilling, dToolThick, dToolDiam
 end

+---------------------------------------------------------------------
+local function GetTunnelDimension( Proc, nPartId)
+   -- sono necessarie almeno due facce
+   if Proc.Fct < 2 then return 0, 0, 0 end
+   -- recupero l'ingombro della trave
+   local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+   -- recupero centro e normale delle facce
+   local ptC = {}
+   local vtN = {}
+   for i = 1, Proc.Fct do
+      ptC[i], vtN[i] = EgtSurfTmFacetCenter( Proc.Id, i - 1, GDB_ID.ROOT)
+   end
+   -- calcolo l'orientamento del tunnel
+   local vtOrtho
+   local bAdj = EgtSurfTmFacetsContact( Proc.Id, 0, 1)
+   if bAdj then
+      vtOrtho = vtN[1] ^ vtN[2]
+   else
+      if Proc.Fct >= 3 then
+         vtOrtho = vtN[1] ^ vtN[3]
+      else
+         return 0, 0, 0
+      end
+   end
+   -- ottengo il boundingBox e prendo le dimensioni lungo la direzione (Z locale) che rappresenta la profondità della fessura
+   local frFc = Frame3d( ptC[1], vtOrtho) ;
+   local b3BoxLoc = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, frFc)
+   local dDepth = b3BoxLoc:getDimZ()
+   -- recupero gruppo per geometria addizionale
+   local nAddGrpId = BL.GetAddGroup( nPartId)
+   if not nAddGrpId then
+      EgtOutLog( 'Error : missing AddGroup')
+      return 0, 0, 0
+   end
+   -- centro del bounding box locale
+   local ptCen = b3BoxLoc:getCenter()
+   ptCen:toGlob( frFc)
+   -- creo superficie intermedia
+   local nSurfInt = EgtSurfTmPlaneInBBox( nAddGrpId, ptCen, vtOrtho, b3Solid, GDB_ID.ROOT)
+   if not nSurfInt then return 0, 0, 0 end
+   -- ritaglio la superficie con le facce della fessura
+   for i = 1, Proc.Fct do
+      EgtCutSurfTmPlane( nSurfInt, ptC[i], -vtN[i], false, GDB_ID.ROOT)
+   end
+   local frSurfInt, dDimMax, dDimMin = EgtSurfTmFacetMinAreaRectangle( nSurfInt, 0, GDB_ID.ROOT)
+   -- cerco la faccia con larghezza pari a dimensione massima della fessura
+   local nLongIdFace = 0
+   for i = 1, Proc.Fct do
+      if abs( vtN[i] * frSurfInt:getVersX()) < 0.5 then
+         nLongIdFace = i - 1
+         break
+      end
+   end
+   return dDimMin, dDimMax, dDepth, vtOrtho, nLongIdFace, nSurfInt
+end
+
 ---------------------------------------------------------------------
 local function GetFaceAdj( Proc, nFacInd, dH, dV)

@@ -489,6 +535,23 @@ local function GetFaceAdj( Proc, nFacInd, dH, dV)
   return nFacAdj
 end

+---------------------------------------------------------------------
+local function CalcCollisionSafety( vtDir)
+   local dCollSic = 10 * BD.COLL_SIC
+   if abs( vtDir:getX()) > 0.999 or abs( vtDir:getY()) > 0.999 or abs( vtDir:getZ()) > 0.999 then
+      dCollSic = 0
+   elseif abs( vtDir:getX()) > 0.996 or abs( vtDir:getY()) > 0.996 or abs( vtDir:getZ()) > 0.996 then
+      dCollSic = 1 * BD.COLL_SIC
+   elseif abs( vtDir:getX()) > 0.89 or abs( vtDir:getY()) > 0.89 or abs( vtDir:getZ()) > 0.89 then
+      dCollSic = 2.5 * BD.COLL_SIC
+   elseif abs( vtDir:getX()) > 0.86 or abs( vtDir:getY()) > 0.86 or abs( vtDir:getZ()) > 0.86 then
+      dCollSic = 4 * BD.COLL_SIC
+   elseif abs( vtDir:getX()) > 0.707 or abs( vtDir:getY()) > 0.707 or abs( vtDir:getZ()) > 0.707 then
+      dCollSic = 5.5 * BD.COLL_SIC
+   end
+   return dCollSic
+end
+
 ---------------------------------------------------------------------
 local function UpdateEncumbrance( Proc, nRawId, b3Raw, b3Solid)
   -- verifico siano una o due facce
@@ -696,7 +759,7 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
      -- se facce formano un tunnel e sono ortogonali
      if bClosedOrthoFaces then
         -- ottengo le dimensioni del tunnel 
-         local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
+         local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId)
         EgtErase( nSurfInt)
         -- verifico se può essere fatto con svuotatura
         if VerifyPocket( Proc, dDimMin) then
@@ -1261,6 +1324,179 @@ local function CheckToInvert( AuxId, bPositive)
   return false
 end

+---------------------------------------------------------------------
+local function SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId, nStartPoint)
+   -- fondo tra loro le curve compatibili
+   EgtMergeCurvesInCurveCompo( nPathInt)
+   local nStartIdEnt, nNumEnt = EgtCurveDomain( nPathInt) 
+   local pLastPIni, pLastPEnd
+   -- faccio una copia della curva e la esplodo
+   if nStartIdEnt then
+      -- ciclo i lati della curva e controllo per ognuno se giace in uno dei piani limite del pezzo: se sì allora il lato è aperto 
+      for i = 1, nNumEnt do
+         local pPini = EgtUP( nPathInt, (i-1), GDB_RT.GLOB) 
+         local pPend = EgtUP( nPathInt, EgtIf( i == nNumEnt, 0, i), GDB_RT.GLOB)
+         if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
+            ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
+            -- scrivo nelle proprietà della curva quali sono i lati aperti
+            local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+            if #sActInfo > 0 then
+               -- se ci sono già altri lati aperti
+               EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+            else
+               -- se è l'unico
+               EgtSetInfo( nPathInt, 'OPEN', (i-1))
+            end
+-- inizio - 20220719 codice vecchio mantenuto per backup
+--         -- Se normale lungo la Z considero il box in X e Y
+--         if abs(vtOrtho:getZ()) > 0.999 then
+--            -- se corrisponde a X
+--            if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or
+--               ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) then
+--               -- setto l'entità open
+--               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+--               if #sActInfo > 0 then
+--                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+--               else
+--                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+--               end
+--               -- prendo i punti per eventuale modifica del punto di inizio percorso
+--               pLastPIni = pPini
+--               pLastPEnd = pPend
+--            -- altrimenti se corrisponde a Y
+--            elseif ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
+--                   ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then
+--               -- setto l'entità open
+--               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+--               if #sActInfo > 0 then
+--                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+--               else
+--                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+--               end
+--               -- prendo i punti per eventuale modifica del punto di inizio percorso
+--               pLastPIni = pPini
+--               pLastPEnd = pPend
+--            end
+--         -- altrimenti se normale lungo la Y considero il box in X e Z
+--         elseif abs(vtOrtho:getZ()) < 0.001 and abs(vtOrtho:getY()) > 0.999 then 
+--            -- se corrisponde a X
+--            if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or
+--               ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) then
+--               -- setto l'entità open
+--               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+--               if #sActInfo > 0 then
+--                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+--               else
+--                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+--               end
+--               -- prendo i punti per eventuale modifica del punto di inizio percorso
+--               pLastPIni = pPini
+--               pLastPEnd = pPend
+--            -- altrimenti se corrisponde a Z
+--            elseif ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
+--                   ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
+--               -- setto l'entità open
+--               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+--               if #sActInfo > 0 then
+--                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+--               else
+--                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+--               end
+--               -- prendo i punti per eventuale modifica del punto di inizio percorso
+--               pLastPIni = pPini
+--               pLastPEnd = pPend
+--            end
+--         -- caso che non dovrebbe mai capitare ma gestito per completezza
+--         -- altrimenti se normale lungo la X considero il box in Y e Z 
+--         elseif abs(vtOrtho:getZ()) < 0.001 and abs(vtOrtho:getX()) > 0.999 then 
+--            -- se corrisponde a Y
+--            if ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
+--               ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then
+--               -- setto l'entità open
+--               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+--               if #sActInfo > 0 then
+--                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+--               else
+--                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+--               end
+--               -- prendo i punti per eventuale modifica del punto di inizio percorso
+--               pLastPIni = pPini
+--               pLastPEnd = pPend
+--            -- altrimenti se corrisponde a Z
+--            elseif ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
+--                   ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
+--               -- setto l'entità open
+--               local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+--               if #sActInfo > 0 then
+--                  EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+--               else
+--                  EgtSetInfo( nPathInt, 'OPEN', (i-1))
+--               end
+--               -- prendo i punti per eventuale modifica del punto di inizio percorso
+--               pLastPIni = pPini
+--               pLastPEnd = pPend
+--            end
+--         -- se asse Z orizzontale verifico se si avvicina piú a Y
+--         elseif abs(vtOrtho:getZ()) < 0.001 then 
+--            if abs(vtOrtho:getY()) > 0.75 then 
+--               -- se corrisponde a Z
+--               if ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or
+--                  ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then
+--                  -- setto l'entità open
+--                  local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+--                  if #sActInfo > 0 then
+--                     EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+--                  else
+--                     EgtSetInfo( nPathInt, 'OPEN', (i-1))
+--                  end
+--                  -- prendo i punti per eventuale modifica del punto di inizio percorso
+--                  pLastPIni = pPini
+--                  pLastPEnd = pPend
+--               end
+--            end
+--         -- se asse Y a 0 (fresa ne davanti ne dietro) verifico se si avvicina piú a Z+
+--         elseif abs(vtOrtho:getY()) < 0.001 then 
+--            if abs(vtOrtho:getZ()) > 0.75 then 
+--               -- se corrisponde a Y
+--               if ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or
+--                  ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then
+--                  -- setto l'entità open
+--                  local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or ''
+--                  if #sActInfo > 0 then
+--                     EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1))
+--                  else
+--                     EgtSetInfo( nPathInt, 'OPEN', (i-1))
+--                  end
+--                  -- prendo i punti per eventuale modifica del punto di inizio percorso
+--                  pLastPIni = pPini
+--                  pLastPEnd = pPend
+--               end
+--            end
+-- fine - 20220719 codice vecchio mantenuto per backup
+         end
+      end
+      -- se devo cambiare il punto di partenza
+      if nStartPoint then
+         if pLastPIni and pLastPEnd then
+            -- calcolo il punto medio con gli ultimi punti utilizzati
+            local ptPs = ( pLastPIni + pLastPEnd) / 2
+            EgtChangeClosedCurveStartPoint( nPathInt, ptPs, GDB_RT.GLOB)
+            -- se devo eliminare la parte open, nei casi in cui la funzione caller non faccia in automatico il check
+            if nStartPoint == 2 then
+               EgtRemoveCurveCompoCurve( nPathInt, true)
+               EgtRemoveCurveCompoCurve( nPathInt, false)
+               return true
+            end
+         end
+      end
+   end
+   return false
+end
+
 ---------------------------------------------------------------------
 local function MakeRoundCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, 
                                     nFacInd, nAddGrpId, dDiam, bMillDown, bDoubleSide)
@@ -1507,7 +1743,7 @@ local function MakeRoundCleanContour( Proc, nPhase, nRawId, nPartId, b3Raw,
         return false, sErr
      end
      -- distanza di sicurezza per evitare collisioni
-      dCollSic = BL.CalcCollisionSafety( vtN1)
+      dCollSic = CalcCollisionSafety( vtN1)
      -- elevazione massima della faccia
      dMaxElev = BL.GetFaceElevation( Proc.Id, nFacInd, nPartId)
      -- ciclo tutta la tabella
@@ -1552,7 +1788,7 @@ local function MakeRoundCleanContour( Proc, nPhase, nRawId, nPartId, b3Raw,
      nFirstId = EgtCopyGlob( nPathInt, nAddGrpId)
      nNumId = 1
      -- distanza di sicurezza per evitare collisioni
-      dCollSic = BL.CalcCollisionSafety( vtOrtho)
+      dCollSic = CalcCollisionSafety( vtOrtho)
      -- calcolo elevazione dalla faccia trasversale aggiunta
      local dSurfIntElev = BL.GetOtherFaceElevation( Proc.Id, nSurfInt, 0)
      if bDoubleSide then
@@ -1576,8 +1812,8 @@ local function MakeRoundCleanContour( Proc, nPhase, nRawId, nPartId, b3Raw,
      end
      -- normale alla faccia aggiunta
      vtN1 = Vector3d( vtOrtho)
-      -- imposto i lati aperti
-      BL.SetOpenSide( nFirstId, vtOrtho, b3Solid, nAddGrpId, 2)
+      -- imposto i lati aperti e con il parametro 2 li cancello per evitare di lavorarli
+      SetOpenSide( nFirstId, vtOrtho, b3Solid, nAddGrpId, 2)
   end

   -- se non trovato il percorso, esco
@@ -2329,7 +2565,7 @@ local function MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfI
   if bIs3Faces then
 --      nAuxId1, _ = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId)
 --      EgtModifyCurveExtrusion( nAuxId1, vtOrtho, GDB_RT.GLOB)
--      BL.SetOpenSide( nAuxId1, vtOrtho, b3Solid, nAddGrpId, 1)
+--      SetOpenSide( nAuxId1, vtOrtho, b3Solid, nAddGrpId, 1)
 --      nNumIdAux = 2

      -- estraggo i percorsi
@@ -2445,7 +2681,7 @@ local function MakeByMillAsSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
   end
   if bOrthoFaces then
      -- ottengo le dimensioni del tunnel
-      local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
+      local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId)
   end
   -- Recupero le facce adiacenti alla principale
   local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacInd)[1]
@@ -2606,7 +2842,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,

   if bOrthoFaces then
      -- ottengo le dimensioni del tunnel
-      dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
+      dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId)
      -- verifico la direzione 
      -- se devo inserire il chamfer
      if nChamfer > 0 then
@@ -2628,7 +2864,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
@@ -2993,11 +3229,10 @@ local function MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw, nFacInd, bReduceDe
      end
   end
   -- eseguo il taglio
-   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)
+   local bMadeASbyBld, sWarn, nIdMach = Fbs.MakeOne( Proc.Id, nFacet, sCutting, dSawDiam, vtN, nil, ( -0.5 + dExtraOffs), BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
   if bMadeASbyBld then
      sWarn = nil
-      if not bReduceDepth and abs(dExtraOffs) > 0 then
+      if abs(dExtraOffs) > 0 then
         sWarn = 'Warning : antisplint elevation is bigger than max tool depth'
      end
   end
@@ -3005,7 +3240,7 @@ local function MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw, nFacInd, bReduceDe
 end

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

   -- calcolo l'elevazione dal punto medio
   local dElev
@@ -3099,10 +3334,8 @@ local function MakePocket( Proc, nPartId, b3Solid, ptPs, tvtN, nFaceRef, sMchFin
   end
   -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
   local sWarn
-   local dDepth = dElev
   if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
-      dDepth = dMaxDepth - dElev
-      EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
+      EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth - dElev)
      dElev = dMaxDepth
      sWarn = 'Warning : elevation bigger than max tool depth'
      EgtOutLog( sWarn)
@@ -3123,25 +3356,7 @@ local function MakePocket( Proc, nPartId, b3Solid, ptPs, tvtN, nFaceRef, sMchFin
         return false, sErr
      end
   end
-   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
+   return true, sWarn, sTuuidPk, dDiamTool
 end

 ---------------------------------------------------------------------
@@ -3166,7 +3381,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, b3Solid, ptPs, tvtN, nSideFace, sMchFind, nUseRoughTool, sPocketing, dPrevFaceElev, tDimAndRef, dAng)
+         local bOk, sWarn, sTuuidPk, dDiamTool, dElev = MakePocket( Proc, nPartId, 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
@@ -3293,27 +3508,15 @@ 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
@@ -3357,7 +3560,7 @@ local function GetUShapeWidth( Proc, nFacInd)
 end

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

   local nFirstMachId
   local bOrthoFaces
@@ -3365,8 +3568,6 @@ 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
@@ -3389,7 +3590,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
   -- se è un tunnel verifico se è possibile usare la svuotatura
   if bOrthoFaces then
      -- ottengo le dimensioni del tunnel 
-      dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
+      dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId)
      -- se due facce posso utilizzare utensile con diametro doppio della dimensione minima
      if Proc.Fct == 2 then
         dDimMin = 2 * dDimMin
@@ -3422,31 +3623,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
               EgtInvertSurf( nSurfInt)
            end
         end
-         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
+         if bMakePocket then
            -- gestione svuotatura da un solo lato o anche dal lato opposto (se non verticale)
            -- estraggo il contorno dalla superfice per evitare i problemi con la svuotatura
            -- e assegno l'estrusione
@@ -3454,7 +3631,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
            EgtModifyCurveExtrusion( nPathInt, vtOrtho, GDB_RT.GLOB)
            -- se ho 3 facce oppure se forzato, ciclo sulle entià del percorso per segnare quelle che sono aperte.
            if bIs3Faces or bSetOpenBorders then
-               BL.SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId)
+               SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId)
            end
            -- variabili per parametri lavorazione
            local dMachDepth
@@ -3463,7 +3640,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
            local bOneShot
            local bComplete = true
            -- imposto altezza aggiuntiva di elevazione
-            local dCollSic = BL.CalcCollisionSafety( vtOrtho)
+            local dCollSic = CalcCollisionSafety( vtOrtho)
            -- se possibile svuotare completamente da una sola parte
            if dMaxDepth > ( dDepth + BD.CUT_EXTRA + dCollSic) then
               dMachDepth = ( dDepth / 2) + BD.CUT_EXTRA
@@ -3472,7 +3649,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 and not bMakeContour then
+               if abs( vtOrtho:getZ()) >= 0.707 and not BD.DOWN_HEAD then
                  dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic
                  dElev = dMaxDepth
                  sWarn = 'Warning : elevation bigger than max tool depth'
@@ -3507,49 +3684,29 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
               local sErr = 'Impossible apply perpendicular pocketing: ' .. sPocketing
               return -2, sErr
            end
-            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
+            -- inserisco la lavorazione di svuotatura
+            local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+            local nMchFId = EgtAddMachining( sName, sPocketing)
+            if not nMchFId then
+               local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
+               EgtOutLog( sErr)
+               return -1, sErr
            end
            -- prendo l'id della prima lavorazione inserita
            if not nFirstMachId then
               nFirstMachId = nMchFId
            end
-            if bMakeContour then
-               -- aggiungo geometria per contornatura
-               EgtSetMachiningGeometry( {{ Proc.Id, nFacInd}})
-            else
-               -- altrimenti aggiungo geometria per svuotatura
-               EgtSetMachiningGeometry( {{ nPathInt, -1}})
-            end
+            -- aggiungo geometria
+            EgtSetMachiningGeometry( {{ nPathInt, -1}})
            -- verifico se devo invertire direzione utensile (in caso di direzione verso la verticale)
            local bInvertMach
-            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
+            if vtOrtho:getZ() < BD.NZ_MINA and abs(vtOrtho:getZ()) >= 0.707 and not BD.DOWN_HEAD then
+               EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+               bInvertMach = true
+            -- altrimenti se da fare in una sola volta e direzionato verso Y+ lo inverto per lavorarlo davanti
+            elseif not bDoubleSide and vtOrtho:getY() > GEO.EPS_SMALL and not ( -(vtOrtho:getZ()) < BD.NZ_MINA) then
+               EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+               bInvertMach = true
            end
            -- imposto posizione braccio porta testa
            local nSCC = MCH_SCC.NONE
@@ -3570,50 +3727,11 @@ 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
-            if not bMakeContour then
-               EgtSetMachiningParam( MCH_MP.INVERT, true)
-            end
+            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 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
+            EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
            -- imposto elevazione e dichiaro non si generano sfridi per VMill
-            local sNotes = ''
-            if not bMakeContour then
-               sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
-            end
+            local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
            sNotes = sNotes .. 'VMRS=0;'
            EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
            -- eseguo
@@ -3656,36 +3774,20 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
                     EgtOutLog( sWarn)
                  end
               end
-               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
+               -- inserisco la lavorazione di svuotatura
+               local sName = 'PockOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+               local nMchFId = EgtAddMachining( sName, EgtIf( bMakePocketDn, sPocketingDn, sPocketing))
+               if not nMchFId then
+                  local sErr = 'Error adding machining ' .. sName .. '-' .. EgtIf( bMakePocketDn, sPocketingDn, sPocketing)
+                  EgtOutLog( sErr)
+                  return -1, sErr
               end
               -- prendo l'id della prima lavorazione inserita
               if not nFirstMachId then
                  nFirstMachId = nMchFId
               end
-               if bMakeContour then
-                  -- aggiungo geometria per contornatura
-                  EgtSetMachiningGeometry( {{ Proc.Id, nFacInd}})
-               else
-                  -- altrimenti aggiungo geometria per svuotatura
-                  EgtSetMachiningGeometry( {{ nPathInt, -1}})
-               end
+               -- aggiungo geometria
+               EgtSetMachiningGeometry( {{ nPathInt, -1}})
               -- imposto direzione utensile opposta
               EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
               -- imposto posizione braccio porta testa
@@ -3707,49 +3809,11 @@ 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)
-               -- 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
+               EgtSetMachiningParam( MCH_MP.INVERT, true)
+               -- imposo affondamento
+               EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth)
               -- imposto elevazione e dichiaro non si generano sfridi per VMill
-               sNotes = ''
-               if not bMakeContour then
-                  sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
-               end
+               local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
               sNotes = sNotes .. 'VMRS=0;'
               EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
               -- eseguo
@@ -3775,7 +3839,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
               end
               if bPock3rd then
                  -- recupero la distanza di sicurezza aggiuntiva
-                  local dFacCollSic = BL.CalcCollisionSafety( vtN)
+                  local dFacCollSic = CalcCollisionSafety( vtN)
                  -- scelgo se lavorare da sotto
                  local bFacPocketDn = ( bMakePocketDn and vtN:getZ() < -0.174)
                  -- inserisco la lavorazione di svuotatura
@@ -4169,7 +4233,7 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
         end
         -- prendo il primo versore
         _, vtN1 = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT)
-         dCollSic = BL.CalcCollisionSafety( vtN1) or 0
+         dCollSic = CalcCollisionSafety( vtN1) or 0
         -- se direzione tende verso una delle alle 3 direzioni azzero l'altezza extra
         if abs( vtN1:getX()) > 0.7 or abs( vtN1:getY()) > 0.7 or abs( vtN1:getZ()) > 0.7 then dCollSic = 0 end

@@ -4226,7 +4290,7 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
      -- alrimenti ho la faccia aggiunta
      else

-         dCollSic = BL.CalcCollisionSafety( vtOrtho)
+         dCollSic = CalcCollisionSafety( vtOrtho)
         nFirstId = EgtCopyGlob( nPathInt, nAddGrpId)
         nNumId = 1
         -- calcolo elevazione dalla faccia trasversale aggiunta
@@ -4250,7 +4314,8 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
            end
         end
         vtN1 = Vector3d(vtOrtho)
-         local bOkPath = BL.SetOpenSide( nFirstId, vtOrtho, b3Solid, nAddGrpId, 2)
+         -- imposto i lati aperti e con il parametro 2 li cancello per evitare di lavorarli
+         local bOkPath = SetOpenSide( nFirstId, vtOrtho, b3Solid, nAddGrpId, 2)
         -- se non ho un percorso chiuso estraggo i percorsi
         if bOkPath then
            -- creo percorsi antisplint dagli estremi dei percorsi di contorno trovati
@@ -4559,7 +4624,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) and not BD.TURN)
+            local bDouble = ( vtN:getZ() < -0.5 and dH > ( BD.MAX_LEN_BH_FROM_BOTTOM or 200))
            -- inserisco la lavorazione di fresatura
            local sName = 'BHMill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
            local nMchFId = EgtAddMachining( sName, sMilling)
@@ -4589,7 +4654,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 or BD.TURN then
+            if vtN:getZ() > -0.5 then
               EgtSetMachiningParam( MCH_MP.LITANG, 0)
               EgtSetMachiningParam( MCH_MP.LIPERP, dFacElev + BD.CUT_SIC)
               EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.AS_LI)
@@ -4610,20 +4675,7 @@ 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 = 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
+            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)
            EgtSetMachiningParam( MCH_MP.SCC, nSCC)
            -- eseguo
            if not ML.ApplyMachining( true, false) then
@@ -4832,7 +4884,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
               if not bOk then return false, sErr end
            end
            -- imposto altezza aggiuntiva di elevazione
-            local dCollSic = BL.CalcCollisionSafety( vtN)
+            local dCollSic = CalcCollisionSafety( vtN)
            -- abilitazione lavorazione da sotto
            local bMillUp = ( BD.DOWN_HEAD and vtN:getZ() > -0.259)
            local bMillDown = ( BD.DOWN_HEAD and vtN:getZ() < 0.342)
@@ -5099,7 +5151,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                        -- se devo inserire il chamfer
                        if ( ( Proc.Fct == 3 and bIsU) or (Proc.Fct == 2 and bIsL)) and nChamfer > 0 then
                           -- ottengo le dimensioni dello pseudotunnel 
-                           local _, _, _, vtOrtho, _, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
+                           local _, _, _, vtOrtho, _, nSurfInt = GetTunnelDimension( Proc, nPartId)
                           local nOk, sErr = MakeChamfer( Proc, true, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)
                           if nOk < 0 then return false, sErr end
                        end
@@ -5113,16 +5165,13 @@ 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())
-                     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
+                     if nChamfer < 2 and nQAntisplintResult == 1 and (( bIsU or bIsL) and ( bPassThrou or bPassEdge)) then
                        local bOk
                        local bSawDown = ( bMillDown and not bMillUp)
-                        bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtNOri, nFacIndOri, sWarn, bSawDown, true)
+                        bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtN, nFacInd, 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
@@ -5132,7 +5181,8 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                     -- o passare subito dalla lavorazione con lama/sega catena
                     if ( bTrySidePocketAtFirst and Proc.Fct == 3 and bIsU) or bForceSideMill then
                        -- lavoro con svuotature (singola o doppia contrapposta)
-                        local sMyMchFind = EgtIf( bForceSideMill, 'OpenPocket', 'Pocket')
+                        -- 20220719 -> settate tutte come OpenPocket; prima era Pocket
+                        local sMyMchFind = 'OpenPocket'
                        local dDiamTool = 100
                        local nPathInt, nSurfInt, bOneShot, nFirstMachId
                        local bIs3Faces = true
@@ -5151,7 +5201,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                           tvtNx[2] = vtN
                           local ptPs = ptC
                           dFacElev = BL.GetFaceElevation( Proc.Id, nFacInd)
-                           dCollSic = BL.CalcCollisionSafety( tvtNx[2])
+                           dCollSic = CalcCollisionSafety( tvtNx[2])
                           local dMachDepth = dFacElev + dCollSic
                           local frFacRec, dFacDim1, dFacDim2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
                           -- limito il diametro utensile massimo a 100 per queste lavorazioni
@@ -5192,7 +5242,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, dDepth = MakePocket( Proc, nPartId, b3Solid, ptPs, tvtNx, nFacInd, sMyMchFind, nUseRoughTool, sPocketing, dMachDepth, nil, nil, bAllWithEndCap)
+                           bOk, sWarn2, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, 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
@@ -5203,8 +5253,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, nil, 
-                                                                        nil, nil, nil, b3Solid, dDepth, 
+                                                                        nFacInd, nAddGrpId, bMillDown, dDiamTool, bDoubleSide, 
+                                                                        vtOrtho, nPathInt, nSurfInt, b3Solid, dDepth, 
                                                                        bOneShot, nFirstMachId)
                              if sWarn2 then
                                 if not sWarn then sWarn = '' end
@@ -5233,7 +5283,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                              bSetOpenBorders = true
                           end
                           nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, 
-                           bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, bIs3Faces, b3Solid, bOrthoFacesMaster, bMillDown, bSetOpenBorders, bIsU, bIsL)
+                           bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, bIs3Faces, b3Solid, bOrthoFacesMaster, bMillDown, bSetOpenBorders)
                           if nOk == -2 then
                              if not sMchFind then 
                                 sMchFind = sMchFindBackUp 
@@ -5253,11 +5303,10 @@ 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, 
-                                                                           nFacIndOri, nAddGrpId, bMillDown, dDiamTool, nil, 
-                                                                           nil, nil, nil, b3Solid, dFacElevOri, 
+                                                                           nFacInd, nAddGrpId, bMillDown, dDiamTool, bDoubleSide, 
+                                                                           vtOrtho, nPathInt, nSurfInt, b3Solid, dDepth, 
                                                                           bOneShot, nFirstMachId)
                                 if sWarn2 then
                                    if not sWarn then sWarn = '' end
@@ -5339,7 +5388,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
               -- se devo inserire il chamfer
               if ( ( Proc.Fct == 3 and bIsU) or (Proc.Fct == 2 and bIsL)) and nChamfer > 0 then
                  -- ottengo le dimensioni dello pseudotunnel 
-                  local _, _, _, vtOrtho, _, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
+                  local _, _, _, vtOrtho, _, nSurfInt = GetTunnelDimension( Proc, nPartId)
                  local nOk, sErr = MakeChamfer( Proc, true, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)
                  if nOk < 0 then return false, sErr end
               end
@@ -5350,16 +5399,13 @@ 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())
-            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
+            if nChamfer < 2 and nQAntisplintResult == 1 and (( bIsU or bIsL) and ( bPassThrou or bPassEdge)) then
               local bOk
               local bSawDown = ( bMillDown and not bMillUp)
-               bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtNOri, nFacIndOri, sWarn, bSawDown)
+               bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtN, nFacInd, sWarn, bSawDown)
               if not bOk then return false, sWarn end
            end
            if nChamfer < 2 and nQAntisplintResult == 2 then
@@ -5374,7 +5420,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, b3Solid, ptC, tvtNx, nFacInd, sMchFind, nUseRoughTool, sPocketing, dFacElev + dCollSic, nil, nil, bAllWithEndCap)
+               bOk, sWarn2, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, 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
@@ -5598,7 +5644,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 = EgtIf( Proc.Prc == 90, false, EgtGetInfo( Proc.Id, Q_USE_ROUGH_TOOL, 'i') ~= 1 and EgtGetInfo( Proc.Id, Q_USE_MILL, 'i') ~= 1)
+   local bUseBlade = 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
@@ -5725,9 +5771,6 @@ 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)
@@ -5772,7 +5815,7 @@ function ProcessLapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
               local nChamfer, dDepthCham, sErrCham = EvaluateQParam( Proc)
               -- se smusso da fare 
               if nChamfer > 0 then
-                  local _, _, _, vtOrtho, _, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
+                  local _, _, _, vtOrtho, _, nSurfInt = GetTunnelDimension( Proc, nPartId)
                  local nOk, sErr = MakeChamfer( Proc, true, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)
                  if nOk < 0 then return false, sErr end
               end
@@ -1,4 +1,4 @@
-- ProcessLongCut.lua by Egaltech s.r.l. 2022/11/04
+-- ProcessLongCut.lua by Egaltech s.r.l. 2022/03/07
 -- 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,9 +11,6 @@
 -- 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.
-- 2022/11/28 Correzioni varie per attacco, pulizia spigoli, utilizzo H3

 -- Tabella per definizione modulo
 local ProcessLongCut = {}
@@ -439,8 +436,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 sotto l'orizzontale 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 negativo 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
@@ -861,8 +858,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
      -- recupero la lavorazione
      local bDownHead = ( nSide == - 1)
      sMchType = EgtIf( bDownHead, 'Long2Cut_H2', 'Long2Cut')
-      local bExcludeH3 = bLarghAsFace and abs( nSide) ~= 1
-      local sMilling = ML.FindMilling( sMchType, dElev, nil, nil, nil, not bDownHead, bDownHead, bExcludeH3)
+      local sMilling = ML.FindMilling( sMchType, dElev, nil, nil, nil, not bDownHead, bDownHead)
      if not sMilling then
         local sErr = 'Error : milling '..sMchType..' not found in library'
         EgtOutLog( sErr)
@@ -887,22 +883,11 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
      if bLimXmin and bLimXmax and Proc.Box:getDimX() < 2 * dToolDiam then
         return MakeByPocketing( Proc, nPhase, nRawId, nPartId)
      end
-      -- determino l'utilizzo della faccia
-      local nFaceUse = EgtIf( abs( vtN:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK))
-      -- determino il lato di attacco (0:xMin, 1:xMax)
-      local nStartSide = 0
-      if nFaceUse == MCH_MILL_FU.ORTHO_DOWN and not bFront then
-         nStartSide = 1
-      elseif nFaceUse ~= MCH_MILL_FU.ORTHO_DOWN then
-         if ( bFront and nSide == -1) or ( not bFront and nSide == 1) then
-            nStartSide = 1
-         end
-      end
      -- determino gli estremi
      local dStartDist = 0
      local dStartAccDist = BD.LONGCUT_ENDLEN
      local bStartFixed = true
-      if ( bLimXmin and nStartSide == 0) or ( bLimXmax and nStartSide == 1) then
+      if ( bLimXmin and bFront) or ( bLimXmax and not bFront) then
         dStartDist = dToolDiam / 2
         dStartAccDist = BD.LONGCUT_MAXLEN
         bStartFixed = false
@@ -910,7 +895,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
      local dEndDist = 0
      local dEndAccDist = BD.LONGCUT_ENDLEN
      local bEndFixed = true
-      if ( bLimXmin and nStartSide == 1) or ( bLimXmax and nStartSide == 0) then
+      if ( bLimXmin and not bFront) or ( bLimXmax and bFront) then
         dEndDist = dToolDiam / 2
         dEndAccDist = BD.LONGCUT_MAXLEN
         bEndFixed = false
@@ -975,6 +960,8 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
            dEndAccDist = 0
         end
      end
+      -- determino l'utilizzo della faccia
+      local nFaceUse = EgtIf( abs( vtN:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK))
      -- si percorre il lato basso della faccia
      local nM = 0
      local nCountMilHead = 0
@@ -1005,22 +992,6 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
               EgtOutLog( sErr)
               return false, sErr
            end
-            -- correggo l'attacco se necessario
-            if i == 1 and not bStartFixed then
-               if nO == 1 or EgtGetMachiningParam( MCH_MP.LITANG) ~= 0 then
-                  EgtSetMachiningParam( MCH_MP.LIELEV, 0)
-                  EgtSetMachiningParam( MCH_MP.LITANG, 0)
-                  EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
-                  EgtSetMachiningParam( MCH_MP.LIPERP, dWidth + BD.CUT_EXTRA + BD.CUT_SIC or 20)
-               end
-            elseif i == nC and not bEndFixed then
-               if nO == 1 or EgtGetMachiningParam( MCH_MP.LOTANG) ~= 0 then
-                  EgtSetMachiningParam( MCH_MP.LOELEV, 0)
-                  EgtSetMachiningParam( MCH_MP.LOTANG, 0)
-                  EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR)
-                  EgtSetMachiningParam( MCH_MP.LOPERP, dWidth + BD.CUT_EXTRA + BD.CUT_SIC or 20)
-               end
-            end
            -- aggiungo geometria
            EgtSetMachiningGeometry( {{ Proc.Id, 0}})
            -- limito opportunamente la lavorazione
@@ -1049,20 +1020,16 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
         end
         -- eventuale lavorazione della faccia limitante l'inizio
         if i == 1 and not bStartFixed then
-            -- per il lato sotto il vettore è opposto
-            local vtIni = EgtIf( bFront, X_AX(), -X_AX())
-            if nSide == -1 then
-               vtIni = -1 * vtIni
-            end
+            local vtIni = EgtIf( bFront, X_AX(), -X_AX()) 
            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, nil, nil, bDownHead)
+                  MakeSideFace( Proc.Id, j, nSide, sMilling, dToolDiam)
                  nCountMilHead = nCountMilHead + 1
               end
            end
            if bForcedLim and nCountMilHead < 1 then
-               MakeSideFace( Proc.Id, 0, nSide, sMilling, dToolDiam, bForcedLim, nil, bDownHead)
+               MakeSideFace( Proc.Id, 0, nSide, sMilling, dToolDiam, bForcedLim)
               nCountMilHead = nCountMilHead + 1
            end
         end
@@ -1070,20 +1037,16 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus

      -- eventuale lavorazione della faccia limitante la fine
      if not bEndFixed then
-         -- per il lato sotto il vettore è opposto
-         local vtFin = EgtIf( bFront, -X_AX(), X_AX())
-         if nSide == -1 then
-            vtFin = -1 * vtFin
-         end
+         local vtFin = EgtIf( bFront, -X_AX(), X_AX()) 
         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, nil, nil, bDownHead)
+               MakeSideFace( Proc.Id, j, nSide, sMilling, dToolDiam)
               nCountMilHead = nCountMilHead + 1
            end
         end
         if bForcedLim  and nCountMilHead < 2 then
-            MakeSideFace( Proc.Id, 0, nSide, sMilling, dToolDiam, bForcedLim, nil, bDownHead)
+            MakeSideFace( Proc.Id, 0, nSide, sMilling, dToolDiam, bForcedLim)
            nCountMilHead = nCountMilHead + 1
         end
      end
@@ -4,8 +4,6 @@
 -- 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 = {}
@@ -231,35 +229,6 @@ 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)
@@ -340,10 +309,8 @@ 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))
-            local vtMove = Vector3d(0,0,dMove)
-            vtMove:toGlob(frMor)
-            EgtMove( AuxId, vtMove, GDB_RT.GLOB)
-            EgtMove( nFlat, vtMove, GDB_RT.GLOB)
+            EgtMove( AuxId, Vector3d(0,0,-dMove))
+            EgtMove( nFlat, Vector3d(0,0,-dMove))
            frMor, dL, dW = EgtSurfTmFacetMinAreaRectangle( nFlat, 0, GDB_ID.ROOT)
            ptC = frMor:getOrigin()
            vtN = frMor:getVersZ()
@@ -420,16 +387,16 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
   end
   local sPocketing
   if Proc.Prc ~= 53 then
-      sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown)
+      sPocketing = ML.FindPocketing( sPockType..sMchExt, dW, nil, nil, not bPockDown, bPockDown)
      if not sPocketing and bPockUp then
-         sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt)
+         sPocketing = ML.FindPocketing( sPockType, dW)
      end
   end
   if not sPocketing then
      sPockType = 'Pocket'
-      sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown)
+      sPocketing = ML.FindPocketing( sPockType..sMchExt, dW, nil, nil, not bPockDown, bPockDown)
      if not sPocketing and bPockUp then
-         sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt)
+         sPocketing = ML.FindPocketing( sPockType, dW)
      end
   end
   if not sPocketing then
@@ -1,4 +1,4 @@
-- ProcessProfCamb.lua by Egaltech s.r.l. 2022/11/03
+-- ProcessProfCamb.lua by Egaltech s.r.l. 2022/05/28
 -- 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,7 +8,6 @@
 -- 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 = {}
@@ -316,14 +315,12 @@ 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'
-      local bH2
-      sMilling, _, _, bH2 = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bMillDown)
+      sMilling, _, _, bMillDown = 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/09/30
+-- ProcessScarfJoint.lua by Egaltech s.r.l. 2022/07/12
 -- Gestione calcolo giunto Gerber per Travi
 -- 2021/06/28 Aggiunto extra-taglio alle lamate orizzontali.
 -- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
@@ -173,11 +173,7 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
               if vtO then
                  vtOrthoO = Vector3d( vtO)
               else
-                  if vtN[vFaceOrd[4]]:getZ() < 0.1 then
-                     vtOrthoO = Z_AX()
-                  else
-                     vtOrthoO = Y_AX()
-                  end
+                  vtOrthoO = Y_AX()
               end
            end
         end
@@ -314,12 +310,10 @@ 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

@@ -352,6 +346,7 @@ 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)
@@ -361,27 +356,21 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
      nGoodFace1 = EgtSurfTmFacetCount( nFace1)
   end

-   -- 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) 
+   local bOkd, sErrD, vCuts = ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Solid, ptC, vtN, Proc, vtRef, bHead, sCutting, dSawDiam, b3Raw) 
   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
@@ -389,20 +378,16 @@ 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
-         -- altrimenti se ho intersezione forzo il DiceCut ad essere eseguito con distanze più piccole
-         else
+            -- 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
            -- 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,7 +2,6 @@
 -- 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 = {}
@@ -13,7 +12,6 @@ local BL = require( 'BeamLib')
 local Fbs = require( 'FacesBySaw')
 local DC = require( 'DiceCut')
 local Cut = require( 'ProcessCut')
-local FreeContour = require( 'ProcessFreeContour')

 EgtOutLog( ' ProcessSimpleScarf started', 1)

@@ -30,13 +28,11 @@ 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 and not bForceSideMill then
+      if vtN:getZ() < - 0.5 and Proc.Box:getDimX() / abs( vtN:getZ()) > BD.MAX_DIM_DICE then
         return true, true
      end
   end
@@ -192,127 +188,118 @@ 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
-   -- 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
-      -- 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
+   -- 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
-      -- 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
+   -- 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
-      -- 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)
+      -- 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
-               if #vCuts[i-1] > 0 then
-                  vtOrthoO = Vector3d( EgtIf( vtRef2, vtRef2, vtRef))
+               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
-                  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
+                  vtOrthoO = Y_AX()
               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
+         -- 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
-            -- 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
+   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
   -- aggiornamento ingombro di testa o coda
   if Proc.Head then
@@ -3,10 +3,6 @@
 -- 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 = {}
@@ -258,13 +254,11 @@ 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)
@@ -273,22 +267,20 @@ 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 = ( ( 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)
+   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)
   -- dati geometrici del taglio
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
   -- flag di lavorazione faccia
@@ -347,12 +339,6 @@ 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
@@ -394,29 +380,12 @@ 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 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
+         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
         -- se finitura con truciolatore
-         elseif nQ05 == 2 then
+         elseif EgtGetInfo( nOriId, 'Q05', 'i') == 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'
@@ -430,15 +399,14 @@ 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 sNotesFinal then
-               EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesFinal)
-            end
-            return bOk, sErr, nNewPhase
+            if not bOk then return bOk, sErr, nNewPhase end
+         end
+         if sNotesFinal then
+            EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesFinal)
         end
      end
-   end
   -- se tagli standard
-   if not bDoubleHorizCut then
+   elseif not bDoubleHorizCut then
      -- calcolo extra taglio ed accorciamento
      local dCutExtra = 0
      local dAccStart = 0
@@ -457,12 +425,10 @@ 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, dAccStartDoubleCut, dAccEndDoubleCut, sNotes, b3Raw, true)
+            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)
            if not bOk then return false, sErr end
         end
      end
@@ -489,7 +455,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) and not bBigSectionCut then
+      if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then
         local sErr = 'Error : section too big for tail cut'
         EgtOutLog( sErr)
         return false, sErr
@@ -1,6 +1,5 @@
-- ProcessStepJoint.lua by Egaltech s.r.l. 2022/11/03
+-- ProcessStepJoint.lua by Egaltech s.r.l. 2022/01/26
 -- Gestione calcolo giunto a gradino per Travi
-- 2022/11/03 Correzione per riconoscimento testa da sotto su fresatura.

 -- Tabella per definizione modulo
 local ProcessStepJoint = {}
@@ -84,14 +83,13 @@ 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, bH2
-   sMilling, _, _, bH2 = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bDownHead)
+   local sMilling
+   sMilling, _, _, bDownHead = 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,6 +1,5 @@
-- ProcessStepJointNotch.lua by Egaltech s.r.l. 2022/11/03
+-- ProcessStepJointNotch.lua by Egaltech s.r.l. 2022/01/25
 -- Gestione calcolo tacca a gradino per Travi
-- 2022/11/03 Correzione per riconoscimento testa da sotto su fresatura.

 -- Tabella per definizione modulo
 local ProcessStepJointNotch = {}
@@ -524,14 +523,13 @@ 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, bH2
-   sMilling, _, _, bH2 = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bDownHead)
+   local sMilling
+   sMilling, _, _, bDownHead = 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,11 +1,9 @@
-- ProcessTenon.lua by Egaltech s.r.l. 2022/11/03
+-- ProcessTenon.lua by Egaltech s.r.l. 2022/05/28
 -- 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 = {}
@@ -122,32 +120,11 @@ 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 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
+   -- 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)
   -- abilitazione lavorazione da sotto
   local bMillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.259)
   local bMillDown = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.1)
@@ -225,8 +202,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 vtN:getX() < 0 and abs( vtN:getX()) < 0.999 and abs( vtN:getY()) < 0.259)
-   BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, ( bH2 and bMillDown) ~= bMyShortPart)
+   local bMyShortPart = ( bShortPart and abs( vtN:getX()) < 0.999 and abs( vtN:getY()) < 0.259)
+   BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, bH2 ~= bMyShortPart)
   -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
   local sWarn
   local dDepth = 0
@@ -1,7 +1,5 @@
 -- 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')
@@ -170,20 +168,12 @@ 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)
-   -- 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
+   table.insert( Parts, {Id = nPartId, Len = Len, DispLen = DispLen, Cnt = nCount})
 end

 -- lunghezza totale pezzi
@@ -217,10 +207,7 @@ for ShortIndex = 1, #ShortList do
   ShortCount = ShortCount + ShortList[ShortIndex].Cnt
 end
 local ShortForRaw = floor( ShortCount / MediumRawQty)
-local ExtraShortForRaw = 0
-if MediumRawQty > 0 then
-   ExtraShortForRaw = fmod( ShortCount, MediumRawQty)
-end
+local ExtraShortForRaw = fmod( ShortCount, MediumRawQty)
 -- creo lista pezzi corti singoli
 local SingleShortList = {}
 for ShortIndex = 1, #ShortList do
@@ -338,7 +325,7 @@ while nMachGroup do
   if EgtGetInfo( nMachGroup, "AUTONEST",'i') == 1 then
      EgtRemoveInfo( nMachGroup, "AUTONEST")
      EgtSetInfo( nMachGroup, "UPDATEUI", 1)
-      local bOk, sErr = pcall( dofile, BEAM.BASEDIR .. "\\BatchProcessNew.lua")
+      local bOk, sErr = pcall( dofile, EgtGetSourceDir() .. "BatchProcessNew.lua")
      if not bOk then
         EgtOutLog( 'Error in BatchProcessNew.lua call (' .. ( sErr or '') ..')')
      end
Author	SHA1	Message	Date
luca.mazzoleni	624a188481	Merge branch 'develop' into BugFix/ProcessLapJointThreeFacesLOpenPocket	2022-08-26 12:44:09 +02:00
luca.mazzoleni	d3c2787f81	Merge branch 'develop' into BugFix/ProcessLapJointThreeFacesLOpenPocket	2022-08-23 08:54:45 +02:00
luca.mazzoleni	93b4adfdec	Merge branch 'develop' into BugFix/ProcessLapJointThreeFacesLOpenPocket	2022-08-12 09:58:54 +02:00
luca.mazzoleni	1d672af81e	Merge branch 'develop' into BugFix/ProcessLapJointThreeFacesLOpenPocket	2022-08-12 09:34:38 +02:00
luca.mazzoleni	8a79a7838e	Merge branch 'BugFix/ScarfOneFaceReduceToCut' into BugFix/ProcessLapJointThreeFacesLOpenPocket	2022-08-09 10:28:00 +02:00
luca.mazzoleni	172fc5180a	Merge branch 'develop' into BugFix/ProcessLapJointThreeFacesLOpenPocket	2022-07-29 10:07:59 +02:00
luca.mazzoleni	6064a19a2c	Merge branch 'develop' into BugFix/ProcessLapJointThreeFacesLOpenPocket	2022-07-25 15:34:53 +02:00
luca.mazzoleni	5cc85a8735	Merge branch 'develop' into BugFix/ProcessLapJointThreeFacesLOpenPocket	2022-07-25 11:17:30 +02:00
luca.mazzoleni	7af9a9affb	BugFix/ProcessLapJointThreeFacesLOpenPocket: modificata ProcessLapJoint -> SetOpenSide ma attendere il check della lavorazione C++	2022-07-19 15:10:25 +02:00
luca.mazzoleni	e26a42dfd9	Merge branch 'develop' into BugFix/ProcessLapJointThreeFacesLOpenPocket	2022-07-19 11:09:12 +02:00