databeamnew/Strategies/Standard/STR0003/STR0003.lua

-- Strategia: STR0003
-- Descrizione 
-- Lama + motosega per slot
-- Feature: tipo lapjoint

-- carico librerie
local BeamLib = require( 'BeamLib')
local BeamData = require( 'BeamData')
local MachiningLib = require( 'MachiningLib')
local FeatureData = require( 'FeatureData')
-- strategie di base
local SlotByChainSaw = require( 'SLOTBYCHAINSAW')

-- Tabella per definizione modulo
local STR0003 = {}
local Strategy = {}
local Blade = {}
local Chainsaw = {}
Blade.Result = {}
Chainsaw.Result = {}

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

local function IsTopologyOk( Proc)
   if Proc.Topology.bAllRightAngles and
      ( Proc.Topology.sName == 'Pocket-5-Blind' or
        Proc.Topology.sName == 'Groove-3-Through' or
        Proc.Topology.sName == 'Groove-4-Blind'  or
        Proc.Topology.sName == 'Tunnel-4-Through') then

      return true
   else
      return false
   end
end


local function GetCompletionPercentage( Proc, Result)
   local dNotMachinedArea = 0
   local dCompletionPercentage = 0

   if Proc.Topology.sFamily == 'Tunnel' then
      dNotMachinedArea = Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1].dLength * ( Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength - Result[1].dDepthMachined)
      if #Result == 2 then
         dNotMachinedArea = dNotMachinedArea - Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1].dLength * ( Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength - Result[2].dDepthMachined)
      end
   else
      if #Result == 1 then
         dNotMachinedArea = Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.dLength * ( Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength - Result[1].dDepthMachined)
      elseif #Result == 2 then
         dNotMachinedArea = ( Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.dLength - Result[2].dDepthMachined) * ( Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength - Result[1].dDepthMachined)
      elseif #Result == 3 then
         dNotMachinedArea = ( Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.dLength - Result[2].dDepthMachined - Result[3].dDepthMachined) * ( Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength - Result[1].dDepthMachined)
      end
   end
   dCompletionPercentage = 100 - dNotMachinedArea / Proc.MainFaces.LongFaces[1].dArea * 100

   return dCompletionPercentage
end


local function AddResult( Machining, Result)
   table.insert( Result, {})
   Result[#Result].bIsApplicable = Machining.bIsApplicable
   Result[#Result].sMessage = Machining.sMessage
   Result[#Result].dDepthMachined = Machining.dDepthToMachine
   Result[#Result].dResidualDepth = Machining.dResidualDepth
   Result[#Result].dBladeMarkLength = Machining.dBladeMarkLength
   Result[#Result].bMachiningAdded = Machining.bMachiningAdded

   return Result
end


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 bIsMortising = ( Machining.nType == MCH_OY.MORTISING)
   local dAddLengthToReduce = 0
   if bIsMortising then
      dAddLengthToReduce = TOOLS[Machining.nToolIndex].dDiameter / 2
   else
      dAddLengthToReduce = sqrt( Machining.dDepthToMachine * TOOLS[Machining.nToolIndex].dDiameter - Machining.dDepthToMachine * Machining.dDepthToMachine)
   end

   if Machining.bInvert then
      Machining.bIsStartClosed, Machining.bIsEndClosed = Machining.bIsEndClosed, Machining.bIsStartClosed
   end

   local LeadIn = {}
   local LeadOut = {}
   LeadIn.dStartAddLength = 0
   LeadOut.dEndAddLength = 0
   if not bIsMortising then
      LeadIn.nType = MCH_MILL_LI.LINEAR
      LeadOut.nType = MCH_MILL_LI.LINEAR
      LeadIn.dTangentDistance = 0
      LeadOut.dTangentDistance = 0
      if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL 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
   else
      if Machining.bIsStartClosed then
         LeadIn.dStartAddLength = -dAddLengthToReduce
      else
         LeadIn.dStartAddLength = BeamData.CUT_EXTRA
      end
      if Machining.bIsEndClosed then
         LeadOut.dEndAddLength = -dAddLengthToReduce
      else
         LeadOut.dEndAddLength = BeamData.CUT_EXTRA
      end
   end

   return LeadIn, LeadOut
end


function Blade.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


function Blade.CalculateMachiningParameters( Proc, Part, FaceToMachine, EdgeToMachine)
   local Cutting = {}
   Cutting.bIsApplicable = true
   Cutting.dDepthToMachine = 0
   Cutting.sMessage = ''
   Cutting.idProc = Proc.id
   Cutting.dResidualDepth = 0
   Cutting.dBladeMarkLength = 0

   local dPocketHeight = 0
   if Proc.Topology.sFamily == 'Tunnel' then
      dPocketHeight = Proc.MainFaces.SideFaces[1].MainEdges.OppositeEdges[1].dLength
   else
      if FaceToMachine.sType == 'Long' then
         dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
      elseif FaceToMachine.sType == 'Side' then
         dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.LongEdges[1].dLength
      end
   end

   -- ricerca utensile
   local ToolSearchParameters = {}
   ToolSearchParameters.dElevation = abs( EdgeToMachine.dElevation)
   ToolSearchParameters.vtToolDirection = EdgeToMachine.vtToolDirection
   ToolSearchParameters.bAllowTopHead = true
   ToolSearchParameters.bAllowBottomHead = false
   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 = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - saw 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 TOOLS[Cutting.nToolIndex].dThickness > dPocketHeight + 10 * GEO.EPS_SMALL then
      Cutting.sMessage = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - pocket too narrow for saw blade thickness'
      Cutting.bIsApplicable = false
      EgtOutLog( Cutting.sMessage)
      return Cutting, EdgeToMachine.dElevation
   end
   if #( 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 = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - pocket too narrow for saw 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 EdgeToMachine.dElevation < -10 * GEO.EPS_SMALL 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 > abs( EdgeToMachine.dElevation) - 10 * GEO.EPS_SMALL then
      -- TODO la depth dovrebbe essere quella del machining
      Cutting.dDepthToMachine = abs( EdgeToMachine.dElevation)
      if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
         Cutting.dRadialOffset = 0
      else
         Cutting.dRadialOffset = EdgeToMachine.dElevation
      end
   else
      Cutting.dDepthToMachine = TOOLS[Cutting.nToolIndex].dMaxDepth - 1
      Cutting.dResidualDepth = abs( EdgeToMachine.dElevation) - Cutting.dDepthToMachine
      if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
         Cutting.dRadialOffset = EdgeToMachine.dElevation - Cutting.dDepthToMachine
      else
         Cutting.dRadialOffset = -Cutting.dDepthToMachine
      end
      if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL and not Strategy.Parameters.bFinishWithChainSaw then
         Cutting.sMessage = 'Feature '.. Proc.idFeature .. ' : sawblade elevation (' .. EgtNumToString( EdgeToMachine.dElevation, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Cutting.dDepthToMachine, 1) .. ')'
         EgtOutLog( Cutting.sMessage)
      end
   end
   -- 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 EdgeToMachine.dElevation > - 10 * GEO.EPS_SMALL then
      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( EdgeToMachine.vtToolDirection)
   else
      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( -EdgeToMachine.vtToolDirection)
   end
   -- SCC
   Cutting.nSCC = Blade.GetSCC( EdgeToMachine.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 = {{Proc.id, FaceToMachine.id}}
   -- nome operazione
   Cutting.sOperationName = 'Cut_' .. ( EgtGetName( Cutting.idProc) or tostring( Cutting.idProc)) .. '_' .. tostring( FaceToMachine.id + 1)

   -- eventuale avviso di danneggiamento pezzo successivo
   -- TODO da sostituire con check se si riesce a separare e il grezzo dietro è lungo a sufficienza
--   local dOffsideLength = max( Cutting.LeadIn.dStartAddLength, Cutting.LeadOut.dEndAddLength) + TOOLS[Cutting.nToolIndex].dDiameter / 2 + 10 * GEO.EPS_SMALL
--   if ( not Proc.bTail or Proc.bAdvTail) and Proc.AffectedFaces.bLeft and ( Proc.dDistanceToNextPart < dOffsideLength) then
--      local sDamageNextPieceMessage = 'Feature '.. Proc.idFeature .. ' : sawblade can damage next piece.'
--      if #Cutting.sMessage > 0 then
--         Cutting.sMessage = Cutting.sMessage .. '\n' .. sDamageNextPieceMessage
--      else
--         Cutting.sMessage = sDamageNextPieceMessage
--      end
--      EgtOutLog( sDamageNextPieceMessage)
--   end

   return Cutting
end


function Blade.AddResult( Cutting)
   AddResult( Cutting, Blade.Result)
end


function Blade.AddMachiningAllSteps( Proc, Cutting, AuxiliaryData)
   local bMachiningAdded = false
   if not AuxiliaryData then
      AuxiliaryData = {}
   end
   AuxiliaryData.Clones = {}

   local dOriginalRadialOffset = Cutting.dRadialOffset
   local dOriginalLeadInPerpDistance = Cutting.LeadIn.dPerpDistance
   local dOriginalLeadOutPerpDistance = Cutting.LeadOut.dPerpDistance
   for i = Cutting.HorizontalSteps.nCount, 1, -1 do
      AuxiliaryData.Clones[i] = {}
      AuxiliaryData.Clones[i].LeadIn = {}
      AuxiliaryData.Clones[i].LeadOut = {}
      AuxiliaryData.Clones[i].dRadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.dStep * ( i - 1)
      -- 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
   end
   bMachiningAdded = MachiningLib.AddNewMachining( Proc, Cutting, AuxiliaryData)

   return bMachiningAdded
end


function Chainsaw.AddResult( Mortising)
   table.insert( Chainsaw.Result, {})
   if not Chainsaw.Result.Bottom then
      Chainsaw.Result.Bottom = {}
   end
   if not Chainsaw.Result.Side then
      Chainsaw.Result.Side = {}
   end
   if not Chainsaw.Result.Opposite then
      Chainsaw.Result.Opposite = {}
   end
   if Mortising.sEdgeType == 'Bottom' then
      table.insert( Chainsaw.Result.Bottom, Mortising)
   elseif Mortising.sEdgeType == 'Side' then
      table.insert( Chainsaw.Result.Side, Mortising)
   elseif Mortising.sEdgeType == 'Opposite' then
      table.insert( Chainsaw.Result.Opposite, Mortising)
   else
      error('AddResult : unknown edge type')
   end
end


function Chainsaw.AddMachiningAllSteps( Proc, Mortising, AuxiliaryData)
   local bMachiningAdded = false
   if not AuxiliaryData then
      AuxiliaryData = {}
   end
   AuxiliaryData.Clones = {}

   local dOriginalRadialOffsetMortising = Mortising.dRadialOffset
   for i = Mortising.VerticalSteps.nCount, 1, -1 do
      AuxiliaryData.Clones[i] = {}
      AuxiliaryData.Clones[i].dRadialOffset = dOriginalRadialOffsetMortising + Mortising.VerticalSteps.dStep * ( i - 1)
   end
   bMachiningAdded = MachiningLib.AddNewMachining( Proc, Mortising, AuxiliaryData)

   return bMachiningAdded
end


function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
   -- TODO da implementare gestione feature lunghe e spezzatura
   -- carico parametri da default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
   local StrategyLib = {}
   StrategyLib.Config = require( 'STR0003\\STR0003Config')
   Strategy.sName = StrategyLib.Config.sStrategyId
   CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
   Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
   Strategy.Result = {}
   Strategy.Result.sInfo = ''
   Blade.Result = {}
   Chainsaw.Result = {}

   if not IsTopologyOk( Proc) then
      local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not implemented'
      EgtOutLog( sErr)
      Strategy.Result.sStatus = 'Not-Applicable'
      Strategy.Result.sInfo = 'Topology'
      return false, Strategy.Result
   end

   -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto)
   -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto
   if Proc.AffectedFaces.bBottom and ( Proc.nFct > 3 or not Proc.AffectedFaces.bTop) then
      local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - pocket on bottom face'
      EgtOutLog( sErr)
      Strategy.Result.sStatus = 'Not-Applicable'
      Strategy.Result.sInfo = 'Direction'
      return false, Strategy.Result
   end

   -- lama
   -- lavorazione di lama - fondo della tasca o fino a massimo materiale se tunnel
   local Cutting = {}
   if Proc.Topology.sFamily == 'Tunnel' then
      Cutting = Blade.CalculateMachiningParameters( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1])
   else
      Cutting = Blade.CalculateMachiningParameters( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge)
   end
   if bAddMachining and Cutting.bIsApplicable then
      Cutting.bIsApplyOk, Cutting.sApplyMessage = Blade.AddMachiningAllSteps( Proc, Cutting)
   end
   Blade.AddResult( Cutting)
   -- lato opposto del tunnel
   if Proc.Topology.sFamily == 'Tunnel' then
      Cutting = Blade.CalculateMachiningParameters( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2])
      if bAddMachining and Cutting.bIsApplicable then
         Cutting.bIsApplyOk, Cutting.sApplyMessage = Blade.AddMachiningAllSteps( Proc, Cutting)
      end
      Blade.AddResult( Cutting)
   else
      -- se la lama non è arrivata sul fondo e c'è almeno un lato aperto va lavorato
      if Blade.Result[1].dResidualDepth > 10 * GEO.EPS_SMALL then
         -- eventuale lavorazione di lama - lato della tasca da cui inizia la lavorazione
         if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsStartOpen then
            Cutting = Blade.CalculateMachiningParameters( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1])
            if bAddMachining and Cutting.bIsApplicable then
               Cutting.bIsApplyOk, Cutting.sApplyMessage = Blade.AddMachiningAllSteps( Proc, Cutting)
            end
            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
            Cutting = Blade.CalculateMachiningParameters( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2])
            if bAddMachining and Cutting.bIsApplicable then
               Cutting.bIsApplyOk, Cutting.sApplyMessage = Blade.AddMachiningAllSteps( Proc, Cutting)
            end
            Blade.AddResult( Cutting)
         end
      -- la lama è arrivata sul fondo e tasca passante, non servono ulteriori lavorazioni
      elseif #( Proc.MainFaces.SideFaces) == 0 then
         Strategy.Parameters.bFinishWithChainSaw = false
         Strategy.Parameters.bNotCompleteWithBladeRadius = false
      end
   end

   -- TODO da migliorare / refactoring in funzione
   local nCanApplyCount = 0
   local nApplyOkCount = 0
   local bAreAllApplyOk
   local dCompletionPercentage = 0
   for i = 1, #Blade.Result do
      Strategy.Result.sInfo = Strategy.Result.sInfo .. '\n' .. Blade.Result[i].sMessage .. '\n' .. ( Blade.Result[i].sApplyMessage or '')
      if Blade.Result[i].bIsApplicable then
         nCanApplyCount = nCanApplyCount + 1
      end
      if Blade.Result[i].bIsApplyOk then
         nApplyOkCount = nApplyOkCount + 1
      end
   end
   if bAddMachining then
      bAreAllApplyOk = ( nApplyOkCount == #Blade.Result)
   end
   if nCanApplyCount == 0 then
      Strategy.Result.sStatus = 'Not-Applicable'
      Strategy.Parameters.bFinishWithChainSaw = false
   else
      dCompletionPercentage = GetCompletionPercentage( Proc, Blade.Result)
      if not Strategy.Parameters.bNotCompleteWithBladeRadius and ( ( nCanApplyCount == #Blade.Result) and dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL) then
         Strategy.Result.sStatus = 'Completed'
      else
         Strategy.Result.sStatus = 'Not-Completed'
      end
   end
   if not Strategy.Parameters.bFinishWithChainSaw then
      Strategy.Result.nCompletionIndex = FeatureData.GetFeatureCompletionIndex( dCompletionPercentage)
      Strategy.Result.nQuality = FeatureData.GetFeatureQuality( 'Blade')
      local MRRParameters = { dStep = TOOLS[Cutting.nToolIndex].dThickness,
                              dSideStep = min( TOOLS[Cutting.nToolIndex].dSideStep, Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength),
                              dFeed = TOOLS[Cutting.nToolIndex].Feeds.dFeed}
      Strategy.Result.dMRR = MachiningLib.GetToolMRR( MRRParameters)

      return bAreAllApplyOk, Strategy.Result
   end

   -- sega a catena
   local Mortising = {}
   if Proc.Topology.sName == 'Groove-4-Blind' or Proc.Topology.sName == 'Pocket-5-Blind' then
      -- si lavora solamente l'impronta lama sui lati chiusi
      if ( Blade.Result[1].dResidualDepth < 10 * GEO.EPS_SMALL) and
         ( Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.dLength > 3 * Blade.Result[1].dBladeMarkLength - 10 * GEO.EPS_SMALL) then

         if not Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsStartOpen then
            local OptionalParameters = { sSideToMachine = 'Start', dLengthToMachine = Blade.Result[1].dBladeMarkLength, dMaxElev = 0}
            Mortising = SlotByChainSaw.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[1].dBladeMarkLength, dMaxElev = 0}
            Mortising = SlotByChainSaw.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[1].dResidualDepth + BeamData.CUT_EXTRA}
         Mortising = SlotByChainSaw.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
      if Chainsaw.Result.Bottom[#Chainsaw.Result.Bottom].dResidualDepth > 10 * GEO.EPS_SMALL and #Proc.MainFaces.SideFaces == 1 then
         -- si lavora solamente l'impronta lama sul fondo
         if ( #Blade.Result > 1) and Blade.Result[2].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[2].dBladeMarkLength - 10 * GEO.EPS_SMALL) then
               local OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result[2].dBladeMarkLength, dMaxElev = 0}
               Mortising = SlotByChainSaw.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[2].dBladeMarkLength - 10 * GEO.EPS_SMALL) then
               local OptionalParameters = { sSideToMachine = 'Start', dLengthToMachine = Blade.Result[2].dBladeMarkLength, dMaxElev = 0}
               Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
            end
         -- si lavora tutto il lato
         else
            local dBladeResidualDepth
            if #Blade.Result > 1 then
               dBladeResidualDepth = Blade.Result[2].dResidualDepth
            else
               dBladeResidualDepth = Blade.Result[1].dResidualDepth
            end
            if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsStartOpen then
               local OptionalParameters = { dMaxElev = dBladeResidualDepth + BeamData.CUT_EXTRA}
               Mortising = SlotByChainSaw.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}
               Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
            end
         end
         Chainsaw.AddResult( Mortising)
      end
   elseif Proc.Topology.sName == 'Groove-3-Through' then
      if Blade.Result[1].dResidualDepth > 10 * GEO.EPS_SMALL then
         -- si lavora tutto il fondo
         local OptionalParameters = { dMaxElev = Blade.Result[1].dResidualDepth + BeamData.CUT_EXTRA}
         Mortising = SlotByChainSaw.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
            -- si lavora solamente l'impronta lama sul fondo
            if ( Blade.Result[2].dResidualDepth < 10 * GEO.EPS_SMALL and Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength > 3 * Blade.Result[2].dBladeMarkLength - 10 * GEO.EPS_SMALL) and
               ( Blade.Result[3].dResidualDepth < 10 * GEO.EPS_SMALL and Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2].dLength > 3 * Blade.Result[3].dBladeMarkLength - 10 * GEO.EPS_SMALL) then
               
               local OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result[2].dBladeMarkLength, dMaxElev = 0}
               Mortising = SlotByChainSaw.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[2].dBladeMarkLength, dMaxElev = 0}
                  Mortising = SlotByChainSaw.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[2].dBladeMarkLength, dMaxElev = 0}
                  Mortising = SlotByChainSaw.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
                     Chainsaw.Result.Bottom[1].bIsApplicable = false
                  end
               end
            -- si lavora tutto il lato
            else
               local OptionalParameters = { dMaxElev = Blade.Result[2].dResidualDepth + BeamData.CUT_EXTRA}
               Mortising = SlotByChainSaw.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 = { dMaxElev = Blade.Result[2].dResidualDepth + BeamData.CUT_EXTRA}
                  Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
                  Chainsaw.AddResult( Mortising)
                  OptionalParameters = {}
                  OptionalParameters = { dMaxElev = Blade.Result[3].dResidualDepth + BeamData.CUT_EXTRA}
                  Mortising = SlotByChainSaw.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
                     Chainsaw.Result.Bottom[1].bIsApplicable = false
                  end
               end
            end
         end
      end
   elseif Proc.Topology.sName == 'Tunnel-4-Through' then
      -- si lavora solamente l'impronta lama sul lato opposto
      if ( Blade.Result[1].dResidualDepth < 10 * GEO.EPS_SMALL and Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1].dLength > 3 * Blade.Result[1].dBladeMarkLength - 10 * GEO.EPS_SMALL) and
         ( Blade.Result[2].dResidualDepth < 10 * GEO.EPS_SMALL and Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2].dLength > 3 * Blade.Result[2].dBladeMarkLength - 10 * GEO.EPS_SMALL) then
         
         local OptionalParameters = { sSideToMachine = 'Start', dLengthToMachine = Blade.Result[1].dBladeMarkLength, dMaxElev = 0}
         Mortising = SlotByChainSaw.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[2].dBladeMarkLength, dMaxElev = 0}
         Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
         Chainsaw.AddResult( Mortising)
         if Chainsaw.Result.Opposite[1].dResidualDepth > GEO.EPS_SMALL or Chainsaw.Result.Opposite[2].dResidualDepth > 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[1].dBladeMarkLength, dMaxElev = 0}
            Mortising = SlotByChainSaw.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[1].dBladeMarkLength, dMaxElev = 0}
            Mortising = SlotByChainSaw.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[2].dBladeMarkLength, dMaxElev = 0}
            Mortising = SlotByChainSaw.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[2].dBladeMarkLength, dMaxElev = 0}
            Mortising = SlotByChainSaw.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[1].dResidualDepth + BeamData.CUT_EXTRA}
         Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
         Chainsaw.AddResult( Mortising)
         if Chainsaw.Result.Opposite[1].dResidualDepth > GEO.EPS_SMALL then
            Chainsaw.Result.Opposite[1].bIsApplicable = false
            local OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result[1].dResidualDepth + BeamData.CUT_EXTRA}
            SlotByChainSaw.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[2].dResidualDepth + BeamData.CUT_EXTRA}
            SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
            Chainsaw.AddResult( Mortising)
         end
      end
   end

   local nIsApplicableCount = 0
   local dFinalCompletionPercentage = 100
   local bAreAllMachiningsAdded = true
   for i = 1, #Chainsaw.Result.Bottom do
      if Chainsaw.Result.Bottom[i].bIsApplicable then
         nIsApplicableCount = nIsApplicableCount + 1
         if bAddMachining then
            local bIsMachiningAdded = Chainsaw.AddMachiningAllSteps( Proc, Chainsaw.Result.Bottom[i])
            if not bIsMachiningAdded then
               bAreAllMachiningsAdded = false
            end
         end
         Strategy.Result.sInfo = Strategy.Result.sInfo .. '\n' .. Chainsaw.Result.Bottom[i].sMessage
      end
   end
   for i = 1, #Chainsaw.Result.Side do
      if Chainsaw.Result.Side[i].bIsApplicable then
         nIsApplicableCount = nIsApplicableCount + 1
         if bAddMachining then
            local bIsMachiningAdded = Chainsaw.AddMachiningAllSteps( Proc, Chainsaw.Result.Side[i])
            if not bIsMachiningAdded then
               bAreAllMachiningsAdded = false
            end
         end
         Strategy.Result.sInfo = Strategy.Result.sInfo .. '\n' .. Chainsaw.Result.Side[i].sMessage
      end
   end
   for i = 1, #Chainsaw.Result.Opposite do
      if Chainsaw.Result.Opposite[i].bIsApplicable then
         nIsApplicableCount = nIsApplicableCount + 1
         if bAddMachining then
            local bIsMachiningAdded = Chainsaw.AddMachiningAllSteps( Proc, Chainsaw.Result.Opposite[i])
            if not bIsMachiningAdded then
               bAreAllMachiningsAdded = false
            end
         end
         Strategy.Result.sInfo = Strategy.Result.sInfo .. '\n' .. Chainsaw.Result.Opposite[i].sMessage
      end
   end
   if nIsApplicableCount > 0 then
      if Mortising.dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then
         Strategy.Result.sStatus = 'Completed'
      else
         Strategy.Result.sStatus = 'Not-Completed'
         -- TODO al momento si assume che la percentuale di completamento dell'ultima lavorazione sia quella rilevante
         dFinalCompletionPercentage = Mortising.dCompletionPercentage
      end
   else
      Strategy.Result.sStatus = 'Not-Applicable'
   end
   Strategy.Result.nCompletionIndex = FeatureData.GetFeatureCompletionIndex( dFinalCompletionPercentage)
   Strategy.Result.nQuality = FeatureData.GetFeatureQuality( 'Chainsaw')
   local MRRParametersBlade = { dStep = TOOLS[Cutting.nToolIndex].dThickness,
                           dSideStep = min( TOOLS[Cutting.nToolIndex].dSideStep, Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength),
                           dFeed = TOOLS[Cutting.nToolIndex].Feeds.dFeed}
   local MRRParametersChainsaw = { dStep = min( TOOLS[Mortising.nToolIndex].dStep, Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength),
                           dSideStep = TOOLS[Mortising.nToolIndex].dThickness,
                           dFeed = TOOLS[Mortising.nToolIndex].Feeds.dFeed}
   local dMRRBlade = MachiningLib.GetToolMRR( MRRParametersBlade)
   local dMRRChainsaw = MachiningLib.GetToolMRR( MRRParametersChainsaw)
   Strategy.Result.dMRR = dMRRBlade * dMRRChainsaw

   return bAreAllMachiningsAdded, Strategy.Result
end

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

 return STR0003