Refactoring/MoveSomeFunctionsToBeamLib:

Fix commenti
2022-09-01 16:15:35 +02:00 · 2022-09-01 16:08:50 +02:00 · 2022-09-01 15:52:49 +02:00 · 2022-09-01 15:24:08 +02:00 · 2022-08-30 14:52:35 +02:00 · 2022-08-30 14:42:26 +02:00
15 changed files with 856 additions and 380 deletions
@@ -1,4 +1,4 @@
-- BeamExec.lua by Egaltech s.r.l. 2022/08/08
+-- 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.
@@ -34,6 +34,7 @@
 --            controllata tramite il parametro IMPROVE_HEAD_TAIL_DRILLINGS da BeamData. Attivata di default.
 -- 2022/08/01 Tolleranza su sezione portata a 0.1 mm (100 * GEO.EPS_SMALL).
 -- 2022/08/08 Modifica per macchine senza BD.MAX_WIDTH2 e BD.MAX_HEIGHT2.
+-- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata.

 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -391,6 +392,7 @@ end
 --    *** Inserimento delle travi nel grezzo ***
 -------------------------------------------------------------------------------------------------------------
 local function VerifyBigSectionCut( dRawW, dRawH)
+   -- lama principale
   local sCutting = ML.FindCutting( 'TailSide')
   local dMaxDepth = 50
   if EgtMdbSetCurrMachining( sCutting or '') then
@@ -400,9 +402,19 @@ local function VerifyBigSectionCut( dRawW, dRawH)
      end
   end
   local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
+   -- eventuale lama su testa sotto
+   local sCutting2 = ML.FindCutting( 'TailSide_H2', false, true)
+   local dMaxDepth2 = 0
+   if sCutting2 and EgtMdbSetCurrMachining( sCutting2) then
+      local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then
+         dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2
+      end
+   end
+   -- verifiche
   local dDimYRef = EgtIf( dRawH < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, abs( BD.MAX_DIM_HTCUT_HBEAM))
   local bBigSectionCut = ( dRawW > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and
-                          ( dRawH > EgtIf( BD.DOWN_HEAD or BD.TURN, 2, 1) * dMaxVertDepth - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+                          ( dRawH > EgtIf( BD.TURN, 2 * dMaxVertDepth, dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
   return bBigSectionCut
 end

@@ -16,6 +16,7 @@
 -- 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 = {}
@@ -814,5 +815,237 @@ 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
@@ -12,6 +12,10 @@
 -- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe).
 -- 2022/06/28 Modificata determinazione taglio bFromBottom in MakeFromTop.
 -- 2022/07/18 Se Q04=1, aggiunto LongCut anche dal lato per macchine tipo PF1250.
+-- 2022/08/12 I tagli di lama inclinati in coda ora partono dal centro e non dall'esterno.
+-- 2022/08/24 Disabilitato il dicing per i tagli meno spessi della lama.
+-- 2022/08/25 In caso di AdvTail con taglio lungo Y la profondità di lavorazione è opportunamente diminuita.
+-- 2022/08/30 Modificata la condizione che determina l'utilizzo della testa da sotto. Ora controlla se la trave è più grande del doppio della massima larghezza del cubetto.

 -- Tabella per definizione modulo
 local ProcessCut = {}
@@ -344,10 +348,13 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
         vtExtra = X_AX()
         bAutoCalcSurf = false
      end
-      vCuts = DC.GetDice( nAddGrpId, EgtIf( bForced, b3Raw, b3Solid), ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA)
-      -- se taglio sborda in coda e non è stato inserito nessun taglio a cubetti, lo rilancio con le dimensioni customizzate
-      if ( bFillTail or bCustDiceCut) and #vCuts == 0 then
-         vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA, Proc.Box:getDimY())
+      -- se il taglio è più spesso della lama abilito il dicing, altrimenti no
+      if Proc.Box:getDimX() >= dSawThick then
+         vCuts = DC.GetDice( nAddGrpId, EgtIf( bForced, b3Raw, b3Solid), ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA)
+         -- se taglio sborda in coda e non è stato inserito nessun taglio a cubetti, lo rilancio con le dimensioni customizzate
+         if ( bFillTail or bCustDiceCut) and #vCuts == 0 then
+            vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA, Proc.Box:getDimY())
+         end
      end
   end
   -- se il ProcessCut viene lanciato dal ProcessSawCut e non ci sono tagli a cubetti, esco
@@ -481,14 +488,17 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
         else
            vtOrthoO = -X_AX()
         end
-      elseif Proc.Head then
-         vtOrthoO = EgtIf( vtN:getY() > -0.02, -Y_AX(), Y_AX())
      else
-         if vtN:getZ() < dVzLimDwnUp then
+         if vtN:getZ() < dVzLimDwnUp or Proc.Head or Proc.Tail then
            vtOrthoO = EgtIf( vtN:getY() > -0.02, -Y_AX(), Y_AX())
         else
            vtOrthoO = EgtIf( vtN:getY() > 0.02, Y_AX(), -Y_AX())
         end
+         -- se è una lavorazione da anticipare diminuisco la profondità del taglio per evitare collisioni con l'albero della lama
+         if Proc.AdvTail then
+            local _, dH = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
+            dCutExtra = min( -BD.ADVANCE_TAIL_OFFS, -dH + dMaxDepth)
+         end
      end
      -- taglio
      local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
@@ -713,9 +723,9 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom,
         return true
      end
   end
-   -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -20deg e sbandato oltre 1deg oppure sezione larga o pezzo corto)
+   -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -20deg e sbandato oltre 1deg oppure sezione più larga di 2 cubetti o pezzo corto)
   local bDownHead = ( BD.DOWN_HEAD and vtN:getZ() < -0.341 and
-                       ( abs( vtN:getY()) > 0.017 or b3Raw:getDimY() > 2 * ( BD.MAX_DIM_HTCUT - BD.CUT_EXTRA_MIN) or b3Raw:getDimX() < BD.LEN_SHORT_PART))
+                       ( abs( vtN:getY()) > 0.017 or b3Raw:getDimY() > 2 * ( BD.MAX_DIM_DICE - BD.CUT_EXTRA_MIN) or b3Raw:getDimX() < BD.LEN_SHORT_PART))
   local bDownTurn = ( BD.TURN and vtN:getZ() < -0.017)
   local bTopHead = ( BD.DOWN_HEAD and ( vtN:getZ() > -0.342 or not bDownHead))
   -- recupero la lavorazione
@@ -1,5 +1,6 @@
 -- ProcessDoubleCut.lua by Egaltech s.r.l. 2022/07/11
 -- Gestione calcolo doppi tagli di lama per Travi
+-- 2022/08/29 Implementata la fresatura dal lato per tagli problematici per PF1250

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

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

 -- Tabella per definizione modulo
 local ProcessDrill = {}
@@ -231,15 +232,17 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
      vtExtr = - vtExtr
   end
   local bOpen = ( Proc.Fcs ~= 0  and  Proc.Fce ~= 0)
+   -- verifico possibilità di foratura da sotto
+   local bDownDrill = ( BD.DOWN_HEAD and ML.FindDrilling( dDiam, nil, false, true))
   -- verifico che il foro non sia fattibile solo da sotto
-   local bToInvert = ( vtExtr:getZ() < BD.DRILL_VZ_MIN and not BD.DOWN_HEAD)
+   local bToInvert = ( vtExtr:getZ() < BD.DRILL_VZ_MIN and not bDownDrill)
   if bToInvert  and  ( not bOpen or Proc.Flg ~= 1) then
      local sErr = 'Error : drilling from bottom impossible'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- se non già richiesta inversione e invertibile
-   if not bToInvert and Proc.Flg == 1 and ( -vtExtr:getZ() >= BD.DRILL_VZ_MIN or BD.DOWN_HEAD) then
+   if not bToInvert and Proc.Flg == 1 and ( -vtExtr:getZ() >= BD.DRILL_VZ_MIN or bDownDrill) then
      -- se il foro è cieco o troppo inclinato all'inizio, lo inverto
      local _, CosB, _ = GetHoleStartData( ptCen, vtExtr, b3Solid)
      if Proc.Fcs == 0 or ( CosB > BD.DRILL_VX_MAX and bOpen) then
@@ -262,8 +265,8 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   local dCheckDepth2 = dDepth2
   local nErrorCode = 0
   -- abilitazione foratura da sotto
-   local bDrillDown = ( BD.DOWN_HEAD and ( Proc.Down or vtExtr:getZ() < -0.1 or vtExtr:getZ() < 0.259))
-   local bDrillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.5)
+   local bDrillDown = ( bDownDrill and ( Proc.Down or vtExtr:getZ() < -0.1 or vtExtr:getZ() < 0.259))
+   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)
@@ -479,7 +482,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
   -- eseguo
   local bOk = ML.ApplyMachining( true, false)
-   if not bOk and BD.DOWN_HEAD then
+   if not bOk and bDownDrill then
      if sType == 'Drill' or sType == 'Drill_H2' or sType == 'AngleDrill' then
         EgtSetMachiningParam( MCH_MP.INVERT, true)
      else
@@ -1,4 +1,4 @@
-- ProcessDtMortise.lua by Egaltech s.r.l. 2022/06/07
+-- ProcessDtMortise.lua by Egaltech s.r.l. 2022/08/18
 -- Gestione calcolo mortase a coda di rondine per Travi
 -- 2021/04/08 Aggiunto controllo massimo materiale lavorabile dalla fresa.
 -- 2021/04/08 Miglioria scelta lavorazione in presenza di testa da sotto.
@@ -6,6 +6,7 @@
 -- 2021/07/20 Aggiunta gestione rinvio angolare su FAST.
 -- 2021/12/01 Se frontale aggiungo taglio con Grp e Proc di vero taglio (per aggiornare ingombro di testa /coda).
 -- 2022/06/01 Modifiche per evitare di entrare nel legno con mortase parziali.
+-- 2022/08/18 Migliorato calcolo dello step.

 -- Tabella per definizione modulo
 local ProcessDtMortise = {}
@@ -430,7 +431,8 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
   local dDist = min( vtOrtDiff:len(), dWidthMrt)
   -- calcolo le passate
   local nPass = ceil( dDist / ( 1.9 * dToolDiam))
-   local dStep = ( dDist - 0.95 * dToolDiam) / ( 2 * nPass)
+   local dStep = 0
+   if nPass > 1 then dStep = max( ( dDist - 2 * dToolDiam) / ( 2 * nPass - 2), 0.25 * dToolDiam) end
   for i = nPass, 1, -1 do
      -- inserisco la lavorazione di contornatura
      local sNameF = 'DtMt_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nPass)
@@ -1,5 +1,6 @@
 -- 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

 -- Tabella per definizione modulo
 local ProcessFreeContour = {}
@@ -233,14 +234,16 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
   local dDepth = abs( EgtCurveThickness( AuxId))
   local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
   local b3Aux = EgtGetBBoxGlob( AuxId, GDB_BB.STANDARD)
-   local bToolInv = ( vtExtr:getZ() < -0.1)
+   local 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
   -- verifico i parametri Q per profondità smusso e per eseguirlo in esclusiva
   local nChamfer, dDepthCham, sChamfer = VerifyChamfer( Proc, AuxId, nRawId, true)
-      -- recupero la lavorazione
-   local sMilling = ML.FindMilling( 'FreeContour')
+   -- recupero la lavorazione
+   local bTopHead = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.1)
+   local bDownHead = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.1)
+   local sMilling = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, bTopHead, bDownHead)
   if not sMilling then
      local sErr = 'Error : FreeContour not found in library'
      EgtOutLog( sErr)
@@ -688,6 +691,76 @@ local function MakeByPocket( Proc, nPhase, nRawId, nPartId, dOvmHead)
   return true
 end

+---------------------------------------------------------------------
+local function MakeByMark( Proc, nRawId, b3Raw, nPartId)
+   -- ingombro del pezzo
+   local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
+   local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
+   if not b3Solid then
+      local sErr = 'Error : part box not found'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- recupero e verifico l'entità curva
+   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0
+   if AuxId then AuxId = AuxId + Proc.Id end
+   if not AuxId  or  ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then
+      local sErr = 'Error : missing profile geometry'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- recupero i dati della curva e del profilo
+   local dDepth = abs( EgtCurveThickness( AuxId))
+   local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
+   local bToolInv = ( vtExtr:getZ() < -0.1 and b3Aux:getDimZ() > b3Raw:getDimZ() - 5)
+   -- verifico che la marcatura non sia orientata verso il basso (-5 deg)
+   if vtExtr:getZ() < - 0.1 and not BD.DOWN_HEAD and not BD.TURN then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Mark from bottom impossible'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- abilitazione lavorazione da sotto
+   local bMillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.259)
+   local bMillDown = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.174)
+   -- recupero la lavorazione
+   local sMillType = 'Text'
+   --local sMchExt = EgtIf( bMillDown, '_H2', '')
+   local sMilling = ML.FindMilling( sMillType, nil, nil, nil, nil, bMillUp, bMillDown)
+   if not sMilling then
+      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- inserisco la lavorazione
+   local sName = 'FreeMark_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+   local nMchId = EgtAddMachining( sName, sMilling)
+   if not nMchId then
+      local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   EgtSetInfo( nMchId, 'Part', Proc.PartId)
+   -- aggiungo geometria
+   EgtSetMachiningGeometry( {{ AuxId, -1}})
+   -- se estrusione da sotto, inverto direzione fresa
+   if bToolInv then
+      EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+   end
+   -- posizione braccio porta testa
+   local nSCC = MCH_SCC.ADIR_ZP
+   if AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
+      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
+   end
+   EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+   -- eseguo
+   if not EgtApplyMachining( true, false) then
+      local _, sErr = EgtGetLastMachMgrError()
+      EgtSetOperationMode( nMchId, false)
+      return false, sErr
+   end
+   return true
+end
+
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessFreeContour.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
@@ -698,7 +771,15 @@ function ProcessFreeContour.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
      return MakeByPocket( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- altrimenti contornatura
   else
-      return MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
+      -- recupero il tipo di lavorazione
+      local nCntType = EgtGetInfo( Proc.Id, 'CNT_TYPE', 'i') or 0
+      -- se marcatura
+      if nCntType == 10 then
+         return MakeByMark( Proc, nRawId, b3Raw, nPartId)
+      -- se fresatura
+      else
+         return MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
+      end
   end
 end

@@ -1,7 +1,8 @@
-- ProcessSplit.lua by Egaltech s.r.l. 2022/07/25
+-- 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.

 -- Tabella per definizione modulo
 local ProcessHeadCut = {}
@@ -173,10 +174,22 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
      end
   end
   local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
+   -- recupero la eventuale lavorazione con lama da sotto
+   local sCutting2 = ML.FindCutting( 'HeadSide_H2', false, true)
+   -- recupero i dati della eventuale seconda lama
+   local dSawDiam2 = 0
+   local dMaxDepth2 = 0
+   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
+      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.DOWN_HEAD or BD.TURN, 2, 1) * dMaxVertDepth - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+                          ( b3Raw:getDimZ() > EgtIf( BD.TURN, 2 * dMaxVertDepth, dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
   local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA)
   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
   local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL)
@@ -250,23 +263,12 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
      end
   -- altrimenti necessari tagli da sopra e sotto con testa opportuna
   else
-      -- recupero la lavorazione con lama da sotto
-      local sCutting2 = ML.FindCutting( 'HeadSide_H2', false, true)
+      -- verifico esistenza della lavorazione con lama da sotto
      if not sCutting2 then
         local sErr = 'Error : cutting H2 not found in library'
         EgtOutLog( sErr)
         return false, sErr
      end
-      -- recupero i dati della seconda lama
-      local dSawDiam2 = 400
-      local dMaxDepth2 = 50
-      if EgtMdbSetCurrMachining( sCutting2) then
-         local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then
-            dSawDiam2 = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam2
-            dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2
-         end
-      end
      -- verifico che le due lame riescano a lavorare la sezione
      local dDimZ = b3Raw:getDimZ()
      local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ
@@ -279,16 +281,18 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
      local dCutExtra = -dMaxDepth2 + dExtra / 2 + BD.CUT_EXTRA_MIN
      local dCutExtra2 = -dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
      local dAccStart = 0
+      local dVzLimDwnUp
+      if BD.TURN then dVzLimDwnUp = -2 end
      -- eseguo i tagli da sotto necessari
      for i = nCuts, 1, -1 do
         local dCutOffset = ( i - 1) * dOffsL
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, nil, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
         if not bOk then return false, sErr end
      end
      -- eseguo i tagli da sopra necessari
      for i = nCuts, 1, -1 do
         local dCutOffset = ( i - 1) * dOffsL
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
         if not bOk then return false, sErr end
      end
   end
@@ -49,6 +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/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.

 -- Tabella per definizione modulo
 local ProcessLapJoint = {}
@@ -443,62 +445,6 @@ 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)

@@ -533,23 +479,6 @@ 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
@@ -757,7 +686,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 = GetTunnelDimension( Proc, nPartId)
+         local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
         EgtErase( nSurfInt)
         -- verifico se può essere fatto con svuotatura
         if VerifyPocket( Proc, dDimMin) then
@@ -1322,165 +1251,6 @@ 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
-      -- 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
-
 ---------------------------------------------------------------------
 local function MakeRoundCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, 
                                     nFacInd, nAddGrpId, dDiam, bMillDown, bDoubleSide)
@@ -1727,7 +1497,7 @@ local function MakeRoundCleanContour( Proc, nPhase, nRawId, nPartId, b3Raw,
         return false, sErr
      end
      -- distanza di sicurezza per evitare collisioni
-      dCollSic = CalcCollisionSafety( vtN1)
+      dCollSic = BL.CalcCollisionSafety( vtN1)
      -- elevazione massima della faccia
      dMaxElev = BL.GetFaceElevation( Proc.Id, nFacInd, nPartId)
      -- ciclo tutta la tabella
@@ -1772,7 +1542,7 @@ local function MakeRoundCleanContour( Proc, nPhase, nRawId, nPartId, b3Raw,
      nFirstId = EgtCopyGlob( nPathInt, nAddGrpId)
      nNumId = 1
      -- distanza di sicurezza per evitare collisioni
-      dCollSic = CalcCollisionSafety( vtOrtho)
+      dCollSic = BL.CalcCollisionSafety( vtOrtho)
      -- calcolo elevazione dalla faccia trasversale aggiunta
      local dSurfIntElev = BL.GetOtherFaceElevation( Proc.Id, nSurfInt, 0)
      if bDoubleSide then
@@ -1797,7 +1567,7 @@ local function MakeRoundCleanContour( Proc, nPhase, nRawId, nPartId, b3Raw,
      -- normale alla faccia aggiunta
      vtN1 = Vector3d( vtOrtho)
      -- imposto i lati aperti
-      SetOpenSide( nFirstId, vtOrtho, b3Solid, nAddGrpId, 2)
+      BL.SetOpenSide( nFirstId, vtOrtho, b3Solid, nAddGrpId, 2)
   end

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

      -- estraggo i percorsi
@@ -2665,7 +2435,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 = GetTunnelDimension( Proc, nPartId)
+      local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
   end
   -- Recupero le facce adiacenti alla principale
   local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacInd)[1]
@@ -2826,7 +2596,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,

   if bOrthoFaces then
      -- ottengo le dimensioni del tunnel
-      dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId)
+      dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
      -- verifico la direzione 
      -- se devo inserire il chamfer
      if nChamfer > 0 then
@@ -3574,7 +3344,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 = GetTunnelDimension( Proc, nPartId)
+      dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
      -- se due facce posso utilizzare utensile con diametro doppio della dimensione minima
      if Proc.Fct == 2 then
         dDimMin = 2 * dDimMin
@@ -3615,7 +3385,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
-               SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId)
+               BL.SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId)
            end
            -- variabili per parametri lavorazione
            local dMachDepth
@@ -3624,7 +3394,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
            local bOneShot
            local bComplete = true
            -- imposto altezza aggiuntiva di elevazione
-            local dCollSic = CalcCollisionSafety( vtOrtho)
+            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
@@ -3823,7 +3593,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
               end
               if bPock3rd then
                  -- recupero la distanza di sicurezza aggiuntiva
-                  local dFacCollSic = CalcCollisionSafety( vtN)
+                  local dFacCollSic = BL.CalcCollisionSafety( vtN)
                  -- scelgo se lavorare da sotto
                  local bFacPocketDn = ( bMakePocketDn and vtN:getZ() < -0.174)
                  -- inserisco la lavorazione di svuotatura
@@ -4217,7 +3987,7 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
         end
         -- prendo il primo versore
         _, vtN1 = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT)
-         dCollSic = CalcCollisionSafety( vtN1) or 0
+         dCollSic = BL.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

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

-         dCollSic = CalcCollisionSafety( vtOrtho)
+         dCollSic = BL.CalcCollisionSafety( vtOrtho)
         nFirstId = EgtCopyGlob( nPathInt, nAddGrpId)
         nNumId = 1
         -- calcolo elevazione dalla faccia trasversale aggiunta
@@ -4298,7 +4068,7 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
            end
         end
         vtN1 = Vector3d(vtOrtho)
-         local bOkPath = SetOpenSide( nFirstId, vtOrtho, b3Solid, nAddGrpId, 2)
+         local bOkPath = BL.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
@@ -4349,6 +4119,59 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
   return true, sMyWarn
 end

+---------------------------------------------------------------------
+local function MakeTunnelByChainSaw( Proc, sSawing, nLundIdFace, vtOrtho, dWorkDepth, dMaxMat, nStep, dStep, sFaceUse, bOpposite)
+   for i = 1, nStep do
+      -- inserisco la lavorazione di sawing
+      local sName = ''
+      if bOpposite then
+         sName = 'Csaw_Opp_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
+      else
+         sName = 'Csaw_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
+      end
+      local nMchFId = EgtAddMachining( sName, sSawing)
+      if not nMchFId then
+         local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- aggiungo geometria
+      EgtSetMachiningGeometry( {{ Proc.Id, nLundIdFace}})
+      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nLundIdFace, GDB_ID.ROOT)
+      -- imposto angolo 3° asse rot
+      EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 1))
+      EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 1))
+      -- imposto offset radiale
+      local dOffs = ( i - 1) * dStep
+      EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
+      EgtSetMachiningParam( MCH_MP.FACEUSE, sFaceUse)
+      EgtSetMachiningParam( MCH_MP.DEPTH, dWorkDepth)
+      -- modifico la distanza di attacco per considerare anche tunnel inclinati
+      EgtSetMachiningParam( MCH_MP.STARTPOS, 50)
+      -- eseguo
+      if not ML.ApplyMachining( true, false) then
+         if EgtGetOutstrokeInfo() then
+            local _, sErr = EgtGetLastMachMgrError()
+            EgtSetOperationMode( nMchFId, false)
+            return false, sErr
+         end
+         EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 2))
+         EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 2))
+         if not ML.ApplyMachining( true, false) then
+            local _, sErr = EgtGetLastMachMgrError()
+            EgtSetOperationMode( nMchFId, false)
+            return false, sErr
+         end
+      end
+      if EgtIsMachiningEmpty() then
+         _, sWarn = EgtGetMachMgrWarning( 0)
+         EgtSetOperationMode( nMchFId, false)
+         return false, sWarn
+      end
+   end
+   return true
+end
+
 ---------------------------------------------------------------------
 local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePart, bPrevBhSideMill, bAllWithEndCap)
   if not BD.MAXDIAM_POCK_CORNER then
@@ -4470,63 +4293,40 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
            if nStep > 1 then
               dStep = ( dDimMin - dSawThick) / ( nStep - 1)
            end
-            for i = 1, nStep do
-               -- inserisco la lavorazione di sawing
-               local sName = 'Csaw_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
-               local nMchFId = EgtAddMachining( sName, sSawing)
-               if not nMchFId then
-                  local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing
-                  EgtOutLog( sErr)
-                  return false, sErr
-               end
-               -- aggiungo geometria
-               EgtSetMachiningGeometry( {{ Proc.Id, nLundIdFace}})
-               -- imposto uso del lato faccia
-               -- al momento, dato che la fessura è passante da parte a parte, gestisco solo la lavorazione
-               -- dall'alto e di fronte (da dietro è disabilitata perchè ho extracorsa con la FAST). 
-               -- Questa feature non è applicata su facce di testa e quindi non controllo l'entrata in X
-               if abs(vtOrtho:getZ()) >= 0.707 then
-                  EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN)
-               else
-                  EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_BACK)
-               end
-               local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nLundIdFace, GDB_ID.ROOT)
-               -- imposto angolo 3° asse rot
-               EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 1))
-               EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 1))
-               -- imposto offset radiale
-               local dOffs = ( i - 1) * dStep
-               EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
-               -- se possibile aumento l'affondamento pari al raggio corner + 1
-               if dMaxMat > (dDepth + dSawCornerRad + 1) then
-                  EgtSetMachiningParam( MCH_MP.DEPTH, (dDepth + dSawCornerRad + 1))
-               -- se massimo affondamento utensile inferiore fessura, setto affondamento ed emetto warning
-               elseif dMaxMat < dDepth then
-                  EgtSetMachiningParam( MCH_MP.DEPTH, dMaxMat)
-                  sWarn = 'Warning : elevation bigger than max tool depth'
-                  EgtOutLog( sWarn)
-               end
-               -- eseguo
-               if not ML.ApplyMachining( true, false) then
-                  if EgtGetOutstrokeInfo() then
-                     local _, sErr = EgtGetLastMachMgrError()
-                     EgtSetOperationMode( nMchFId, false)
-                     return false, sErr
-                  end
-                  EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 2))
-                  EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 2))
-                  if not ML.ApplyMachining( true, false) then
-                     local _, sErr = EgtGetLastMachMgrError()
-                     EgtSetOperationMode( nMchFId, false)
-                     return false, sErr
-                  end
-               end
-               if EgtIsMachiningEmpty() then
-                  _, sWarn = EgtGetMachMgrWarning( 0)
-                  EgtSetOperationMode( nMchFId, false)
-                  return false, sWarn
+            local bSplit = false
+            local sFaceUse, sFaceUseOtherSide
+            -- imposto il lato di lavorazione, da sopra oppure di fronte
+            -- se è di fronte, non è una Fast e il tagliente non arriva splitto la lavorazione
+            -- Questa feature non è applicata su facce di testa e quindi non controllo l'entrata in X
+            if abs(vtOrtho:getZ()) >= 0.707 then
+               sFaceUse = MCH_MILL_FU.PARAL_DOWN
+            else
+               sFaceUse = MCH_MILL_FU.PARAL_BACK
+               -- per escludere la Fast controllo C_SIMM
+               if BD.C_SIMM and dMaxMat < dDepth then
+                  bSplit = true
+                  sFaceUseOtherSide = MCH_MILL_FU.PARAL_FRONT
+                  dDepth = dDepth / 2 + BD.CUT_EXTRA
               end
            end
+            local dWorkDepth = dDepth
+            -- cerco di estendere il taglio considerando la parte arrotondata della lama + 1
+            if dMaxMat > dDepth + dSawCornerRad + 1 then
+               dWorkDepth = dDepth + dSawCornerRad + 1
+            -- se massimo affondamento utensile inferiore alla profondità da lavorare, setto la profondità di lavoro e emetto warning
+            elseif dMaxMat < dDepth then
+               dWorkDepth = dMaxMat
+               sWarn = 'Warning : elevation bigger than max tool depth'
+               EgtOutLog( sWarn)
+            end
+            -- lavoro da un lato
+            local bOk, sErr = MakeTunnelByChainSaw( Proc, sSawing, nLundIdFace, vtOrtho, dWorkDepth, dMaxMat, nStep, dStep, sFaceUse, false)
+            if not bOk then return false, sErr end
+            -- se è da lavorare anche dall'altro lato
+            if bSplit then
+               bOk, sErr = MakeTunnelByChainSaw( Proc, sSawing, nLundIdFace, vtOrtho, dWorkDepth, dMaxMat, nStep, dStep, sFaceUseOtherSide, true)
+               if not bOk then return false, sErr end
+            end
         end
      end
   -- altrimenti non è una fessura
@@ -4837,7 +4637,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 = CalcCollisionSafety( vtN)
+            local dCollSic = BL.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)
@@ -5104,7 +4904,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 = GetTunnelDimension( Proc, nPartId)
+                           local _, _, _, vtOrtho, _, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
                           local nOk, sErr = MakeChamfer( Proc, true, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)
                           if nOk < 0 then return false, sErr end
                        end
@@ -5147,13 +4947,13 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                        -- 3 facce non a L ma con una faccia favorevole a Y, oppure
                        -- 4 facce
                        -- lancio la MakePocket ( lavorazione solo da un lato, fondo della tasca la faccia più favorevole a Y)
-                        if bForceSideMill and (( Proc.Fct == 3 and bIsL) or ( Proc.Fct == 3 and abs( vtNFacApproxY:getY()) >= 0.707 ) or Proc.Fct == 4) then
+                        if bForceSideMill and (( Proc.Fct == 3 and bIsL) or ( ( Proc.Fct == 3 or Proc.Fct == 2) and abs( vtNFacApproxY:getY()) >= 0.707 ) or Proc.Fct == 4) then
                           nFacInd, vtN, ptC = nFacApproxY, vtNFacApproxY, ptCFacApproxY
                           local tvtNx = {}
                           tvtNx[2] = vtN
                           local ptPs = ptC
                           dFacElev = BL.GetFaceElevation( Proc.Id, nFacInd)
-                           dCollSic = CalcCollisionSafety( tvtNx[2])
+                           dCollSic = BL.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
@@ -5340,7 +5140,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 = GetTunnelDimension( Proc, nPartId)
+                  local _, _, _, vtOrtho, _, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
                  local nOk, sErr = MakeChamfer( Proc, true, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)
                  if nOk < 0 then return false, sErr end
               end
@@ -5767,7 +5567,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 = GetTunnelDimension( Proc, nPartId)
+                  local _, _, _, vtOrtho, _, nSurfInt = BL.GetTunnelDimension( Proc, nPartId)
                  local nOk, sErr = MakeChamfer( Proc, true, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)
                  if nOk < 0 then return false, sErr end
               end
@@ -323,8 +323,8 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
   EgtOutLog( 'ptC=' .. tostring( ptC) ..' vtN=' .. tostring( vtN), 3)
   -- Se mortasa chiusa
   if not bOpenBtm then
-      -- verifico che la mortasa non sia orientata verso il basso (limite -5 deg) o che ci sia una testa da sotto o un rinvio angolare
-      if vtN:getZ() < -0.1 and not BD.DOWN_HEAD and not BD.ANG_TRASM then
+      -- verifico che la mortasa non sia orientata verso il basso (limite -5 deg) o che ci sia una testa da sotto o un rinvio angolare o macchina Turn
+      if vtN:getZ() < -0.1 and not BD.DOWN_HEAD and not BD.ANG_TRASM and not BD.TURN then
         local sErr = 'Error : Mortise from bottom impossible'
         EgtOutLog( sErr)
         return false, sErr
@@ -440,7 +440,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
      local sMillingDown
      if bDouble then
         if nSide == 0  then
-            if BD.DOWN_HEAD then               
+            if BD.DOWN_HEAD then
               -- recupero la lavorazione
               sMillingDown = ML.FindMilling( 'Prof_H2', nil, nil, nil, nil, false, true)
               if not sMillingDown then
@@ -448,7 +448,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
                  EgtOutLog( sWarn)
                  bDouble = false
               end
-            else
+            elseif not BD.TURN then
               sWarn = 'Warning in profiling : depth (' .. EgtNumToString( dProfDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dToolMaxDepth, 1) .. ')'
               EgtOutLog( sWarn)
               bDouble = false
@@ -489,7 +489,9 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         -- imposto l'affondamento
         EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
         -- posizione braccio porta testa
-         EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
+         local nSCC = EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
+         if BD.TURN then nSCC = MCH_SCC.ADIR_ZP end
+         EgtSetMachiningParam( MCH_MP.SCC, nSCC)
         -- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
         local bFinish
         local dOriOffset = 0
@@ -588,7 +590,9 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
      end
      -- posizione braccio porta testa
-      EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
+      local nSCC = EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
+      if BD.TURN then nSCC = MCH_SCC.ADIR_ZP end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
      -- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
      local bFinish
      local dOriOffset = 0
@@ -633,7 +637,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
      -- se parametro Q disabilitato, e consentito anche in alcuni casi lavorarlo con la feature da sotto 
      -- inserisco eventuale finitura faccia finale (ortogonale alla trave o, se da sotto, parallela)
      if EgtGetInfo( Proc.Id, sEnableExtraMillUpperFace, 'i') ~= 1 and bLastTrim and
-         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD))) then
+         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD or BD.TURN))) then
         sName = 'ProfV_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
         local nMchVId = EgtAddMachining( sName, sMilling)
         if not nMchVId then
@@ -659,6 +663,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH')
         EgtSetMachiningParam( MCH_MP.STEP, 0)
         EgtSetMachiningParam( MCH_MP.OFFSR, 0)
+         if BD.TURN then EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_ZP) end
         -- eseguo
         if not ML.ApplyMachining( true, false) then
            local _, sErr = EgtGetLastMachMgrError()
@@ -669,7 +674,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
      -- se parametro Q disabilitato, e consentito anche in alcuni casi lavorarlo con la feature da sotto 
      -- inserisco eventuale finitura faccia finale (ortogonale alla trave o, se da sotto, parallela)
      if EgtGetInfo( Proc.Id, sEnableExtraMillUpperFace, 'i') ~= 1 and bFirstTrim and
-         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD))) then
+         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD or BD.TURN))) then
         sName = 'ProfV2_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
         local nMchV2Id = EgtAddMachining( sName, sMilling)
         if not nMchV2Id then
@@ -692,6 +697,7 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         EgtSetMachiningParam( MCH_MP.STEP, 0)
         EgtSetMachiningParam( MCH_MP.OFFSR, 0)
         EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dWidth, 1))
+         if BD.TURN then EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_ZP) end
         -- eseguo
         if not ML.ApplyMachining( true, false) then
            local _, sErr = EgtGetLastMachMgrError()
@@ -440,7 +440,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
      local sMillingDown
      if bDouble then
         if nSide == 0  then
-            if BD.DOWN_HEAD then               
+            if BD.DOWN_HEAD then
               -- recupero la lavorazione
               sMillingDown = ML.FindMilling( 'Prof_H2', nil, nil, nil, nil, false, true)
               if not sMillingDown then
@@ -448,7 +448,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
                  EgtOutLog( sWarn)
                  bDouble = false
               end
-            else
+            elseif not BD.TURN then
               sWarn = 'Warning in profiling : depth (' .. EgtNumToString( dProfDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dToolMaxDepth, 1) .. ')'
               EgtOutLog( sWarn)
               bDouble = false
@@ -489,7 +489,9 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         -- imposto l'affondamento
         EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
         -- posizione braccio porta testa
-         EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
+         local nSCC = EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
+         if BD.TURN then nSCC = MCH_SCC.ADIR_ZP end
+         EgtSetMachiningParam( MCH_MP.SCC, nSCC)
         -- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
         local bFinish
         local dOriOffset = 0
@@ -588,7 +590,9 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
      end
      -- posizione braccio porta testa
-      EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
+      local nSCC = EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
+      if BD.TURN then nSCC = MCH_SCC.ADIR_ZP end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
      -- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
      local bFinish
      local dOriOffset = 0
@@ -633,7 +637,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
      -- se parametro Q disabilitato, e consentito anche in alcuni casi lavorarlo con la feature da sotto 
      -- inserisco eventuale finitura faccia finale (ortogonale alla trave o, se da sotto, parallela)
      if EgtGetInfo( Proc.Id, sEnableExtraMillUpperFace, 'i') ~= 1 and bLastTrim and
-         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD))) then
+         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD or BD.TURN))) then
         sName = 'ProfV_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
         local nMchVId = EgtAddMachining( sName, sMilling)
         if not nMchVId then
@@ -659,6 +663,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH')
         EgtSetMachiningParam( MCH_MP.STEP, 0)
         EgtSetMachiningParam( MCH_MP.OFFSR, 0)
+         if BD.TURN then EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_ZP) end
         -- eseguo
         if not ML.ApplyMachining( true, false) then
            local _, sErr = EgtGetLastMachMgrError()
@@ -669,7 +674,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
      -- se parametro Q disabilitato, e consentito anche in alcuni casi lavorarlo con la feature da sotto 
      -- inserisco eventuale finitura faccia finale (ortogonale alla trave o, se da sotto, parallela)
      if EgtGetInfo( Proc.Id, sEnableExtraMillUpperFace, 'i') ~= 1 and bFirstTrim and
-         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD))) then
+         ( nSide ~= -1 or ( nSide == -1 and ( EgtGetInfo( Proc.Id, sMachFacesUnderneath, 'i') == 1 or BD.DOWN_HEAD or BD.TURN))) then
         sName = 'ProfV2_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
         local nMchV2Id = EgtAddMachining( sName, sMilling)
         if not nMchV2Id then
@@ -692,6 +697,7 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         EgtSetMachiningParam( MCH_MP.STEP, 0)
         EgtSetMachiningParam( MCH_MP.OFFSR, 0)
         EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dWidth, 1))
+         if BD.TURN then EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_ZP) end
         -- eseguo
         if not ML.ApplyMachining( true, false) then
            local _, sErr = EgtGetLastMachMgrError()
@@ -701,12 +707,13 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
      end
   end
   -- aggiorno ingombro testa o coda per presa
-   if nSide ~= 1 then
+   if nSide ~= 1 then -- se feature di fianco o da sotto
      if bHead then
         BL.UpdateHCING( nRawId, b3Raw:getMax():getX() - dCurrOvmH - Proc.Box:getMin():getX())
      else
         BL.UpdateTCING( nRawId, Proc.Box:getMax():getX() - b3Solid:getMin():getX())
      end
+   -- altrimenti feature da sopra
   else
      if bHead then
         BL.UpdateHCING( nRawId, b3Raw:getMax():getX() - dCurrOvmH - Proc.Box:getMax():getX())
@@ -500,20 +500,20 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
      if abs( vtRef:getZ()) > 0.1 then
         local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
         if b3Fac1 then dHCI = b3Raw:getMax():getX() - dOvmHead - b3Fac1:getMin():getX() end
+         dHCI = 0.75 * dHCI
      else
         dHCI = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX()
      end
-      dHCI = 0.75 * dHCI
      BL.UpdateHCING( nRawId, dHCI)
   elseif Proc.Tail then
      local dTCI = 0
      if abs( vtRef:getZ()) > 0.1 then
         local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
         if b3Fac1 then dTCI = b3Fac1:getMax():getX() - b3Solid:getMin():getX() end
+         dTCI = 0.75 * dTCI
      else
         dTCI = Proc.Box:getMax():getX() - b3Solid:getMin():getX()
      end
-      dTCI = 0.75 * dTCI
      BL.UpdateTCING( nRawId, dTCI)
   end

@@ -1,7 +1,8 @@
-- ProcessSplit.lua by Egaltech s.r.l. 2022/07/26
+-- ProcessSplit.lua by Egaltech s.r.l. 2022/08/18
 -- Gestione calcolo tagli di separazione per Travi
 -- 2022/05/31 Aggiunta gestione sezioni alte e larghe con taglio con sega a catena seguito da rifinitura con lama (aggiunta funzione MakeSplitByChainSaw); gestione eventuale creazione nuova fase dall'interno della Make.
 -- 2022/06/10 Per sezioni alte e larghe aggiunta gestione finitura in base a sovramateriale e a parametro Q05 dell' eventuale lavorazione sostituita.
+-- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata.

 -- Tabella per definizione modulo
 local ProcessSplit = {}
@@ -261,10 +262,22 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
      end
   end
   local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
+   -- recupero la eventuale lavorazione con lama da sotto
+   local sCutting2 = ML.FindCutting( 'TailSide_H2', false, true)
+   -- recupero i dati della eventuale seconda lama
+   local dSawDiam2 = 0
+   local dMaxDepth2 = 0
+   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
+      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.DOWN_HEAD or BD.TURN, 2, 1) * dMaxVertDepth - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+                          ( b3Raw:getDimZ() > EgtIf( BD.TURN, 2 * dMaxVertDepth,  dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
   local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and ( b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA))
   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
   local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA  + 10 * GEO.EPS_SMALL)
@@ -433,23 +446,12 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
      end
   -- altrimenti necessari tagli da sopra e sotto con testa opportuna
   else
-      -- recupero la lavorazione con lama da sotto
-      local sCutting2 = ML.FindCutting( 'TailSide_H2', false, true)
+      -- verifico esistenza della lavorazione con lama da sotto
      if not sCutting2 then
         local sErr = 'Error : cutting H2 not found in library'
         EgtOutLog( sErr)
         return false, sErr
      end
-      -- recupero i dati della seconda lama
-      local dSawDiam2 = 400
-      local dMaxDepth2 = 50
-      if EgtMdbSetCurrMachining( sCutting2) then
-         local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then
-            dSawDiam2 = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam2
-            dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2
-         end
-      end
      -- verifico che le due lame riescano a lavorare la sezione
      local dDimZ = b3Raw:getDimZ()
      local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ
@@ -462,11 +464,14 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
      local dCutExtra = -dMaxDepth2 + dExtra / 2 + BD.CUT_EXTRA_MIN
      local dCutExtra2 = -dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
      local dAccStart = 0
+      -- limiti da sotto
+      local dVzLimDwnUp
+      if BD.TURN then dVzLimDwnUp = -2 end
      -- eseguo i tagli da sotto necessari
      for i = nCuts, 1, -1 do
         local dCutOffset = ( i - 1) * dOffsL
         local sNotes = EgtIf( bSplit, 'Presplit;', 'Precut;')
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, nil, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
         if not bOk then return false, sErr end
      end
      -- eseguo i tagli da sopra necessari
@@ -478,7 +483,7 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
         else
            sNotes = EgtIf( i == 1, 'Cut;', 'Precut;')
         end
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
         if not bOk then return false, sErr end
      end
   end
@@ -46,7 +46,7 @@ function ProcessText.Make( Proc, nPhase, nRawId, nPartId)
      return false, sErr
   end
   -- verifico che il testo non sia orientato verso il basso (-5 deg)
-   if vtN:getZ() < - 0.1 and not BD.DOWN_HEAD then
+   if vtN:getZ() < - 0.1 and not BD.DOWN_HEAD and not BD.TURN then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Text from bottom impossible'
      EgtOutLog( sErr)
      return false, sErr
Author	SHA1	Message	Date
luca.mazzoleni	04b0650f96	Refactoring/MoveSomeFunctionsToBeamLib: Fix commenti	2022-09-01 16:15:35 +02:00
luca.mazzoleni	8b31881abb	Refactoring/MoveSomeFunctionsToBeamLib: spostata SetOpenSide da LapJoint a BeamLib	2022-09-01 16:08:50 +02:00
luca.mazzoleni	055d8bd4d3	Refactoring/MoveSomeFunctionsToBeamLib: piccola correzione	2022-09-01 15:52:49 +02:00
luca.mazzoleni	b0e10cee87	Refactoring/MoveSomeFunctionsToBeamLib: spostate le funzioni GetTunnelDimension e CalcCollisionSafety da LapJoint a BeamLib	2022-09-01 15:24:08 +02:00
luca.mazzoleni	a9e43984a2	Merge branch 'BugFix/Ticket#787' into develop	2022-08-30 14:52:35 +02:00
luca.mazzoleni	1e93303981	BugFix/Ticket#787 : In ProcessCut 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-08-30 14:42:26 +02:00
luca.mazzoleni	7fec3d6584	in DoubleCut aggiunta la gestione del parametro CUT_VZ_MIN, da BeamData	2022-08-29 15:47:04 +02:00
luca.mazzoleni	e61cc2ba08	Merge branch 'BugFix/DoubleCutCollision' into develop	2022-08-29 13:25:42 +02:00
luca.mazzoleni	516a56c8b5	BugFix/DoubleCutCollision: update commenti	2022-08-29 13:25:07 +02:00
luca.mazzoleni	2482338a12	BugFix/DoubleCutCollision: inDoubleCut implementata la fresatura di lato nel caso di lavorazione con lama problematica	2022-08-29 12:52:57 +02:00
luca.mazzoleni	0528ac4a31	BugFix/DoubleCutCollision: doublecut impostata per lanciare fresatura di lato in caso di lavorazione con lama problematica; da aggiungere la fresatura di lato	2022-08-26 18:30:49 +02:00
luca.mazzoleni	4e77597b7d	Merge remote-tracking branch 'origin/master' into develop	2022-08-26 12:43:34 +02:00
DarioS	058babe605	DataBeam : - modifiche su lavorazione di Profili Concavo e Convesso per macchina Turn.	2022-08-25 17:47:50 +02:00
luca.mazzoleni	a7676c7331	Merge branch 'BugFix/CutOnShortAndTallBeams' into develop	2022-08-25 16:35:02 +02:00
luca.mazzoleni	f1abaeaac3	Merge branch 'master' into develop	2022-08-25 16:34:51 +02:00
luca.mazzoleni	5db6398725	BugFix/CutOnShortAndTallBeams: migliorato il calcolo della riduzione di profondità di lavorazione	2022-08-25 16:12:32 +02:00
luca.mazzoleni	a8924f4425	BugFix/CutOnShortAndTallBeams: In ProcessCut nel caso di pezzi corti (AdvTail) con taglio lungo Y la profondità di lavorazione è opportunamente diminuita.	2022-08-25 12:32:57 +02:00
DarioS	e4c5a2e06d	DataBeam : - piccoli aggiustamenti per TURN.	2022-08-25 11:42:34 +02:00
luca.mazzoleni	29ed56df16	Merge branch 'BugFix/NoDicingIfCutNotThickerThanSaw' into develop	2022-08-24 16:56:34 +02:00
luca.mazzoleni	6d64f2232d	BugFix/NoDicingIfCutNotThickerThanSaw: In ProcessCut disabilitato il dicing per tagli meno spessi della lama	2022-08-24 16:45:47 +02:00
luca.mazzoleni	e0abdbbe63	Merge branch 'Feature/MarkingInFreeContour' into develop	2022-08-23 18:29:34 +02:00
luca.mazzoleni	45afa144ad	Feature/MarkingInFreeContour: In FreeContour aggiunta la gestione dell'utensile penna per P13=10	2022-08-23 18:19:44 +02:00
luca.mazzoleni	dc4a0eda3e	Merge remote-tracking branch 'origin/master' into develop	2022-08-23 12:00:10 +02:00
DarioS	b0cdb95e48	DataBeam : - modifiche a lavorazione FreeContour per macchine con testa da sotto.	2022-08-23 11:49:05 +02:00
luca.mazzoleni	53e8605297	Merge branch 'BugFix/BetterFaceuseOnCutOnTail' into develop	2022-08-23 10:42:53 +02:00
luca.mazzoleni	41e490dcd2	Merge branch 'develop' into BugFix/BetterFaceuseOnCutOnTail	2022-08-23 08:54:30 +02:00
luca.mazzoleni	56f66d66c3	Merge remote-tracking branch 'origin/master' into develop	2022-08-23 08:54:07 +02:00
DarioS	7497b62dee	DataBeam : - in mortase a coda di rondine migliorato calcolo step tra passate.	2022-08-18 19:38:00 +02:00
DarioS	e67e397225	DataBeam : - modiciche a taglio di testa e taglio di separazione per macchine con testa da sotto con lama disabilitata - modiciche a forature per macchine con testa da sotto con puntaa disabilitata.	2022-08-18 15:11:21 +02:00
luca.mazzoleni	a972fbd425	BugFix/BetterFaceuseOnCutOnTail nella ProcessCut i tagli inclinati in coda ora partono dal centro (scelta faceUse migliore)	2022-08-12 17:48:12 +02:00
luca.mazzoleni	d5140acc91	BugFix: correzioni minori	2022-08-12 09:58:33 +02:00
luca.mazzoleni	b197c96a34	Feature/DoubleSideChainSawLapJoint modificati commenti	2022-08-12 09:27:06 +02:00
luca.mazzoleni	f3a72a7683	Merge branch 'Feature/DoubleSideChainSawLapJoint' into develop	2022-08-11 19:05:36 +02:00
luca.mazzoleni	d72560241b	Feature/DoubleSideChainSawLapJoint: In ProcessLapJoint aggiunta lavorazione tunnel splittata con sega a catena per tutte le macchine ad esclusione della Fast	2022-08-11 18:58:18 +02:00
luca.mazzoleni	0689328082	BugFix/LapJointL2FacesQ03: in L030 corretta lavorazionedi facce a L verso Y con parametro Q03=2/3	2022-08-10 13:07:35 +02:00
luca.mazzoleni	a1a6f2243a	Merge branch 'BugFix/ScarfOneFaceReduceToCut' into develop	2022-08-09 11:47:21 +02:00