- in Headcut e Split aggiunta gestione parametro MIN_HEIGHT_ADDED_CUTS da BeamData per scegliere l'altezza minima per cui devono essere aggiunti i tagli orizzontali supplementari

Merge branch 'develop' into ZeroPreCutForHeadCutSplit
- in HeadCut e Split correzioni a pretaglio a zero
2024-09-05 12:12:29 +02:00 · 2024-09-04 18:28:17 +02:00 · 2024-09-04 18:27:39 +02:00 · 2024-09-04 17:52:37 +02:00 · 2024-09-04 15:54:13 +02:00 · 2024-09-04 09:17:07 +02:00
32 changed files with 985 additions and 513 deletions
@@ -461,7 +461,7 @@ else
   -- Passo in modalità lavora
   EgtSetCurrMachGroup( EgtGetLastMachGroup())
   -- Se necessario eseguo aggiornamento con setup corrente e ricalcolo delle lavorazioni
-   if bToRecalc then
+   if bToRecalc or BEAM.FLAG == 3 or BEAM.FLAG == 4 then
      EgtOutLog( ' +++ Recalculating all dispositions and machinings >>>')
      EgtImportSetup()
      EgtApplyAllMachinings()
@@ -525,7 +525,8 @@ if  ( BEAM.FLAG == 0 and ( bToProcess or bToRecalc)) or BEAM.FLAG == 3 or BEAM.F
 end

 -- *** Genero programma CN *** ( se richiesto)
-if BEAM.FLAG == 0 or BEAM.FLAG == 4 then
+local bIsGenerationEnabled = ( EgtVerifyKeyOption( 110) == false)
+if bIsGenerationEnabled and ( BEAM.FLAG == 0 or BEAM.FLAG == 4) then
   EgtOutLog( ' +++ Generating NC part program >>>')
   local sInfo = 'EgtCAM5' .. EgtIf( EgtIs64bit(), ' 64bit', '')
   if EgtGetExeVersion then
@@ -562,7 +562,7 @@ else
   -- Passo in modalità lavora
   EgtSetCurrMachGroup( EgtGetLastMachGroup())
   -- Se necessario eseguo aggiornamento con setup corrente e ricalcolo delle lavorazioni
-   if bToRecalc then
+   if bToRecalc or BEAM.FLAG == 3 or BEAM.FLAG == 4 then
      EgtOutLog( ' +++ Recalculating all dispositions and machinings >>>')
      EgtImportSetup()
      EgtApplyAllMachinings()
@@ -626,7 +626,8 @@ if  ( BEAM.FLAG == 0 and ( bToProcess or bToRecalc)) or BEAM.FLAG == 3 or BEAM.F
 end

 -- *** Genero programma CN *** ( se richiesto)
-if BEAM.FLAG == 0 or BEAM.FLAG == 4 then
+local bIsGenerationEnabled = ( EgtVerifyKeyOption( 110) == false)
+if bIsGenerationEnabled and ( BEAM.FLAG == 0 or BEAM.FLAG == 4) then
   EgtOutLog( ' +++ Generating NC part program >>>')
   local sInfo = 'EgtCAM5' .. EgtIf( EgtIs64bit(), ' 64bit', '')
   if EgtGetExeVersion then
@@ -63,6 +63,7 @@
 -- 2024/03/13 In CollectFeatures si scrive lunghezza foro su Proc e si controla se serve Predrill
 --            In OrderFeature, preforo sempre prima del foro
 -- 2024/04/11 In CollectFeatures aggiunta lettura info PRID, scritta in Proc.FeatureId
+-- 2024/09/04 Gestione dipendenza foro-tasca in caso di fase con pezzo ribaltato

 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -844,6 +845,16 @@ local function OrderFeatures( vProc, b3Raw)
         B2.Box:getCenter():getX() > B1.Box:getMin():getX() and B2.Box:getCenter():getX() < B1.Box:getMax():getX() then
         return false
      end
+      -- se primo è ribasso e secondo è una mortasa a coda di rondine, il ribasso va sempre prima a meno che la mortasa a coda di rondine non sia di testa
+      if LapJoint.Identify(B1) and B1.PassedByDtMortise and DtMortise.SideIdentify(B2) and
+         B2.Box:getCenter():getX() > B1.Box:getMin():getX() and B2.Box:getCenter():getX() < B1.Box:getMax():getX() then
+         return true
+      end
+      -- se primo è mortasa a coda di rondine e secondo è ribasso, la mortasa a coda di rondine va sempre dopo a meno che la mortasa a coda di rondine non sia di testa
+      if DtMortise.SideIdentify(B1) and LapJoint.Identify(B2) and B2.PassedByDtMortise and
+         B1.Box:getCenter():getX() > B2.Box:getMin():getX() and B1.Box:getCenter():getX() < B2.Box:getMax():getX() then
+         return false
+      end
      -- se primo è feature di coda e l'altro è separazione o non è feature di coda
      if B1.Tail and ( Split.Identify( B2) or not B2.Tail) then
         return false
@@ -1267,6 +1278,20 @@ local function ClassifyFeatures( vProc, b3Raw, Stats)
      vProc[nSplitting].Down = true
      bSomeDown = true
   end
+   
+   -- si cerca di riclassificare le feature che dipendono da altre (in caso siano su rotazioni diverse)
+   for i = 1, #vProc do
+      local Proc = vProc[i]
+      -- FORATURA
+      if Drill.Identify( Proc) and Proc.Dependency then
+         if Proc.Dependency.ExecBefore then
+            if Proc.Dependency.ExecBefore.Down then
+               local bMachiningSideChanged = Drill.Classify( Proc, b3Raw, 'DOWN')
+            end
+         end
+      end
+   end
+   
   return bAllOk, bSomeDown, bSomeSide, bSplitRot
 end

@@ -2002,6 +2027,12 @@ function GetFeatureInfoAndDependency( vProc, b3Raw)
         -- verifico se feature tipo LapJoint è attraversata da almeno un foro
         if ( Proc.Topology == 'Pocket' or Proc.Topology == 'Tunnel' or Proc.Topology == 'Groove' or Mortise.Identify( Proc)) and Drill.Identify( ProcB) and Overlaps( Proc.Box, ProcB.Box) then
            Proc.PassedByHole = true
+            ProcB.Dependency = {}
+            ProcB.Dependency.ExecBefore = Proc
+         end
+         -- verifico se feature tipo LapJoint è attraversata da almeno una mortasa a coda di rondine
+         if ( Proc.Topology == 'Pocket' or Proc.Topology == 'Tunnel' or Proc.Topology == 'Groove') and DtMortise.SideIdentify( ProcB) and Overlaps( Proc.Box, ProcB.Box) then
+            Proc.PassedByDtMortise = true
         end
         -- verifiche per specchiature
         if BD.DOWN_HEAD or BD.TWO_EQUAL_HEADS then
@@ -1188,6 +1188,11 @@ end

 -------------------------------------------------------------------------------------------------------------
 function BeamLib.GetFacetsInfo( Proc, b3Raw)
+
+   if Proc.Fct > 20 then
+      return nil
+   end
+
   local Face = {}
   local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( Proc.PartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
   local vAdj
@@ -45,7 +45,7 @@ local BD = require( 'BeamData')
 local ML = require( 'MachiningLib')

 ---------------------------------------------------------------------
-function MakeParallelOne( nSurfId, nFacet, sCutting, dSawDiam, nFaceUse, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, bForceInvert)
+function MakeParallelOne( nSurfId, nFacet, sCutting, dSawDiam, nFaceUse, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, bForceInvert, bForceTangentLeadInOut)
   EgtOutLog( 'FacesBySaw.MakeParallelOne', 3)
   -- dati della faccia
   local ptC, vtN = EgtSurfTmFacetCenter( nSurfId, nFacet, GDB_ID.ROOT)
@@ -76,7 +76,7 @@ function MakeParallelOne( nSurfId, nFacet, sCutting, dSawDiam, nFaceUse, dVzLimD
   local bLioTang
   local Ktp = 1.1
   if BD.KIOTP then Ktp = BD.KIOTP end
-   if Ktp * dLi2Tang < dLiPerp then
+   if bForceTangentLeadInOut or ( Ktp * dLi2Tang < dLiPerp) then
      bLioTang = true
      dLiTang, dLiPerp, dLoTang, dLoPerp = dLi2Tang, dLi2Perp, dLo2Tang, dLo2Perp
      if BD.TURN then
@@ -192,7 +192,7 @@ local function GetNameSolidFaceIncludingLine( b3Solid, ptP1Comp, ptP2Comp)
 end

 ---------------------------------------------------------------------
-function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, bForceInvert, bMaximizeVerticalDepth)
+function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, bForceInvert, bMaximizeVerticalDepth, bSpecialTangentLeadInOut, bForceTangentLeadInOut, Par5Alternative)
   -- se lama con asse parallelo alla faccia, passo alla apposita funzione
   if ( Par5 == MCH_MILL_FU.PARAL_DOWN or
        Par5 == MCH_MILL_FU.PARAL_TOP or
@@ -200,7 +200,7 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
        Par5 == MCH_MILL_FU.PARAL_BACK or
        Par5 == MCH_MILL_FU.PARAL_LEFT or
        Par5 == MCH_MILL_FU.PARAL_RIGHT) then
-      return MakeParallelOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, bForceInvert)
+      return MakeParallelOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, bForceInvert, bForceTangentLeadInOut)
   end
   -- la lama ha asse perpendicolare alla faccia
   EgtOutLog( 'FacesBySaw.MakeOne', 3)
@@ -209,6 +209,8 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
   -- risolvo parametro ambiguo
   local nOrthoOpposite
   local vtOrthO
+   local nOrthoOppositeAlternative
+   local vtOrthOAlternative
   if isVector3d( Par5) then
      nOrthoOpposite = BL.GetNearestOrthoOpposite( Par5, vtN)
      vtOrthO = Vector3d( Par5)
@@ -216,6 +218,15 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
      nOrthoOpposite = Par5
      vtOrthO = BL.GetVersRef( Par5)
   end
+   if Par5Alternative then
+      if isVector3d( Par5Alternative) then
+         nOrthoOppositeAlternative = BL.GetNearestOrthoOpposite( Par5Alternative, vtN)
+         vtOrthOAlternative = Vector3d( Par5Alternative)
+      else
+         nOrthoOppositeAlternative = Par5Alternative
+         vtOrthOAlternative = BL.GetVersRef( Par5Alternative)
+      end
+   end
   EgtOutLog( 'VtOrthO='..tostring( vtOrthO)..' FaceUse='..tostring( nOrthoOpposite), 3)
   -- verifico se testa da sotto oppure se lavorazione sotto con testa da sopra
   if not dVzLimDwnUp then dVzLimDwnUp = BL.GetNzLimDownUp( b3Raw, vtN, vtOrthO) end
@@ -235,13 +246,34 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
   end
   local bIsSawCCW = ( EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) < 0)
   local bInvert = bForceInvert
-   -- se la lama ruota in senso antiorario inverto la direzione di lavorazione, per avere rotazione lama opposta a avanzamento
+   -- l'inversione può essere comandata da rotazione lama (direzione concorde, legata anche a DownUp) oppure da direzione Z del percorso (si preferisce lavorare dal basso verso l'alto per limitare le corse)
+   -- se c'è disaccordo tra rotazione e direzione si cambia il lato di lavoro, se possibile. Se ciò non è possbile comanda la direzione.
   if bInvert == nil then
      if not BD.TURN or abs( ptP2:getY() - ptP1:getY()) < 250 then
-         if bIsSawCCW ~= bDownUp then
-            bInvert = ( ptP2:getZ() < ptP1:getZ() + 100 * GEO.EPS_SMALL)
+         local bIsMachiningDownwards = ( ptP2:getZ() < ptP1:getZ() - 100 * GEO.EPS_SMALL)
+         local bIsMachiningUpwards = ( ptP2:getZ() > ptP1:getZ() + 100 * GEO.EPS_SMALL)
+         if ( bIsSawCCW ~= bDownUp) and bIsMachiningDownwards then
+            bInvert = true
+         elseif ( ( bIsSawCCW ~= bDownUp) ~= bIsMachiningDownwards) then
+            if Par5Alternative then
+               bInvert = true
+               nOrthoOpposite = nOrthoOppositeAlternative
+               vtOrthO = vtOrthOAlternative
+               -- avendo riassegnato la direzione di lavoro, i dati della linea vanno ricalcolati
+               ptP1, ptPm, ptP2, vtV1, vtV2, dLen, dWidth = EgtSurfTmFacetOppositeSide( nSurfId, nFacet, BL.GetVersRef( nOrthoOpposite), GDB_ID.ROOT)
+               if not dLen or dLen < 1.1 or not dWidth or dWidth < 1.1 then
+                  local sWarn = 'Face ' .. string.format( '%d,%d', nSurfId, nFacet) .. ' skipped : too small'
+                  EgtOutLog( sWarn, 1)
+                  return true, ''
+               end
+               vtV1 = - vtV1
+            elseif bIsMachiningDownwards or not bIsMachiningUpwards then
+               bInvert = true
+            else
+               bInvert = false
+            end
         else
-            bInvert = ( ptP2:getZ() < ptP1:getZ() - 100 * GEO.EPS_SMALL)
+            bInvert = false
         end
      else
         local vtTmp = ptP2 - ptP1 ; vtTmp:normalize()
@@ -330,8 +362,26 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
   local dLiTang, dLiPerp, dLoTang, dLoPerp, vtLio = FacesBySaw.CalcLeadInOutPerpGeom( ptPa1, ptPa2, vtV1, vtV2, vtN, dSawDiam / 2, vtRef, dCutExtra, b3Box)
   local dLenLi = sqrt( dLiTang * dLiTang + dLiPerp * dLiPerp)
   local dLenLo = sqrt( dLoTang * dLoTang + dLoPerp * dLoPerp)
+   local dLiCompLength = 0
   -- attacco tangente
-   local dLi2Tang, dLi2Perp, dLo2Tang, dLo2Perp = FacesBySaw.CalcLeadInOutTangGeom( ptPa1, ptPa2, vtN, dSawDiam / 2, vtRef, dCutExtra, b3Box)
+   local dLi2Tang = 0
+   local dLi2Perp = 0
+   local dLo2Tang = 0
+   local dLo2Perp = 0
+   local dLi2CompLength = 0
+
+   -- si predilige un attacco tangenziale (con calcolo automatico di quanto uscire) se faccia che guarda in giù, non troppo orientata verso X e linea non troppo inclinata in X
+   -- non si fa se macchina tipo PF e pezzo alto perchè la lama, uscendo da sopra, toccherebbe la traversa
+   -- TODO si potranno togliere i limiti sulle normali quando si implementerà un modo per calcolare Lead In / Out correttamente in tutti i casi
+   -- 
+   if bSpecialTangentLeadInOut and not bIsBiLinea and ( vtN:getZ() < - 0.087) and ( abs( vtN:getX()) < 0.258) and ( abs( vtTg:getX()) < 0.1736) and ( abs( vtN:getY()) < 0.5 or ( BD.MAX_DIM_HTCUT_HBEAM > 0 or ( b3Raw:getDimZ() < 420))) then
+      dLi2Tang = 0
+      dLi2Perp = BD.CUT_EXTRA
+      dLi2CompLength = dLen + dSawDiam / 2 + BD.COLL_SIC
+      dLo2Tang = dSawDiam / 2
+   else
+      dLi2Tang, dLi2Perp, dLo2Tang, dLo2Perp = FacesBySaw.CalcLeadInOutTangGeom( ptPa1, ptPa2, vtN, dSawDiam / 2, vtRef, dCutExtra, b3Box)
+   end
   local dLenLi2 = abs( dLi2Tang)
   local dLenLo2 = abs( dLo2Tang)

@@ -402,7 +452,7 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
         dLoPerp = BD.COLL_SIC
      else
         bLioTang = true
-         dLiTang, dLiPerp, dLoTang, dLoPerp = dLi2Tang, dLi2Perp, dLo2Tang, dLo2Perp
+         dLiTang, dLiPerp, dLoTang, dLoPerp, dLiCompLength = dLi2Tang, dLi2Perp, dLo2Tang, dLo2Perp, dLi2CompLength
      end
   end
   -- posizione braccio
@@ -475,6 +525,7 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
   if BD.TURN and bLioTang == 1 then EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.TG_PERP) end
   EgtSetMachiningParam( MCH_MP.LITANG, dLiTang)
   EgtSetMachiningParam( MCH_MP.LIPERP, dLiPerp)
+   EgtSetMachiningParam( MCH_MP.LICOMPLEN, dLiCompLength)
   if BD.TURN and bLioTang == 2 then EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.PERP_TG) end
   EgtSetMachiningParam( MCH_MP.LOTANG, dLoTang)
   EgtSetMachiningParam( MCH_MP.LOPERP, dLoPerp)
@@ -624,7 +675,8 @@ function FacesBySaw.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, sCutType,
            local vtOrthO = EgtIf( ( i % 2) == 1, vtRef[nOtInd], vtRef[nUpInd])
            -- lavoro la faccia
            for j = 1, #vCuts[i] do
-               local bOk, sErr = FacesBySaw.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthO, dNzLimDwnUp, dCutExtra, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+               local bSpecialTangentLeadInOut = ( i % 2 == 0) and ( Proc.AffectedFaces.Left or Proc.AffectedFaces.Right)
+               local bOk, sErr = FacesBySaw.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthO, dNzLimDwnUp, dCutExtra, BD.CUT_SIC, 0, 0, 0, nil, b3Raw, nil, nil, bSpecialTangentLeadInOut)
               if not bOk then
                  return bOk, sErr
               end
@@ -684,14 +736,16 @@ function FacesBySaw.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, sCutType,
               end
               -- taglio perpendicolare (limite Vz Down Up messo a -2 per non farlo mai intervenire)
               if vCuts[i][j] then
-                  local bOk, sErr = FacesBySaw.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO_1, -2, dExtraCut_1, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+                  local bSpecialTangentLeadInOut = ( i % 2 == 0) and ( Proc.AffectedFaces.Left or Proc.AffectedFaces.Right)
+                  local bOk, sErr = FacesBySaw.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO_1, -2, dExtraCut_1, BD.CUT_SIC, 0, 0, 0, nil, b3Raw, nil, nil, bSpecialTangentLeadInOut)
                  if not bOk then
                     return bOk, sErr
                  end
               end
               -- taglio parallelo (limite Vz Down Up messo a -2 per non farlo mai intervenire)
               if vCuts[i+1][j] then
-                  local bOk, sErr = FacesBySaw.MakeOne( vCuts[i+1][j], 0, sCutting, dSawDiam, vtOrthoO_2, -2, dExtraCut_2, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+                  local bSpecialTangentLeadInOut = ( ( i + 1) % 2 == 0) and ( Proc.AffectedFaces.Left or Proc.AffectedFaces.Right)
+                  local bOk, sErr = FacesBySaw.MakeOne( vCuts[i+1][j], 0, sCutting, dSawDiam, vtOrthoO_2, -2, dExtraCut_2, BD.CUT_SIC, 0, 0, 0, nil, b3Raw, nil, nil, bSpecialTangentLeadInOut)
                  if not bOk then
                     return bOk, sErr
                  end
@@ -151,7 +151,8 @@ function ProcessBlockHausFront.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dO
      -- se va fatto, inserisco la lavorazione
      if bCut then
         local CutProc = { Id = AuxId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
         -- se taglio applicato setto la nota al gruppo Mach per non doverla lavorare una seconda volta
         if bOk then
@@ -242,7 +243,8 @@ function ProcessBlockHausFront.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dO
         -- se va fatto, inserisco la lavorazione
         if bCut then
            local CutProc = { Id = AuxId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+            CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
            -- se taglio applicato setto la nota al gruppo Mach per non doverla lavorare una seconda volta
            if bOk then
@@ -548,7 +548,8 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                           dVzLimDwnUp = -0.708
                        end
                     end
-                     local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtNewOrthoO, dVzLimDwnUp, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+                     local bSpecialTangentLeadInOut = ( i % 2 == 0) and ( Proc.AffectedFaces.Left or Proc.AffectedFaces.Right)
+                     local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtNewOrthoO, dVzLimDwnUp, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, 0, nil, b3Raw, nil, nil, bSpecialTangentLeadInOut)
                     if not bOk then return bOk, sErr end
                  end
                  -- tutti gli altri casi vengono saltati
@@ -575,7 +576,12 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                  elseif not BD.C_SIMM and not BD.TURN and vtN:getZ() > 0.707 then
                     dVzLimDwnUp = -0.708
                  end
-                  local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, sNotes, b3Raw)
+                  local bSpecialTangentLeadInOut = ( i % 2 == 0) and ( Proc.AffectedFaces.Left or Proc.AffectedFaces.Right)
+                  local vtOrthoOAlternative
+                  if ( i % 2 == 0) and ( Proc.Fct == 1) and bNoPerpCuts then
+                     vtOrthoOAlternative = - vtOrthoO
+                  end
+                  local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, sNotes, b3Raw, nil, nil, bSpecialTangentLeadInOut, nil, vtOrthoOAlternative)
                  if not bOk then return bOk, sErr end
               end
            end
@@ -757,14 +763,16 @@ local function MakeFromDown( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead)
            end
            -- taglio perpendicolare (limite Vz Down Up messo a -2 per non farlo mai intervenire)
            if vCuts[i][j] then
-               local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO_1, -2, dExtraCut_1, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+               local bSpecialTangentLeadInOut = ( i % 2 == 0) and ( Proc.AffectedFaces.Left or Proc.AffectedFaces.Right)
+               local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO_1, -2, dExtraCut_1, BD.CUT_SIC, 0, 0, 0, nil, b3Raw, nil, nil, bSpecialTangentLeadInOut)
               if not bOk then
                  return bOk, sErr
               end
            end
            -- taglio parallelo (limite Vz Down Up messo a -2 per non farlo mai intervenire)
            if vCuts[i+1][j] then
-               local bOk, sErr = Fbs.MakeOne( vCuts[i+1][j], 0, sCutting, dSawDiam, vtOrthoO_2, -2, dExtraCut_2, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+               local bSpecialTangentLeadInOut = ( i % 2 == 0) and ( Proc.AffectedFaces.Left or Proc.AffectedFaces.Right)
+               local bOk, sErr = Fbs.MakeOne( vCuts[i+1][j], 0, sCutting, dSawDiam, vtOrthoO_2, -2, dExtraCut_2, BD.CUT_SIC, 0, 0, 0, nil, b3Raw, nil, nil, bSpecialTangentLeadInOut)
               if not bOk then return bOk, sErr end
            end
         end
@@ -521,7 +521,8 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
         local b3Add = EgtGetBBoxGlob( AddId, GDB_BB.STANDARD)
         -- applico lavorazione
         local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Add, Fct = 1, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, bForced, b3Raw, sNotes, dOvmTail, true)
         if not bOk then return bOk, sErr end
      end
@@ -533,7 +534,8 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
         local b3Add = EgtGetBBoxGlob( AddId, GDB_BB.STANDARD)
         -- applico lavorazione
         local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Add, Fct = 1, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, bForced, b3Raw, sNotes, dOvmTail, true)
         if not bOk then return bOk, sErr end
      end
@@ -1433,7 +1433,8 @@ local function MakeAuxCut( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Sol
      return true
   end
   -- inserisco la lavorazione
-   local CutProc = { Id = AuxId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg, Head = Proc.Head, Tail = Proc.Tail}
+   local CutProc = { Id = AuxId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg, Head = Proc.Head, Tail = Proc.Tail, PartId = Proc.PartId}
+   CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
   local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
   if not bOk then return bOk, sErr end
   -- imposto la nota nel gruppo aggiuntivo di lavorazione per evitare di tagliare una seconda volta
@@ -22,6 +22,7 @@
 -- 2023/11/06 Migliorata gestione dei fori con AngularTransmission.
 -- 2024/03/13 Aggiunta gestione Predrill
 -- 2024/03/18 Per Predrill corretta direzione estrusione per fori con direzione verso il basso
+-- 2024/09/04 Gestione dipendenza foro-tasca in caso di fase con pezzo ribaltato

 -- Tabella per definizione modulo
 local ProcessDrill = {}
@@ -213,7 +214,7 @@ end

 ---------------------------------------------------------------------
 -- Classificazione della feature
-function ProcessDrill.Classify( Proc, b3Raw)
+function ProcessDrill.Classify( Proc, b3Raw, sDownOrSideOrStd)
   -- recupero e verifico l'entità foro
   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0
   if AuxId then AuxId = AuxId + Proc.Id end
@@ -243,6 +244,18 @@ function ProcessDrill.Classify( Proc, b3Raw)
   local bOpen = ( Proc.Fce ~= 0)
   local bFaceDown = ( ptCen:getZ() < b3Raw:getMin():getZ() + 2  and  (( not Proc.Head  and  not Proc.Tail) or (( BD.ROT90 or BD.DOWN_HEAD or BD.TURN) and abs( Proc.Flg) == 2)))
   local bAngTransm = ( BD.ANG_TRASM and ML.FindDrilling( dDiam, nil, nil, nil, nil, true) and AreSameOrOppositeVectorApprox( vtExtr, Z_AX()))
+
+   -- se ci sono delle dipendenze da altre feature da rispettare
+   if sDownOrSideOrStd then
+      if sDownOrSideOrStd == 'DOWN' then
+         if vtExtr:getZ() < - BD.DRILL_VZ_MIN then
+            Proc.Down = true
+            return true
+         end
+      end
+      return false
+   end
+
   -- verifico se il foro è sotto e quindi va spostato o sopra o sul fianco
   if (( vtExtr:getZ() < BD.DRILL_VZ_MIN or bFaceDown) and ( not bOpen or Proc.Flg ~= 1)) then
      if not bOpen then
@@ -210,7 +210,8 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         local AddId = EgtSurfTmPlaneInBBox( nAddGrpId, ptCutC, vtCutN, b3Solid, GDB_RT.GLOB)
         local b3Cut = EgtGetBBoxGlob( AddId or GDB_ID.NULL, GDB_BB.STANDARD)
         local CutProc = { Id = AddId, Grp = Proc.Grp - 2, Prc = 10, Box = b3Cut, Fct = 1, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         local bFromBottom = ( b3Solid:getDimX() < BD.LEN_SHORT_PART and vtExtr:getZ() > 0.25)
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dCurrOvmH, bFromBottom)
         if not bOk then return bOk, sErr end
@@ -207,7 +207,8 @@ function ProcessDtTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
         -- altrimenti applico taglio di lama
         else
            local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+            CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
            local bFromBottom = ( b3Solid:getDimX() < BD.LEN_SHORT_PART and vtExtr:getZ() > 0.25)
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom)
            if not bOk then return bOk, sErr end
@@ -22,6 +22,7 @@ local Fbs = require( 'FacesBySaw')
 local Cut = require( 'ProcessCut')
 local Pocket = require( 'FaceByPocket')
 local Topology = require( 'FeatureTopology')
+local Split = require( 'ProcessSplit')

 EgtOutLog( ' ProcessHeadCut started', 1)

@@ -29,6 +30,10 @@ EgtOutLog( ' ProcessHeadCut started', 1)
 local BD = require( 'BeamData')
 local ML = require( 'MachiningLib')

+if BD.PRECUT_HEAD == nil then
+   BD.PRECUT_HEAD = true
+end
+
 ---------------------------------------------------------------------
 -- Riconoscimento della feature
 function ProcessHeadCut.Identify( Proc)
@@ -156,10 +161,9 @@ end

 ---------------------------------------------------------------------
 -- tagli verticali aggiuntivi
-local function AddVerticalPreCuts( Proc, sCutting, dCutXOffset, b3Raw )
-   local _, dimH = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
-   local nVerticalCuts = ceil( dimH / ( BD.MAX_LEN_DICE)) - 1
-   local dVerticalSliceHeight = dimH / ( nVerticalCuts + 1)
+local function AddVerticalPreCuts( Proc, sCutting, dCutXOffset, b3Raw)
+   local nVerticalCuts = ceil( Proc.Face[1].WidthTrimmed / ( BD.MAX_LEN_DICE)) - 1
+   local dVerticalSliceHeight = Proc.Face[1].WidthTrimmed / ( nVerticalCuts + 1)
   -- recupero il diametro dell'utensile
   local dSawDiam = 400
   if EgtMdbSetCurrMachining( sCutting) then
@@ -173,12 +177,180 @@ local function AddVerticalPreCuts( Proc, sCutting, dCutXOffset, b3Raw )
   for j = nVerticalCuts, 1, -1 do
      local nFaceUse = MCH_MILL_FU.PARAL_FRONT
      local dVerticalCutOffset = dVerticalSliceHeight * -j
-      bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nFaceUse, nil, -0.1 -dCutXOffset, BD.CUT_SIC, dVerticalCutOffset, 0, 0, '', b3Raw)
+      local bForceTangentLeadInOut = BD.PRESS_ROLLER
+      bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nFaceUse, nil, -0.1 -dCutXOffset, BD.CUT_SIC, dVerticalCutOffset, 0, 0, '', b3Raw, nil, nil, nil, bForceTangentLeadInOut)
      if not bOk then return bOk, sErr end
   end
+   
   return bOk, sErr
 end

+---------------------------------------------------------------------
+-- tagli standard
+local function MakeStandardCuts( Proc, b3Raw, nCuts, dOffsetBetweenCuts, HeadCutType, Cutting1Data, Cutting2Data, dStartOffset, dOvmHead)
+   local PrecutType = { bBigSectionCut = HeadCutType.bBigSectionCut, bHorizCut = HeadCutType.bHorizCut, bDoubleHorizCut = HeadCutType.bDoubleHorizCut, bDoubleCut = HeadCutType.bDoubleCut, sType = 'Precut', bNeedVerticalAddedCuts = false, bNeedHorizontalAddedCuts = false}
+   if not HeadCutType.bDoubleHorizCut then
+      -- flag di lavorazione faccia
+      local nOrthoOpposite = EgtIf( HeadCutType.bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_FRONT)
+      -- calcolo extra taglio ed accorciamento
+      local dCutExtra = 0
+      local dAccStart = 0
+      local dAccEnd = 0
+
+      if b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL or b3Raw:getDimY() < 2 * BD.MAX_DIM_HTCUT_HBEAM + 10 * GEO.EPS_SMALL then
+         dCutExtra = EgtIf( HeadCutType.bDoubleCut, - 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN,  BD.CUT_EXTRA)
+      else
+         dCutExtra = - ( b3Raw:getDimY() - Cutting1Data.dMaxDepth)
+         local dSawRad = Cutting1Data.dSawDiam / 2
+         -- distanza in Y tra il centro della lama e l'intersezione tra la lama stessa e la massima Z della trave, + extra
+         -- se taglio doppio l'intersezione sarà in mezzeria, se taglio singolo sarà all'estremo opposto della trave
+         local dKL = dSawRad - Cutting1Data.dMaxDepth + EgtIf( HeadCutType.bDoubleCut, b3Raw:getDimY() / 2 + BD.CUT_EXTRA_MIN, b3Raw:getDimY() + BD.CUT_EXTRA)
+         -- lunghezza minima del percorso di lavorazione, in caso accorciamento porti a lunghezza negativa
+         local dMinSawingLength = 5
+         if BD.C_SIMM then
+            dAccEnd = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
+            -- non posso comunque accorciare più della dimensione della geometria, quindi in caso allungo entrata
+            if dAccEnd > b3Raw:getDimZ() - 100 * GEO.EPS_SMALL then
+               dAccStart = b3Raw:getDimZ() - dAccEnd - dMinSawingLength
+            end
+         else
+            dAccStart = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
+            -- non posso comunque accorciare più della dimensione della geometria, quindi in caso allungo uscita
+            if dAccStart > b3Raw:getDimZ() - 100 * GEO.EPS_SMALL then
+               dAccEnd = b3Raw:getDimZ() - dAccStart - dMinSawingLength
+            end
+         end
+      end
+
+      -- per travi alte faccio dei tagli orizzontali aggiuntivi
+      if HeadCutType.bNeedHorizontalAddedCuts then
+         -- taglio a zero (con lama) per evitare problemi con grezzo più lungo del previsto. Se BigSection il pretaglio è già stato fatto.
+         if not ( HeadCutType.bBigSectionCut) and BD.PRECUT_HEAD then
+            dStartOffset = dOvmHead
+            local bOkPrecut, sErrPrecut = MakeStandardCuts( Proc, b3Raw, 1, 0, PrecutType, Cutting1Data, Cutting2Data, dStartOffset)
+            if not bOkPrecut then
+               return false, sErrPrecut
+            end
+         end
+         local nHorizontalCuts = ceil( Proc.Face[1].HeightTrimmed / BD.MAX_DIM_DICE) - 1
+         local dHorizontalSliceHeight = Proc.Face[1].HeightTrimmed / ( nHorizontalCuts + 1)
+         for i = nCuts, 1, -1 do
+            local dCutXOffset = ( i - 1) * dOffsetBetweenCuts
+            -- tagli orizzontali
+            for j = nHorizontalCuts, 1, -1 do
+               local nFaceUse = MCH_MILL_FU.PARAL_DOWN
+               local dHorizontalCutOffset = dHorizontalSliceHeight * -j
+               local bForceTangentLeadInOut = BD.PRESS_ROLLER
+               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.dSawDiam, nFaceUse, nil, -0.1 -dCutXOffset, BD.CUT_SIC, dHorizontalCutOffset, 0, 0, '', b3Raw, nil, nil, nil, bForceTangentLeadInOut)
+               if not bOk then return bOk, sErr end
+            end
+            -- se necessario taglio verticale doppio, eseguo l'opposto
+            if HeadCutType.bDoubleCut then
+               -- gli accorciamenti vanno invertiti per il taglio opposto
+               local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
+               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.dSawDiam, MCH_MILL_FU.ORTHO_BACK, nil, dCutExtra, BD.CUT_SIC, dCutXOffset, dAccStartDoubleCut, dAccEndDoubleCut, '', b3Raw, true)
+               if not bOk then return false, sErr end
+            end
+            -- taglio verticale
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutXOffset, dAccStart, dAccEnd, '', b3Raw)
+            if not bOk then return bOk, sErr end
+         end
+         return true, sWarn
+      end
+
+      -- taglio a zero (con lama) per evitare problemi con grezzo più lungo del previsto. Se BigSection il pretaglio è già stato fatto.
+      if not ( HeadCutType.bBigSectionCut) and BD.PRECUT_HEAD and HeadCutType.bNeedVerticalAddedCuts then
+         dStartOffset = dOvmHead
+         local bOkPrecut, sErrPrecut = MakeStandardCuts( Proc, b3Raw, 1, 0, PrecutType, Cutting1Data, Cutting2Data, dStartOffset)
+         if not bOkPrecut then
+            return false, sErrPrecut
+         end
+      end
+      -- se necessari tagli in doppio, eseguo gli opposti
+      if HeadCutType.bDoubleCut then
+         -- gli accorciamenti vanno invertiti per il taglio opposto
+         local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
+         for i = nCuts, 1, -1 do
+            local dCutOffset = ( i - 1) * dOffsetBetweenCuts
+            if i == 1 and HeadCutType.sType =='Precut' then
+               dCutOffset = dStartOffset
+            end
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.dSawDiam, MCH_MILL_FU.ORTHO_BACK, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStartDoubleCut, dAccEndDoubleCut, '', b3Raw, true)
+            if not bOk then return false, sErr end
+         end
+      end
+      -- eseguo i tagli necessari
+      for i = nCuts, 1, -1 do
+         local dCutOffset = ( i - 1) * dOffsetBetweenCuts
+         -- se trave larga effettuo tagli verticali aggiuntivi
+         if HeadCutType.bNeedVerticalAddedCuts then
+            local bOk, sErr = AddVerticalPreCuts( Proc, Cutting1Data.sCutting, dCutOffset, b3Raw)
+            if not bOk then return bOk, sErr end
+         end
+         if i == 1 and HeadCutType.sType =='Precut' then
+            dCutOffset = dStartOffset
+         end
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, '', b3Raw)
+         if not bOk then return false, sErr end
+      end
+   -- altrimenti necessari tagli da sopra e sotto con testa opportuna
+   else
+      -- verifico esistenza della lavorazione con lama da sotto
+      if not Cutting2Data.sCutting then
+         local sErr = 'Error : cutting H2 not found in library'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- verifico che le due lame riescano a lavorare la sezione
+      local dDimZ = b3Raw:getDimZ()
+      local dExtra = Cutting1Data.dMaxVertDepth + Cutting2Data.dMaxDepth - dDimZ
+      if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not HeadCutType.bBigSectionCut then
+         local sErr = 'Error : section too big for head cut'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- calcolo extra taglio ed accorciamento
+      local dCutExtra = -Cutting2Data.dMaxDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
+      local dCutExtra2 = -Cutting1Data.dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
+      local dAccStart = 0
+      local dVzLimDwnUp
+      if BD.TURN then dVzLimDwnUp = -2 end
+      -- taglio a zero (con lama) per evitare problemi con grezzo più lungo del previsto. Se BigSection il pretaglio è già stato fatto.
+      if not ( HeadCutType.bBigSectionCut) and BD.PRECUT_HEAD and HeadCutType.bNeedVerticalAddedCuts then
+         dStartOffset = dOvmHead
+         local bOkPrecut, sErrPrecut = MakeStandardCuts( Proc, b3Raw, 1, 0, PrecutType, Cutting1Data, Cutting2Data, dStartOffset)
+         if not bOkPrecut then
+            return false, sErrPrecut
+         end
+      end
+      -- eseguo i tagli da sotto necessari
+      for i = nCuts, 1, -1 do
+         local dCutOffset = ( i - 1) * dOffsetBetweenCuts
+         if i == 1 and HeadCutType.sType =='Precut' then
+            dCutOffset = dStartOffset
+         end
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting2Data.sCutting, Cutting2Data.dSawDiam, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw, nil, true)
+         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) * dOffsetBetweenCuts
+         if i == 1 and HeadCutType.sType =='Precut' then
+            dCutOffset = dStartOffset
+         end
+         -- se trave larga effettuo tagli verticali aggiuntivi
+         if HeadCutType.bNeedVerticalAddedCuts then
+            local bOk, sErr = AddVerticalPreCuts( Proc, Cutting1Data.sCutting, dCutOffset, b3Raw)
+            if not bOk then return bOk, sErr end
+         end
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.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
+
+   return true
+end
+
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut)
@@ -223,7 +395,7 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then
         dSawDiam2 = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam2
         dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2
-         dSawThick2 = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick2
+         dSawThick2 = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dSawThick2
      end
   end
   -- caratteristiche taglio
@@ -233,6 +405,15 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
   local bHorizCut = ( ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA)
   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
   local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL)
+   -- verifico necessità di tagli aggiuntivi orizzontali o verticali
+   local dMinOvmHeadForAddeddCuts = 10.123
+   local bNeedVerticalAddedCuts = ( Proc.Face[1].WidthTrimmed > BD.MAX_LEN_DICE) and ( dOvmHead > dMinOvmHeadForAddeddCuts - 10 * GEO.EPS_SMALL)
+   local bNeedHorizontalAddedCuts = ( Proc.Face[1].HeightTrimmed > ( BD.MIN_HEIGHT_ADDED_CUTS or BD.MAX_LEN_DICE)) and not bBigSectionCut and ( dOvmHead > dMinOvmHeadForAddeddCuts - 10 * GEO.EPS_SMALL)
+   -- dati lavorazioni sopra e sotto
+   local Cutting1Data = { sCutting = sCutting, dSawDiam = dSawDiam, dMaxDepth = dMaxDepth, dSawThick = dSawThick, dMaxVertDepth = dMaxVertDepth}
+   local Cutting2Data = { sCutting = sCutting2, dSawDiam = dSawDiam2, dMaxDepth = dMaxDepth2, dSawThick = dSawThick2}
+   -- dati sul taglio di testa da effettuare
+   local HeadCutType = { bBigSectionCut = bBigSectionCut, bHorizCut = bHorizCut, bDoubleHorizCut = bDoubleHorizCut, bDoubleCut = bDoubleCut, bNeedVerticalAddedCuts = bNeedVerticalAddedCuts, bNeedHorizontalAddedCuts = bNeedHorizontalAddedCuts}
   -- dati geometrici del taglio
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
   -- se non obbligatorio e coincide con inizio grezzo, non va fatto
@@ -242,8 +423,6 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
   -- determino se lo spessore del materiale da rimuovere è eccessivo e quindi vanno fatti più tagli con offset
   local nCuts = max( ceil( dOvmHead / (( BD.MAX_LEN_SCRAP_START or BD.MAX_LEN_SCRAP) + 0.5)), 1)
   local dOffsL = dOvmHead / nCuts
-   local _, dimH, dimV = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
-   local dMinOvmHeadForAddeddCuts = 10.123
   -- se taglio per sezioni alte e larghe
   if bBigSectionCut then
      if dOvmHead > 0 then
@@ -259,11 +438,34 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
            else
               dMaxElev = Proc.Box:getMax():getX() - b3Raw:getMin():getX()
            end
+            -- taglio a zero (con sega a catena o mix catena + lama) per evitare problemi con grezzo più lungo del previsto
+            if BD.PRECUT_HEAD then
+               -- recupero dati utensile della sega a catena più lunga a disposizione
+               local sSawing = ML.FindSawing( 'SawingForSplitting', nil, nil, 'Longest')
+               if not sSawing then
+                  sSawing = ML.FindSawing( 'Sawing', nil, nil, 'Longest')
+               end
+               local dChainSawMaxMat = 0
+               local dChainSawLen = 0
+               if EgtMdbSetCurrMachining( sSawing or '') then
+                  local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+                  if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+                     dChainSawMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dChainSawMaxMat
+                     dChainSawLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dChainSawLen
+                  end
+               end
+               local SawingData = { sSawing = sSawing, dChainSawMaxMat = dChainSawMaxMat, dChainSawLen = dChainSawLen, bInvert = true}
+               local dOffset = dOvmHead
+               local bOkPrecut, sErrPrecut = Split.MakeBigSectionSplitting( Proc, b3Raw, dOffset, SawingData, Cutting2Data)
+               if not bOkPrecut then
+                  return false, sErrPrecut
+               end
+            end
            -- controllo se è necessario un taglio con dicing o si deve proseguire ai casi standard
            if dMaxElev > dSawThickCheck then
               local bOk, sErr
               -- se trave larga effettuo tagli verticali aggiuntivi
-               if ( dimH > BD.MAX_LEN_DICE) and ( dOvmHead > dMinOvmHeadForAddeddCuts - 10 * GEO.EPS_SMALL) then
+               if bNeedVerticalAddedCuts then
                  -- ad ogni offset di taglio dovrò fare prima i tagli verticali e poi i cubetti 
                  for i = nCuts, 1, -1 do
                     local nAddGrpId = BL.GetAddGroup( Proc.PartId)
@@ -288,11 +490,11 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
                     bOk, sErr = AddVerticalPreCuts( AddProc, sCutting, 0, b3Raw)
                     if not bOk then return bOk, sErr end
                     -- tagli a cubetti con eventuale superficie limitante
-                     bOk, sErr = Cut.Make( AddProc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT, nil, nLimitingSurf)
+                     bOk, sErr = Cut.Make( AddProc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, nil, nil, nLimitingSurf)
                  end
               -- tagli aggiuntivi non necessari
               else
-                  bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT)
+                  bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true)
               end
               return bOk, sErr
            end
@@ -315,130 +517,11 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
         end
      end
   end
-   -- se tagli standard
-   if not bDoubleHorizCut then
-      -- flag di lavorazione faccia
-      local nOrthoOpposite = EgtIf( bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_FRONT)
-      -- calcolo extra taglio ed accorciamento
-      local dCutExtra = 0
-      local dAccStart = 0
-      local dAccEnd = 0
-      if b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL or b3Raw:getDimY() < 2 * BD.MAX_DIM_HTCUT_HBEAM + 10 * GEO.EPS_SMALL then
-         dCutExtra = EgtIf( bDoubleCut, - 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN,  BD.CUT_EXTRA)
-      else
-         dCutExtra = - ( b3Raw:getDimY() - dMaxDepth)
-         local dSawRad = dSawDiam / 2
-         -- distanza in Y tra il centro della lama e l'intersezione tra la lama stessa e la massima Z della trave, + extra
-         -- se taglio doppio l'intersezione sarà in mezzeria, se taglio singolo sarà all'estremo opposto della trave
-         local dKL = dSawRad - dMaxDepth + EgtIf( bDoubleCut, b3Raw:getDimY() / 2 + BD.CUT_EXTRA_MIN, b3Raw:getDimY() + BD.CUT_EXTRA)
-         -- lunghezza minima del percorso di lavorazione, in caso accorciamento porti a lunghezza negativa
-         local dMinSawingLength = 5
-         if BD.C_SIMM then
-            dAccEnd = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
-            -- non posso comunque accorciare più della dimensione della geometria, quindi in caso allungo entrata
-            if dAccEnd > b3Raw:getDimZ() - 100 * GEO.EPS_SMALL then
-               dAccStart = b3Raw:getDimZ() - dAccEnd - dMinSawingLength
-            end
-         else
-            dAccStart = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
-            -- non posso comunque accorciare più della dimensione della geometria, quindi in caso allungo uscita
-            if dAccStart > b3Raw:getDimZ() - 100 * GEO.EPS_SMALL then
-               dAccEnd = b3Raw:getDimZ() - dAccStart - dMinSawingLength
-            end
-         end
-      end
+   
+   local bOk, sErr = MakeStandardCuts( Proc, b3Raw, nCuts, dOffsL, HeadCutType, Cutting1Data, Cutting2Data, nil, dOvmHead)

-      -- per travi alte faccio dei tagli orizzontali aggiuntivi
-      local bAreHorizontalCutsNeeded = ( dimV > BD.MAX_LEN_DICE) and not bBigSectionCut and ( dOvmHead > dMinOvmHeadForAddeddCuts - 10 * GEO.EPS_SMALL)
-      if bAreHorizontalCutsNeeded then
-         local nHorizontalCuts = ceil( dimV / BD.MAX_DIM_DICE) - 1
-         local dHorizontalSliceHeight = dimV / ( nHorizontalCuts + 1)
-         for i = nCuts, 1, -1 do
-            local dCutXOffset = ( i - 1) * dOffsL
-            -- tagli orizzontali
-            for j = nHorizontalCuts, 1, -1 do
-               local nFaceUse = MCH_MILL_FU.PARAL_DOWN
-               local dHorizontalCutOffset = dHorizontalSliceHeight * -j
-               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nFaceUse, nil, -0.1 -dCutXOffset, BD.CUT_SIC, dHorizontalCutOffset, 0, 0, '', b3Raw)
-               if not bOk then return bOk, sErr end
-            end
-            -- se necessario taglio verticale doppio, eseguo l'opposto
-            if bDoubleCut then
-               -- gli accorciamenti vanno invertiti per il taglio opposto
-               local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
-               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_BACK, nil, dCutExtra, BD.CUT_SIC, dCutXOffset, dAccStartDoubleCut, dAccEndDoubleCut, '', b3Raw, true)
-               if not bOk then return false, sErr end
-            end
-            -- taglio verticale
-            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutXOffset, dAccStart, dAccEnd, '', b3Raw)
-            if not bOk then return bOk, sErr end
-         end
-         return true, sWarn
-      end
-
-      -- se necessari tagli in doppio, eseguo gli opposti
-      if bDoubleCut then
-         -- gli accorciamenti vanno invertiti per il taglio opposto
-         local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
-         for i = nCuts, 1, -1 do
-            local dCutOffset = ( i - 1) * dOffsL
-            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_BACK, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStartDoubleCut, dAccEndDoubleCut, '', b3Raw, true)
-            if not bOk then return false, sErr end
-         end
-      end
-      -- eseguo i tagli necessari
-      for i = nCuts, 1, -1 do
-         local dCutOffset = ( i - 1) * dOffsL
-         -- se trave larga effettuo tagli verticali aggiuntivi
-         if ( dimH > BD.MAX_LEN_DICE) and ( dOvmHead > dMinOvmHeadForAddeddCuts - 10 * GEO.EPS_SMALL) then
-            local bOk, sErr = AddVerticalPreCuts( Proc, sCutting, dCutOffset, b3Raw)
-            if not bOk then return bOk, sErr end
-         end
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, '', b3Raw)
-         if not bOk then return false, sErr end
-      end
-   -- altrimenti necessari tagli da sopra e sotto con testa opportuna
-   else
-      -- 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
-      -- verifico che le due lame riescano a lavorare la sezione
-      local dDimZ = b3Raw:getDimZ()
-      local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ
-      if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not bBigSectionCut then
-         local sErr = 'Error : section too big for head cut'
-         EgtOutLog( sErr)
-         return false, sErr
-      end
-      -- calcolo extra taglio ed accorciamento
-      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, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw, nil, true)
-         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
-         -- se trave larga effettuo tagli verticali aggiuntivi
-         if ( dimH > BD.MAX_LEN_DICE) and ( dOvmHead > dMinOvmHeadForAddeddCuts - 10 * GEO.EPS_SMALL) then
-            local bOk, sErr = AddVerticalPreCuts( Proc, sCutting, dCutOffset, b3Raw)
-            if not bOk then return bOk, sErr end
-         end
-         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
-   return true
-end   
+   return bOk, sErr
+end

 ---------------------------------------------------------------------
 return ProcessHeadCut
@@ -108,6 +108,7 @@
 -- 2024/06/18 In MakeByMillAsSaw si cerca di orientare il motore verso il lato più vicino (rispetto a dove è la feature)
 -- 2024/06/28 In VerifySideMillAsSaw modificato criterio ricerca utensile in base a normale della faccia
 -- 2024/07/04 In IsTailFeature controllo per spostare lapjoint dopo taglio di separazione per lavorazioni tipo BH
+-- 2024/09/03 In MakeLongMoreFaces si aggiunge faccia di fondo anche per topologia Groove passante a 3 facce

 -- Tabella per definizione modulo
 local ProcessLapJoint = {}
@@ -141,6 +142,9 @@ local Q_SIDE_ROUGH_TOOL     = '' -- i
 local Q_ANTISPLINT_TYPE     = '' -- i
 local Q_BLADE_ON_ALONG_FACE = '' -- i
 local Q_MAX_ELEVATION       = '' -- d
+local Q_SAW_PLUS_CHAIN      = '' -- i
+local Q_FORCE_CHAINSAW      = '' -- i
+

 -- variabile smussi
 local bMadeChamfer
@@ -182,6 +186,7 @@ local function AssignQIdent( Proc)
   Q_MAX_ELEVATION      = 'Q10'
   Q_STAIRCASE          = ''
   Q_SAW_PLUS_CHAIN     = 'Q11'
+   Q_FORCE_CHAINSAW     = 'Q12'

   if ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 16 then
      Q_FORCE_BLADE         = 'Q01' -- i
@@ -1187,7 +1192,8 @@ local function MakePreCuts( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, nCha
         EgtSetName( AddId, 'AddCut_' .. tostring( Proc.Id))
         -- applico lavorazione
         local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         local nCutFacet = EgtSurfTmFacetCount( AddId)
         if nCutFacet == 1 then
            return Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
@@ -2547,7 +2553,7 @@ end
 ---------------------------------------------------------------------
 local function MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)

-   -- Se variabile globale indica che lo smusso è gi stato fatto, esco
+   -- Se variabile globale indica che lo smusso è già stato fatto, esco
   if bMadeChamfer then
      return 0
   end
@@ -2561,6 +2567,7 @@ local function MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfI
   end
   -- ottengo le curve di contorno libero
   local nAuxId1, nAuxId2, nNumIdAux
+   local bIsOpenPath = false
   if bIs3Faces then
      -- estraggo i percorsi
      nAuxId1, nNumIdAux = EgtExtractSurfTmLoops( Proc.Id, nAddGrpId)
@@ -2571,6 +2578,36 @@ local function MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfI
   else
      nAuxId1, nNumIdAux = EgtExtractSurfTmLoops( Proc.Id, nAddGrpId)
      if not nNumIdAux then nNumIdAux = 0 end
+      -- se non è una curva chiusa bisogna estrarre le sole curve da lavorare
+      if Proc.TopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then
+         local IdsToMachine = {}
+         bIsOpenPath = true
+         local nFirstId, nIdCount = EgtExplodeCurveCompo( nAuxId1)
+         for i = nFirstId, nFirstId + nIdCount - 1, 1 do
+            -- se segmento di retta
+            if EgtGetType( i) == GDB_TY.CRV_LINE then
+               local _, nEntitiesCount = EgtCurveDomain(i)
+               for j = 0, nEntitiesCount - 1 do
+                  local ptStart = EgtUP( i, j, GDB_RT.GLOB)
+                  local ptEnd = EgtUP( i, j + 1, GDB_RT.GLOB)
+                  if ( AreSameVectorApprox( vtOrtho, X_AX()) and ( abs( ptStart:getX() - b3Solid:getMax():getX()) < 100 * GEO.EPS_SMALL and abs( ptEnd:getX() - b3Solid:getMax():getX()) < 100 * GEO.EPS_SMALL) or
+                       AreSameVectorApprox( vtOrtho, -X_AX()) and ( abs( ptStart:getX() - b3Solid:getMin():getX()) < 100 * GEO.EPS_SMALL and abs( ptEnd:getX() - b3Solid:getMin():getX()) < 100 * GEO.EPS_SMALL) or
+                       AreSameVectorApprox( vtOrtho, Y_AX()) and ( abs( ptStart:getY() - b3Solid:getMax():getY()) < 100 * GEO.EPS_SMALL and abs( ptEnd:getY() - b3Solid:getMax():getY()) < 100 * GEO.EPS_SMALL) or
+                       AreSameVectorApprox( vtOrtho, -Y_AX()) and ( abs( ptStart:getY() - b3Solid:getMin():getY()) < 100 * GEO.EPS_SMALL and abs( ptEnd:getY() - b3Solid:getMin():getY()) < 100 * GEO.EPS_SMALL) or
+                       AreSameVectorApprox( vtOrtho, Z_AX()) and ( abs( ptStart:getZ() - b3Solid:getMax():getZ()) < 100 * GEO.EPS_SMALL and abs( ptEnd:getZ() - b3Solid:getMax():getZ()) < 100 * GEO.EPS_SMALL) or
+                       AreSameVectorApprox( vtOrtho, -Z_AX()) and ( abs( ptStart:getZ() - b3Solid:getMin():getZ()) < 100 * GEO.EPS_SMALL and abs( ptEnd:getZ() - b3Solid:getMin():getZ()) < 100 * GEO.EPS_SMALL)
+                     ) then
+                     table.insert( IdsToMachine, i)
+                  end
+               end
+            else
+               return 0
+            end
+         end
+         local ptNear = EgtSurfTmFacetCenter(Proc.Id, 0, GDB_ID.ROOT)
+         nAuxId1 = EgtCurveCompoByReorder( nAddGrpId, IdsToMachine, ptNear, true, GDB_ID.ROOT)
+         nNumIdAux = 1
+      end
   end

   local dExtra = 2
@@ -2590,13 +2627,20 @@ local function MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfI
         end
      else
         AuxId = nAuxId1 + i - 1
-         vtExtr, _, _ = EgtCurveArea( AuxId)
-      end
-      if vtExtr then
-         if not bIs3Faces then
+         if bIsOpenPath then
+            _, vtExtr = EgtCurveIsFlat( AuxId)
+         else
+            vtExtr, _, _ = EgtCurveArea( AuxId)
+         end
+         if vtExtr then
            local fFrCurve = EgtGetGlobFrame( AuxId)
            vtExtr:toGlob( fFrCurve)
+            if bIsOpenPath and vtExtr * vtOrtho < GEO.EPS_SMALL then
+               vtExtr = -vtExtr
+            end
         end
+      end
+      if vtExtr then
 --         if bIs3Faces and i == nNumIdAux then
 --            vtExtr = -vtExtr
 --         end
@@ -2840,6 +2884,12 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
         local nOk, sErr = MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)
         if nOk < 0 then return false, sErr end
      end
+   -- slot aperta su due lati
+   elseif Proc.TopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then
+      if nChamfer > 0 then
+         local nOk, sErr = MakeChamfer( Proc, false, nAddGrpId, rfFac:getVersZ(), b3Solid, nil, dDepthCham)
+         if nOk < 0 then return false, sErr end
+      end
   end
   if not dDepth then dDepth = dElev end
   -- Recupero le facce adiacenti alla principale
@@ -3359,7 +3409,11 @@ local function MakePocket( Proc, nPartId, b3Solid, ptPs, tvtN, nFaceRef, sMchFin
         end
      end
   end
+   -- eventuale massima elevazione imposta dall'utente
+   local dMaxElev = EgtGetInfo( Proc.Id, Q_MAX_ELEVATION, 'd')
+   if dMaxElev and dMaxElev < 1 then dMaxElev = nil end
   -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
+   dElev = dMaxElev or dElev
   local sWarn
   local dDepth = dElev
   if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
@@ -3370,11 +3424,7 @@ local function MakePocket( Proc, nPartId, b3Solid, ptPs, tvtN, nFaceRef, sMchFin
      EgtOutLog( sWarn)
   end
   -- imposto elevazione e dichiaro non si generano sfridi per VMill
-   -- eventuale massima elevazione imposta dall'utente
-   local dMaxElev = EgtGetInfo( Proc.Id, Q_MAX_ELEVATION, 'd')
-   if dMaxElev and dMaxElev < 1 then dMaxElev = nil end
-   dMaxElev = dMaxElev or dElev
-   local sNotes = 'MaxElev=' .. EgtNumToString( dMaxElev, 1) .. ';'
+   local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
   sNotes = sNotes .. 'VMRS=0;'
   if bOpenOutRaw then
      sNotes = sNotes .. 'OpenOutRaw=1;'
@@ -5106,22 +5156,29 @@ function SawPlusChain.ApplyMachining( Machining, b3Raw)
      local nErr
      nErr, sErr = EgtGetLastMachMgrError()
      -- se mortasatura e l'errore è compatibile (Axes values not calculable) si prova con l'altra configurazione dell'asse bloccato
-      -- TODO valutare se c'è modo di capire preventivamente la configurazione dell'asse bloccato e quindi rimuovere questa parte di codice
-      if Machining.Type == MCH_OY.MORTISING and nErr == 2507 then
-         if Machining.BlockedAxis.Orientation  == 'perpendicular' then
-            Machining.BlockedAxis.Orientation = 'parallel'
-         else
-            Machining.BlockedAxis.Orientation  = 'perpendicular'
+      if Machining.Type == MCH_OY.MORTISING then
+         -- se errore "Axes values not calculable" si prova con l'altra configurazione dell'asse bloccato
+         if nErr == 2507 then
+            if Machining.BlockedAxis.Orientation  == 'perpendicular' then
+               Machining.BlockedAxis.Orientation = 'parallel'
+            else
+               Machining.BlockedAxis.Orientation  = 'perpendicular'
+            end
+            EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.BlockedAxis.VtN, Machining.BlockedAxis.VtOut))
+            if Machining.SuggestedAngles.Index == 1 then
+               Machining.SuggestedAngles.Index = 2
+            else
+               Machining.SuggestedAngles.Index = 1
+            end
+            EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.SuggestedAngles.VtN, Machining.SuggestedAngles.VtOrtho, Machining.SuggestedAngles.Index))
+            sErr = ''
+            bIsApplyOk = ML.ApplyMachining( true, false)
+         -- se errore "Outstroke" e permesso ToolInvert provo ad invertire il lato di lavorazione
+         elseif Machining.AllowToolInvert and nErr == 2508 then
+            EgtSetMachiningParam( MCH_MP.TOOLINVERT, not Machining.ToolInvert)
+            sErr = ''
+            bIsApplyOk = ML.ApplyMachining( true, false)
         end
-         EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.BlockedAxis.VtN, Machining.BlockedAxis.VtOut))
-         if Machining.SuggestedAngles.Index == 1 then
-            Machining.SuggestedAngles.Index = 2
-         else
-            Machining.SuggestedAngles.Index = 1
-         end
-         EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.SuggestedAngles.VtN, Machining.SuggestedAngles.VtOrtho, Machining.SuggestedAngles.Index))
-         sErr = ''
-         bIsApplyOk = ML.ApplyMachining( true, false)
      end
      if not bIsApplyOk then
         nErr, sErr = EgtGetLastMachMgrError()
@@ -5178,18 +5235,16 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc, FaceToMachine, Edg
      Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. SawPlusChain.Name .. ' not applicable - saw blade not found'
      Cutting.CanApply = false
      EgtOutLog( Cutting.Message)
-      return Cutting
   end
   Cutting.Type = MCH_OY.MILLING
   Cutting.Tool = SawPlusChain.GetToolFromMachining( Cutting.Name)

-   -- verifica dimensioni tasca compatibili
+   -- verifica dimensioni tasca e direzione compatibili
   -- se tasca meno spessa della lama la strategia non è applicabile
   if Cutting.Tool.Thickness > dPocketHeight + 10 * GEO.EPS_SMALL then
      Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. SawPlusChain.Name .. ' not applicable - pocket too narrow for saw blade thickness'
      Cutting.CanApply = false
      EgtOutLog( Cutting.Message)
-      return Cutting
   end
   if #( Proc.MainFaces.SideFaces) > 1 then
      -- se tasca più stretta della lama la strategia non è applicabile
@@ -5197,9 +5252,13 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc, FaceToMachine, Edg
         Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. SawPlusChain.Name .. ' not applicable - pocket too narrow for saw blade diameter'
         Cutting.CanApply = false
         EgtOutLog( Cutting.Message)
-         return Cutting
      end
   end
+   if EdgeToMachine.ToolDirection:getZ() < BD.NZ_MINA then
+      Cutting.CanApply = false
+      Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : skipped sawblade from bottom'
+      EgtOutLog( Cutting.Message)
+   end

   -- parametri della lavorazione
   -- inizio e fine aperti o chiusi
@@ -5330,6 +5389,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc, FaceToMachine
   Mortising.CanApply = true
   Mortising.Message = ''
   Mortising.ProcId = Proc.Id
+   Mortising.AllowToolInvert = false
   local bNeedToMachineOtherSide = false
   local dTestCornerRadius = 43
   -- OneSide | OneSideAndExtend | BothSides | BothSidesAndExtend
@@ -5373,18 +5433,21 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc, FaceToMachine
      Mortising.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. SawPlusChain.Name .. ' not applicable - chainsaw not found'
      Mortising.CanApply = false
      EgtOutLog( Mortising.Message)
-      return Mortising
   end
   Mortising.Type = MCH_OY.MORTISING
   Mortising.Tool = SawPlusChain.GetToolFromMachining( Mortising.Name)

+   -- in caso di tunnel da un lato permetto eventuale inversione lato di lavoro in caso di errori di applicazione (es: Outstroke)
+   if Proc.Topology == 'Tunnel' and sMortisingType == 'OneSide' or sMortisingType == 'OneSideAndExtend' then
+      Mortising.AllowToolInvert = true
+   end
+
   -- verifica dimensioni tasca compatibili
   -- se tasca meno spessa della sega a catena la strategia non è applicabile
   if Mortising.Tool.Thickness > dPocketHeight + 10 * GEO.EPS_SMALL then
      Mortising.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. SawPlusChain.Name .. ' not applicable - pocket too narrow for chainsaw thickness'
      Mortising.CanApply = false
      EgtOutLog( Mortising.Message)
-      return Mortising
   end
   if #( Proc.MainFaces.SideFaces) > 1 then
      -- se tasca più stretta della sega a catena la strategia non è applicabile
@@ -5392,9 +5455,13 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc, FaceToMachine
         Mortising.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. SawPlusChain.Name .. ' not applicable - pocket too narrow for chainsaw width'
         Mortising.CanApply = false
         EgtOutLog( Mortising.Message)
-         return Mortising
      end
   end
+   if EdgeToMachine.ToolDirection:getZ() < - 10 * GEO.EPS_ANG_SMALL then
+      Mortising.CanApply = false
+      Mortising.Message = 'Feature '.. Proc.FeatureId .. ' : skipped chainsaw from bottom'
+      EgtOutLog( Mortising.Message)
+   end

   -- parametri della lavorazione
   -- inizio e fine aperti o chiusi
@@ -5551,9 +5618,9 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
   local bIsCuttingOk = false
   if Cutting.CanApply then
      bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
-   end
-   if not bIsCuttingOk then
-      return bIsCuttingOk, Cutting.Message
+      if not bIsCuttingOk then
+         return bIsCuttingOk, Cutting.Message
+      end
   end
   local dBottomDepthToMachine = Cutting.RadialOffset
   -- lato opposto del tunnel
@@ -5562,9 +5629,9 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
      bIsCuttingOk = false
      if Cutting.CanApply then
         bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
-      end
-      if not bIsCuttingOk then
-         return bIsCuttingOk, Cutting.Message
+         if not bIsCuttingOk then
+            return bIsCuttingOk, Cutting.Message
+         end
      end
   else
      -- se la lama non è arrivata sul fondo e c'è almeno un lato aperto va lavorato
@@ -5575,9 +5642,9 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
            bIsCuttingOk = false
            if Cutting.CanApply then
               bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
-            end
-            if not bIsCuttingOk then
-               return bIsCuttingOk, Cutting.Message
+               if not bIsCuttingOk then
+                  return bIsCuttingOk, Cutting.Message
+               end
            end
         end
         -- eventuale lavorazione di lama - lato della tasca in cui finisce la lavorazione
@@ -5586,9 +5653,9 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
            bIsCuttingOk = false
            if Cutting.CanApply then
               bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
-            end
-            if not bIsCuttingOk then
-               return bIsCuttingOk, Cutting.Message
+               if not bIsCuttingOk then
+                  return bIsCuttingOk, Cutting.Message
+               end
            end
         end
      -- la lama è arrivata sul fondo e tasca passante, non servono ulteriori lavorazioni
@@ -5622,9 +5689,9 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
      bIsMortisingOk = false
      if Mortising.CanApply then
         bIsMortisingOk, Mortising.Message = SawPlusChain.Chainsaw.ApplyAllSteps( Mortising, b3Raw)
-      end
-      if not bIsMortisingOk then
-         return bIsMortisingOk, Mortising.Message
+         if not bIsMortisingOk then
+            return bIsMortisingOk, Mortising.Message
+         end
      end
   else
      -- se la sega a catena non è arrivata sul fondo e c'è almeno un lato aperto va lavorato
@@ -5635,9 +5702,9 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
            bIsMortisingOk = false
            if Mortising.CanApply then
               bIsMortisingOk, Mortising.Message = SawPlusChain.Chainsaw.ApplyAllSteps( Mortising, b3Raw)
-            end
-            if not bIsMortisingOk then
-               return bIsMortisingOk, Mortising.Message
+               if not bIsMortisingOk then
+                  return bIsMortisingOk, Mortising.Message
+               end
            end
         end
         -- eventuale lavorazione di sega a catena - lato della tasca in cui finisce la lavorazione
@@ -5646,9 +5713,9 @@ function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
            bIsMortisingOk = false
            if Mortising.CanApply then
               bIsMortisingOk, Mortising.Message = SawPlusChain.Chainsaw.ApplyAllSteps( Mortising, b3Raw)
-            end
-            if not bIsMortisingOk then
-               return bIsMortisingOk, Mortising.Message
+               if not bIsMortisingOk then
+                  return bIsMortisingOk, Mortising.Message
+               end
            end
         end
      end
@@ -5731,23 +5798,38 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
   if nChamfer < 0 then
      return false, sErrCham
   end
+   -- eventuale forzatura sega a catena
+   local bForceChainsaw = ( EgtGetInfo( Proc.Id, Q_FORCE_CHAINSAW, 'i') or 0) > 0
   -- se è un tunnel provo a vedere se è possibile lavorarlo con la svuotatura o con la sega catena
   if bClosedOrthoFaces then
      local bTryWithBlades = true
+      local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace
+      -- forzata sega a catena
+      if bForceChainsaw then
+         -- ottengo le dimensioni del tunnel 
+         dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace = BL.GetTunnelDimension( Proc, nPartId)
      -- lavoro fessura con svuotature (singola o doppia contrapposta)
-      local sMyMchFind = 'Pocket'
-      local nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, 
+      else
+         local sMyMchFind = 'Pocket'
+         local nOk, sErr
+         nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho,
            nLundIdFace = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, false, b3Solid, bClosedOrthoFaces)
-      if nOk < 0 then
-         return false, sErr
-      elseif nOk > 0 then
-         bTryWithBlades = false
+         if nOk < 0 then
+            return false, sErr
+         elseif nOk > 0 then
+            bTryWithBlades = false
+         end
      end
      -- Se la svuotatura precedente non è stata fatta e chamfer non è mutuamente esclusivo provo con la sega-catena
      if bTryWithBlades and nChamfer < 2 then
         -- verifico se posso farlo con la sega-catena
         local bMakeChainSaw, sSawing, dMaxMat, dSawCornerRad, dSawThick, _, dSawWidth = VerifyChainSaw( Proc, dDimMin, dDimMax, dDepth)
         if bMakeChainSaw then
+            -- se forzata sega a catena devo verificare se inserire lo smusso
+            if bForceChainsaw and nChamfer > 0 then
+               local nOk, sErr = MakeChamfer( Proc, false, nAddGrpId, vtOrtho, b3Solid, nLundIdFace, dDepthCham)
+               if nOk < 0 then return -1, sErr end
+            end
            -- Ricalcolo l'affondamento tenendo conto di eventuale inclinazione
            local dSlDepth
            local frSlDh = Frame3d( Proc.Box:getCenter(), vtOrtho)
@@ -6203,6 +6285,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
            if bMillDown and BD.GetBottomToolMaxTotLen then
               dMaxTotLen = BD.GetBottomToolMaxTotLen( vtN)
            end
+            local dUserMaxElev = EgtGetInfo( Proc.Id, Q_MAX_ELEVATION, 'd')
            -- ricerca lavorazione
            local sPocketing
            local _, sMyPocketing, dMyTMaxDepth, dMyTDiam = VerifyPocket( Proc, dDiam, dFacElev + dCollSic, dMaxTotLen, sMchFind, bMillUp, bMillDown)
@@ -6210,10 +6293,12 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
               _, sMyPocketing, dMyTMaxDepth, dMyTDiam = VerifyPocket( Proc, dDiam, dFacElev + dCollSic, dMaxTotLen, sMchFind)
               bMillDown = false
            end
+            -- se l'utente ha definito un'elevazione custom dUserMaxElev si lavora sempre la faccia standard
            if sMyPocketing and
               ( dMyTMaxDepth > dFacElev + dCollSic - 10 * GEO.EPS_SMALL or ( dMyTMaxDepth > 0.8 * dFacElev + dCollSic and not bIsU) or
                 ( bIsL and nUseRoughTool == 0) or
-                 ( Proc.Prc == 25 and not bIsU and not bIsL)) then
+                 ( Proc.Prc == 25 and not bIsU and not bIsL)) or
+                 ( dUserMaxElev and dUserMaxElev > 10 * GEO.EPS_SMALL) then
               sPocketing = sMyPocketing
            end
            if bMillDown then
@@ -6232,6 +6317,10 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
            if bForceSideMill then
               sPocketing = nil
            end
+            -- se forzata sega a catena
+            if bForceChainsaw then
+               sPocketing = nil
+            end
            -- leggo parametro Q
            local nQAntisplintResult = EgtGetInfo( Proc.Id, Q_ANTISPLINT_TYPE, 'i') or 0
            -- se lavorazione fresa come lama disabilito eventuale antischeggia
@@ -6453,8 +6542,9 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                                 sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2)
                              end
                           end
-                        -- in tutti gli altri casi lancio la MakeByPockets (lavorazione singola o doppia contrapposta, fondo della tasca una faccia fittizia perpendicolare al lato lungo)
-                        else
+                        -- in tutti gli altri casi, a meno che non sia forzata sega a catena, lancio la MakeByPockets
+                        -- lavorazione singola o doppia contrapposta, fondo della tasca una faccia fittizia perpendicolare al lato lungo
+                        elseif not bForceChainsaw then
                           -- se 2 facce setto i parametri corretti per la MakeByPockets
                           if bForceSideMill and Proc.Fct == 2 then
                              bIs3Faces = false
@@ -6758,7 +6848,7 @@ local function MakeLongMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
   end
   -- verifico se applicare gestione speciale per tunnel
   local nSurfBottomId
-   if Proc.Topology == 'Tunnel' then
+   if Proc.Topology == 'Tunnel' or ( Proc.Topology == 'Groove' and Proc.IsThrough and Proc.Fct == 3) then
      bAddEndCapLeftSide = true
      bAddEndCapRightSide = true
      -- recupero centro e normale delle facce
@@ -1391,7 +1391,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
            -- aggiungo geometria
            EgtSetMachiningGeometry( {{ Proc.Id, 0}})
            -- inverto se utensile antiorario per garantire senso di percorrenza migliore
-            local bInvert = EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) < 0
+            local bInvert = EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) > 0
            -- setto workside e eventuale inversione
            if bInvert then
               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
@@ -949,18 +949,6 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
         end
      -- altrimenti concavo
      else
-         -- se effettivamente un taglio longitudinale e lama non taglia completamente, limito la lavorazione. Altrimenti esco.
-         for k = 1, #vOrd do
-            if vWidth[vOrd[k]] + BD.CUT_SIC > dMaxDepth  then
-               if not( ProcessLong2Cut.Identify( Proc)) then
-                  return false
-               else
-                  local sWarn2 = 'Warning in ' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. ' : elevation (' .. EgtNumToString( vWidth[vOrd[k]], 1) .. ') bigger than max saw depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-                  if not sWarn then sWarn = '' end
-                  sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2)
-               end
-            end
-         end
         -- si percorrono i lati alto e basso della faccia
         for i = 1, nC do
            -- Posizione braccio portatesta
@@ -990,6 +978,22 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
                  EgtOutLog( sErr)
                  return false, sErr
               end
+               -- se effettivamente un taglio longitudinale e lama non taglia completamente, limito la lavorazione. Altrimenti esco.
+               local dCheckDepth = 0
+               if bCanUseBlade then
+                  dCheckDepth = dMaxDepth
+               elseif bCanUseUnderBlade then
+                  dCheckDepth = dMaxDepthDn
+               end
+               if vWidth[vOrd[j]] + 100 * GEO.EPS_SMALL > dCheckDepth  then
+                  if not( ProcessLong2Cut.Identify( Proc)) then
+                     return false
+                  else
+                     local sWarn2 = 'Warning in ' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. ' : elevation (' .. EgtNumToString( vWidth[vOrd[j]], 1) .. ') bigger than max saw depth (' .. EgtNumToString( dCheckDepth, 1) .. ')'
+                     if not sWarn then sWarn = '' end
+                     sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2)
+                  end
+               end
               -- se lama da sotto verifico se la componente Y della profondità di taglio supera la capacità della lama
               if nSide <= 0 and bCanUseUnderBlade then
                  if ( vWidth[vOrd[j]] / 2) > dMaxDepthDn then
@@ -1003,7 +1007,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
               local dLioPerp

               if j == 1 then -- il primo taglio lo faccio completo se angolo interno maggiore di 90
-                  local dMinOffsBigFace = max( vWidth[vOrd[j]] - dMaxDepth, 0)
+                  local dMinOffsBigFace = max( vWidth[vOrd[j]] - dCheckDepth, 0)
                  -- se la faccia è più grande del massimo materiale lama, allora limito lavorazione
                  if dMinOffsBigFace > 0 then
                     dOffset = dMinOffsBigFace
@@ -1015,7 +1019,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
                  end
                  dLioPerp = vWidth[vOrd[j]] + BD.CUT_SIC
               else -- il secondo ridotto della distanza minima e della componente spessore della lama
-                  local dMinOffsBigFace = max( vWidth[vOrd[j]] - dMaxDepth, 0)
+                  local dMinOffsBigFace = max( vWidth[vOrd[j]] - dCheckDepth, 0)
                  -- se la faccia è più grande del massimo materiale lama, allora limito lavorazione
                  if dMinOffsBigFace > 0 then
                     dOffset = dMinOffsBigFace
@@ -3,6 +3,7 @@
 -- 2020/05/28 Tipo di lavorazione passato da Mark a Text.
 -- 2021/05/03 Aggiunta gestione testa da sotto.
 -- 2022/12/05 Aggiunta gestione tipo di lavorazione Text_AT.
+-- 2024/09/04 In Make gestione di più geometrie ausiliarie ( ora si lavora anche il testo, oltre che alle linee di marcatura)

 -- Tabella per definizione modulo
 local ProcessMark = {}
@@ -50,9 +51,6 @@ end
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessMark.Make( Proc, nPhase, nRawId, nPartId)
-   -- recupero eventuale geometria ausiliaria
-   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
-   if AuxId then AuxId = AuxId + Proc.Id end
   -- recupero i dati della marcatura
   local vtExtr
   if EgtGetType( Proc.Id) ~= GDB_TY.EXT_TEXT then
@@ -108,13 +106,15 @@ function ProcessMark.Make( Proc, nPhase, nRawId, nPartId)
      EgtSetOperationMode( nMchFId, false)
      return false, sErr
   end
-   -- eventuale lavorazione su seconda geometria
-   if AuxId then
+   -- si verifica se ci sono altre geometrie da lavorare
+   local AdditionalGeometries = EgtSplitString( EgtGetInfo( Proc.Id, 'AUXID', 's')) or {}
+   for i = 1, #AdditionalGeometries do
+      local AuxId = Proc.Id + AdditionalGeometries[i]
      -- inserisco la lavorazione di fresatura
-      local sName2 = 'Decor2_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-      local nMchF2Id = EgtAddMachining( sName, sMilling)
-      if not nMchF2Id then
-         local sErr = 'Error adding machining ' .. sName2 .. '-' .. sMilling
+      local nOtherMachiningId = EgtAddMachining( sName, sMilling)
+      if not nOtherMachiningId then
+         sName = 'Decor' .. '_' .. tostring( i) .. '_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+         local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
         EgtOutLog( sErr)
         return false, sErr
      end
@@ -125,14 +125,14 @@ function ProcessMark.Make( Proc, nPhase, nRawId, nPartId)
      -- eseguo
      if not ML.ApplyMachining( true, false) then
         local _, sErr = EgtGetLastMachMgrError()
-         EgtSetOperationMode( nMchF2Id, false)
+         EgtSetOperationMode( nOtherMachiningId, false)
         return false, sErr
      end
      -- se geometria a X maggiore, la sposto prima
      local ptS1 = EgtSP( Proc.Id, GDB_ID.ROOT)
      local ptS2 = EgtSP( AuxId, GDB_ID.ROOT)
      if ptS2:getX() > ptS1:getX() then
-         EgtRelocateGlob( nMchF2Id, nMchFId, GDB_IN.BEFORE)
+         EgtRelocateGlob( nOtherMachiningId, nMchFId, GDB_IN.BEFORE)
      end
   end
   return true
@@ -417,7 +417,8 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         local AddId = EgtSurfTmPlaneInBBox( nAddGrpId, ptCutC, vtCutN, b3Solid, GDB_RT.GLOB)
         local b3Cut = EgtGetBBoxGlob( AddId or GDB_ID.NULL, GDB_BB.STANDARD)
         local CutProc = { Id = AddId, Grp = Proc.Grp - 2, Prc = 10, Box = b3Cut, Fct = 1, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         local bFromBottom = ( b3Solid:getDimX() < BD.LEN_SHORT_PART and vtExtr:getZ() > 0.25)
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dCurrOvmH, bFromBottom)
         if not bOk then return bOk, sErr end
@@ -307,7 +307,8 @@ function ProcessProfCamb.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         -- altrimenti applico taglio di lama
         else
            local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+            CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dCurrOvmH)
            if not bOk then
               return false, sErr
@@ -311,7 +311,8 @@ function ProcessProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         -- altrimenti applico taglio di lama
         else
            local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+            CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dCurrOvmH)
            if not bOk then
               return false, sErr
@@ -311,7 +311,8 @@ function ProcessProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         -- altrimenti applico taglio di lama
         else
            local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+            CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dCurrOvmH)
            if not bOk then
               return false, sErr
@@ -258,7 +258,8 @@ function ProcessProfFront.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         -- altrimenti applico taglio di lama
         else
            local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+            CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dCurrOvmH)
            if not bOk then
               return false, sErr
@@ -293,7 +293,8 @@ function ProcessProfHead.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         -- altrimenti applico taglio di lama
         else
            local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+            CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dCurrOvmH)
            if not bOk then
               return false, sErr
@@ -134,7 +134,8 @@ function ProcessRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
         -- applico taglio di lama
         local b3Cut = EgtGetBBoxGlob( AddId or GDB_ID.NULL, GDB_BB.STANDARD)
         local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Cut, Fct = 1, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         if BL.IsCutNeeded( CutProc, b3Raw, dOvmHead) then
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, false)
            if not bOk then return bOk, sErr end
@@ -4,6 +4,7 @@
 -- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
 -- 2022/07/12 Aggiunta gestione PF1250 e TURN.
 -- 2023/02/14 Gestite le rotazioni di 90 deg nell'aggiornamento del grezzo.
+-- 2024/09/03 In ApplyDiceCut, se possibile, i tagli paralleli sono fatti con un unico passaggio di fianco.

 -- Tabella per definizione modulo
 local ProcessScarfJoint = {}
@@ -134,7 +135,9 @@ end
 local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Solid, ptC, vtN, Proc, vtRef, bHead, sCutting, dSawDiam, b3Raw, dNewDiceDim)

   local bOk = true
+   local bOk2 = true
   local sErr = ''
+   local sErr2 = ''

   local vCuts = {}
   if nGoodFace1 and nGoodFace4 and nGoodFace1 > 0 and nGoodFace4 > 0 then
@@ -185,9 +188,49 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
         -- extra taglio
         local dExtraCut = EgtIf( i % 2 == 1, 0, BD.CUT_EXTRA)
         -- lavoro la faccia
-         for j = 1, #vCuts[i] do
-            bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
-            if not bOk then return bOk, 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 dDiceFaceMaxH = 0
+         local dDiceFaceMinH = GEO.INFINITO
+         if ( i % 2) == 0  then
+            for cont = 1, #vCuts[i] do
+               local _, dDiceFaceH, dDiceFaceV = BL.GetFaceHvRefDim( vCuts[i][cont], 0)
+               dDiceFaceMaxH = max( dDiceFaceMaxH, dDiceFaceH)
+               -- calcolo lato orizzontale minore ipotizzando sia un trapezio
+               local dDiceFaceH2 = ( 2 * EgtSurfArea( vCuts[i][cont]) ) / dDiceFaceV - dDiceFaceH
+               dDiceFaceMinH = min( dDiceFaceMinH, dDiceFaceH2)
+            end
+         end
+         -- se si può fare, faccio unico taglio parallelo
+         if ( i % 2) == 0 and ( dMaxDepth > dDiceFaceMaxH - 0.5 * dDiceFaceMinH + BD.CUT_EXTRA_MIN) then
+            local bDoubleCut = false
+            local dCutExtra = BD.CUT_EXTRA
+            if dMaxDepth < dDiceFaceMaxH + BD.CUT_EXTRA then
+               bDoubleCut = true
+               dCutExtra = - 0.5 * dDiceFaceMinH + BD.CUT_EXTRA_MIN
+            end
+            local nSurfToCut = EgtSurfTmBySewing( nAddGrpId, vCuts[i], false)
+            local nFaceUseCut1, nFaceUseCut2 = MCH_MILL_FU.ORTHO_BACK, MCH_MILL_FU.ORTHO_FRONT
+            if Proc.Tail then
+               nFaceUseCut1, nFaceUseCut2 = nFaceUseCut2, nFaceUseCut1
+            end
+            if bDoubleCut then
+               bOk, sErr = Fbs.MakeOne( nSurfToCut, 0, sCutting, dSawDiam, nFaceUseCut1, nil, dCutExtra, BD.CUT_SIC, 0, 0, 0, '', b3Raw, true)
+               if not bOk then return false, sErr end
+            end
+            bOk2, sErr2 = Fbs.MakeOne( nSurfToCut, 0, sCutting, dSawDiam, nFaceUseCut2, nil, dCutExtra, BD.CUT_SIC, 0, 0, 0, '', b3Raw)
+            if not bOk2 then return false, sErr2 end
+         else
+            for j = 1, #vCuts[i] do
+               bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+               if not bOk then return bOk, sErr end
+            end
         end
      end
      -- lavoro la faccia interna in ogni caso
@@ -201,7 +244,7 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
      if vFaceOrd[3] ~= 0 then
         -- inserisco la lavorazione
         local vtOrthoO = Vector3d( vtRef)
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+         bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
         if not bOk then return bOk, sErr end
      end
   end
@@ -4,6 +4,7 @@
 -- 2022/08/09 Ora se la feature ha meno di due facce viene richiamata la normale Cut.
 -- 2022/11/09 Aggiunta gestione parametro Q04 per forzare utilizzo fresa di lato e lavorare come FreeContour.
 -- 2023/02/14 Gestite le rotazioni di 90 deg nell'aggiornamento del grezzo.
+-- 2024/08/05 Se assimilabile ad un taglio (1 faccia) si considerare area non pinzabile testa/coda

 -- Tabella per definizione modulo
 local ProcessSimpleScarf = {}
@@ -148,7 +149,7 @@ function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmT
   -- se ci sono meno di due facce si riduce a una normale Cut
   local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
   if nFacetCnt < 2 then
-      local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, nil, nil, nil, dOvmTail)
+      local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, nil, nil, nil, dOvmTail, true)
      return bOk, sErr
   end
   -- dati delle facce
@@ -38,6 +38,10 @@ EgtOutLog( ' ProcessSplit started', 1)
 local BD = require( 'BeamData')
 local ML = require( 'MachiningLib')

+if BD.PRECUT_TAIL == nil then
+   BD.PRECUT_TAIL = true
+end
+
 ---------------------------------------------------------------------
 -- Riconoscimento della feature
 function ProcessSplit.Identify( Proc)
@@ -63,7 +67,7 @@ end

 ---------------------------------------------------------------------
 -- lavorazione smussi
-local function MakeChamfer( nOriId, Proc, nPhase, nRawId, nPartId, dOvmHead)
+local function MakeChamfer( nOriId, Proc, nPhase, nRawId, nPartId, dOvmTail)
   -- verifico che lo smusso sia richiesto
   local dDepth = EgtGetInfo( nOriId, 'Q06', 'd') or 0
   if dDepth < 0.1 then return true end
@@ -165,7 +169,7 @@ end

 ---------------------------------------------------------------------
 -- lavorazione con sega a catena per sezioni alte e larghe
-local function MakeSplitByChainSaw( nSurfId, sSawing, nFaceUse, dDepth, sNotes, dOffs, bExtendStartEnd)
+local function MakeCutByChainSaw( nSurfId, sSawing, nFaceUse, dDepth, sNotes, dRadialOffset, bExtendStartEnd, bInvert)
   -- Recupero i dati dell'utensile
   local dMaxMat = 0
   local dSawCornerRad = 0
@@ -205,7 +209,7 @@ local function MakeSplitByChainSaw( nSurfId, sSawing, nFaceUse, dDepth, sNotes,
   local vtOrtho = BL.GetVersRef( nFaceUse)
   EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 1))
   -- imposto offset radiale per mantenere il materiale in coda per la finitura
-   EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
+   EgtSetMachiningParam( MCH_MP.OFFSR, dRadialOffset)
   -- imposto eventuale allungamento percorso iniziale
   local dStartAddLen = 0
   local dEndAddLen = 0
@@ -217,7 +221,13 @@ local function MakeSplitByChainSaw( nSurfId, sSawing, nFaceUse, dDepth, sNotes,
   EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEndAddLen)
   -- faccio in modo che l'attacco della lama sia dal lato opposto rispetto al corpo macchina
   EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
-   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+   if bInvert and bInvert == true then
+      EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+      EgtSetMachiningParam( MCH_MP.INVERT, true)
+   else
+      EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+      EgtSetMachiningParam( MCH_MP.INVERT, false)
+   end
   if dMaxMat >= dDepth then
      EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
   -- se massimo affondamento utensile inferiore fessura, setto affondamento ed emetto warning
@@ -253,12 +263,82 @@ local function MakeSplitByChainSaw( nSurfId, sSawing, nFaceUse, dDepth, sNotes,
   return true, sName, nMchFId
 end

+---------------------------------------------------------------------
+-- split per sezioni grandi con sega a catena o mix catena + lama
+function ProcessSplit.MakeBigSectionSplitting( Proc, b3Raw, dOffset, SawingData, Cutting2Data)
+   local sNotes = ''
+   if SawingData.bSplit ~= nil then
+      sNotes = 'Precut;'
+   end
+   local bigSectionSplitType
+   -- se pezzo non troppo alto, taglio singolo da sopra
+   if b3Raw:getDimZ() + BD.CUT_EXTRA_MIN < SawingData.dChainSawMaxMat + 10 * GEO.EPS_SMALL then
+      bigSectionSplitType = "single horizontal"
+   -- se pezzo non troppo largo, taglio singolo da davanti
+   elseif b3Raw:getDimY() + BD.CUT_EXTRA_MIN < min( SawingData.dChainSawMaxMat, SawingData.dChainSawLen - BD.C_SIMM_ENC) + 10 * GEO.EPS_SMALL then
+      bigSectionSplitType = "single vertical"
+   -- se pezzo non troppo largo, tagli dai due fianchi (dietro e davanti)
+   elseif 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN < min( SawingData.dChainSawMaxMat, SawingData.dChainSawLen - BD.C_SIMM_ENC) + 10 * GEO.EPS_SMALL then
+      bigSectionSplitType = "double vertical"
+   -- altrimenti taglio con sega a catena da sopra e con lama da sotto
+   elseif BD.DOWN_HEAD and ( b3Raw:getDimZ() + BD.CUT_EXTRA_MIN < Cutting2Data.dMaxDepth + SawingData.dChainSawMaxMat + 10 * GEO.EPS_SMALL) then
+      bigSectionSplitType = "double horizontal"
+   end
+
+   -- in base alle scelte precedenti, applico le lavorazioni
+   if bigSectionSplitType == "single horizontal" then
+      local dCutDepth = b3Raw:getDimZ() + BD.CUT_EXTRA_MIN
+      local sNotesSplit = EgtIf( SawingData.bSplit, 'Split;', sNotes)
+      -- verifico se sega a catena lunga e devo quindi estendere ingresso e uscita perchè è probabile che non riesca a ruotare sopra al pezzo
+      local bExtendStartEnd
+      local dMinLengthLongChainSaw = 630
+      if SawingData.dChainSawLen > dMinLengthLongChainSaw - 10 * GEO.EPS_SMALL then
+         bExtendStartEnd = true
+      end
+      local bOk, sErr = MakeCutByChainSaw( Proc.Id, SawingData.sSawing, MCH_MILL_FU.PARAL_TOP, dCutDepth, sNotesSplit, dOffset, bExtendStartEnd, SawingData.bInvert)
+      if not bOk then return bOk, sErr end
+   elseif bigSectionSplitType == "single vertical" then
+      local dCutDepth = b3Raw:getDimY() + BD.CUT_EXTRA_MIN
+      local sNotesSplit = EgtIf( SawingData.bSplit, 'Split;', sNotes)
+      local bOk, sErr = MakeCutByChainSaw( Proc.Id, SawingData.sSawing, MCH_MILL_FU.PARAL_FRONT, dCutDepth, sNotesSplit, dOffset, nil, SawingData.bInvert)
+      if not bOk then return bOk, sErr end
+   elseif bigSectionSplitType == "double vertical" then
+      local dCutDepth = 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN
+      local sNotesSplit = EgtIf( SawingData.bSplit, 'Presplit;', sNotes)
+      local bOk, sErr = MakeCutByChainSaw( Proc.Id, SawingData.sSawing, MCH_MILL_FU.PARAL_BACK, dCutDepth, sNotesSplit, dOffset, nil, SawingData.bInvert)
+      if not bOk then return bOk, sErr end
+      sNotesSplit = EgtIf( SawingData.bSplit, 'Split;', sNotes)
+      bOk, sErr = MakeCutByChainSaw( Proc.Id, SawingData.sSawing, MCH_MILL_FU.PARAL_FRONT, dCutDepth, sNotesSplit, dOffset, nil, SawingData.bInvert)
+      if not bOk then return bOk, sErr end
+   elseif bigSectionSplitType == "double horizontal" then
+      -- sega a catena da sopra
+      local dChainSawCutDepth = b3Raw:getDimZ() + BD.CUT_EXTRA_MIN - Cutting2Data.dMaxDepth
+      local sNotesSplit = EgtIf( SawingData.bSplit, 'Presplit;', sNotes)
+      local bOk, sErr = MakeCutByChainSaw( Proc.Id, SawingData.sSawing, MCH_MILL_FU.PARAL_TOP, dChainSawCutDepth, sNotesSplit, dOffset, nil, SawingData.bInvert)
+      if not bOk then return bOk, sErr end
+      -- lama da sotto
+      local dCutExtra = -dChainSawCutDepth + BD.CUT_EXTRA_MIN
+      local dVzLimDwnUp
+      if BD.TURN then dVzLimDwnUp = -2 end
+      local sNotes = EgtIf( SawingData.bSplit, 'Split;', sNotes)
+      local bMaximizeVerticalDepth = true
+      bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting2Data.sCutting, Cutting2Data.dSawDiam, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dOffset, 0, 0, sNotes, b3Raw, nil, bMaximizeVerticalDepth)
+      if not bOk then return false, sErr end
+   -- se è comunque troppo grande per essere separato, esco
+   else
+      local sErr = 'Error : section too big for splitting'
+      EgtOutLog( sErr)
+      return false, sErr, -1
+   end
+
+   return true
+end
+
 ---------------------------------------------------------------------
 -- tagli verticali aggiuntivi
 local function AddVerticalPreCuts( Proc, sCutting, dCutXOffset, b3Raw, sNotes)
-   local _, dimH = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
-   local nVerticalCuts = ceil( dimH / ( BD.MAX_LEN_DICE)) - 1
-   local dVerticalSliceHeight = dimH / ( nVerticalCuts + 1)
+   local nVerticalCuts = ceil( Proc.Face[1].WidthTrimmed / ( BD.MAX_LEN_DICE)) - 1
+   local dVerticalSliceHeight = Proc.Face[1].WidthTrimmed / ( nVerticalCuts + 1)
   -- recupero il diametro dell'utensile
   local dSawDiam = 400
   if EgtMdbSetCurrMachining( sCutting) then
@@ -272,12 +352,212 @@ local function AddVerticalPreCuts( Proc, sCutting, dCutXOffset, b3Raw, sNotes)
   for j = nVerticalCuts, 1, -1 do
      local nFaceUse = MCH_MILL_FU.PARAL_FRONT
      local dVerticalCutOffset = dVerticalSliceHeight * -j
-      bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nFaceUse, nil, -0.1 -dCutXOffset, BD.CUT_SIC, dVerticalCutOffset, 0, 0, sNotes, b3Raw)
+      local bForceTangentLeadInOut = BD.PRESS_ROLLER
+      bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nFaceUse, nil, -0.1 -dCutXOffset, BD.CUT_SIC, dVerticalCutOffset, 0, 0, sNotes, b3Raw, nil, nil, nil, bForceTangentLeadInOut)
      if not bOk then return bOk, sErr end
   end
+
   return bOk, sErr
 end

+---------------------------------------------------------------------
+-- tagli standard
+local function MakeStandardCuts( Proc, b3Raw, nCuts, dOffsetBetweenCuts, TailCutType, Cutting1Data, Cutting2Data, dStartOffset, dLenEndRaw)
+   if not TailCutType.sType then
+      TailCutType.sType = ''
+   end
+   local PrecutType = { bBigSectionCut = TailCutType.bBigSectionCut, bHorizCut = TailCutType.bHorizCut, bDoubleHorizCut = TailCutType.bDoubleHorizCut, bDoubleCut = TailCutType.bDoubleCut, bSplit = TailCutType.bSplit, sType = 'Precut', bNeedVerticalAddedCuts = false, bNeedHorizontalAddedCuts = false}
+   if not TailCutType.bDoubleHorizCut then
+      -- flag di lavorazione faccia
+      local nOrthoOpposite = EgtIf( TailCutType.bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_BACK)
+      -- calcolo extra taglio ed accorciamento
+      local dCutExtra = 0
+      local dAccStart = 0
+      local dAccEnd = 0
+      if TailCutType.bBigSectionCut and BD.C_SIMM then
+         -- qui arrivano sezioni molto grandi su macchine tipo PF con materiale da asportare inferiore allo spessore lama
+         local dSawRad = Cutting1Data.dSawDiam / 2
+         dCutExtra = - ( b3Raw:getDimY() - dSawRad)
+         dAccEnd = dSawRad
+      elseif b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL or b3Raw:getDimY() < 2 * BD.MAX_DIM_HTCUT_HBEAM + 10 * GEO.EPS_SMALL then
+         dCutExtra = EgtIf( TailCutType.bDoubleCut, - 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN, BD.CUT_EXTRA)
+      else
+         dCutExtra = - ( b3Raw:getDimY() - Cutting1Data.dMaxDepth)
+         local dSawRad = Cutting1Data.dSawDiam / 2
+         -- distanza in Y tra il centro della lama e l'intersezione tra la lama stessa e la massima Z della trave, + extra
+         -- se taglio doppio l'intersezione sarà in mezzeria, se taglio singolo sarà all'estremo opposto della trave
+         local dKL = dSawRad - Cutting1Data.dMaxDepth + EgtIf( TailCutType.bDoubleCut, b3Raw:getDimY() / 2 + BD.CUT_EXTRA_MIN, b3Raw:getDimY() + BD.CUT_EXTRA)
+         -- lunghezza minima del percorso di lavorazione, in caso accorciamento porti a lunghezza negativa
+         local dMinSawingLength = 5
+         if BD.C_SIMM then
+            dAccEnd = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
+            -- non posso comunque accorciare più della dimensione della geometria, quindi in caso allungo entrata
+            if dAccEnd > b3Raw:getDimZ() - 100 * GEO.EPS_SMALL then
+               dAccStart = b3Raw:getDimZ() - dAccEnd - dMinSawingLength
+            end
+         else
+            dAccStart = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
+            -- non posso comunque accorciare più della dimensione della geometria, quindi in caso allungo uscita
+            if dAccStart > b3Raw:getDimZ() - 100 * GEO.EPS_SMALL then
+               dAccEnd = b3Raw:getDimZ() - dAccStart - dMinSawingLength
+            end
+         end
+      end
+
+      -- per travi alte faccio faccio dei tagli orizzontali aggiuntivi
+      if TailCutType.bNeedHorizontalAddedCuts then
+         -- taglio a zero (con lama) per evitare problemi con grezzo più lungo del previsto. Se BigSection il pretaglio è già stato fatto.
+         if not TailCutType.bBigSectionCut and BD.PRECUT_TAIL then
+            dStartOffset = dLenEndRaw
+            local bOkPrecut, sErrPrecut = MakeStandardCuts( Proc, b3Raw, 1, 0, PrecutType, Cutting1Data, Cutting2Data, dStartOffset)
+            if not bOkPrecut then
+               return false, sErrPrecut
+            end
+         end
+         local nHorizontalCuts = ceil ( Proc.Face[1].HeightTrimmed / BD.MAX_DIM_DICE) - 1
+         local dHorizontalSliceHeight = Proc.Face[1].HeightTrimmed / ( nHorizontalCuts + 1)
+         for i = nCuts, 1, -1 do
+            local dCutXOffset = ( i - 1) * dOffsetBetweenCuts
+            -- tagli orizzontali
+            for j = nHorizontalCuts, 1, -1 do
+               local nFaceUse = MCH_MILL_FU.PARAL_DOWN
+               local dHorizontalCutOffset = dHorizontalSliceHeight * -j
+               local bForceTangentLeadInOut = BD.PRESS_ROLLER
+               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0 , Cutting1Data.sCutting, Cutting1Data.dSawDiam, nFaceUse, nil, -0.1 - dCutXOffset, BD.CUT_SIC, dHorizontalCutOffset, 0, 0, 'Precut;', b3Raw, nil, nil, nil, bForceTangentLeadInOut)
+               if not bOk then return false, sErr end
+            end
+            -- se necessario taglio verticale doppio, eseguo l'opposto
+            if TailCutType.bDoubleCut then
+               -- gli accorciamenti vanno invertiti per il taglio opposto
+               local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
+               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.dSawDiam, MCH_MILL_FU.ORTHO_FRONT, nil, dCutExtra, BD.CUT_SIC, dCutXOffset, dAccStartDoubleCut, dAccEndDoubleCut, 'Precut;', b3Raw, true)
+               if not bOk then return false, sErr end
+            end
+            -- taglio verticale
+            local sInfo = 'Precut'
+            if i == 1 and TailCutType.sType ~= 'Precut' then
+               sInfo = 'Cut'
+            end
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutXOffset, dAccStart, dAccEnd, sInfo, b3Raw)
+            if not bOk then return false, sErr end
+         end
+         return true, sWarn
+      end
+
+      -- taglio a zero (con lama) per evitare problemi con grezzo più lungo del previsto. Se BigSection il pretaglio è già stato fatto.
+      if not TailCutType.bBigSectionCut and BD.PRECUT_TAIL and TailCutType.bNeedVerticalAddedCuts then
+         dStartOffset = dLenEndRaw
+         local bOkPrecut, sErrPrecut = MakeStandardCuts( Proc, b3Raw, 1, 0, PrecutType, Cutting1Data, Cutting2Data, dStartOffset)
+         if not bOkPrecut then
+            return false, sErrPrecut
+         end
+      end
+      -- se necessari tagli in doppio, eseguo gli opposti
+      if TailCutType.bDoubleCut then
+         -- gli accorciamenti vanno invertiti per il taglio opposto
+         local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
+         for i = nCuts, 1, -1 do
+            local dCutOffset = ( i - 1) * dOffsetBetweenCuts
+            if i == 1 and TailCutType.sType =='Precut' then
+               dCutOffset = dStartOffset
+            end
+            local sNotes = EgtIf( TailCutType.bSplit, 'Presplit;', 'Precut;')
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.dSawDiam, MCH_MILL_FU.ORTHO_FRONT, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStartDoubleCut, dAccEndDoubleCut, sNotes, b3Raw, true)
+            if not bOk then return false, sErr end
+         end
+      end
+      -- eseguo i tagli necessari
+      for i = nCuts, 1, -1 do
+         local dCutOffset = ( i - 1) * dOffsetBetweenCuts
+         -- se trave larga effettuo tagli verticali aggiuntivi
+         if TailCutType.bNeedVerticalAddedCuts then
+            local sSpecNotes = EgtIf( TailCutType.bSplit, 'Presplit;', 'Precut;')
+            local bOk, sErr = AddVerticalPreCuts( Proc, Cutting1Data.sCutting, dCutOffset, b3Raw, sSpecNotes)
+            if not bOk then return bOk, sErr end
+         end
+         if i == 1 and TailCutType.sType =='Precut' then
+            dCutOffset = dStartOffset
+         end
+         local sNotes
+         if TailCutType.bSplit then
+            sNotes = EgtIf( i == 1, 'Split;', 'Presplit;')
+         else
+            sNotes = EgtIf( i == 1 and TailCutType.sType ~= 'Precut', 'Cut;', 'Precut;')
+         end
+         -- se primo taglio da sopra e PF o ONE richiedo risalita preliminare a Zmax
+         if i == nCuts and TailCutType.bHorizCut and BD.C_SIMM and not BD.DOWN_HEAD then
+            sNotes = EgtSetValInNotes( sNotes, 'StartZmax', 2)
+         end
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw)
+         if not bOk then return false, sErr end
+      end
+   -- altrimenti necessari tagli da sopra e sotto con testa opportuna
+   else
+      -- verifico esistenza della lavorazione con lama da sotto
+      if not Cutting2Data.sCutting then
+         local sErr = 'Error : cutting H2 not found in library'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- verifico che le due lame riescano a lavorare la sezione
+      local dDimZ = b3Raw:getDimZ()
+      local dExtra = Cutting1Data.dMaxVertDepth + Cutting2Data.dMaxDepth - dDimZ
+      if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not TailCutType.bBigSectionCut then
+         local sErr = 'Error : section too big for tail cut'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- calcolo extra taglio ed accorciamento
+      local dCutExtra = -Cutting2Data.dMaxDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
+      local dCutExtra2 = -Cutting1Data.dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
+      local dAccStart = 0
+      -- limiti da sotto
+      local dVzLimDwnUp
+      if BD.TURN then dVzLimDwnUp = -2 end
+      -- taglio a zero (con lama) per evitare problemi con grezzo più lungo del previsto. Se BigSection il pretaglio è già stato fatto.
+      if not TailCutType.bBigSectionCut and BD.PRECUT_TAIL and TailCutType.bNeedVerticalAddedCuts then
+         dStartOffset = dLenEndRaw
+         local bOkPrecut, sErrPrecut = MakeStandardCuts( Proc, b3Raw, 1, 0, PrecutType, Cutting1Data, Cutting2Data, dStartOffset)
+         if not bOkPrecut then
+            return false, sErrPrecut
+         end
+      end
+      -- eseguo i tagli da sotto necessari
+      for i = nCuts, 1, -1 do
+         local dCutOffset = ( i - 1) * dOffsetBetweenCuts
+         if i == 1 and TailCutType.sType =='Precut' then
+            dCutOffset = dStartOffset
+         end
+         local sNotes = EgtIf( TailCutType.bSplit, 'Presplit;', 'Precut;')
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting2Data.sCutting, Cutting2Data.dSawDiam, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw, nil, true)
+         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) * dOffsetBetweenCuts
+         if i == 1 and TailCutType.sType =='Precut' then
+            dCutOffset = dStartOffset
+         end
+         -- se trave larga effettuo tagli verticali aggiuntivi
+         if TailCutType.bNeedVerticalAddedCuts then
+            local sSpecNotes = EgtIf( TailCutType.bSplit, 'Presplit;', 'Precut;')
+            local bOk, sErr = AddVerticalPreCuts( Proc, Cutting1Data.sCutting, dCutOffset, b3Raw, sSpecNotes)
+            if not bOk then return bOk, sErr end
+         end
+         local sNotes
+         if TailCutType.bSplit then
+            sNotes = EgtIf( i == 1, 'Split;', 'Presplit;')
+         else
+            sNotes = EgtIf( i == 1 and TailCutType.sType ~= 'Precut', 'Cut;', 'Precut;')
+         end
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, Cutting1Data.sCutting, Cutting1Data.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
+
+   return true
+end
+
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dOvmTail)
@@ -289,7 +569,7 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
   -- inserimento smussi
   local nOriId = EgtGetInfo( Proc.Id, 'ORI', 'i')
   if nOriId then
-      local bOkc, sErrC = MakeChamfer( nOriId, Proc, nPhase, nRawId, nPartId, dOvmHead)
+      local bOkc, sErrC = MakeChamfer( nOriId, Proc, nPhase, nRawId, nPartId, dOvmTail)
      if not bOkc then return bOkc, sErrC end
   end
   -- recupero la lavorazione
@@ -326,6 +606,20 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
         dSawThick2 = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick2
      end
   end
+   -- recupero dati utensile della sega a catena più lunga a disposizione
+   local sSawing = ML.FindSawing( 'SawingForSplitting', nil, nil, 'Longest')
+   if not sSawing then
+      sSawing = ML.FindSawing( 'Sawing', nil, nil, 'Longest')
+   end
+   local dChainSawMaxMat = 0
+   local dChainSawLen = 0
+   if EgtMdbSetCurrMachining( sSawing or '') then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         dChainSawMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dChainSawMaxMat
+         dChainSawLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dChainSawLen
+      end
+   end
   -- caratteristiche taglio
   local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dSawMaxDepth, abs( BD.MAX_DIM_HTCUT_HBEAM))
   local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and
@@ -335,8 +629,6 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
   local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA  + 10 * GEO.EPS_SMALL)
   -- dati geometrici del taglio
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
-   -- flag di lavorazione faccia
-   local nOrthoOpposite = EgtIf( bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_BACK)
   -- separazione solo se esiste grezzo successivo con pezzi o scaricabile
   local nNextRawId = EgtGetNextRawPart( nRawId)
   local bSplit = ( nNextRawId  and  ( EgtGetPartInRawPartCount( nNextRawId) > 0  or  EgtGetRawPartBBox( nNextRawId):getDimX() >= BD.MinRaw))
@@ -344,8 +636,6 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
   local dLenEndRaw = dOvmTail
   local nCuts = 1
   local dOffsL = 0
-   local _, dimH, dimV = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
-   local dMinTailScrapForAdditionalCuts = 10.123
   if not bSplit then
      -- cerco grezzo successivo che sia nella fase
      if nNextRawId  and  EgtVerifyRawPartPhase( nNextRawId, nPhase) then
@@ -355,94 +645,38 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
         dOffsL = dLenEndRaw / nCuts
         -- aggiorno ingombro del grezzo corrente con quello del successivo
         b3Raw:Add( b3NextRaw)
+      else
+         dLenEndRaw = min( dOvmTail, abs( ptC:getX() - b3Raw:getMin():getX()))
      end
   end
+   -- determino la necessità di tagli aggiuntivi
+   local dMinTailScrapForAdditionalCuts = 10.123
+   local bNeedVerticalAddedCuts = not bSplit and ( Proc.Face[1].WidthTrimmed > BD.MAX_LEN_DICE) and ( dLenEndRaw > dMinTailScrapForAdditionalCuts - 10 * GEO.EPS_SMALL)
+   local bNeedHorizontalAddedCuts = not bSplit and ( Proc.Face[1].HeightTrimmed > ( BD.MIN_HEIGHT_ADDED_CUTS or BD.MAX_LEN_DICE)) and not bBigSectionCut and ( dLenEndRaw > dMinTailScrapForAdditionalCuts - 10 * GEO.EPS_SMALL)
+   -- dati lavorazioni sopra e sotto
+   local Cutting1Data = { sCutting = sCutting, dSawDiam = dSawDiam, dMaxDepth = dSawMaxDepth, dSawThick = dSawThick, dMaxVertDepth = dMaxVertDepth}
+   local Cutting2Data = { sCutting = sCutting2, dSawDiam = dSawDiam2, dMaxDepth = dSawMaxDepth2, dSawThick = dSawThick2}
+   local SawingData = { sSawing = sSawing, dChainSawMaxMat = dChainSawMaxMat, dChainSawLen = dChainSawLen, bSplit = bSplit or false}
+   -- dati sul taglio di coda da effettuare
+   local TailCutType = { bBigSectionCut = bBigSectionCut, bHorizCut = bHorizCut, bDoubleHorizCut = bDoubleHorizCut, bDoubleCut = bDoubleCut, bSplit = bSplit, bNeedVerticalAddedCuts = bNeedVerticalAddedCuts, bNeedHorizontalAddedCuts = bNeedHorizontalAddedCuts}
   -- se taglio per pezzi alti e larghi
   local nNewPhase = 0
   if bBigSectionCut then
      local bFinishingNeeded = false
      if bSplit then
-         -- recupero dati utensile della sega a catena più lunga a disposizione
-         local sSawing = ML.FindSawing( 'SawingForSplitting', nil, nil, 'Longest')
-         if not sSawing then
-            sSawing = ML.FindSawing( 'Sawing', nil, nil, 'Longest')
-         end
-         local dChainSawMaxMat = 0
-         local dChainSawLen = 0
-         if EgtMdbSetCurrMachining( sSawing or '') then
-            local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-            if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-               dChainSawMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dChainSawMaxMat
-               dChainSawLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dChainSawLen
-            end
-         end
-
-         local bigSectionSplitType
-         -- se pezzo non troppo alto, taglio singolo da sopra
-         if b3Raw:getDimZ() + BD.CUT_EXTRA_MIN < dChainSawMaxMat + 10 * GEO.EPS_SMALL then
-            bigSectionSplitType = "single horizontal"
-         -- se pezzo non troppo largo, taglio singolo da davanti
-         elseif b3Raw:getDimY() + BD.CUT_EXTRA_MIN < min( dChainSawMaxMat, dChainSawLen - BD.C_SIMM_ENC) + 10 * GEO.EPS_SMALL then
-            bigSectionSplitType = "single vertical"
-         -- se pezzo non troppo largo, tagli dai due fianchi (dietro e davanti)
-         elseif 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN < min( dChainSawMaxMat, dChainSawLen - BD.C_SIMM_ENC) + 10 * GEO.EPS_SMALL then
-            bigSectionSplitType = "double vertical"
-         -- altrimenti taglio con sega a catena da sopra e con lama da sotto
-         elseif BD.DOWN_HEAD and ( b3Raw:getDimZ() + BD.CUT_EXTRA_MIN < dSawMaxDepth2 + dChainSawMaxMat + 10 * GEO.EPS_SMALL) then
-            bigSectionSplitType = "double horizontal"
-         end
-
-         -- assegno offset in  lunghezza
-         local dOffs = 0
+         -- assegno offset in lunghezza
+         local dTailOffset = 0
         if dOvmTail > BD.OVM_CHAIN_HBEAM then
-            dOffs = dOvmTail - BD.OVM_CHAIN_HBEAM
+            dTailOffset = dOvmTail - BD.OVM_CHAIN_HBEAM
            bFinishingNeeded = true
         end
-         
-         -- in base alle scelte precedenti, applico le lavorazioni
-         if bigSectionSplitType == "single horizontal" then
-            local dCutDepth = b3Raw:getDimZ() + BD.CUT_EXTRA_MIN
-            local sNotesSplit = 'Split;'
-            -- verifico se sega a catena lunga e devo quindi estendere ingresso e uscita perchè è probabile che non riesca a ruotare sopra al pezzo
-            local bExtendStartEnd
-            local dMinLengthLongChainSaw = 630
-            if dChainSawLen > dMinLengthLongChainSaw - 10 * GEO.EPS_SMALL then
-               bExtendStartEnd = true
-            end
-            local bOk, sErr = MakeSplitByChainSaw( Proc.Id, sSawing, MCH_MILL_FU.PARAL_TOP, dCutDepth, sNotesSplit, dOffs, bExtendStartEnd)
-            if not bOk then return bOk, sErr, nNewPhase end
-         elseif bigSectionSplitType == "single vertical" then
-            local dCutDepth = b3Raw:getDimY() + BD.CUT_EXTRA_MIN
-            local sNotesSplit = 'Split;'
-            local bOk, sErr = MakeSplitByChainSaw( Proc.Id, sSawing, MCH_MILL_FU.PARAL_FRONT, dCutDepth, sNotesSplit, dOffs)
-            if not bOk then return bOk, sErr, nNewPhase end
-         elseif bigSectionSplitType == "double vertical" then
-            local dCutDepth = 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN
-            local sNotesSplit = 'Presplit;'
-            local bOk, sErr = MakeSplitByChainSaw( Proc.Id, sSawing, MCH_MILL_FU.PARAL_BACK, dCutDepth, sNotesSplit, dOffs)
-            if not bOk then return bOk, sErr, nNewPhase end
-            sNotesSplit = 'Split;'
-            bOk, sErr = MakeSplitByChainSaw( Proc.Id, sSawing, MCH_MILL_FU.PARAL_FRONT, dCutDepth, sNotesSplit, dOffs)
-            if not bOk then return bOk, sErr, nNewPhase end
-         elseif bigSectionSplitType == "double horizontal" then
-            -- sega a catena da sopra
-            local dChainSawCutDepth = b3Raw:getDimZ() + BD.CUT_EXTRA_MIN - dSawMaxDepth2
-            local sNotesSplit = 'Presplit;'
-            local bOk, sErr = MakeSplitByChainSaw( Proc.Id, sSawing, MCH_MILL_FU.PARAL_TOP, dChainSawCutDepth, sNotesSplit, dOffs)
-            if not bOk then return bOk, sErr, nNewPhase end
-            -- lama da sotto
-            local dCutExtra = -dChainSawCutDepth + BD.CUT_EXTRA_MIN
-            local dVzLimDwnUp
-            if BD.TURN then dVzLimDwnUp = -2 end
-            local sNotes = 'Split;'
-            local bMaximizeVerticalDepth = true
-            bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dOffs, 0, 0, sNotes, b3Raw, nil, bMaximizeVerticalDepth)
-            if not bOk then return false, sErr end
-         -- se è comunque troppo grande per essere separato, esco
-         else
-            local sErr = 'Error : section too big for splitting'
-            EgtOutLog( sErr)
-            return false, sErr, -1
+         -- split per grande sezione
+         local bOk, sErr, nNewPhase2 = ProcessSplit.MakeBigSectionSplitting( Proc, b3Raw, dTailOffset, SawingData, Cutting2Data)
+         if nNewPhase2 then
+            nNewPhase = nNewPhase2
+         end
+         if not bOk then
+            return bOk, sErr, nNewPhase
         end
         -- se necessaria finitura, creo nuova fase
         if bFinishingNeeded then
@@ -490,12 +724,20 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
         else
            dMaxElev = Proc.Box:getMax():getX() - b3Raw:getMin():getX()
         end
+         -- taglio a zero (con sega a catena o mix catena + lama) per evitare problemi con grezzo più lungo del previsto
+         if BD.PRECUT_TAIL and not bSplit then
+            local dTailOffset = dLenEndRaw
+            local bOkPrecut, sErrPrecut = ProcessSplit.MakeBigSectionSplitting( Proc, b3Raw, dTailOffset, SawingData, Cutting2Data)
+            if not bOkPrecut then
+               return false, sErrPrecut
+            end
+         end
         -- se finitura con lama
         if nQ05 < 2 or ( not bSplit and dMaxElev > dSawThickCheck) then
            -- controllo se è necessario un taglio con dicing o si deve proseguire ai casi standard
            if bSplit or dMaxElev > dSawThickCheck then
               local bOk, sErr
-               if not bSplit and ( dimH > BD.MAX_LEN_DICE) and ( dLenEndRaw > dMinTailScrapForAdditionalCuts - 10 * GEO.EPS_SMALL) then
+               if bNeedVerticalAddedCuts then
                  -- ad ogni offset di taglio dovrò fare prima i tagli verticali e poi i cubetti 
                  for i = nCuts, 1, -1 do
                     local nAddGrpId = BL.GetAddGroup( Proc.PartId)
@@ -560,156 +802,11 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
         return true, nil, nNewPhase
      end
   end
-   -- se tagli standard
-   if not bDoubleHorizCut then
-      -- calcolo extra taglio ed accorciamento
-      local dCutExtra = 0
-      local dAccStart = 0
-      local dAccEnd = 0
-      if bBigSectionCut and BD.C_SIMM then
-         -- qui arrivano sezioni molto grandi su macchine tipo PF con materiale da asportare inferiore allo spessore lama
-         local dSawRad = dSawDiam / 2
-         dCutExtra = - ( b3Raw:getDimY() - dSawRad)
-         dAccEnd = dSawRad
-      elseif b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL or b3Raw:getDimY() < 2 * BD.MAX_DIM_HTCUT_HBEAM + 10 * GEO.EPS_SMALL then
-         dCutExtra = EgtIf( bDoubleCut, - 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN, BD.CUT_EXTRA)
-      else
-         dCutExtra = - ( b3Raw:getDimY() - dSawMaxDepth)
-         local dSawRad = dSawDiam / 2
-         -- distanza in Y tra il centro della lama e l'intersezione tra la lama stessa e la massima Z della trave, + extra
-         -- se taglio doppio l'intersezione sarà in mezzeria, se taglio singolo sarà all'estremo opposto della trave
-         local dKL = dSawRad - dSawMaxDepth + EgtIf( bDoubleCut, b3Raw:getDimY() / 2 + BD.CUT_EXTRA_MIN, b3Raw:getDimY() + BD.CUT_EXTRA)
-         -- lunghezza minima del percorso di lavorazione, in caso accorciamento porti a lunghezza negativa
-         local dMinSawingLength = 5
-         if BD.C_SIMM then
-            dAccEnd = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
-            -- non posso comunque accorciare più della dimensione della geometria, quindi in caso allungo entrata
-            if dAccEnd > b3Raw:getDimZ() - 100 * GEO.EPS_SMALL then
-               dAccStart = b3Raw:getDimZ() - dAccEnd - dMinSawingLength
-            end
-         else
-            dAccStart = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
-            -- non posso comunque accorciare più della dimensione della geometria, quindi in caso allungo uscita
-            if dAccStart > b3Raw:getDimZ() - 100 * GEO.EPS_SMALL then
-               dAccEnd = b3Raw:getDimZ() - dAccStart - dMinSawingLength
-            end
-         end
-      end

-      -- per travi alte faccio faccio dei tagli orizzontali aggiuntivi
-      local bAreHorizontalCutsNeeded = not bSplit and ( dimV > BD.MAX_LEN_DICE) and not bBigSectionCut and ( dLenEndRaw > dMinTailScrapForAdditionalCuts - 10 * GEO.EPS_SMALL)
-      if bAreHorizontalCutsNeeded then
-         local nHorizontalCuts = ceil ( dimV / BD.MAX_DIM_DICE) - 1
-         local dHorizontalSliceHeight = dimV / ( nHorizontalCuts + 1)
-         for i = nCuts, 1, -1 do
-            local dCutXOffset = ( i - 1) * dOffsL
-            -- tagli orizzontali
-            for j = nHorizontalCuts, 1, -1 do
-               local nFaceUse = MCH_MILL_FU.PARAL_DOWN
-               local dHorizontalCutOffset = dHorizontalSliceHeight * -j
-               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0 , sCutting, dSawDiam, nFaceUse, nil, -0.1 - dCutXOffset, BD.CUT_SIC, dHorizontalCutOffset, 0, 0, 'Precut;', b3Raw)
-               if not bOk then return false, sErr end
-            end
-            -- se necessario taglio verticale doppio, eseguo l'opposto
-            if bDoubleCut then
-               -- gli accorciamenti vanno invertiti per il taglio opposto
-               local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
-               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_FRONT, nil, dCutExtra, BD.CUT_SIC, dCutXOffset, dAccStartDoubleCut, dAccEndDoubleCut, 'Precut;', b3Raw, true)
-               if not bOk then return false, sErr end
-            end
-            -- taglio verticale
-            local sInfo = 'PreCut;'
-            if i == 1 then sInfo = 'Cut;' end
-            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutXOffset, dAccStart, dAccEnd, sInfo, b3Raw)
-            if not bOk then return false, sErr end
-         end
-         return true, sWarn, nNewPhase
-      end
+   local bOk, sErr = MakeStandardCuts( Proc, b3Raw, nCuts, dOffsL, TailCutType, Cutting1Data, Cutting2Data, nil, dLenEndRaw)

-      -- se necessari tagli in doppio, eseguo gli opposti
-      if bDoubleCut then
-         -- gli accorciamenti vanno invertiti per il taglio opposto
-         local dAccStartDoubleCut, dAccEndDoubleCut = dAccEnd, dAccStart
-         for i = nCuts, 1, -1 do
-            local dCutOffset = ( i - 1) * dOffsL
-            local sNotes = EgtIf( bSplit, 'Presplit;', 'Precut;')
-            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_FRONT, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStartDoubleCut, dAccEndDoubleCut, sNotes, b3Raw, true)
-            if not bOk then return false, sErr end
-         end
-      end
-      -- eseguo i tagli necessari
-      for i = nCuts, 1, -1 do
-         local dCutOffset = ( i - 1) * dOffsL
-         -- se trave larga effettuo tagli verticali aggiuntivi
-         if not bSplit and ( dimH > BD.MAX_LEN_DICE) and ( dLenEndRaw > dMinTailScrapForAdditionalCuts - 10 * GEO.EPS_SMALL) then
-            local sSpecNotes = EgtIf( bSplit, 'Presplit;', 'Precut;')
-            local bOk, sErr = AddVerticalPreCuts( Proc, sCutting, dCutOffset, b3Raw, sSpecNotes)
-            if not bOk then return bOk, sErr end
-         end
-         local sNotes
-         if bSplit then
-            sNotes = EgtIf( i == 1, 'Split;', 'Presplit;')
-         else
-            sNotes = EgtIf( i == 1, 'Cut;', 'Precut;')
-         end
-         -- se primo taglio da sopra e PF o ONE richiedo risalita preliminare a Zmax
-         if i == nCuts and bHorizCut and BD.C_SIMM and not BD.DOWN_HEAD then
-            sNotes = EgtSetValInNotes( sNotes, 'StartZmax', 2)
-         end
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw)
-         if not bOk then return false, sErr end
-      end
-   -- altrimenti necessari tagli da sopra e sotto con testa opportuna
-   else
-      -- 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
-      -- verifico che le due lame riescano a lavorare la sezione
-      local dDimZ = b3Raw:getDimZ()
-      local dExtra = dMaxVertDepth + dSawMaxDepth2 - dDimZ
-      if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not bBigSectionCut then
-         local sErr = 'Error : section too big for tail cut'
-         EgtOutLog( sErr)
-         return false, sErr
-      end
-      -- calcolo extra taglio ed accorciamento
-      local dCutExtra = -dSawMaxDepth2 + 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, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw, nil, true)
-         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
-         -- se trave larga effettuo tagli verticali aggiuntivi
-         if not bSplit and ( dimH > BD.MAX_LEN_DICE) and ( dLenEndRaw > dMinTailScrapForAdditionalCuts - 10 * GEO.EPS_SMALL) then
-            local sSpecNotes = EgtIf( bSplit, 'Presplit;', 'Precut;')
-            local bOk, sErr = AddVerticalPreCuts( Proc, sCutting, dCutOffset, b3Raw, sSpecNotes)
-            if not bOk then return bOk, sErr end
-         end
-         local sNotes
-         if bSplit then
-            sNotes = EgtIf( i == 1, 'Split;', 'Presplit;')
-         else
-            sNotes = EgtIf( i == 1, 'Cut;', 'Precut;')
-         end
-         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
-   return true, nil, nNewPhase
-end   
+   return bOk, sErr, nNewPhase
+end

 ---------------------------------------------------------------------
 return ProcessSplit
@@ -212,7 +212,8 @@ local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
         EgtSetInfo( AddId, 'TASKID', Proc.TaskId)
         -- applico lavorazione
         local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
         if not bOk then return bOk, sErr end
      end
@@ -223,7 +224,8 @@ local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
         EgtSetInfo( AddId, 'TASKID', Proc.TaskId)
         -- applico lavorazione
         local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
         if not bOk then return bOk, sErr end
      end
@@ -392,7 +394,8 @@ local function MakeThreeFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
      EgtSetInfo( AddId, 'TASKID', Proc.TaskId)
      -- applico lavorazione
      local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                        Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                        Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+      CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
      local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
      if not bOk then return bOk, sErr end
   end
@@ -200,7 +200,8 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
         else
            local b3Cut = EgtGetBBoxGlob( AddId or GDB_ID.NULL, GDB_BB.STANDARD)
            local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Cut, Fct = 1, Flg = Proc.Flg,
-                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+            CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
            local bFromBottom = ( bShortPart and vtExtr:getZ() > 0.25)
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom)
            if not bOk then
@@ -232,7 +232,8 @@ local function MakeMachByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw,
      -- se va fatto, inserisco la lavorazione
      if bCut then
         local CutProc = { Id = AuxId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
         -- se taglio applicato setto la nota al gruppo Mach per non doverla lavorare una seconda volta
         if bOk then
@@ -330,7 +331,8 @@ local function MakeMachByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw,
         -- se va fatto, inserisco la lavorazione
         if bCut then
            local CutProc = { Id = AuxId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
-                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
+                              Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
+            CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
            -- se taglio applicato setto la nota al gruppo Mach per non doverla lavorare una seconda volta
            if bOk then
@@ -1,5 +1,26 @@
           ==== Beam Update Log ====

+Versione 2.6h2 (26/08/2024)
+- Added : in BatchProcess e New si verifica l'abilitazione alla generazione con EgtVerifyKeyOption
+- Modif : in FacesBySaw introdotti attacchi tangenziali solo da un lato, limitati a facce con Z negative
+- Modif : in LapJoint -> tunnel lo smusso funziona anche se è forzata la sega a catena
+- Modif : in LapJoint -> svuotatura, se l'utente ha definito un'elevazione custom si lavora sempre la faccia standard
+- Modif : in FacesBySaw -> MakeOne aggiunta la possibilità di passare una direzione di lavoro alternativa per poter rispettare contemporaneamente la direzione di lavoro concorde e la direzione di taglio.
+
+Versione 2.6h1 (20/08/2024)
+- Modif : in SimpleScarf, se assimilabile a un taglio, si considera area non pinzabile
+- Modif : in LapJoint gestito smusso nel caso Groove-Blind-RightAngles-Parallel-4
+- Modif : varie modifiche ai tagli di lama per evitare chiusura rulli pneumatici e finecorsa
+- Modif : in BatchProcessNew, se presente flag apposito in EgtCam5, si evita la generazione
+
+Versione 2.6g4 (19/07/2024)
+- Modif : in BatchProcess e BatchProcessNew si forza ricalcolo ogni volta che si è in situazione di CHECK o CHECK + GENERATE
+
+Versione 2.6g3 (07/07/2024)
+- Added : aggiunta possibilità di funzione GetNzLimDownUp specifica per ogni macchina
+- Modif : anche nel taglio a cubetti si chiama GetNzLimDownUp di macchina, se presente, per decidere limite orientamento lama verso il basso
+- Modif : in BeamExec inserito controllo massimo numero di facce per lanciare GetFacetsInfo
+- Fixed : in LapJoint corretto typo in nome variabile che provocava mancata impostazione asse bloccato

 Versione 2.6g2 (04/07/2024)
 - Modif : le lavorazioni BlockHaus, se vicine alla coda, vengono spostate dopo il taglio di separazione
@@ -2,5 +2,5 @@
 -- Gestione della versione di Beam

 NAME = 'Beam'
-VERSION = '2.6g2'
-MIN_EXE = '2.6e2'
+VERSION = '2.6h2'
+MIN_EXE = '2.6h1'
Author	SHA1	Message	Date
luca.mazzoleni	0a767d1afd	- in Headcut e Split aggiunta gestione parametro MIN_HEIGHT_ADDED_CUTS da BeamData per scegliere l'altezza minima per cui devono essere aggiunti i tagli orizzontali supplementari	2024-09-05 12:12:29 +02:00
luca.mazzoleni	d5be638099	Merge branch 'develop' into ZeroPreCutForHeadCutSplit	2024-09-04 18:28:17 +02:00
luca.mazzoleni	b6c5514f9e	- in HeadCut e Split correzioni a pretaglio a zero	2024-09-04 18:27:39 +02:00
luca.mazzoleni	4fd18d377f	- in split modifiche per precut	2024-09-04 17:52:37 +02:00
andrea.villa	9dff37f1f4	Gestione dipendenza foro-tasca in caso di fase con pezzo ribaltato	2024-09-04 15:54:13 +02:00
luca.mazzoleni	b71ad963f1	Merge branch 'develop' into ZeroPreCutForHeadCutSplit	2024-09-04 09:17:07 +02:00
andrea.villa	3aefca4613	- In Mark, gestita la lavorazione del testo	2024-09-04 09:16:24 +02:00
luca.mazzoleni	cc5117aa11	- in Split refactoring e implemento pretaglio a zero - in HeadCut piccole migliorie in pretaglio a zero	2024-09-03 18:02:18 +02:00
andrea.villa	c5a8b852d9	- in LapJpint, in MakeLongMoreFaces si aggiunge faccia di fondo anche per topologia Groove passante a 3 facce	2024-09-03 15:11:53 +02:00
andrea.villa	69514074a9	- In ScarfJoint, in ApplyDiceCut, tagli paralleli fatti con unico passaggio di fianco	2024-09-03 12:45:28 +02:00
luca.mazzoleni	6ecd613f12	- in HeadCut corrette Width e Height invertite	2024-09-02 16:54:47 +02:00
luca.mazzoleni	6e4dee29af	modifiche a HeadCut per introduzione tagli a zero (PreCut) per evitare problemi con pezzi non lunghi quanto ci si aspetta	2024-09-02 10:29:08 +02:00
luca.mazzoleni	da7ebc6b97	- refactoring di ProcessHeadCut	2024-08-29 18:17:08 +02:00
luca.mazzoleni	4685b6bde6	- se lapjoint attraversata da L055, la lapjoint viene fatta prima	2024-08-29 10:47:51 +02:00
luca.mazzoleni	3a063bd2cf	Merge branch 'master' into develop	2024-08-26 18:10:47 +02:00
luca.mazzoleni	710a1fe070	- HotFix: in FacesBySaw -> MakeOne corretto SCC in caso di soluzione alternativa	2024-08-26 18:10:20 +02:00
luca.mazzoleni	d818492d67	Merge tag '2.6h2' into develop release	2024-08-26 15:43:59 +02:00
luca.mazzoleni	e55e33c40a	Merge branch 'release/2.6h2'	2024-08-26 15:43:44 +02:00
luca.mazzoleni	8cadb25261	update log e version	2024-08-26 15:43:30 +02:00
luca.mazzoleni	2622b58cad	Merge branch 'OneFaceCutAlternativeDirection' into develop	2024-08-26 15:31:03 +02:00
luca.mazzoleni	b5be932955	- in FacesBySaw -> MakeOne aggiunta la possibilità di passare una direzione di lavoro alternativa per poter rispettare contemporaneamente la direzione di lavoro concorde e la direzione di taglio	2024-08-26 15:17:31 +02:00
luca.mazzoleni	44ac2f8c2a	Merge branch 'test' into develop	2024-08-22 16:37:55 +02:00
luca.mazzoleni	0b928e987f	- in LapJoint -> svuotatura, correzione all'utilizzo dell'elevazione custom	2024-08-22 15:49:25 +02:00
luca.mazzoleni	c213c3f059	- in LapJoint -> svuotatura, se l'utente ha definito un'elevazione custom si lavora sempre la faccia standard	2024-08-22 15:23:03 +02:00
luca.mazzoleni	330698b6aa	in tunnel LapJoint -> tunnel lo smusso funziona anche se è forzata la sega a catena	2024-08-22 12:01:43 +02:00
luca.mazzoleni	eb1ef693c4	Merge branch 'test' into develop	2024-08-22 11:25:02 +02:00
luca.mazzoleni	862751c84a	- in FacesBySaw attacchi tangenziali solo da un lato limitati a facce con Z negative - in BatchProcess e New si verifica l'abilitazione della generazione con EgtVerifyKeyOption - in Version, MIN_EXE modificato per richiesta compatibilità con EgtVerifyKeyOption	2024-08-21 13:05:31 +02:00
luca.mazzoleni	e5a30c38d3	Merge tag '2.6h1' into develop r	2024-08-20 17:45:26 +02:00
luca.mazzoleni	e83d8db1cc	Merge branch 'release/2.6h1'	2024-08-20 17:45:14 +02:00
luca.mazzoleni	9de88ffe84	update log e version	2024-08-20 17:45:00 +02:00
luca.mazzoleni	ffaf33c62e	in BatchProcessNew se flag apposito in Cam5 la generazione è disabilitata	2024-08-20 17:34:46 +02:00
luca.mazzoleni	8c0389582b	Merge branch 'ImproveDicingParallelTangentLead' into develop	2024-08-20 17:05:20 +02:00
luca.mazzoleni	ebe3d79c11	- in FacesBySaw attacchi tangenziali solo da un lato limitati a facce con basse componenti Y - in split e headcut i tagli addizionali orizzontali o verticali, se la macchina ha i ruli, si fanno sempre con attacco tangenziale	2024-08-20 17:02:37 +02:00
luca.mazzoleni	f8c40739da	- in attacchi tangenziali solo da un lato alcune correzioni - aggiunta la raccolta delle Affected Faces a tutti i casi in cui si crea una feature a posteriori (non presente nel btl)	2024-08-19 17:37:16 +02:00
luca.mazzoleni	fa5aac926e	- attacchi tangenziali solo da un lato lasciati solo per se FacesBySaw è chiamata da ProcessCut	2024-08-09 12:02:27 +02:00
luca.mazzoleni	749cd1e2bb	- in FacesBySaw limiti alle normali se attacco tangenziale dallo stesso lato	2024-08-09 12:00:20 +02:00
luca.mazzoleni	587aaaafce	- in FacesBySaw->MakeOne, se attacco tangenziale e cubetti paralleli, si attacca e stacca sempre dallo stesso lato - modificate di conseguenza funzioni significative che generano questi tipi di taglio	2024-08-08 15:20:51 +02:00
luca.mazzoleni	2cfa7caba7	Merge branch 'ImproveChamferLapJoint' into develop	2024-08-07 17:46:16 +02:00
luca.mazzoleni	fc0fba5bd3	- in FacesBySaw revert delle modifiche precedenti per problemi di chiusura rulli	2024-08-07 17:45:38 +02:00
luca.mazzoleni	94159f88f3	- in FacesBySaw.MakeOne se si ha outstroke si tenta attacco alternativo	2024-08-07 16:11:38 +02:00
luca.mazzoleni	4961d2d528	- in LapJoint gestito smusso nel caso Groove-Blind-RightAngles-Parallel-4	2024-08-06 15:25:37 +02:00
luca.mazzoleni	7b22f5cc47	Merge remote-tracking branch 'origin/develop' into develop	2024-08-06 15:19:50 +02:00
andrea.villa	5047d5b652	In SimpleSarf, se assimilabile ad un taglio (1 faccia) si considerare area non pinzabile testa/coda	2024-08-05 09:24:14 +02:00
luca.mazzoleni	7f9b880ff7	Merge branch 'master' into develop	2024-07-19 18:06:44 +02:00
luca.mazzoleni	7e457a22b0	update log e versione	2024-07-19 18:06:32 +02:00
luca.mazzoleni	3c080e2b1a	in BatchProcess e BatchProcessNew bToRecalc forzato se flag 3 o 4	2024-07-19 18:04:16 +02:00
luca.mazzoleni	9d3edbfb54	- in BatchProcessNew bToRecalc forzato se flasg 3 o 4 - in ProcessLapJoint si evita di tentare di lavorare con sega a catena da sotto	2024-07-19 16:08:18 +02:00
luca.mazzoleni	adf465c5e2	-in SawPlusChain non non si applicano lavorazioni con lama da sotto (lama da sotto al momento non gestita) -in SawPlusChain ora se una lavorazione non è applicabile si prosegue con le altre invece di uscire	2024-07-18 18:41:09 +02:00
luca.mazzoleni	23f695fd56	Merge branch 'master' into develop	2024-07-18 16:03:36 +02:00
luca.mazzoleni	52f347def1	update log e version	2024-07-17 16:10:37 +02:00
luca.mazzoleni	028688b88a	- in SawPlusChain con tunnel passante fatto da un solo lato, se apply della sega a catena fallisce per finecorsa, si riapplica dal lato opposto	2024-07-17 16:06:26 +02:00
luca.mazzoleni	cde5b137ae	update log e versione per 2.6g3	2024-07-17 15:24:10 +02:00
luca.mazzoleni	d0cf5887d3	-in LongCut invertito senso di rotazione truciolatore (ora è in discordanza)	2024-07-17 12:28:21 +02:00
luca.mazzoleni	afc4c6aaff	- corretto problema in LongDoubleCut in cui si sbagliava la riduzione di affondamento con lama da sotto - in Lapjoint aggiunta Q_FORCE_CHAINSAW per forzare sega a catena anche in casi in cui ci passerebbe la fresa	2024-07-17 11:46:07 +02:00
luca.mazzoleni	caa1875309	Merge branch 'master' into develop	2024-07-12 12:53:14 +02:00
Dario Sassi	0acd75bece	DataBeam : - inserito controllo massimo numero di facce (20) per eseguire GetFacetsInfo.	2024-07-09 18:18:56 +02:00
Dario Sassi	db691cefe4	Merge commit 'd0ecd175c284b108acb1b4290cf5616b61d121c8'	2024-07-09 17:52:36 +02:00