diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua
index 0ab6135..af2d211 100644
--- a/LuaLibs/BeamExec.lua
+++ b/LuaLibs/BeamExec.lua
@@ -2104,6 +2104,7 @@ function BeamExec.ProcessFeatures()
                Proc.Box = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD)
                Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
                Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc)
+               Proc.DistanceToNextPart = BL.GetDistanceToNextPart( nRawId, nPhase)
                Proc.PrevDouble = nPrevDouble
                nPrevDouble = Proc.Double
                local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bNeedHCut, b3Raw, nOrd, sDownOrSideOrStd, nil, nil, dCurrOvmT)
@@ -2185,6 +2186,7 @@ function BeamExec.ProcessFeatures()
                Proc.Box = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD)
                Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
                Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc)
+               Proc.DistanceToNextPart = BL.GetDistanceToNextPart( nRawId, nPhase)
                Proc.PrevDouble = nPrevDouble
                nPrevDouble = Proc.Double
                local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, false, b3Raw, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dCurrOvmT)
@@ -2254,6 +2256,7 @@ function BeamExec.ProcessFeatures()
             Proc.Box = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD)
             Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
             Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc)
+            Proc.DistanceToNextPart = BL.GetDistanceToNextPart( nRawId, nPhase)
             Proc.PrevDouble = nPrevDouble
             nPrevDouble = Proc.Double
             local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, false, b3Raw, nOrd, sDownOrSideOrStd, nil, nil, dCurrOvmT)
diff --git a/LuaLibs/BeamLib.lua b/LuaLibs/BeamLib.lua
index 7373bd9..bb06fba 100644
--- a/LuaLibs/BeamLib.lua
+++ b/LuaLibs/BeamLib.lua
@@ -814,9 +814,10 @@ function BeamLib.GetDistanceToNextPart( nRawId, nPhase)
    -- se segue una parte rimanente riutilizzabile, modifico opportunamente questa distanza
    if not BeamLib.IsSplittedPartPhase( nPhase) then
       local nNextRawId = EgtGetNextRawPart( nRawId)
-      if  nNextRawId and 
-          EgtGetPartInRawPartCount( nNextRawId) <= 0 and 
-          EgtGetRawPartBBox( nNextRawId):getDimX() >= BD.MinRaw then
+      if nNextRawId and
+         EgtGetPartInRawPartCount( nNextRawId) <= 0 and
+         EgtGetRawPartBBox( nNextRawId):getDimX() >= BD.MinRaw then
+
          dDistToNextPiece = BD.OVM_MID
       end
    end
@@ -1185,11 +1186,19 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 function BeamLib.GetFacetsInfo( Proc, b3Raw)
-   Face = {}
+   local Face = {}
    local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( Proc.PartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+   local vAdj
+   if Proc.AdjacencyMatrix then
+      vAdj = Proc.AdjacencyMatrix
+   else
+      vAdj = BeamLib.GetAdjacencyMatrix( Proc)
+   end
 
    for i = 1, Proc.Fct do
-      Face[i] = { Id = i - 1, VtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT )}
+      Face[i] = {}
+      Face[i].Id = i - 1
+      Face[i].PtCenter, Face[i].VtN =  EgtSurfTmFacetCenter( Proc.Id, i - 1, GDB_ID.ROOT)
       if Proc.Fct < 10 then
          local frHV, dFaceWidthTrimmed, dFaceHeightTrimmed = BeamLib.GetFaceHvRefDim( Proc.Id, i - 1, b3Raw)
          -- frame OCS faccia
@@ -1205,11 +1214,58 @@ function BeamLib.GetFacetsInfo( Proc, b3Raw)
          Face[i].Height = dFaceHeight
          -- elevazione calcolata rispetto al box della parte
          Face[i].Elevation = EgtSurfTmFacetElevationInBBox( Proc.Id, i - 1, b3Solid, true, GDB_ID.ROOT)
+         -- area della faccia
+         -- TODO qui sarebbe meglio l'area vera e non quella del rettangolo minimo
+         local _, dLongEdgeDimension, dShortEdgeDimension = EgtSurfTmFacetMinAreaRectangle( Proc.Id, i - 1, GDB_ID.ROOT)
+         Face[i].Area = dShortEdgeDimension * dLongEdgeDimension
+         -- adiacenze della faccia
+         -- TODO chiamarle in modo che si capisca che sono solo gli id e non l'intero oggetto faccia
+         Face[i].Adjacencies = {}
+         for j = 1, Proc.Fct do
+            if vAdj[i][j] and vAdj[i][j] ~= 0 and ( i ~= j) then
+               table.insert( Face[i].Adjacencies, j - 1)
+            end
+         end
       end
    end
 
    return Face
 end
 
+---------------------------------------------------------------------
+-- restituisce la matrice delle adiacenze di Proc dove i e j sono le facce e a(ij) è l'angolo tra di esse; 0 se nessuna adiacenza
+function BeamLib.GetAdjacencyMatrix( Proc)
+   local vAdj = {}
+   -- essendo la matrice simmetrica a diagonale nulla, ne calcolo solo la metà superiore
+   for i = 1, Proc.Fct do
+      vAdj[i] = {}
+      for j = i + 1, Proc.Fct do
+         _, _, _, vAdj[i][j] = EgtSurfTmFacetsContact( Proc.Id, i - 1, j - 1, GDB_ID.ROOT)
+         if not vAdj[i][j] then vAdj[i][j] = 0 end
+      end
+   end
+   -- riempio di conseguenza il resto della matrice
+   for i = 1, Proc.Fct do
+      vAdj[i][i] = 0
+      for j = i + 1, Proc.Fct do
+         vAdj[j][i] = vAdj[i][j]
+      end
+   end
+   return vAdj
+end
+
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.GetMachiningSteps( dMachiningDepth, dStep)
+
+   local MachiningSteps = {}
+   MachiningSteps.StepLength = 0
+   MachiningSteps.Count = ceil( ( dMachiningDepth - 10 * GEO.EPS_SMALL) / dStep)
+   if MachiningSteps.Count > 1 then
+      MachiningSteps.StepLength = ( dMachiningDepth - dStep) / ( MachiningSteps.Count - 1)
+   end
+
+   return MachiningSteps
+end
+
 -------------------------------------------------------------------------------------------------------------
 return BeamLib
\ No newline at end of file
diff --git a/LuaLibs/FeatureTopology.lua b/LuaLibs/FeatureTopology.lua
index df8d227..733f97c 100644
--- a/LuaLibs/FeatureTopology.lua
+++ b/LuaLibs/FeatureTopology.lua
@@ -19,32 +19,10 @@ local BL = require( 'BeamLib')
 
 EgtOutLog( ' FeatureTopology started', 1)
 
----------------------------------------------------------------------
--- restituisce la matrice delle adiacenze di Proc dove i e j sono le facce e a(ij) è l'angolo tra di esse; 0 se nessuna adiacenza
-local function GetAdjacencyMatrix( Proc)
-   local vAdj = {}
-   -- essendo la matrice simmetrica a diagonale nulla, ne calcolo solo la metà superiore
-   for i = 1, Proc.Fct do
-      vAdj[i] = {}
-      for j = i + 1, Proc.Fct do
-         _, _, _, vAdj[i][j] = EgtSurfTmFacetsContact( Proc.Id, i - 1, j - 1, GDB_ID.ROOT)
-         if not vAdj[i][j] then vAdj[i][j] = 0 end
-      end
-   end
-   -- riempio di conseguenza il resto della matrice
-   for i = 1, Proc.Fct do
-      vAdj[i][i] = 0
-      for j = i + 1, Proc.Fct do
-         vAdj[j][i] = vAdj[i][j]
-      end
-   end
-   return vAdj
-end
-
 ---------------------------------------------------------------------
 -- restituisce gli id delle facce di Proc che hanno il numero di adiacenze nAdj
 function FeatureTopology.GetFacesWithGivenAdjacencyNumber( Proc, vAdj, nAdj)
-   if not vAdj then vAdj = GetAdjacencyMatrix( Proc) end
+   if not vAdj then vAdj = BL.GetAdjacencyMatrix( Proc) end
    local nFct = #( vAdj or {}) 
    local vFacesWithGivenAdj = {}
    for i = 1, nFct do
@@ -188,7 +166,7 @@ function FeatureTopology.Classify( Proc, b3Raw)
       Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
    end
 
-   local vAdj = GetAdjacencyMatrix( Proc)
+   local vAdj = Proc.AdjacencyMatrix or BL.GetAdjacencyMatrix( Proc)
    local bAllAnglesConcave, bAllRightAngles = AreAllAnglesConcaveOrRight( vAdj)
    local vTriangularFaces = GetTriangularFaces( Proc)
    local bIsAnyDimensionLongAsPart = IsAnyDimensionLongAsPart( Proc)
diff --git a/LuaLibs/ProcessCut.lua b/LuaLibs/ProcessCut.lua
index 04883f4..d74d6b7 100644
--- a/LuaLibs/ProcessCut.lua
+++ b/LuaLibs/ProcessCut.lua
@@ -25,6 +25,7 @@
 -- 2023/10/27 In MakeFromTop corretto massimo materiale in caso di lavorazione da sotto.
 -- 2023/12/07 Correzione in Classify in scelta ribaltamento trave quando si è in condizioni downUp.
 -- 2024/01/18 Gestita superficie limitante opzionale da passare a diceCut.
+-- 2024/05/10 In MakeFromTop ricalcolo direzione di lavorazione su facce a cubetti
 
 -- Tabella per definizione modulo
 local ProcessCut = {}
@@ -479,7 +480,15 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
             if vtO then
                vtOrthoO = Vector3d( vtO) * EgtIf( bOrthInv, -1, 1)
             else
-               if bHorizCut then
+               -- ricalcolo tipo taglio perché "bHorizCut" è calcolato sulla feature, mentre il cubetto potrebbe essere lavorato in un altro modo
+               local _, dLen, dWidth = BL.GetFaceHvRefDim( vCuts[i][1], 0, b3Raw)
+               local bCutDirection = bHorizCut
+               -- se bisogna tagliare di fianco ma la lunghezza faccia è più del massimo materiale, forzo lavorazione da sopra
+               if not bHorizCut and dLen > dMaxDepth then
+                  bCutDirection = true
+               end
+
+               if bCutDirection then
                   vtOrthoO = Z_AX()
                else
                   if vtN:getZ() < dNzLimDwnUp then
diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua
index 63367ce..cb3faf8 100644
--- a/LuaLibs/ProcessLapJoint.lua
+++ b/LuaLibs/ProcessLapJoint.lua
@@ -775,6 +775,10 @@ function ProcessLapJoint.IsTailFeature( Proc, b3Raw)
          return false
       end
    end
+   -- se forzata lavorazione con lama e feature aperta sulla coda potrei lavorare anche dalla coda
+   if Proc.AffectedFaces.Left and ( EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') or 0) > 0 then
+      return true
+   end
    -- deve avere la normale principale diretta verso la coda (oppure tunnel)
    Topology.Classify( Proc, b3Raw)
    local nFacInd, dElev, nFacInd2, dElev2 = BL.GetFaceWithMostAdj( Proc, nPartId)
@@ -4618,12 +4622,15 @@ end
 local SawPlusChain =  {}
 SawPlusChain.Saw = {}
 SawPlusChain.Chainsaw = {}
+SawPlusChain.Name = 'SawPlusChain'
+SawPlusChain.ApplyOnlySawblade = false
 
 
 function SawPlusChain.IsTopologyOk( Proc)
    if Proc.TopologyLongName == 'Pocket-Blind-RightAngles-Parallel-5' or
       Proc.TopologyLongName == 'Groove-Through-RightAngles-Parallel-3' or
-      Proc.TopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then
+      Proc.TopologyLongName == 'Groove-Blind-RightAngles-Parallel-4'  or
+      Proc.TopologyLongName == 'Tunnel-Through-RightAngles-Parallel-4' then
 
       return true
    else
@@ -4632,7 +4639,59 @@ function SawPlusChain.IsTopologyOk( Proc)
 end
 
 
+function SawPlusChain.GetTunnelFaces( Proc)
+   local TunnelAddedFaces = {}
+
+   -- TODO scrivere il box della parte nella Proc o fare funzione per recuperarlo
+   local b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( Proc.PartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+
+   if not ( Proc.IsThrough and Proc.AllRightAngles and Proc.Fct < 5) then
+      error( 'GetTunnelFaces : Topology not implemented')
+   end
+
+   -- direzione del tunnel
+   local vtTunnelDirection = Proc.Face[1].VtN ^ Proc.Face[ Proc.Face[1].Adjacencies[1] + 1].VtN
+   
+   -- centro del tunnel
+   local frTunnel = Frame3d( Proc.Face[1].PtCenter, vtTunnelDirection)
+   local b3Tunnel = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, frTunnel)
+   local ptTunnelCenter = b3Tunnel:getCenter()
+   ptTunnelCenter:toGlob( frTunnel)
+
+   -- recupero gruppo per geometria addizionale
+   local nAddGrpId = BL.GetAddGroup( Proc.PartId)
+   if not nAddGrpId then
+      EgtOutLog( 'Error : missing AddGroup')
+      return TunnelAddedFaces
+   end
+
+   -- faccia centrale, si crea larga come la parte e poi si trimma
+   TunnelAddedFaces.MiddleFaceTm = {}
+   TunnelAddedFaces.MiddleFaceTm.Id = EgtSurfTmPlaneInBBox( nAddGrpId, ptTunnelCenter, vtTunnelDirection, b3Part, GDB_ID.ROOT)
+   -- TODO se non si riesce a costruire la faccia bisogna dare errore o semplicemente non ritornarla??
+   for i = 1, Proc.Fct do
+      EgtCutSurfTmPlane( TunnelAddedFaces.MiddleFaceTm.Id, Proc.Face[i].PtCenter, -Proc.Face[i].VtN, false, GDB_ID.ROOT)
+   end
+
+   local _, dFaceWidth, dFaceHeight = BL.GetFaceHvRefDim( TunnelAddedFaces.MiddleFaceTm.Id, 0)
+   -- larghezza OCS faccia
+   TunnelAddedFaces.MiddleFaceTm.Width = dFaceWidth
+   -- altezza OCS faccia
+   TunnelAddedFaces.MiddleFaceTm.Height = dFaceHeight
+   if TunnelAddedFaces.MiddleFaceTm.Height > TunnelAddedFaces.MiddleFaceTm.Width then
+      TunnelAddedFaces.MiddleFaceTm.Height, TunnelAddedFaces.MiddleFaceTm.Width = TunnelAddedFaces.MiddleFaceTm.Width, TunnelAddedFaces.MiddleFaceTm.Height
+   end
+
+   return TunnelAddedFaces
+end
+
+
 function SawPlusChain.GetBottomFace( Proc)
+   local BottomFace = {}
+   if Proc.Topology == 'Tunnel' then
+      return nil
+   end
+
    -- la faccia di fondo ha sempre Fct - 1 adiacenze. Se si trovano più facce di fondo si sceglie quella con minor elevazione
    local vBottomFace = Topology.GetFacesWithGivenAdjacencyNumber( Proc, Proc.vAdj, Proc.Fct - 1)
    local nBottomFace
@@ -4652,7 +4711,6 @@ function SawPlusChain.GetBottomFace( Proc)
       nBottomFace = vBottomFace[1]
    end
 
-   local BottomFace = {}
    BottomFace.Id = nBottomFace
    BottomFace.Width = Proc.Face[nBottomFace + 1].Width
    BottomFace.Height = Proc.Face[nBottomFace + 1].Height
@@ -4666,62 +4724,87 @@ function SawPlusChain.GetBottomFace( Proc)
 end
 
 
-function SawPlusChain.GetFaceToMachine( Proc)
-   if not Proc.Pocket.BottomFace or not Proc.Pocket.BottomFace.Id then
-      Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc)
+function SawPlusChain.GetLongFace( Proc)
+   if not Proc.MainFaces.BottomFace or not Proc.MainFaces.BottomFace.Id then
+      Proc.MainFaces.BottomFace = SawPlusChain.GetBottomFace( Proc)
    end
 
-   -- facce adiacenti a quella di fondo, ordinate
-   local FacesAdjacentToBottom = BL.GetAdjacentFaces( Proc, Proc.Pocket.BottomFace.Id)
-   table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnMainFace > b.LengthOnMainFace end)
+   local FacesToAnalyze = {}
+   -- tutte le facce, ordinate per dimensione
+   if Proc.Topology == 'Tunnel' then
+      for i = 1, Proc.Fct do
+         FacesToAnalyze[i] = {}
+         FacesToAnalyze[i].Id = Proc.Face[i].Id
+         FacesToAnalyze[i].Area = Proc.Face[i].Area
+         FacesToAnalyze[i].LengthOnMainFace = Proc.Face[i].LengthOnMainFace
+      end
+      table.sort( FacesToAnalyze, function( a, b) return a.Area > b.Area end)
+   -- facce adiacenti a quella di fondo, ordinate per lunghezza sul lato di fondo
+   else
+      FacesToAnalyze = BL.GetAdjacentFaces( Proc, Proc.MainFaces.BottomFace.Id)
+      table.sort( FacesToAnalyze, function( a, b) return a.LengthOnMainFace > b.LengthOnMainFace end)
+   end
 
-   -- si sceglie la faccia adiacente sul lato più lungo
-   local FaceToMachine = {}
-   FaceToMachine.Id = FacesAdjacentToBottom[1].Id
+   -- si sceglie la più grande (tunnel) o quella adiacente sul lato lungo
+   local LongFace = {}
+   LongFace.Id = FacesToAnalyze[1].Id
    for i = 1, Proc.Fct do
-      if FaceToMachine.Id == Proc.Face[i].Id then
-         FaceToMachine.Width = Proc.Face[i].Width
-         FaceToMachine.Height = Proc.Face[i].Height
-         FaceToMachine.Elevation = Proc.Face[i].Elevation
-         FaceToMachine.VtN = Proc.Face[i].VtN
-         if FaceToMachine.Height > FaceToMachine.Width then
-            FaceToMachine.Height, FaceToMachine.Width = FaceToMachine.Width, FaceToMachine.Height
+      if LongFace.Id == Proc.Face[i].Id then
+         LongFace.Width = Proc.Face[i].Width
+         LongFace.Height = Proc.Face[i].Height
+         LongFace.Elevation = Proc.Face[i].Elevation
+         LongFace.VtN = Proc.Face[i].VtN
+         if LongFace.Height > LongFace.Width then
+            LongFace.Height, LongFace.Width = LongFace.Width, LongFace.Height
          end
       end
    end
 
-   return FaceToMachine
+   LongFace.Edges = SawPlusChain.GetLongFaceEdges( Proc, LongFace)
+
+   return LongFace
 end
 
 
 function SawPlusChain.GetSideFaces( Proc)
-   if not Proc.Pocket.BottomFace or not Proc.Pocket.BottomFace.Id then
-      Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc)
+   if not Proc.MainFaces.BottomFace or not Proc.MainFaces.BottomFace.Id then
+      Proc.MainFaces.BottomFace = SawPlusChain.GetBottomFace( Proc)
    end
-   if not Proc.Pocket.FaceToMachine or not Proc.Pocket.FaceToMachine.Id then
-      Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc)
+   if not Proc.MainFaces.LongFace or not Proc.MainFaces.LongFace.Id then
+      Proc.MainFaces.LongFace = SawPlusChain.GetLongFace( Proc)
    end
 
-   -- facce adiacenti a quella di fondo, ordinate
-   local FacesAdjacentToBottom = BL.GetAdjacentFaces( Proc, Proc.Pocket.BottomFace.Id)
-   table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnMainFace > b.LengthOnMainFace end)
-
+   local FacesToAnalyze = {}
+   -- tutte le facce, ordinate per dimensione
+   if Proc.Topology == 'Tunnel' then
+      for i = 1, Proc.Fct do
+         FacesToAnalyze[i] = {}
+         FacesToAnalyze[i].Id = Proc.Face[i].Id
+         FacesToAnalyze[i].Area = Proc.Face[i].Area
+         FacesToAnalyze[i].LengthOnMainFace = Proc.Face[i].LengthOnMainFace
+      end
+      table.sort( FacesToAnalyze, function( a, b) return a.Area > b.Area end)
+   -- facce adiacenti a quella di fondo, ordinate per lunghezza sul lato di fondo
+   else
+      FacesToAnalyze = BL.GetAdjacentFaces( Proc, Proc.MainFaces.BottomFace.Id)
+      table.sort( FacesToAnalyze, function( a, b) return a.LengthOnMainFace > b.LengthOnMainFace end)
+   end
    -- si determina il criterio di scelta delle facce laterali
-   local FacesAdjacentToFaceToMachine = BL.GetAdjacentFaces( Proc, Proc.Pocket.FaceToMachine.Id)
-   local bIsFaceToMachineTheLargest = not ( Proc.Fct == 4 and #FacesAdjacentToFaceToMachine == 3)
+   local FacesAdjacentToLongFace = BL.GetAdjacentFaces( Proc, Proc.MainFaces.LongFace.Id)
+   local bIsLongFaceTheLargest = not ( Proc.Fct == 4 and #FacesAdjacentToLongFace == 3)
 
    local SideFaces = {}
-   for i = 1, #FacesAdjacentToBottom do
-      if ( not bIsFaceToMachineTheLargest and i < #FacesAdjacentToBottom) or
-         ( bIsFaceToMachineTheLargest and i > 2) then
-         table.insert( SideFaces, FacesAdjacentToBottom[i])
-         SideFaces[ #SideFaces].Id = FacesAdjacentToBottom[i].Id
-         SideFaces[ #SideFaces].Width = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Width
-         SideFaces[ #SideFaces].Height = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Height
-         SideFaces[ #SideFaces].Elevation = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Elevation
-         SideFaces[ #SideFaces].VtN = Proc.Face[FacesAdjacentToBottom[i].Id + 1].VtN
-         if SideFaces[ #SideFaces].Height > SideFaces[ #SideFaces].Width then
-            SideFaces[ #SideFaces].Height, SideFaces[ #SideFaces].Width = SideFaces[ #SideFaces].Width, SideFaces[ #SideFaces].Height
+   for i = 1, #FacesToAnalyze do
+      if ( not bIsLongFaceTheLargest and i < #FacesToAnalyze) or
+         ( bIsLongFaceTheLargest and i > 2) then
+         table.insert( SideFaces, FacesToAnalyze[i])
+         SideFaces[#SideFaces].Id = FacesToAnalyze[i].Id
+         SideFaces[#SideFaces].Width = Proc.Face[FacesToAnalyze[i].Id + 1].Width
+         SideFaces[#SideFaces].Height = Proc.Face[FacesToAnalyze[i].Id + 1].Height
+         SideFaces[#SideFaces].Elevation = Proc.Face[FacesToAnalyze[i].Id + 1].Elevation
+         SideFaces[#SideFaces].VtN = Proc.Face[FacesToAnalyze[i].Id + 1].VtN
+         if SideFaces[#SideFaces].Height > SideFaces[#SideFaces].Width then
+            SideFaces[#SideFaces].Height, SideFaces[#SideFaces].Width = SideFaces[ #SideFaces].Width, SideFaces[ #SideFaces].Height
          end
       end
    end
@@ -4730,6 +4813,58 @@ function SawPlusChain.GetSideFaces( Proc)
 end
 
 
+function SawPlusChain.GetLongFaceEdges( Proc, Face)
+   local Edges = {}
+   Edges.SideEdges = {}
+   Edges.OppositeEdges = {}
+
+   local nFaceType, vEdges = EgtSurfTmGetFacetOutlineInfo( Proc.Id, Face.Id, GDB_ID.ROOT)
+   if nFaceType < 1 then
+      for j = 1, #vEdges do
+         local nPreviousEdgeIndex = j - 1
+         if j == 1 then
+            nPreviousEdgeIndex = #vEdges
+         end
+         local nNextEdgeIndex = j + 1
+         if j == #vEdges then
+            nNextEdgeIndex = 1
+         end
+
+         local CurrentEdge = {}
+         CurrentEdge.AdjacentFaceId = vEdges[j].Adj
+         CurrentEdge.ToolDirection = Vector3d( vEdges[j].Norm)
+         CurrentEdge.Length = vEdges[j].Len
+         CurrentEdge.Elevation = vEdges[j].Elev
+         CurrentEdge.IsOpen = vEdges[j].Open
+         CurrentEdge.IsStartOpen = ( vEdges[nPreviousEdgeIndex].Open)
+         CurrentEdge.IsEndOpen = ( vEdges[nNextEdgeIndex].Open)
+
+         if Proc.Topology == 'Tunnel' then
+            if CurrentEdge.AdjacentFaceId > -1 then
+               table.insert( Edges.SideEdges, CurrentEdge)
+            else
+               table.insert( Edges.OppositeEdges, CurrentEdge)
+            end
+         else
+            if CurrentEdge.AdjacentFaceId == Proc.MainFaces.BottomFace.Id then
+               Edges.BottomEdge = CurrentEdge
+            elseif vEdges[nNextEdgeIndex].Adj == Proc.MainFaces.BottomFace.Id then
+               Edges.SideEdges.StartEdge = CurrentEdge
+            elseif vEdges[nPreviousEdgeIndex].Adj == Proc.MainFaces.BottomFace.Id then
+               Edges.SideEdges.EndEdge = CurrentEdge
+            else
+               table.insert( Edges.OppositeEdges, CurrentEdge)
+            end
+         end
+      end
+   else
+      error( 'Face with closed hole')
+   end
+
+   return Edges
+end
+
+
 function SawPlusChain.GetToolFromMachining( sMachiningName)
    local Tool = {}
    if EgtMdbSetCurrMachining( sMachiningName) then
@@ -4762,44 +4897,10 @@ function SawPlusChain.GetToolFromMachining( sMachiningName)
 end
 
 
-function SawPlusChain.GetVerticalSteps( Proc, Machining)
-   if not Proc.Pocket or not Proc.Pocket.Height then
-      error( 'Missing pocket depth')
-   elseif not Machining.Tool or not Machining.Tool.Thickness then
-      error( 'Missing tool thickness')
-   end
-   local VerticalSteps = {}
-   VerticalSteps.StepLength = 0
-   VerticalSteps.Count = ceil( ( Proc.Pocket.Height - 10 * GEO.EPS_SMALL) / Machining.Tool.Thickness)
-   if VerticalSteps.Count > 1 then
-      VerticalSteps.StepLength = ( Proc.Pocket.Height - Machining.Tool.Thickness) / ( VerticalSteps.Count - 1)
-   end
-
-   return VerticalSteps
-end
-
-
-function SawPlusChain.GetHorizontalSteps( Machining)
-   if not Machining.Depth then
-      error( 'Missing machining depth')
-   end
-   local HorizontalSteps = {}
-   HorizontalSteps.StepLength = 0
-   HorizontalSteps.Count = ceil( ( Machining.Depth - 10 * GEO.EPS_SMALL) / Machining.Tool.SideStep)
-   if HorizontalSteps.Count > 1 then
-      HorizontalSteps.StepLength = ( Machining.Depth - Machining.Tool.SideStep) / ( HorizontalSteps.Count - 1)
-   end
-
-   return HorizontalSteps
-end
-
-
-function SawPlusChain.CalculateLeadInOut( Proc, Machining)
+function SawPlusChain.CalculateLeadInOut( Machining, EdgeToMachine)
    -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
 
-   -- si determina se l'inizio o la fine della lavorazione sono chiusi e l'eventuale riduzione da applicare
-   local bIsStartClosed = false
-   local bIsEndClosed = false
+   -- si determina l'eventuale riduzione da applicare in caso di inizio o fine chiusi
    local bIsMortising = ( Machining.Type == MCH_OY.MORTISING)
    local dAddLengthToReduce = 0
    if bIsMortising then
@@ -4807,27 +4908,9 @@ function SawPlusChain.CalculateLeadInOut( Proc, Machining)
    else
       dAddLengthToReduce = sqrt( Machining.Depth * Machining.Tool.Diameter - Machining.Depth * Machining.Depth)
    end
-   if #( Proc.Pocket.SideFaces) == 2 then
-      bIsStartClosed = true
-      bIsEndClosed = true
-   elseif #( Proc.Pocket.SideFaces) == 1 then
-      local CCWDirection = ( Machining.FaceToMachine.VtN ^ Proc.Pocket.BottomFace.VtN)
-      if Machining.ToolInvert or bIsMortising then
-         CCWDirection = - CCWDirection
-      end
-      if CCWDirection * Proc.Pocket.SideFaces[1].VtN > 10 * GEO.EPS_SMALL then
-         if Machining.Tool.IsCCW then
-            bIsStartClosed = true
-         else
-            bIsEndClosed = true
-         end
-      else
-         if Machining.Tool.IsCCW then
-            bIsEndClosed = true
-         else
-            bIsStartClosed = true
-         end
-      end
+
+   if Machining.Invert then
+      Machining.IsStartClosed, Machining.IsEndClosed = Machining.IsEndClosed, Machining.IsStartClosed
    end
 
    local LeadIn = {}
@@ -4839,34 +4922,39 @@ function SawPlusChain.CalculateLeadInOut( Proc, Machining)
       LeadOut.Type = MCH_MILL_LI.LINEAR
       LeadIn.TangentDistance = 0
       LeadOut.TangentDistance = 0
-      LeadIn.PerpDistance = Proc.Pocket.Depth + BD.CUT_SIC
-      LeadOut.PerpDistance = Proc.Pocket.Depth + BD.CUT_SIC
+      if EdgeToMachine.Elevation > -10 * GEO.EPS_SMALL then
+         LeadIn.PerpDistance = EdgeToMachine.Elevation + BD.CUT_SIC
+         LeadOut.PerpDistance = EdgeToMachine.Elevation + BD.CUT_SIC
+      else
+         LeadIn.PerpDistance = BD.CUT_SIC
+         LeadOut.PerpDistance = BD.CUT_SIC
+      end
       LeadIn.Elevation = 0
       LeadOut.Elevation = 0
       LeadIn.CompLength = 0
       LeadOut.CompLength = 0
-      if bIsStartClosed and bIsEndClosed then
+      if Machining.IsStartClosed and Machining.IsEndClosed then
          LeadIn.StartAddLength = -dAddLengthToReduce
          LeadOut.EndAddLength = -dAddLengthToReduce
-      elseif bIsStartClosed then
+      elseif Machining.IsStartClosed then
          LeadIn.StartAddLength = -dAddLengthToReduce
          -- eventuale correzione per accorciamento maggiore di larghezza tasca
-         LeadOut.EndAddLength = max( -LeadIn.StartAddLength - Proc.Pocket.Width + 10 * BD.CUT_EXTRA, BD.CUT_EXTRA)
-      elseif bIsEndClosed then
+         LeadOut.EndAddLength = max( -LeadIn.StartAddLength - EdgeToMachine.Length + 10 * BD.CUT_EXTRA, BD.CUT_EXTRA)
+      elseif Machining.IsEndClosed then
          LeadOut.EndAddLength = -dAddLengthToReduce
          -- eventuale correzione per accorciamento maggiore di larghezza tasca
-         LeadIn.StartAddLength = max( -LeadOut.EndAddLength - Proc.Pocket.Width + 10 * BD.CUT_EXTRA, BD.CUT_EXTRA)
+         LeadIn.StartAddLength = max( -LeadOut.EndAddLength - EdgeToMachine.Length + 10 * BD.CUT_EXTRA, BD.CUT_EXTRA)
       else
          LeadIn.StartAddLength = BD.CUT_EXTRA
          LeadOut.EndAddLength = BD.CUT_EXTRA
       end
    else
-      if bIsStartClosed then
+      if Machining.IsStartClosed then
          LeadIn.StartAddLength = -dAddLengthToReduce
       else
          LeadIn.StartAddLength = BD.CUT_EXTRA
       end
-      if bIsEndClosed then
+      if Machining.IsEndClosed then
          LeadOut.EndAddLength = -dAddLengthToReduce
       else
          LeadOut.EndAddLength = BD.CUT_EXTRA
@@ -4888,7 +4976,7 @@ function SawPlusChain.ApplyMachining( Machining, b3Raw)
 
    -- impostazione parametri lavorazione
    local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
-   EgtSetMachiningGeometry( {{ Machining.ProcId, Machining.FaceToMachine.Id}})
+   EgtSetMachiningGeometry( Machining.Geometry)
    EgtSetMachiningParam( MCH_MP.FACEUSE, Machining.Faceuse)
    EgtSetMachiningParam( MCH_MP.SCC, Machining.SCC)
    EgtSetMachiningParam( MCH_MP.INVERT, Machining.Invert)
@@ -4918,9 +5006,9 @@ function SawPlusChain.ApplyMachining( Machining, b3Raw)
          EgtSetMachiningParam( MCH_MP.STEP, Machining.Steps.StepLength)
       end
    end
-   EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut))
+   EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.BlockedAxis.VtN, Machining.BlockedAxis.VtOut))
    if Machining.Type == MCH_OY.MORTISING then
-      EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.FaceToMachine.VtN, Machining.Direction, Machining.SuggestedAngles.Index))
+      EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.SuggestedAngles.VtN, Machining.SuggestedAngles.VtOrtho, Machining.SuggestedAngles.Index))
    end
    EgtSetMachiningParam( MCH_MP.OVERL, Machining.Overlap)
    EgtSetMachiningParam( MCH_MP.STARTPOS, max( Machining.StartSafetyLength, EgtGetMachiningParam( MCH_MP.STARTPOS)))
@@ -4941,13 +5029,13 @@ function SawPlusChain.ApplyMachining( Machining, b3Raw)
          else
             Machining.BlockedAxis.Orientation  = 'perpendicular'
          end
-         EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut))
+         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.FaceToMachine.VtN, Machining.Direction, Machining.SuggestedAngles.Index))
+         EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.SuggestedAngles.VtN, Machining.SuggestedAngles.VtOrtho, Machining.SuggestedAngles.Index))
          sErr = ''
          bIsApplyOk = ML.ApplyMachining( true, false)
       end
@@ -4983,36 +5071,42 @@ function SawPlusChain.Saw.GetSCC( vtMachiningDirection)
 end
 
 
-function SawPlusChain.Saw.CalculateMachiningParameters( Proc)
+function SawPlusChain.Saw.CalculateMachiningParameters( Proc, FaceToMachine, EdgeToMachine)
    local Cutting = {}
    Cutting.CanApply = true
    Cutting.Message = ''
    Cutting.ProcId = Proc.Id
 
+   local dPocketHeight = 0
+   if Proc.Topology == 'Tunnel' then
+      dPocketHeight = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Height
+   else
+      dPocketHeight = Proc.MainFaces.BottomFace.Height
+   end
+
    -- ricerca lavorazione
    Cutting.Name = ML.FindCutting( 'HeadSide', true, false)
    if not Cutting.Name then
-      Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found'
+      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)
-   Cutting.FaceToMachine = Proc.Pocket.FaceToMachine
 
    -- verifica dimensioni tasca compatibili
    -- se tasca meno spessa della lama la strategia non è applicabile
-   if Cutting.Tool.Thickness > Proc.Pocket.Height + 10 * GEO.EPS_SMALL then
-      Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness'
+   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.Pocket.SideFaces) > 1 then
+   if #( Proc.MainFaces.SideFaces) > 1 then
       -- se tasca più stretta della lama la strategia non è applicabile
-      if Cutting.Tool.Diameter > Proc.Pocket.Width + 10 * GEO.EPS_SMALL then
-         Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter'
+      if Cutting.Tool.Diameter > EdgeToMachine.Length + 10 * GEO.EPS_SMALL then
+         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
@@ -5020,8 +5114,9 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc)
    end
 
    -- parametri della lavorazione
-   -- direzione utensile
-   Cutting.Direction = Proc.Pocket.Direction
+   -- inizio e fine aperti o chiusi
+      Cutting.IsStartClosed = not EdgeToMachine.IsStartOpen
+      Cutting.IsEndClosed = not EdgeToMachine.IsEndOpen
    -- lato di lavoro e inversioni
    if Cutting.Tool.IsCCW then
       Cutting.Workside = MCH_MILL_WS.RIGHT
@@ -5030,31 +5125,43 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc)
       Cutting.Workside = MCH_MILL_WS.LEFT
       Cutting.Invert = false
    end
+   if EdgeToMachine.Elevation < -10 * GEO.EPS_SMALL then
+      Cutting.Invert = not Cutting.Invert
+   end
    -- TODO gestire lama da sotto e lama downUp
-   if Cutting.FaceToMachine.VtN:getZ() < - 10 * GEO.EPS_SMALL then
+   if FaceToMachine.VtN:getZ() < - 10 * GEO.EPS_SMALL then
       Cutting.ToolInvert = true
       Cutting.Invert = not Cutting.Invert
    else
       Cutting.ToolInvert = false
    end
    -- profondità e offset radiale
-   if Cutting.Tool.MaxDepth > Proc.Pocket.Depth - 10 * GEO.EPS_SMALL then
-      Cutting.Depth = Proc.Pocket.Depth
-      Cutting.RadialOffset = 0
+   if Cutting.Tool.MaxDepth > abs( EdgeToMachine.Elevation) - 10 * GEO.EPS_SMALL then
+      -- TODO la depth dovrebbe essere quella del machining
+      Cutting.Depth = abs( EdgeToMachine.Elevation)
+      if EdgeToMachine.Elevation > -10 * GEO.EPS_SMALL then
+         Cutting.RadialOffset = 0
+      else
+         Cutting.RadialOffset = EdgeToMachine.Elevation
+      end
    else
-      Cutting.Depth = Cutting.Tool.MaxDepth
-      Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth
-      if Proc.Pocket.ApplyOnlySawblade then
-         Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : sawblade elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Cutting.Depth, 1) .. ')'
+      Cutting.Depth = Cutting.Tool.MaxDepth - 1
+      if EdgeToMachine.Elevation > -10 * GEO.EPS_SMALL then
+         Cutting.RadialOffset = EdgeToMachine.Elevation - Cutting.Depth
+      else
+         Cutting.RadialOffset = -Cutting.Depth
+      end
+      if EdgeToMachine.Elevation > -10 * GEO.EPS_SMALL and SawPlusChain.ApplyOnlySawblade then
+         Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : sawblade elevation (' .. EgtNumToString( EdgeToMachine.Elevation, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Cutting.Depth, 1) .. ')'
          EgtOutLog( Cutting.Message)
       end
    end
    -- step verticale e offset longitudinale
-   Cutting.Steps = SawPlusChain.GetVerticalSteps( Proc, Cutting)
+   Cutting.Steps = BL.GetMachiningSteps( dPocketHeight, Cutting.Tool.Thickness)
    Cutting.Steps.StepType = MCH_MILL_ST.ONEWAY
    Cutting.MaxElev = Cutting.Steps.StepLength * Cutting.Steps.Count - 10 * GEO.EPS_SMALL
    if Cutting.ToolInvert and Cutting.Steps.Count > 1 then
-      Cutting.LongitudinalOffset = - Proc.Pocket.Height
+      Cutting.LongitudinalOffset = - dPocketHeight
    else
       Cutting.LongitudinalOffset = 0
    end
@@ -5063,31 +5170,36 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc)
    -- overlap
    Cutting.Overlap = 0
    -- faceuse
-   Cutting.Faceuse = BL.GetNearestOrthoOpposite( Cutting.Direction)
+   if EdgeToMachine.Elevation > - 10 * GEO.EPS_SMALL then
+      Cutting.Faceuse = BL.GetNearestOrthoOpposite( EdgeToMachine.ToolDirection)
+   else
+      Cutting.Faceuse = BL.GetNearestOrthoOpposite( -EdgeToMachine.ToolDirection)
+   end
    -- SCC
-   Cutting.SCC = SawPlusChain.Saw.GetSCC( Cutting.Direction)
-   -- angoli suggeriti
-   Cutting.SuggestedAngles = ''
+   Cutting.SCC = SawPlusChain.Saw.GetSCC( EdgeToMachine.ToolDirection)
    -- asse bloccato
    Cutting.BlockedAxis = {}
    Cutting.BlockedAxis.Orientation = 'perpendicular'
-   Cutting.BlockedAxis.VtOut = EgtIf( Cutting.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX())
+   Cutting.BlockedAxis.VtN = FaceToMachine.VtN
+   Cutting.BlockedAxis.VtOut = EgtIf( FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX())
    -- approccio e retrazione
-   Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.CalculateLeadInOut( Proc, Cutting)
+   Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.CalculateLeadInOut( Cutting, EdgeToMachine)
    -- eventuale step orizzontale
    Cutting.HorizontalSteps = {}
    if Cutting.Tool.SideStep then
-      Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Cutting)
+      Cutting.HorizontalSteps = BL.GetMachiningSteps( Cutting.Depth, Cutting.Tool.SideStep)
    else
       Cutting.HorizontalSteps.Count = 1
       Cutting.HorizontalSteps.StepLength = 0
    end
+   -- geometria
+   Cutting.Geometry = {{Proc.Id, FaceToMachine.Id}}
    -- nome operazione
-   Cutting.OperationName = 'Cut_' .. ( EgtGetName( Cutting.ProcId) or tostring( Cutting.ProcId)) .. '_' .. tostring( Cutting.FaceToMachine.Id + 1)
+   Cutting.OperationName = 'Cut_' .. ( EgtGetName( Cutting.ProcId) or tostring( Cutting.ProcId)) .. '_' .. tostring( FaceToMachine.Id + 1)
 
    -- eventuale avviso di danneggiamento pezzo successivo
    local dOffsideLength = max( Cutting.LeadIn.StartAddLength, Cutting.LeadOut.EndAddLength) + Cutting.Tool.Diameter / 2 + 10 * GEO.EPS_SMALL
-   if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then
+   if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.DistanceToNextPart < dOffsideLength) then
       local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : sawblade can damage next piece.'
       if #Cutting.Message > 0 then
          Cutting.Message = Cutting.Message .. '\n' .. sDamageNextPieceMessage
@@ -5101,120 +5213,208 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc)
 end
 
 
-function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc)
-   local Chainsawing = {}
-   Chainsawing.CanApply = true
-   Chainsawing.Message = ''
-   Chainsawing.ProcId = Proc.Id
+function SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
+   local bIsCuttingOk = false
+   local sCuttingApplyMessage = ''
+
+   local dOriginalRadialOffset = Cutting.RadialOffset
+   local dOriginalLeadInPerpDistance = Cutting.LeadIn.PerpDistance
+   local dOriginalLeadOutPerpDistance = Cutting.LeadOut.PerpDistance
+   for i = Cutting.HorizontalSteps.Count, 1, -1 do
+      Cutting.RadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.StepLength * ( i - 1)
+      -- update distanza perpendicolare attacco per contemplare l'offset applicato
+      Cutting.LeadIn.PerpDistance = dOriginalLeadInPerpDistance - Cutting.RadialOffset
+      Cutting.LeadOut.PerpDistance = dOriginalLeadOutPerpDistance - Cutting.RadialOffset
+      -- applicazione lavorazione
+      bIsCuttingOk, sCuttingApplyMessage = SawPlusChain.ApplyMachining( Cutting, b3Raw)
+      -- update messaggi
+      if sCuttingApplyMessage and #sCuttingApplyMessage > 0 then
+         sCuttingApplyMessage = sCuttingApplyMessage .. 'Apply : ' .. sCuttingApplyMessage .. '\n'
+      end
+   end
+
+   return bIsCuttingOk, sCuttingApplyMessage
+end
+
+
+function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc, FaceToMachine, EdgeToMachine)
+   local Mortising = {}
+   Mortising.CanApply = true
+   Mortising.Message = ''
+   Mortising.ProcId = Proc.Id
+   local dTestCornerRadius = 43
+   local sMortisingType
+   
+   local dPocketHeight = 0
+   if Proc.Topology == 'Tunnel' then
+      dPocketHeight = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Height
+   else
+      dPocketHeight = Proc.MainFaces.BottomFace.Height
+   end
 
    -- ricerca lavorazione
-   Chainsawing.Name = ML.FindSawing( 'Sawing', Proc.Pocket.Depth)
-   if not Chainsawing.Name then
-      Chainsawing.Name = ML.FindSawing( 'Sawing', nil, nil, 'Longest')
+   if Proc.Topology == 'Tunnel' then
+      Mortising.Name = ML.FindSawing( 'Sawing', abs( EdgeToMachine.Elevation) + dTestCornerRadius + BD.CUT_EXTRA_MIN)
+      sMortisingType = "OneSideAndExtend"
+      if not Mortising.Name then
+         Mortising.Name = ML.FindSawing( 'Sawing', abs( EdgeToMachine.Elevation) / 2 + dTestCornerRadius + BD.CUT_EXTRA_MIN)
+         sMortisingType = "BothSidesAndExtend"
+      end
+   else
+      Mortising.Name = ML.FindSawing( 'Sawing', abs( EdgeToMachine.Elevation))
+      sMortisingType = "OneSide"
    end
-   if not Chainsawing.Name then
-      Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found'
-      Chainsawing.CanApply = false
-      EgtOutLog( Chainsawing.Message)
-      return Chainsawing
+   if not Mortising.Name then
+      Mortising.Name = ML.FindSawing( 'Sawing', nil, nil, 'Longest')
+      if Proc.Topology == 'Tunnel' then
+         sMortisingType = "BothSides"
+      end
    end
-   Chainsawing.Type = MCH_OY.MORTISING
-   Chainsawing.Tool = SawPlusChain.GetToolFromMachining( Chainsawing.Name)
-   Chainsawing.FaceToMachine = Proc.Pocket.FaceToMachine
+   if not Mortising.Name then
+      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)
 
    -- verifica dimensioni tasca compatibili
    -- se tasca meno spessa della sega a catena la strategia non è applicabile
-   if Chainsawing.Tool.Thickness > Proc.Pocket.Height + 10 * GEO.EPS_SMALL then
-      Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness'
-      Chainsawing.CanApply = false
-      EgtOutLog( Chainsawing.Message)
-      return Chainsawing
+   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.Pocket.SideFaces) > 1 then
+   if #( Proc.MainFaces.SideFaces) > 1 then
       -- se tasca più stretta della sega a catena la strategia non è applicabile
-      if Chainsawing.Tool.Width > Proc.Pocket.Width + 10 * GEO.EPS_SMALL then
-         Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width'
-         Chainsawing.CanApply = false
-         EgtOutLog( Chainsawing.Message)
-         return Chainsawing
+      if Mortising.Tool.Width > EdgeToMachine.Length + 10 * GEO.EPS_SMALL then
+         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
 
    -- parametri della lavorazione
-   -- direzione utensile
-   Chainsawing.Direction = Proc.Pocket.Direction
+   -- inizio e fine aperti o chiusi
+   Mortising.IsStartClosed = not EdgeToMachine.IsStartOpen
+   Mortising.IsEndClosed = not EdgeToMachine.IsEndOpen
    -- lato di lavoro e inversioni
-   if Chainsawing.Tool.IsCCW then
-      Chainsawing.Workside = MCH_MILL_WS.RIGHT
-      Chainsawing.Invert = false
+   Mortising.Invert = false
+   if EdgeToMachine.Elevation > -10 * GEO.EPS_SMALL then
+      Mortising.Workside = MCH_MILL_WS.RIGHT
+      Mortising.ToolInvert = false
    else
-      Chainsawing.Workside = MCH_MILL_WS.LEFT
-      Chainsawing.Invert = true
+      Mortising.Workside = MCH_MILL_WS.LEFT
+      Mortising.ToolInvert = true
    end
-   Chainsawing.ToolInvert = false
    -- profondità e offset longitudinale
-   if Chainsawing.Tool.MaxMat > Proc.Pocket.Depth - 10 * GEO.EPS_SMALL then
-      Chainsawing.Depth = Proc.Pocket.Depth
-      Chainsawing.LongitudinalOffset = 0
+   if sMortisingType == "OneSide" then
+      Mortising.Depth = abs( EdgeToMachine.Elevation)
+   elseif sMortisingType == 'OneSideAndExtend' then
+      Mortising.Depth = abs( EdgeToMachine.Elevation) + Mortising.Tool.CornerRadius + BD.CUT_EXTRA_MIN
+   elseif sMortisingType == 'BothSides' then
+      Mortising.Depth = abs( EdgeToMachine.Elevation) / 2
+   elseif sMortisingType == 'BothSidesAndExtend' then
+      Mortising.Depth = abs( EdgeToMachine.Elevation) / 2 + Mortising.Tool.CornerRadius + BD.CUT_EXTRA_MIN
+   end
+   if Mortising.Tool.MaxMat > Mortising.Depth - 10 * GEO.EPS_SMALL then
+      if EdgeToMachine.Elevation > -10 * GEO.EPS_SMALL then
+         Mortising.LongitudinalOffset = 0
+      else
+         Mortising.LongitudinalOffset = abs( EdgeToMachine.Elevation) - Mortising.Depth
+      end
    else
-      Chainsawing.Depth = Chainsawing.Tool.MaxMat
-      Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth
-      Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : chainsaw elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Chainsawing.Depth, 1) .. ')'
-      EgtOutLog( Chainsawing.Message)
+      Mortising.Depth = Mortising.Tool.MaxMat - 1
+      if EdgeToMachine.Elevation > -10 * GEO.EPS_SMALL then
+         Mortising.LongitudinalOffset = EdgeToMachine.Elevation - Mortising.Depth
+      else
+         Mortising.LongitudinalOffset = 0
+      end
+      Mortising.Message = 'Feature '.. Proc.FeatureId .. ' : chainsaw elevation (' .. EgtNumToString( EdgeToMachine.Elevation, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Mortising.Depth, 1) .. ')'
+      EgtOutLog( Mortising.Message)
    end
    -- offset radiale
-   Chainsawing.RadialOffset = 0
+   Mortising.RadialOffset = 0
    -- distanza di sicurezza
-   Chainsawing.StartSafetyLength = Proc.Pocket.Depth
+   Mortising.StartSafetyLength = EdgeToMachine.Elevation
    -- overlap
-   Chainsawing.Overlap = 0
+   Mortising.Overlap = 0
    -- faceuse
-   Chainsawing.Faceuse = BL.GetNearestParalOpposite( Chainsawing.Direction)
+   if EdgeToMachine.Elevation > - 10 * GEO.EPS_SMALL then
+      Mortising.Faceuse = BL.GetNearestParalOpposite( EdgeToMachine.ToolDirection)
+   else
+      Mortising.Faceuse = BL.GetNearestParalOpposite( -EdgeToMachine.ToolDirection)
+   end
    -- SCC
-   Chainsawing.SCC = MCH_SCC.NONE
+   Mortising.SCC = MCH_SCC.NONE
    -- asse bloccato e angoli suggeriti
-   Chainsawing.BlockedAxis = {}
-   Chainsawing.BlockedAxis.Orientation = 'perpendicular'
-   Chainsawing.SuggestedAngles = {}
-   Chainsawing.SuggestedAngles.Index = 1
+   Mortising.BlockedAxis = {}
+   Mortising.BlockedAxis.Orientation = 'perpendicular'
+   Mortising.BlockedAxis.VtN = FaceToMachine.VtN
+   Mortising.SuggestedAngles = {}
+   Mortising.SuggestedAngles.Index = 1
+   Mortising.SuggestedAngles.VtN = FaceToMachine.VtN
+   Mortising.SuggestedAngles.VtOrthO = EdgeToMachine.ToolDirection
    -- approccio e retrazione
-   Chainsawing.LeadIn, Chainsawing.LeadOut = SawPlusChain.CalculateLeadInOut( Proc, Chainsawing)
+   Mortising.LeadIn, Mortising.LeadOut = SawPlusChain.CalculateLeadInOut( Mortising, EdgeToMachine)
    -- eventuale step verticale
-   Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing)
+   Mortising.VerticalSteps = BL.GetMachiningSteps( dPocketHeight, Mortising.Tool.Thickness)
+   -- geometria
+   Mortising.Geometry = {{Proc.Id, FaceToMachine.Id}}
    -- nome operazione
-   Chainsawing.OperationName = 'Chainsaw_' .. ( EgtGetName( Chainsawing.ProcId) or tostring( Chainsawing.ProcId)) .. '_' .. tostring( Chainsawing.FaceToMachine.Id + 1)
+   Mortising.OperationName = 'Chainsaw_' .. ( EgtGetName( Mortising.ProcId) or tostring( Mortising.ProcId)) .. '_' .. tostring( FaceToMachine.Id + 1)
 
    -- eventuale avviso di danneggiamento pezzo successivo
-   local dOffsideLength = max( Chainsawing.LeadIn.StartAddLength, Chainsawing.LeadOut.EndAddLength) + Chainsawing.Tool.Width / 2 + 10 * GEO.EPS_SMALL
-   if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then
+   local dOffsideLength = max( Mortising.LeadIn.StartAddLength, Mortising.LeadOut.EndAddLength) + Mortising.Tool.Width / 2 + 10 * GEO.EPS_SMALL
+   if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.DistanceToNextPart < dOffsideLength) then
       local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : chainsaw can damage next piece.'
-      if #Chainsawing.Message > 0 then
-         Chainsawing.Message = Chainsawing.Message .. '\n' .. sDamageNextPieceMessage
+      if #Mortising.Message > 0 then
+         Mortising.Message = Mortising.Message .. '\n' .. sDamageNextPieceMessage
       else
-         Chainsawing.Message = sDamageNextPieceMessage
+         Mortising.Message = sDamageNextPieceMessage
       end
       EgtOutLog( sDamageNextPieceMessage)
    end
 
-   return Chainsawing
+   return Mortising
 end
 
 
-function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw)
-   Proc.Pocket = {}
-   Proc.Pocket.ApplyOnlySawblade = bOnlySaw
-   Proc.Pocket.Strategy = 'SawPlusChain'
+function SawPlusChain.Chainsaw.ApplyAllSteps( Mortising, b3Raw)
+   local bIsMortisingOk = false
+   local sMortisingApplyMessage = ''
+
+   local dOriginalRadialOffsetMortising = Mortising.RadialOffset
+   for i = Mortising.VerticalSteps.Count, 1, -1 do
+      Mortising.RadialOffset = dOriginalRadialOffsetMortising + Mortising.VerticalSteps.StepLength * ( i - 1)
+      -- applicazione lavorazione
+      bIsMortisingOk, sMortisingApplyMessage = SawPlusChain.ApplyMachining( Mortising, b3Raw)
+      -- update messaggi
+      if sMortisingApplyMessage and #sMortisingApplyMessage > 0 then
+         Mortising.Message = Mortising.Message .. '\n' .. 'Apply : ' .. sMortisingApplyMessage
+      end
+   end
+
+   return bIsMortisingOk, sMortisingApplyMessage
+end
+
+
+function SawPlusChain.Make( bOnlySaw, Proc, nRawId)
+   SawPlusChain.ApplyOnlySawblade = bOnlySaw
    local b3Raw = EgtGetRawPartBBox( nRawId)
 
    -- TODO per implementare la strategia con lapjoint lunghe bisogna prima riconoscere le topologie che arrivano
    if Proc.IsSplittedLapJoint then
-      local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for long lapjoint'
+      local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. SawPlusChain.Name .. ' not implemented for long lapjoint'
       EgtOutLog( sErr)
       return false, sErr
    end
 
    if not SawPlusChain.IsTopologyOk( Proc) then
-      local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented'
+      local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. SawPlusChain.Name .. ' not implemented'
       EgtOutLog( sErr)
       return false, sErr
    end
@@ -5222,81 +5422,141 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw)
    -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto)
    -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto
    if Proc.AffectedFaces.Bottom and ( Proc.Fct > 3 or not Proc.AffectedFaces.Top)  then
-      local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face'
+      local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. SawPlusChain.Name .. ' not applicable - pocket on bottom face'
       EgtOutLog( sErr)
       return false, sErr
    end
 
-   -- caratteristiche della tasca
-   Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc)
-   Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc)
-   Proc.Pocket.SideFaces = SawPlusChain.GetSideFaces( Proc)
-   Proc.Pocket.Width = Proc.Pocket.BottomFace.Width
-   Proc.Pocket.Height = Proc.Pocket.BottomFace.Height
-   Proc.Pocket.Depth = Proc.Pocket.BottomFace.Elevation
-   Proc.Pocket.Direction = Proc.Pocket.BottomFace.VtN
-   Proc.Pocket.DistanceToNextPart = BL.GetDistanceToNextPart( nRawId, nPhase)
+   -- facce principali
+   Proc.MainFaces = {}
+   Proc.MainFaces.BottomFace = SawPlusChain.GetBottomFace( Proc)
+   Proc.MainFaces.LongFace = SawPlusChain.GetLongFace( Proc)
+   Proc.MainFaces.SideFaces = SawPlusChain.GetSideFaces( Proc)
+   if Proc.Topology == 'Tunnel' then
+      Proc.MainFaces.TunnelAddedFaces = SawPlusChain.GetTunnelFaces( Proc)
+   end
 
-   -- parametri lavorazione di lama
-   local Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc)
-
-   -- applicazione lavorazione di lama con eventuali step XY
+   -- lama
+   -- lavorazione di lama - fondo della tasca o fino a massimo materiale se tunnel
+   local Cutting = {}
+   if Proc.Topology == 'Tunnel' then
+      Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.OppositeEdges[1])
+   else
+      Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.BottomEdge)
+   end
    local bIsCuttingOk = false
-   local sCuttingApplyMessage = ''
    if Cutting.CanApply then
-      local dOriginalRadialOffset = Cutting.RadialOffset
-      local dOriginalLeadInPerpDistance = Cutting.LeadIn.PerpDistance
-      local dOriginalLeadOutPerpDistance = Cutting.LeadOut.PerpDistance
-      for i = Cutting.HorizontalSteps.Count, 1, -1 do
-         Cutting.RadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.StepLength * ( i - 1)
-         -- update distanza perpendicolare attacco per contemplare l'offset applicato
-         Cutting.LeadIn.PerpDistance = dOriginalLeadInPerpDistance - Cutting.RadialOffset
-         Cutting.LeadOut.PerpDistance = dOriginalLeadOutPerpDistance - Cutting.RadialOffset
-         -- applicazione lavorazione
-         bIsCuttingOk, sCuttingApplyMessage = SawPlusChain.ApplyMachining( Cutting, b3Raw)
-         -- update messaggi
-         if sCuttingApplyMessage and #sCuttingApplyMessage > 0 then
-            Cutting.Message = Cutting.Message .. 'Apply : ' .. sCuttingApplyMessage .. '\n'
+      bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
+   end
+   if not bIsCuttingOk then
+      return bIsCuttingOk, Cutting.Message
+   end
+   local dBottomDepthToMachine = Cutting.RadialOffset
+
+   -- lato opposto del tunnel
+   if Proc.Topology == 'Tunnel' then
+      Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.OppositeEdges[2])
+      bIsCuttingOk = false
+      if Cutting.CanApply then
+         bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
+      end
+      if not bIsCuttingOk then
+         return bIsCuttingOk, Cutting.Message
+      end
+   else
+      -- se la lama non è arrivata sul fondo e c'è almeno un lato aperto va lavorato
+      if Cutting.RadialOffset > 10 * GEO.EPS_SMALL then
+         -- eventuale lavorazione di lama - lato della tasca da cui inizia la lavorazione
+         if Proc.MainFaces.LongFace.Edges.BottomEdge.IsStartOpen then
+            Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.SideEdges.StartEdge)
+            bIsCuttingOk = false
+            if Cutting.CanApply then
+               bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
+            end
+            if not bIsCuttingOk then
+               return bIsCuttingOk, Cutting.Message
+            end
          end
+         -- eventuale lavorazione di lama - lato della tasca in cui finisce la lavorazione
+         if Proc.MainFaces.LongFace.Edges.BottomEdge.IsEndOpen then
+            Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.SideEdges.EndEdge)
+            bIsCuttingOk = false
+            if Cutting.CanApply then
+               bIsCuttingOk, Cutting.Message = SawPlusChain.Saw.ApplyAllSteps( Cutting, b3Raw)
+            end
+            if not bIsCuttingOk then
+               return bIsCuttingOk, Cutting.Message
+            end
+         end
+      -- la lama è arrivata sul fondo e tasca passante, non servono ulteriori lavorazioni
+      elseif #( Proc.MainFaces.SideFaces) == 0 then
+         SawPlusChain.ApplyOnlySawblade = true
       end
    end
 
-   -- se tasca passante e la lama è arrivata sul fondo, non servono ulteriori lavorazioni
-   if #Proc.Pocket.SideFaces == 0 and Cutting.RadialOffset == 0 then
-      bOnlySaw = true
-   end
-   
-   if bOnlySaw or not bIsCuttingOk then
+   if SawPlusChain.ApplyOnlySawblade then
       return bIsCuttingOk, Cutting.Message
    end
 
-   -- parametri lavorazione con sega a catena
-   local Chainsawing = SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc)
-   -- si lavora solo quanto non lavorato dalla lama
-   Chainsawing.MaxElev = Cutting.RadialOffset + BD.CUT_EXTRA
+   -- sega a catena
+   -- parametri lavorazione con sega a catena - fondo della tasca o tunnel
+   local Mortising = {}
+   if Proc.Topology == 'Tunnel' then
+      Mortising = SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.OppositeEdges[1])
+   else
+      Mortising = SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.BottomEdge)
+      -- si lavora solo quanto non lavorato dalla lama
+      Mortising.MaxElev = dBottomDepthToMachine + BD.CUT_EXTRA
+   end
+   local bIsMortisingOk = false
+   if Mortising.CanApply then
+      bIsMortisingOk, Mortising.Message = SawPlusChain.Chainsaw.ApplyAllSteps( Mortising, b3Raw)
+   end
 
-   -- applicazione lavorazione con sega a catena con eventuali step in Z
-   local bIsChainsawingOk = false
-   local sChainsawingApplyMessage = ''
-   if Chainsawing.CanApply then
-      local dOriginalRadialOffsetChainsawing = Chainsawing.RadialOffset
-      for i = Chainsawing.VerticalSteps.Count, 1, -1 do
-         Chainsawing.RadialOffset = dOriginalRadialOffsetChainsawing + Chainsawing.VerticalSteps.StepLength * ( i - 1)
-         -- applicazione lavorazione
-         bIsChainsawingOk, sChainsawingApplyMessage = SawPlusChain.ApplyMachining( Chainsawing, b3Raw)
-         -- update messaggi
-         if sChainsawingApplyMessage and #sChainsawingApplyMessage > 0 then
-            Chainsawing.Message = Chainsawing.Message .. '\n' .. 'Apply : ' .. sChainsawingApplyMessage
+   -- lato opposto del tunnel
+   if Proc.Topology == 'Tunnel' then
+      Mortising = SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.OppositeEdges[2])
+      bIsMortisingOk = false
+      if Mortising.CanApply then
+         bIsMortisingOk, Mortising.Message = SawPlusChain.Chainsaw.ApplyAllSteps( Mortising, b3Raw)
+      end
+      if not bIsMortisingOk then
+         return bIsMortisingOk, Mortising.Message
+      end
+   else
+      -- se la sega a catena non è arrivata sul fondo e c'è almeno un lato aperto va lavorato
+      if Mortising.LongitudinalOffset > 10 * GEO.EPS_SMALL then
+         -- eventuale lavorazione di sega a catena - lato della tasca da cui inizia la lavorazione
+         if Proc.MainFaces.LongFace.Edges.BottomEdge.IsStartOpen then
+            Mortising = SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.SideEdges.StartEdge)
+            bIsMortisingOk = false
+            if Mortising.CanApply then
+               bIsMortisingOk, Mortising.Message = SawPlusChain.Chainsaw.ApplyAllSteps( Mortising, b3Raw)
+            end
+            if not bIsMortisingOk then
+               return bIsMortisingOk, Mortising.Message
+            end
+         end
+         -- eventuale lavorazione di sega a catena - lato della tasca in cui finisce la lavorazione
+         if Proc.MainFaces.LongFace.Edges.BottomEdge.IsEndOpen then
+            Mortising = SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFace, Proc.MainFaces.LongFace.Edges.SideEdges.EndEdge)
+            bIsMortisingOk = false
+            if Mortising.CanApply then
+               bIsMortisingOk, Mortising.Message = SawPlusChain.Chainsaw.ApplyAllSteps( Mortising, b3Raw)
+            end
+            if not bIsMortisingOk then
+               return bIsMortisingOk, Mortising.Message
+            end
          end
       end
    end
 
    local sFinalMessage = ''
-   if #Cutting.Message > 0 or #Chainsawing.Message > 0 then
-      sFinalMessage = Cutting.Message .. '\n' .. Chainsawing.Message
+   if #Cutting.Message > 0 or #Mortising.Message > 0 then
+      sFinalMessage = Cutting.Message .. '\n' .. Mortising.Message
    end
    
-   return bIsChainsawingOk, sFinalMessage
+   return bIsMortisingOk, sFinalMessage
 end
 
 --#endregion SawPlusChain
@@ -5325,11 +5585,11 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
    end
 
    -- strategia lama + eventuale sega a catena
-   if ( EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') or 0) > 0 then                       --TEST
+   if ( EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') or 0) > 0 then
       local bOk
       local sErr
       local bOnlySaw = EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') == 1
-      bOk, sErr = SawPlusChain.Make ( Proc, nRawId, nPhase, bOnlySaw)
+      bOk, sErr = SawPlusChain.Make ( bOnlySaw, Proc, nRawId)
       return bOk, sErr
    end
 
diff --git a/LuaLibs/ProcessMortise.lua b/LuaLibs/ProcessMortise.lua
index fecdfe7..db80299 100644
--- a/LuaLibs/ProcessMortise.lua
+++ b/LuaLibs/ProcessMortise.lua
@@ -128,7 +128,7 @@ end
       local nFaceUse = BL.GetNearestParalOpposite( vtN)
       EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
       -- applico il parametro plunge, che setta la lavorazione per affondare solamente, senza lavorare tutto il contorno; 1: solo lato iniziale, 2: solo lato finale, 3: entrambi
-      sNotes = 'Plunge=3;'
+      local sNotes = 'Plunge=3;'
       EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
       -- imposto angolo 3° asse rot
       local vtOrtho = BL.GetVersRef( nFaceUse)
diff --git a/UpdateLog.txt b/UpdateLog.txt
index 74354e2..b488a6d 100644
--- a/UpdateLog.txt
+++ b/UpdateLog.txt
@@ -1,9 +1,13 @@
            ==== Beam Update Log ====
 
+Versione 2.6e3 (14/05/2024)
+- Modif : in SawPlusChain aggiunta gestione lavorazioni aggiuntive lati aperti e tunnel
+- Fixed : in Cut -> MakeFromTop ricalcolo direzione di lavorazione su facce a cubetti.
+
 Versione 2.6e2 (10/05/2024)
-- Fixed : correzioni a FeatureTopology
-- Modif : in LongCut allungamento percorso ingresso per evitare collisioni durante approccio pezzo quando si setta OutRaw
-- Modif : in LongCut se non trova fresa per pulizia dà messaggio di warning anziché di errore
+- Modif : in FeatureTopology aggiunta proprietà IsTrough = true anche a Cut
+- Modif : LongCut : se non trova fresa per pulizia, da messaggio di warning anziché di errore
+- Fixed : LongCut : allungamento percorso ingresso per evitare collisioni durante approccio pezzo quando si setta OutRaw.
 
 Versione 2.6e1 (03/05/2024)
 - Modif : in LapJoint Groove verso il basso lavorata di preferenza dal lato
diff --git a/Version.lua b/Version.lua
index 60b085b..3dd5ccb 100644
--- a/Version.lua
+++ b/Version.lua
@@ -2,5 +2,5 @@
 -- Gestione della versione di Beam
 
 NAME = 'Beam'
-VERSION = '2.6e2'
-MIN_EXE = '2.6a1'
+VERSION = '2.6e3'
+MIN_EXE = '2.6e2'