Merge branch 'develop' into STR0001_TenonDT

- SLOTBYBLADE rinominata FACEBYBLADE; vecchia FACEBYBLADE eliminata
- SLOTBYCHAINSAW rinominata FACEBYCHAINSAW - in SPLITCUT modifiche alle chiamate di FACEBYBLADE per contemplare la nuova funzione - in STR0005 - codolo l'utensile non viene passato ma viene lasciato scegliere alla FACEBYBLADE
2025-02-25 16:12:12 +01:00 · 2025-01-28 10:54:16 +01:00 · 2025-01-27 18:03:47 +01:00 · 2025-01-27 15:57:12 +01:00 · 2025-01-27 11:55:36 +01:00 · 2025-01-07 12:52:28 +01:00
13 changed files with 630 additions and 520 deletions
@@ -216,6 +216,7 @@ local function GetStrategies_Egalware( Proc)
   ---------------------------------------------------------------------
   -- Feature : Dovetail Tenon
   elseif ID.IsDovetailTenon( Proc) then
+      Strategies =  { { sStrategyId = 'STR0001'}}
   ---------------------------------------------------------------------
   -- Feature : Dovetail Mortise
   elseif ID.IsDovetailMortise( Proc) then
@@ -474,6 +475,7 @@ local function GetStrategies_Essetre( Proc)
   ---------------------------------------------------------------------
   -- Feature : Dovetail Tenon
   elseif ID.IsDovetailTenon( Proc) then
+      Strategies =  { { sStrategyId = 'STR0001'}}
   ---------------------------------------------------------------------
   -- Feature : Dovetail Mortise
   elseif ID.IsDovetailMortise( Proc) then
@@ -140,7 +140,7 @@ function BeamExec.GetToolsFromDB()
               Tool.dStemDiameter = EgtTdbGetCurrToolParam( MCH_TP.STEMDIAM) or Tool.ToolHolder.dDiameter -- se non settato, considero diametro come ToolHolder
               Tool.dSideAngle = EgtTdbGetCurrToolParam( MCH_TP.SIDEANG) or 0
               -- verifico che parametri siano compatibili con una fresa a coda di rondine ( angolo di fianco standard Coda di rondine -> 15°) 
-               Tool.bIsDoveTail = Tool.Type == 'MILL_NOTIP' and  abs( abs( Tool.dSideAngle) - SIDEANGLE_DOVETAIL) < 1
+               Tool.bIsDoveTail = Tool.sType == 'MILL_NOTIP' and  abs( abs( Tool.dSideAngle) - SIDEANGLE_DOVETAIL) < 1
               -- verifico che sia una fresa tipo T-Mill o BlockHaus
               Tool.dSideDepth = EgtGetValInNotes( Tool.sUserNotes, 'SIDEDEPTH', 'd') or 0                   -- se non settato nell'utensile, dico che non ha massimo affondamento laterale
               Tool.bIsTMill = Tool.dSideDepth > 0
@@ -209,6 +209,19 @@ function FeatureLib.ClassifyTopology( Proc, Part)
   return FeatureTopology
 end

+-------------------------------------------------------------------------------------------------------------
+function FeatureLib.GetAdditionalInfo( Proc, Part)
+   -- se foro calcolo altri dati
+   if ID.IsDrilling( Proc) then
+      -- assegno diametro e facce di ingresso e uscita (dati tabelle sempre per riferimento)
+      Proc.dDiam, Proc.dLen, Proc.nFcs, Proc.nFce = FeatureLib.GetDrillingData( Proc)
+   elseif ID.IsDovetailTenon( Proc) then
+      Proc.dDTLength, Proc.dDTMaxDist, Proc.vtDTNormal, Proc.ptDTCenter, Proc.idAddAuxGeom = FeatureLib.GetDoveTailTenonData( Proc)
+   end
+
+   return Proc
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- Recupero dati foro e adattamento se speciale
 function FeatureLib.GetDrillingData( Proc)
@@ -230,6 +243,60 @@ function FeatureLib.GetDrillingData( Proc)
   return dDiam, dLen, nFcs, nFce
 end

+-------------------------------------------------------------------------------------------------------------
+-- Recupero dati tenone a coda di rondine
+function FeatureLib.GetDoveTailTenonData( Proc)
+   -- recupero e verifico l'entità curva
+   local idAux = EgtGetInfo( Proc.id, 'AUXID', 'i')
+   if idAux then idAux = idAux + Proc.id end
+   -- recupero i dati della curva
+   local vtExtr = EgtCurveExtrusion( idAux, GDB_RT.GLOB)
+   local ptBC = EgtGP( idAux, GDB_RT.GLOB)
+   -- determino altezza del tenone
+   local frDtTen = Frame3d( ptBC, vtExtr)
+   local b3DtTen = EgtGetBBoxRef( Proc.id, GDB_BB.STANDARD, frDtTen)
+   local dDtTenH = b3DtTen:getDimZ()
+   -- assegno centro e normale della faccia top
+   local vtN = vtExtr
+   local ptC = ptBC + vtN * dDtTenH
+   -- calcolo distanza massima della curva dal punto più lontano della base tenone Dt (facet 0)
+   local dMaxDist
+   for i = 0, Proc.nFct - 1 do
+      local ptFC, vtFN = EgtSurfTmFacetCenter( Proc.id, i, GDB_ID.ROOT)
+      if not AreSameVectorApprox( vtFN, vtN) or abs( ( ptFC - ptBC) * vtN) > 100 * GEO.EPS_SMALL then
+         break
+      end
+      local nLoopId, nLoopCnt = EgtExtractSurfTmFacetLoops( Proc.id, i, EgtGetParent( Proc.id))
+      if nLoopId then
+         local dUmin, dUmax = EgtCurveDomain( nLoopId)
+         for dU = dUmin, dUmax do
+            local ptP = EgtUP( nLoopId, dU, GDB_ID.ROOT)
+            local ptNear = EgtNP( idAux, ptP, GDB_ID.ROOT)
+            local dDist = dist( ptP, ptNear)
+            if not dMaxDist or dDist > dMaxDist then
+               dMaxDist = dDist
+            end
+         end
+         for j = 1, nLoopCnt do
+            EgtErase( nLoopId + j - 1)
+         end
+      end
+   end
+   if not dMaxDist then
+      local b3DtAux = EgtGetBBoxRef( idAux, GDB_BB.STANDARD, frDtTen)
+      dMaxDist = 2 * ( b3DtTen:getRadius() - b3DtAux:getRadius())
+   end
+
+   Proc.dDTLength = dDtTenH
+   Proc.dDTMaxDist = dMaxDist
+   Proc.vtDTNormal = vtExtr
+   Proc.ptDTCenter = ptC
+   Proc.idAddAuxGeom = idAux
+
+   return Proc.dDTLength, Proc.dDTMaxDist, Proc.vtDTNormal, Proc.ptDTCenter, Proc.idAddAuxGeom
+
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- funzione che restituisce indice di completamento in base alla percentuale di volume lavorato
 function FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
@@ -214,7 +214,7 @@ function MachiningLib.FindMill( Proc, ToolSearchParameters)
      elseif TOOLS[i].bIsProfiledTool then
         bIsToolCompatible = false
      -- controlli standard
-      elseif TOOLS[i].dDiameter > ToolSearchParameters.dMaxToolDiameter then
+      elseif ToolSearchParameters.dMaxToolDiameter and TOOLS[i].dDiameter > ToolSearchParameters.dMaxToolDiameter then
         bIsToolCompatible = false
      elseif TOOLS[i].SetupInfo.bIsTopHead  and  ToolSearchParameters.vtToolDirection:getZ() < TOOLS[i].SetupInfo.dMaxNegativeAngle then
         bIsToolCompatible = false
@@ -228,7 +228,7 @@ function MachiningLib.FindMill( Proc, ToolSearchParameters)
         bIsToolCompatible = false
      elseif ToolSearchParameters.sMillShape == 'PEN' and  not TOOLS[i].bIsPen then
         bIsToolCompatible = false
-      elseif TOOLS[i].sType ~= ToolSearchParameters.sType then
+      elseif ToolSearchParameters.sType and TOOLS[i].sType ~= ToolSearchParameters.sType then
         -- se sto cercando una fresa che non può lavorare di testa, quelle che lavorano di testa sono comunque ammesse
         if TOOLS[i].sType == 'MILL_STD' and  ToolSearchParameters.sType == 'MILL_NOTIP' then
            bIsToolCompatible = true
@@ -252,7 +252,7 @@ function MachiningLib.FindMill( Proc, ToolSearchParameters)
         if ToolEntryAngle.dValue > 0 and ToolEntryAngle.dValue < 90  then
            dCurrentMaxMatReduction = dCurrentMaxMatReduction / ToolEntryAngle.dSin + ( ( dDimObjToCheck - TOOLS[i].dDiameter) / 2) / ToolEntryAngle.dTan
         end
-         -- dCurrMachReduction = negativo -> limitare, positivo -> mm extra disponibili
+         -- dCurrentResidualDepth = negativo -> mm extra disponibili, positivo -> limitare
         local dCurrentResidualDepth = ToolSearchParameters.dElevation + dCurrentMaxMatReduction - TOOLS[i].dMaxDepth

         -- se non ancora trovato, oppure se completo e il migliore fino ad ora non è completo: corrente è il migliore
@@ -296,6 +296,7 @@ end
 -------------------------------------------------------------------------------------------------------------
 -- funzione per cercare utensile tipo LAMA con certe caratteristiche
 -- TODO da completare
+-- TODO il FindBlade dovrà restituire di utilizzare sempre la lama sopra se l'angolo lo permette, ma avendo un'altezza massima (da macchina) oltre cui il DownUp non sarà fattibile (evita collisioni tra asse e pezzo)
 function MachiningLib.FindBlade( Proc, ToolSearchParameters)
   local ToolInfo = {}

@@ -251,7 +251,7 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
   local Splitting = {}
   local AuxiliaryData = {}

-   Strategy.sSplitStrategy = GetSplitStrategy( Proc, Part)
+   Strategy.SplitStrategy = GetSplitStrategy( Proc, Part)
   if bAddMachining then
      -- inserimento smussi su spigoli del taglio
      if Strategy.Parameters.bMakeChamfer then
@@ -261,34 +261,26 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
      local OptionalParameters = {}
      -- applico le lavorazioni
   ----------------------------------------------------------------------------------
-      if Strategy.sSplitStrategy.sTypeMachining == 'BladeSideSingle' then
+      if Strategy.SplitStrategy.sTypeMachining == 'BladeSideSingle' then
         OptionalParameters = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_BACK
-         OptionalParameters.sDepth = 0
+         OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex

         -- TODO gestire lavorazione a cubetti

         local EdgeToMachine = GetEdgeToMachine( Proc, -Y_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
         Splitting.sStage = 'Head'
         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeSideDouble' then
-         OptionalParameters = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
+      elseif Strategy.SplitStrategy.sTypeMachining == 'BladeSideDouble' then
         -- Taglio lato frontale
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_BACK
-         OptionalParameters.sDepth = 0
-         OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
+         OptionalParameters = {}
+         OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+         OptionalParameters.dDepthToMachine = Part.dWidth / 2 + BeamData.CUT_EXTRA_MIN

         -- TODO gestire lavorazione a cubetti

         local EdgeToMachine = GetEdgeToMachine( Proc, -Y_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
         Splitting.sStage = 'Head'
         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
@@ -297,50 +289,38 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
         OptionalParameters = {}
         Splitting = {}
         AuxiliaryData = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_FRONT
-         OptionalParameters.sDepth = 0
-         OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
+         OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+         OptionalParameters.dDepthToMachine = Part.dWidth / 2 + BeamData.CUT_EXTRA_MIN

         -- TODO gestire lavorazione a cubetti

         EdgeToMachine = GetEdgeToMachine( Proc, Y_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
         Splitting.sStage = 'Head'
         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeHorizontalSingle' then
+      elseif Strategy.SplitStrategy.sTypeMachining == 'BladeHorizontalSingle' then
         OptionalParameters = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
-         OptionalParameters.sDepth = 0
-         OptionalParameters.dRadialOffset = -BeamData.CUT_EXTRA
+         OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+         OptionalParameters.dDepthToMachine = Part.dHeight + BeamData.CUT_EXTRA

         -- TODO gestire lavorazione a cubetti

         local EdgeToMachine = GetEdgeToMachine( Proc, Z_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
         Splitting.sStage = 'Head'
         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeHorizontalDouble' then
-         OptionalParameters = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
+      elseif Strategy.SplitStrategy.sTypeMachining == 'BladeHorizontalDouble' then
         -- Taglio lato frontale
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
-         OptionalParameters.sDepth = 0
-         local dExtraMaxMat = ( Strategy.sSplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + Strategy.sSplitStrategy[2].ToolInfo.dMaxMatBladeFromDown - Part.dHeight - BeamData.CUT_EXTRA) / 2
-         OptionalParameters.dRadialOffset = Part.dHeight - Strategy.sSplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + dExtraMaxMat
+         OptionalParameters = {}
+         OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+         local dExtraMaxMat = ( Strategy.SplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + Strategy.SplitStrategy[2].ToolInfo.dMaxMatBladeFromDown - Part.dHeight - BeamData.CUT_EXTRA_MIN) / 2
+         OptionalParameters.dDepthToMachine = Strategy.SplitStrategy[1].ToolInfo.dMaxMatBladeFromTop - dExtraMaxMat

         -- TODO gestire lavorazione a cubetti

         local EdgeToMachine = GetEdgeToMachine( Proc, Z_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
         Splitting.sStage = 'Head'
         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
@@ -349,33 +329,29 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
         OptionalParameters = {}
         Splitting = {}
         AuxiliaryData = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[2].ToolInfo.nToolIndex
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_TOP
-         OptionalParameters.sDepth = 0
-         OptionalParameters.dRadialOffset = Part.dHeight - Strategy.sSplitStrategy[2].ToolInfo.dMaxMatBladeFromDown + dExtraMaxMat
+         OptionalParameters.nToolIndex = Strategy.SplitStrategy[2].ToolInfo.nToolIndex
+         OptionalParameters.dDepthToMachine = Strategy.SplitStrategy[2].ToolInfo.dMaxMatBladeFromDown - dExtraMaxMat

         -- TODO gestire lavorazione a cubetti

         EdgeToMachine = GetEdgeToMachine( Proc, -Z_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
         Splitting.sStage = 'Head'
         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawHorizontal' then
+      elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawHorizontal' then
         ; -- TODO
   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawSideSingle' then
+      elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawSideSingle' then
         ; -- TODO
   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawSideDouble' then
+      elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawSideDouble' then
         ; -- TODO
   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawPlusBlade' then
+      elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawPlusBlade' then
         ; -- TODO
   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'Mill' then
+      elseif Strategy.SplitStrategy.sTypeMachining == 'Mill' then
         ; -- TODO
   ----------------------------------------------------------------------------------
      end
@@ -5,18 +5,210 @@

 -- carico librerie
 local BeamLib = require( 'BeamLib')
+local BeamData = require( 'BeamData')
+local MachiningLib = require( 'MachiningLib')
+local FeatureLib = require( 'FeatureLib')
+-- strategie di base
+local FaceByBlade = require('FACEBYBLADE')

 -- Tabella per definizione modulo
 local STR0001 = {}
+local Strategy = {}
+

 -------------------------------------------------------------------------------------------------------------
-function STR0001.Make( AddMachining, Proc, Part, CustomParameters)
-    -- carico parametri de default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
-    local StrategyLib = {}
-    StrategyLib.Config = require( 'STR0001\\STR0001Config')
-    CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
-    StrategyParameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
+function STR0001.Make( bAddMachining, Proc, Part, CustomParameters)
+   -- carico parametri de default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
+   local StrategyLib = {}
+   StrategyLib.Config = require( 'STR0001\\STR0001Config')
+   Strategy.sName = StrategyLib.Config.sStrategyId
+   CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
+   Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
+   Strategy.Machining = {}
+   Strategy.Result = {}

+
+   local bAreAllMachiningsAdded = true
+   local ToolSearchParameters = {}
+   local Milling = {}
+   local Cutting = {}
+   local Pocketing = {}
+
+   --  ===== RICERCA UTENSILE =====
+   --  === ricerca utensile per taglio del tenone in lunghezza ===
+   -- TODO fare funzione generale per trovare lama data una faccia?
+   Cutting.bIsApplicable = false
+   ToolSearchParameters.bAllowTopHead = true
+   ToolSearchParameters.bAllowBottomHead = false
+   ToolSearchParameters.vtToolDirection = Proc.vtDTNormal
+   Cutting.ToolInfo = {}
+   Cutting.ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
+   if Cutting.ToolInfo.nToolIndex then
+      Cutting.bIsApplicable = true
+      local ParametersMRR = {}
+      ParametersMRR.nToolIndex = Cutting.ToolInfo.nToolIndex
+      Cutting.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+   end
+
+   -- === ricerca utensile per lavorare tenone coda di rondine ===
+   Milling.bIsApplicable = false
+   ToolSearchParameters.dElevation = Proc.dDTLength
+   ToolSearchParameters.vtToolDirection = Proc.vtDTNormal
+   ToolSearchParameters.sMillShape = 'DOVETAIL'
+   Milling.ToolInfo = {}
+   Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
+   Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Mill')
+   if Milling.ToolInfo.nToolIndex then
+      Milling.bIsApplicable = true
+      local ParametersMRR = {}
+      ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
+      Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+   end
+
+   --  === ricerca utensile di svuotatura (se richiesto) ===
+   -- se bastano passate con sovramateriale
+   local nMillingPathsNeeded = ceil( Proc.dDTMaxDist / TOOLS[Milling.ToolInfo.nToolIndex].dSideStep)
+   if nMillingPathsNeeded <= Strategy.Parameters.nMaxMillingPaths then
+      Pocketing.bNotNeeded = true
+      Pocketing.dMRR = Milling.dMRR
+   -- serve svuotatura
+   else
+      Pocketing.ToolInfo = {}
+      -- se ammessa svuotatura con utensile DoveTail, copio i dati
+      if Strategy.Parameters.bUseDTToolOnPocketing then
+         Pocketing.ToolInfo = Milling.ToolInfo
+         Pocketing.dMRR = Milling.dMRR
+      -- altrimenti serve cercarne un altro
+      else
+         ToolSearchParameters = {}
+         ToolSearchParameters.dElevation = Proc.dDTLength
+         ToolSearchParameters.vtToolDirection = Proc.vtDTNormal
+         Pocketing.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
+      end
+      -- se trovato utensile di svuotatura
+      if Pocketing.ToolInfo.nToolIndex then
+         Pocketing.bIsApplicable = true
+      end
+   end
+
+   -- setto il risultato in base agli utensili trovati
+   -- lavorazione completa
+   if Milling.bIsApplicable and Cutting.bIsApplicable and ( Pocketing.bIsApplicable or Pocketing.bNotNeeded) then
+      Strategy.Result.sStatus = 'Completed'
+      Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
+      Strategy.Result.dMRR =  ( Milling.dMRR + Cutting.dMRR + Pocketing.dMRR) / 3
+      Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Mill,Blade,Mill')
+   -- lavorazione incompleta
+   elseif Cutting.bIsApplicable then
+      Strategy.Result.sStatus = 'Not-Completed'
+      Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 50)
+      Strategy.Result.dMRR =  ( Milling.dMRR + Cutting.dMRR + Pocketing.dMRR) / 3
+      Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Mill')
+      if not Milling.bIsApplicable then
+         Strategy.Result.sInfo = 'DoveTail-Mill not found'
+      else
+         Strategy.Result.sInfo = 'DoveTail tenon not completed'
+      end
+   -- strategia non applicabile, manca il taglio di lama sulla lunghezza del tenone
+   else
+      Strategy.Result.sStatus = 'Not-Applicable'
+      Strategy.Result.nCompletionIndex = 0
+      Strategy.Result.dMRR = 0
+      Strategy.Result.nQuality = 0
+      Strategy.Result.sInfo = 'Mill not found'
+   end
+
+   -- applicazione delle lavorazioni
+   if bAddMachining and Strategy.Result.sStatus ~= 'Not-Applicable' then
+      -- creo piano di taglio sulla testa del tenone
+      local nAddGrpId = BeamLib.GetAddGroup( Part.id)
+      local idTenonCutPlane = EgtSurfTmPlaneInBBox( nAddGrpId, Proc.ptDTCenter, Proc.vtDTNormal, Part.b3Part, GDB_RT.GLOB)
+      if idTenonCutPlane then
+         EgtSetName( idTenonCutPlane, 'AddCut_' .. tostring( Proc.id))
+         EgtSetInfo( idTenonCutPlane, 'TASKID', Proc.idTask)
+      end
+
+      -- taglio in lunghezza sul tenone
+      if Cutting.bIsApplicable then
+         OptionalParameters = {}
+         local AuxiliaryData = {}
+         OptionalParameters.nToolIndex = Cutting.ToolInfo.nToolIndex
+         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_BACK
+         OptionalParameters.sDepth = 0
+
+         -- TODO gestire lavorazione a cubetti
+
+         -- TODO
+         -- Su faccia appena creata NON sono stati calcolati gli edges.
+         -- La FaceByBlade si aspetta di lavorare 1 faccia di una trimesh. Fare altra funzione?
+
+         --local nFaceType, vEdges = EgtSurfTmGetFacetOutlineInfo( AddId, 0, GDB_ID.ROOT)
+         --local EdgeToMachine = GetEdgeToMachine( vEdges, -Y_AX())
+         -- approccio e retrazione
+         --OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Cutting, EdgeToMachine)
+         --Cutting = FaceByBlade.Make( Proc, Part, AddId, EdgeToMachine, OptionalParameters)
+         if Proc.AffectedFaces.bLeft then
+            Cutting.sStage = 'AfterTail'
+         end
+         MachiningLib.AddNewMachining( Proc, Cutting, AuxiliaryData)
+      end
+
+      -- svuotatura
+      if Pocketing.bIsApplicable then
+         -- azzero eventuale contatore passaggi con sovramateriale
+         nMillingPathsNeeded = 1
+      end
+
+      -- passaggio sul profilo
+      if Milling.bIsApplicable then
+         local AuxiliaryData = {}
+         -- aggiungo geometria
+         Milling.Geometry = {{ Proc.idAddAuxGeom, -1}}
+         Milling.nToolIndex = Milling.ToolInfo.nToolIndex
+         Milling.nType = MCH_MY.MILLING
+         Milling.vtToolDirection = Proc.vtDTNormal
+         Milling.sDepth = 0
+
+         -- LeadIn / LeadOut
+         Milling.LeadIn = {}
+         Milling.LeadOut = {}
+         Milling.LeadIn.nType = MCH_MILL_LI.LINEAR
+         Milling.LeadOut.nType = MCH_MILL_LI.LINEAR
+         Milling.LeadIn.dTangentDistance = TOOLS[Milling.ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
+         Milling.LeadIn.dPerpDistance = 0
+         Milling.LeadOut.dTangentDistance = TOOLS[Milling.ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
+         Milling.LeadOut.dPerpDistance = 0
+
+         if Proc.AffectedFaces.bLeft then
+            Milling.sStage = 'AfterTail'
+         end
+
+         -- sistemo il lato e la direzione di lavoro
+         Milling.bInvert = EgtIf( TOOLS[Milling.ToolInfo.nToolIndex].bIsCCW, false, true)
+         Milling.nWorkside = EgtIf( TOOLS[Milling.ToolInfo.nToolIndex].bIsCCW, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
+
+         Milling.sUserNotes = EgtSetVal( 'MaxElev', EgtNumToString( Proc.dDTLength, 1)) .. ';'
+
+         -- TODO calcolare SCC
+
+         -- passate con sovramateriale
+         AuxiliaryData.Clones = {}
+         for i = nMillingPathsNeeded, 1, -1 do
+            -- il primo è il passaggio più esterno
+            local nIndexClones = nMillingPathsNeeded - i + 1
+            -- suddivido step in base al numero passate da fare
+            local dRealSideStep = floor( Proc.dDTMaxDist / nMillingPathsNeeded)
+            -- cambia solo sovrmateriale radiale
+            AuxiliaryData.Clones[nIndexClones] = {}
+            AuxiliaryData.Clones[nIndexClones].dRadialOffset = ( i - 1) * dRealSideStep
+         end
+
+         -- aggiunge lavorazione
+         bAreAllMachiningsAdded = MachiningLib.AddNewMachining( Proc, Milling, AuxiliaryData)
+      end
+   end
+
+   return bAreAllMachiningsAdded, Strategy.Result
 end

 -------------------------------------------------------------------------------------------------------------
@@ -19,8 +19,8 @@ local BeamData = require( 'BeamData')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
-local SlotByBlade = require( 'SLOTBYBLADE')
-local SlotByChainSaw = require( 'SLOTBYCHAINSAW')
+local FaceByBlade = require( 'FACEBYBLADE')
+local FaceByChainsaw = require( 'FACEBYCHAINSAW')

 -- Tabella per definizione modulo
 local STR0003 = {}
@@ -210,8 +210,8 @@ function Blade.AddMachiningAllSteps( Proc, Cutting, AuxiliaryData)
      AuxiliaryData.Clones[i].LeadOut = {}
      AuxiliaryData.Clones[i].dRadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.dStep * ( Cutting.HorizontalSteps.nCount - i)
      -- update distanza perpendicolare attacco per contemplare l'offset applicato
-      AuxiliaryData.Clones[i].LeadIn.dPerpDistance = dOriginalLeadInPerpDistance - Cutting.dRadialOffset
-      AuxiliaryData.Clones[i].LeadOut.dPerpDistance = dOriginalLeadOutPerpDistance - Cutting.dRadialOffset
+      AuxiliaryData.Clones[i].LeadIn.dPerpDistance = dOriginalLeadInPerpDistance - AuxiliaryData.Clones[i].dRadialOffset + dOriginalRadialOffset
+      AuxiliaryData.Clones[i].LeadOut.dPerpDistance = dOriginalLeadOutPerpDistance - AuxiliaryData.Clones[i].dRadialOffset + dOriginalRadialOffset
   end
   bMachiningAdded = MachiningLib.AddNewMachining( Proc, Cutting, AuxiliaryData)

@@ -297,15 +297,15 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
   local OptionalParameters = { bForceLongcutBlade = Strategy.Parameters.bForceLongcutBlade, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
   if Proc.Topology.sFamily == 'Tunnel' then
      OptionalParameters.bOppositeToolDirection = true
-      Cutting = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+      Cutting = FaceByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
   else
-      Cutting = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
+      Cutting = FaceByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
   end
   Blade.AddResult( Cutting)
   -- lato opposto del tunnel
   if Proc.Topology.sFamily == 'Tunnel' then
      OptionalParameters.bOppositeToolDirection = true
-      Cutting = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
+      Cutting = FaceByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
      Blade.AddResult( Cutting)
   else
      -- se la lama non è arrivata sul fondo e c'è almeno un lato aperto va lavorato
@@ -313,13 +313,13 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
         -- eventuale lavorazione di lama - lato della tasca da cui inizia la lavorazione
         if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsStartOpen then
            OptionalParameters.bOppositeToolDirection = true
-            Cutting = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+            Cutting = FaceByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
            Blade.AddResult( Cutting)
         end
         -- eventuale lavorazione di lama - lato della tasca in cui finisce la lavorazione
         if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsEndOpen then
            OptionalParameters.bOppositeToolDirection = true
-            Cutting = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
+            Cutting = FaceByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
            Blade.AddResult( Cutting)
         end
      -- la lama è arrivata sul fondo e tasca passante, non servono ulteriori lavorazioni
@@ -383,18 +383,18 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)

         if not Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsStartOpen then
            local OptionalParameters = { sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Bottom[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
            Chainsaw.AddResult( Mortising)
         end
         if not Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsEndOpen then
            local OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result.Bottom[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
            Chainsaw.AddResult( Mortising)
         end
      -- si lavora tutto il fondo
      else
         local OptionalParameters = { dMaxElev = Blade.Result.Bottom[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
-         Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
+         Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
         Chainsaw.AddResult( Mortising)
      end
      -- ancora materiale residuo - se possibile si lavora dal lato
@@ -403,10 +403,10 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
         if ( #Blade.Result.Side > 0) and Blade.Result.Side[1].dResidualDepth < 10 * GEO.EPS_SMALL then
            if ( Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsStartOpen and Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength > 3 * Blade.Result.Side[1].dBladeMarkLength - 10 * GEO.EPS_SMALL) then
               local OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result.Side[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-               Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+               Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
            elseif ( Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsEndOpen and Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2].dLength > 3 * Blade.Result.Side[1].dBladeMarkLength - 10 * GEO.EPS_SMALL) then
               local OptionalParameters = { sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Side[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-               Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
+               Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
            end
         -- si lavora tutto il lato
         else
@@ -418,10 +418,10 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
            end
            if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsStartOpen then
               local OptionalParameters = { dMaxElev = dBladeResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-               Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+               Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
            elseif Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsEndOpen then
               local OptionalParameters = { dMaxElev = dBladeResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-               Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
+               Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
            end
         end
         Chainsaw.AddResult( Mortising)
@@ -430,7 +430,7 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
      if Blade.Result.Bottom[1].dResidualDepth > 10 * GEO.EPS_SMALL then
         -- si lavora tutto il fondo
         local OptionalParameters = { dMaxElev = Blade.Result.Bottom[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
-         Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
+         Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
         Chainsaw.AddResult( Mortising)
         -- ancora materiale residuo - si lavorano i lati
         if Chainsaw.Result.Bottom[1].dResidualDepth > 10 * GEO.EPS_SMALL then
@@ -439,16 +439,16 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
               ( Blade.Result.Side[2].dResidualDepth < 10 * GEO.EPS_SMALL and Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2].dLength > 3 * Blade.Result.Side[2].dBladeMarkLength - 10 * GEO.EPS_SMALL) then
               
               local OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result.Side[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-               Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+               Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
               Chainsaw.AddResult( Mortising)
               -- ancora materiale residuo - si lavora da entrambi i lati
               if Chainsaw.Result.Side[1].dResidualDepth > 10 * GEO.EPS_SMALL then
                  local OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'End', dLengthToMachine = Blade.Result.Side[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-                  Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+                  Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
                  Chainsaw.AddResult( Mortising)
                  OptionalParameters = {}
                  OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Side[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-                  Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
+                  Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
                  Chainsaw.AddResult( Mortising)
                  -- lavorando dai due lati non c'è materiale residuo - si può eliminare la lavorazione del fondo
                  if Chainsaw.Result.Side[2].dResidualDepth < 10 * GEO.EPS_SMALL then
@@ -458,17 +458,17 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
            -- si lavora tutto il lato
            else
               local OptionalParameters = { dMaxElev = Blade.Result.Side[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-               Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+               Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
               Chainsaw.AddResult( Mortising)
               -- ancora materiale residuo - si lavora da entrambi i lati
               if Chainsaw.Result.Side[1].dResidualDepth > 10 * GEO.EPS_SMALL then
                  Chainsaw.Result.Side[1].bIsApplicable = false
                  local OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Side[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-                  Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+                  Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
                  Chainsaw.AddResult( Mortising)
                  OptionalParameters = {}
                  OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Side[2].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-                  Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
+                  Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
                  Chainsaw.AddResult( Mortising)
                  -- lavorando dai due lati non c'è materiale residuo - si può disabilitare la lavorazione del fondo
                  if Chainsaw.Result.Side[2].dResidualDepth < 10 * GEO.EPS_SMALL then
@@ -484,43 +484,43 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
         ( Blade.Result.Opposite[2].dResidualDepth < 10 * GEO.EPS_SMALL and Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2].dLength > 3 * Blade.Result.Opposite[2].dBladeMarkLength - 10 * GEO.EPS_SMALL) then
         
         local OptionalParameters = { sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Opposite[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-         Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+         Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
         Chainsaw.AddResult( Mortising)
         OptionalParameters = {}
         OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result.Opposite[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-         Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+         Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
         Chainsaw.AddResult( Mortising)
         if Chainsaw.Result.Opposite[1].dResidualDepth > 10 * GEO.EPS_SMALL or Chainsaw.Result.Opposite[2].dResidualDepth > 10 * GEO.EPS_SMALL then
            Chainsaw.Result.Opposite[1].bIsApplicable = false
            Chainsaw.Result.Opposite[2].bIsApplicable = false
            local OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Opposite[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
            Chainsaw.AddResult( Mortising)
            OptionalParameters = {}
            OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'End', dLengthToMachine = Blade.Result.Opposite[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
            Chainsaw.AddResult( Mortising)
            OptionalParameters = {}
            OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Opposite[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
            Chainsaw.AddResult( Mortising)
            OptionalParameters = {}
            OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'End', dLengthToMachine = Blade.Result.Opposite[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
            Chainsaw.AddResult( Mortising)
         end
      else
         local OptionalParameters = { dMaxElev = Blade.Result.Opposite[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-         Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+         Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
         Chainsaw.AddResult( Mortising)
         if Chainsaw.Result.Opposite[1].dResidualDepth > 10 * GEO.EPS_SMALL then
            Chainsaw.Result.Opposite[1].bIsApplicable = false
            local OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Opposite[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
            Chainsaw.AddResult( Mortising)
            OptionalParameters = {}
            OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Opposite[2].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
            Chainsaw.AddResult( Mortising)
         end
      end
@@ -19,7 +19,7 @@ local BeamData = require( 'BeamData')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
-local SlotByChainSaw = require( 'SLOTBYCHAINSAW')
+local FaceByChainsaw = require( 'FACEBYCHAINSAW')

 -- Tabella per definizione modulo
 local STR0004 = {}
@@ -185,38 +185,38 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
   local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
   if Proc.Topology.sName == 'Groove-4-Blind' or Proc.Topology.sName == 'Pocket-5-Blind' then
      -- si lavora tutto il fondo
-      Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
+      Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
      Chainsaw.AddResult( Mortising)
      -- materiale residuo - se possibile si lavora dal lato
      if ( Chainsaw.Result.Bottom[#Chainsaw.Result.Bottom].dResidualDepth > 10 * GEO.EPS_SMALL or not Chainsaw.Result.Bottom[#Chainsaw.Result.Bottom].bIsApplicable) and #Proc.MainFaces.SideFaces == 1 then
         if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsStartOpen then
            OptionalParameters.bOppositeToolDirection = true
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
         elseif Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsEndOpen then
            OptionalParameters.bOppositeToolDirection = true
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
         end
         Chainsaw.AddResult( Mortising)
      end
   elseif Proc.Topology.sName == 'Groove-3-Through' then
      -- si lavora tutto il fondo
      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
-      Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
+      Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
      Chainsaw.AddResult( Mortising)
      -- materiale residuo - si lavorano i lati
      if ( Chainsaw.Result.Bottom[1].dResidualDepth > 10 * GEO.EPS_SMALL or not Chainsaw.Result.Bottom[#Chainsaw.Result.Bottom].bIsApplicable) then
         local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-         Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+         Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
         Chainsaw.AddResult( Mortising)
         -- ancora materiale residuo - si lavora da entrambi i lati
         if Chainsaw.Result.Side[1].dResidualDepth > 10 * GEO.EPS_SMALL then
            Chainsaw.Result.Side[1].bIsApplicable = false
            local OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
            Chainsaw.AddResult( Mortising)
            OptionalParameters = {}
            OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
+            Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
            Chainsaw.AddResult( Mortising)
            -- lavorando dai due lati non c'è materiale residuo - si può disabilitare la lavorazione del fondo
            if Chainsaw.Result.Side[2].dResidualDepth < 10 * GEO.EPS_SMALL then
@@ -226,16 +226,16 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
      end
   elseif Proc.Topology.sName == 'Tunnel-4-Through' then
      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-      Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+      Mortising = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
      Chainsaw.AddResult( Mortising)
      if Chainsaw.Result.Opposite[1].dResidualDepth > 10 * GEO.EPS_SMALL then
         Chainsaw.Result.Opposite[1].bIsApplicable = false
         local OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-         SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+         FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
         Chainsaw.AddResult( Mortising)
         OptionalParameters = {}
         OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
-         SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
+         FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
         Chainsaw.AddResult( Mortising)
      end
   end
@@ -10,7 +10,7 @@ local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
 local BladeToWaste = require( 'BLADETOWASTE')
-local SlotByBlade = require( 'SLOTBYBLADE')
+local FaceByBlade = require( 'FACEBYBLADE')

 -- Tabella per definizione modulo
 local STR0005 = {}
@@ -115,6 +115,7 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
   Strategy.Result.sInfo = ''
   Blade.Result = {}

+   -- estensione oltre la coda
   local dExtendAfterTail = Strategy.Parameters.dExtendAfterTail or max( Part.dDistanceToNextPiece - BeamData.CUT_EXTRA, 0)
   if MachiningLib.CanExtendAfterTail( Strategy.Parameters.sCanDamageNextPiece, Part) then
      dExtendAfterTail = 10000
@@ -124,13 +125,17 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
   local bLeaveWasteAttached = Strategy.Parameters.sCuttingStrategy == 'LEAVE_WASTE_ATTACHED'
   local bFeatureHindersClamping = FeatureLib.IsMachiningLong( max( dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail), Part, { dMaxSegmentLength = BeamData.LONGCUT_ENDLEN})
   local Cutting = {}
-   local MRRParametersBlade = {}
+   local dMRRBlade = 0

   if bFeatureHindersClamping or bLeaveWasteAttached then
-      -- TODO Lavorazione con codolo
-            -- attenzione perchè se l'inclinazione della faccia la fa finire oltre lo spigolo questo riduce il massimo calcolare (come calcolare????)
+      -- TODO valutare se estrapolare in funzione a sè stante in StrategyLibs
+      -- TODO verificare funzionamento con lama da sotto
+      -- attenzione perchè se l'inclinazione della faccia la fa finire oltre lo spigolo questo riduce il massimo (come calcolare????)
      -- il FindBlade dovrà restituire di utilizzare sempre la lama sopra se l'angolo lo permette, ma avendo un'altezza massima (da macchina) oltre cui il DownUp non sarà fattibile (evita collisioni tra asse e pezzo)
      
+      local Cutting1 = {}
+      local Cutting2 = {}
+
      -- si trovano i lati da lavorare
      local EdgesSorted = {}
      for i = 1, #Proc.Faces[1].Edges do
@@ -140,30 +145,6 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)

      local dDepthToMachine = EdgesSorted[1].dElevation / 2 - Strategy.Parameters.dStripWidth / 2

-      -- ricerca utensile
-      local ToolSearchParameters = {}
-      ToolSearchParameters.dElevation = dDepthToMachine
-      ToolSearchParameters.vtToolDirection = EdgesSorted[1].vtN
-      ToolSearchParameters.bAllowTopHead = true
-      ToolSearchParameters.bAllowBottomHead = true
-      ToolSearchParameters.bForceLongcutBlade = Strategy.Parameters.bForceLongcutBlade
-      local ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
-      Cutting.nToolIndex = ToolInfo.nToolIndex
-      Cutting.nType = MCH_OY.MILLING
-      if not TOOLS[Cutting.nToolIndex].sName then
-         Cutting.sMessage = 'Blade not found'
-         Cutting.bIsApplicable = false
-         EgtOutLog( Cutting.sMessage)
-         return Cutting, EdgesSorted[1].dElevation
-      end
-
-      -- parametri per il calcolo della velocità di asportazione
-      MRRParametersBlade = {
-                            dStep = min( TOOLS[Cutting.nToolIndex].dStep, EdgesSorted[1].dElevation),
-                            dSideStep = TOOLS[Cutting.nToolIndex].dThickness,
-                            dFeed = TOOLS[Cutting.nToolIndex].Feeds.dFeed
-                           }
-      
      -- eventuali punti di spezzatura
      local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
      local bIsSplitFeature = false
@@ -172,12 +153,12 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
      end

      -- primo lato
-      local OptionalParameters = { dDepthToMachine = dDepthToMachine, nToolIndex = Cutting.nToolIndex, bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail}
-      Cutting = SlotByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[1], OptionalParameters)
-      Blade.AddResult( Cutting)
+      local OptionalParameters = { dDepthToMachine = dDepthToMachine, bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail}
+      Cutting1 = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[1], OptionalParameters)
+      Blade.AddResult( Cutting1)
      -- secondo lato
-      Cutting = SlotByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[2], OptionalParameters)
-      Blade.AddResult( Cutting)
+      Cutting2 = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[2], OptionalParameters)
+      Blade.AddResult( Cutting2)

      -- lavorazioni raggruppate in unica lista
      Blade.Result.Sorted = {}
@@ -194,6 +175,22 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)

      table.sort( Blade.Result.Sorted, SortMachiningsBySegment)

+      -- parametri per il calcolo della velocità di asportazione
+      MRRParameters1 = {
+                        dStep = TOOLS[Cutting1.nToolIndex].dThickness,
+                        dSideStep = min( TOOLS[Cutting1.nToolIndex].dSideStep, dDepthToMachine),
+                        dFeed = TOOLS[Cutting1.nToolIndex].Feeds.dFeed}
+                        
+      MRRParameters2 = {
+                        dStep = TOOLS[Cutting2.nToolIndex].dThickness,
+                        dSideStep = min( TOOLS[Cutting2.nToolIndex].dSideStep, dDepthToMachine),
+                        dFeed = TOOLS[Cutting2.nToolIndex].Feeds.dFeed}
+      
+      local dMRRBlade1 = MachiningLib.GetToolMRR( MRRParameters1)
+      local dMRRBlade2 = MachiningLib.GetToolMRR( MRRParameters2)
+      dMRRBlade = ( dMRRBlade1 + dMRRBlade2) / 2
+
+      Cutting = Cutting2
      -- se la lavorazione con codolo fallisce o non è possibile si proseguirà a quella con cubetti
   end

@@ -217,6 +214,7 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
         Strategy.Result.sInfo = Strategy.Result.sInfo .. '\n' .. Blade.Result.Sorted[i].sMessage
      end
   end
+   -- TODO calcolo migliore area lavorata; se ho il codolo ha senso l'incompleta? se incompleta con codolo faccio i cubetti??
   if nIsApplicableCount > 0 then
      if Cutting.dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then
         Strategy.Result.sStatus = 'Completed'
@@ -230,7 +228,6 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
   end
   Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dFinalCompletionPercentage)
   Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
-   local dMRRBlade = MachiningLib.GetToolMRR( MRRParametersBlade)
   Strategy.Result.dMRR = dMRRBlade

   return bAreAllMachiningsAdded, Strategy.Result
@@ -1,7 +1,7 @@
 -- Strategia: FACEBYBLADE
 -- Descrizione 
-- Strategia di base per la lavorazione di una faccia con lama
-- Feature: tutte
+-- Strategia di base per la lavorazione delle slot o tasche con lama
+-- Feature: tipo lapjoint

 -- carico librerie
 local BeamLib = require( 'BeamLib')
@@ -11,9 +11,18 @@ local MachiningLib = require( 'MachiningLib')
 -- Tabella per definizione modulo
 local FACEBYBLADE = {}

-
 -------------------------------------------------------------------------------------------------------------
-local function CalculateLeadInOut( EdgeToMachine)
+
+local function CalculateLeadInOut( Machining, EdgeToMachine)
+   -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
+
+   -- si determina l'eventuale riduzione da applicare in caso di inizio o fine chiusi
+   local dAddLengthToReduce = sqrt( Machining.dDepthToMachine * TOOLS[Machining.nToolIndex].dDiameter - Machining.dDepthToMachine * Machining.dDepthToMachine)
+
+   if Machining.bInvert then
+      Machining.bIsStartClosed, Machining.bIsEndClosed = Machining.bIsEndClosed, Machining.bIsStartClosed
+   end
+
   local LeadIn = {}
   local LeadOut = {}
   LeadIn.dStartAddLength = 0
@@ -22,93 +31,271 @@ local function CalculateLeadInOut( EdgeToMachine)
   LeadOut.nType = MCH_MILL_LI.LINEAR
   LeadIn.dTangentDistance = 0
   LeadOut.dTangentDistance = 0
-   -- elevazione sempre in negativo
-   LeadIn.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
-   LeadOut.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
+   if AreSameVectorApprox( Machining.vtToolDirection, EdgeToMachine.vtN) then
+      LeadIn.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC - Machining.dRadialOffset
+      LeadOut.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC - Machining.dRadialOffset
+   else
+      LeadIn.dPerpDistance = BeamData.CUT_SIC - Machining.dRadialOffset
+      LeadOut.dPerpDistance = BeamData.CUT_SIC - Machining.dRadialOffset
+   end
   LeadIn.dElevation = 0
   LeadOut.dElevation = 0
   LeadIn.dCompLength = 0
   LeadOut.dCompLength = 0
-   LeadIn.dStartAddLength = BeamData.CUT_EXTRA
-   LeadOut.dEndAddLength = BeamData.CUT_EXTRA
+   if Machining.bIsStartClosed and Machining.bIsEndClosed then
+      LeadIn.dStartAddLength = -dAddLengthToReduce
+      LeadOut.dEndAddLength = -dAddLengthToReduce
+   elseif Machining.bIsStartClosed then
+      LeadIn.dStartAddLength = -dAddLengthToReduce
+      -- eventuale correzione per accorciamento maggiore di larghezza tasca
+      LeadOut.dEndAddLength = max( -LeadIn.dStartAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
+   elseif Machining.bIsEndClosed then
+      LeadOut.dEndAddLength = -dAddLengthToReduce
+      -- eventuale correzione per accorciamento maggiore di larghezza tasca
+      LeadIn.dStartAddLength = max( -LeadOut.dEndAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
+   else
+      LeadIn.dStartAddLength = BeamData.CUT_EXTRA
+      LeadOut.dEndAddLength = BeamData.CUT_EXTRA
+   end

   return LeadIn, LeadOut
 end

-------------------------------------------------------------------------------------------------------------
-- TODO da sistemare
+
 local function GetSCC( vtMachiningDirection)
+   -- TODO implementare SCC come per FacesBySaw
   local nSCC = MCH_SCC.NONE
-   
-   if vtMachiningDirection:getZ() < -0.9 then
-      nSCC = MCH_SCC.ADIR_ZM
-   elseif vtMachiningDirection:getZ() > 0.9 then
+   if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then
      nSCC = MCH_SCC.ADIR_ZP
-   elseif vtMachiningDirection:getY() < -0.707 then
-      nSCC = MCH_SCC.ADIR_YM
-   elseif vtMachiningDirection:getY() > 0.707 then
+   elseif AreOppositeVectorApprox( vtMachiningDirection, Z_AX()) then
+      nSCC = MCH_SCC.ADIR_ZM
+   elseif AreSameVectorApprox( vtMachiningDirection, Y_AX()) then
      nSCC = MCH_SCC.ADIR_YP
-   elseif vtMachiningDirection:getX() < -0.707 then
-      nSCC = MCH_SCC.ADIR_XM
-   elseif vtMachiningDirection:getX() > 0.707 then
+   elseif AreOppositeVectorApprox( vtMachiningDirection, Y_AX()) then
+      nSCC = MCH_SCC.ADIR_YM
+   elseif AreSameVectorApprox( vtMachiningDirection, X_AX()) then
      nSCC = MCH_SCC.ADIR_XP
+   elseif AreOppositeVectorApprox( vtMachiningDirection, X_AX()) then
+      nSCC = MCH_SCC.ADIR_XM
   end

   return nSCC
 end

-------------------------------------------------------------------------------------------------------------
-- TODO da sistemare
+
+-- TODO calcolo area lavorata per completamento
 function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalParameters)
   local Cutting = {}
+   Cutting.bIsApplicable = true
+   Cutting.dDepthToMachine = 0
+   Cutting.sMessage = ''
+   Cutting.idProc = Proc.id
+   Cutting.dResidualDepth = EdgeToMachine.dElevation
+   Cutting.dBladeMarkLength = 0
+   Cutting.sEdgeType = EdgeToMachine.sType
+   Cutting.nFeatureSegment = 1

-   local vtMachiningDirection = EdgeToMachine.vtN
-   local vtN = Proc.Faces[FaceToMachine.id+1].vtN
-   Cutting.sDepth = OptionalParameters.sDepth or 0
-   Cutting.dLongitudinalOffset = OptionalParameters.dLongitudinalOffset or 0
-   Cutting.dRadialOffset = OptionalParameters.dRadialOffset or 0
+   -- parametri opzionali
+   if not OptionalParameters then
+      OptionalParameters = {}
+   end
+   local bForceLongcutBlade = OptionalParameters.bForceLongcutBlade or false
+   local dExtendAfterTail = OptionalParameters.dExtendAfterTail or 10000
+   local dPocketHeight = OptionalParameters.dPocketHeight or 0
+   local dDepthToMachine = min( OptionalParameters.dDepthToMachine or EdgeToMachine.dElevation, EdgeToMachine.dElevation)
+   local bIsSplitFeature = OptionalParameters.bIsSplitFeature or false
+   local bOppositeToolDirection = OptionalParameters.bOppositeToolDirection or false
+   local sDepth = OptionalParameters.sDepth or 0
+   local nToolIndex = OptionalParameters.nToolIndex
+   local dLongitudinalOffset = OptionalParameters.dLongitudinalOffset or 0
+   if OptionalParameters.dPocketHeight then
+      dLongitudinalOffset = 0
+   end
+   local sUserNotes = OptionalParameters.sUserNotes or ''

-   Cutting.nType = MCH_MY.MILLING
-   Cutting.nToolIndex = OptionalParameters.nToolIndex
-   Cutting.Geometry = {{ Proc.id, FaceToMachine.id}}
-   Cutting.id = Proc.id
-   Cutting.vtToolDirection = vtMachiningDirection
-
-   -- TODO se l'utensile non arriva dai parametri opzionali va cercato!!
-
-   -- ===== calcolo LeadIn/out =====
-   if OptionalParameters.LeadIn and OptionalParameters.LeadOut then
-      Cutting.LeadIn, Cutting.LeadOut = OptionalParameters.LeadIn, OptionalParameters.LeadOut
+   -- lunghezze e punti caratteristici della lavorazione e del lato lavorato
+   Cutting.dLengthToMachine = EdgeToMachine.dLength
+   Cutting.dEdgeLength = EdgeToMachine.dLength
+   if bOppositeToolDirection then
+      Cutting.vtToolDirection = -EdgeToMachine.vtN
   else
-      Cutting.LeadIn, Cutting.LeadOut = CalculateLeadInOut( EdgeToMachine)
+      Cutting.vtToolDirection = EdgeToMachine.vtN
+   end
+   Cutting.vtEdgeDirection = EdgeToMachine.vtN ^ FaceToMachine.vtN
+   -- TODO conviene spostare questi calcoli nel FaceData?
+   Cutting.ptEdge1, _, Cutting.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -Cutting.vtToolDirection, GDB_ID.ROOT)
+   local b3BoxEdge = BBox3d( Cutting.ptEdge1, Cutting.ptEdge2)
+   Cutting.dLengthOnX = b3BoxEdge:getDimX()
+   --
+
+   -- ricerca utensile
+   if nToolIndex then
+      Cutting.nToolIndex = nToolIndex
+   else
+      local ToolSearchParameters = {}
+      ToolSearchParameters.dElevation = dDepthToMachine
+      ToolSearchParameters.vtToolDirection = Cutting.vtToolDirection
+      ToolSearchParameters.bAllowTopHead = true
+      -- TODO bisognerà implementare anche la lama da sotto
+      ToolSearchParameters.bAllowBottomHead = false
+      ToolSearchParameters.bForceLongcutBlade = bForceLongcutBlade
+      local ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
+      Cutting.nToolIndex = ToolInfo.nToolIndex
+   end
+   Cutting.nType = MCH_OY.MILLING
+   if not TOOLS[Cutting.nToolIndex].sName then
+      Cutting.sMessage = 'Blade not found'
+      Cutting.bIsApplicable = false
+      EgtOutLog( Cutting.sMessage)
+      return Cutting, EdgeToMachine.dElevation
   end

-   -- ===== scelta soluzione braccio C del motore =====
-   Cutting.nSCC = GetSCC( vtMachiningDirection)
-
-   -- ===== parametri da settare in UserNotes =====
-   Cutting.nFaceuse = OptionalParameters.nFaceuse
-   Cutting.sUserNotes = EgtSetValInNotes( Cutting.sUserNotes, 'VtFaceUse', vtMachiningDirection)
-   if OptionalParameters.sUserNotes then
-      Cutting.sUserNotes = Cutting.sUserNotes .. OptionalParameters.sUserNotes
+   -- verifica dimensioni tasca compatibili
+   -- se tasca meno spessa della lama la strategia non è applicabile
+   if OptionalParameters.dPocketHeight and ( TOOLS[Cutting.nToolIndex].dThickness > dPocketHeight + 10 * GEO.EPS_SMALL) then
+      Cutting.sMessage = 'Pocket too narrow for blade thickness'
+      Cutting.bIsApplicable = false
+      EgtOutLog( Cutting.sMessage)
+      return Cutting, EdgeToMachine.dElevation
   end
-
-   -- ===== scelta senso di lavorazione =====
-   local bIsSawCCW = TOOLS[Cutting.nToolIndex].bIsCCW
-   local bInvert
-   -- se la lama ruota in senso antiorario inverto la direzione di lavorazione, per avere rotazione lama opposta a avanzamento
-   if bInvert == nil then
-      bInvert = ( not bIsSawCCW)
-      if bIsSawCCW then
-         bInvert = (( Cutting.nFaceuse == MCH_MILL_FU.ORTHO_FRONT and vtN:getX() < 0) or ( Cutting.nFaceuse == MCH_MILL_FU.ORTHO_BACK and vtN:getX() > 0))
-      else
-         bInvert = (( Cutting.nFaceuse == MCH_MILL_FU.ORTHO_FRONT and vtN:getX() > 0) or ( Cutting.nFaceuse == MCH_MILL_FU.ORTHO_BACK and vtN:getX() < 0))
+   if Proc.MainFaces and #( Proc.MainFaces.SideFaces) > 1 then
+      -- se tasca più stretta della lama la strategia non è applicabile
+      if TOOLS[Cutting.nToolIndex].dDiameter > EdgeToMachine.dLength + 10 * GEO.EPS_SMALL then
+         Cutting.sMessage = 'Pocket too narrow for blade diameter'
+         Cutting.bIsApplicable = false
+         EgtOutLog( Cutting.sMessage)
+         return Cutting, EdgeToMachine.dElevation
+      end
+   end
+
+   -- parametri della lavorazione
+   -- profondità (parametro DEPTH)
+      Cutting.sDepth = sDepth
+   -- inizio e fine aperti o chiusi
+      Cutting.bIsStartClosed = not EdgeToMachine.bIsStartOpen
+      Cutting.bIsEndClosed = not EdgeToMachine.bIsEndOpen
+   -- lato di lavoro e inversioni
+   if TOOLS[Cutting.nToolIndex].bIsCCW then
+      Cutting.nWorkside = MCH_MILL_WS.RIGHT
+      Cutting.bInvert = true
+   else
+      Cutting.nWorkside = MCH_MILL_WS.LEFT
+      Cutting.bInvert = false
+   end
+   if bOppositeToolDirection then
+      Cutting.bInvert = not Cutting.bInvert
+   end
+   -- TODO gestire lama da sotto e lama downUp
+   if FaceToMachine.vtN:getZ() < - 10 * GEO.EPS_SMALL then
+      Cutting.bToolInvert = true
+      Cutting.bInvert = not Cutting.bInvert
+   else
+      Cutting.bToolInvert = false
+   end
+   -- profondità da lavorare e offset radiale
+   if TOOLS[Cutting.nToolIndex].dMaxDepth > dDepthToMachine - 10 * GEO.EPS_SMALL then
+      -- TODO la depth dovrebbe essere quella del machining
+      Cutting.dDepthToMachine = dDepthToMachine
+      Cutting.dResidualDepth = 0
+      if bOppositeToolDirection then
+         Cutting.dRadialOffset = -dDepthToMachine
+      else
+         Cutting.dRadialOffset = EdgeToMachine.dElevation - dDepthToMachine
+      end
+   else
+      Cutting.dDepthToMachine = TOOLS[Cutting.nToolIndex].dMaxDepth - 1
+      Cutting.dResidualDepth = EdgeToMachine.dElevation - Cutting.dDepthToMachine
+      if bOppositeToolDirection then
+         Cutting.dRadialOffset = -Cutting.dDepthToMachine
+      else
+         Cutting.dRadialOffset = EdgeToMachine.dElevation - Cutting.dDepthToMachine
+      end
+   end
+   -- completamento
+   Cutting.dCompletionPercentage = 100 - Cutting.dResidualDepth / Cutting.dDepthToMachine
+   -- step verticale e offset longitudinale
+   Cutting.Steps = MachiningLib.GetMachiningSteps( dPocketHeight, TOOLS[Cutting.nToolIndex].dThickness)
+   Cutting.Steps.nStepType = MCH_MILL_ST.ONEWAY
+   Cutting.dMaxElev = Cutting.Steps.dStep * Cutting.Steps.nCount - 10 * GEO.EPS_SMALL
+   if Cutting.bToolInvert and Cutting.Steps.nCount > 1 then
+      Cutting.dLongitudinalOffset = - dPocketHeight
+   else
+      Cutting.dLongitudinalOffset = dLongitudinalOffset
+   end
+   -- distanza di sicurezza
+   Cutting.dStartSafetyLength = 10
+   -- overlap
+   Cutting.dOverlap = 0
+   -- faceuse
+   if bOppositeToolDirection then
+      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( -Cutting.vtToolDirection)
+   else
+      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( Cutting.vtToolDirection)
+   end
+   -- SCC
+   Cutting.nSCC = GetSCC( Cutting.vtToolDirection)
+   -- asse bloccato
+   Cutting.sBlockedAxis = BeamLib.GetBlockedAxis( Cutting.nToolIndex, 'perpendicular', Part.b3Raw, FaceToMachine.vtN, EgtIf( FaceToMachine.vtN:getX() > 0, X_AX(), -X_AX()))
+   -- approccio e retrazione
+   Cutting.LeadIn, Cutting.LeadOut = CalculateLeadInOut( Cutting, EdgeToMachine)
+   -- eventuale step orizzontale
+   Cutting.HorizontalSteps = {}
+   if TOOLS[Cutting.nToolIndex].dSideStep then
+      Cutting.HorizontalSteps = MachiningLib.GetMachiningSteps( Cutting.dDepthToMachine, TOOLS[Cutting.nToolIndex].dSideStep)
+   else
+      Cutting.HorizontalSteps.nCount = 1
+      Cutting.HorizontalSteps.dStep = 0
+   end
+   -- lunghezza impronta lama
+   if Cutting.bIsStartClosed and Cutting.bIsEndClosed then
+      Cutting.dBladeMarkLength = abs( min( Cutting.LeadIn.dStartAddLength, Cutting.LeadOut.dEndAddLength))
+   elseif Cutting.bIsStartClosed then
+      Cutting.dBladeMarkLength = abs( Cutting.LeadIn.dStartAddLength)
+   elseif Cutting.bIsEndClosed then
+      Cutting.dBladeMarkLength = abs( Cutting.LeadOut.dEndAddLength)
+   end
+   -- geometria
+   Cutting.Geometry = {{Cutting.idProc, FaceToMachine.id}}
+   -- note utente
+   Cutting.sUserNotes = sUserNotes
+   -- nome operazione
+   Cutting.sOperationName = 'Cut_' .. ( EgtGetName( Cutting.idProc) or tostring( Cutting.idProc)) .. '_' .. tostring( FaceToMachine.id + 1)
+
+   -- se lavorazione aperta sulla coda, eventuali aggiustamenti
+   -- TODO valutare se fare funzione a parte
+   if Proc.AffectedFaces.bLeft and ( EdgeToMachine.sType == 'Bottom' or ( Cutting.vtToolDirection:getX() < 0.707)) then
+      local dLengthOnX = Cutting.dLengthOnX
+      -- se feature splittata non si considera la lunghezza della feature per il check spostamento dopo separazione
+      if bIsSplitFeature then
+         dLengthOnX = 0
+      end
+      local bStartLeft = MachiningLib.StartsLeftSide( Cutting)
+      local dAddLengthLeftSide = Cutting.LeadOut.dEndAddLength
+      local dAddLengthToReduce = sqrt( Cutting.dDepthToMachine * TOOLS[Cutting.nToolIndex].dDiameter - Cutting.dDepthToMachine * Cutting.dDepthToMachine)
+      if bStartLeft then
+         dAddLengthLeftSide = Cutting.LeadIn.dStartAddLength
+      end
+      if not AreSameOrOppositeVectorApprox( EdgeToMachine.vtN, Y_AX()) then
+         if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
+            Cutting.sStage = 'AfterTail'
+         else
+            Cutting.bIsApplicable = false
+         end
+      elseif dAddLengthLeftSide + dAddLengthToReduce > dExtendAfterTail then
+         if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
+            Cutting.sStage = 'AfterTail'
+         else
+            if bStartLeft then
+               Cutting.LeadIn.dStartAddLength = - dAddLengthToReduce + dExtendAfterTail
+            else
+               Cutting.LeadOut.dEndAddLength = - dAddLengthToReduce + dExtendAfterTail
+            end
+         end
      end
   end
-   Cutting.bInvert = bInvert
-   Cutting.nWorkside = EgtIf( bInvert, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)

   return Cutting
+   
 end

 -------------------------------------------------------------------------------------------------------------
@@ -1,4 +1,4 @@
-- Strategia: SLOTBYCHAINSAW
+-- Strategia: FACEBYCHAINSAW
 -- Descrizione 
 -- Strategia di base per la lavorazione delle slot o tasche con sega a catena
 -- Feature: tipo lapjoint
@@ -9,7 +9,7 @@ local BeamData = require( 'BeamData')
 local MachiningLib = require( 'MachiningLib')

 -- Tabella per definizione modulo
-local SLOTBYCHAINSAW = {}
+local FACEBYCHAINSAW = {}

 -------------------------------------------------------------------------------------------------------------

@@ -48,7 +48,7 @@ end


 -- TODO calcolo area lavorata per completamento
-function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalParameters)
+function FACEBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalParameters)
   local Mortising = {}
   Mortising.bIsApplicable = true
   Mortising.dDepthToMachine = 0
@@ -71,6 +71,7 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
   local dPocketHeight = OptionalParameters.dPocketHeight or 0
   local bIsSplitFeature = OptionalParameters.bIsSplitFeature or false
   local bOppositeToolDirection = OptionalParameters.bOppositeToolDirection or false
+   local sDepth = OptionalParameters.sDepth or 'TH'

   -- lunghezze e punti caratteristici della lavorazione e del lato lavorato
   Mortising.dLengthToMachine = dLengthToMachine
@@ -257,4 +258,4 @@ end

 -------------------------------------------------------------------------------------------------------------

- return SLOTBYCHAINSAW
+ return FACEBYCHAINSAW
@@ -1,289 +0,0 @@
-- Strategia: SLOTBYBLADE
-- Descrizione 
-- Strategia di base per la lavorazione delle slot o tasche con lama
-- Feature: tipo lapjoint
-
-- carico librerie
-local BeamLib = require( 'BeamLib')
-local BeamData = require( 'BeamData')
-local MachiningLib = require( 'MachiningLib')
-
-- Tabella per definizione modulo
-local SLOTBYBLADE = {}
-
-------------------------------------------------------------------------------------------------------------
-
-local function CalculateLeadInOut( Machining, EdgeToMachine)
-   -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
-
-   -- si determina l'eventuale riduzione da applicare in caso di inizio o fine chiusi
-   local dAddLengthToReduce = sqrt( Machining.dDepthToMachine * TOOLS[Machining.nToolIndex].dDiameter - Machining.dDepthToMachine * Machining.dDepthToMachine)
-
-   if Machining.bInvert then
-      Machining.bIsStartClosed, Machining.bIsEndClosed = Machining.bIsEndClosed, Machining.bIsStartClosed
-   end
-
-   local LeadIn = {}
-   local LeadOut = {}
-   LeadIn.dStartAddLength = 0
-   LeadOut.dEndAddLength = 0
-   LeadIn.nType = MCH_MILL_LI.LINEAR
-   LeadOut.nType = MCH_MILL_LI.LINEAR
-   LeadIn.dTangentDistance = 0
-   LeadOut.dTangentDistance = 0
-   if AreSameVectorApprox( Machining.vtToolDirection, EdgeToMachine.vtN) then
-      LeadIn.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC
-      LeadOut.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC
-   else
-      LeadIn.dPerpDistance = BeamData.CUT_SIC
-      LeadOut.dPerpDistance = BeamData.CUT_SIC
-   end
-   LeadIn.dElevation = 0
-   LeadOut.dElevation = 0
-   LeadIn.dCompLength = 0
-   LeadOut.dCompLength = 0
-   if Machining.bIsStartClosed and Machining.bIsEndClosed then
-      LeadIn.dStartAddLength = -dAddLengthToReduce
-      LeadOut.dEndAddLength = -dAddLengthToReduce
-   elseif Machining.bIsStartClosed then
-      LeadIn.dStartAddLength = -dAddLengthToReduce
-      -- eventuale correzione per accorciamento maggiore di larghezza tasca
-      LeadOut.dEndAddLength = max( -LeadIn.dStartAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
-   elseif Machining.bIsEndClosed then
-      LeadOut.dEndAddLength = -dAddLengthToReduce
-      -- eventuale correzione per accorciamento maggiore di larghezza tasca
-      LeadIn.dStartAddLength = max( -LeadOut.dEndAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
-   else
-      LeadIn.dStartAddLength = BeamData.CUT_EXTRA
-      LeadOut.dEndAddLength = BeamData.CUT_EXTRA
-   end
-
-   return LeadIn, LeadOut
-end
-
-
-local function GetSCC( vtMachiningDirection)
-   -- TODO implementare SCC come per FacesBySaw
-   local nSCC = MCH_SCC.NONE
-   if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then
-      nSCC = MCH_SCC.ADIR_ZP
-   elseif AreOppositeVectorApprox( vtMachiningDirection, Z_AX()) then
-      nSCC = MCH_SCC.ADIR_ZM
-   elseif AreSameVectorApprox( vtMachiningDirection, Y_AX()) then
-      nSCC = MCH_SCC.ADIR_YP
-   elseif AreOppositeVectorApprox( vtMachiningDirection, Y_AX()) then
-      nSCC = MCH_SCC.ADIR_YM
-   elseif AreSameVectorApprox( vtMachiningDirection, X_AX()) then
-      nSCC = MCH_SCC.ADIR_XP
-   elseif AreOppositeVectorApprox( vtMachiningDirection, X_AX()) then
-      nSCC = MCH_SCC.ADIR_XM
-   end
-
-   return nSCC
-end
-
-
-- TODO calcolo area lavorata per completamento
-function SLOTBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalParameters)
-   local Cutting = {}
-   Cutting.bIsApplicable = true
-   Cutting.dDepthToMachine = 0
-   Cutting.sMessage = ''
-   Cutting.idProc = Proc.id
-   Cutting.dResidualDepth = EdgeToMachine.dElevation
-   Cutting.dBladeMarkLength = 0
-   Cutting.sEdgeType = EdgeToMachine.sType
-   Cutting.nFeatureSegment = 1
-
-   -- parametri opzionali
-   if not OptionalParameters then
-      OptionalParameters = {}
-   end
-   local bForceLongcutBlade = OptionalParameters.bForceLongcutBlade or false
-   local dExtendAfterTail = OptionalParameters.dExtendAfterTail or 10000
-   local dPocketHeight = OptionalParameters.dPocketHeight or 0
-   local dDepthToMachine = min( OptionalParameters.dDepthToMachine or EdgeToMachine.dElevation, EdgeToMachine.dElevation)
-   local bIsSplitFeature = OptionalParameters.bIsSplitFeature or false
-   local bOppositeToolDirection = OptionalParameters.bOppositeToolDirection or false
-
-   -- lunghezze e punti caratteristici della lavorazione e del lato lavorato
-   Cutting.dLengthToMachine = EdgeToMachine.dLength
-   Cutting.dEdgeLength = EdgeToMachine.dLength
-   if bOppositeToolDirection then
-      Cutting.vtToolDirection = -EdgeToMachine.vtN
-   else
-      Cutting.vtToolDirection = EdgeToMachine.vtN
-   end
-   Cutting.vtEdgeDirection = EdgeToMachine.vtN ^ FaceToMachine.vtN
-   -- TODO conviene spostare questi calcoli nel FaceData?
-   Cutting.ptEdge1, _, Cutting.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -Cutting.vtToolDirection, GDB_ID.ROOT)
-   local b3BoxEdge = BBox3d( Cutting.ptEdge1, Cutting.ptEdge2)
-   Cutting.dLengthOnX = b3BoxEdge:getDimX()
-   --
-
-   -- ricerca utensile
-   local ToolSearchParameters = {}
-   ToolSearchParameters.dElevation = EdgeToMachine.dElevation
-   ToolSearchParameters.vtToolDirection = Cutting.vtToolDirection
-   ToolSearchParameters.bAllowTopHead = true
-   ToolSearchParameters.bAllowBottomHead = false
-   ToolSearchParameters.bForceLongcutBlade = bForceLongcutBlade
-   local ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
-   Cutting.nToolIndex = ToolInfo.nToolIndex
-   Cutting.nType = MCH_OY.MILLING
-   if not TOOLS[Cutting.nToolIndex].sName then
-      Cutting.sMessage = 'Blade not found'
-      Cutting.bIsApplicable = false
-      EgtOutLog( Cutting.sMessage)
-      return Cutting, EdgeToMachine.dElevation
-   end
-
-   -- verifica dimensioni tasca compatibili
-   -- se tasca meno spessa della lama la strategia non è applicabile
-   if OptionalParameters.dPocketHeight and ( TOOLS[Cutting.nToolIndex].dThickness > dPocketHeight + 10 * GEO.EPS_SMALL) then
-      Cutting.sMessage = 'Pocket too narrow for blade thickness'
-      Cutting.bIsApplicable = false
-      EgtOutLog( Cutting.sMessage)
-      return Cutting, EdgeToMachine.dElevation
-   end
-   if Proc.MainFaces and #( Proc.MainFaces.SideFaces) > 1 then
-      -- se tasca più stretta della lama la strategia non è applicabile
-      if TOOLS[Cutting.nToolIndex].dDiameter > EdgeToMachine.dLength + 10 * GEO.EPS_SMALL then
-         Cutting.sMessage = 'Pocket too narrow for blade diameter'
-         Cutting.bIsApplicable = false
-         EgtOutLog( Cutting.sMessage)
-         return Cutting, EdgeToMachine.dElevation
-      end
-   end
-
-   -- parametri della lavorazione
-   -- profondità (parametro DEPTH) non usata
-      Cutting.sDepth = 0
-   -- inizio e fine aperti o chiusi
-      Cutting.bIsStartClosed = not EdgeToMachine.bIsStartOpen
-      Cutting.bIsEndClosed = not EdgeToMachine.bIsEndOpen
-   -- lato di lavoro e inversioni
-   if TOOLS[Cutting.nToolIndex].bIsCCW then
-      Cutting.nWorkside = MCH_MILL_WS.RIGHT
-      Cutting.bInvert = true
-   else
-      Cutting.nWorkside = MCH_MILL_WS.LEFT
-      Cutting.bInvert = false
-   end
-   if bOppositeToolDirection then
-      Cutting.bInvert = not Cutting.bInvert
-   end
-   -- TODO gestire lama da sotto e lama downUp
-   if FaceToMachine.vtN:getZ() < - 10 * GEO.EPS_SMALL then
-      Cutting.bToolInvert = true
-      Cutting.bInvert = not Cutting.bInvert
-   else
-      Cutting.bToolInvert = false
-   end
-   -- profondità da lavorare e offset radiale
-   if TOOLS[Cutting.nToolIndex].dMaxDepth > dDepthToMachine - 10 * GEO.EPS_SMALL then
-      -- TODO la depth dovrebbe essere quella del machining
-      Cutting.dDepthToMachine = dDepthToMachine
-      Cutting.dResidualDepth = 0
-      if bOppositeToolDirection then
-         Cutting.dRadialOffset = -dDepthToMachine
-      else
-         Cutting.dRadialOffset = EdgeToMachine.dElevation - dDepthToMachine
-      end
-   else
-      Cutting.dDepthToMachine = TOOLS[Cutting.nToolIndex].dMaxDepth - 1
-      Cutting.dResidualDepth = EdgeToMachine.dElevation - Cutting.dDepthToMachine
-      if bOppositeToolDirection then
-         Cutting.dRadialOffset = -Cutting.dDepthToMachine
-      else
-         Cutting.dRadialOffset = EdgeToMachine.dElevation - Cutting.dDepthToMachine
-      end
-   end
-   -- completamento
-   Cutting.dCompletionPercentage = 100 - Cutting.dResidualDepth / Cutting.dDepthToMachine
-   -- step verticale e offset longitudinale
-   Cutting.Steps = MachiningLib.GetMachiningSteps( dPocketHeight, TOOLS[Cutting.nToolIndex].dThickness)
-   Cutting.Steps.nStepType = MCH_MILL_ST.ONEWAY
-   Cutting.dMaxElev = Cutting.Steps.dStep * Cutting.Steps.nCount - 10 * GEO.EPS_SMALL
-   if Cutting.bToolInvert and Cutting.Steps.nCount > 1 then
-      Cutting.dLongitudinalOffset = - dPocketHeight
-   else
-      Cutting.dLongitudinalOffset = 0
-   end
-   -- distanza di sicurezza
-   Cutting.dStartSafetyLength = 10
-   -- overlap
-   Cutting.dOverlap = 0
-   -- faceuse
-   if bOppositeToolDirection then
-      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( -Cutting.vtToolDirection)
-   else
-      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( Cutting.vtToolDirection)
-   end
-   -- SCC
-   Cutting.nSCC = GetSCC( Cutting.vtToolDirection)
-   -- asse bloccato
-   Cutting.sBlockedAxis = BeamLib.GetBlockedAxis( Cutting.nToolIndex, 'perpendicular', Part.b3Raw, FaceToMachine.vtN, EgtIf( FaceToMachine.vtN:getX() > 0, X_AX(), -X_AX()))
-   -- approccio e retrazione
-   Cutting.LeadIn, Cutting.LeadOut = CalculateLeadInOut( Cutting, EdgeToMachine)
-   -- eventuale step orizzontale
-   Cutting.HorizontalSteps = {}
-   if TOOLS[Cutting.nToolIndex].dSideStep then
-      Cutting.HorizontalSteps = MachiningLib.GetMachiningSteps( Cutting.dDepthToMachine, TOOLS[Cutting.nToolIndex].dSideStep)
-   else
-      Cutting.HorizontalSteps.nCount = 1
-      Cutting.HorizontalSteps.dStep = 0
-   end
-   -- lunghezza impronta lama
-   if Cutting.bIsStartClosed and Cutting.bIsEndClosed then
-      Cutting.dBladeMarkLength = abs( min( Cutting.LeadIn.dStartAddLength, Cutting.LeadOut.dEndAddLength))
-   elseif Cutting.bIsStartClosed then
-      Cutting.dBladeMarkLength = abs( Cutting.LeadIn.dStartAddLength)
-   elseif Cutting.bIsEndClosed then
-      Cutting.dBladeMarkLength = abs( Cutting.LeadOut.dEndAddLength)
-   end
-   -- geometria
-   Cutting.Geometry = {{Cutting.idProc, FaceToMachine.id}}
-   -- nome operazione
-   Cutting.sOperationName = 'Cut_' .. ( EgtGetName( Cutting.idProc) or tostring( Cutting.idProc)) .. '_' .. tostring( FaceToMachine.id + 1)
-
-   -- se lavorazione aperta sulla coda, eventuali aggiustamenti
-   -- TODO valutare se fare funzione a parte
-   if Proc.AffectedFaces.bLeft and ( EdgeToMachine.sType == 'Bottom' or ( Cutting.vtToolDirection:getX() < 0.707)) then
-      local dLengthOnX = Cutting.dLengthOnX
-      -- se feature splittata non si considera la lunghezza della feature per il check spostamento dopo separazione
-      if bIsSplitFeature then
-         dLengthOnX = 0
-      end
-      local bStartLeft = MachiningLib.StartsLeftSide( Cutting)
-      local dAddLengthLeftSide = Cutting.LeadOut.dEndAddLength
-      local dAddLengthToReduce = sqrt( Cutting.dDepthToMachine * TOOLS[Cutting.nToolIndex].dDiameter - Cutting.dDepthToMachine * Cutting.dDepthToMachine)
-      if bStartLeft then
-         dAddLengthLeftSide = Cutting.LeadIn.dStartAddLength
-      end
-      if not AreSameOrOppositeVectorApprox( EdgeToMachine.vtN, Y_AX()) then
-         if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
-            Cutting.sStage = 'AfterTail'
-         else
-            Cutting.bIsApplicable = false
-         end
-      elseif dAddLengthLeftSide + dAddLengthToReduce > dExtendAfterTail then
-         if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
-            Cutting.sStage = 'AfterTail'
-         else
-            if bStartLeft then
-               Cutting.LeadIn.dStartAddLength = - dAddLengthToReduce + dExtendAfterTail
-            else
-               Cutting.LeadOut.dEndAddLength = - dAddLengthToReduce + dExtendAfterTail
-            end
-         end
-      end
-   end
-
-   return Cutting
-   
-end
-
-------------------------------------------------------------------------------------------------------------
-
- return SLOTBYBLADE
@@ -227,16 +227,12 @@ function SPLITCUT.Execute( Proc, Part, Strategy)
      Machining.AuxiliaryData = {}
      local OptionalParameters = {}
      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
-      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_BACK
-      OptionalParameters.sDepth = 0
      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Split;', 'Cut;')

      Machining.AuxiliaryData.bIsSplitOrCut = true

      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Y_AX())
-      -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
      table.insert( Machinings, Machining)

@@ -248,15 +244,11 @@ function SPLITCUT.Execute( Proc, Part, Strategy)
      local OptionalParameters = {}
      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
      -- Taglio lato frontale
-      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_BACK
-      OptionalParameters.sDepth = 0
      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
-      OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
+      OptionalParameters.dDepthToMachine = Part.dWidth / 2 + BeamData.CUT_EXTRA_MIN
      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Presplit;', 'Precut;')

      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Y_AX())
-      -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
      table.insert( Machinings, Machining)

@@ -266,17 +258,13 @@ function SPLITCUT.Execute( Proc, Part, Strategy)
      Machining.AuxiliaryData = {}
      OptionalParameters = {}
      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
-      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_FRONT
-      OptionalParameters.sDepth = 0
      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
-      OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
+      OptionalParameters.dDepthToMachine = Part.dWidth / 2 + BeamData.CUT_EXTRA_MIN
      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Split;', 'Cut;')

      Machining.AuxiliaryData.bIsSplitOrCut = true

      EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, Y_AX())
-      -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
      table.insert( Machinings, Machining)
  ----------------------------------------------------------------------------------
@@ -286,38 +274,30 @@ function SPLITCUT.Execute( Proc, Part, Strategy)
      Machining.AuxiliaryData = {}
      local OptionalParameters = {}
      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
-      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
-      OptionalParameters.sDepth = 0
      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
-      OptionalParameters.dRadialOffset = -BeamData.CUT_EXTRA
+      OptionalParameters.dDepthToMachine = Part.dHeight + BeamData.CUT_EXTRA
      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Split;', 'Cut;')

      Machining.AuxiliaryData.bIsSplitOrCut = true

      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, Z_AX())
-      -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
      table.insert( Machinings, Machining)
  ----------------------------------------------------------------------------------
   elseif Strategy.SplitStrategy.sTypeMachining == 'BladeHorizontalDouble' then
+      -- Taglio lato frontale
      local Machining = {}
      Machining.Splitting = {}
      Machining.AuxiliaryData = {}
      local OptionalParameters = {}
      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
-      -- Taglio lato frontale
-      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
-      OptionalParameters.sDepth = 0
      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
-      local dExtraMaxMat = ( Strategy.SplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + Strategy.SplitStrategy[2].ToolInfo.dMaxMatBladeFromDown - Part.dHeight - BeamData.CUT_EXTRA) / 2
-      OptionalParameters.dRadialOffset = Part.dHeight - Strategy.SplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + dExtraMaxMat
+      local dExtraMaxMat = ( Strategy.SplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + Strategy.SplitStrategy[2].ToolInfo.dMaxMatBladeFromDown - Part.dHeight - BeamData.CUT_EXTRA_MIN) / 2
+      OptionalParameters.dDepthToMachine = Strategy.SplitStrategy[1].ToolInfo.dMaxMatBladeFromTop - dExtraMaxMat
      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Presplit;', 'Precut;')


      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, Z_AX())
-      -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
      table.insert( Machinings, Machining)

@@ -327,17 +307,13 @@ function SPLITCUT.Execute( Proc, Part, Strategy)
      Machining.AuxiliaryData = {}
      OptionalParameters = {}
      OptionalParameters.nToolIndex = Strategy.SplitStrategy[2].ToolInfo.nToolIndex
-      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_TOP
-      OptionalParameters.sDepth = 0
      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
-      OptionalParameters.dRadialOffset = Part.dHeight - Strategy.SplitStrategy[2].ToolInfo.dMaxMatBladeFromDown + dExtraMaxMat
+      OptionalParameters.dDepthToMachine = Strategy.SplitStrategy[2].ToolInfo.dMaxMatBladeFromDown - dExtraMaxMat
      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Split;', 'Cut;')

      Machining.AuxiliaryData.bIsSplitOrCut = true

      EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Z_AX())
-      -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
      table.insert( Machinings, Machining)
  ----------------------------------------------------------------------------------
Author	SHA1	Message	Date
andrea.villa	cf4b504733	Merge branch 'develop' into STR0001_TenonDT	2025-02-25 16:12:12 +01:00
luca.mazzoleni	084b6758a3	- SLOTBYBLADE rinominata FACEBYBLADE; vecchia FACEBYBLADE eliminata - SLOTBYCHAINSAW rinominata FACEBYCHAINSAW - in SPLITCUT modifiche alle chiamate di FACEBYBLADE per contemplare la nuova funzione - in STR0005 - codolo l'utensile non viene passato ma viene lasciato scegliere alla FACEBYBLADE	2025-01-28 10:54:16 +01:00
luca.mazzoleni	a8c2e2fe98	- in HEADCUT si chiama la SLOTBYBLADE e non più la FACEBYBLADE - in STR0003 e SLOTBYBLADE modifiche al calcolo LeadIn / LeadOut	2025-01-27 18:03:47 +01:00
luca.mazzoleni	e37486db1d	- in STR0003 correzione nel calcolo LeadIn/Out per i cloni	2025-01-27 15:57:12 +01:00
luca.mazzoleni	f9168e8380	Merge branch 'STR0005_Codolo' into develop	2025-01-27 11:55:36 +01:00
andrea.villa	d013e836a0	Merge remote-tracking branch 'origin/develop' into STR0001_TenonDT	2025-01-07 12:52:28 +01:00
andrea.villa	0c8d5516e1	Merge remote-tracking branch 'origin/develop' into STR0001_TenonDT	2025-01-07 12:27:41 +01:00
andrea.villa	37f85bccec	- Gestione cloni - Aggiunta attacco lineare	2025-01-07 09:16:06 +01:00
andrea.villa	512b907aae	- Aggiunto passaggio di contornatura su profilo - Prima bozza struttura lavorazioni - Piccole modifiche in altre librerie	2025-01-03 17:19:15 +01:00
andrea.villa	e9d71ab75e	- Aggiunta chiamata strategia in BasicCustomerStrategies - Calcolo parametri aggiuntivi - Prima bozza (non funzionante) della strategia	2025-01-02 16:41:36 +01:00
andrea.villa	ad112ca6c3	Merge remote-tracking branch 'origin/develop' into STR0001_TenonDT	2025-01-02 15:55:50 +01:00